![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ultra14f.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / isa|
Return to ultra14f.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 ! root 1: /* ! 2: * Ported for use with the UltraStor 14f by Gary Close ([email protected]) ! 3: * Thanks to Julian Elischer for advice and help with this port. ! 4: * ! 5: * Written by Julian Elischer ([email protected]) ! 6: * for TRW Financial Systems for use under the MACH(2.5) operating system. ! 7: * ! 8: * TRW Financial Systems, in accordance with their agreement with Carnegie ! 9: * Mellon University, makes this software available to CMU to distribute ! 10: * or use in any manner that they see fit as long as this message is kept with ! 11: * the software. For this reason TFS also grants any other persons or ! 12: * organisations permission to use or modify this software. ! 13: * ! 14: * TFS supplies this software to be publicly redistributed ! 15: * on the understanding that TFS is not responsible for the correct ! 16: * functioning of this software in any circumstances. ! 17: * ! 18: * ! 19: * PATCHES MAGIC LEVEL PATCH THAT GOT US HERE ! 20: * -------------------- ----- ---------------------- ! 21: * CURRENT PATCH LEVEL: 1 00098 ! 22: * -------------------- ----- ---------------------- ! 23: * ! 24: * 16 Feb 93 Julian Elischer ADDED for SCSI system ! 25: * commenced: Sun Sep 27 18:14:01 PDT 1992 ! 26: */ ! 27: ! 28: #include <sys/types.h> ! 29: #include <uha.h> ! 30: ! 31: #include <sys/param.h> ! 32: #include <sys/systm.h> ! 33: #include <sys/errno.h> ! 34: #include <sys/ioctl.h> ! 35: #include <sys/buf.h> ! 36: #include <sys/proc.h> ! 37: #include <sys/user.h> ! 38: ! 39: #ifdef MACH /* EITHER CMU OR OSF */ ! 40: #include <i386/ipl.h> ! 41: #include <i386at/scsi.h> ! 42: #include <i386at/scsiconf.h> ! 43: ! 44: #ifdef OSF /* OSF ONLY */ ! 45: #include <sys/table.h> ! 46: #include <i386/handler.h> ! 47: #include <i386/dispatcher.h> ! 48: #include <i386/AT386/atbus.h> ! 49: ! 50: #else OSF /* CMU ONLY */ ! 51: #include <i386at/atbus.h> ! 52: #include <i386/pio.h> ! 53: #endif OSF ! 54: #endif MACH /* end of MACH specific */ ! 55: ! 56: #ifdef __386BSD__ /* 386BSD specific */ ! 57: #define isa_dev isa_device ! 58: #define dev_unit id_unit ! 59: #define dev_addr id_iobase ! 60: ! 61: #include <i386/include/pio.h> ! 62: #include <i386/isa/isa_device.h> ! 63: #include <scsi/scsi_all.h> ! 64: #include <scsi/scsiconf.h> ! 65: #endif __386BSD__ ! 66: ! 67: /* */ ! 68: ! 69: #ifdef __386BSD__ ! 70: #ifdef DDB ! 71: int Debugger(); ! 72: #else ! 73: #define Debugger() panic("should call debugger here") ! 74: #endif /*!DDB*/ ! 75: #endif __386BSD__ ! 76: ! 77: #ifdef MACH ! 78: int Debugger(); ! 79: #endif MACH ! 80: ! 81: typedef struct {unsigned char addr[4]; } physaddr; ! 82: typedef struct {unsigned char len[4]; } physlen; ! 83: ! 84: ! 85: #ifdef MACH ! 86: extern physaddr kvtophys(); ! 87: #define PHYSTOKV(x) phystokv(x) ! 88: #define KVTOPHYS(x) kvtophys(x) ! 89: #endif MACH ! 90: ! 91: #ifdef __386BSD__ ! 92: #define PHYSTOKV(x) (x | 0xFE000000) ! 93: #define KVTOPHYS(x) vtophys(x) ! 94: #endif __386BSD__ ! 95: ! 96: extern int delaycount; /* from clock setup code */ ! 97: #define NUM_CONCURRENT 16 /* number of concurrent ops per board */ ! 98: #define UHA_NSEG 33 /* number of dma segments supported */ ! 99: #define FUDGE(X) (X>>1) /* our loops are slower than spinwait() */ ! 100: /* */ ! 101: /************************** board definitions *******************************/ ! 102: /* ! 103: * I/O Port Interface ! 104: */ ! 105: #define UHA_LMASK (0x000) /* local doorbell mask reg */ ! 106: #define UHA_LINT (0x001) /* local doorbell int/stat reg */ ! 107: #define UHA_SMASK (0x002) /* system doorbell mask reg */ ! 108: #define UHA_SINT (0x003) /* system doorbell int/stat reg */ ! 109: #define UHA_ID0 (0x004) /* product id reg 0 */ ! 110: #define UHA_ID1 (0x005) /* product id reg 1 */ ! 111: #define UHA_CONF1 (0x006) /* config reg 1 */ ! 112: #define UHA_CONF2 (0x007) /* config reg 2 */ ! 113: #define UHA_OGM0 (0x008) /* outgoing mail ptr 0 least sig */ ! 114: #define UHA_OGM1 (0x009) /* outgoing mail ptr 1 least mid */ ! 115: #define UHA_OGM2 (0x00a) /* outgoing mail ptr 2 most mid */ ! 116: #define UHA_OGM3 (0x00b) /* outgoing mail ptr 3 most sig */ ! 117: #define UHA_ICM0 (0x00c) /* incoming mail ptr 0 */ ! 118: #define UHA_ICM1 (0x00d) /* incoming mail ptr 1 */ ! 119: #define UHA_ICM2 (0x00e) /* incoming mail ptr 2 */ ! 120: #define UHA_ICM3 (0x00f) /* incoming mail ptr 3 */ ! 121: ! 122: /* ! 123: * UHA_LMASK bits (read only) ! 124: */ ! 125: ! 126: #define UHA_LDIE 0x80 /* local doorbell int enabled */ ! 127: #define UHA_SRSTE 0x40 /* soft reset enabled */ ! 128: #define UHA_ABORTEN 0x10 /* abort MSCP enabled */ ! 129: #define UHA_OGMINTEN 0x01 /* outgoing mail interrupt enabled */ ! 130: ! 131: /* ! 132: * UHA_LINT bits (read) ! 133: */ ! 134: ! 135: #define UHA_LDIP 0x80 /* local doorbell int pending */ ! 136: ! 137: /* ! 138: * UHA_LINT bits (write) ! 139: */ ! 140: ! 141: #define UHA_ADRST 0x40 /* adapter soft reset */ ! 142: #define UHA_SBRST 0x20 /* scsi bus reset */ ! 143: #define UHA_ASRST 0x60 /* adapter and scsi reset */ ! 144: #define UHA_ABORT 0x10 /* abort MSCP */ ! 145: #define UHA_OGMINT 0x01 /* tell adapter to get mail */ ! 146: ! 147: /* ! 148: * UHA_SMASK bits (read) ! 149: */ ! 150: ! 151: #define UHA_SINTEN 0x80 /* system doorbell interupt Enabled */ ! 152: #define UHA_ABORT_COMPLETE_EN 0x10 /* abort MSCP command complete int Enabled */ ! 153: #define UHA_ICM_ENABLED 0x01 /* ICM interrupt enabled ! 154: ! 155: /* ! 156: * UHA_SMASK bits (write) ! 157: */ ! 158: ! 159: #define UHA_ENSINT 0x80 /* enable system doorbell interrupt */ ! 160: #define UHA_EN_ABORT_COMPLETE 0x10 /* enable abort MSCP complete int */ ! 161: #define UHA_ENICM 0x01 /* enable ICM interrupt */ ! 162: ! 163: /* ! 164: * UHA_SINT bits (read) ! 165: */ ! 166: ! 167: #define UHA_SINTP 0x80 /* system doorbell int pending */ ! 168: #define UHA_ABORT_SUCC 0x10 /* abort MSCP successful */ ! 169: #define UHA_ABORT_FAIL 0x18 /* abort MSCP failed */ ! 170: ! 171: /* ! 172: * UHA_SINT bits (write) ! 173: */ ! 174: ! 175: #define UHA_ABORT_ACK 0x18 /* acknowledge status and clear */ ! 176: #define UHA_ICM_ACK 0x01 /* acknowledge ICM and clear */ ! 177: ! 178: /* ! 179: * UHA_CONF1 bits (read only) ! 180: */ ! 181: ! 182: #define UHA_DMA_CH5 0x00 /* DMA channel 5 */ ! 183: #define UHA_DMA_CH6 0x40 /* 6 */ ! 184: #define UHA_DMA_CH7 0x80 /* 7 */ ! 185: #define UHA_IRQ15 0x00 /* IRQ 15 */ ! 186: #define UHA_IRQ14 0x10 /* 14 */ ! 187: #define UHA_IRQ11 0x20 /* 11 */ ! 188: #define UHA_IRQ10 0x30 /* 10 */ ! 189: ! 190: /*********************************** ! 191: * ha_status error codes ! 192: \***********************************/ ! 193: ! 194: #define UHA_NO_ERR 0x00 /* No error supposedly */ ! 195: #define UHA_SBUS_ABORT_ERR 0x84 /* scsi bus abort error */ ! 196: #define UHA_SBUS_TIMEOUT 0x91 /* scsi bus selection timeout */ ! 197: #define UHA_SBUS_OVER_UNDER 0x92 /* scsi bus over/underrun */ ! 198: #define UHA_BAD_SCSI_CMD 0x96 /* illegal scsi command */ ! 199: #define UHA_AUTO_SENSE_ERR 0x9b /* auto request sense err */ ! 200: #define UHA_SBUS_RES_ERR 0xa3 /* scsi bus reset error */ ! 201: #define UHA_BAD_SG_LIST 0xff /* invalid scatter gath list */ ! 202: ! 203: /* */ ! 204: ! 205: struct uha_dma_seg ! 206: { ! 207: physaddr addr; ! 208: physlen len; ! 209: }; ! 210: /* */ ! 211: ! 212: struct mscp ! 213: { ! 214: unsigned char opcode:3; ! 215: #define U14_HAC 0x01 /*host adapter command*/ ! 216: #define U14_TSP 0x02 /*target scsi pass through command*/ ! 217: #define U14_SDR 0x04 /*scsi device reset*/ ! 218: unsigned char xdir:2; /*xfer direction*/ ! 219: #define U14_SDET 0x00 /*determined by scsi command*/ ! 220: #define U14_SDIN 0x01 /*scsi data in*/ ! 221: #define U14_SDOUT 0x02 /*scsi data out*/ ! 222: #define U14_NODATA 0x03 /*no data xfer*/ ! 223: unsigned char dcn:1; /*disable disconnect for this command*/ ! 224: unsigned char ca:1; /*Cache control*/ ! 225: unsigned char sgth:1; /*scatter gather flag*/ ! 226: unsigned char target:3; ! 227: unsigned char chan:2; /*scsi channel (always 0 for 14f)*/ ! 228: unsigned char lun:3; ! 229: physaddr data; ! 230: physlen datalen; ! 231: physaddr link; ! 232: unsigned char link_id; ! 233: unsigned char sg_num; /*number of scat gath segs */ ! 234: /*in s-g list if sg flag is*/ ! 235: /*set. starts at 1, 8bytes per*/ ! 236: unsigned char senselen; ! 237: unsigned char cdblen; ! 238: unsigned char cdb[12]; ! 239: unsigned char ha_status; ! 240: unsigned char targ_status; ! 241: physaddr sense; /* if 0 no auto sense */ ! 242: /*-----------------end of hardware supported fields----------------*/ ! 243: struct mscp *next; /* in free list */ ! 244: struct scsi_xfer *xs; /* the scsi_xfer for this cmd */ ! 245: long int delta; /* difference from previous*/ ! 246: struct mscp *later,*sooner; ! 247: int flags; ! 248: #define MSCP_FREE 0 ! 249: #define MSCP_ACTIVE 1 ! 250: #define MSCP_ABORTED 2 ! 251: struct uha_dma_seg uha_dma[UHA_NSEG]; ! 252: struct scsi_sense_data mscp_sense; ! 253: }; ! 254: ! 255: struct mscp *uha_soonest = (struct mscp *)0; ! 256: struct mscp *uha_latest = (struct mscp *)0; ! 257: long int uha_furtherest = 0; /* longest time in the timeout queue */ ! 258: /* */ ! 259: ! 260: struct uha_data ! 261: { ! 262: int flags; ! 263: #define UHA_INIT 0x01; ! 264: int baseport; ! 265: struct mscp mscps[NUM_CONCURRENT]; ! 266: struct mscp *free_mscp; ! 267: int our_id; /* our scsi id */ ! 268: int vect; ! 269: int dma; ! 270: } uha_data[NUHA]; ! 271: ! 272: int uhaprobe(); ! 273: int uha_attach(); ! 274: int uhaintr(); ! 275: int uha_scsi_cmd(); ! 276: int uha_timeout(); ! 277: int uha_abort(); ! 278: struct mscp *cheat; ! 279: void uhaminphys(); ! 280: long int uha_adapter_info(); ! 281: ! 282: unsigned long int scratch; ! 283: ! 284: #ifdef MACH ! 285: struct isa_driver uhadriver = { uhaprobe, 0, uha_attach, "uha", 0, 0, 0}; ! 286: int (*uhaintrs[])() = {uhaintr, 0}; ! 287: #endif MACH ! 288: ! 289: #ifdef __386BSD__ ! 290: struct isa_driver uhadriver = { uhaprobe, uha_attach, "uha"}; ! 291: #endif __386BSD__ ! 292: ! 293: static uha_unit = 0; ! 294: int uha_debug = 0; ! 295: #define UHA_SHOWMSCPS 0x01 ! 296: #define UHA_SHOWINTS 0x02 ! 297: #define UHA_SHOWCMDS 0x04 ! 298: #define UHA_SHOWMISC 0x08 ! 299: #define FAIL 1 ! 300: #define SUCCESS 0 ! 301: #define PAGESIZ 4096 ! 302: ! 303: struct scsi_switch uha_switch = ! 304: { ! 305: uha_scsi_cmd, ! 306: uhaminphys, ! 307: 0, ! 308: 0, ! 309: uha_adapter_info, ! 310: 0,0,0 ! 311: }; ! 312: ! 313: /* */ ! 314: /***********************************************************************\ ! 315: * Function to send a command out through a mailbox * ! 316: \***********************************************************************/ ! 317: uha_send_mbox( int unit ! 318: ,struct mscp *mscp) ! 319: { ! 320: int port = uha_data[unit].baseport; ! 321: int spincount = FUDGE(delaycount) * 1; /* 1ms should be enough */ ! 322: int s = splbio(); ! 323: ! 324: while( ((inb(port + UHA_LINT) & (UHA_LDIP)) ! 325: != (0)) ! 326: && (spincount--)); ! 327: if(spincount == -1) ! 328: { ! 329: printf("uha%d: board not responding\n",unit); ! 330: Debugger(); ! 331: } ! 332: ! 333: outl(port + UHA_OGM0,KVTOPHYS(mscp)); ! 334: outb(port + UHA_LINT, (UHA_OGMINT)); ! 335: splx(s); ! 336: } ! 337: ! 338: /***********************************************************************\ ! 339: * Function to send abort to 14f * ! 340: \***********************************************************************/ ! 341: ! 342: uha_abort( int unit ! 343: ,struct mscp *mscp) ! 344: { ! 345: int port = uha_data[unit].baseport; ! 346: int spincount = FUDGE(delaycount) * 1; ! 347: int abortcount = FUDGE(delaycount) * 2000; ! 348: int s = splbio(); ! 349: ! 350: while(((inb(port + UHA_LINT) & (UHA_LDIP)) ! 351: != (0)) ! 352: && (spincount--)); ! 353: if(spincount == -1); ! 354: { ! 355: printf("uha%d: board not responding\n",unit); ! 356: Debugger(); ! 357: } ! 358: ! 359: outl(port + UHA_OGM0,KVTOPHYS(mscp)); ! 360: outb(port + UHA_LINT,UHA_ABORT); ! 361: ! 362: while((abortcount--) && (!(inb(port + UHA_SINT) & UHA_ABORT_FAIL))); ! 363: if(abortcount == -1) ! 364: { ! 365: printf("uha%d: board not responding\n",unit); ! 366: Debugger(); ! 367: } ! 368: if((inb(port + UHA_SINT) & 0x10) != 0) ! 369: { ! 370: outb(port + UHA_SINT,UHA_ABORT_ACK); ! 371: return(1); ! 372: } ! 373: else ! 374: { ! 375: outb(port + UHA_SINT,UHA_ABORT_ACK); ! 376: return(0); ! 377: } ! 378: } ! 379: ! 380: /***********************************************************************\ ! 381: * Function to poll for command completion when in poll mode * ! 382: \***********************************************************************/ ! 383: uha_poll(int unit ,int wait) /* in msec */ ! 384: { ! 385: int port = uha_data[unit].baseport; ! 386: int spincount = FUDGE(delaycount) * wait; /* in msec */ ! 387: int stport = port + UHA_SINT; ! 388: int start = spincount; ! 389: ! 390: retry: ! 391: while( (spincount--) && (!(inb(stport) & UHA_SINTP))); ! 392: if(spincount == -1) ! 393: { ! 394: printf("uha%d: board not responding\n",unit); ! 395: return(EIO); ! 396: } ! 397: if ((int)cheat != PHYSTOKV(inl(port + UHA_ICM0))) ! 398: { ! 399: printf("discarding %x ",inl(port + UHA_ICM0)); ! 400: outb(port + UHA_SINT, UHA_ICM_ACK); ! 401: spinwait(50); ! 402: goto retry; ! 403: }/* don't know this will work */ ! 404: uhaintr(unit); ! 405: return(0); ! 406: } ! 407: ! 408: /*******************************************************\ ! 409: * Check if the device can be found at the port given * ! 410: * and if so, set it up ready for further work * ! 411: * as an argument, takes the isa_dev structure from * ! 412: * autoconf.c * ! 413: \*******************************************************/ ! 414: uhaprobe(dev) ! 415: struct isa_dev *dev; ! 416: { ! 417: int unit = uha_unit; ! 418: dev->dev_unit = unit; ! 419: uha_data[unit].baseport = dev->dev_addr; ! 420: if(unit >= NUHA) ! 421: { ! 422: printf("uha: unit number (%d) too high\n",unit); ! 423: return(0); ! 424: } ! 425: ! 426: /*try and initialize unit at this location*/ ! 427: if (uha_init(unit) != 0) ! 428: { ! 429: return(0); ! 430: } ! 431: ! 432: /* if its there put in it's interrupt and DRQ vectors */ ! 433: ! 434: dev->id_irq = (1 << uha_data[unit].vect); ! 435: dev->id_drq = uha_data[unit].dma; ! 436: ! 437: ! 438: uha_unit ++; ! 439: return(1); ! 440: } ! 441: ! 442: /***********************************************\ ! 443: * Attach all the sub-devices we can find * ! 444: \***********************************************/ ! 445: uha_attach(dev) ! 446: struct isa_dev *dev; ! 447: { ! 448: int unit = dev->dev_unit; ! 449: ! 450: ! 451: #ifdef __386BSD__ ! 452: printf("uha%d: probing for scsi devices..", unit); ! 453: #endif __386BSD__ ! 454: ! 455: /***********************************************\ ! 456: * ask the adapter what subunits are present * ! 457: \***********************************************/ ! 458: scsi_attachdevs( unit, uha_data[unit].our_id, &uha_switch); ! 459: ! 460: #if defined(OSF) ! 461: uha_attached[unit]=1; ! 462: #endif /* defined(OSF) */ ! 463: if(!unit) /* only one for all boards */ ! 464: { ! 465: uha_timeout(0); ! 466: } ! 467: return; ! 468: } ! 469: ! 470: /***********************************************\ ! 471: * Return some information to the caller about * ! 472: * the adapter and it's capabilities * ! 473: \***********************************************/ ! 474: long int uha_adapter_info(unit) ! 475: int unit; ! 476: { ! 477: return(2); /* 2 outstanding requests at a time per device */ ! 478: } ! 479: ! 480: /***********************************************\ ! 481: * Catch an interrupt from the adaptor * ! 482: \***********************************************/ ! 483: uhaintr(unit) ! 484: { ! 485: struct mscp *mscp; ! 486: u_char uhastat; ! 487: unsigned long int mboxval; ! 488: ! 489: int port = uha_data[unit].baseport; ! 490: ! 491: ! 492: if(scsi_debug & PRINTROUTINES) ! 493: printf("uhaintr "); ! 494: ! 495: #if defined(OSF) ! 496: if (!uha_attached[unit]) ! 497: { ! 498: return(1); ! 499: } ! 500: #endif /* defined(OSF) */ ! 501: while(inb(port + UHA_SINT) & UHA_SINTP) ! 502: { ! 503: /***********************************************\ ! 504: * First get all the information and then * ! 505: * acknowlege the interrupt * ! 506: \***********************************************/ ! 507: uhastat = inb(port + UHA_SINT); ! 508: mboxval = inl(port + UHA_ICM0); ! 509: outb(port + UHA_SINT,UHA_ICM_ACK); ! 510: ! 511: if(scsi_debug & TRACEINTERRUPTS) ! 512: printf("status = 0x%x ",uhastat); ! 513: /***********************************************\ ! 514: * Process the completed operation * ! 515: \***********************************************/ ! 516: ! 517: mscp = (struct mscp *)(PHYSTOKV(mboxval)); ! 518: ! 519: if(uha_debug & UHA_SHOWCMDS ) ! 520: { ! 521: uha_show_scsi_cmd(mscp->xs); ! 522: } ! 523: if((uha_debug & UHA_SHOWMSCPS) && mscp) ! 524: printf("<int mscp(%x)>",mscp); ! 525: uha_remove_timeout(mscp); ! 526: ! 527: uha_done(unit,mscp); ! 528: } ! 529: return(1); ! 530: } ! 531: ! 532: /***********************************************\ ! 533: * We have a mscp which has been processed by the * ! 534: * adaptor, now we look to see how the operation * ! 535: * went. * ! 536: \***********************************************/ ! 537: ! 538: uha_done(unit,mscp) ! 539: int unit; ! 540: struct mscp *mscp; ! 541: { ! 542: struct scsi_sense_data *s1,*s2; ! 543: struct scsi_xfer *xs = mscp->xs; ! 544: ! 545: if(scsi_debug & (PRINTROUTINES | TRACEINTERRUPTS)) ! 546: printf("uha_done "); ! 547: /***********************************************\ ! 548: * Otherwise, put the results of the operation * ! 549: * into the xfer and call whoever started it * ! 550: \***********************************************/ ! 551: if ( (mscp->ha_status == UHA_NO_ERR) || (xs->flags & SCSI_ERR_OK)) ! 552: { /* All went correctly OR errors expected */ ! 553: xs->resid = 0; ! 554: xs->error = 0; ! 555: } ! 556: else ! 557: { ! 558: ! 559: s1 = &(mscp->mscp_sense); ! 560: s2 = &(xs->sense); ! 561: ! 562: if(mscp->ha_status != UHA_NO_ERR) ! 563: { ! 564: switch(mscp->ha_status) ! 565: { ! 566: case UHA_SBUS_TIMEOUT: /* No response */ ! 567: if (uha_debug & UHA_SHOWMISC) ! 568: { ! 569: printf("timeout reported back\n"); ! 570: } ! 571: xs->error = XS_TIMEOUT; ! 572: break; ! 573: case UHA_SBUS_OVER_UNDER: ! 574: if (uha_debug & UHA_SHOWMISC) ! 575: { ! 576: printf("scsi bus xfer over/underrun\n"); ! 577: } ! 578: xs->error = XS_DRIVER_STUFFUP; ! 579: break; ! 580: case UHA_BAD_SG_LIST: ! 581: if (uha_debug & UHA_SHOWMISC) ! 582: { ! 583: printf("bad sg list reported back\n"); ! 584: } ! 585: xs->error = XS_DRIVER_STUFFUP; ! 586: break; ! 587: default: /* Other scsi protocol messes */ ! 588: xs->error = XS_DRIVER_STUFFUP; ! 589: if (uha_debug & UHA_SHOWMISC) ! 590: { ! 591: printf("unexpected ha_status: %x\n", ! 592: mscp->ha_status); ! 593: } ! 594: } ! 595: ! 596: } ! 597: else ! 598: { ! 599: ! 600: if (mscp->targ_status != 0) ! 601: /**************************************************************************\ ! 602: * I have no information for any possible value of target status field * ! 603: * other than 0 means no error!! So I guess any error is unexpected in that * ! 604: * event!! * ! 605: \**************************************************************************/ ! 606: ! 607: { ! 608: if (uha_debug & UHA_SHOWMISC) ! 609: { ! 610: printf("unexpected targ_status: %x\n", ! 611: mscp->targ_status); ! 612: } ! 613: xs->error = XS_DRIVER_STUFFUP; ! 614: } ! 615: } ! 616: } ! 617: done: xs->flags |= ITSDONE; ! 618: uha_free_mscp(unit,mscp, xs->flags); ! 619: if(xs->when_done) ! 620: (*(xs->when_done))(xs->done_arg,xs->done_arg2); ! 621: } ! 622: ! 623: /***********************************************\ ! 624: * A mscp (and hence a mbx-out is put onto the * ! 625: * free list. * ! 626: \***********************************************/ ! 627: uha_free_mscp(unit,mscp, flags) ! 628: struct mscp *mscp; ! 629: { ! 630: unsigned int opri; ! 631: ! 632: if(scsi_debug & PRINTROUTINES) ! 633: printf("mscp%d(0x%x)> ",unit,flags); ! 634: if (!(flags & SCSI_NOMASK)) ! 635: opri = splbio(); ! 636: ! 637: mscp->next = uha_data[unit].free_mscp; ! 638: uha_data[unit].free_mscp = mscp; ! 639: mscp->flags = MSCP_FREE; ! 640: /***********************************************\ ! 641: * If there were none, wake abybody waiting for * ! 642: * one to come free, starting with queued entries* ! 643: \***********************************************/ ! 644: if (!mscp->next) { ! 645: wakeup(&uha_data[unit].free_mscp); ! 646: } ! 647: if (!(flags & SCSI_NOMASK)) ! 648: splx(opri); ! 649: } ! 650: ! 651: /***********************************************\ ! 652: * Get a free mscp (and hence mbox-out entry) * ! 653: \***********************************************/ ! 654: struct mscp * ! 655: uha_get_mscp(unit,flags) ! 656: { ! 657: unsigned opri; ! 658: struct mscp *rc; ! 659: ! 660: if(scsi_debug & PRINTROUTINES) ! 661: printf("<mscp%d(0x%x) ",unit,flags); ! 662: if (!(flags & SCSI_NOMASK)) ! 663: opri = splbio(); ! 664: /***********************************************\ ! 665: * If we can and have to, sleep waiting for one * ! 666: * to come free * ! 667: \***********************************************/ ! 668: while ((!(rc = uha_data[unit].free_mscp)) && (!(flags & SCSI_NOSLEEP))) ! 669: { ! 670: sleep(&uha_data[unit].free_mscp, PRIBIO); ! 671: } ! 672: if (rc) ! 673: { ! 674: uha_data[unit].free_mscp = rc->next; ! 675: rc->flags = MSCP_ACTIVE; ! 676: } ! 677: if (!(flags & SCSI_NOMASK)) ! 678: splx(opri); ! 679: return(rc); ! 680: } ! 681: ! 682: ! 683: ! 684: /***********************************************\ ! 685: * Start the board, ready for normal operation * ! 686: \***********************************************/ ! 687: ! 688: uha_init(unit) ! 689: int unit; ! 690: { ! 691: unsigned char ad[4]; ! 692: volatile unsigned char model; ! 693: volatile unsigned char submodel; ! 694: unsigned char config_reg1; ! 695: unsigned char config_reg2; ! 696: unsigned char dma_ch; ! 697: unsigned char irq_ch; ! 698: unsigned char uha_id; ! 699: int port = uha_data[unit].baseport; ! 700: int i; ! 701: int resetcount = FUDGE(delaycount) * 4000; ! 702: ! 703: model = inb(port + UHA_ID0); ! 704: submodel = inb(port + UHA_ID1); ! 705: if ((model != 0x56) & (submodel != 0x40)) ! 706: { /* printf("ultrastor 14f not responding\n"); */ ! 707: return(ENXIO); } ! 708: ! 709: printf("uha%d reading board settings, ",unit); ! 710: ! 711: config_reg1 = inb(port + UHA_CONF1); ! 712: config_reg2 = inb(port + UHA_CONF2); ! 713: dma_ch = (config_reg1 & 0xc0); ! 714: irq_ch = (config_reg1 & 0x30); ! 715: uha_id = (config_reg2 & 0x07); ! 716: ! 717: switch(dma_ch) ! 718: { ! 719: case UHA_DMA_CH5: ! 720: uha_data[unit].dma = 5; ! 721: printf("dma=5 "); ! 722: break; ! 723: case UHA_DMA_CH6: ! 724: uha_data[unit].dma = 6; ! 725: printf("dma=6 "); ! 726: break; ! 727: case UHA_DMA_CH7: ! 728: uha_data[unit].dma = 7; ! 729: printf("dma=7 "); ! 730: break; ! 731: default: ! 732: printf("illegal dma jumper setting\n"); ! 733: return(EIO); ! 734: } ! 735: switch(irq_ch) ! 736: { ! 737: case UHA_IRQ10: ! 738: uha_data[unit].vect = 10; ! 739: printf("int=10 "); ! 740: break; ! 741: case UHA_IRQ11: ! 742: uha_data[unit].vect = 11; ! 743: printf("int=11 "); ! 744: break; ! 745: case UHA_IRQ14: ! 746: uha_data[unit].vect = 14; ! 747: printf("int=14 "); ! 748: break; ! 749: case UHA_IRQ15: ! 750: uha_data[unit].vect = 15; ! 751: printf("int=15 "); ! 752: break; ! 753: default: ! 754: printf("illegal int jumper setting\n"); ! 755: return(EIO); ! 756: } ! 757: /* who are we on the scsi bus */ ! 758: printf("id=%x\n",uha_id); ! 759: uha_data[unit].our_id = uha_id; ! 760: ! 761: ! 762: /***********************************************\ ! 763: * link up all our MSCPs into a free list * ! 764: \***********************************************/ ! 765: for (i=0; i < NUM_CONCURRENT; i++) ! 766: { ! 767: uha_data[unit].mscps[i].next = uha_data[unit].free_mscp; ! 768: uha_data[unit].free_mscp = &uha_data[unit].mscps[i]; ! 769: uha_data[unit].free_mscp->flags = MSCP_FREE; ! 770: } ! 771: ! 772: /***********************************************\ ! 773: * Note that we are going and return (to probe) * ! 774: \***********************************************/ ! 775: outb(port + UHA_LINT, UHA_ASRST); ! 776: while( (resetcount--) && (!(inb(port + UHA_LINT)))); ! 777: if(resetcount == -1) ! 778: { ! 779: printf("uha%d: board timed out during reset\n",unit); ! 780: return(ENXIO); ! 781: } ! 782: ! 783: outb(port + UHA_SMASK, 0x81); /* make sure interrupts are enabled */ ! 784: uha_data[unit].flags |= UHA_INIT; ! 785: return(0); ! 786: } ! 787: ! 788: ! 789: ! 790: #ifndef min ! 791: #define min(x,y) (x < y ? x : y) ! 792: #endif min ! 793: ! 794: ! 795: void uhaminphys(bp) ! 796: struct buf *bp; ! 797: { ! 798: #ifdef MACH ! 799: #if !defined(OSF) ! 800: bp->b_flags |= B_NPAGES; /* can support scat/gather */ ! 801: #endif /* defined(OSF) */ ! 802: #endif MACH ! 803: if(bp->b_bcount > ((UHA_NSEG-1) * PAGESIZ)) ! 804: { ! 805: bp->b_bcount = ((UHA_NSEG-1) * PAGESIZ); ! 806: } ! 807: } ! 808: ! 809: /***********************************************\ ! 810: * start a scsi operation given the command and * ! 811: * the data address. Also needs the unit, target * ! 812: * and lu * ! 813: \***********************************************/ ! 814: int uha_scsi_cmd(xs) ! 815: struct scsi_xfer *xs; ! 816: { ! 817: struct scsi_sense_data *s1,*s2; ! 818: struct mscp *mscp; ! 819: struct uha_dma_seg *sg; ! 820: int seg; /* scatter gather seg being worked on */ ! 821: int i = 0; ! 822: int rc = 0; ! 823: int thiskv; ! 824: unsigned long int thisphys,nextphys; ! 825: int unit =xs->adapter; ! 826: int bytes_this_seg,bytes_this_page,datalen,flags; ! 827: struct iovec *iovp; ! 828: int s; ! 829: unsigned int stat; ! 830: int port = uha_data[unit].baseport; ! 831: unsigned long int templen; ! 832: ! 833: ! 834: if(scsi_debug & PRINTROUTINES) ! 835: printf("uha_scsi_cmd "); ! 836: /***********************************************\ ! 837: * get a mscp (mbox-out) to use. If the transfer * ! 838: * is from a buf (possibly from interrupt time) * ! 839: * then we can't allow it to sleep * ! 840: \***********************************************/ ! 841: flags = xs->flags; ! 842: if(xs->bp) flags |= (SCSI_NOSLEEP); /* just to be sure */ ! 843: if(flags & ITSDONE) ! 844: { ! 845: printf("Already done?"); ! 846: xs->flags &= ~ITSDONE; ! 847: } ! 848: if(!(flags & INUSE)) ! 849: { ! 850: printf("Not in use?"); ! 851: xs->flags |= INUSE; ! 852: } ! 853: if (!(mscp = uha_get_mscp(unit,flags))) ! 854: { ! 855: xs->error = XS_DRIVER_STUFFUP; ! 856: return(TRY_AGAIN_LATER); ! 857: } ! 858: ! 859: cheat = mscp; ! 860: if(uha_debug & UHA_SHOWMSCPS) ! 861: printf("<start mscp(%x)>",mscp); ! 862: if(scsi_debug & SHOWCOMMANDS) ! 863: { ! 864: uha_show_scsi_cmd(xs); ! 865: } ! 866: mscp->xs = xs; ! 867: /***********************************************\ ! 868: * Put all the arguments for the xfer in the mscp * ! 869: \***********************************************/ ! 870: ! 871: if (flags & SCSI_RESET) ! 872: { ! 873: mscp->opcode = 0x04; ! 874: mscp->ca = 0x01; ! 875: } ! 876: else ! 877: { ! 878: mscp->opcode = 0x02; ! 879: mscp->ca = 0x01; ! 880: } ! 881: ! 882: if (flags & SCSI_DATA_IN) ! 883: { ! 884: mscp->xdir = 0x01; ! 885: } ! 886: if (flags & SCSI_DATA_OUT) ! 887: { ! 888: mscp->xdir = 0x02; ! 889: } ! 890: ! 891: if (xs->lu != 0) ! 892: { ! 893: xs->error = XS_DRIVER_STUFFUP; ! 894: uha_free_mscp(unit,mscp,flags); ! 895: return(HAD_ERROR); ! 896: } ! 897: ! 898: mscp->dcn = 0x00; ! 899: mscp->chan = 0x00; ! 900: mscp->target = xs->targ; ! 901: mscp->lun = xs->lu; ! 902: mscp->link.addr[0] = 0x00; ! 903: mscp->link.addr[1] = 0x00; ! 904: mscp->link.addr[2] = 0x00; ! 905: mscp->link.addr[3] = 0x00; ! 906: mscp->link_id = 0x00; ! 907: mscp->cdblen = xs->cmdlen; ! 908: scratch = KVTOPHYS(&(mscp->mscp_sense)); ! 909: mscp->sense.addr[0] = (scratch & 0xff); ! 910: mscp->sense.addr[1] = ((scratch >> 8) & 0xff); ! 911: mscp->sense.addr[2] = ((scratch >> 16) & 0xff); ! 912: mscp->sense.addr[3] = ((scratch >> 24) & 0xff); ! 913: mscp->senselen = sizeof(mscp->mscp_sense); ! 914: mscp->ha_status = 0x00; ! 915: mscp->targ_status = 0x00; ! 916: ! 917: if(xs->datalen) ! 918: { /* should use S/G only if not zero length */ ! 919: scratch = KVTOPHYS(mscp->uha_dma); ! 920: mscp->data.addr[0] = (scratch & 0xff); ! 921: mscp->data.addr[1] = ((scratch >> 8) & 0xff); ! 922: mscp->data.addr[2] = ((scratch >> 16) & 0xff); ! 923: mscp->data.addr[3] = ((scratch >> 24) & 0xff); ! 924: sg = mscp->uha_dma ; ! 925: seg = 0; ! 926: mscp->sgth = 0x01; ! 927: ! 928: if(flags & SCSI_DATA_UIO) ! 929: { ! 930: iovp = ((struct uio *)xs->data)->uio_iov; ! 931: datalen = ((struct uio *)xs->data)->uio_iovcnt; ! 932: xs->datalen = 0; ! 933: while ((datalen) && (seg < UHA_NSEG)) ! 934: { ! 935: scratch = (unsigned long)iovp->iov_base; ! 936: sg->addr.addr[0] = (scratch & 0xff); ! 937: sg->addr.addr[1] = ((scratch >> 8) & 0xff); ! 938: sg->addr.addr[2] = ((scratch >> 16) & 0xff); ! 939: sg->addr.addr[3] = ((scratch >> 24) & 0xff); ! 940: xs->datalen += *(unsigned long *)sg->len.len = iovp->iov_len; ! 941: if(scsi_debug & SHOWSCATGATH) ! 942: printf("(0x%x@0x%x)" ! 943: ,iovp->iov_len ! 944: ,iovp->iov_base); ! 945: sg++; ! 946: iovp++; ! 947: seg++; ! 948: datalen--; ! 949: } ! 950: } ! 951: else ! 952: { ! 953: /***********************************************\ ! 954: * Set up the scatter gather block * ! 955: \***********************************************/ ! 956: ! 957: if(scsi_debug & SHOWSCATGATH) ! 958: printf("%d @0x%x:- ",xs->datalen,xs->data); ! 959: datalen = xs->datalen; ! 960: thiskv = (int)xs->data; ! 961: thisphys = KVTOPHYS(thiskv); ! 962: templen = 0; ! 963: ! 964: while ((datalen) && (seg < UHA_NSEG)) ! 965: { ! 966: bytes_this_seg = 0; ! 967: ! 968: /* put in the base address */ ! 969: sg->addr.addr[0] = (thisphys & 0xff); ! 970: sg->addr.addr[1] = ((thisphys >> 8) & 0xff); ! 971: sg->addr.addr[2] = ((thisphys >> 16) & 0xff); ! 972: sg->addr.addr[3] = ((thisphys >> 24) & 0xff); ! 973: ! 974: if(scsi_debug & SHOWSCATGATH) ! 975: printf("0x%x",thisphys); ! 976: ! 977: /* do it at least once */ ! 978: nextphys = thisphys; ! 979: while ((datalen) && (thisphys == nextphys)) ! 980: /*********************************************\ ! 981: * This page is contiguous (physically) with * ! 982: * the the last, just extend the length * ! 983: \*********************************************/ ! 984: { ! 985: /* how far to the end of the page */ ! 986: nextphys = (thisphys & (~(PAGESIZ - 1))) ! 987: + PAGESIZ; ! 988: bytes_this_page = nextphys - thisphys; ! 989: /**** or the data ****/ ! 990: bytes_this_page = min(bytes_this_page ! 991: ,datalen); ! 992: bytes_this_seg += bytes_this_page; ! 993: datalen -= bytes_this_page; ! 994: ! 995: /* get more ready for the next page */ ! 996: thiskv = (thiskv & (~(PAGESIZ - 1))) ! 997: + PAGESIZ; ! 998: if(datalen) ! 999: thisphys = KVTOPHYS(thiskv); ! 1000: } ! 1001: /********************************************\ ! 1002: * next page isn't contiguous, finish the seg * ! 1003: \********************************************/ ! 1004: if(scsi_debug & SHOWSCATGATH) ! 1005: printf("(0x%x)",bytes_this_seg); ! 1006: sg->len.len[0] = (bytes_this_seg & 0xff); ! 1007: sg->len.len[1] = ((bytes_this_seg >> 8) & 0xff); ! 1008: sg->len.len[2] = ((bytes_this_seg >> 16) & 0xff); ! 1009: sg->len.len[3] = ((bytes_this_seg >> 24) & 0xff); ! 1010: templen += bytes_this_seg; ! 1011: sg++; ! 1012: seg++; ! 1013: } ! 1014: } /*end of iov/kv decision */ ! 1015: mscp->datalen.len[0] = (templen & 0xff); ! 1016: mscp->datalen.len[1] = ((templen >> 8) & 0xff); ! 1017: mscp->datalen.len[2] = ((templen >> 16) & 0xff); ! 1018: mscp->datalen.len[3] = ((templen >> 24) & 0xff); ! 1019: mscp->sg_num = seg; ! 1020: ! 1021: if(scsi_debug & SHOWSCATGATH) ! 1022: printf("\n"); ! 1023: if (datalen) ! 1024: { /* there's still data, must have run out of segs! */ ! 1025: printf("uha_scsi_cmd%d: more than %d DMA segs\n", ! 1026: unit,UHA_NSEG); ! 1027: xs->error = XS_DRIVER_STUFFUP; ! 1028: uha_free_mscp(unit,mscp,flags); ! 1029: return(HAD_ERROR); ! 1030: } ! 1031: ! 1032: } ! 1033: else ! 1034: { /* No data xfer, use non S/G values */ ! 1035: mscp->data.addr[0] = 0x00; ! 1036: mscp->data.addr[1] = 0x00; ! 1037: mscp->data.addr[2] = 0x00; ! 1038: mscp->data.addr[3] = 0x00; ! 1039: mscp->datalen.len[0] = 0x00; ! 1040: mscp->datalen.len[1] = 0x00; ! 1041: mscp->datalen.len[2] = 0x00; ! 1042: mscp->datalen.len[3] = 0x00; ! 1043: mscp->xdir = 0x03; ! 1044: mscp->sgth = 0x00; ! 1045: mscp->sg_num = 0x00; ! 1046: } ! 1047: ! 1048: /***********************************************\ ! 1049: * Put the scsi command in the mscp and start it * ! 1050: \***********************************************/ ! 1051: bcopy(xs->cmd, mscp->cdb, xs->cmdlen); ! 1052: ! 1053: /***********************************************\ ! 1054: * Usually return SUCCESSFULLY QUEUED * ! 1055: \***********************************************/ ! 1056: if (!(flags & SCSI_NOMASK)) ! 1057: { ! 1058: s = splbio(); ! 1059: uha_send_mbox(unit,mscp); ! 1060: uha_add_timeout(mscp,xs->timeout); ! 1061: splx(s); ! 1062: if(scsi_debug & TRACEINTERRUPTS) ! 1063: printf("cmd_sent "); ! 1064: return(SUCCESSFULLY_QUEUED); ! 1065: } ! 1066: /***********************************************\ ! 1067: * If we can't use interrupts, poll on completion* ! 1068: \***********************************************/ ! 1069: uha_send_mbox(unit,mscp); ! 1070: if(scsi_debug & TRACEINTERRUPTS) ! 1071: printf("cmd_wait "); ! 1072: do ! 1073: { ! 1074: if(uha_poll(unit,xs->timeout)) ! 1075: { ! 1076: if (!(xs->flags & SCSI_SILENT)) printf("cmd fail\n"); ! 1077: if(!(uha_abort(unit,mscp))) ! 1078: { ! 1079: printf("abort failed in wait\n"); ! 1080: uha_free_mscp(unit,mscp,flags); ! 1081: } ! 1082: xs->error = XS_DRIVER_STUFFUP; ! 1083: splx(s); ! 1084: return(HAD_ERROR); ! 1085: } ! 1086: } while (!(xs->flags & ITSDONE));/* something (?) else finished */ ! 1087: splx(s); ! 1088: scsi_debug = 0;uha_debug = 0; ! 1089: if(xs->error) ! 1090: { ! 1091: return(HAD_ERROR); ! 1092: } ! 1093: return(COMPLETE); ! 1094: } ! 1095: ! 1096: /* ! 1097: * +----------+ +----------+ +----------+ ! 1098: * uha_soonest--->| later |--->| later|--->| later|--->0 ! 1099: * | [Delta] | | [Delta] | | [Delta] | ! 1100: * 0<---|sooner |<---|sooner |<---|sooner |<---uha_latest ! 1101: * +----------+ +----------+ +----------+ ! 1102: * ! 1103: * uha_furtherest = sum(Delta[1..n]) ! 1104: */ ! 1105: uha_add_timeout(mscp,time) ! 1106: struct mscp *mscp; ! 1107: int time; ! 1108: { ! 1109: int timeprev; ! 1110: struct mscp *prev; ! 1111: int s = splbio(); ! 1112: ! 1113: if(prev = uha_latest) /* yes, an assign */ ! 1114: { ! 1115: timeprev = uha_furtherest; ! 1116: } ! 1117: else ! 1118: { ! 1119: timeprev = 0; ! 1120: } ! 1121: while(prev && (timeprev > time)) ! 1122: { ! 1123: timeprev -= prev->delta; ! 1124: prev = prev->sooner; ! 1125: } ! 1126: if(prev) ! 1127: { ! 1128: mscp->delta = time - timeprev; ! 1129: if( mscp->later = prev->later) /* yes an assign */ ! 1130: { ! 1131: mscp->later->sooner = mscp; ! 1132: mscp->later->delta -= mscp->delta; ! 1133: } ! 1134: else ! 1135: { ! 1136: uha_furtherest = time; ! 1137: uha_latest = mscp; ! 1138: } ! 1139: mscp->sooner = prev; ! 1140: prev->later = mscp; ! 1141: } ! 1142: else ! 1143: { ! 1144: if( mscp->later = uha_soonest) /* yes, an assign*/ ! 1145: { ! 1146: mscp->later->sooner = mscp; ! 1147: mscp->later->delta -= time; ! 1148: } ! 1149: else ! 1150: { ! 1151: uha_furtherest = time; ! 1152: uha_latest = mscp; ! 1153: } ! 1154: mscp->delta = time; ! 1155: mscp->sooner = (struct mscp *)0; ! 1156: uha_soonest = mscp; ! 1157: } ! 1158: splx(s); ! 1159: } ! 1160: ! 1161: uha_remove_timeout(mscp) ! 1162: struct mscp *mscp; ! 1163: { ! 1164: int s = splbio(); ! 1165: ! 1166: if(mscp->sooner) ! 1167: { ! 1168: mscp->sooner->later = mscp->later; ! 1169: } ! 1170: else ! 1171: { ! 1172: uha_soonest = mscp->later; ! 1173: } ! 1174: if(mscp->later) ! 1175: { ! 1176: mscp->later->sooner = mscp->sooner; ! 1177: mscp->later->delta += mscp->delta; ! 1178: } ! 1179: else ! 1180: { ! 1181: uha_latest = mscp->sooner; ! 1182: uha_furtherest -= mscp->delta; ! 1183: } ! 1184: mscp->sooner = mscp->later = (struct mscp *)0; ! 1185: splx(s); ! 1186: } ! 1187: ! 1188: ! 1189: extern int hz; ! 1190: #define ONETICK 500 /* milliseconds */ ! 1191: #define SLEEPTIME ((hz * 1000) / ONETICK) ! 1192: uha_timeout(arg) ! 1193: int arg; ! 1194: { ! 1195: struct mscp *mscp; ! 1196: int unit; ! 1197: int s = splbio(); ! 1198: unsigned int stat; ! 1199: int port = uha_data[unit].baseport; ! 1200: ! 1201: while( mscp = uha_soonest ) ! 1202: { ! 1203: if(mscp->delta <= ONETICK) ! 1204: /***********************************************\ ! 1205: * It has timed out, we need to do some work * ! 1206: \***********************************************/ ! 1207: { ! 1208: unit = mscp->xs->adapter; ! 1209: printf("uha%d:%d device timed out\n",unit ! 1210: ,mscp->xs->targ); ! 1211: if(uha_debug & UHA_SHOWMSCPS) ! 1212: uha_print_active_mscp(); ! 1213: ! 1214: /***************************************\ ! 1215: * Unlink it from the queue * ! 1216: \***************************************/ ! 1217: uha_remove_timeout(mscp); ! 1218: ! 1219: if((uha_abort(unit,mscp) !=1) || (mscp->flags = MSCP_ABORTED)) ! 1220: { ! 1221: printf("AGAIN"); ! 1222: mscp->xs->retries = 0; /* I MEAN IT ! */ ! 1223: uha_done(unit,mscp,FAIL); ! 1224: } ! 1225: else /* abort the operation that has timed out */ ! 1226: { ! 1227: printf("\n"); ! 1228: uha_add_timeout(mscp,2000 + ONETICK); ! 1229: mscp->flags = MSCP_ABORTED; ! 1230: } ! 1231: } ! 1232: else ! 1233: /***********************************************\ ! 1234: * It has not timed out, adjust and leave * ! 1235: \***********************************************/ ! 1236: { ! 1237: mscp->delta -= ONETICK; ! 1238: uha_furtherest -= ONETICK; ! 1239: break; ! 1240: } ! 1241: } ! 1242: splx(s); ! 1243: timeout(uha_timeout,arg,SLEEPTIME); ! 1244: } ! 1245: ! 1246: uha_show_scsi_cmd(struct scsi_xfer *xs) ! 1247: { ! 1248: u_char *b = (u_char *)xs->cmd; ! 1249: int i = 0; ! 1250: if(!(xs->flags & SCSI_RESET)) ! 1251: { ! 1252: printf("uha%d:%d:%d-" ! 1253: ,xs->adapter ! 1254: ,xs->targ ! 1255: ,xs->lu); ! 1256: while(i < xs->cmdlen ) ! 1257: { ! 1258: if(i) printf(","); ! 1259: printf("%x",b[i++]); ! 1260: } ! 1261: printf("-\n"); ! 1262: } ! 1263: else ! 1264: { ! 1265: printf("uha%d:%d:%d-RESET-\n" ! 1266: ,xs->adapter ! 1267: ,xs->targ ! 1268: ,xs->lu ! 1269: ); ! 1270: } ! 1271: } ! 1272: uha_print_mscp(mscp) ! 1273: struct mscp *mscp; ! 1274: { ! 1275: printf("mscp:%x op:%x cmdlen:%d senlen:%d\n" ! 1276: ,mscp ! 1277: ,mscp->opcode ! 1278: ,mscp->cdblen ! 1279: ,mscp->senselen); ! 1280: printf(" sg:%d sgnum:%x datlen:%d hstat:%x tstat:%x delta:%d flags:%x\n" ! 1281: ,mscp->sgth ! 1282: ,mscp->sg_num ! 1283: ,mscp->datalen ! 1284: ,mscp->ha_status ! 1285: ,mscp->targ_status ! 1286: ,mscp->delta ! 1287: ,mscp->flags); ! 1288: uha_show_scsi_cmd(mscp->xs); ! 1289: } ! 1290: ! 1291: uha_print_active_mscp() ! 1292: { ! 1293: struct mscp *mscp; ! 1294: mscp = uha_soonest; ! 1295: ! 1296: while(mscp) ! 1297: { ! 1298: uha_print_mscp(mscp); ! 1299: mscp = mscp->later; ! 1300: } ! 1301: printf("Furtherest = %d\n",uha_furtherest); ! 1302: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.