Subversion Repositories planix.SVN

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

int usbdebug;

static char *edir[] = {"in", "out", "inout"};
static char *etype[] = {"ctl", "iso", "bulk", "intr"};
static char* cnames[] =
{
        "none", "audio", "comms", "hid", "",
        "", "", "printer", "storage", "hub", "data"
};
static char* devstates[] =
{
        "detached", "attached", "enabled", "assigned", "configured"
};

char*
classname(int c)
{
        static char buf[30];

        if(c >= 0 && c < nelem(cnames))
                return cnames[c];
        else{
                seprint(buf, buf+30, "%d", c);
                return buf;
        }
}

char *
hexstr(void *a, int n)
{
        int i;
        char *dbuff, *s, *e;
        uchar *b;

        b = a;
        dbuff = s = emallocz(1024, 0);
        *s = 0;
        e = s + 1024;
        for(i = 0; i < n; i++)
                s = seprint(s, e, " %.2ux", b[i]);
        if(s == e)
                fprint(2, "%s: usb/lib: hexdump: bug: small buffer\n", argv0);
        return dbuff;
}

static char *
seprintiface(char *s, char *e, Iface *i)
{
        int     j;
        Altc    *a;
        Ep      *ep;
        char    *eds, *ets;

        s = seprint(s, e, "\t\tiface csp %s.%uld.%uld\n",
                classname(Class(i->csp)), Subclass(i->csp), Proto(i->csp));
        for(j = 0; j < Naltc; j++){
                a=i->altc[j];
                if(a == nil)
                        break;
                s = seprint(s, e, "\t\t  alt %d attr %d ival %d",
                        j, a->attrib, a->interval);
                if(a->aux != nil)
                        s = seprint(s, e, " devspec %p\n", a->aux);
                else
                        s = seprint(s, e, "\n");
        }
        for(j = 0; j < Nep; j++){
                ep = i->ep[j];
                if(ep == nil)
                        break;
                eds = ets = "";
                if(ep->dir <= nelem(edir))
                        eds = edir[ep->dir];
                if(ep->type <= nelem(etype))
                        ets = etype[ep->type];
                s = seprint(s, e, "\t\t  ep id %d addr %d dir %s type %s"
                        " itype %d maxpkt %d ntds %d\n",
                        ep->id, ep->addr, eds, ets, ep->isotype,
                        ep->maxpkt, ep->ntds);
        }
        return s;
}

static char*
seprintconf(char *s, char *e, Usbdev *d, int ci)
{
        int i;
        Conf *c;
        char *hd;

        c = d->conf[ci];
        s = seprint(s, e, "\tconf: cval %d attrib %x %d mA\n",
                c->cval, c->attrib, c->milliamps);
        for(i = 0; i < Niface; i++)
                if(c->iface[i] == nil)
                        break;
                else
                        s = seprintiface(s, e, c->iface[i]);
        for(i = 0; i < Nddesc; i++)
                if(d->ddesc[i] == nil)
                        break;
                else if(d->ddesc[i]->conf == c){
                        hd = hexstr((uchar*)&d->ddesc[i]->data,
                                d->ddesc[i]->data.bLength);
                        s = seprint(s, e, "\t\tdev desc %x[%d]: %s\n",
                                d->ddesc[i]->data.bDescriptorType,
                                d->ddesc[i]->data.bLength, hd);
                        free(hd);
                }
        return s;
}

int
Ufmt(Fmt *f)
{
        int i;
        Dev *d;
        Usbdev *ud;
        char buf[1024];
        char *s, *e;

        s = buf;
        e = buf+sizeof(buf);
        d = va_arg(f->args, Dev*);
        if(d == nil)
                return fmtprint(f, "<nildev>\n");
        s = seprint(s, e, "%s", d->dir);
        ud = d->usb;
        if(ud == nil)
                return fmtprint(f, "%s %ld refs\n", buf, d->ref);
        s = seprint(s, e, " csp %s.%uld.%uld",
                classname(Class(ud->csp)), Subclass(ud->csp), Proto(ud->csp));
        s = seprint(s, e, " vid %#ux did %#ux", ud->vid, ud->did);
        s = seprint(s, e, " refs %ld\n", d->ref);
        s = seprint(s, e, "\t%s %s %s\n", ud->vendor, ud->product, ud->serial);
        for(i = 0; i < Nconf; i++){
                if(ud->conf[i] == nil)
                        break;
                else
                        s = seprintconf(s, e, ud, i);
        }
        return fmtprint(f, "%s", buf);
}

char*
estrdup(char *s)
{
        char *d;

        d = strdup(s);
        if(d == nil)
                sysfatal("strdup: %r");
        setmalloctag(d, getcallerpc(&s));
        return d;
}

void*
emallocz(ulong size, int zero)
{
        void *x;

        x = malloc(size);
        if(x == nil)
                sysfatal("malloc: %r");
        if(zero)
                memset(x, 0, size);
        setmalloctag(x, getcallerpc(&size));
        return x;
}