Subversion Repositories planix.SVN

/*

 * USB Enhanced Host Controller Interface (EHCI) driver

 * High speed USB 2.0.

 *

 * Note that all of our unlock routines call coherence.

 *

 * BUGS:

 * - Too many delays and ilocks.

 * - bandwidth admission control must be done per-frame.

 * - requires polling (some controllers miss interrupts).

 * - must warn of power overruns.

 */

#include	"u.h"

#include	"../port/lib.h"

#include	"mem.h"

#include	"dat.h"

#include	"fns.h"

#include	"io.h"

#include	"../port/error.h"

#include	"../port/usb.h"

#include	"../port/portusbehci.h"

#include	"usbehci.h"

#include	"uncached.h"

#define diprint		if(ehcidebug || iso->debug)print

#define ddiprint	if(ehcidebug>1 || iso->debug>1)print

#define dqprint		if(ehcidebug || (qh->io && qh->io->debug))print

#define ddqprint	if(ehcidebug>1 || (qh->io && qh->io->debug>1))print

#define TRUNC(x, sz)	((x) & ((sz)-1))

#define LPTR(q)		((ulong*)KADDR((q) & ~0x1F))

typedef struct Ctlio Ctlio;

typedef union Ed Ed;

typedef struct Edpool Edpool;

typedef struct Itd Itd;

typedef struct Qio Qio;

typedef struct Qtd Qtd;

typedef struct Sitd Sitd;

typedef struct Td Td;

/*

 * EHCI interface registers and bits

 */

enum

{

	/* Queue states (software) */

	Qidle		= 0,

	Qinstall,

	Qrun,

	Qdone,

	Qclose,

	Qfree,

	Enabledelay	= 100,		/* waiting for a port to enable */

	Abortdelay	= 5,		/* delay after cancelling Tds (ms) */

	Incr		= 64,		/* for pools of Tds, Qhs, etc. */

	Align		= 128,		/* in bytes for all those descriptors */

	/* Keep them as a power of 2, lower than ctlr->nframes */

	/* Also, keep Nisoframes >= Nintrleafs */

	Nintrleafs	= 32,		/* nb. of leaf frames in intr. tree */

	Nisoframes	= 64,		/* nb. of iso frames (in window) */

	/*

	 * HW constants

	 */

	/* Itd bits (csw[]) */

	Itdactive	= 0x80000000,	/* execution enabled */

	Itddberr	= 0x40000000,	/* data buffer error */

	Itdbabble	= 0x20000000,	/* babble error */

	Itdtrerr	= 0x10000000,	/* transaction error */

	Itdlenshift	= 16,		/* transaction length */

	Itdlenmask	= 0xFFF,

	Itdioc		= 0x00008000,	/* interrupt on complete */

	Itdpgshift	= 12,		/* page select field */

	Itdoffshift	= 0,		/* transaction offset */

	/* Itd bits, buffer[] */

	Itdepshift	= 8,		/* endpoint address (buffer[0]) */

	Itddevshift	= 0,		/* device address (buffer[0]) */

	Itdin		= 0x800,	/* is input (buffer[1]) */

	Itdout		= 0,

	Itdmaxpktshift	= 0,		/* max packet (buffer[1]) */

	Itdntdsshift	= 0,		/* nb. of tds per µframe (buffer[2]) */

	Itderrors	= Itddberr|Itdbabble|Itdtrerr,

	/* Sitd bits (epc) */

	Stdin		= 0x80000000,	/* input direction */

	Stdportshift	= 24,		/* hub port number */

	Stdhubshift	= 16,		/* hub address */

	Stdepshift	= 8,		/* endpoint address */

	Stddevshift	= 0,		/* device address */

	/* Sitd bits (mfs) */

	Stdssmshift	= 0,		/* split start mask */

	Stdscmshift	= 8,		/* split complete mask */

	/* Sitd bits (csw) */

