ref: 82b046f36f8084a22bbb5d71edd0edd9179561eb
dir: /appl/lib/scsiio.b/
implement ScsiIO;
# adapted from /sys/src/libdisk on Plan 9: subject to Lucent Public License 1.02
include "sys.m";
sys: Sys;
include "bufio.m";
bufio: Bufio;
Iobuf: import bufio;
include "daytime.m";
daytime: Daytime;
include "scsiio.m";
scsiverbose := 0;
Codefile: con "/lib/scsicodes";
Code: adt {
v: int; # (asc<<8) | ascq
s: string;
};
codes: array of Code;
init(verbose: int)
{
sys = load Sys Sys->PATH;
bufio = load Bufio Bufio->PATH;
daytime = load Daytime Daytime->PATH;
scsiverbose = verbose;
getcodes();
}
getcodes()
{
fd := bufio->open(Codefile, Sys->OREAD);
if(fd == nil)
return;
codes = array[256] of Code;
nc := 0;
while((s := fd.gets('\n')) != nil){
if(s[0] == '#' || s[0] == '\n')
continue;
s = s[0: len s-1]; # trim '\n'
m: string;
for(i := 0; i < len s; i++)
if(s[i] == ' '){
m = s[i+1:];
break;
}
c := Code(tohex(s), m);
if(nc >= len codes){
ct := array[nc + 20] of Code;
ct[0:] = codes;
codes = ct;
}
codes[nc++] = c;
}
codes = codes[0:nc];
}
tohex(s: string): int
{
n := 0;
j := 0;
for(i := 0; i < len s && j < 4; i++){
if(s[i] == '/')
continue;
d := hex(s[i]);
if(d < 0)
return -1;
n = (n<<4) | d;
j++;
}
return n;
}
hex(c: int): int
{
if(c >= '0' && c <= '9')
return c-'0';
if(c >= 'A' && c <= 'F')
return c-'A' + 10;
if(c >= 'a' && c <= 'f')
return c-'a' + 10;
return -1;
}
scsierror(asc: int, ascq: int): string
{
t := -1;
for(i := 0; i < len codes; i++){
if(codes[i].v == ((asc<<8) | ascq))
return codes[i].s;
if(codes[i].v == (asc<<8))
t = i;
}
if(t >= 0)
return sys->sprint("(ascq #%.2ux) %s", ascq, codes[t].s);
return sys->sprint("scsi #%.2ux %.2ux", asc, ascq);
}
_scsicmd(s: ref Scsi, cmd: array of byte, data: array of byte, io: int, dolock: int): int
{
if(dolock)
qlock(s);
dcount := len data;
if(sys->write(s.rawfd, cmd, len cmd) != len cmd) {
sys->werrstr("cmd write: %r");
if(dolock)
qunlock(s);
return -1;
}
n: int;
resp := array[16] of byte;
case io {
Sread =>
n = sys->read(s.rawfd, data, dcount);
if(n < 0 && scsiverbose)
sys->fprint(sys->fildes(2), "dat read: %r: cmd %#2.2uX\n", int cmd[0]);
Swrite =>
n = sys->write(s.rawfd, data, dcount);
if(n != dcount && scsiverbose)
sys->fprint(sys->fildes(2), "dat write: %r: cmd %#2.2uX\n", int cmd[0]);
Snone or * =>
n = sys->write(s.rawfd, resp, 0);
if(n != 0 && scsiverbose)
sys->fprint(sys->fildes(2), "none write: %r: cmd %#2.2uX\n", int cmd[0]);
}
m := sys->read(s.rawfd, resp, len resp);
if(dolock)
qunlock(s);
if(m < 0){
sys->werrstr("resp read: %r\n");
return -1;
}
status := int string resp[0:m];
if(status == 0)
return n;
sys->werrstr(sys->sprint("cmd %2.2uX: status %uX dcount %d n %d", int cmd[0], status, dcount, n));
return -1;
}
Scsi.rawcmd(s: self ref Scsi, cmd: array of byte, data: array of byte, io: int): int
{
return _scsicmd(s, cmd, data, io, 1);
}
_scsiready(s: ref Scsi, dolock: int): int
{
if(dolock)
qlock(s);
for(i:=0; i<3; i++) {
cmd := array[6] of {0 => byte 16r00, * => byte 0}; # test unit ready
if(sys->write(s.rawfd, cmd, len cmd) != len cmd) {
if(scsiverbose)
sys->fprint(sys->fildes(2), "ur cmd write: %r\n");
continue;
}
resp := array[16] of byte;
sys->write(s.rawfd, resp, 0);
m := sys->read(s.rawfd, resp, len resp);
if(m < 0){
if(scsiverbose)
sys->fprint(sys->fildes(2), "ur resp read: %r\n");
continue; # retry
}
status := int string resp[0:m];
if(status == 0 || status == 16r02) {
if(dolock)
qunlock(s);
return 0;
}
if(scsiverbose)
sys->fprint(sys->fildes(2), "target: bad status: %x\n", status);
}
if(dolock)
qunlock(s);
return -1;
}
Scsi.ready(s: self ref Scsi): int
{
return _scsiready(s, 1);
}
Scsi.cmd(s: self ref Scsi, cmd: array of byte, data: array of byte, io: int): int
{
dcount := len data;
code := 0;
key := 0;
qlock(s);
sense: array of byte;
for(tries:=0; tries<2; tries++) {
n := _scsicmd(s, cmd, data, io, 0);
if(n >= 0) {
qunlock(s);
return n;
}
#
# request sense
#
sense = array[255] of {* => byte 16rFF}; # TO DO: usb mass storage devices might inist on less
req := array[6] of {0 => byte 16r03, 4 => byte len sense, * => byte 0};
if((n=_scsicmd(s, req, sense, Sread, 0)) < 14)
if(scsiverbose)
sys->fprint(sys->fildes(2), "reqsense scsicmd %d: %r\n", n);
if(_scsiready(s, 0) < 0)
if(scsiverbose)
sys->fprint(sys->fildes(2), "unit not ready\n");
key = int sense[2];
code = int sense[12];
if(code == 16r17 || code == 16r18) { # recovered errors
qunlock(s);
return dcount;
}
if(code == 16r28 && int cmd[0] == 16r43) { # get info and media changed
s.nchange++;
s.changetime = daytime->now();
continue;
}
}
# drive not ready, or medium not present
if(cmd[0] == byte 16r43 && key == 2 && (code == 16r3a || code == 16r04)) {
s.changetime = 0;
qunlock(s);
return -1;
}
qunlock(s);
if(cmd[0] == byte 16r43 && key == 5 && code == 16r24) # blank media
return -1;
p := scsierror(code, int sense[13]);
sys->werrstr(sys->sprint("cmd #%.2ux: %s", int cmd[0], p));
if(scsiverbose)
sys->fprint(sys->fildes(2), "scsi cmd #%.2ux: %.2ux %.2ux %.2ux: %s\n", int cmd[0], key, code, int sense[13], p);
# if(key == 0)
# return dcount;
return -1;
}
Scsi.open(dev: string): ref Scsi
{
rawfd := sys->open(dev+"/raw", Sys->ORDWR);
if(rawfd == nil)
return nil;
ctlfd := sys->open(dev+"/ctl", Sys->ORDWR);
if(ctlfd == nil)
return nil;
buf := array[512] of byte;
n := sys->readn(ctlfd, buf, len buf);
if(n < 8){
if(n >= 0)
sys->werrstr("error reading ctl file");
return nil;
}
ctlfd = nil;
for(i := 0; i < n; i++)
if(buf[i] == byte '\n')
break;
inq := string buf[0:i];
if(i >= n || inq[0:8] != "inquiry "){
sys->werrstr("invalid inquiry string");
return nil;
}
s := ref Scsi;
s.lock = chan[1] of int;
s.rawfd = rawfd;
s.inquire = inq[8:];
s.changetime = daytime->now();
if(s.ready() < 0)
return nil;
return s;
}
qlock(s: ref Scsi)
{
s.lock <-= 1;
}
qunlock(s: ref Scsi)
{
<-s.lock;
}