![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scsiconf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / scsi|
Return to scsiconf.c CVS log | Up to [Net/2] / Net2 / scsi |
1.1 ! root 1: /* ! 2: * Written by Julian Elischer ([email protected]) ! 3: * for TRW Financial Systems for use under the MACH(2.5) operating system. ! 4: * ! 5: * TRW Financial Systems, in accordance with their agreement with Carnegie ! 6: * Mellon University, makes this software available to CMU to distribute ! 7: * or use in any manner that they see fit as long as this message is kept with ! 8: * the software. For this reason TFS also grants any other persons or ! 9: * organisations permission to use or modify this software. ! 10: * ! 11: * TFS supplies this software to be publicly redistributed ! 12: * on the understanding that TFS is not responsible for the correct ! 13: * functioning of this software in any circumstances. ! 14: * ! 15: * ! 16: * PATCHES MAGIC LEVEL PATCH THAT GOT US HERE ! 17: * -------------------- ----- ---------------------- ! 18: * CURRENT PATCH LEVEL: 1 00098 ! 19: * -------------------- ----- ---------------------- ! 20: * ! 21: * 16 Feb 93 Julian Elischer ADDED for SCSI system ! 22: */ ! 23: ! 24: /* ! 25: * Ported to run under 386BSD by Julian Elischer ([email protected]) Sept 1992 ! 26: */ ! 27: ! 28: /* ! 29: $Log: ! 30: * ! 31: */ ! 32: #include <sys/types.h> ! 33: #include "st.h" ! 34: #include "sd.h" ! 35: #include "ch.h" ! 36: #include "cd.h" ! 37: ! 38: #ifdef MACH ! 39: #include <i386/machparam.h> ! 40: #endif MACH ! 41: #include <scsi/scsi_all.h> ! 42: #include <scsi/scsiconf.h> ! 43: ! 44: #if !defined(OSF) && !defined(__386BSD__) ! 45: #include "bll.h" ! 46: #include "cals.h" ! 47: #include "kil.h" ! 48: #else ! 49: #define NBLL 0 ! 50: #define NCALS 0 ! 51: #define NKIL 0 ! 52: #endif /* !defined(OSF) && !defined(__386BSD__) */ ! 53: ! 54: #if NSD > 0 ! 55: extern sdattach(); ! 56: #endif NSD ! 57: #if NST > 0 ! 58: extern stattach(); ! 59: #endif NST ! 60: #if NCH > 0 ! 61: extern chattach(); ! 62: #endif NCH ! 63: #if NCD > 0 ! 64: extern cdattach(); ! 65: #endif NCD ! 66: #if NBLL > 0 ! 67: extern bllattach(); ! 68: #endif NBLL ! 69: #if NCALS > 0 ! 70: extern calsattach(); ! 71: #endif NCALS ! 72: #if NKIL > 0 ! 73: extern kil_attach(); ! 74: #endif NKIL ! 75: ! 76: /***************************************************************\ ! 77: * The structure of pre-configured devices that might be turned * ! 78: * off and therefore may not show up * ! 79: \***************************************************************/ ! 80: struct predefined ! 81: { ! 82: u_char scsibus; ! 83: u_char dev; ! 84: u_char lu; ! 85: int (*attach_rtn)(); ! 86: char *devname; ! 87: char flags; ! 88: } ! 89: pd[] = ! 90: { ! 91: #ifdef EXAMPLE_PREDEFINE ! 92: #if NSD > 0 ! 93: {0,0,0,sdattach,"sd",0},/* define a disk at scsibus=0 dev=0 lu=0 */ ! 94: #endif NSD ! 95: #endif EXAMPLE_PREDEFINE ! 96: {0,9,9} /*illegal dummy end entry */ ! 97: }; ! 98: ! 99: ! 100: /***************************************************************\ ! 101: * The structure of known drivers for autoconfiguration * ! 102: \***************************************************************/ ! 103: static struct scsidevs ! 104: { ! 105: int type; ! 106: int removable; ! 107: char *manufacturer; ! 108: char *model; ! 109: char *version; ! 110: int (*attach_rtn)(); ! 111: char *devname; ! 112: char flags; /* 1 show my comparisons during boot(debug) */ ! 113: } ! 114: #define SC_SHOWME 0x01 ! 115: #define SC_ONE_LU 0x00 ! 116: #define SC_MORE_LUS 0x02 ! 117: knowndevs[] = { ! 118: #if NSD > 0 ! 119: { T_DIRECT,T_FIXED,"standard","any" ! 120: ,"any",sdattach,"sd",SC_ONE_LU }, ! 121: { T_DIRECT,T_FIXED,"MAXTOR ","XT-4170S " ! 122: ,"B5A ",sdattach,"mx1",SC_ONE_LU }, ! 123: #endif NSD ! 124: #if NST > 0 ! 125: { T_SEQUENTIAL,T_REMOV,"standard","any" ! 126: ,"any",stattach,"st",SC_ONE_LU }, ! 127: #endif NST ! 128: #if NCALS > 0 ! 129: { T_PROCESSOR,T_FIXED,"standard","any" ! 130: ,"any",calsattach,"cals",SC_MORE_LUS }, ! 131: #endif NCALS ! 132: #if NCH > 0 ! 133: { T_CHANGER,T_REMOV,"standard","any" ! 134: ,"any",chattach,"ch",SC_ONE_LU }, ! 135: #endif NCH ! 136: #if NCD > 0 ! 137: { T_READONLY,T_REMOV,"SONY ","CD-ROM CDU-8012 " ! 138: ,"3.1a",cdattach,"cd",SC_ONE_LU }, ! 139: #endif NCD ! 140: #if NBLL > 0 ! 141: { T_PROCESSOR,T_FIXED,"AEG ","READER " ! 142: ,"V1.0",bllattach,"bll",SC_MORE_LUS }, ! 143: #endif NBLL ! 144: #if NKIL > 0 ! 145: { T_SCANNER,T_FIXED,"KODAK ","IL Scanner 900 " ! 146: ,"any",kil_attach,"kil",SC_ONE_LU }, ! 147: #endif NKIL ! 148: ! 149: {0} ! 150: }; ! 151: /***************************************************************\ ! 152: * Declarations * ! 153: \***************************************************************/ ! 154: struct predefined *scsi_get_predef(); ! 155: struct scsidevs *scsi_probedev(); ! 156: struct scsidevs *selectdev(); ! 157: ! 158: /* controls debug level within the scsi subsystem */ ! 159: /* see scsiconf.h for values */ ! 160: int scsi_debug = 0x0; ! 161: int scsibus = 0x0; /* This is the Nth scsibus */ ! 162: ! 163: /***************************************************************\ ! 164: * The routine called by the adapter boards to get all their * ! 165: * devices configured in. * ! 166: \***************************************************************/ ! 167: scsi_attachdevs( unit, scsi_addr, scsi_switch) ! 168: int unit,scsi_addr; ! 169: struct scsi_switch *scsi_switch; ! 170: { ! 171: int targ,lun; ! 172: struct scsidevs *bestmatch = (struct scsidevs *)0; ! 173: struct predefined *predef; ! 174: int maybe_more; ! 175: ! 176: #ifdef SCSI_DELAY ! 177: #if SCSI_DELAY > 2 ! 178: printf("waiting for scsi devices to settle\n"); ! 179: #else SCSI_DELAY > 2 ! 180: #define SCSI_DELAY 15 ! 181: #endif SCSI_DELAY > 2 ! 182: #else ! 183: #define SCSI_DELAY 2 ! 184: #endif SCSI_DELAY ! 185: spinwait(1000 * SCSI_DELAY); ! 186: targ = 0; ! 187: while(targ < 8) ! 188: { ! 189: maybe_more = 0; /* by default only check 1 lun */ ! 190: if (targ == scsi_addr) ! 191: { ! 192: targ++; ! 193: continue; ! 194: } ! 195: lun = 0; ! 196: while(lun < 8) ! 197: { ! 198: predef = scsi_get_predef(scsibus ! 199: ,targ ! 200: ,lun ! 201: ,&maybe_more); ! 202: bestmatch = scsi_probedev(unit ! 203: ,targ ! 204: ,lun ! 205: ,scsi_switch ! 206: ,&maybe_more); ! 207: if((bestmatch) && (predef)) /* both exist */ ! 208: { ! 209: if(bestmatch->attach_rtn ! 210: != predef->attach_rtn) ! 211: { ! 212: printf("Clash in found/expected devices\n"); ! 213: printf("will link in FOUND\n"); ! 214: } ! 215: (*(bestmatch->attach_rtn))(unit, ! 216: targ, ! 217: lun, ! 218: scsi_switch); ! 219: } ! 220: if((bestmatch) && (!predef)) /* just FOUND */ ! 221: { ! 222: (*(bestmatch->attach_rtn))(unit, ! 223: targ, ! 224: lun, ! 225: scsi_switch); ! 226: } ! 227: if((!bestmatch) && (predef)) /* just predef */ ! 228: { ! 229: (*(predef->attach_rtn))(unit, ! 230: targ, ! 231: lun, ! 232: scsi_switch); ! 233: } ! 234: if(!(maybe_more)) /* nothing suggests we'll find more */ ! 235: { ! 236: break; /* nothing here, skip to next targ */ ! 237: } ! 238: /* otherwise something says we should look further*/ ! 239: lun++; ! 240: } ! 241: targ++; ! 242: } ! 243: #if NGENSCSI > 0 ! 244: /***************************************************************\ ! 245: * If available hook up the generic scsi driver, letting it * ! 246: * know which target is US. (i.e. illegal or at least special) * ! 247: \***************************************************************/ ! 248: genscsi_attach(unit,scsi_addr,0,scsi_switch); ! 249: #endif ! 250: scsibus++; /* next time we are on the NEXT scsi bus */ ! 251: } ! 252: ! 253: /***********************************************\ ! 254: * given a target and lu, check if there is a * ! 255: * predefined device for that address * ! 256: \***********************************************/ ! 257: struct predefined *scsi_get_predef(unit,target,lu,maybe_more) ! 258: int unit,target,lu,*maybe_more; ! 259: { ! 260: int upto,numents; ! 261: ! 262: numents = (sizeof(pd)/sizeof(struct predefined)) - 1; ! 263: ! 264: for(upto = 0;upto < numents;upto++) ! 265: { ! 266: if(pd[upto].scsibus != unit) ! 267: continue; ! 268: if(pd[upto].dev != target) ! 269: continue; ! 270: if(pd[upto].lu != lu) ! 271: continue; ! 272: ! 273: printf(" dev%d,lu%d: %s - PRECONFIGURED -\n" ! 274: ,target ! 275: ,lu ! 276: ,pd[upto].devname); ! 277: *maybe_more = pd[upto].flags & SC_MORE_LUS; ! 278: return(&(pd[upto])); ! 279: } ! 280: return((struct predefined *)0); ! 281: } ! 282: ! 283: /***********************************************\ ! 284: * given a target and lu, ask the device what * ! 285: * it is, and find the correct driver table * ! 286: * entry. * ! 287: \***********************************************/ ! 288: struct scsidevs *scsi_probedev(unit,target,lu,scsi_switch, maybe_more) ! 289: ! 290: struct scsi_switch *scsi_switch; ! 291: int unit,target,lu; ! 292: int *maybe_more; ! 293: { ! 294: struct scsidevs *bestmatch = (struct scsidevs *)0; ! 295: char *dtype=(char *)0,*desc; ! 296: char *qtype; ! 297: static struct scsi_inquiry_data inqbuf; ! 298: int len,qualifier,type,remov; ! 299: char manu[32]; ! 300: char model[32]; ! 301: char version[32]; ! 302: ! 303: ! 304: bzero(&inqbuf,sizeof(inqbuf)); ! 305: /***********************************************\ ! 306: * Ask the device what it is * ! 307: \***********************************************/ ! 308: #ifdef DEBUG ! 309: if((target == 0) && (lu == 0)) ! 310: scsi_debug = 0xfff; ! 311: else ! 312: scsi_debug = 0; ! 313: #endif DEBUG ! 314: if(scsi_ready( unit, ! 315: target, ! 316: lu, ! 317: scsi_switch, ! 318: SCSI_NOSLEEP | SCSI_NOMASK) != COMPLETE) ! 319: { ! 320: return(struct scsidevs *)0; ! 321: } ! 322: if(scsi_inquire(unit, ! 323: target, ! 324: lu, ! 325: scsi_switch, ! 326: &inqbuf, ! 327: SCSI_NOSLEEP | SCSI_NOMASK) != COMPLETE) ! 328: { ! 329: return(struct scsidevs *)0; ! 330: } ! 331: ! 332: /***********************************************\ ! 333: * note what BASIC type of device it is * ! 334: \***********************************************/ ! 335: if(scsi_debug & SHOWINQUIRY) ! 336: { ! 337: desc=(char *)&inqbuf; ! 338: printf("inq: %x %x %x %x %x %x %x %x %x %x %x %x %x\n", ! 339: desc[0], desc[1], desc[2], desc[3], ! 340: desc[4], desc[5], desc[6], desc[7], ! 341: desc[8], desc[9], desc[10], desc[11], ! 342: desc[12]); ! 343: } ! 344: ! 345: type = inqbuf.device_type; ! 346: qualifier = inqbuf.device_qualifier; ! 347: remov = inqbuf.removable; ! 348: ! 349: /* Check for a non-existent unit. If the device is returning ! 350: * this much, then we must set the flag that has ! 351: * the searcher keep looking on other luns. ! 352: */ ! 353: if (qualifier == 3 && type == T_NODEVICE) ! 354: { ! 355: *maybe_more = 1; ! 356: return (struct scsidevs *)0; ! 357: } ! 358: ! 359: /* Any device qualifier that has ! 360: * the top bit set (qualifier&4 != 0) is vendor specific and ! 361: * won't match in this switch. ! 362: */ ! 363: ! 364: switch(qualifier) ! 365: { ! 366: case 0: ! 367: qtype=""; ! 368: break; ! 369: case 1: ! 370: qtype=", Unit not Connected!"; ! 371: break; ! 372: case 2: ! 373: qtype=", Reserved Peripheral Qualifier!"; ! 374: break; ! 375: case 3: ! 376: qtype=", The Target can't support this Unit!"; ! 377: break; ! 378: ! 379: default: ! 380: dtype="vendor specific"; ! 381: qtype=""; ! 382: *maybe_more = 1; ! 383: break; ! 384: } ! 385: ! 386: if (dtype == 0) ! 387: switch(type) ! 388: { ! 389: case T_DIRECT: ! 390: dtype="direct"; ! 391: break; ! 392: case T_SEQUENTIAL: ! 393: dtype="sequential"; ! 394: break; ! 395: case T_PRINTER: ! 396: dtype="printer"; ! 397: break; ! 398: case T_PROCESSOR: ! 399: dtype="processor"; ! 400: break; ! 401: case T_READONLY: ! 402: dtype="readonly"; ! 403: break; ! 404: case T_WORM: ! 405: dtype="worm"; ! 406: break; ! 407: case T_SCANNER: ! 408: dtype="scanner"; ! 409: break; ! 410: case T_OPTICAL: ! 411: dtype="optical"; ! 412: break; ! 413: case T_CHANGER: ! 414: dtype="changer"; ! 415: break; ! 416: case T_COMM: ! 417: dtype="communication"; ! 418: break; ! 419: default: ! 420: dtype="unknown"; ! 421: break; ! 422: } ! 423: ! 424: /***********************************************\ ! 425: * Then if it's advanced enough, more detailed * ! 426: * information * ! 427: \***********************************************/ ! 428: if(inqbuf.ansii_version > 0) ! 429: { ! 430: if ((len = inqbuf.additional_length ! 431: + ( (char *)inqbuf.unused ! 432: - (char *)&inqbuf)) ! 433: > (sizeof(struct scsi_inquiry_data) - 1)) ! 434: len = sizeof(struct scsi_inquiry_data) - 1; ! 435: desc=inqbuf.vendor; ! 436: desc[len-(desc - (char *)&inqbuf)] = 0; ! 437: strncpy(manu,inqbuf.vendor,8);manu[8]=0; ! 438: strncpy(model,inqbuf.product,16);model[16]=0; ! 439: strncpy(version,inqbuf.revision,4);version[4]=0; ! 440: } ! 441: else ! 442: /***********************************************\ ! 443: * If not advanced enough, use default values * ! 444: \***********************************************/ ! 445: { ! 446: desc="early protocol device"; ! 447: strncpy(manu,"unknown",8); ! 448: strncpy(model,"unknown",16); ! 449: strncpy(version,"????",4); ! 450: } ! 451: printf(" dev%d,lu%d: type %d:%d(%s%s),%s '%s%s%s' scsi%d\n" ! 452: ,target ! 453: ,lu ! 454: ,qualifier,type ! 455: ,dtype,qtype ! 456: ,remov?"removable":"fixed" ! 457: ,manu ! 458: ,model ! 459: ,version ! 460: ,inqbuf.ansii_version ! 461: ); ! 462: /***********************************************\ ! 463: * Try make as good a match as possible with * ! 464: * available sub drivers * ! 465: \***********************************************/ ! 466: bestmatch = (selectdev(unit,target,lu,&scsi_switch, ! 467: qualifier,type,remov,manu,model,version)); ! 468: if((bestmatch) && (bestmatch->flags & SC_MORE_LUS)) ! 469: { ! 470: *maybe_more = 1; ! 471: } ! 472: return(bestmatch); ! 473: } ! 474: ! 475: /***********************************************\ ! 476: * Try make as good a match as possible with * ! 477: * available sub drivers * ! 478: \***********************************************/ ! 479: struct scsidevs ! 480: *selectdev(unit,target,lu,dvr_switch,qualifier,type,remov,manu,model,rev) ! 481: int unit,target,lu; ! 482: struct scsi_switch *dvr_switch; ! 483: int qualifier,type,remov; ! 484: char *manu,*model,*rev; ! 485: { ! 486: int numents = (sizeof(knowndevs)/sizeof(struct scsidevs)) - 1; ! 487: int count = 0; ! 488: int bestmatches = 0; ! 489: struct scsidevs *bestmatch = (struct scsidevs *)0; ! 490: struct scsidevs *thisentry = knowndevs; ! 491: ! 492: type |= (qualifier << 5); ! 493: ! 494: thisentry--; ! 495: while( count++ < numents) ! 496: { ! 497: thisentry++; ! 498: if(type != thisentry->type) ! 499: { ! 500: continue; ! 501: } ! 502: if(bestmatches < 1) ! 503: { ! 504: bestmatches = 1; ! 505: bestmatch = thisentry; ! 506: } ! 507: if(remov != thisentry->removable) ! 508: { ! 509: continue; ! 510: } ! 511: if(bestmatches < 2) ! 512: { ! 513: bestmatches = 2; ! 514: bestmatch = thisentry; ! 515: } ! 516: if(thisentry->flags & SC_SHOWME) ! 517: printf("\n%s-\n%s-",thisentry->manufacturer, manu); ! 518: if(strcmp(thisentry->manufacturer, manu)) ! 519: { ! 520: continue; ! 521: } ! 522: if(bestmatches < 3) ! 523: { ! 524: bestmatches = 3; ! 525: bestmatch = thisentry; ! 526: } ! 527: if(thisentry->flags & SC_SHOWME) ! 528: printf("\n%s-\n%s-",thisentry->model, model); ! 529: if(strcmp(thisentry->model, model)) ! 530: { ! 531: continue; ! 532: } ! 533: if(bestmatches < 4) ! 534: { ! 535: bestmatches = 4; ! 536: bestmatch = thisentry; ! 537: } ! 538: if(thisentry->flags & SC_SHOWME) ! 539: printf("\n%s-\n%s-",thisentry->version, rev); ! 540: if(strcmp(thisentry->version, rev)) ! 541: { ! 542: continue; ! 543: } ! 544: if(bestmatches < 5) ! 545: { ! 546: bestmatches = 5; ! 547: bestmatch = thisentry; ! 548: break; ! 549: } ! 550: } ! 551: ! 552: if (bestmatch == (struct scsidevs *)0) ! 553: printf(" No explicit device driver match for \"%s %s\".\n", ! 554: manu, model); ! 555: ! 556: return(bestmatch); ! 557: } ! 558: ! 559: static int recurse = 0; ! 560: /***********************************************\ ! 561: * Do a scsi operation asking a device if it is * ! 562: * ready. Use the scsi_cmd routine in the switch * ! 563: * table. * ! 564: \***********************************************/ ! 565: scsi_ready(unit,target,lu,scsi_switch, flags) ! 566: struct scsi_switch *scsi_switch; ! 567: { ! 568: struct scsi_test_unit_ready scsi_cmd; ! 569: struct scsi_xfer scsi_xfer; ! 570: volatile int rval; ! 571: int key; ! 572: ! 573: bzero(&scsi_cmd, sizeof(scsi_cmd)); ! 574: bzero(&scsi_xfer, sizeof(scsi_xfer)); ! 575: scsi_cmd.op_code = TEST_UNIT_READY; ! 576: ! 577: scsi_xfer.flags=flags | INUSE; ! 578: scsi_xfer.adapter=unit; ! 579: scsi_xfer.targ=target; ! 580: scsi_xfer.lu=lu; ! 581: scsi_xfer.cmd=(struct scsi_generic *)&scsi_cmd; ! 582: scsi_xfer.retries=8; ! 583: scsi_xfer.timeout=10000; ! 584: scsi_xfer.cmdlen=sizeof(scsi_cmd); ! 585: scsi_xfer.data=0; ! 586: scsi_xfer.datalen=0; ! 587: scsi_xfer.resid=0; ! 588: scsi_xfer.when_done=0; ! 589: scsi_xfer.done_arg=0; ! 590: retry: scsi_xfer.error=0; ! 591: /*******************************************************\ ! 592: * do not use interrupts * ! 593: \*******************************************************/ ! 594: rval = (*(scsi_switch->scsi_cmd))(&scsi_xfer); ! 595: if (rval != COMPLETE) ! 596: { ! 597: if(scsi_debug) ! 598: { ! 599: printf("scsi error, rval = 0x%x\n",rval); ! 600: printf("code from driver: 0x%x\n",scsi_xfer.error); ! 601: } ! 602: switch(scsi_xfer.error) ! 603: { ! 604: case XS_SENSE: ! 605: /*******************************************************\ ! 606: * Any sense value is illegal except UNIT ATTENTION * ! 607: * In which case we need to check again to get the * ! 608: * correct response. * ! 609: *( especially exabytes) * ! 610: \*******************************************************/ ! 611: if(scsi_xfer.sense.error_class == 7 ) ! 612: { ! 613: key = scsi_xfer.sense.ext.extended.sense_key ; ! 614: switch(key) ! 615: { ! 616: case 2: /* not ready BUT PRESENT! */ ! 617: return(COMPLETE); ! 618: case 6: ! 619: spinwait(1000); ! 620: if(scsi_xfer.retries--) ! 621: { ! 622: scsi_xfer.flags &= ~ITSDONE; ! 623: goto retry; ! 624: } ! 625: return(COMPLETE); ! 626: default: ! 627: if(scsi_debug) ! 628: printf("%d:%d,key=%x.", ! 629: target,lu,key); ! 630: } ! 631: } ! 632: return(HAD_ERROR); ! 633: case XS_BUSY: ! 634: spinwait(1000); ! 635: if(scsi_xfer.retries--) ! 636: { ! 637: scsi_xfer.flags &= ~ITSDONE; ! 638: goto retry; ! 639: } ! 640: return(COMPLETE); /* it's busy so it's there */ ! 641: case XS_TIMEOUT: ! 642: default: ! 643: return(HAD_ERROR); ! 644: } ! 645: } ! 646: return(COMPLETE); ! 647: } ! 648: /***********************************************\ ! 649: * Do a scsi operation asking a device what it is* ! 650: * Use the scsi_cmd routine in the switch table. * ! 651: \***********************************************/ ! 652: scsi_inquire(unit,target,lu,scsi_switch,inqbuf, flags) ! 653: struct scsi_switch *scsi_switch; ! 654: u_char *inqbuf; ! 655: { ! 656: struct scsi_inquiry scsi_cmd; ! 657: struct scsi_xfer scsi_xfer; ! 658: volatile int rval; ! 659: ! 660: bzero(&scsi_cmd, sizeof(scsi_cmd)); ! 661: bzero(&scsi_xfer, sizeof(scsi_xfer)); ! 662: scsi_cmd.op_code = INQUIRY; ! 663: scsi_cmd.length = sizeof(struct scsi_inquiry_data); ! 664: ! 665: scsi_xfer.flags=flags | SCSI_DATA_IN | INUSE; ! 666: scsi_xfer.adapter=unit; ! 667: scsi_xfer.targ=target; ! 668: scsi_xfer.lu=lu; ! 669: scsi_xfer.retries=8; ! 670: scsi_xfer.timeout=10000; ! 671: scsi_xfer.cmd=(struct scsi_generic *)&scsi_cmd; ! 672: scsi_xfer.cmdlen= sizeof(struct scsi_inquiry); ! 673: scsi_xfer.data=inqbuf; ! 674: scsi_xfer.datalen=sizeof(struct scsi_inquiry_data); ! 675: scsi_xfer.resid=sizeof(struct scsi_inquiry_data); ! 676: scsi_xfer.when_done=0; ! 677: scsi_xfer.done_arg=0; ! 678: retry: scsi_xfer.error=0; ! 679: /*******************************************************\ ! 680: * do not use interrupts * ! 681: \*******************************************************/ ! 682: if ((*(scsi_switch->scsi_cmd))(&scsi_xfer) != COMPLETE) ! 683: { ! 684: if(scsi_debug) printf("inquiry had error(0x%x) ",scsi_xfer.error); ! 685: switch(scsi_xfer.error) ! 686: { ! 687: case XS_NOERROR: ! 688: break; ! 689: case XS_SENSE: ! 690: /*******************************************************\ ! 691: * Any sense value is illegal except UNIT ATTENTION * ! 692: * In which case we need to check again to get the * ! 693: * correct response. * ! 694: *( especially exabytes) * ! 695: \*******************************************************/ ! 696: if((scsi_xfer.sense.error_class == 7 ) ! 697: && (scsi_xfer.sense.ext.extended.sense_key == 6)) ! 698: { /* it's changed so it's there */ ! 699: spinwait(1000); ! 700: { ! 701: if(scsi_xfer.retries--) ! 702: { ! 703: scsi_xfer.flags &= ~ITSDONE; ! 704: goto retry; ! 705: } ! 706: } ! 707: return( COMPLETE); ! 708: } ! 709: return(HAD_ERROR); ! 710: case XS_BUSY: ! 711: spinwait(1000); ! 712: if(scsi_xfer.retries--) ! 713: { ! 714: scsi_xfer.flags &= ~ITSDONE; ! 715: goto retry; ! 716: } ! 717: case XS_TIMEOUT: ! 718: default: ! 719: return(HAD_ERROR); ! 720: } ! 721: } ! 722: return(COMPLETE); ! 723: } ! 724: ! 725: ! 726: ! 727: ! 728: /***********************************************\ ! 729: * Utility routines often used in SCSI stuff * ! 730: \***********************************************/ ! 731: ! 732: /***********************************************\ ! 733: * convert a physical address to 3 bytes, * ! 734: * MSB at the lowest address, * ! 735: * LSB at the highest. * ! 736: \***********************************************/ ! 737: ! 738: lto3b(val, bytes) ! 739: u_char *bytes; ! 740: { ! 741: *bytes++ = (val&0xff0000)>>16; ! 742: *bytes++ = (val&0xff00)>>8; ! 743: *bytes = val&0xff; ! 744: } ! 745: ! 746: /***********************************************\ ! 747: * The reverse of lto3b * ! 748: \***********************************************/ ! 749: _3btol(bytes) ! 750: u_char *bytes; ! 751: { ! 752: int rc; ! 753: rc = (*bytes++ << 16); ! 754: rc += (*bytes++ << 8); ! 755: rc += *bytes; ! 756: return(rc); ! 757: } ! 758:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.