![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ss.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386|
Return to ss.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / io.386 |
1.1 ! root 1: /* ! 2: * io.386/ss.c ! 3: * ! 4: * Device driver for Seagate ST01/ST02 scsi host adapters. ! 5: * ! 6: * Revised: Wed May 26 16:57:51 1993 CDT ! 7: */ ! 8: ! 9: /* ! 10: * To do: ! 11: * nonzero LUN's ! 12: * start new command during disconnect ! 13: * rewrite as single state machine, instead of 7 of them ! 14: * separate SCSI layer from host-dependent stuff ! 15: */ ! 16: ! 17: /* ! 18: * Debug levels. ! 19: * DEBUG = 0 No debug output. ! 20: * DEBUG = 1 Debug output on error only. ! 21: * DEBUG = 2 Debug output on error and at other selected places. ! 22: * DEBUG = 3 Print state machine trace. ! 23: * DEBUG = 4 Print info xfer phases and msg_in values. ! 24: */ ! 25: #if (DEBUG >= 1) ! 26: static int s_id; ! 27: #define PR1(str) printf("%s%d ", str, s_id) ! 28: #else ! 29: #define PR1(str) ! 30: #endif ! 31: #if (DEBUG >= 2) ! 32: #define PR2(str) printf(str) ! 33: #else ! 34: #define PR2(str) ! 35: #endif ! 36: #if (DEBUG >= 3) ! 37: #define PR3(str) printf("%s%d ", str, s_id) ! 38: #else ! 39: #define PR3(str) ! 40: #endif ! 41: #if (DEBUG >= 4) ! 42: #define PR4(str) printf("%s%d ", str, s_id) ! 43: #else ! 44: #define PR4(str) ! 45: #endif ! 46: ! 47: /* ! 48: * Includes. ! 49: */ ! 50: #include <sys/coherent.h> ! 51: ! 52: #include <kernel/typed.h> ! 53: #if _I386 ! 54: #include <kernel/fakeff.h> ! 55: #include <sys/dmac.h> ! 56: #endif ! 57: #include <sys/io.h> ! 58: #include <sys/sched.h> ! 59: #include <sys/uproc.h> ! 60: #include <sys/proc.h> ! 61: #include <sys/con.h> ! 62: #include <sys/stat.h> ! 63: #include <sys/devices.h> /* SCSI_MAJOR */ ! 64: #include <sys/errno.h> ! 65: #include <sys/fdisk.h> ! 66: #include <sys/hdioctl.h> ! 67: #include <sys/scsiwork.h> ! 68: ! 69: /* ! 70: * Definitions. ! 71: * Constants. ! 72: * Macros with argument lists. ! 73: * Typedefs. ! 74: * Enums. ! 75: */ ! 76: #define SS_RAM 0x1800 /* Offset of parameter RAM */ ! 77: ! 78: /* Future Domain */ ! 79: #define FD_CSR 0x1C00 /* Offset of control/status register */ ! 80: #define FD_DAT 0x1E00 /* Offset of data port */ ! 81: ! 82: /* Seagate */ ! 83: #define SS_CSR 0x1A00 /* Offset of control/status register */ ! 84: #define SS_DAT 0x1C00 /* Offset of data port */ ! 85: ! 86: #define SS_RAM_LEN 128 /* ST0x has 128 bytes of RAM */ ! 87: #define SS_DAT_LEN 0x400 /* Byte range mapped to data port */ ! 88: #define SS_SEL_LEN 0x2000 /* Total size of memory-mapped area */ ! 89: ! 90: #define WC_ENABLE_SCSI 0x80 /* Write Control (WC) register bits */ ! 91: #define WC_ENABLE_IRPT 0x40 ! 92: #define WC_ENABLE_PRTY 0x20 ! 93: #define WC_ARBITRATE 0x10 ! 94: #define WC_ATTENTION 0x08 ! 95: #define WC_BUSY 0x04 ! 96: #define WC_SELECT 0x02 ! 97: #define WC_SCSI_RESET 0x01 ! 98: ! 99: #define RS_ARBIT_COMPL 0x80 /* Read STATUS (RS) register bits */ ! 100: #define RS_PRTY_ERROR 0x40 ! 101: #define RS_SELECT 0x20 ! 102: #define RS_REQUEST 0x10 ! 103: #define RS_CTRL_DATA 0x08 ! 104: #define RS_I_O 0x04 ! 105: #define RS_MESSAGE 0x02 ! 106: #define RS_BUSY 0x01 ! 107: ! 108: #define DEV_SCSI_ID(dev) ((dev >> 4) & 0x0007) ! 109: #define DEV_LUN(dev) ((dev >> 2) & 0x0003) ! 110: #define DEV_DRIVE(dev) ((dev >> 2) & 0x001F) ! 111: #define DEV_PARTN(dev) (dev & 0x0003) ! 112: #define DEV_SPECIAL(dev) (dev & 0x0080) ! 113: ! 114: #define HIPRI_RETRIES 5000 /* # of times to retry while hogging CPU */ ! 115: #define LOPRI_RETRIES 5 /* # of retries with sleep between tries */ ! 116: #define WHOLE_DRIVE NPARTN ! 117: #define RESET_TICKS 50 /* # of clock ticks for reset settling */ ! 118: #define LOAD_DELAY 30000 /* Loop counter during ssload() only */ ! 119: ! 120: #define BUS_FREE ((ffbyte(ss_csr) & (RS_BUSY | RS_SELECT)) == 0) ! 121: #define TGT_RSEL \ ! 122: ( (ffbyte(ss_csr) & (RS_SELECT | RS_I_O )) \ ! 123: && (ffbyte(ss_dat) & (host_id | (1<<s_id) )) ) ! 124: ! 125: #define DELAY_ARB 10 /* delays units are 10 msec (clock ticks) */ ! 126: #define DELAY_BDR 30 ! 127: #define DELAY_BSY 20 ! 128: #define DELAY_RES 50 ! 129: #define DELAY_RST 40 ! 130: ! 131: #define MAX_AVL_COUNT 100 ! 132: #define MAX_BDR_COUNT 3 ! 133: #define MAX_BSY_COUNT 3 ! 134: #define MAX_TRY_COUNT 10 ! 135: #define INL_MAX_REQ_POLL 800000L ! 136: #define WKG_MAX_REQ_POLL 20000L ! 137: ! 138: typedef enum { /* values for current driver state */ ! 139: SST_DEQUEUE =0, ! 140: SST_BUS_DEV_RESET, ! 141: SST_HIPRI_RESET, ! 142: SST_LOPRI_RESET, ! 143: SST_POLL_ARBITN, ! 144: SST_POLL_BEGIN_IO, ! 145: SST_POLL_RESELECT, ! 146: SST_REQ_SENSE, ! 147: SST_RESET_OFF ! 148: } SST_TYPE; ! 149: ! 150: typedef enum { /* values for input to recovery routine */ ! 151: RV_A_TIMEOUT, ! 152: RV_P_TIMEOUT, ! 153: RV_R_TIMEOUT, ! 154: RV_BF_TIMEOUT, ! 155: RV_CS_BUSY, ! 156: RV_CS_CHECK ! 157: } RV_TYPE; ! 158: ! 159: typedef struct ss { ! 160: ulong capacity; ! 161: ulong blocklen; ! 162: ulong bno; ! 163: int msg_in; ! 164: int dr_watch; ! 165: unchar cmdbuf[G1CMDLEN]; ! 166: int cmdlen; ! 167: int cmd_bytes_out; ! 168: int cmdstat; ! 169: BUF *bp; /* current I/O request node, or NULL */ ! 170: struct fdisk_s parmp[NPARTN+1]; ! 171: SST_TYPE state; ! 172: TIM tim; /* for target-specific timers */ ! 173: unchar avl_count; ! 174: unchar bdr_count; ! 175: unchar bsy_count; ! 176: unchar try_count; ! 177: uint busy:1; /* 1 if command uses local buffer */ ! 178: uint expired:1; /* 1 if target's timer has expired */ ! 179: uint ptab_read:1; /* 1 if partition table has been read */ ! 180: uint waiting:1; /* 1 if target timer is running */ ! 181: } ss_type; ! 182: ! 183: /* ! 184: * Functions. ! 185: * Import Functions. ! 186: * Export Functions. ! 187: * Local Functions. ! 188: */ ! 189: ! 190: /* functions from bufq.c */ ! 191: extern int bufq_init(); ! 192: extern void bufq_rlse(); ! 193: extern void bufq_wr_tail(); ! 194: extern BUF * bufq_rd_head(); ! 195: extern BUF * bufq_rm_head(); ! 196: ! 197: /* functions from ssas.s */ ! 198: extern void ss_get(); ! 199: extern int ss_put(); ! 200: extern int nulldev(); ! 201: extern int nonedev(); ! 202: #ifndef _I386 ! 203: extern unsigned char ffbyte(); ! 204: #endif ! 205: ! 206: static void ssopen(); /* CON functions */ ! 207: static void ssclose(); ! 208: static void ssblock(); ! 209: static void ssread(); ! 210: static void sswrite(); ! 211: static int ssioctl(); ! 212: static void sswatch(); ! 213: static void ssload(); ! 214: static void ssunload(); ! 215: ! 216: static int bus_dev_reset(); /* additional support functions */ ! 217: static int chk_reconn(); ! 218: static void do_connect(); ! 219: static void dummy_reconn(); ! 220: static int far_info_xfer(); ! 221: static int host_ident(); ! 222: static int init_call(); ! 223: static void init_pointers(); ! 224: static int inquiry(); ! 225: static int local_info_xfer(); ! 226: static int mode_sense(); ! 227: static void next_req(); ! 228: static void nonpolled(); ! 229: static int read_cap(); ! 230: static void recover(); ! 231: static int req_sense(); ! 232: static int rsel_handshake(); ! 233: static void ssdelay(); ! 234: static void ss_finished(); ! 235: static void ss_mach(); ! 236: static void set_timeout(); ! 237: static int ssinit(); ! 238: static void ssintr(); ! 239: static int start_arb(); ! 240: static void stop_timeout(); ! 241: static void tbparms(); ! 242: static unchar xpmod(); ! 243: ! 244: /* ! 245: * Global Data. ! 246: * Import Variables. ! 247: * Export Variables. ! 248: * Local Variables. ! 249: */ ! 250: ! 251: extern short at_drive_ct; /* set by atcount() before any load routines run */ ! 252: ! 253: CON sscon = { ! 254: DFBLK|DFCHR, /* Flags */ ! 255: SCSI_MAJOR, /* Major index */ ! 256: ssopen, /* Open */ ! 257: ssclose, /* Close */ ! 258: ssblock, /* Block */ ! 259: ssread, /* Read */ ! 260: sswrite, /* Write */ ! 261: ssioctl, /* Ioctl */ ! 262: nulldev, /* Powerfail */ ! 263: sswatch, /* Timeout */ ! 264: ssload, /* Load */ ! 265: ssunload, /* Unload */ ! 266: nulldev /* Poll */ ! 267: }; ! 268: ! 269: /* ! 270: * Configurable variables - see /etc/conf/ss/Space.c ! 271: * ! 272: * In the low byte of NSDRIVE, bit n is 1 if SCSI ID n is an installed target. ! 273: * The high byte indicates which type of host adapter: ! 274: * 00 - ST01/ST02 ! 275: * 80 - TMC-845/850/860/875/885 ! 276: * 40 - TMC-840/841/880/881 ! 277: */ ! 278: extern unsigned int NSDRIVE; ! 279: extern unsigned int SS_INT; /* ST0[12] use either IRQ3 or IRQ5 */ ! 280: extern unsigned int SS_BASE; /* Segment addr of ST0x comm area */ ! 281: ! 282: /* ncyl, nhead, nspt */ ! 283: extern _drv_parm_t drv_parm[]; ! 284: ! 285: static BUF dbuf; /* For raw I/O */ ! 286: static paddr_t ss_base; /* physical address of ST0x comm area */ ! 287: static faddr_t ss_fp; /* (far *) to ST0x comm area */ ! 288: ! 289: static faddr_t ss_ram; /* (far *) to parameter RAM */ ! 290: static faddr_t ss_csr; /* (far *) to control/status */ ! 291: static faddr_t ss_dat; /* (far *) to data port */ ! 292: ! 293: static TIM delay_tim; /* needed for calls to ssdelay() */ ! 294: static int do_sst_op; /* 1 when state machine iteration continues */ ! 295: static int ss_expired; /* 1 after local timeout */ ! 296: ! 297: static uint max_req_poll; /* this changes after initialization */ ! 298: ! 299: static unchar host_id; /* Host is SCSI ID #7 for Seagate, 6 for FD */ ! 300: static unchar swap_status_bits; ! 301: ! 302: static ss_type *ss_tbl; /* points to block of "ss" structs */ ! 303: static ss_type *ss[MAX_SCSI_ID]; ! 304: ! 305: /* ! 306: * host_claimed is -1 if host is available, else it's the SCSI id of the ! 307: * target that claims the host. ! 308: * ! 309: * host is claimed at start of any of the follwoing: ! 310: * SCSI bus reset ! 311: * arbitration for block i/o request ! 312: * reselect ! 313: * ! 314: * host is released at: ! 315: * end of SCSI bus reset ! 316: * completion (successful or not) of block i/o request (ss_finished) ! 317: * disconnect <-- temporarily disabled ! 318: */ ! 319: static int host_claimed; ! 320: ! 321: /* ! 322: * ssload() - load routine. ! 323: * ! 324: * Action: The controller is reset and the interrupt vector is grabbed. ! 325: * The drive characteristics are set up at this time. ! 326: */ ! 327: static void ssload() ! 328: { ! 329: int erf = 0; /* 1 if error occurs */ ! 330: int i; ! 331: int max_id = -1; ! 332: int num_drives = 0; ! 333: int tbnum; ! 334: ! 335: ! 336: /* ! 337: * Allocate a selector to map into ST0x memory-mapped comm area. ! 338: */ ! 339: ss_base = (paddr_t)((long)(unsigned)SS_BASE << 4); ! 340: #ifdef _I386 ! 341: ss_fp = map_pv(ss_base, (fsize_t)SS_SEL_LEN); ! 342: #else /* _I386 */ ! 343: ss_fp = ptov(ss_base, (fsize_t)SS_SEL_LEN); ! 344: #endif /* _I386 */ ! 345: ss_ram = ss_fp + SS_RAM; ! 346: ! 347: /* ! 348: * Primitive test of ST0x RAM. ! 349: */ ! 350: sfword(ss_ram, 0xA55A); ! 351: sfword(ss_ram + 2, 0x3CC3); ! 352: sfword(ss_ram + SS_RAM_LEN - 4, 0xA55A); ! 353: sfword(ss_ram + SS_RAM_LEN - 2, 0x3CC3); ! 354: if (ffword(ss_ram) != 0xA55A /* fetch a "far" word */ ! 355: || ffword(ss_ram + 2) != 0x3CC3 ! 356: || ffword(ss_ram + SS_RAM_LEN - 4) != 0xA55A ! 357: || ffword(ss_ram + SS_RAM_LEN - 2) != 0x3CC3) { ! 358: printf("Error - host failed memory test\n"); ! 359: erf = 1; ! 360: } ! 361: ! 362: /* ! 363: * Set host-dependent constants. ! 364: */ ! 365: switch(NSDRIVE >> 8) { ! 366: case 0x00: /* ST01/ST02 */ ! 367: ss_csr = ss_fp + SS_CSR; ! 368: ss_dat = ss_fp + SS_DAT; ! 369: host_id = 0x80; /* host is id #7 */ ! 370: break; ! 371: case 0x80: /* TMC-845/850/860/875/885 */ ! 372: ss_csr = ss_fp + FD_CSR; ! 373: ss_dat = ss_fp + FD_DAT; ! 374: host_id = 0x40; /* host is id #6 */ ! 375: break; ! 376: case 0x40: /* TMC-840/841/880/881 */ ! 377: ss_csr = ss_fp + SS_CSR; ! 378: ss_dat = ss_fp + SS_DAT; ! 379: host_id = 0x40; /* host is id #6 */ ! 380: swap_status_bits = 1; ! 381: break; ! 382: } ! 383: NSDRIVE &= ~(uint)host_id; ! 384: ! 385: /* ! 386: * Allocate drive structs. ! 387: * ! 388: * Do a single call to kalloc() then put allocated pieces into ! 389: * array ss. ! 390: * ! 391: * First allocate and clear storage. Then hook up the pointers. ! 392: */ ! 393: if (!erf) { ! 394: for (i = 0; i < MAX_SCSI_ID; i++) ! 395: if ((NSDRIVE >> i) & 1) { ! 396: max_id = i; ! 397: num_drives++; ! 398: } ! 399: if (num_drives == 0) { ! 400: printf("Error - ss has no valid target id's\n"); ! 401: erf = 1; ! 402: } else if ((ss_tbl = kalloc(num_drives*sizeof(ss_type))) ! 403: == NULL) { ! 404: printf("Error - ss can't allocate structs\n"); ! 405: erf = 1; ! 406: } else ! 407: kclear(ss_tbl, num_drives * sizeof(ss_type)); ! 408: } ! 409: if (!erf) { ! 410: ss_type *foo = ss_tbl; ! 411: ! 412: for (i = 0; i < MAX_SCSI_ID; i++) ! 413: if ((NSDRIVE >> i) & 1) ! 414: ss[i] = foo++; ! 415: } ! 416: ! 417: /* ! 418: * Claim IRQ vector. ! 419: */ ! 420: setivec(SS_INT, ssintr); ! 421: ! 422: /* ! 423: * Initialize drives we know about (i.e. in NSDRIVE bitmap). ! 424: * ! 425: * Part of this is getting parameters from tboot, if any. ! 426: * The drive number in tboot's data block must be matched with ! 427: * the SCSI id in question. Drive numbering in tboot is assumed ! 428: * to start with any "at" drives (at_drive_ct counts these) ! 429: * then proceed with SCSI drives in increasing id number order. ! 430: */ ! 431: tbnum = at_drive_ct; /* tboot drive number for first SCSI drive */ ! 432: host_claimed = -1; ! 433: bufq_init(max_id + 1); ! 434: max_req_poll = INL_MAX_REQ_POLL; ! 435: if (!erf) { ! 436: for (i = 0; i < MAX_SCSI_ID; i++) ! 437: if ((NSDRIVE >> i) & 1) { ! 438: tbparms(tbnum, i); /* get tboot parms */ ! 439: ssinit(i); ! 440: tbnum++; ! 441: } ! 442: } ! 443: max_req_poll = WKG_MAX_REQ_POLL; ! 444: } ! 445: ! 446: /* ! 447: * ssunload() - unload routine. ! 448: */ ! 449: static void ssunload() ! 450: { ! 451: /* ! 452: * Deallocate driver heap space. ! 453: */ ! 454: if (ss_tbl) ! 455: kfree(ss_tbl); ! 456: bufq_rlse(); ! 457: ! 458: /* ! 459: * Free the ST0x selector. ! 460: */ ! 461: #ifdef _I386 ! 462: unmap_pv(ss_fp); ! 463: #else /* _I386 */ ! 464: vrelse(ss_fp); ! 465: #endif /* _I386 */ ! 466: ! 467: /* ! 468: * Release IRQ vector. ! 469: */ ! 470: clrivec(SS_INT); ! 471: } ! 472: ! 473: /* ! 474: * ssopen() ! 475: * ! 476: * Input: dev = disk device to be opened. ! 477: * mode = access mode [IPR,IPW, IPR+IPW]. ! 478: * ! 479: * Action: Validate the minor device. ! 480: * Update the paritition table if necessary. ! 481: */ ! 482: static void ssopen(dev, mode) ! 483: register dev_t dev; ! 484: { ! 485: int drive, partn; ! 486: struct fdisk_s *fdp; ! 487: ss_type * ssp; ! 488: int s_id; ! 489: unchar * msg; ! 490: ! 491: /* ! 492: * Set up local variables. ! 493: */ ! 494: drive = DEV_SCSI_ID(dev); ! 495: partn = DEV_PARTN(dev); ! 496: s_id = DEV_SCSI_ID(dev); ! 497: ssp = ss[s_id]; ! 498: fdp = ssp->parmp; ! 499: ! 500: #if (DEBUG >= 3) ! 501: devmsg(dev, "ssopen"); ! 502: #endif ! 503: ! 504: /* ! 505: * LUN must be zero. ! 506: * SCSI id must have corresponding 1 in NSDRIVE bitmapped variable. ! 507: */ ! 508: if (DEV_LUN(dev) != 0 || ((1 << drive) & NSDRIVE) == 0) { ! 509: msg = "bad LUN or SCSI id"; ! 510: u.u_error = ENXIO; ! 511: goto bad_open; ! 512: } ! 513: ! 514: /* ! 515: * If "special" bit is set, partition field must be zero. ! 516: */ ! 517: if (DEV_SPECIAL(dev) && partn != 0) { ! 518: msg = "bad special partition"; ! 519: u.u_error = ENXIO; ! 520: goto bad_open; ! 521: } ! 522: ! 523: /* ! 524: * Subscripting gimmick for partition table. ! 525: */ ! 526: if (dev & SDEV) ! 527: partn = WHOLE_DRIVE; ! 528: ! 529: /* ! 530: * If not accessing whole drive and the partition table has not ! 531: * been read yet, try to read it now. ! 532: * Do this by calling fdisk() with partition table device on the drive ! 533: * that is being accessed. ! 534: */ ! 535: if (partn != WHOLE_DRIVE && !(ssp->ptab_read)) { ! 536: int fdisk_dev; ! 537: ! 538: fdisk_dev = (dev | SDEV) & 0xfff0; ! 539: ! 540: #if (DEBUG >=3) ! 541: devmsg(fdisk_dev, "calling fdisk"); ! 542: if (fdisk(fdisk_dev, fdp)) { ! 543: int p; ! 544: ! 545: fdp[WHOLE_DRIVE].p_size = ssp->capacity; ! 546: fdp[WHOLE_DRIVE].p_base = 0; ! 547: printf("fdisk() succeeded\n"); ! 548: for (p=0; p<WHOLE_DRIVE; p++) ! 549: printf("p=%d base=%ld size=%ld\n", p, fdp[p].p_base, fdp[p].p_size); ! 550: ssp->ptab_read = 1; ! 551: } else { ! 552: printf("fdisk() failed\n"); ! 553: u.u_error = ENXIO; ! 554: goto bad_open; ! 555: } ! 556: #else ! 557: if (fdisk(fdisk_dev, fdp)) { ! 558: fdp[WHOLE_DRIVE].p_size = ssp->capacity; ! 559: fdp[WHOLE_DRIVE].p_base = 0; ! 560: ssp->ptab_read = 1; ! 561: } else { ! 562: msg = "bad partition table"; ! 563: u.u_error = ENXIO; ! 564: goto bad_open; ! 565: } ! 566: #endif ! 567: ! 568: } ! 569: ! 570: /* ! 571: * Ensure partition lies within drive boundaries and is non-zero size. ! 572: */ ! 573: if (partn != WHOLE_DRIVE ! 574: && (fdp[partn].p_base+fdp[partn].p_size) > fdp[WHOLE_DRIVE].p_size) { ! 575: msg = "partition exceeds drive capacity"; ! 576: #ifdef _I386 ! 577: u.u_error = EINVAL; ! 578: #else ! 579: u.u_error = EBADFMT; ! 580: #endif /* _I386 */ ! 581: goto bad_open; ! 582: } ! 583: ! 584: if (partn != WHOLE_DRIVE && fdp[partn].p_size == 0) { ! 585: msg = "partition not found"; ! 586: u.u_error = ENODEV; ! 587: goto bad_open; ! 588: } ! 589: ! 590: /* ! 591: * OK to open the device. ! 592: * Start watchdog timer (if not already started) for the host adapter. ! 593: */ ! 594: ++drvl[SCSI_MAJOR].d_time; ! 595: ++ssp->dr_watch; ! 596: goto end_open; ! 597: ! 598: bad_open: ! 599: devmsg(dev, msg); ! 600: end_open: ! 601: return; ! 602: } ! 603: ! 604: /* ! 605: * ssclose() ! 606: */ ! 607: static void ssclose(dev) ! 608: dev_t dev; ! 609: { ! 610: ss_type * ssp; ! 611: int s_id; ! 612: ! 613: s_id = DEV_SCSI_ID(dev); ! 614: ssp = ss[s_id]; ! 615: ! 616: /* ! 617: * Decrement the number of watchdog timer requests open for host ! 618: * adapter and for target. ! 619: */ ! 620: --drvl[SCSI_MAJOR].d_time; ! 621: --ssp->dr_watch; ! 622: ! 623: #if (DEBUG >= 3) ! 624: devmsg(dev, "ssclose"); ! 625: #endif ! 626: ! 627: } ! 628: ! 629: /* ! 630: * ssread() - read a block from the raw disk ! 631: * ! 632: * Input: dev = disk device to be written to. ! 633: * iop = pointer to source I/O structure. ! 634: * ! 635: * Action: Invoke the common raw I/O processing code. ! 636: */ ! 637: static void ssread(dev, iop) ! 638: dev_t dev; ! 639: IO *iop; ! 640: { ! 641: ioreq( &dbuf, iop, dev, BREAD, BFRAW|BFBLK|BFIOC ); ! 642: } ! 643: ! 644: /* ! 645: * sswrite() - write a block to the raw disk ! 646: * ! 647: * Input: dev = disk device to be written to. ! 648: * iop = pointer to source I/O structure. ! 649: * ! 650: * Action: Invoke the common raw I/O processing code. ! 651: */ ! 652: static void sswrite(dev, iop) ! 653: dev_t dev; ! 654: IO *iop; ! 655: { ! 656: ioreq( &dbuf, iop, dev, BWRITE, BFRAW|BFBLK|BFIOC ); ! 657: } ! 658: ! 659: /* ! 660: * ssioctl() ! 661: * ! 662: * Input: dev = disk device to be operated on. ! 663: * cmd = input/output request to be performed. ! 664: * vec = (pointer to) optional argument. ! 665: */ ! 666: static int ssioctl(dev, cmd, vec) ! 667: register dev_t dev; ! 668: int cmd; ! 669: char * vec; ! 670: { ! 671: int ret = 0; ! 672: hdparm_t hdparm; ! 673: struct fdisk_s *fdp; ! 674: int s_id; ! 675: ss_type * ssp; ! 676: ! 677: s_id = DEV_SCSI_ID(dev); ! 678: ssp = ss[s_id]; ! 679: fdp = ssp->parmp; ! 680: ! 681: switch(cmd) { ! 682: case HDGETA: ! 683: /* ! 684: * Get hard disk attributes. ! 685: */ ! 686: PR3("HDGETA"); ! 687: fdp = ssp->parmp; ! 688: *(short *)&hdparm.landc[0] = ! 689: *(short *)&hdparm.ncyl[0] = drv_parm[s_id].ncyl; ! 690: hdparm.nhead = drv_parm[s_id].nhead; ! 691: hdparm.nspt = drv_parm[s_id].nspt; ! 692: #if (DEBUG >= 3) ! 693: printf("ncyl=%d nhead=%d nspt=%d\n", ! 694: hdparm.ncyl[0]+((int)hdparm.ncyl[1]<<8), (int)hdparm.nhead, (int)hdparm.nspt); ! 695: #endif ! 696: kucopy(&hdparm, vec, sizeof hdparm); ! 697: ret = 0; ! 698: break; ! 699: case HDSETA: ! 700: /* ! 701: * Set hard disk attributes. ! 702: */ ! 703: PR3("HDSETA"); ! 704: fdp = ssp->parmp; ! 705: ukcopy(vec, &hdparm, sizeof hdparm); ! 706: drv_parm[s_id].ncyl = *(short *)&hdparm.ncyl[0]; ! 707: drv_parm[s_id].nhead = hdparm.nhead; ! 708: drv_parm[s_id].nspt = hdparm.nspt; ! 709: #if (DEBUG >= 3) ! 710: printf("ncyl=%d nhead=%d nspt=%d\n", ! 711: hdparm.ncyl[0]+((int)hdparm.ncyl[1]<<8), (int)hdparm.nhead, (int)hdparm.nspt); ! 712: #endif ! 713: ret = 0; ! 714: break; ! 715: default: ! 716: u.u_error = EINVAL; ! 717: ret = -1; ! 718: } ! 719: ! 720: return ret; ! 721: } ! 722: ! 723: /* ! 724: * ssblock() - queue a block to the disk ! 725: * ! 726: * Input: bp = pointer to block to be queued. ! 727: * ! 728: * Action: Queue a block to the disk. ! 729: * Make sure that the transfer is within the disk partition. ! 730: */ ! 731: static void ssblock(bp) ! 732: register BUF *bp; ! 733: { ! 734: struct fdisk_s *fdp; ! 735: int partition, drive, s_id; ! 736: dev_t dev; ! 737: ss_type * ssp; ! 738: unchar * msg = NULL; ! 739: ! 740: /* ! 741: * Set up local variables. ! 742: */ ! 743: dev = bp->b_dev; ! 744: partition = DEV_PARTN(dev); ! 745: drive = DEV_DRIVE(dev); ! 746: s_id = DEV_SCSI_ID(dev); ! 747: ssp = ss[s_id]; ! 748: if (dev & SDEV) ! 749: partition = WHOLE_DRIVE; ! 750: fdp = ssp->parmp; ! 751: ! 752: bp->b_resid = bp->b_count; ! 753: #if (DEBUG >= 2) ! 754: if (bp->b_count != BSIZE) ! 755: printf("b_count=%d ", bp->b_count); ! 756: #endif ! 757: ! 758: /* ! 759: * Range check disk region. ! 760: */ ! 761: if (!(ssp->ptab_read)) { ! 762: if ( partition == WHOLE_DRIVE ) { ! 763: #if 0 ! 764: /* Why did we only allow people to access the first block of WHOLE_DRIVE? ! 765: in cases where there was not a valid partition table? */ ! 766: if ((bp->b_bno != 0) || (bp->b_count != BSIZE)) { ! 767: msg = "invalid request"; ! 768: bp->b_flag |= BFERR; ! 769: goto bad_blk; ! 770: } ! 771: #endif ! 772: } else { ! 773: msg = "no partition table"; ! 774: bp->b_flag |= BFERR; ! 775: goto bad_blk; ! 776: } ! 777: } ! 778: ! 779: /* ! 780: * Check for read at end of partition. ! 781: * (Need to return with b_resid = BSIZE to signal end of volume.) ! 782: */ ! 783: else if ((bp->b_req == BREAD) && (bp->b_bno == fdp[partition].p_size)) { ! 784: goto bad_blk; ! 785: } ! 786: ! 787: /* ! 788: * Check for read past end of partition. ! 789: */ ! 790: else if ( (bp->b_bno + (bp->b_count/BSIZE)) ! 791: > fdp[partition].p_size ) { ! 792: msg = "partition overrun"; ! 793: bp->b_flag |= BFERR; ! 794: goto bad_blk; ! 795: } ! 796: ! 797: /* ! 798: * Fail if request is for zero bytes or is not even # of blocks. ! 799: */ ! 800: if ((bp->b_count % BSIZE) || bp->b_count == 0) { ! 801: msg = "invalid byte count"; ! 802: bp->b_flag |= BFERR; ! 803: goto bad_blk; ! 804: } ! 805: ! 806: /* ! 807: * Operation appears valid. ! 808: * Fill fields in the node and queue the request. ! 809: */ ! 810: bufq_wr_tail(s_id, bp); ! 811: ss_mach(s_id); ! 812: goto end_blk; ! 813: ! 814: /* ! 815: * Operation cannot be done. Release the kernel buffer structure. ! 816: * Value of "bp->b_flag" tells caller if error occurred. ! 817: */ ! 818: bad_blk: ! 819: if (msg) ! 820: devmsg(dev, msg); ! 821: bdone(bp); ! 822: ! 823: end_blk: ! 824: return; ! 825: } ! 826: ! 827: /* ! 828: * ssintr() - Interrupt routine. ! 829: * ! 830: * If we have been reselected by a recognized target device ! 831: * let kernel get out of interrupt mode (defer) and do SCSI ! 832: * reconnect stuff. ! 833: */ ! 834: static void ssintr() ! 835: { ! 836: int s_id; ! 837: ! 838: s_id = chk_reconn(); ! 839: if (s_id != -1) { ! 840: if (ss[s_id]->state == SST_POLL_RESELECT) ! 841: defer(ss_mach, s_id); ! 842: else ! 843: defer(dummy_reconn, s_id); ! 844: PR3("!"); ! 845: } ! 846: } ! 847: ! 848: /* ! 849: * dummy_reconn() ! 850: * ! 851: * Somehow we are in a state where the driver software does not expect ! 852: * a reconnect but a device is trying one anyway. Go thru the motions ! 853: * of reconnect because not servicing a hanging reselect seems to leave ! 854: * the target hung - in such a way that it fails to respond to reset ! 855: * messages and to reset on the SCSI bus. ! 856: */ ! 857: static void dummy_reconn(s_id) ! 858: int s_id; ! 859: { ! 860: int bus_timeout; ! 861: unchar phase_type; ! 862: int s; ! 863: int msg_in; ! 864: int cmdstat; ! 865: int xfer_good = 1; ! 866: PR1("DUM"); ! 867: if (ss[s_id]->state == SST_POLL_RESELECT) { ! 868: defer(ss_mach, s_id); ! 869: goto dum_done; ! 870: } ! 871: if (!rsel_handshake()) ! 872: goto dum_done; ! 873: ! 874: s = sphi(); ! 875: while (req_wait(&bus_timeout) && xfer_good) { ! 876: phase_type = ffbyte(ss_csr) & (RS_MESSAGE|RS_I_O|RS_CTRL_DATA); ! 877: switch (xpmod(phase_type)) { ! 878: case XP_MSG_IN: ! 879: msg_in = ffbyte(ss_dat); ! 880: switch(msg_in){ ! 881: case MSG_CMD_CMPLT: ! 882: case MSG_DISCONNECT: ! 883: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_IRPT); ! 884: break; ! 885: } ! 886: break; ! 887: case XP_MSG_OUT: ! 888: sfbyte(ss_dat, MSG_NOP); ! 889: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI); ! 890: break; ! 891: case XP_STAT_IN: ! 892: cmdstat = ffbyte(ss_dat); ! 893: break; ! 894: case XP_CMD_OUT: ! 895: case XP_DATA_OUT: ! 896: xfer_good = 0; ! 897: break; ! 898: case XP_DATA_IN: ! 899: ffbyte(ss_dat); ! 900: break; ! 901: default: ! 902: break; ! 903: } /* endswitch */ ! 904: } /* endwhile */ ! 905: spl(s); ! 906: ! 907: dum_done: ! 908: return; ! 909: } ! 910: ! 911: /* ! 912: * sswatch() ! 913: * ! 914: * Invoked once per second if any devices going through this driver are open. ! 915: * Poll for any reselect, in case interrupt got lost. ! 916: */ ! 917: static void sswatch() ! 918: { ! 919: int s_id; ! 920: ss_type * ssp; ! 921: ! 922: for (s_id = 0; s_id < MAX_SCSI_ID; s_id++) { ! 923: ssp = ss[s_id]; ! 924: if (ssp && ssp->dr_watch) ! 925: defer(ss_mach, s_id); ! 926: } /* endfor */ ! 927: } ! 928: ! 929: /* ! 930: * bus_wait() ! 931: * ! 932: * Wait for specified bit values to appear in Status Register. ! 933: * This uses a tight loop and does not expect to be interrupted. ! 934: * ! 935: * Argument "flags" is a double-byte value; the high byte is ANDed with ! 936: * status register contents, and the result is tested for equality with ! 937: * the low byte. ! 938: * ! 939: * Return 1 if values wanted appeared, 0 if timeout occurred. ! 940: */ ! 941: static int bus_wait(flags) ! 942: unsigned short flags; ! 943: { ! 944: int found, i; ! 945: unsigned char status; ! 946: ! 947: found = 0; ! 948: for ( i = 0; i < HIPRI_RETRIES; i++) { ! 949: status = ffbyte(ss_csr); ! 950: if ((status & (flags >> 8)) == (flags & 0xff)) { ! 951: found = 1; ! 952: break; ! 953: } ! 954: } ! 955: ! 956: #if (DEBUG >= 1) ! 957: if (!found) ! 958: printf("TO:f=%x s=%x ", flags, status); ! 959: #endif ! 960: ! 961: return found; ! 962: } ! 963: ! 964: /* ! 965: * ssinit() ! 966: * ! 967: * Attempt to initialize the (unique) drive with a given SCSI id. ! 968: * Assume only one drive per SCSI id, having LUN = 0. ! 969: * ! 970: * Return 1 if success, 0 if failure. ! 971: */ ! 972: static int ssinit(s_id) ! 973: int s_id; ! 974: { ! 975: int retval = 1; ! 976: unchar query_buf[MODESENSELEN]; ! 977: ss_type * ssp = ss[s_id]; ! 978: int dev = ((sscon.c_mind << 8) | 0x80 | (s_id << 4)); ! 979: ! 980: printf("SCSI ID %d LUN 0\n", s_id); ! 981: if (retval) ! 982: if (init_call(inquiry, s_id, query_buf)) { ! 983: query_buf[INQUIRYLEN] = 0; ! 984: #if (debug >= 2) ! 985: devmsg(dev, query_buf + 8); ! 986: #endif ! 987: if (query_buf[0] == 0) { ! 988: retval = 1; ! 989: } else ! 990: devmsg(dev, "Not Direct Access Device"); ! 991: } else ! 992: devmsg(dev, "Inquiry Failed"); ! 993: ! 994: if (retval) ! 995: if (init_call(read_cap, s_id, query_buf)) { ! 996: retval = 1; ! 997: ssp->capacity = query_buf[3] | (query_buf[2] << 8) ! 998: | (((long)(query_buf[1])) << 16) ! 999: | (((long)(query_buf[0])) << 24); ! 1000: ssp->blocklen = query_buf[7] | (query_buf[6] << 8) ! 1001: | (((long)(query_buf[5])) << 16) ! 1002: | (((long)(query_buf[4])) << 24); ! 1003: ! 1004: printf("Capacity=%ld blocks Block length=%ld\n", ! 1005: ssp->capacity, ssp->blocklen); ! 1006: } else ! 1007: devmsg(dev, "Read Capacity Failed"); ! 1008: ! 1009: if (retval) ! 1010: if (init_call(mode_sense, s_id, query_buf)) { ! 1011: /* ! 1012: * Display physical drive parameters. ! 1013: */ ! 1014: #define FMT_PG (4+8+8+12) ! 1015: #define DDG_PG (4+8+8+12+24) ! 1016: unchar heads; ! 1017: unsigned short spt; ! 1018: ulong cyls; ! 1019: ! 1020: spt=((int)query_buf[FMT_PG+10]<<8) ! 1021: + query_buf[FMT_PG+11]; ! 1022: cyls=((int)query_buf[DDG_PG+2]<<16) ! 1023: + ((int)query_buf[DDG_PG+3]<<8) ! 1024: + query_buf[DDG_PG+4]; ! 1025: heads=query_buf[DDG_PG+5]; ! 1026: ! 1027: printf("Physical: cylinders=%ld ", cyls); ! 1028: printf("heads=%d ", heads); ! 1029: printf("spt=%d\n", spt); ! 1030: ! 1031: if (drv_parm[s_id].ncyl == 0) { ! 1032: drv_parm[s_id].ncyl = cyls; ! 1033: drv_parm[s_id].nhead = heads; ! 1034: drv_parm[s_id].nspt = spt; ! 1035: } else { ! 1036: printf("Logical: cylinders=%d ", ! 1037: drv_parm[s_id].ncyl); ! 1038: printf("heads=%d ", drv_parm[s_id].nhead); ! 1039: printf("spt=%d\n", drv_parm[s_id].nspt); ! 1040: } ! 1041: } else ! 1042: devmsg(dev, "Mode Sense Failed"); ! 1043: ! 1044: return retval; ! 1045: } ! 1046: ! 1047: /* ! 1048: * far_info_xfer() ! 1049: * ! 1050: * Do bus cycle information transfer phases. ! 1051: * This includes message in/out, command in/out, and data in/out. ! 1052: * ! 1053: * If cmdlen is nonzero, cmdbuf is an array of bytes of that length, ! 1054: * to be sent to the target. ! 1055: * ! 1056: * Return 1 if bus timeout did not occur, else 0. ! 1057: * ! 1058: * pseudocode: ! 1059: * ! 1060: * while (wait for REQ true or BUSY false on SCSI bus) ! 1061: * if (BUSY false) ! 1062: * break from while loop ! 1063: * else ! 1064: * switch (xfer phase = RS_CTRL_DATA|RS_I_O|RS_MESSAGE) ! 1065: * case XP_MSG_IN/XP_MSG_OUT/... ! 1066: * handle the indicated information transfer phase ! 1067: * endswitch ! 1068: * endif ! 1069: * endwhile ! 1070: */ ! 1071: static int far_info_xfer(s_id) ! 1072: int s_id; ! 1073: { ! 1074: int bus_timeout; ! 1075: unchar phase_type; ! 1076: unchar msg_in; ! 1077: int s; ! 1078: int bytes_to_send; ! 1079: ss_type * ssp = ss[s_id]; ! 1080: BUF * bp = ssp->bp; ! 1081: int xfer_good = 1; ! 1082: int xfer_count = bp->b_count - bp->b_resid; ! 1083: int irpts_masked; ! 1084: int block_done=0; ! 1085: ! 1086: ssp->cmd_bytes_out = 0; ! 1087: ssp->msg_in = -1; ! 1088: ! 1089: irpts_masked = 0; ! 1090: while (req_wait(&bus_timeout) && xfer_good) { ! 1091: phase_type = ffbyte(ss_csr) & (RS_MESSAGE|RS_I_O|RS_CTRL_DATA); ! 1092: if (!irpts_masked) { ! 1093: s = sphi(); ! 1094: irpts_masked = 1; ! 1095: } ! 1096: switch (xpmod(phase_type)) { ! 1097: case XP_MSG_IN: ! 1098: msg_in = ffbyte(ss_dat); ! 1099: switch(msg_in){ ! 1100: case MSG_CMD_CMPLT: ! 1101: PR4("Mcc"); ! 1102: ssp->msg_in = msg_in; ! 1103: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_IRPT); ! 1104: break; ! 1105: case MSG_DISCONNECT: ! 1106: PR4("Mdc"); ! 1107: ssp->msg_in = msg_in; ! 1108: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_IRPT); ! 1109: break; ! 1110: case MSG_SAVE_DPTR: ! 1111: PR4("Msd"); ! 1112: break; ! 1113: case MSG_RSTOR_DPTR: ! 1114: PR4("Mrd"); ! 1115: break; ! 1116: case MSG_ABORT: ! 1117: PR4("Mab"); ! 1118: break; ! 1119: case MSG_DEV_RESET: ! 1120: PR4("Mdr"); ! 1121: break; ! 1122: case MSG_IDENTIFY: ! 1123: PR4("Mmi"); ! 1124: break; ! 1125: case MSG_IDENT_DC: ! 1126: PR4("Mmd"); ! 1127: break; ! 1128: } ! 1129: break; ! 1130: case XP_MSG_OUT: ! 1131: PR4("MO"); ! 1132: /* ! 1133: * This case shouldn't happen. We weren't ! 1134: * asserting ATTENTION. Abort the bus cycle. ! 1135: */ ! 1136: sfbyte(ss_dat, MSG_NOP); ! 1137: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI); ! 1138: break; ! 1139: case XP_STAT_IN: ! 1140: PR4("SI"); ! 1141: ssp->cmdstat = ffbyte(ss_dat); ! 1142: break; ! 1143: case XP_CMD_OUT: ! 1144: /* ! 1145: * Ship out command bytes. ! 1146: * Reset SCSI bus if too many command bytes are wanted. ! 1147: */ ! 1148: bytes_to_send = ssp->cmdlen - ssp->cmd_bytes_out; ! 1149: if(bytes_to_send > 0) { ! 1150: sfbyte(ss_dat, ssp->cmdbuf[ssp->cmd_bytes_out++]); ! 1151: /* ! 1152: * If just sent last byte, allow interrupts. ! 1153: */ ! 1154: if (bytes_to_send == 1) { ! 1155: PR4("CO"); ! 1156: if (bp->b_req == BREAD) { ! 1157: if (irpts_masked) { ! 1158: spl(s); ! 1159: irpts_masked = 0; ! 1160: } ! 1161: } ! 1162: } ! 1163: } else { /* This case should not happen. */ ! 1164: xfer_good = 0; ! 1165: } ! 1166: break; ! 1167: case XP_DATA_IN: ! 1168: /* ! 1169: * If caller's buffer has room, keep incoming ! 1170: * data byte. ! 1171: */ ! 1172: if (block_done) { ! 1173: xfer_good = 0; ! 1174: PR1("Data in overrun"); ! 1175: } else if (bp->b_req != BREAD) { ! 1176: xfer_good = 0; ! 1177: } else { ! 1178: #if 0 ! 1179: int getbval; ! 1180: ! 1181: block_done=1; ! 1182: PR4("DI"); ! 1183: if(getbval = ss_getb(ss_dat, ! 1184: #ifdef _I386 ! 1185: bp->b_vaddr + xfer_count)) { ! 1186: #else ! 1187: bp->b_faddr + xfer_count)) { ! 1188: #endif /* _I386 */ ! 1189: xfer_good = 0; ! 1190: #if (DEBUG >= 1) ! 1191: printf("getb=%d ", getbval); ! 1192: #endif ! 1193: } ! 1194: #else ! 1195: block_done=1; ! 1196: #ifdef _I386 ! 1197: ! 1198: if (BSIZE != xpcopy(ss_dat, bp->b_paddr + xfer_count, ! 1199: BSIZE, SEG_386_KD|SEG_VIRT)) { ! 1200: devmsg(bp->b_dev, "XP_DATA_IN: ss_dat: %x, bp->bpaddr: %x, xfer_count: %x\n", ! 1201: ss_dat, bp->b_paddr, xfer_count); ! 1202: break; ! 1203: } ! 1204: #else ! 1205: ffcopy(ss_dat, bp->b_faddr + xfer_count, BSIZE); ! 1206: #endif /* _I386 */ ! 1207: #endif /* 0 */ ! 1208: } ! 1209: break; ! 1210: case XP_DATA_OUT: ! 1211: /* ! 1212: * Copy output buffer bytes to data register. ! 1213: */ ! 1214: if (block_done) { ! 1215: xfer_good = 0; ! 1216: PR1("Data out overrun"); ! 1217: } else if (bp->b_req != BWRITE) { ! 1218: xfer_good = 0; ! 1219: } else { ! 1220: #if 0 ! 1221: int putbval; ! 1222: block_done=1; ! 1223: PR4("DO"); ! 1224: if (putbval = ss_putb(ss_dat, ! 1225: #ifdef _I386 ! 1226: bp->b_vaddr + xfer_count)) { ! 1227: #else ! 1228: bp->b_faddr + xfer_count)) { ! 1229: #endif /* _I386 */ ! 1230: xfer_good = 0; ! 1231: #if (DEBUG >= 1) ! 1232: printf("putb=%d ", putbval); ! 1233: #endif ! 1234: } ! 1235: #else ! 1236: block_done=1; ! 1237: #ifdef _I386 ! 1238: if (BSIZE != pxcopy(bp->b_paddr + xfer_count, ss_dat, ! 1239: BSIZE, SEG_386_KD|SEG_VIRT)) { ! 1240: devmsg(bp->b_dev, "XP_DATA_OUT: bp->b_paddr: %x, xfer_count: %x, ss_dat: %x\n", ! 1241: bp->b_paddr, xfer_count, ss_dat); ! 1242: break; ! 1243: } ! 1244: ! 1245: #else ! 1246: ffcopy(bp->b_faddr + xfer_count, ss_dat, BSIZE); ! 1247: #endif /* _I386 */ ! 1248: #endif ! 1249: if (irpts_masked) { ! 1250: spl(s); ! 1251: irpts_masked = 0; ! 1252: } ! 1253: } ! 1254: break; ! 1255: default: ! 1256: break; ! 1257: } /* endswitch */ ! 1258: } ! 1259: if (irpts_masked) ! 1260: spl(s); ! 1261: ! 1262: #if (DEBUG >= 1) ! 1263: switch(ssp->cmdstat) { ! 1264: case -1: ! 1265: if (msg_in != MSG_DISCONNECT) ! 1266: printf("CS-",ssp->cmdstat); ! 1267: break; ! 1268: case CS_GOOD: ! 1269: break; ! 1270: case CS_CHECK: ! 1271: printf("CSK",ssp->cmdstat); ! 1272: break; ! 1273: case CS_BUSY: ! 1274: printf("CSY",ssp->cmdstat); ! 1275: break; ! 1276: case CS_RESERVED: ! 1277: default: ! 1278: printf("CS%x",ssp->cmdstat); ! 1279: } ! 1280: #endif ! 1281: ! 1282: return (bus_timeout) ? 0 : 1 ; ! 1283: } ! 1284: ! 1285: /* ! 1286: * req_wait() ! 1287: * ! 1288: * This routine is called at the start of each information transfer ! 1289: * phase and after the last such phase. ! 1290: * ! 1291: * It returns 1 if REQ is asserted on the SCSI bus, meaning another phase ! 1292: * may begin, and 0 otherwise. A REQ signal will not be seen if the function ! 1293: * times out or if BUSY drops. A value of 1 is written to the pointer argument ! 1294: * if timeout occurred, else 0 is written. ! 1295: */ ! 1296: static int req_wait(to_ptr) ! 1297: int *to_ptr; ! 1298: { ! 1299: int req_found; ! 1300: unsigned char status; ! 1301: ulong poll_ct; ! 1302: int s; ! 1303: ! 1304: s = splo(); ! 1305: *to_ptr = 1; ! 1306: req_found = 0; ! 1307: for (poll_ct = 0L; poll_ct < max_req_poll; poll_ct++) { ! 1308: status = ffbyte(ss_csr); ! 1309: if (status & RS_REQUEST) { ! 1310: req_found = 1; ! 1311: *to_ptr = 0; ! 1312: break; ! 1313: } else if ((status & RS_BUSY) == 0) { ! 1314: *to_ptr = 0; ! 1315: break; ! 1316: } ! 1317: } ! 1318: ! 1319: #if (DEBUG >= 1) ! 1320: if (*to_ptr) { ! 1321: printf("TX: s=%x ", status); ! 1322: } ! 1323: #endif ! 1324: ! 1325: spl(s); ! 1326: return req_found; ! 1327: } ! 1328: ! 1329: /* ! 1330: * req_sense() ! 1331: * ! 1332: * Request Sense for a device. The main reason for doing this is to ! 1333: * clear a standing Command Status of Device Check. ! 1334: * ! 1335: * Full results are discarded. Return 1 if Device returns No Sense or ! 1336: * or Unit Attention. Else return 0. ! 1337: * ! 1338: */ ! 1339: static int req_sense(s_id) ! 1340: int s_id; ! 1341: { ! 1342: unchar sense_buf[SENSELEN]; ! 1343: unchar cmdbuf[G0CMDLEN]; ! 1344: int ret = 0; ! 1345: ! 1346: cmdbuf[0] = ScmdREQUESTSENSE; ! 1347: cmdbuf[1] = 0; ! 1348: cmdbuf[2] = 0; ! 1349: cmdbuf[3] = 0; ! 1350: cmdbuf[4] = SENSELEN; ! 1351: cmdbuf[5] = 0; ! 1352: ! 1353: #if (DEBUG >= 2) ! 1354: {int i; for (i=0; i<SENSELEN; i++) sense_buf[i]=0;} ! 1355: #endif ! 1356: ! 1357: PR2("rqs:"); ! 1358: if (!start_arb()) { ! 1359: PR2("NO arb"); ! 1360: #if (DEBUG >= 2) ! 1361: printf("status=%x ", ffbyte(ss_csr)); ! 1362: #endif ! 1363: goto rqs_done; ! 1364: } ! 1365: ! 1366: if (!host_ident(s_id, 0)) { ! 1367: PR2("NO host ident"); ! 1368: #if (DEBUG >= 2) ! 1369: printf("status=%x ", ffbyte(ss_csr)); ! 1370: #endif ! 1371: goto rqs_done; ! 1372: } ! 1373: ! 1374: if(!local_info_xfer(cmdbuf, G0CMDLEN, sense_buf, SENSELEN, NULL, 0)) { ! 1375: PR2("NO local xfer"); ! 1376: goto rqs_done; ! 1377: } else { ! 1378: /* ! 1379: * Return 1 if drive responded with any of these sense keys: ! 1380: * 0x00 No Sense ! 1381: * 0x06 Unit Attention ! 1382: * 0x0B Aborted Command ! 1383: * In any of the above cases, a retry will likely succeed ! 1384: * without Buse Device Reset or SCSI Bus Reset. ! 1385: */ ! 1386: switch (sense_buf[2]) { ! 1387: case 0x00: ! 1388: case 0x06: ! 1389: case 0x0B: ! 1390: ret = 1; ! 1391: break; ! 1392: } /* endswitch */ ! 1393: } ! 1394: ! 1395: rqs_done: ! 1396: #if (DEBUG >= 2) ! 1397: { ! 1398: int i; ! 1399: ! 1400: for (i=0; i<SENSELEN;i++) ! 1401: printf("%x ", sense_buf[i]); ! 1402: printf("\n"); ! 1403: } ! 1404: #endif ! 1405: return ret; ! 1406: } ! 1407: ! 1408: /* ! 1409: * inquiry() ! 1410: * ! 1411: * Inquiry command for a device. ! 1412: * Find out if device is direct access, removable, etc. ! 1413: * ! 1414: * Put result of inquiry into supplied buffer. ! 1415: * Return 1 if command succeeds, else 0. ! 1416: */ ! 1417: static int inquiry(s_id, buf) ! 1418: int s_id; ! 1419: unchar * buf; ! 1420: { ! 1421: int ret = 0; ! 1422: unchar cmdbuf[G0CMDLEN]; ! 1423: ! 1424: cmdbuf[0] = ScmdINQUIRY; ! 1425: cmdbuf[1] = 0; ! 1426: cmdbuf[2] = 0; ! 1427: cmdbuf[3] = 0; ! 1428: cmdbuf[4] = INQUIRYLEN; ! 1429: cmdbuf[5] = 0; ! 1430: ! 1431: if (start_arb() && host_ident(s_id, 0) && ! 1432: local_info_xfer(cmdbuf, G0CMDLEN, buf, INQUIRYLEN, NULL, 0)) ! 1433: ret = 1; ! 1434: ! 1435: return ret; ! 1436: } ! 1437: ! 1438: /* ! 1439: * mode_sense() ! 1440: * ! 1441: * Mode Sense command for a device. ! 1442: * Use this to get disk parameters: ! 1443: * number of cylinders ! 1444: * number of heads ! 1445: * number of sectors per track. ! 1446: * ! 1447: * Put result of mode sense into supplied buffer. ! 1448: * Return 1 if command succeeds, else 0. ! 1449: */ ! 1450: static int mode_sense(s_id, buf) ! 1451: int s_id; ! 1452: unchar * buf; ! 1453: { ! 1454: int ret = 0; ! 1455: unchar cmdbuf[G0CMDLEN]; ! 1456: ! 1457: cmdbuf[0] = ScmdMODESENSE; ! 1458: cmdbuf[1] = 0; ! 1459: cmdbuf[2] = 0x3F; ! 1460: cmdbuf[3] = 0; ! 1461: cmdbuf[4] = MODESENSELEN; ! 1462: cmdbuf[5] = 0; ! 1463: ! 1464: if (start_arb() && host_ident(s_id, 0) && ! 1465: local_info_xfer(cmdbuf, G0CMDLEN, buf, MODESENSELEN, NULL, 0)) ! 1466: ret = 1; ! 1467: ! 1468: return ret; ! 1469: } ! 1470: ! 1471: /* ! 1472: * read_cap() ! 1473: * ! 1474: * Read Capacity command for a device. ! 1475: * ! 1476: * Return 1 if command succeeds, else 0. ! 1477: */ ! 1478: static int read_cap(s_id, buf) ! 1479: int s_id; ! 1480: unchar * buf; ! 1481: { ! 1482: int ret = 0; ! 1483: unchar cmdbuf[G1CMDLEN]; ! 1484: ! 1485: cmdbuf[0] = ScmdREADCAPACITY; ! 1486: cmdbuf[1] = 0; ! 1487: cmdbuf[2] = 0; ! 1488: cmdbuf[3] = 0; ! 1489: cmdbuf[4] = 0; ! 1490: cmdbuf[5] = 0; ! 1491: cmdbuf[6] = 0; ! 1492: cmdbuf[7] = 0; ! 1493: cmdbuf[8] = 0; ! 1494: cmdbuf[9] = 0; ! 1495: ! 1496: if (start_arb() && host_ident(s_id, 0) && ! 1497: local_info_xfer(cmdbuf, G1CMDLEN, buf, READCAPLEN, NULL, 0)) ! 1498: ret = 1; ! 1499: ! 1500: return ret; ! 1501: } ! 1502: ! 1503: /* ! 1504: * bus_dev_reset() ! 1505: * ! 1506: * Send Bus Device Reset message to the given SCSI id. ! 1507: * Return 1 if host adapter was not busy and no obvious timeouts occurred, ! 1508: * else 0. ! 1509: */ ! 1510: static int bus_dev_reset(s_id) ! 1511: { ! 1512: int bdr_ok = 1; ! 1513: int dev = ((sscon.c_mind << 8) | 0x80 | (s_id << 4)); ! 1514: ! 1515: PR1("BDR"); ! 1516: if (bdr_ok) { ! 1517: /* ! 1518: * Do ST0x arbitration. ! 1519: * ! 1520: * De-assert SCSI enable bit. ! 1521: * Write my SCSI id to port. ! 1522: * Start arbitration. ! 1523: */ ! 1524: sfbyte(ss_csr, WC_ENABLE_PRTY); ! 1525: sfbyte(ss_dat, host_id); ! 1526: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ARBITRATE); ! 1527: ! 1528: /* ! 1529: * SCSI spec says there is "no maximum" to the wait for ! 1530: * arbitration complete. ! 1531: */ ! 1532: if (!bus_wait(RS_ARBIT_COMPL << 8 | RS_ARBIT_COMPL)) { ! 1533: bdr_ok = 0; ! 1534: } ! 1535: } ! 1536: ! 1537: /* ! 1538: * Arbitration complete. Now select, with ATN to allow messages. ! 1539: */ ! 1540: if (bdr_ok) { ! 1541: sfbyte(ss_dat, host_id | (1 << s_id)); /* Write both SCSI id's */ ! 1542: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_ATTENTION | WC_SELECT); ! 1543: ! 1544: if (!bus_wait(RS_BUSY << 8 | RS_BUSY)) ! 1545: bdr_ok = 0; ! 1546: } ! 1547: ! 1548: if (bdr_ok) { ! 1549: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_ATTENTION); ! 1550: ! 1551: if (!bus_wait(((RS_REQUEST|RS_CTRL_DATA|RS_I_O|RS_MESSAGE) << 8) ! 1552: | (RS_REQUEST|RS_CTRL_DATA|RS_MESSAGE))) ! 1553: bdr_ok = 0; ! 1554: } ! 1555: ! 1556: if (bdr_ok) { ! 1557: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI); ! 1558: sfbyte(ss_dat, MSG_DEV_RESET); ! 1559: if (!bus_wait((0xFF << 8) | 0)) ! 1560: bdr_ok = 0; ! 1561: } ! 1562: ! 1563: return bdr_ok; ! 1564: } ! 1565: ! 1566: /* ! 1567: * chk_reconn() ! 1568: * ! 1569: * Check SELECT to see if any SCSI device has tried to reconnect to the host ! 1570: * adapter. Called if there is an interrupt, and by the timer in case ! 1571: * we somehow lose an interrupt. ! 1572: * ! 1573: * Return -1 if no reselect detected, or the SCSI ID of the reselecting ! 1574: * target if there is one. ! 1575: */ ! 1576: static int chk_reconn() ! 1577: { ! 1578: unchar csr, dat; ! 1579: int s_id = -1; ! 1580: ! 1581: csr = ffbyte(ss_csr); ! 1582: if (csr & (RS_SELECT | RS_I_O)) { ! 1583: dat = ffbyte(ss_dat); ! 1584: if ((dat & host_id) && (dat & NSDRIVE)) { ! 1585: dat &= ~host_id; ! 1586: s_id = 0; ! 1587: while (dat >>=1) ! 1588: s_id++; ! 1589: } ! 1590: } ! 1591: ! 1592: return s_id; ! 1593: } ! 1594: ! 1595: /* ! 1596: * ss_mach() ! 1597: * ! 1598: * Gives a distinct state machine for each target device. ! 1599: */ ! 1600: void ss_mach(s_id) ! 1601: int s_id; ! 1602: { ! 1603: ss_type * ssp = ss[s_id]; ! 1604: BUF * bp; ! 1605: ! 1606: do_sst_op = 1; /* plan to run this routine again in most cases */ ! 1607: while (do_sst_op) { ! 1608: bp = ssp->bp; /* nonpolled() below can change ssp->bp */ ! 1609: switch (ssp->state) { ! 1610: /* ! 1611: * Polling states execute whether ssp->waiting or not. ! 1612: */ ! 1613: case SST_POLL_ARBITN: ! 1614: PR3("XPAR"); ! 1615: if (ffbyte(ss_csr) & RS_ARBIT_COMPL) { ! 1616: ssp->waiting = 0; ! 1617: if (host_ident(s_id, 1)) ! 1618: do_connect(s_id); ! 1619: else ! 1620: recover(s_id, RV_P_TIMEOUT); ! 1621: } else { ! 1622: if (ssp->expired) { ! 1623: ssp->expired = 0; ! 1624: recover(s_id, RV_A_TIMEOUT); ! 1625: } else ! 1626: do_sst_op = 0; ! 1627: } ! 1628: break; ! 1629: case SST_POLL_RESELECT: ! 1630: PR3("XPRS"); ! 1631: if (TGT_RSEL) { ! 1632: ssp->waiting = 0; ! 1633: if (host_claimed == -1) ! 1634: host_claimed = s_id; ! 1635: else if (host_claimed != s_id) { ! 1636: #if (DEBUG >= 1) ! 1637: printf("%d->%d ", host_claimed, s_id); ! 1638: #endif ! 1639: } ! 1640: if (rsel_handshake()) { ! 1641: do_connect(s_id); ! 1642: } else { ! 1643: recover(s_id, RV_P_TIMEOUT); ! 1644: } ! 1645: } else { /* Reselect poll is negative */ ! 1646: if (ssp->expired) { ! 1647: ssp->expired = 0; ! 1648: recover(s_id, RV_R_TIMEOUT); ! 1649: } else ! 1650: do_sst_op = 0; ! 1651: } ! 1652: break; ! 1653: case SST_POLL_BEGIN_IO: ! 1654: PR3("XPBI"); ! 1655: if (bp == NULL) ! 1656: ssp->state = SST_DEQUEUE; ! 1657: else { ! 1658: /* ! 1659: * At this point a SCSI command is about to ! 1660: * be initiated. It may be a retry. ! 1661: */ ! 1662: if (host_claimed == -1 && BUS_FREE && BUS_FREE) { ! 1663: ssp->waiting = 0; ! 1664: init_pointers(s_id); ! 1665: if (start_arb()) { ! 1666: host_claimed = s_id; ! 1667: if (host_ident(s_id, 1)) { ! 1668: do_connect(s_id); ! 1669: } else { ! 1670: recover(s_id, RV_P_TIMEOUT); ! 1671: } ! 1672: } else { ! 1673: /* ! 1674: * If arbitration does not succeed right away, it is usually ! 1675: * because another drive is trying to reselect the host. ! 1676: */ ! 1677: set_timeout(s_id, DELAY_ARB); ! 1678: } ! 1679: } else { /* host busy or bus not free */ ! 1680: int o_id; ! 1681: ! 1682: if ((o_id = chk_reconn()) != -1) ! 1683: defer(dummy_reconn, s_id); ! 1684: ++ssp->avl_count; ! 1685: if (ssp->avl_count >= MAX_AVL_COUNT) ! 1686: recover(s_id, RV_BF_TIMEOUT); ! 1687: else ! 1688: set_timeout(s_id, DELAY_BSY); ! 1689: } ! 1690: } ! 1691: break; ! 1692: default: ! 1693: if (ssp->waiting) ! 1694: do_sst_op = 0; ! 1695: else { ! 1696: /* ! 1697: * Nonpolling states execute only if no ! 1698: * target timer is running. ! 1699: */ ! 1700: nonpolled(s_id); ! 1701: } ! 1702: } /* endswitch */ ! 1703: } /* endwhile */ ! 1704: } ! 1705: ! 1706: /* ! 1707: * nonpolled() ! 1708: * ! 1709: * Part of ss_mach() - handling of nonpolling states is taken out simply ! 1710: * for readability. ! 1711: */ ! 1712: static void nonpolled(s_id) ! 1713: int s_id; ! 1714: { ! 1715: ss_type * ssp = ss[s_id]; ! 1716: BUF * bp = ssp->bp; ! 1717: struct fdisk_s *fdp; ! 1718: int partition; ! 1719: dev_t dev; ! 1720: ! 1721: switch (ssp->state) { ! 1722: case SST_BUS_DEV_RESET: ! 1723: PR3("XBDR"); ! 1724: if (bus_dev_reset(s_id)) { ! 1725: do_sst_op = 0; ! 1726: set_timeout(s_id, DELAY_BDR); ! 1727: ssp->state = SST_REQ_SENSE; ! 1728: } else ! 1729: recover(s_id, RV_P_TIMEOUT); ! 1730: break; ! 1731: case SST_DEQUEUE: ! 1732: if(bufq_rd_head(s_id) != NULL && !ssp->busy) { ! 1733: PR3("XDQU"); ! 1734: ssp->busy = 1; ! 1735: bp = bufq_rm_head(s_id); ! 1736: ssp->bp = bp; ! 1737: dev = bp->b_dev; ! 1738: partition = DEV_PARTN(dev); ! 1739: if (dev & SDEV) ! 1740: partition = WHOLE_DRIVE; ! 1741: fdp = ssp->parmp; ! 1742: if (partition != WHOLE_DRIVE) ! 1743: ssp->bno = fdp[partition].p_base + bp->b_bno; ! 1744: else ! 1745: ssp->bno = bp->b_bno; ! 1746: if (bp->b_req == BREAD) ! 1747: ssp->cmdbuf[0] = ScmdREADEXTENDED; ! 1748: else ! 1749: ssp->cmdbuf[0] = ScmdWRITEXTENDED; ! 1750: ssp->cmdbuf[1] = 0; ! 1751: ssp->cmdbuf[2] = ssp->bno >> 24; ! 1752: ssp->cmdbuf[3] = ssp->bno >> 16; ! 1753: ssp->cmdbuf[4] = ssp->bno >> 8; ! 1754: ssp->cmdbuf[5] = ssp->bno; ! 1755: ssp->cmdbuf[6] = 0; ! 1756: ssp->cmdbuf[7] = 0; ! 1757: ssp->cmdbuf[8] = 1; ! 1758: ssp->cmdbuf[9] = 0; ! 1759: ssp->cmdlen = G1CMDLEN; ! 1760: init_pointers(s_id); ! 1761: ssp->bdr_count = 0; ! 1762: ssp->bsy_count = 0; ! 1763: ssp->try_count = 0; ! 1764: ssp->state = SST_POLL_BEGIN_IO; ! 1765: } else /* queue is empty or ssp->busy */ ! 1766: do_sst_op = 0; ! 1767: break; ! 1768: case SST_HIPRI_RESET: ! 1769: case SST_LOPRI_RESET: ! 1770: PR1("XRST"); ! 1771: /* ! 1772: * SST_LOPRI_RESET is same as SST_HIPRI_RESET for now. ! 1773: * Later, can implement a delay to allow other targets to ! 1774: * finish pending operations. ! 1775: */ ! 1776: if (host_claimed == s_id || host_claimed == -1) { ! 1777: host_claimed = s_id; ! 1778: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_SCSI_RESET); /* reset ON */ ! 1779: ssp->state = SST_RESET_OFF; ! 1780: set_timeout(s_id, DELAY_RST); ! 1781: PR1("+"); ! 1782: } else ! 1783: set_timeout(s_id, DELAY_RST); ! 1784: break; ! 1785: case SST_REQ_SENSE: ! 1786: PR1("XRQS"); ! 1787: /* ! 1788: * Come here at end of SCSI Bus reset (and at other times). ! 1789: * If we have host claimed, release it. ! 1790: */ ! 1791: if (host_claimed == s_id) ! 1792: host_claimed = -1; ! 1793: if (req_sense(s_id)) ! 1794: ssp->state = SST_POLL_BEGIN_IO; ! 1795: else ! 1796: recover(s_id, RV_P_TIMEOUT); ! 1797: break; ! 1798: case SST_RESET_OFF: ! 1799: PR3("XRFF"); ! 1800: sfbyte(ss_csr, WC_ENABLE_PRTY); /* reset OFF */ ! 1801: ssp->state = SST_REQ_SENSE; ! 1802: set_timeout(s_id, DELAY_RST); ! 1803: } /* endswitch */ ! 1804: } ! 1805: ! 1806: /* ! 1807: * start_arb() ! 1808: * ! 1809: * return 1 if host adapter returned Arbitration Complete within allotted ! 1810: * number of tries, else 0 ! 1811: */ ! 1812: static int start_arb() ! 1813: { ! 1814: int ret = 0; ! 1815: int poll_ct; ! 1816: ! 1817: sfbyte(ss_csr, WC_ENABLE_PRTY); ! 1818: sfbyte(ss_dat, host_id); ! 1819: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ARBITRATE); ! 1820: ! 1821: /* ! 1822: * SCSI spec says there is "no maximum" to the wait for arbitration ! 1823: * complete. ! 1824: */ ! 1825: for (poll_ct = 0; poll_ct < HIPRI_RETRIES; poll_ct++) { ! 1826: if (ffbyte(ss_csr) & RS_ARBIT_COMPL) { ! 1827: ret = 1; ! 1828: break; ! 1829: } else if (chk_reconn() != -1) { ! 1830: sfbyte(ss_csr, WC_ENABLE_PRTY); ! 1831: break; ! 1832: } ! 1833: } ! 1834: #if (DEBUG >= 1) ! 1835: if (!ret) ! 1836: PR1("oSA"); ! 1837: #endif ! 1838: return ret; ! 1839: } ! 1840: ! 1841: /* ! 1842: * host_ident() ! 1843: * ! 1844: * This routine is the bridge in a SCSI bus cycle between Abitration ! 1845: * Complete and the Information Transfer phases. ! 1846: * ! 1847: * return 1 if everything went ok, 0 in case of timeout ! 1848: */ ! 1849: static int host_ident(s_id, disconnect) ! 1850: int s_id; ! 1851: int disconnect; ! 1852: { ! 1853: int ret = 0; ! 1854: ! 1855: /* ! 1856: * Arbitration complete. Now select, with ATN to allow messages. ! 1857: */ ! 1858: sfbyte(ss_dat, host_id | (1 << s_id)); /* Write both SCSI id's */ ! 1859: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_ATTENTION | WC_SELECT); ! 1860: ! 1861: if (bus_wait(RS_BUSY << 8 | RS_BUSY)) { ! 1862: /* ! 1863: * Assert ATTN so target expects incoming message byte. ! 1864: */ ! 1865: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_ATTENTION); ! 1866: ! 1867: if (bus_wait(((RS_REQUEST|RS_CTRL_DATA|RS_I_O|RS_MESSAGE) << 8) ! 1868: | (RS_REQUEST|RS_CTRL_DATA|RS_MESSAGE))) { ! 1869: if (disconnect) { ! 1870: sfbyte(ss_dat, MSG_IDENT_DC); ! 1871: } else { ! 1872: sfbyte(ss_dat, MSG_IDENTIFY); ! 1873: } ! 1874: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_ENABLE_IRPT); ! 1875: ret = 1; ! 1876: } else { ! 1877: PR1("oHI2"); ! 1878: } ! 1879: } else { ! 1880: PR1("oHI1"); ! 1881: } ! 1882: return ret; ! 1883: } ! 1884: ! 1885: /* ! 1886: * rsel_handshake() ! 1887: * ! 1888: * After Reselect is detected, a couple steps are needed before entering ! 1889: * Information Transfer phases. This routine does those steps. ! 1890: * ! 1891: * return 1 if ok, 0 in case of timeout. ! 1892: */ ! 1893: static int rsel_handshake() ! 1894: { ! 1895: int ret = 0; ! 1896: ! 1897: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_BUSY); ! 1898: if (bus_wait(RS_SELECT << 8 | 0)) { ! 1899: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI); ! 1900: ret = 1; ! 1901: } ! 1902: return ret; ! 1903: } ! 1904: ! 1905: /* ! 1906: * set_timeout() ! 1907: * ! 1908: * Start a timer so as not to wait forever in case something goes wrong while ! 1909: * waiting for an event. Available delays are: ! 1910: * ! 1911: * DELAY_ARB - wait for arbitration complete ! 1912: * DELAY_BDR - allow settling time after Bus Device Reset ! 1913: * DELAY_BSY - wait for not HOST_BUSY and bus free ! 1914: * DELAY_RES - wait for reselect by target ! 1915: * DELAY_RST - allow settling times when doing SCSI Bus Reset ! 1916: * ! 1917: * Second argument is number of clock ticks to wait until timer expiration. ! 1918: */ ! 1919: static void set_timeout(s_id, delay) ! 1920: int s_id, delay; ! 1921: { ! 1922: ss_type * ssp = ss[s_id]; ! 1923: ! 1924: ssp->expired = 0; ! 1925: ssp->waiting = 1; ! 1926: do_sst_op = 0; ! 1927: timeout(&(ssp->tim), delay, stop_timeout, s_id); ! 1928: } ! 1929: ! 1930: /* ! 1931: * stop_timeout() ! 1932: * ! 1933: * Called on expiration of the timer for a given target. ! 1934: * Don't expire a timer if it's no longer active. ! 1935: */ ! 1936: static void stop_timeout(s_id) ! 1937: int s_id; ! 1938: { ! 1939: ss_type * ssp = ss[s_id]; ! 1940: ! 1941: if (ssp->waiting) { ! 1942: ssp->expired = 1; ! 1943: ssp->waiting = 0; ! 1944: } ! 1945: ss_mach(s_id); ! 1946: } ! 1947: ! 1948: /* ! 1949: * init_pointers() ! 1950: * ! 1951: * Initialize command and data pointers when starting (or restarting) ! 1952: * a block i/o command. ! 1953: */ ! 1954: static void init_pointers(s_id) ! 1955: int s_id; ! 1956: { ! 1957: ss_type * ssp = ss[s_id]; ! 1958: BUF * bp = ssp->bp; ! 1959: ! 1960: ssp->cmdstat = -1; ! 1961: ssp->cmd_bytes_out = 0; ! 1962: ssp->avl_count = 0; ! 1963: } ! 1964: ! 1965: /* ! 1966: * recover() ! 1967: * ! 1968: * This routine is called directly or indirectly from ss_mach(). It ! 1969: * determines what to do when the interface fails to behave as desired. ! 1970: * ! 1971: * Arguments are the SCSI id of the target HDC and an error type. ! 1972: * Error types are: ! 1973: * ! 1974: * RV_A_TIMEOUT (arbitration timeout) ! 1975: * Host adapter takes too long to respond with arbitration complete. ! 1976: * ! 1977: * RV_P_TIMEOUT (protocol timeout) ! 1978: * Timeout waiting for desired SCSI bus status while connected to a target. ! 1979: * ! 1980: * RV_R_TIMEOUT (reconnect timeout) ! 1981: * Timeout after target disconnects, waiting for reconnect. ! 1982: * ! 1983: * RV_BF_TIMEOUT (bus free timeout) ! 1984: * Waited too long for host not busy and BUS_FREE. ! 1985: * ! 1986: * RV_CS_BUSY (target device busy) ! 1987: * Command status returned was Busy. ! 1988: * ! 1989: * RV_CS_CHECK (target device check) ! 1990: * Command status returned was CHECK. ! 1991: * ! 1992: * Whenever an error occurs, one of the above inputs, together with the SCSI id ! 1993: * of the target, is sent to the recovery process. The recovery process in turn ! 1994: * programs the next state for the machine. ! 1995: */ ! 1996: static void recover(s_id, errtype) ! 1997: int s_id; ! 1998: RV_TYPE errtype; ! 1999: { ! 2000: ss_type * ssp = ss[s_id]; ! 2001: BUF * bp = ssp->bp; ! 2002: ! 2003: #if (DEBUG >= 1) ! 2004: int foo; ! 2005: if ((foo=chk_reconn()) != -1) ! 2006: printf("HONK%d ", foo); ! 2007: #endif ! 2008: ! 2009: ++ssp->try_count; ! 2010: if (ssp->try_count < MAX_TRY_COUNT) { ! 2011: ! 2012: switch (errtype) { ! 2013: ! 2014: case RV_CS_BUSY: ! 2015: ++ssp->bsy_count; ! 2016: if (ssp->bsy_count < MAX_BSY_COUNT) { ! 2017: ssp->state = SST_POLL_BEGIN_IO; ! 2018: set_timeout(s_id, DELAY_BSY); ! 2019: } else ! 2020: ssp->state = SST_BUS_DEV_RESET; ! 2021: break; ! 2022: ! 2023: case RV_CS_CHECK: ! 2024: ssp->state = SST_REQ_SENSE; ! 2025: break; ! 2026: ! 2027: case RV_P_TIMEOUT: ! 2028: /* fall thru */ ! 2029: case RV_R_TIMEOUT: ! 2030: ++ssp->bdr_count; ! 2031: if (ssp->bdr_count < MAX_BDR_COUNT) ! 2032: ssp->state = SST_BUS_DEV_RESET; ! 2033: else ! 2034: ssp->state = SST_LOPRI_RESET; ! 2035: break; ! 2036: ! 2037: case RV_BF_TIMEOUT: ! 2038: /* fall thru */ ! 2039: case RV_A_TIMEOUT: ! 2040: ssp->state = SST_HIPRI_RESET; ! 2041: } ! 2042: } else { /* try_count >= MAX_TRY_COUNT */ ! 2043: if (bp) { ! 2044: bp->b_flag |= BFERR; ! 2045: printf("(%d,%d): ", major(bp->b_dev), minor(bp->b_dev)); ! 2046: printf("%s error bno=%ld\n", ! 2047: (bp->b_req == BREAD) ? "read" : "write", ! 2048: bp->b_bno); ! 2049: } ! 2050: ss_finished(s_id); ! 2051: } ! 2052: } ! 2053: ! 2054: /* ! 2055: * ss_finished ! 2056: * ! 2057: * Release current i/o buffer to the O/S. ! 2058: */ ! 2059: static void ss_finished(s_id) ! 2060: int s_id; ! 2061: { ! 2062: ss_type * ssp = ss[s_id]; ! 2063: BUF * bp = ssp->bp; ! 2064: int go_again = 1; ! 2065: ! 2066: if (host_claimed == s_id) ! 2067: host_claimed = -1; ! 2068: ssp->busy = 0; ! 2069: if (bp) { ! 2070: if (!(bp->b_flag & BFERR)) ! 2071: bp->b_resid -= BSIZE; ! 2072: if ((bp->b_flag & BFERR) || bp->b_resid == 0) { ! 2073: ssp->bp = NULL; ! 2074: bdone(bp); ! 2075: go_again = 0; ! 2076: } ! 2077: } ! 2078: if (go_again) { ! 2079: ssp->state = SST_POLL_BEGIN_IO; ! 2080: ssp->bdr_count = 0; ! 2081: ssp->bsy_count = 0; ! 2082: ssp->try_count = 0; ! 2083: ! 2084: ssp->bno++; ! 2085: ssp->cmdbuf[2] = ssp->bno >> 24; ! 2086: ssp->cmdbuf[3] = ssp->bno >> 16; ! 2087: ssp->cmdbuf[4] = ssp->bno >> 8; ! 2088: ssp->cmdbuf[5] = ssp->bno; ! 2089: } else { ! 2090: /* ! 2091: * After processing a kernel i/o request, stop the ! 2092: * state machine for the current id. Then start ! 2093: * this or some other machine which has a request ! 2094: * pending. ! 2095: */ ! 2096: do_sst_op = 0; ! 2097: ssp->state = SST_DEQUEUE; ! 2098: next_req(s_id); ! 2099: } ! 2100: } ! 2101: ! 2102: /* ! 2103: * next_req() ! 2104: * ! 2105: * Given the SCSI id where an i/o request just completed, start handling ! 2106: * another i/o request - which may be for the same or other SCSI id. ! 2107: * For now, use round-robin scheduling. ! 2108: */ ! 2109: static void next_req(s_id) ! 2110: int s_id; ! 2111: { ! 2112: int next_id = s_id; ! 2113: ! 2114: while (1) { ! 2115: next_id++; ! 2116: if (next_id >= MAX_SCSI_ID) ! 2117: next_id = 0; ! 2118: if (ss[next_id] ! 2119: && (ss[next_id]->state != SST_DEQUEUE || bufq_rd_head(next_id))) { ! 2120: defer(ss_mach, next_id); ! 2121: break; ! 2122: } ! 2123: if (next_id == s_id) ! 2124: break; ! 2125: } ! 2126: } ! 2127: ! 2128: /* ! 2129: * do_connect() ! 2130: * ! 2131: * This function is called when the host is successfully connected to ! 2132: * the target. It invokes information transfer protocol and then sets ! 2133: * up some sort of recovery unless the command completed successfully ! 2134: * or there was a normal disconnect. ! 2135: */ ! 2136: static void do_connect(s_id) ! 2137: int s_id; ! 2138: { ! 2139: int result; ! 2140: ss_type * ssp = ss[s_id]; ! 2141: ! 2142: result = far_info_xfer(s_id); ! 2143: if (!result) ! 2144: recover(s_id, RV_P_TIMEOUT); ! 2145: else if (ssp->msg_in == MSG_DISCONNECT) { ! 2146: ssp->state = SST_POLL_RESELECT; ! 2147: set_timeout(s_id, DELAY_RES); ! 2148: #if 0 ! 2149: if (host_claimed == s_id) ! 2150: host_claimed = -1; ! 2151: #endif ! 2152: } else if (ssp->msg_in == MSG_CMD_CMPLT && ssp->cmdstat == CS_GOOD) ! 2153: ss_finished(s_id); ! 2154: else if (ssp->cmdstat == CS_BUSY) ! 2155: recover(s_id, RV_CS_BUSY); ! 2156: else if (ssp->cmdstat == CS_CHECK) ! 2157: recover(s_id, RV_CS_CHECK); ! 2158: else /* something else went wrong */ ! 2159: recover(s_id, RV_P_TIMEOUT); ! 2160: } ! 2161: ! 2162: /* ! 2163: * local_info_xfer() ! 2164: * ! 2165: * Do bus cycle information transfer phases. ! 2166: * Transfer is for a command which will produce local results in the driver. ! 2167: * Other ...info_xfer routine handles kernel block i/o commands. ! 2168: * ! 2169: * Return 1 if transfer succeeded, else 0. ! 2170: * ! 2171: */ ! 2172: static int local_info_xfer(cmdbuf, cmdlen, inbuf, inlen, outbuf, outlen) ! 2173: unchar * cmdbuf, * inbuf, * outbuf; ! 2174: uint cmdlen, inlen, outlen; ! 2175: { ! 2176: int bus_timeout; ! 2177: unchar phase_type; ! 2178: int s; ! 2179: int cmd_bytes_out = 0; ! 2180: int data_bytes_in = 0; ! 2181: int data_bytes_out = 0; ! 2182: int ret = 0; ! 2183: int xfer_good = 1; ! 2184: int cmdstat = -1; ! 2185: int msg_in = -1; ! 2186: #if (DEBUG >= 1) ! 2187: int x, xct=0; ! 2188: unchar xch[100]; ! 2189: #endif ! 2190: ! 2191: s = sphi(); ! 2192: while (req_wait(&bus_timeout) && xfer_good) { ! 2193: phase_type = ffbyte(ss_csr) & (RS_MESSAGE|RS_I_O|RS_CTRL_DATA); ! 2194: #if (DEBUG >= 1) ! 2195: if (xct < 100) ! 2196: xch[xct++]=phase_type; ! 2197: #endif ! 2198: switch (xpmod(phase_type)) { ! 2199: case XP_MSG_IN: ! 2200: msg_in = ffbyte(ss_dat); ! 2201: switch(msg_in){ ! 2202: case MSG_CMD_CMPLT: ! 2203: case MSG_DISCONNECT: ! 2204: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_IRPT); ! 2205: break; ! 2206: } ! 2207: break; ! 2208: case XP_MSG_OUT: ! 2209: /* ! 2210: * This case shouldn't happen. We weren't ! 2211: * asserting ATTENTION. ! 2212: */ ! 2213: sfbyte(ss_dat, MSG_NOP); ! 2214: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI); ! 2215: break; ! 2216: case XP_STAT_IN: ! 2217: cmdstat = ffbyte(ss_dat); ! 2218: break; ! 2219: case XP_CMD_OUT: ! 2220: /* ! 2221: * Ship out command bytes. ! 2222: */ ! 2223: if (cmd_bytes_out < cmdlen) { ! 2224: sfbyte(ss_dat, cmdbuf[cmd_bytes_out++]); ! 2225: #if 1 ! 2226: /* ! 2227: * If just sent last byte, allow interrupts. ! 2228: */ ! 2229: if (cmd_bytes_out == cmdlen) { ! 2230: spl(s); ! 2231: s = sphi(); ! 2232: } ! 2233: #endif ! 2234: } else { /* This case should not happen. */ ! 2235: xfer_good = 0; ! 2236: } ! 2237: break; ! 2238: case XP_DATA_IN: ! 2239: /* ! 2240: * If caller's buffer has room, keep incoming ! 2241: * data byte. Else toss it. ! 2242: */ ! 2243: if (data_bytes_in < inlen) { ! 2244: #if 0 ! 2245: do { ! 2246: inbuf[data_bytes_in++] = ffbyte(ss_dat); ! 2247: } while (data_bytes_in < inlen); ! 2248: #else ! 2249: inbuf[data_bytes_in++] = ffbyte(ss_dat); ! 2250: #endif ! 2251: } else ! 2252: xfer_good = 0; ! 2253: break; ! 2254: case XP_DATA_OUT: ! 2255: /* ! 2256: * Copy output buffer bytes to data register. ! 2257: */ ! 2258: if (data_bytes_out < outlen) { ! 2259: sfbyte(outbuf[data_bytes_out++], ss_dat); ! 2260: } else { /* This case should not happen. */ ! 2261: xfer_good = 0; ! 2262: } ! 2263: break; ! 2264: default: ! 2265: break; ! 2266: } /* endswitch */ ! 2267: } ! 2268: spl(s); ! 2269: ! 2270: if (bus_timeout) { ! 2271: PR1("oLX1"); ! 2272: } else if (!xfer_good) { ! 2273: PR1("oLX2"); ! 2274: } else if (cmdstat != CS_GOOD) { ! 2275: PR1("oLX3"); ! 2276: #if (DEBUG >= 1) ! 2277: printf("cmdstat=%x ", cmdstat); ! 2278: #endif ! 2279: } else ! 2280: ret = 1; ! 2281: #if (DEBUG >= 1) ! 2282: if (!ret) { ! 2283: printf("csr=%x ", ffbyte(ss_csr)); ! 2284: printf("xct=%d ", xct); ! 2285: for (x=0; x < xct; x++) ! 2286: printf("%x ", xch[x]); ! 2287: } ! 2288: #endif ! 2289: ! 2290: return ret; ! 2291: } ! 2292: ! 2293: /* ! 2294: * scsireset() ! 2295: * ! 2296: * Reset the SCSI bus. ! 2297: * Allow settling time when turning reset on/off. ! 2298: * Settling times were determined empirically. ! 2299: * Each tick is 10 msec. ! 2300: */ ! 2301: static void scsireset() ! 2302: { ! 2303: int s; ! 2304: ! 2305: #if (DEBUG >= 1) ! 2306: printf("scsireset "); ! 2307: #endif ! 2308: s = splo(); ! 2309: sfbyte(ss_csr, WC_ENABLE_PRTY | WC_ENABLE_SCSI | WC_SCSI_RESET); ! 2310: ssdelay(RESET_TICKS); ! 2311: sfbyte(ss_csr, WC_ENABLE_PRTY); ! 2312: ssdelay(RESET_TICKS); ! 2313: spl(s); ! 2314: } ! 2315: ! 2316: /* ! 2317: * ssdelay() ! 2318: * ! 2319: * Delay for some number of arbitrary ticks. ! 2320: * ! 2321: * Using sleep() causes a panic if this driver is linked to the kernel, ! 2322: * even though this routine is called only via ssload(). ! 2323: */ ! 2324: static void ssdelay(ticks) ! 2325: int ticks; ! 2326: { ! 2327: #if 0 ! 2328: timeout(&delay_tim, ticks, wakeup, (int)&delay_tim); ! 2329: sleep((char *)&delay_tim, CVPAUSE, IVPAUSE, SVPAUSE); ! 2330: #else ! 2331: int i, j; ! 2332: ! 2333: for (i = 0; i < ticks; i++) ! 2334: for (j = 0; j < LOAD_DELAY; j++); ! 2335: #endif ! 2336: } ! 2337: ! 2338: /* ! 2339: * init_call() ! 2340: * ! 2341: * Call SCSI command function during initialization, with error recovery. ! 2342: * If the simple command fails, try a Bus Device Reset, then SCSI Bus reset. ! 2343: */ ! 2344: static int init_call(fn, s_id, buf) ! 2345: int (*fn)(); ! 2346: int s_id; ! 2347: unchar * buf; ! 2348: { ! 2349: int ret = 1; ! 2350: int i; ! 2351: int o_id; ! 2352: int s; ! 2353: s=sphi(); ! 2354: for (i = 0; i < 2; i++) { ! 2355: o_id = chk_reconn(); ! 2356: if (o_id != -1) ! 2357: dummy_reconn(s_id); ! 2358: if ((*fn)(s_id, buf)) ! 2359: goto init_call_done; ! 2360: ! 2361: req_sense(s_id); ! 2362: if ((*fn)(s_id, buf)) ! 2363: goto init_call_done; ! 2364: ! 2365: if (bus_dev_reset(s_id)) { ! 2366: ssdelay(RESET_TICKS); ! 2367: req_sense(s_id); ! 2368: if ((*fn)(s_id, buf)) ! 2369: goto init_call_done; ! 2370: } ! 2371: ! 2372: scsireset(); ! 2373: req_sense(s_id); ! 2374: if ((*fn)(s_id, buf)) ! 2375: goto init_call_done; ! 2376: } ! 2377: ! 2378: ret = 0; ! 2379: ! 2380: init_call_done: ! 2381: spl(s); ! 2382: return ret; ! 2383: } ! 2384: ! 2385: /* ! 2386: * xpmod() ! 2387: * ! 2388: * Command/Data and Message bits are swapped on-board (outside the chip) ! 2389: * on older Future Domain host boards. ! 2390: */ ! 2391: static unchar xpmod(oldphase) ! 2392: unchar oldphase; ! 2393: { ! 2394: unchar ret = oldphase; ! 2395: ! 2396: if (swap_status_bits) { ! 2397: ret &= ~(RS_CTRL_DATA | RS_MESSAGE); ! 2398: if (oldphase & RS_MESSAGE) ! 2399: ret |= RS_CTRL_DATA; ! 2400: if (oldphase & RS_CTRL_DATA) ! 2401: ret |= RS_MESSAGE; ! 2402: } ! 2403: return ret; ! 2404: } ! 2405: ! 2406: /* ! 2407: * tbparms() ! 2408: * ! 2409: * If the drive table has already been patched for this SCSI id, do nothing. ! 2410: * Otherwise, given the real-mode drive number (tbnum) and the SCSI id (s_id), ! 2411: * look for drive parameters from tertiary boot, and copy into driver ! 2412: * data block if we find them. ! 2413: */ ! 2414: static void tbparms(tbnum, s_id) ! 2415: int tbnum, s_id; ! 2416: { ! 2417: FIFO *ffp; ! 2418: typed_space *tp; ! 2419: extern typed_space boot_gift; ! 2420: ! 2421: if (drv_parm[s_id].ncyl == 0 ! 2422: && F_NULL != (ffp = fifo_open(&boot_gift, 0))) { ! 2423: ! 2424: if (tp = fifo_read(ffp)) { ! 2425: BIOS_DISK *bdp = (BIOS_DISK *)tp->ts_data; ! 2426: if ((T_BIOS_DISK == tp->ts_type) && ! 2427: (tbnum == bdp->dp_drive) ) { ! 2428: drv_parm[s_id].ncyl = bdp->dp_cylinders; ! 2429: drv_parm[s_id].nhead = bdp->dp_heads; ! 2430: drv_parm[s_id].nspt = bdp->dp_sectors; ! 2431: } ! 2432: } ! 2433: fifo_close(ffp); ! 2434: } ! 2435: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.