sys/src/cmd/nusb/lib/dev.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <thread.h>
   4 #include "usb.h"
   5
   6 /*
   7  * epN.M -> N
   8  */
   9 static int
  10 nameid(char *s)
  11 {
  12         char *r;
  13         char nm[20];
  14
  15         r = strrchr(s, 'p');
  16         if(r == nil)
  17                 return -1;
  18         strecpy(nm, nm+sizeof(nm), r+1);
  19         r = strchr(nm, '.');
  20         if(r == nil)
  21                 return -1;
  22         *r = 0;
  23         return atoi(nm);
  24 }
  25
  26 Dev*
  27 openep(Dev *d, int id)
  28 {
  29         char *mode;     /* How many modes? */
  30         Ep *ep;
  31         Altc *ac;
  32         Dev *epd;
  33         Usbdev *ud;
  34         char name[40];
  35
  36         if(access("/dev/usb", AEXIST) < 0 && bind("#u", "/dev", MBEFORE) < 0)
  37                 return nil;
  38         if(d->cfd < 0 || d->usb == nil){
  39                 werrstr("device not configured");
  40                 return nil;
  41         }
  42         ud = d->usb;
  43         if(id < 0 || id >= nelem(ud->ep) || ud->ep[id] == nil){
  44                 werrstr("bad enpoint number");
  45                 return nil;
  46         }
  47         ep = ud->ep[id];
  48         mode = "rw";
  49         if(ep->dir == Ein)
  50                 mode = "r";
  51         if(ep->dir == Eout)
  52                 mode = "w";
  53         snprint(name, sizeof(name), "/dev/usb/ep%d.%d", d->id, id);
  54         if(access(name, AEXIST) == 0){
  55                 dprint(2, "%s: %s already exists; trying to open\n", argv0, name);
  56                 epd = opendev(name);
  57                 if(epd != nil)
  58                         epd->maxpkt = ep->maxpkt;       /* guess */
  59                 return epd;
  60         }
  61         if(devctl(d, "new %d %d %s", id, ep->type, mode) < 0){
  62                 dprint(2, "%s: %s: new: %r\n", argv0, d->dir);
  63                 return nil;
  64         }
  65         epd = opendev(name);
  66         if(epd == nil)
  67                 return nil;
  68         epd->id = id;
  69         if(devctl(epd, "maxpkt %d", ep->maxpkt) < 0)
  70                 fprint(2, "%s: %s: openep: maxpkt: %r\n", argv0, epd->dir);
  71         else
  72                 dprint(2, "%s: %s: maxpkt %d\n", argv0, epd->dir, ep->maxpkt);
  73         epd->maxpkt = ep->maxpkt;
  74         ac = ep->iface->altc[0];
  75         if(ep->ntds > 1 && devctl(epd, "ntds %d", ep->ntds) < 0)
  76                 fprint(2, "%s: %s: openep: ntds: %r\n", argv0, epd->dir);
  77         else
  78                 dprint(2, "%s: %s: ntds %d\n", argv0, epd->dir, ep->ntds);
  79
  80         /*
  81          * For iso endpoints and high speed interrupt endpoints the pollival is
  82          * actually 2ⁿ and not n.
  83          * The kernel usb driver must take that into account.
  84          * It's simpler this way.
  85          */
  86
  87         if(ac != nil && (ep->type == Eintr || ep->type == Eiso) && ac->interval != 0)
  88                 if(devctl(epd, "pollival %d", ac->interval) < 0)
  89                         fprint(2, "%s: %s: openep: pollival: %r\n", argv0, epd->dir);
  90         return epd;
  91 }
  92
  93 Dev*
  94 opendev(char *fn)
  95 {
  96         Dev *d;
  97         int l;
  98
  99         if(access("/dev/usb", AEXIST) < 0 && bind("#u", "/dev", MBEFORE) < 0)
 100                 return nil;
 101         d = emallocz(sizeof(Dev), 1);
 102         incref(d);
 103
 104         l = strlen(fn);
 105         d->dfd = -1;
 106         /*
 107          * +30 to allocate extra size to concat "/<epfilename>"
 108          * we should probably remove that feature from the manual
 109          * and from the code after checking out that nobody relies on
 110          * that.
 111          */
 112         d->dir = emallocz(l + 30, 0);
 113         strcpy(d->dir, fn);
 114         strcpy(d->dir+l, "/ctl");
 115         d->cfd = open(d->dir, ORDWR|OCEXEC);
 116         d->dir[l] = 0;
 117         d->id = nameid(fn);
 118         if(d->cfd < 0){
 119                 werrstr("can't open endpoint %s: %r", d->dir);
 120                 free(d->dir);
 121                 free(d);
 122                 return nil;
 123         }
 124         dprint(2, "%s: opendev %#p %s\n", argv0, d, fn);
 125         return d;
 126 }
 127
 128 int
 129 opendevdata(Dev *d, int mode)
 130 {
 131         char buf[80]; /* more than enough for a usb path */
 132
 133         seprint(buf, buf+sizeof(buf), "%s/data", d->dir);
 134         d->dfd = open(buf, mode|OCEXEC);
 135         return d->dfd;
 136 }
 137
 138 enum
 139 {
 140         /*
 141          * Max device conf is also limited by max control request size as
 142          * limited by Maxctllen in the kernel usb.h (both limits are arbitrary).
 143          */
 144         Maxdevconf = 4 * 1024,  /* asking for 16K kills Newsham's disk */
 145 };
 146
 147 int
 148 loaddevconf(Dev *d, int n)
 149 {
 150         uchar *buf;
 151         int nr;
 152         int type;
 153
 154         if(n >= nelem(d->usb->conf)){
 155                 werrstr("loaddevconf: bug: out of configurations in device");
 156                 fprint(2, "%s: %r\n", argv0);
 157                 return -1;
 158         }
 159         buf = emallocz(Maxdevconf, 0);
 160         type = Rd2h|Rstd|Rdev;
 161         nr = usbcmd(d, type, Rgetdesc, Dconf<<8|n, 0, buf, Maxdevconf);
 162         if(nr < Dconflen){
 163                 free(buf);
 164                 return -1;
 165         }
 166         if(d->usb->conf[n] == nil)
 167                 d->usb->conf[n] = emallocz(sizeof(Conf), 1);
 168         nr = parseconf(d->usb, d->usb->conf[n], buf, nr);
 169         free(buf);
 170         return nr;
 171 }
 172
 173 Ep*
 174 mkep(Usbdev *d, int id)
 175 {
 176         Ep *ep;
 177
 178         d->ep[id] = ep = emallocz(sizeof(Ep), 1);
 179         ep->id = id;
 180         return ep;
 181 }
 182
 183 static char*
 184 mkstr(uchar *b, int n)
 185 {
 186         Rune r;
 187         char *us;
 188         char *s;
 189         char *e;
 190
 191         if(n <= 2 || (n & 1) != 0)
 192                 return strdup("none");
 193         n = (n - 2)/2;
 194         b += 2;
 195         us = s = emallocz(n*UTFmax+1, 0);
 196         e = s + n*UTFmax+1;
 197         for(; --n >= 0; b += 2){
 198                 r = GET2(b);
 199                 s = seprint(s, e, "%C", r);
 200         }
 201         return us;
 202 }
 203
 204 char*
 205 loaddevstr(Dev *d, int sid)
 206 {
 207         uchar buf[128];
 208         int langid;
 209         int type;
 210         int nr;
 211
 212         if(sid == 0)
 213                 return estrdup("none");
 214         type = Rd2h|Rstd|Rdev;
 215
 216         /*
 217          * there are devices which do not return a string if used
 218          * with invalid language id, so at least try to use the first
 219          * one and choose english if failed
 220          */
 221         nr=usbcmd(d, type, Rgetdesc, Dstr<<8, 0, buf, sizeof(buf));
 222         if(nr < 4)
 223                 langid = 0x0409;        // english
 224         else
 225                 langid = buf[3]<<8|buf[2];
 226
 227         nr=usbcmd(d, type, Rgetdesc, Dstr<<8|sid, langid, buf, sizeof(buf));
 228         return mkstr(buf, nr);
 229 }
 230
 231 int
 232 loaddevdesc(Dev *d)
 233 {
 234         uchar buf[Ddevlen];
 235         int nr;
 236         int type;
 237         Ep *ep0;
 238
 239         type = Rd2h|Rstd|Rdev;
 240         nr = sizeof(buf);
 241         memset(buf, 0, nr);
 242         if((nr=usbcmd(d, type, Rgetdesc, Ddev<<8|0, 0, buf, nr)) < 0)
 243                 return -1;
 244         /*
 245          * Several hubs are returning descriptors of 17 bytes, not 18.
 246          * We accept them and leave number of configurations as zero.
 247          * (a get configuration descriptor also fails for them!)
 248          */
 249         if(nr < Ddevlen){
 250                 print("%s: %s: warning: device with short descriptor\n",
 251                         argv0, d->dir);
 252                 if(nr < Ddevlen-1){
 253                         werrstr("short device descriptor (%d bytes)", nr);
 254                         return -1;
 255                 }
 256         }
 257         d->usb = emallocz(sizeof(Usbdev), 1);
 258         ep0 = mkep(d->usb, 0);
 259         ep0->dir = Eboth;
 260         ep0->type = Econtrol;
 261         ep0->maxpkt = d->maxpkt = 8;            /* a default */
 262         nr = parsedev(d, buf, nr);
 263         if(nr >= 0){
 264                 d->usb->vendor = loaddevstr(d, d->usb->vsid);
 265                 if(strcmp(d->usb->vendor, "none") != 0){
 266                         d->usb->product = loaddevstr(d, d->usb->psid);
 267                         d->usb->serial = loaddevstr(d, d->usb->ssid);
 268                 }
 269         }
 270         return nr;
 271 }
 272
 273 int
 274 configdev(Dev *d)
 275 {
 276         int i;
 277
 278         if(d->dfd < 0)
 279                 opendevdata(d, ORDWR);
 280         if(d->dfd < 0)
 281                 return -1;
 282         if(loaddevdesc(d) < 0)
 283                 return -1;
 284         for(i = 0; i < d->usb->nconf; i++)
 285                 if(loaddevconf(d, i) < 0)
 286                         return -1;
 287         return 0;
 288 }
 289
 290 static void
 291 closeconf(Conf *c)
 292 {
 293         int i;
 294         int a;
 295
 296         if(c == nil)
 297                 return;
 298         for(i = 0; i < nelem(c->iface); i++)
 299                 if(c->iface[i] != nil){
 300                         for(a = 0; a < nelem(c->iface[i]->altc); a++)
 301                                 free(c->iface[i]->altc[a]);
 302                         free(c->iface[i]);
 303                 }
 304         free(c);
 305 }
 306
 307 void
 308 closedev(Dev *d)
 309 {
 310         int i;
 311         Usbdev *ud;
 312
 313         if(d==nil || decref(d) != 0)
 314                 return;
 315         dprint(2, "%s: closedev %#p %s\n", argv0, d, d->dir);
 316         if(d->free != nil)
 317                 d->free(d->aux);
 318         if(d->cfd >= 0)
 319                 close(d->cfd);
 320         if(d->dfd >= 0)
 321                 close(d->dfd);
 322         d->cfd = d->dfd = -1;
 323         free(d->dir);
 324         d->dir = nil;
 325         ud = d->usb;
 326         d->usb = nil;
 327         if(ud != nil){
 328                 free(ud->vendor);
 329                 free(ud->product);
 330                 free(ud->serial);
 331                 for(i = 0; i < nelem(ud->ep); i++)
 332                         free(ud->ep[i]);
 333                 for(i = 0; i < nelem(ud->ddesc); i++)
 334                         free(ud->ddesc[i]);
 335
 336                 for(i = 0; i < nelem(ud->conf); i++)
 337                         closeconf(ud->conf[i]);
 338                 free(ud);
 339         }
 340         free(d);
 341 }
 342
 343 static char*
 344 reqstr(int type, int req)
 345 {
 346         char *s;
 347         static char* ds[] = { "dev", "if", "ep", "oth" };
 348         static char buf[40];
 349
 350         if(type&Rd2h)
 351                 s = seprint(buf, buf+sizeof(buf), "d2h");
 352         else
 353                 s = seprint(buf, buf+sizeof(buf), "h2d");
 354         if(type&Rclass)
 355                 s = seprint(s, buf+sizeof(buf), "|cls");
 356         else if(type&Rvendor)
 357                 s = seprint(s, buf+sizeof(buf), "|vnd");
 358         else
 359                 s = seprint(s, buf+sizeof(buf), "|std");
 360         s = seprint(s, buf+sizeof(buf), "|%s", ds[type&3]);
 361
 362         switch(req){
 363         case Rgetstatus: s = seprint(s, buf+sizeof(buf), " getsts"); break;
 364         case Rclearfeature: s = seprint(s, buf+sizeof(buf), " clrfeat"); break;
 365         case Rsetfeature: s = seprint(s, buf+sizeof(buf), " setfeat"); break;
 366         case Rsetaddress: s = seprint(s, buf+sizeof(buf), " setaddr"); break;
 367         case Rgetdesc: s = seprint(s, buf+sizeof(buf), " getdesc"); break;
 368         case Rsetdesc: s = seprint(s, buf+sizeof(buf), " setdesc"); break;
 369         case Rgetconf: s = seprint(s, buf+sizeof(buf), " getcnf"); break;
 370         case Rsetconf: s = seprint(s, buf+sizeof(buf), " setcnf"); break;
 371         case Rgetiface: s = seprint(s, buf+sizeof(buf), " getif"); break;
 372         case Rsetiface: s = seprint(s, buf+sizeof(buf), " setif"); break;
 373         }
 374         USED(s);
 375         return buf;
 376 }
 377
 378 static int
 379 cmdreq(Dev *d, int type, int req, int value, int index, uchar *data, int count)
 380 {
 381         int ndata, n;
 382         uchar *wp;
 383         uchar buf[8];
 384         char *hd, *rs;
 385
 386         assert(d != nil);
 387         if(data == nil){
 388                 wp = buf;
 389                 ndata = 0;
 390         }else{
 391                 ndata = count;
 392                 wp = emallocz(8+ndata, 0);
 393         }
 394         wp[0] = type;
 395         wp[1] = req;
 396         PUT2(wp+2, value);
 397         PUT2(wp+4, index);
 398         PUT2(wp+6, count);
 399         if(data != nil)
 400                 memmove(wp+8, data, ndata);
 401         if(usbdebug>2){
 402                 hd = hexstr(wp, ndata+8);
 403                 rs = reqstr(type, req);
 404                 fprint(2, "%s: %s val %d|%d idx %d cnt %d out[%d] %s\n",
 405                         d->dir, rs, value>>8, value&0xFF,
 406                         index, count, ndata+8, hd);
 407                 free(hd);
 408         }
 409         n = write(d->dfd, wp, 8+ndata);
 410         if(wp != buf)
 411                 free(wp);
 412         if(n < 0)
 413                 return -1;
 414         if(n != 8+ndata){
 415                 dprint(2, "%s: cmd: short write: %d\n", argv0, n);
 416                 return -1;
 417         }
 418         return n;
 419 }
 420
 421 static int
 422 cmdrep(Dev *d, void *buf, int nb)
 423 {
 424         char *hd;
 425
 426         nb = read(d->dfd, buf, nb);
 427         if(nb >0 && usbdebug > 2){
 428                 hd = hexstr(buf, nb);
 429                 fprint(2, "%s: in[%d] %s\n", d->dir, nb, hd);
 430                 free(hd);
 431         }
 432         return nb;
 433 }
 434
 435 int
 436 usbcmd(Dev *d, int type, int req, int value, int index, uchar *data, int count)
 437 {
 438         int i, r, nerr;
 439         char err[64];
 440
 441         /*
 442          * Some devices do not respond to commands some times.
 443          * Others even report errors but later work just fine. Retry.
 444          */
 445         r = -1;
 446         *err = 0;
 447         for(i = nerr = 0; i < Uctries; i++){
 448                 if(type & Rd2h)
 449                         r = cmdreq(d, type, req, value, index, nil, count);
 450                 else
 451                         r = cmdreq(d, type, req, value, index, data, count);
 452                 if(r > 0){
 453                         if((type & Rd2h) == 0)
 454                                 break;
 455                         r = cmdrep(d, data, count);
 456                         if(r > 0)
 457                                 break;
 458                         if(r == 0)
 459                                 werrstr("no data from device");
 460                 }
 461                 nerr++;
 462                 if(*err == 0)
 463                         rerrstr(err, sizeof(err));
 464                 sleep(Ucdelay);
 465         }
 466         if(r > 0 && i >= 2)
 467                 /* let the user know the device is not in good shape */
 468                 fprint(2, "%s: usbcmd: %s: required %d attempts (%s)\n",
 469                         argv0, d->dir, i, err);
 470         return r;
 471 }
 472
 473 int
 474 unstall(Dev *dev, Dev *ep, int dir)
 475 {
 476         int r;
 477
 478         if(dir == Ein)
 479                 dir = 0x80;
 480         else
 481                 dir = 0;
 482         r = Rh2d|Rstd|Rep;
 483         if(usbcmd(dev, r, Rclearfeature, Fhalt, ep->id|dir, nil, 0)<0){
 484                 werrstr("unstall: %s: %r", ep->dir);
 485                 return -1;
 486         }
 487         if(devctl(ep, "clrhalt") < 0){
 488                 werrstr("clrhalt: %s: %r", ep->dir);
 489                 return -1;
 490         }
 491         return 0;
 492 }
 493
 494 /*
 495  * To be sure it uses a single write.
 496  */
 497 int
 498 devctl(Dev *dev, char *fmt, ...)
 499 {
 500         char buf[128];
 501         va_list arg;
 502         char *e;
 503
 504         va_start(arg, fmt);
 505         e = vseprint(buf, buf+sizeof(buf), fmt, arg);
 506         va_end(arg);
 507         return write(dev->cfd, buf, e-buf);
 508 }
 509
 510 Dev *
 511 getdev(int id)
 512 {
 513         Dev *d;
 514         char buf[40];
 515
 516         snprint(buf, sizeof buf, "/dev/usb/ep%d.0", id);
 517         d = opendev(buf);
 518         if(d == nil)
 519                 return nil;
 520         if(configdev(d) < 0){
 521                 closedev(d);
 522                 return nil;
 523         }
 524         return d;
 525 }