	Stdioc		= 0x80000000,	/* interrupt on complete */

	Stdpg		= 0x40000000,	/* page select */

	Stdlenshift	= 16,		/* total bytes to transfer */

	Stdlenmask	= 0x3FF,

	Stdactive	= 0x00000080,	/* active */

	Stderr		= 0x00000040,	/* tr. translator error */

	Stddberr	= 0x00000020,	/* data buffer error */

	Stdbabble	= 0x00000010,	/* babble error */

	Stdtrerr	= 0x00000008,	/* transaction error */

	Stdmmf		= 0x00000004,	/* missed µframe */

	Stddcs		= 0x00000002,	/* do complete split */

	Stderrors	= Stderr|Stddberr|Stdbabble|Stdtrerr|Stdmmf,

	/* Sitd bits buffer[1] */

	Stdtpall	= 0x00000000,	/* all payload here (188 bytes) */

	Stdtpbegin	= 0x00000008,	/* first payload for fs trans. */

	Stdtcntmask	= 0x00000007,	/* T-count */

	/* Td bits (csw) */

	Tddata1		= 0x80000000,	/* data toggle 1 */

	Tddata0		= 0x00000000,	/* data toggle 0 */

	Tdlenshift	= 16,		/* total bytes to transfer */

	Tdlenmask	= 0x7FFF,

	Tdmaxpkt	= 0x5000,	/* max buffer for a Td */

	Tdioc		= 0x00008000,	/* interrupt on complete */

	Tdpgshift	= 12,		/* current page */

	Tdpgmask	= 7,

	Tderr1		= 0x00000400,	/* bit 0 of error counter */

	Tderr2		= 0x00000800,	/* bit 1 of error counter */

	Tdtokout	= 0x00000000,	/* direction out */

	Tdtokin		= 0x00000100,	/* direction in */

	Tdtoksetup	= 0x00000200,	/* setup packet */

	Tdtok		= 0x00000300,	/* token bits */

	Tdactive		= 0x00000080,	/* active */

	Tdhalt		= 0x00000040,	/* halted */

	Tddberr		= 0x00000020,	/* data buffer error */

	Tdbabble	= 0x00000010,	/* babble error */

	Tdtrerr		= 0x00000008,	/* transaction error */

	Tdmmf		= 0x00000004,	/* missed µframe */

	Tddcs		= 0x00000002,	/* do complete split */

	Tdping		= 0x00000001,	/* do ping */

	Tderrors	= Tdhalt|Tddberr|Tdbabble|Tdtrerr|Tdmmf,

	/* Qh bits (eps0) */

	Qhrlcmask	= 0xF,		/* nak reload count */

	Qhrlcshift	= 28,		/* nak reload count */

	Qhnhctl		= 0x08000000,	/* not-high speed ctl */

	Qhmplmask	= 0x7FF,	/* max packet */

	Qhmplshift	= 16,

	Qhhrl		= 0x00008000,	/* head of reclamation list */

	Qhdtc		= 0x00004000,	/* data toggle ctl. */

	Qhint		= 0x00000080,	/* inactivate on next transition */

	Qhspeedmask	= 0x00003000,	/* speed bits */

	Qhfull		= 0x00000000,	/* full speed */

	Qhlow		= 0x00001000,	/* low speed */

	Qhhigh		= 0x00002000,	/* high speed */

	/* Qh bits (eps1) */

	Qhmultshift	= 30,		/* multiple tds per µframe */

	Qhmultmask	= 3,

	Qhportshift	= 23,		/* hub port number */

	Qhhubshift	= 16,		/* hub address */

	Qhscmshift	= 8,		/* split completion mask bits */

	Qhismshift	= 0,		/* interrupt sched. mask bits */

};

/*

 * Endpoint tree (software)

 */

struct Qtree

{

	int	nel;

	int	depth;

	ulong*	bw;

	Qh**	root;

};

/*

 * One per endpoint per direction, to control I/O.

 */

