ref: fb7dd4b3a868cb8987049c95bb32e6425a73c8b9
dir: /appl/lib/usb/usb.b/
#
# Copyright © 2002 Vita Nuova Holdings Limited
#
implement Usb;
include "sys.m";
sys: Sys;
include "usb.m";
include "string.m";
str: String;
Proto: adt {
proto: int;
name: string;
};
SubClass: adt {
subclass: int;
name: string;
proto: array of Proto;
};
Class: adt {
class: int;
name: string;
subclass: array of SubClass;
};
classes := array [] of {
Class(Usb->CL_AUDIO, "audio",
array [] of {
SubClass(1, "control", nil),
SubClass(2, "stream", nil),
SubClass(3, "midi", nil),
}
),
Class(Usb->CL_COMMS, "comms",
array [] of {
SubClass(1, "abstract",
array [] of {
Proto(1, "AT"),
}
)
}
),
Class(Usb->CL_HID, "hid",
array [] of {
SubClass(1, "boot",
array [] of {
Proto(1, "kbd"),
Proto(2, "mouse"),
}
)
}
),
Class(Usb->CL_PRINTER, "printer",
array [] of {
SubClass(1, "printer",
array [] of {
Proto(1, "uni"),
Proto(2, "bi"),
}
)
}
),
Class(Usb->CL_HUB, "hub",
array [] of {
SubClass(1, "hub", nil),
}
),
Class(Usb->CL_DATA, "data", nil),
Class(Usb->CL_MASS, "mass",
array [] of {
SubClass(1, "rbc",
array [] of {
Proto(0, "cbi-cc"),
Proto(1, "cbi-nocc"),
Proto(16r50, "bulkonly"),
}
),
SubClass(2, "sff-8020i/mmc-2",
array [] of {
Proto(0, "cbi-cc"),
Proto(1, "cbi-nocc"),
Proto(16r50, "bulkonly"),
}
),
SubClass(3, "qic-157",
array [] of {
Proto(0, "cbi-cc"),
Proto(1, "cbi-nocc"),
Proto(16r50, "bulkonly"),
}
),
SubClass(4, "ufi",
array [] of {
Proto(0, "cbi-cc"),
Proto(1, "cbi-nocc"),
Proto(16r50, "bulkonly"),
}
),
SubClass(5, "sff-8070i",
array [] of {
Proto(0, "cbi-cc"),
Proto(1, "cbi-nocc"),
Proto(16r50, "bulkonly"),
}
),
SubClass(6, "scsi",
array [] of {
Proto(0, "cbi-cc"),
Proto(1, "cbi-nocc"),
Proto(16r50, "bulkonly"),
}
),
}
),
};
get2(b: array of byte): int
{
return int b[0] | (int b[1] << 8);
}
put2(buf: array of byte, v: int)
{
buf[0] = byte v;
buf[1] = byte (v >> 8);
}
get4(b: array of byte): int
{
return int b[0] | (int b[1] << 8) | (int b[2] << 16) | (int b[3] << 24);
}
put4(buf: array of byte, v: int)
{
buf[0] = byte v;
buf[1] = byte (v >> 8);
buf[2] = byte (v >> 16);
buf[3] = byte (v >> 24);
}
bigget2(b: array of byte): int
{
return int b[1] | (int b[0] << 8);
}
bigput2(buf: array of byte, v: int)
{
buf[1] = byte v;
buf[0] = byte (v >> 8);
}
bigget4(b: array of byte): int
{
return int b[3] | (int b[2] << 8) | (int b[1] << 16) | (int b[0] << 24);
}
bigput4(buf: array of byte, v: int)
{
buf[3] = byte v;
buf[2] = byte (v >> 8);
buf[1] = byte (v >> 16);
buf[0] = byte (v >> 24);
}
strtol(s: string, base: int): (int, string)
{
if (str == nil)
str = load String String->PATH;
if (base != 0)
return str->toint(s, base);
if (len s >= 2 && (s[0:2] == "0X" || s[0:2] == "0x"))
return str->toint(s[2:], 16);
if (len s > 0 && s[0:1] == "0")
return str->toint(s[1:], 8);
return str->toint(s, 10);
}
memset(buf: array of byte, v: int)
{
for (x := 0; x < len buf; x++)
buf[x] = byte v;
}
setupreq(setupfd: ref Sys->FD, typ, req, value, index: int, outbuf: array of byte, count: int): int
{
additional: int;
if (outbuf != nil) {
additional = len outbuf;
# if there is an outbuf, then the count sent must be length of the payload
# this assumes that RH2D is set
count = additional;
}
else
additional = 0;
buf := array[8 + additional] of byte;
buf[0] = byte typ;
buf[1] = byte req;
put2(buf[2:], value);
put2(buf[4:], index);
put2(buf[6:], count);
if (additional)
buf[8:] = outbuf;
rv := sys->write(setupfd, buf, len buf);
if (rv < 0)
return -1;
if (rv != len buf)
return -1;
return rv;
}
setupreply(setupfd: ref Sys->FD, buf: array of byte): int
{
nb := sys->read(setupfd, buf, len buf);
return nb;
}
setup(setupfd: ref Sys->FD, typ, req, value, index: int, outbuf: array of byte, inbuf: array of byte): int
{
count: int;
if (inbuf != nil)
count = len inbuf;
else
count = 0;
if (setupreq(setupfd, typ, req, value, index, outbuf, count) < 0)
return -1;
if (count == 0)
return 0;
return setupreply(setupfd, inbuf);
}
get_descriptor(fd: ref Sys->FD, rtyp: int, dtyp: int, dindex: int, langid: int, buf: array of byte): int
{
nr := -1;
if (setupreq(fd, RD2H | rtyp | Rdevice, GET_DESCRIPTOR, (dtyp << 8) | dindex, langid, nil, len buf) < 0
|| (nr = setupreply(fd, buf)) < 1)
return -1;
return nr;
}
get_standard_descriptor(fd: ref Sys->FD, dtyp: int, index: int, buf: array of byte): int
{
return get_descriptor(fd, Rstandard, dtyp, index, 0, buf);
}
get_class_descriptor(fd: ref Sys->FD, dtyp: int, index: int, buf: array of byte): int
{
return get_descriptor(fd, Rclass, dtyp, index, 0, buf);
}
get_vendor_descriptor(fd: ref Sys->FD, dtyp: int, index: int, buf: array of byte): int
{
return get_descriptor(fd, Rvendor, dtyp, index, 0, buf);
}
get_status(fd: ref Sys->FD, port: int): int
{
buf := array [4] of byte;
if (setupreq(fd, RD2H | Rclass | Rother, GET_STATUS, 0, port, nil, len buf) < 0
|| setupreply(fd, buf) < len buf)
return -1;
return get2(buf);
}
set_address(fd: ref Sys->FD, address: int): int
{
return setupreq(fd, RH2D | Rstandard | Rdevice, SET_ADDRESS, address, 0, nil, 0);
}
set_configuration(fd: ref Sys->FD, n: int): int
{
return setupreq(fd, RH2D | Rstandard | Rdevice, SET_CONFIGURATION, n, 0, nil, 0);
}
setclear_feature(fd: ref Sys->FD, rtyp: int, value: int, index: int, on: int): int
{
req: int;
if (on)
req = SET_FEATURE;
else
req = CLEAR_FEATURE;
return setupreq(fd, RH2D | rtyp, req, value, index, nil, 0);
}
parse_conf(b: array of byte): ref Configuration
{
if (len b < DCONFLEN)
return nil;
conf := ref Configuration;
conf.id = int b[5];
conf.iface = array[int b[4]] of Interface;
conf.attr = int b[7];
conf.powerma = int b[8] * 2;
return conf;
}
parse_iface(conf: ref Configuration, b: array of byte): ref AltInterface
{
if (len b < DINTERLEN || conf == nil)
return nil;
id := int b[2];
if (id >= len conf.iface)
return nil;
ai := ref AltInterface;
ai.id = int b[3];
if (int b[4] != 0)
ai.ep = array [int b[4]] of ref Endpt;
ai.class = int b[5];
ai.subclass = int b[6];
ai.proto = int b[7];
conf.iface[id].altiface = ai :: conf.iface[id].altiface;
return ai;
}
parse_endpt(conf: ref Configuration, ai: ref AltInterface, b: array of byte): ref Endpt
{
if (len b < DENDPLEN || conf == nil || ai == nil || ai.ep == nil)
return nil;
for (i := 0; i < len ai.ep; i++)
if (ai.ep[i] == nil)
break;
if (i >= len ai.ep)
return nil;
ep := ref Endpt;
ai.ep[i] = ep;
ep.addr = int b[2];
ep.attr = int b[3];
ep.d2h = ep.addr & 16r80;
ep.etype = int b[3] & 3;
ep.isotype = (int b[3] >> 2) & 3;
ep.maxpkt = get2(b[4:]);
ep.interval = int b[6];
return ep;
}
get_parsed_configuration_descriptor(fd: ref Sys->FD, n: int): ref Configuration
{
conf: ref Configuration;
altiface: ref AltInterface;
b := array [256] of byte;
nr := get_standard_descriptor(fd, CONFIGURATION, n, b);
if (nr < 0)
return nil;
conf = nil;
altiface = nil;
for (i := 0; nr - i > 2 && b[i] > byte 0 && int b[i] <= nr - i; i += int b[i]) {
ni := i + int b[i];
case int b[i + 1] {
Usb->CONFIGURATION =>
conf = parse_conf(b[i: ni]);
if (conf == nil)
return nil;
Usb->INTERFACE =>
altiface = parse_iface(conf, b[i: ni]);
if (altiface == nil)
return nil;
Usb->ENDPOINT =>
if (parse_endpt(conf, altiface, b[i: ni]) == nil)
return nil;
}
}
if (i < nr)
sys->print("usb: residue at end of descriptors\n");
return conf;
}
get_parsed_device_descriptor(fd: ref Sys->FD): ref Device
{
b := array [256] of byte;
nr := get_standard_descriptor(fd, DEVICE, 0, b);
if (nr < DDEVLEN) {
if (nr == 8 || nr == 16) {
memset(b[nr: DDEVLEN - 1], 0);
b[DDEVLEN - 1] = byte 1;
nr = DDEVLEN;
}
else
return nil;
}
dev := ref Device;
dev.usbmajor = int b[3];
dev.usbminor = int b[2];
dev.class = int b[4];
dev.subclass = int b[5];
dev.proto = int b[6];
dev.maxpkt0 = int b[7];
dev.vid = get2(b[8:]);
dev.did = get2(b[10:]);
dev.relmajor = int b[13];
dev.relminor = int b[12];
dev.nconf = int b[17];
return dev;
}
dump_configuration(fd: ref Sys->FD, conf: ref Configuration)
{
sys->fprint(fd, "configuration %d attr 0x%.x powerma %d\n", conf.id, conf.attr, conf.powerma);
for (i := 0; i < len conf.iface; i++) {
sys->fprint(fd, "\tinterface %d\n", i);
ail := conf.iface[i].altiface;
while (ail != nil) {
ai := hd ail;
sys->fprint(fd, "\t\t%d class %d subclass %d proto %d [%s]\n",
ai.id, ai.class, ai.subclass, ai.proto,
sclass(ai.class, ai.subclass, ai.proto));
for (e := 0; e < len ai.ep; e++) {
if (ai.ep[e] == nil) {
sys->fprint(fd, "\t\t\t missing descriptor\n");
continue;
}
sys->fprint(fd, "\t\t\t0x%.2ux attr 0x%.x maxpkt %d interval %d\n",
ai.ep[e].addr, ai.ep[e].attr, ai.ep[e].maxpkt, ai.ep[e].interval);
}
ail = tl ail;
}
}
sys->fprint(fd, "done dumping\n");
}
sclass(class, subclass, proto: int): string
{
for (c := 0; c < len classes; c++)
if (classes[c].class == class)
break;
if (c >= len classes)
return sys->sprint("%d.%d.%d", class, subclass, proto);
if (classes[c].subclass == nil)
return sys->sprint("%s.%d.%d", classes[c].name, subclass, proto);
for (sc := 0; sc < len classes[c].subclass; sc++)
if (classes[c].subclass[sc].subclass == subclass)
break;
if (sc >= len classes[c].subclass)
return sys->sprint("%s.%d.%d", classes[c].name, subclass, proto);
if (classes[c].subclass[sc].proto == nil)
return sys->sprint("%s.%s.%d", classes[c].name, classes[c].subclass[sc].name, proto);
for (p := 0; p < len classes[c].subclass[sc].proto; p++)
if (classes[c].subclass[sc].proto[p].proto == proto)
break;
if (p >= len classes[c].subclass[sc].proto)
return sys->sprint("%s.%s.%d", classes[c].name, classes[c].subclass[sc].name, proto);
return sys->sprint("%s.%s.%s", classes[c].name, classes[c].subclass[sc].name,
classes[c].subclass[sc].proto[p].name);
}
init()
{
sys = load Sys Sys->PATH;
}