Re: [9fans] usbd problem

[Sape Mullender <sape@plan9.bell-labs.com>]

[-- Attachment #1: Type: text/plain, Size: 296 bytes --]

>> Nemo found a bug in usb/lib/dump.c that may well account for
>> this.  I incorporated his change (and fixed a bug in his code :-).
>> I'll ask Geoff to push it out today.
>>
>> 	Sape
>
> excellent.  i'll give it a shot.
>
> - erik

Give it a shot now:
	/sys/src/cmd/usb/lib/dump.c

[-- Attachment #2: dump.c --]
[-- Type: text/plain, Size: 14184 bytes --]

#include <u.h>
#include <libc.h>
#include <thread.h>
#include <bio.h>
#include "usb.h"

int verbose;

typedef struct Flags Flags;
typedef struct Classes Classes;

struct Flags {
	int	bit;
	char*	name0;
	char*	name1;
};

struct Classes {
	char*	name;
	struct {
		char*	name;
		char*	proto[4];
	} subclass[4];
};

static Classes	classname[] = {
	[CL_AUDIO]	{"audio",	{[1]{"control"}, [2]{"stream"}, [3]{"midi"}}},
	[CL_COMMS]	{"comms",	{[1] {"abstract", {[1]"AT"}}}},
	[CL_HID]	{"hid",		{[1] {"boot", {[1]"kbd", [2]"mouse"}}}},
	[CL_PRINTER]	{"printer",	{[1]"printer", {[1]"uni", [2]"bi"}}},
	[CL_HUB]	{"hub",		{[1]{"hub"}}},
	[CL_DATA]	{"data"},
};

static	void	pflag(Flags*, uint);

char *
sclass(char *p, char *e, ulong csp)
{
	Classes *cs;
	int c, s, pr;

	c = Class(csp);
	s = Subclass(csp);
	pr = Proto(csp);
	if(c < 0 || c >= nelem(classname) || (cs = &classname[c])->name == nil)
		return seprint(p, e, "%d.%d.%d", c, s, pr);
	p = seprint(p, e, "%s.", cs->name);
	if(s < 0 || s >= nelem(cs->subclass) || cs->subclass[s].name == nil)
		p = seprint(p, e, "%d.%d", s, pr);
	else{
		p = seprint(p, e, "%s.", cs->subclass[s].name);
		if(pr < 0 || pr >= nelem(cs->subclass[s].proto) || cs->subclass[s].proto[pr] == nil)
			p = seprint(p, e, "%d", pr);
		else
			p = seprint(p, e, "%s", cs->subclass[s].proto[pr]);
	}
	return p;
}

void
pdevice(Device *, int, ulong, void *b, int n)
{
	DDevice *d;
	char scbuf[64];

	if(n < DDEVLEN)
		return;
	d = b;
	if(debug & Dbginfo) {
		fprint(2, "usb (bcd)%c%c%c%c",
				'0'+((d->bcdUSB[1]>>4)&0xf), '0'+(d->bcdUSB[1]&0xf),
				'0'+((d->bcdUSB[0]>>4)&0xf), '0'+(d->bcdUSB[0]&0xf));
		sclass(scbuf, scbuf + sizeof scbuf,
			CSP(d->bDeviceClass, d->bDeviceSubClass, d->bDeviceProtocol)),
		fprint(2, " class %d subclass %d proto %d [%s] max0 %d",
			d->bDeviceClass, d->bDeviceSubClass, d->bDeviceProtocol,
			scbuf,
			d->bMaxPacketSize0);
		fprint(2, " vendor %#x product %#x device (bcd)%c%c%c%c",
			GET2(d->idVendor), GET2(d->idProduct),
			'0'+((d->bcdDevice[1]>>4)&0xf), '0'+(d->bcdDevice[1]&0xf),
			'0'+((d->bcdDevice[0]>>4)&0xf), '0'+(d->bcdDevice[0]&0xf));
		fprint(2, " man %d prod %d serial %d nconfig %d",
			d->iManufacturer, d->iProduct, d->iSerialNumber,
			d->bNumConfigurations);
	}
}

void
phid(Device *, int, ulong, void *b, int n)
{
	DHid *d;

	if(n < DHIDLEN){
		fprint(2, "%s: hid too short\n", argv0);
		return;
	}
	d = b;
	if(debug & Dbginfo)
		fprint(2, "HID (bcd)%c%c%c%c country %d nhidclass %d classdtype %#x dlen %d\n",
			'0'+((d->bcdHID[1]>>4)&0xf), '0'+(d->bcdHID[1]&0xf),
			'0'+((d->bcdHID[0]>>4)&0xf), '0'+(d->bcdHID[0]&0xf),
			d->bCountryCode, d->bNumDescriptors,
			d->bClassDescriptorType, GET2(d->wItemLength));
}

static	Flags	ioflags[] = {
	{0, "Data", "Constant"},
	{1, "Array", "Variable"},
	{2, "Absolute", "Relative"},
	{3, "NoWrap", "Wrap"},
	{4, "Linear", "NonLinear"},
	{5, "PreferredState", "No Preferred State"},
	{6, "No Null position", "Null state"},
	{7, "Non Volatile", "Volatile"},
	{8, "Bit Field", "Buffered Bytes"},
	{-1, nil, nil},
};

static void
pflag(Flags *tab, uint v)
{
	char buf[200], *s;
	int n;

	n = 0;
	buf[0] = 0;
	for(; tab->name0 != nil; tab++){
		if(v & (1<<tab->bit))
			s = tab->name1;
		else
			s = tab->name0;
		if(s != nil && *s)
			n += snprint(buf+n, sizeof(buf)-n, ", %s", s);
	}
	if((debug & Dbginfo) && buf[0])
		fprint(2, "[%s]", buf+2);
}

void
preport(Device *, int, ulong, byte *b, int n)
{
	byte *s, *es;
	int tag, nb, i, indent;
	int v;
	Flags *tab;

	s = b+2;
	es = b+n;
	indent = 0;
	while(s < es){
		for(i=0; i<indent; i++)
			fprint(2, " ");
		tag = *s++;
		if(tag == Tlong){
			fprint(2, "long report tag");
			return;
		}
		if((nb = tag&3) == 3)
			nb = 4;
		v = 0;
		for(i=0; i<nb; i++)
			v |= s[i] << (i*8);
		switch(tag & Tmtype){
		case Treserved:
			if(tag == Tlong){
				fprint(2, "long report tag");
				return;
			}
			fprint(2, "illegal tag");
			return;
		case Tmain:
			tab = nil;
			if (debug & Dbginfo) {
				switch(tag & Tmitem){
				case Tinput:
					fprint(2, "Input");
					tab = ioflags;
					break;
				case Toutput:
					fprint(2, "Output");
					tab = ioflags;
					break;
				case Tfeature:
					fprint(2, "Feature");
					tab = ioflags;
					break;
				case Tcoll:
					fprint(2, "Collection");
					indent++;
					break;
				case Tecoll:
					fprint(2, "End Collection");
					indent--;
					break;
				default:
					fprint(2, "unexpected item %.2x", tag);
				}
				fprint(2, "=%#ux", v);
				if(tab != nil)
					pflag(tab, v);
			}
			break;
		case Tglobal:
			if (debug & Dbginfo) {
				fprint(2, "Global %#ux: ", v);
				switch(tag & Tmitem){
				case Tusagepage:
					fprint(2, "Usage Page %#ux", v);
					break;
				case Tlmin:
					fprint(2, "Logical Min %d", v);
					break;
				case Tlmax:
					fprint(2, "Logical Max %d", v);
					break;
				case Tpmin:
					fprint(2, "Physical Min %d", v);
					break;
				case Tpmax:
					fprint(2, "Physical Max %d", v);
					break;
				case Tunitexp:
					fprint(2, "Unit Exponent %d", v);
					break;
				case Tunit:
					fprint(2, "Unit %d", v);
					break;
				case Trepsize:
					fprint(2, "Report size %d", v);
					break;
				case TrepID:
					fprint(2, "Report ID %#x", v);
					break;
				case Trepcount:
					fprint(2, "Report Count %d", v);
					break;
				case Tpush:
					fprint(2, "Push %d", v);
					break;
				case Tpop:
					fprint(2, "Pop %d", v);
					break;
				default:
					fprint(2, "Unknown %#ux", v);
					break;
				}
			}
			break;
		case Tlocal:
			if (debug & Dbginfo) {
				fprint(2, "Local %#ux: ", v);
				switch(tag & Tmitem){
				case Tusage:
					fprint(2, "Usage %d", v);
					break;
				case Tumin:
					fprint(2, "Usage min %d", v);
					break;
				case Tumax:
					fprint(2, "Usage max %d", v);
					break;
				case Tdindex:
					fprint(2, "Designator index %d", v);
					break;
				case Tdmin:
					fprint(2, "Designator min %d", v);
					break;
				case Tdmax:
					fprint(2, "Designator max %d", v);
					break;
				case Tsindex:
					fprint(2, "String index %d", v);
					break;
				case Tsmin:
					fprint(2, "String min %d", v);
					break;
				case Tsmax:
					fprint(2, "String max %d", v);
					break;
				case Tsetdelim:
					fprint(2, "Set delim %#ux", v);
					break;
				default:
					fprint(2, "Unknown %#ux", v);
					break;
				}
			}
			break;
		}
		fprint(2, "\n");
		s += nb;
	}
}

void
phub(Device *, int, ulong, void *b, int n)
{
	DHub *d;

	if(n < DHUBLEN)
		return;
	d = b;
	if (debug & Dbginfo)
		fprint(2, "nport %d charac %#.4x pwr %dms current %dmA remov %#.2x",
			d->bNbrPorts, GET2(d->wHubCharacteristics),
			d->bPwrOn2PwrGood*2, d->bHubContrCurrent,
			d->DeviceRemovable[0]);
}

void
pstring(Device *, int, ulong, void *b, int n)
{
	byte *rb;
	char *s;
	Rune r;
	int l;

	if(n <= 2){
		fprint(2, "\"\"");
		return;
	}
	if(n & 1){
		fprint(2, "illegal count\n");
		return;
	}
	n = (n - 2)/2;
	rb = (byte*)b + 2;
	s = malloc(n*UTFmax+1);
	for(l=0; --n >= 0; rb += 2){
		r = GET2(rb);
		l += runetochar(s+l, &r);
	}
	s[l] = 0;
	fprint(2, "\"%s\"", s);
	free(s);
}

void
pcs_raw(char *tag, byte *b, int n)
{
	int i;

	if (debug & Dbginfo) {
		fprint(2, "%s", tag);
		for(i=2; i<n; i++)
			fprint(2, " %.2x", b[i]);
	}
}

static void
pcs_config(Device *, int, ulong, void *b, int n)
{
	pcs_raw("CS_CONFIG", b, n);
}

static void
pcs_string(Device *, ulong, void *b, int n)
{
	pcs_raw("CS_STRING", b, n);
}

static void
pcs_endpoint(Device *, int, ulong, void *bb, int n)
{
	byte *b = bb;

	if (debug & Dbginfo) {
		switch(b[2]) {
		case 0x01:
			fprint(2,
		"CS_ENDPOINT for TerminalID %d, delay %d, format_tag %#ux\n",
				b[3], b[4], b[5] | (b[6]<<8));
			break;
		case 0x02:
			fprint(2,
"CS_INTERFACE FORMAT_TYPE %d, channels %d, subframesize %d, resolution %d, freqtype %d, ",
				b[3], b[4], b[5], b[6], b[7]);
			fprint(2, "freq0 %d, freq1 %d\n",
				b[8]  |  b[9]<<8 | b[10]<<16,
				b[11] | b[12]<<8 | b[13]<<16);
			break;
		default:
			pcs_raw("CS_INTERFACE", bb, n);
		}
	}
}

static void
pcs_interface(Device *, int n, ulong, void *bb, int nb)
{

	if ((debug & Dbginfo) && n >= 0)
		pcs_raw("CS_INTERFACE", bb, nb);
}

void
pdesc(Device *d, int c, ulong csp, byte *b, int n)
{
	int class, subclass, proto, dalt, i, ep, ifc, len;
	DConfig *dc;
	DEndpoint *de;
	DInterface *di;
	Dinf *dif;
	Endpt *dep;
	void (*f)(Device *, int, ulong, void*, int);
	char scbuf[64];

	class = Class(csp);
	dalt = -1;
	ifc = -1;
	if (c >= nelem(d->config)) {
		fprint(2, "Too many interfaces (%d of %d)\n",
			c, nelem(d->config));
		return;
	}
	if(debug & Dbginfo)
		fprint(2, "pdesc %d.%d [%d]\n", d->id, c, n);
	len = -1;
	while(n > 2 && b[0] && b[0] <= n){
		if (debug & Dbginfo)
			fprint(2, "desc %d.%d [%d] %#2.2x: ", d->id, c, b[0], b[1]);
		switch (b[1]) {
		case CONFIGURATION:
			if(b[0] < DCONFLEN){
				if(debug & Dbginfo)
					fprint(2, "short config %d < %d", b[0], DCONFLEN);
				return;
			}
			dc = (DConfig*)b;
			d->config[c]->nif = dc->bNumInterfaces;
			d->config[c]->cval = dc->bConfigurationValue;
			d->config[c]->attrib = dc->bmAttributes;
			d->config[c]->milliamps = dc->MaxPower*2;
			d->nif += d->config[c]->nif;
			if (debug & Dbginfo)
				fprint(2, "config %d: tdlen %d ninterface %d iconfig %d attr %#.2x power %dmA\n",
					dc->bConfigurationValue,
					GET2(dc->wTotalLength),
					dc->bNumInterfaces, dc->iConfiguration,
					dc->bmAttributes, dc->MaxPower*2);
			break;
		case INTERFACE:
			if(n < DINTERLEN){
				if(debug & Dbginfo)
					fprint(2, "short interface %d < %d", b[0], DINTERLEN);
				return;
			}
			di = (DInterface *)b;
			class = di->bInterfaceClass;
			subclass = di->bInterfaceSubClass;
			proto = di->bInterfaceProtocol;
			csp = CSP(class, subclass, proto);
			if(debug & Dbginfo){
				sclass(scbuf, scbuf + sizeof scbuf, csp);
				fprint(2, "interface %d: alt %d nept %d class %#x subclass %#x proto %d [%s] iinterface %d\n",
					di->bInterfaceNumber,
					di->bAlternateSetting,
					di->bNumEndpoints, class, subclass,
					proto, scbuf, di->iInterface);
			}
			if (c < 0) {
				fprint(2, "Unexpected INTERFACE message\n");
				return;
			}
			ifc = di->bInterfaceNumber;
			dalt = di->bAlternateSetting;
			if (ifc < 0 || ifc >= nelem(d->config[c]->iface))
				sysfatal("Bad interface number %d", ifc);
			if (dalt < 0 ||
			    dalt >= nelem(d->config[c]->iface[ifc]->dalt))
				sysfatal("Bad alternate number %d", dalt);
			if (d->config[c] == nil)
				sysfatal("No config");
			if (ifc == 0) {
				if (c == 0)
					d->ep[0]->csp = csp;
				d->config[c]->csp = csp;
			}
			dif = d->config[c]->iface[ifc];
			if (dif == nil) {
				d->config[c]->iface[ifc] = dif =
					mallocz(sizeof(Dinf), 1);
				dif->csp = csp;
			}
			dif->interface = di->bInterfaceNumber;
			break;
		case ENDPOINT:
			if(n < DENDPLEN)
				return;
			de = (DEndpoint *)b;
			if(debug & Dbginfo) {
				fprint(2, "addr %#2.2x attrib %#2.2x maxpkt %d interval %dms",
					de->bEndpointAddress, de->bmAttributes,
					GET2(de->wMaxPacketSize), de->bInterval);
				if(de->bEndpointAddress & 0x80)
					fprint(2, " [IN]");
				else
					fprint(2, " [OUT]");
				switch(de->bmAttributes&0x33){
				case 0:
					fprint(2, " [Control]");
					break;
				case 1:
					fprint(2, " [Iso]");
					switch(de->bmAttributes&0xc){
					case 0x4:
						fprint(2, " [Asynchronous]");
						break;
					case 0x8:
						fprint(2, " [Adaptive]");
						break;
					case 0xc:
						fprint(2, " [Synchronous]");
						break;
					}
					break;
				case 2:
					fprint(2, " [Bulk]");
					break;
				case 3:
					fprint(2, " [Interrupt]");
					break;
				}
				if(b[0] == 9)
					fprint(2, "refresh %d synchaddress %d",
						b[7], b[8]);
				fprint(2, "\n");
			}
			if (c < 0 || ifc < 0 || dalt < 0) {
				fprint(2, "Unexpected ENDPOINT message\n");
				return;
			}
			dif = d->config[c]->iface[ifc];
			if (dif == nil)
				sysfatal("d->config[%d]->iface[%d] == nil",
					c, ifc);
			if (dif->dalt[dalt] == nil)
				dif->dalt[dalt] = mallocz(sizeof(Dalt),1);
			dif->dalt[dalt]->attrib = de->bmAttributes;
			dif->dalt[dalt]->interval = de->bInterval;
			ep = de->bEndpointAddress & 0xf;
			dep = d->ep[ep];
			if(debug)
				fprint(2, "%s: endpoint addr %d\n", argv0, ep);
			if(dep == nil){
				d->ep[ep] = dep = newendpt(d, ep, class);
				dep->dir = de->bEndpointAddress & 0x80
					? Ein : Eout;
			}else if ((dep->addr&0x80) !=
			    (de->bEndpointAddress&0x80))
				dep->dir = Eboth;
			dep->maxpkt = GET2(de->wMaxPacketSize);
			dep->addr = de->bEndpointAddress;
			dep->type = de->bmAttributes & 0x03;
			dep->isotype = (de->bmAttributes>>2) & 0x03;
			dep->csp = csp;
			dep->conf = d->config[c];
			dep->iface = dif;
			for(i = 0; i < nelem(dif->endpt); i++)
				if(dif->endpt[i] == nil){
					dif->endpt[i] = dep;
					break;
				}
			if(i == nelem(dif->endpt))
				fprint(2, "Too many endpoints\n");
			if (d->nif <= ep)
				d->nif = ep+1;
			break;
		default:
			assert(nelem(dprinter) == 0x100);
			f = dprinter[b[1]];
			if(f != nil){
				(*f)(d, c, dalt<<24 | ifc<<16 | (csp&0xffff),
					b, b[0]);
				if(debug & Dbginfo)
					fprint(2, "\n");
			}else
				if(verbose){
					int i;

					switch(b[1]){
					case DEVICE:
						fprint(2, "(device)");
						break;
					case STRING:
						fprint(2, "(string)");
						break;
					default:
						fprint(2, "(unknown type)");
					}
					for(i=1; i<b[0]; i++)
						fprint(2, " %.2x", b[i]);
					fprint(2, "\n");
				}else if(debug & Dbginfo)
					fprint(2, "\n");
			break;
		}
		len = b[0];
		n -= len;
		b += len;
	}
	if(n)
		fprint(2, "pdesc: %d bytes left unparsed, b[0]=%d, b[-len]=%d, len=%d\n", n, b[0], b[-len], len);
}