struct Qio

{

	QLock;			/* for the entire I/O process */

	Rendez;			/* wait for completion */

	Qh*	qh;		/* Td list (field const after init) */

	int	usbid;		/* usb address for endpoint/device */

	int	toggle;		/* Tddata0/Tddata1 */

	int	tok;		/* Tdtoksetup, Tdtokin, Tdtokout */

	ulong	iotime;		/* last I/O time; to hold interrupt polls */

	int	debug;		/* debug flag from the endpoint */

	char*	err;		/* error string */

	char*	tag;		/* debug (no room in Qh for this) */

	ulong	bw;

};

struct Ctlio

{

	Qio;			/* a single Qio for each RPC */

	uchar*	data;		/* read from last ctl req. */

	int	ndata;		/* number of bytes read */

};

struct Isoio

{

	QLock;

	Rendez;			/* wait for space/completion/errors */

	int	usbid;		/* address used for device/endpoint */

	int	tok;		/* Tdtokin or Tdtokout */

	int	state;		/* Qrun -> Qdone -> Qrun... -> Qclose */

	int	nframes;	/* number of frames ([S]Itds) used */

	uchar*	data;		/* iso data buffers if not embedded */

	char*	err;		/* error string */

	int	nerrs;		/* nb of consecutive I/O errors */

	ulong	maxsize;	/* ntds * ep->maxpkt */

	long	nleft;		/* number of bytes left from last write */

	int	debug;		/* debug flag from the endpoint */

	int	hs;		/* is high speed? */

	Isoio*	next;		/* in list of active Isoios */

	ulong	td0frno;	/* first frame used in ctlr */

	union{

		Itd*	tdi;	/* next td processed by interrupt */

		Sitd*	stdi;

	};

	union{

		Itd*	tdu;	/* next td for user I/O in tdps */

		Sitd*	stdu;

	};

	union{

		Itd**	itdps;	/* itdps[i]: ptr to Itd for i-th frame or nil */

		Sitd**	sitdps;	/* sitdps[i]: ptr to Sitd for i-th frame or nil */

		ulong**	tdps;	/* same thing, as seen by hw */

	};

};

struct Edpool

{

	Lock;

	Ed*	free;

	int	nalloc;

	int	ninuse;

	int	nfree;

};

/*

 * We use the 64-bit version for Itd, Sitd, Td, and Qh.

 * If the ehci is 64-bit capable it assumes we are using those

 * structures even when the system is 32 bits.

 */

/*

 * Iso transfer descriptor.  hw: 92 bytes, 108 bytes total

 * aligned to 32.

 */

struct Itd

{

	ulong	link;		/* to next hw struct */

	ulong	csw[8];		/* sts/length/pg/off. updated by hw */

	ulong	buffer[7];	/* buffer pointers, addrs, maxsz */

	ulong	xbuffer[7];	/* high 32 bits of buffer for 64-bits */

	ulong	_pad0;		/* pad to next cache line */

	/* cache-line boundary here */

	/* software */

	Itd*	next;

	ulong	ndata;		/* number of bytes in data */

	ulong	mdata;		/* max number of bytes in data */

	uchar*	data;

};

/*

 * Split transaction iso transfer descriptor.

 * hw: 36 bytes, 52 bytes total. aligned to 32.

 */

struct Sitd

{

	ulong	link;		/* to next hw struct */

	ulong	epc;		/* static endpoint state. addrs */

	ulong	mfs;		/* static endpoint state. µ-frame sched. */

	ulong	csw;		/* transfer state. updated by hw */

	ulong	buffer[2];	/* buf. ptr/offset. offset updated by hw */

				/* buf ptr/TP/Tcnt. TP/Tcnt updated by hw */

	ulong	blink;		/* back pointer */

	/* cache-line boundary after xbuffer[0] */

	ulong	xbuffer[2];	/* high 32 bits of buffer for 64-bits */

