ref: 57f8b3d1acf273a88568c49d0b83b6863485b9e0
dir: /sys/src/cmd/cwfs/scsi.c/
/* * interface to scsi devices via scsi(2) to sd(3), * which does not implement LUNs. */ #include "all.h" #include "io.h" enum { Ninquiry = 255, Nsense = 255, CMDtest = 0x00, CMDreqsense = 0x03, CMDread6 = 0x08, CMDwrite6 = 0x0A, CMDinquiry = 0x12, CMDstart = 0x1B, CMDread10 = 0x28, CMDwrite10 = 0x2A, }; typedef struct { Target target[NTarget]; } Ctlr; static Ctlr scsictlr[MaxScsi]; extern int scsiverbose; void scsiinit(void) { Ctlr *ctlr; int ctlrno, targetno; Target *tp; scsiverbose = 1; for(ctlrno = 0; ctlrno < MaxScsi; ctlrno++){ ctlr = &scsictlr[ctlrno]; memset(ctlr, 0, sizeof(Ctlr)); for(targetno = 0; targetno < NTarget; targetno++){ tp = &ctlr->target[targetno]; qlock(tp); qunlock(tp); sprint(tp->id, "scsictlr#%d.%d", ctlrno, targetno); tp->ctlrno = ctlrno; tp->targetno = targetno; tp->inquiry = ialloc(Ninquiry, 0); tp->sense = ialloc(Nsense, 0); } } } static uchar lastcmd[16]; static int lastcmdsz; static int sense2stcode(uchar *sense) { switch(sense[2] & 0x0F){ case 6: /* unit attention */ /* * 0x28 - not ready to ready transition, * medium may have changed. * 0x29 - power on, RESET or BUS DEVICE RESET occurred. */ if(sense[12] != 0x28 && sense[12] != 0x29) return STcheck; /*FALLTHROUGH*/ case 0: /* no sense */ case 1: /* recovered error */ return STok; case 8: /* blank data */ return STblank; case 2: /* not ready */ if(sense[12] == 0x3A) /* medium not present */ return STcheck; /*FALLTHROUGH*/ default: /* * If unit is becoming ready, rather than not ready, * then wait a little then poke it again; should this * be here or in the caller? */ if((sense[12] == 0x04 && sense[13] == 0x01)) { // delay(500); // scsitest(tp, lun); fprint(2, "sense2stcode: unit becoming ready\n"); return STcheck; /* not exactly right */ } return STcheck; } } /* * issue the SCSI command via scsi(2). lun must already be in cmd[1]. */ static int doscsi(Target* tp, int rw, uchar* cmd, int cbytes, void* data, int* dbytes) { int lun, db = 0; uchar reqcmd[6], reqdata[Nsense], dummy[1]; Scsi *sc; sc = tp->sc; if (sc == nil) panic("doscsi: nil tp->sc"); lun = cmd[1] >> 5; /* save lun in case we need it for reqsense */ /* cope with zero arguments */ if (dbytes != nil) db = *dbytes; if (data == nil) data = dummy; if (scsi(sc, cmd, cbytes, data, db, rw) >= 0) return STok; /* cmd failed, get whatever sense data we can */ memset(reqcmd, 0, sizeof reqcmd); reqcmd[0] = CMDreqsense; reqcmd[1] = lun<<5; reqcmd[4] = Nsense; memset(reqdata, 0, sizeof reqdata); if (scsicmd(sc, reqcmd, sizeof reqcmd, reqdata, sizeof reqdata, Sread) < 0) return STharderr; /* translate sense data to ST* codes */ return sense2stcode(reqdata); } static int scsiexec(Target* tp, int rw, uchar* cmd, int cbytes, void* data, int* dbytes) { int s; /* * issue the SCSI command. lun must already be in cmd[1]. */ s = doscsi(tp, rw, cmd, cbytes, data, dbytes); switch(s){ case STcheck: memmove(lastcmd, cmd, cbytes); lastcmdsz = cbytes; /*FALLTHROUGH*/ default: /* * It's more complicated than this. There are conditions which * are 'ok' but for which the returned status code is not 'STok'. * Also, not all conditions require a reqsense, there may be a * need to do a reqsense here when necessary and making it * available to the caller somehow. * * Later. */ break; } return s; } static int scsitest(Target* tp, char lun) { uchar cmd[6]; memset(cmd, 0, sizeof cmd); cmd[0] = CMDtest; cmd[1] = lun<<5; return scsiexec(tp, SCSIread, cmd, sizeof cmd, 0, 0); } static int scsistart(Target* tp, char lun, int start) { uchar cmd[6]; memset(cmd, 0, sizeof cmd); cmd[0] = CMDstart; cmd[1] = lun<<5; if(start) cmd[4] = 1; return scsiexec(tp, SCSIread, cmd, sizeof cmd, 0, 0); } static int scsiinquiry(Target* tp, char lun, int* nbytes) { uchar cmd[6]; memset(cmd, 0, sizeof cmd); cmd[0] = CMDinquiry; cmd[1] = lun<<5; *nbytes = Ninquiry; cmd[4] = *nbytes; return scsiexec(tp, SCSIread, cmd, sizeof cmd, tp->inquiry, nbytes); } static char *key[] = { "no sense", "recovered error", "not ready", "medium error", "hardware error", "illegal request", "unit attention", "data protect", "blank check", "vendor specific", "copy aborted", "aborted command", "equal", "volume overflow", "miscompare", "reserved" }; static int scsireqsense(Target* tp, char lun, int* nbytes, int quiet) { char *s; int n, status, try; uchar cmd[6], *sense; sense = tp->sense; for(try = 0; try < 20; try++) { memset(cmd, 0, sizeof cmd); cmd[0] = CMDreqsense; cmd[1] = lun<<5; cmd[4] = Ninquiry; memset(sense, 0, Ninquiry); *nbytes = Ninquiry; status = scsiexec(tp, SCSIread, cmd, sizeof cmd, sense, nbytes); if(status != STok) return status; *nbytes = sense[0x07]+8; switch(sense[2] & 0x0F){ case 6: /* unit attention */ /* * 0x28 - not ready to ready transition, * medium may have changed. * 0x29 - power on, RESET or BUS DEVICE RESET occurred. */ if(sense[12] != 0x28 && sense[12] != 0x29) goto buggery; /*FALLTHROUGH*/ case 0: /* no sense */ case 1: /* recovered error */ return STok; case 8: /* blank data */ return STblank; case 2: /* not ready */ if(sense[12] == 0x3A) /* medium not present */ goto buggery; /*FALLTHROUGH*/ default: /* * If unit is becoming ready, rather than not ready, * then wait a little then poke it again; should this * be here or in the caller? */ if((sense[12] == 0x04 && sense[13] == 0x01)){ delay(500); scsitest(tp, lun); break; } goto buggery; } } buggery: if(quiet == 0){ s = key[sense[2]&0x0F]; fprint(2, "%s: reqsense: '%s' code #%2.2ux #%2.2ux\n", tp->id, s, sense[12], sense[13]); fprint(2, "%s: byte 2: #%2.2ux, bytes 15-17: #%2.2ux #%2.2ux #%2.2ux\n", tp->id, sense[2], sense[15], sense[16], sense[17]); fprint(2, "lastcmd (%d): ", lastcmdsz); for(n = 0; n < lastcmdsz; n++) fprint(2, " #%2.2ux", lastcmd[n]); fprint(2, "\n"); } return STcheck; } static Target* scsitarget(Device* d) { int ctlrno, targetno; ctlrno = d->wren.ctrl; if(ctlrno < 0 || ctlrno >= MaxScsi /* || scsictlr[ctlrno].io == nil */) return 0; targetno = d->wren.targ; if(targetno < 0 || targetno >= NTarget) return 0; return &scsictlr[ctlrno].target[targetno]; } static void scsiprobe(Device* d) { Target *tp; int nbytes, s; uchar *sense; int acount; if((tp = scsitarget(d)) == 0) panic("scsiprobe: device = %Z", d); acount = 0; again: s = scsitest(tp, d->wren.lun); if(s < STok){ fprint(2, "%s: test, status %d\n", tp->id, s); return; } /* * Determine if the drive exists and is not ready or * is simply not responding. * If the status is OK but the drive came back with a 'power on' or * 'reset' status, try the test again to make sure the drive is really * ready. * If the drive is not ready and requires intervention, try to spin it * up. */ s = scsireqsense(tp, d->wren.lun, &nbytes, acount); sense = tp->sense; switch(s){ case STok: if ((sense[2] & 0x0F) == 0x06 && (sense[12] == 0x28 || sense[12] == 0x29)) if(acount == 0){ acount = 1; goto again; } break; case STcheck: if((sense[2] & 0x0F) == 0x02){ if(sense[12] == 0x3A) break; if(sense[12] == 0x04 && sense[13] == 0x02){ fprint(2, "%s: starting...\n", tp->id); if(scsistart(tp, d->wren.lun, 1) == STok) break; s = scsireqsense(tp, d->wren.lun, &nbytes, 0); } } /*FALLTHROUGH*/ default: fprint(2, "%s: unavailable, status %d\n", tp->id, s); return; } /* * Inquire to find out what the device is. * Hardware drivers may need some of the info. */ s = scsiinquiry(tp, d->wren.lun, &nbytes); if(s != STok) { fprint(2, "%s: inquiry failed, status %d\n", tp->id, s); return; } fprint(2, "%s: %s\n", tp->id, (char*)tp->inquiry+8); tp->ok = 1; } int scsiio(Device* d, int rw, uchar* cmd, int cbytes, void* data, int dbytes) { Target *tp; int e, nbytes, s; if((tp = scsitarget(d)) == 0) panic("scsiio: device = %Z", d); qlock(tp); if(tp->ok == 0) scsiprobe(d); qunlock(tp); s = STinit; for(e = 0; e < 10; e++){ for(;;){ nbytes = dbytes; s = scsiexec(tp, rw, cmd, cbytes, data, &nbytes); if(s == STok) break; s = scsireqsense(tp, d->wren.lun, &nbytes, 0); if(s == STblank && rw == SCSIread) { memset(data, 0, dbytes); return STok; } if(s != STok) break; } if(s == STok) break; } if(e) fprint(2, "%s: retry %d cmd #%x\n", tp->id, e, cmd[0]); return s; } void newscsi(Device *d, Scsi *sc) { Target *tp; if((tp = scsitarget(d)) == nil) panic("newscsi: device = %Z", d); tp->sc = sc; /* connect Target to Scsi */ }