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