	/* software */

	Sitd*	next;

	ulong	ndata;		/* number of bytes in data */

	ulong	mdata;		/* max number of bytes in data */

	uchar*	data;

};

/*

 * Queue element transfer descriptor.

 * hw: first 52 bytes, total 68+sbuff bytes.  aligned to 32 bytes.

 */

struct Td

{

	ulong	nlink;		/* to next Td */

	ulong	alink;		/* alternate link to next Td */

	ulong	csw;		/* cmd/sts. updated by hw */

	ulong	buffer[5];	/* buf ptrs. offset updated by hw */

	/* cache-line boundary here */

	ulong	xbuffer[5];	/* high 32 bits of buffer for 64-bits */

	/* software */

	Td*	next;		/* in qh or Isoio or free list */

	ulong	ndata;		/* bytes available/used at data */

	uchar*	data;		/* pointer to actual data */

	uchar*	buff;		/* allocated data buffer or nil */

	uchar	sbuff[1];	/* first byte of embedded buffer */

};

/*

 * Queue head. Aligned to 32 bytes.

 * hw: first 68 bytes, 92 total.

 */

struct Qh

{

	ulong	link;		/* to next Qh in round robin */

	ulong	eps0;		/* static endpoint state. addrs */

	ulong	eps1;		/* static endpoint state. µ-frame sched. */

	/* updated by hw */

	ulong	tclink;		/* current Td (No Term bit here!) */

	ulong	nlink;		/* to next Td */

	ulong	alink;		/* alternate link to next Td */

	ulong	csw;		/* cmd/sts. updated by hw */

	/* cache-line boundary after buffer[0] */

	ulong	buffer[5];	/* buf ptrs. offset updated by hw */

	ulong	xbuffer[5];	/* high 32 bits of buffer for 64-bits */

	/* software */

	Qh*	next;		/* in controller list/tree of Qhs */

	int	state;		/* Qidle -> Qinstall -> Qrun -> Qdone | Qclose */

	Qio*	io;		/* for this queue */

	Td*	tds;		/* for this queue */

	int	sched;		/* slot for for intr. Qhs */

	Qh*	inext;		/* next in list of intr. qhs */

};

/*

 * We can avoid frame span traversal nodes if we don't span frames.

 * Just schedule transfers that can fit on the current frame and

 * wait a little bit otherwise.

 */

/*

 * Software. Ehci descriptors provided by pool.

 * There are soo few because we avoid using Fstn.

 */

union Ed

{

	Ed*	next;		/* in free list */

	Qh	qh;

	Td	td;

	Itd	itd;

	Sitd	sitd;

	uchar	align[Align];

};

int ehcidebug = 0;

static Edpool edpool;

static char* qhsname[] = { "idle", "install", "run", "done", "close", "FREE" };

Ecapio* ehcidebugcapio;

int ehcidebugport;

void

ehcirun(Ctlr *ctlr, int on)

{

	int i;

	Eopio *opio;

	ddprint("ehci %#p %s\n", ctlr->capio, on ? "starting" : "halting");

	opio = ctlr->opio;

	if(on)

		opio->cmd |= Crun;

	else

		opio->cmd = Cstop;

	coherence();

	for(i = 0; i < 100; i++)

		if(on == 0 && (opio->sts & Shalted) != 0)

			break;

		else if(on != 0 && (opio->sts & Shalted) == 0)

			break;

		else

			delay(1);

	if(i == 100)

		print("ehci %#p %s cmd timed out\n",

			ctlr->capio, on ? "run" : "halt");

	ddprint("ehci %#p cmd %#lux sts %#lux\n",

		ctlr->capio, opio->cmd, opio->sts);

}

static void*

edalloc(void)

{

	Ed *ed, *pool;

	int i;

	lock(&edpool);

	if(edpool.free == nil){

		pool = xspanalloc(Incr*sizeof(Ed), Align, 0);

		if(pool == nil)

			panic("edalloc");

		for(i=Incr; --i>=0;){

			pool[i].next = edpool.free;

			edpool.free = &pool[i];

		}

		edpool.nalloc += Incr;

		edpool.nfree += Incr;

		dprint("ehci: edalloc: %d eds\n", edpool.nalloc);

	}

	ed = edpool.free;

	edpool.free = ed->next;

	edpool.ninuse++;

	edpool.nfree--;

	unlock(&edpool);

	memset(ed, 0, sizeof(Ed));	/* safety */

	assert(((ulong)ed & 0xF) == 0);

	return ed;

}

static void

edfree(void *a)

{

	Ed *ed;

	ed = a;

	lock(&edpool);

	ed->next = edpool.free;

	edpool.free = ed;

	edpool.ninuse--;

	edpool.nfree++;

	unlock(&edpool);

}

/*

 * Allocate and do some initialization.

 * Free after releasing buffers used.

 */

static Itd*

itdalloc(void)

{

	Itd *td;

	td = edalloc();

	td->link = Lterm;

	return td;

}

static void

itdfree(Itd *td)

{

	edfree(td);

}

static Sitd*

sitdalloc(void)

{

	Sitd *td;

	td = edalloc();

	td->link = td->blink = Lterm;

	return td;

}

static void

sitdfree(Sitd *td)

{

	edfree(td);

}

static Td*

tdalloc(void)

{

	Td *td;

	td = edalloc();

	td->nlink = td->alink = Lterm;

	return td;

}

static void

tdfree(Td *td)

{

	if(td == nil)

		return;

	free(td->buff);

	edfree(td);

}

static void

tdlinktd(Td *td, Td *next)

{

	td->next = next;

	td->alink = Lterm;

	if(next == nil)

		td->nlink = Lterm;

	else

		td->nlink = PADDR(next);

	coherence();

}

static Qh*

qhlinkqh(Qh *qh, Qh *next)

{

	qh->next = next;

	if(next == nil)

		qh->link = Lterm;

	else

		qh->link = PADDR(next)|Lqh;

	coherence();

	return qh;

}

static void

qhsetaddr(Qh *qh, ulong addr)

{

	ulong eps0;

	eps0 = qh->eps0 & ~((Epmax<<8)|Devmax);

	qh->eps0 = eps0 | addr & Devmax | ((addr >> 7) & Epmax) << 8;

	coherence();

}

/*

 * return largest power of 2 <= n

 */

static int

flog2lower(int n)

{

	int i;

	for(i = 0; (1 << (i + 1)) <= n; i++)

		;

	return i;

}

static int

pickschedq(Qtree *qt, int pollival, ulong bw, ulong limit)

{

	int i, j, d, upperb, q;

	ulong best, worst, total;

	d = flog2lower(pollival);

	if(d > qt->depth)

		d = qt->depth;

	q = -1;

	worst = 0;

	best = ~0;

	upperb = (1 << (d+1)) - 1;

	for(i = (1 << d) - 1; i < upperb; i++){

		total = qt->bw[0];

		for(j = i; j > 0; j = (j - 1) / 2)

			total += qt->bw[j];

		if(total < best){

			best = total;

			q = i;

		}

		if(total > worst)

			worst = total;

	}

	if(worst + bw >= limit)

		return -1;

	return q;

}

static int

schedq(Ctlr *ctlr, Qh *qh, int pollival)

{

	int q;

	Qh *tqh;

	ulong bw;

	bw = qh->io->bw;

	q = pickschedq(ctlr->tree, pollival, 0, ~0);

	ddqprint("ehci: sched %#p q %d, ival %d, bw %uld\n",

		qh->io, q, pollival, bw);

	if(q < 0){

		print("ehci: no room for ed\n");

		return -1;

	}

	ctlr->tree->bw[q] += bw;

	tqh = ctlr->tree->root[q];

	qh->sched = q;

	qhlinkqh(qh, tqh->next);

	qhlinkqh(tqh, qh);

	coherence();

	qh->inext = ctlr->intrqhs;

	ctlr->intrqhs = qh;

	coherence();

	return 0;

}

static void

unschedq(Ctlr *ctlr, Qh *qh)

{

	int q;

	Qh *prev, *this, *next;

	Qh **l;

	ulong bw;

	bw = qh->io->bw;

	q = qh->sched;

	if(q < 0)

		return;

	ctlr->tree->bw[q] -= bw;

	prev = ctlr->tree->root[q];

	this = prev->next;

	while(this != nil && this != qh){

		prev = this;

		this = this->next;

	}

	if(this == nil)

		print("ehci: unschedq %d: not found\n", q);

	else{

		next = this->next;

		qhlinkqh(prev, next);

	}

	for(l = &ctlr->intrqhs; *l != nil; l = &(*l)->inext)

		if(*l == qh){

			*l = (*l)->inext;

			return;

		}

	print("ehci: unschedq: qh %#p not found\n", qh);

}

static ulong

qhmaxpkt(Qh *qh)

{

	return (qh->eps0 >> Qhmplshift) & Qhmplmask;

}

static void

qhsetmaxpkt(Qh *qh, int maxpkt)

{

	ulong eps0;

	eps0 = qh->eps0 & ~(Qhmplmask << Qhmplshift);

	qh->eps0 = eps0 | (maxpkt & Qhmplmask) << Qhmplshift;

	coherence();

}

/*

 * Initialize the round-robin circular list of ctl/bulk Qhs

 * if ep is nil. Otherwise, allocate and link a new Qh in the ctlr.

 */

static Qh*

qhalloc(Ctlr *ctlr, Ep *ep, Qio *io, char* tag)

{

	Qh *qh;

	int ttype;

	qh = edalloc();

	qh->nlink = Lterm;

	qh->alink = Lterm;

	qh->csw = Tdhalt;

	qh->state = Qidle;

	qh->sched = -1;

	qh->io = io;

	if(ep != nil){

		qh->eps0 = 0;

		qhsetmaxpkt(qh, ep->maxpkt);

		if(ep->dev->speed == Lowspeed)

			qh->eps0 |= Qhlow;

		if(ep->dev->speed == Highspeed)

			qh->eps0 |= Qhhigh;

		else if(ep->ttype == Tctl)

			qh->eps0 |= Qhnhctl;

		qh->eps0 |= Qhdtc | 8 << Qhrlcshift;	/* 8 naks max */

		coherence();

		qhsetaddr(qh, io->usbid);

		qh->eps1 = (ep->ntds & Qhmultmask) << Qhmultshift;

		qh->eps1 |= ep->dev->port << Qhportshift;

		qh->eps1 |= ep->dev->hub << Qhhubshift;

		qh->eps1 |= 034 << Qhscmshift;

		if(ep->ttype == Tintr)

			qh->eps1 |= 1 << Qhismshift;	/* intr. start µf. */

		coherence();

		if(io != nil)

			io->tag = tag;

	}

	ilock(ctlr);

	ttype = Tctl;

	if(ep != nil)

		ttype = ep->ttype;

	switch(ttype){

	case Tctl:

	case Tbulk:

		if(ctlr->qhs == nil){

			ctlr->qhs = qhlinkqh(qh, qh);

			qh->eps0 |= Qhhigh | Qhhrl;

			coherence();

			ctlr->opio->link = PADDR(qh)|Lqh;

			coherence();

		}else{

			qhlinkqh(qh, ctlr->qhs->next);

			qhlinkqh(ctlr->qhs, qh);

		}

		break;

	case Tintr:

		schedq(ctlr, qh, ep->pollival);

		break;

	default:

		print("ehci: qhalloc called for ttype != ctl/bulk\n");

	}

	iunlock(ctlr);

	return qh;

}

static int

qhadvanced(void *a)

{

	Ctlr *ctlr;

	ctlr = a;

	return (ctlr->opio->cmd & Ciasync) == 0;

}

/*

 * called when a qh is removed, to be sure the hw is not

 * keeping pointers into it.

 */

static void

qhcoherency(Ctlr *ctlr)

{

	int i;

	qlock(&ctlr->portlck);

	ctlr->opio->cmd |= Ciasync;	/* ask for intr. on async advance */

	coherence();

	for(i = 0; i < 3 && qhadvanced(ctlr) == 0; i++)

		if(!waserror()){

			tsleep(ctlr, qhadvanced, ctlr, Abortdelay);

			poperror();

		}

	dprint("ehci: qhcoherency: doorbell %d\n", qhadvanced(ctlr));

	if(i == 3)

		print("ehci: async advance doorbell did not ring\n");

	ctlr->opio->cmd &= ~Ciasync;	/* try to clean */

	qunlock(&ctlr->portlck);

}

static void

qhfree(Ctlr *ctlr, Qh *qh)

{

	Td *td, *ltd;

	Qh *q;

	if(qh == nil)

		return;

	ilock(ctlr);

	if(qh->sched < 0){

		for(q = ctlr->qhs; q != nil; q = q->next)

			if(q->next == qh)

				break;

		if(q == nil)

			panic("qhfree: nil q");

		q->next = qh->next;

		q->link = qh->link;

		coherence();

	}else

		unschedq(ctlr, qh);

	iunlock(ctlr);

	qhcoherency(ctlr);

	for(td = qh->tds; td != nil; td = ltd){

		ltd = td->next;

		tdfree(td);

	}

	edfree(qh);

}

static void

qhlinktd(Qh *qh, Td *td)

{

	ulong csw;

	int i;

	csw = qh->csw;

	qh->tds = td;

	if(td == nil)

		qh->csw = (csw & ~Tdactive) | Tdhalt;

	else{

		csw &= Tddata1 | Tdping;	/* save */

		qh->csw = Tdhalt;

		coherence();

		qh->tclink = 0;

		qh->alink = Lterm;

		qh->nlink = PADDR(td);

		for(i = 0; i < nelem(qh->buffer); i++)

			qh->buffer[i] = 0;

		coherence();

		qh->csw = csw & ~(Tdhalt|Tdactive);	/* activate next */

	}

	coherence();

}

static char*

seprintlink(char *s, char *se, char *name, ulong l, int typed)

{

	s = seprint(s, se, "%s %ulx", name, l);

	if((l & Lterm) != 0)

		return seprint(s, se, "T");

	if(typed == 0)

		return s;

	switch(l & (3<<1)){

	case Litd:

		return seprint(s, se, "I");

	case Lqh:

		return seprint(s, se, "Q");

	case Lsitd:

		return seprint(s, se, "S");

	default:

		return seprint(s, se, "F");

	}

}

static char*

seprintitd(char *s, char *se, Itd *td)

{

	int i;

	ulong b0, b1;

	char flags[6];

	char *rw;

	if(td == nil)

		return seprint(s, se, "<nil itd>\n");

	b0 = td->buffer[0];

	b1 = td->buffer[1];

	s = seprint(s, se, "itd %#p", td);

	rw = (b1 & Itdin) ? "in" : "out";

	s = seprint(s, se, " %s ep %uld dev %uld max %uld mult %uld",

		rw, (b0>>8)&Epmax, (b0&Devmax),

		td->buffer[1] & 0x7ff, b1 & 3);

	s = seprintlink(s, se, " link", td->link, 1);

	s = seprint(s, se, "\n");

	for(i = 0; i < nelem(td->csw); i++){

		memset(flags, '-', 5);

		if((td->csw[i] & Itdactive) != 0)

			flags[0] = 'a';

		if((td->csw[i] & Itdioc) != 0)