lib/libusb/libusb01.c

   1 /* $FreeBSD: head/lib/libusb/libusb01.c 264344 2014-04-11 14:11:55Z hselasky $ */
   2 /*-
   3  * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * This file contains the emulation layer for LibUSB v0.1 from sourceforge.
  29  */
  30
  31 #ifdef LIBUSB_GLOBAL_INCLUDE_FILE
  32 #include LIBUSB_GLOBAL_INCLUDE_FILE
  33 #else
  34 #include <errno.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <time.h>
  39 #include <sys/queue.h>
  40 #endif
  41
  42 #include "libusb20.h"
  43 #include "libusb20_desc.h"
  44 #include "libusb20_int.h"
  45 #include "usb.h"
  46
  47 /*
  48  * The two following macros were taken from the original LibUSB v0.1
  49  * for sake of compatibility:
  50  */
  51 #define LIST_ADD(begin, ent)       \
  52   do {                             \
  53     if (begin) {                   \
  54       ent->next = begin;           \
  55       ent->next->prev = ent;       \
  56     } else {                       \
  57       ent->next = NULL;            \
  58     }                              \
  59     ent->prev = NULL;              \
  60     begin = ent;                   \
  61   } while(0)
  62
  63 #define LIST_DEL(begin, ent)             \
  64   do {                                   \
  65     if (ent->prev) {                     \
  66       ent->prev->next = ent->next;       \
  67     } else {                             \
  68       begin = ent->next;                 \
  69     }                                    \
  70     if (ent->next) {                     \
  71       ent->next->prev = ent->prev;       \
  72     }                                    \
  73     ent->prev = NULL;                    \
  74     ent->next = NULL;                    \
  75   } while (0)
  76
  77 struct usb_bus *usb_busses = NULL;
  78
  79 static struct usb_bus usb_global_bus = {
  80         .dirname = {"/dev/usb"},
  81         .root_dev = NULL,
  82         .devices = NULL,
  83 };
  84
  85 static struct libusb20_backend *usb_backend = NULL;
  86
  87 struct usb_parse_state {
  88
  89         struct {
  90                 struct libusb20_endpoint *currep;
  91                 struct libusb20_interface *currifc;
  92                 struct libusb20_config *currcfg;
  93                 struct libusb20_me_struct *currextra;
  94         }       a;
  95
  96         struct {
  97                 struct usb_config_descriptor *currcfg;
  98                 struct usb_interface_descriptor *currifc;
  99                 struct usb_endpoint_descriptor *currep;
 100                 struct usb_interface *currifcw;
 101                 uint8_t *currextra;
 102         }       b;
 103
 104         uint8_t preparse;
 105 };
 106
 107 static struct libusb20_transfer *
 108 usb_get_transfer_by_ep_no(usb_dev_handle * dev, uint8_t ep_no)
 109 {
 110         struct libusb20_device *pdev = (void *)dev;
 111         struct libusb20_transfer *xfer;
 112         int err;
 113         uint32_t bufsize;
 114         uint8_t x;
 115         uint8_t speed;
 116
 117         x = (ep_no & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 2;
 118
 119         if (ep_no & LIBUSB20_ENDPOINT_DIR_MASK) {
 120                 /* this is an IN endpoint */
 121                 x |= 1;
 122         }
 123         speed = libusb20_dev_get_speed(pdev);
 124
 125         /* select a sensible buffer size */
 126         if (speed == LIBUSB20_SPEED_LOW) {
 127                 bufsize = 256;
 128         } else if (speed == LIBUSB20_SPEED_FULL) {
 129                 bufsize = 4096;
 130         } else if (speed == LIBUSB20_SPEED_SUPER) {
 131                 bufsize = 65536;
 132         } else {
 133                 bufsize = 16384;
 134         }
 135
 136         xfer = libusb20_tr_get_pointer(pdev, x);
 137
 138         if (xfer == NULL)
 139                 return (xfer);
 140
 141         err = libusb20_tr_open(xfer, bufsize, 1, ep_no);
 142         if (err == LIBUSB20_ERROR_BUSY) {
 143                 /* already opened */
 144                 return (xfer);
 145         } else if (err) {
 146                 return (NULL);
 147         }
 148         /* success */
 149         return (xfer);
 150 }
 151
 152 usb_dev_handle *
 153 usb_open(struct usb_device *dev)
 154 {
 155         int err;
 156
 157         err = libusb20_dev_open(dev->dev, 16 * 2);
 158         if (err == LIBUSB20_ERROR_BUSY) {
 159                 /*
 160                  * Workaround buggy USB applications which open the USB
 161                  * device multiple times:
 162                  */
 163                 return (dev->dev);
 164         }
 165         if (err)
 166                 return (NULL);
 167
 168         /*
 169          * Dequeue USB device from backend queue so that it does not get
 170          * freed when the backend is re-scanned:
 171          */
 172         libusb20_be_dequeue_device(usb_backend, dev->dev);
 173
 174         return (dev->dev);
 175 }
 176
 177 int
 178 usb_close(usb_dev_handle * udev)
 179 {
 180         struct usb_device *dev;
 181         int err;
 182
 183         err = libusb20_dev_close((void *)udev);
 184
 185         if (err)
 186                 return (-1);
 187
 188         if (usb_backend != NULL) {
 189                 /*
 190                  * Enqueue USB device to backend queue so that it gets freed
 191                  * when the backend is re-scanned:
 192                  */
 193                 libusb20_be_enqueue_device(usb_backend, (void *)udev);
 194         } else {
 195                 /*
 196                  * The backend is gone. Free device data so that we
 197                  * don't start leaking memory!
 198                  */
 199                 dev = usb_device(udev);
 200                 libusb20_dev_free((void *)udev);
 201                 LIST_DEL(usb_global_bus.devices, dev);
 202                 free(dev);
 203         }
 204         return (0);
 205 }
 206
 207 int
 208 usb_get_string(usb_dev_handle * dev, int strindex,
 209     int langid, char *buf, size_t buflen)
 210 {
 211         int err;
 212
 213         if (dev == NULL)
 214                 return (-1);
 215
 216         if (buflen > 65535)
 217                 buflen = 65535;
 218
 219         err = libusb20_dev_req_string_sync((void *)dev,
 220             strindex, langid, buf, buflen);
 221
 222         if (err)
 223                 return (-1);
 224
 225         return (0);
 226 }
 227
 228 int
 229 usb_get_string_simple(usb_dev_handle * dev, int strindex,
 230     char *buf, size_t buflen)
 231 {
 232         int err;
 233
 234         if (dev == NULL)
 235                 return (-1);
 236
 237         if (buflen > 65535)
 238                 buflen = 65535;
 239
 240         err = libusb20_dev_req_string_simple_sync((void *)dev,
 241             strindex, buf, buflen);
 242
 243         if (err)
 244                 return (-1);
 245
 246         return (strlen(buf));
 247 }
 248
 249 int
 250 usb_get_descriptor_by_endpoint(usb_dev_handle * udev, int ep, uint8_t type,
 251     uint8_t ep_index, void *buf, int size)
 252 {
 253         memset(buf, 0, size);
 254
 255         if (udev == NULL)
 256                 return (-1);
 257
 258         if (size > 65535)
 259                 size = 65535;
 260
 261         return (usb_control_msg(udev, ep | USB_ENDPOINT_IN,
 262             USB_REQ_GET_DESCRIPTOR, (type << 8) + ep_index, 0,
 263             buf, size, 1000));
 264 }
 265
 266 int
 267 usb_get_descriptor(usb_dev_handle * udev, uint8_t type, uint8_t desc_index,
 268     void *buf, int size)
 269 {
 270         memset(buf, 0, size);
 271
 272         if (udev == NULL)
 273                 return (-1);
 274
 275         if (size > 65535)
 276                 size = 65535;
 277
 278         return (usb_control_msg(udev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
 279             (type << 8) + desc_index, 0, buf, size, 1000));
 280 }
 281
 282 int
 283 usb_parse_descriptor(uint8_t *source, char *description, void *dest)
 284 {
 285         uint8_t *sp = source;
 286         uint8_t *dp = dest;
 287         uint16_t w;
 288         uint32_t d;
 289         char *cp;
 290
 291         for (cp = description; *cp; cp++) {
 292                 switch (*cp) {
 293                 case 'b':               /* 8-bit byte */
 294                         *dp++ = *sp++;
 295                         break;
 296                         /*
 297                          * 16-bit word, convert from little endian to CPU
 298                          */
 299                 case 'w':
 300                         w = (sp[1] << 8) | sp[0];
 301                         sp += 2;
 302                         /* Align to word boundary */
 303                         dp += ((dp - (uint8_t *)0) & 1);
 304                         *((uint16_t *)dp) = w;
 305                         dp += 2;
 306                         break;
 307                         /*
 308                          * 32-bit dword, convert from little endian to CPU
 309                          */
 310                 case 'd':
 311                         d = (sp[3] << 24) | (sp[2] << 16) |
 312                             (sp[1] << 8) | sp[0];
 313                         sp += 4;
 314                         /* Align to word boundary */
 315                         dp += ((dp - (uint8_t *)0) & 1);
 316                         /* Align to double word boundary */
 317                         dp += ((dp - (uint8_t *)0) & 2);
 318                         *((uint32_t *)dp) = d;
 319                         dp += 4;
 320                         break;
 321                 }
 322         }
 323         return (sp - source);
 324 }
 325
 326 static void
 327 usb_parse_extra(struct usb_parse_state *ps, uint8_t **pptr, int *plen)
 328 {
 329         void *ptr;
 330         uint16_t len;
 331
 332         ptr = ps->a.currextra->ptr;
 333         len = ps->a.currextra->len;
 334
 335         if (ps->preparse == 0) {
 336                 memcpy(ps->b.currextra, ptr, len);
 337                 *pptr = ps->b.currextra;
 338                 *plen = len;
 339         }
 340         ps->b.currextra += len;
 341         return;
 342 }
 343
 344 static void
 345 usb_parse_endpoint(struct usb_parse_state *ps)
 346 {
 347         struct usb_endpoint_descriptor *bep;
 348         struct libusb20_endpoint *aep;
 349
 350         aep = ps->a.currep;
 351         bep = ps->b.currep++;
 352
 353         if (ps->preparse == 0) {
 354                 /* copy descriptor fields */
 355                 bep->bLength = aep->desc.bLength;
 356                 bep->bDescriptorType = aep->desc.bDescriptorType;
 357                 bep->bEndpointAddress = aep->desc.bEndpointAddress;
 358                 bep->bmAttributes = aep->desc.bmAttributes;
 359                 bep->wMaxPacketSize = aep->desc.wMaxPacketSize;
 360                 bep->bInterval = aep->desc.bInterval;
 361                 bep->bRefresh = aep->desc.bRefresh;
 362                 bep->bSynchAddress = aep->desc.bSynchAddress;
 363         }
 364         ps->a.currextra = &aep->extra;
 365         usb_parse_extra(ps, &bep->extra, &bep->extralen);
 366         return;
 367 }
 368
 369 static void
 370 usb_parse_iface_sub(struct usb_parse_state *ps)
 371 {
 372         struct libusb20_interface *aifc;
 373         struct usb_interface_descriptor *bifc;
 374         uint8_t x;
 375
 376         aifc = ps->a.currifc;
 377         bifc = ps->b.currifc++;
 378
 379         if (ps->preparse == 0) {
 380                 /* copy descriptor fields */
 381                 bifc->bLength = aifc->desc.bLength;
 382                 bifc->bDescriptorType = aifc->desc.bDescriptorType;
 383                 bifc->bInterfaceNumber = aifc->desc.bInterfaceNumber;
 384                 bifc->bAlternateSetting = aifc->desc.bAlternateSetting;
 385                 bifc->bNumEndpoints = aifc->num_endpoints;
 386                 bifc->bInterfaceClass = aifc->desc.bInterfaceClass;
 387                 bifc->bInterfaceSubClass = aifc->desc.bInterfaceSubClass;
 388                 bifc->bInterfaceProtocol = aifc->desc.bInterfaceProtocol;
 389                 bifc->iInterface = aifc->desc.iInterface;
 390                 bifc->endpoint = ps->b.currep;
 391         }
 392         for (x = 0; x != aifc->num_endpoints; x++) {
 393                 ps->a.currep = aifc->endpoints + x;
 394                 usb_parse_endpoint(ps);
 395         }
 396
 397         ps->a.currextra = &aifc->extra;
 398         usb_parse_extra(ps, &bifc->extra, &bifc->extralen);
 399         return;
 400 }
 401
 402 static void
 403 usb_parse_iface(struct usb_parse_state *ps)
 404 {
 405         struct libusb20_interface *aifc;
 406         struct usb_interface *bifc;
 407         uint8_t x;
 408
 409         aifc = ps->a.currifc;
 410         bifc = ps->b.currifcw++;
 411
 412         if (ps->preparse == 0) {
 413                 /* initialise interface wrapper */
 414                 bifc->altsetting = ps->b.currifc;
 415                 bifc->num_altsetting = aifc->num_altsetting + 1;
 416         }
 417         usb_parse_iface_sub(ps);
 418
 419         for (x = 0; x != aifc->num_altsetting; x++) {
 420                 ps->a.currifc = aifc->altsetting + x;
 421                 usb_parse_iface_sub(ps);
 422         }
 423         return;
 424 }
 425
 426 static void
 427 usb_parse_config(struct usb_parse_state *ps)
 428 {
 429         struct libusb20_config *acfg;
 430         struct usb_config_descriptor *bcfg;
 431         uint8_t x;
 432
 433         acfg = ps->a.currcfg;
 434         bcfg = ps->b.currcfg;
 435
 436         if (ps->preparse == 0) {
 437                 /* initialise config wrapper */
 438                 bcfg->bLength = acfg->desc.bLength;
 439                 bcfg->bDescriptorType = acfg->desc.bDescriptorType;
 440                 bcfg->wTotalLength = acfg->desc.wTotalLength;
 441                 bcfg->bNumInterfaces = acfg->num_interface;
 442                 bcfg->bConfigurationValue = acfg->desc.bConfigurationValue;
 443                 bcfg->iConfiguration = acfg->desc.iConfiguration;
 444                 bcfg->bmAttributes = acfg->desc.bmAttributes;
 445                 bcfg->MaxPower = acfg->desc.bMaxPower;
 446                 bcfg->interface = ps->b.currifcw;
 447         }
 448         for (x = 0; x != acfg->num_interface; x++) {
 449                 ps->a.currifc = acfg->interface + x;
 450                 usb_parse_iface(ps);
 451         }
 452
 453         ps->a.currextra = &acfg->extra;
 454         usb_parse_extra(ps, &bcfg->extra, &bcfg->extralen);
 455         return;
 456 }
 457
 458 int
 459 usb_parse_configuration(struct usb_config_descriptor *config,
 460     uint8_t *buffer)
 461 {
 462         struct usb_parse_state ps;
 463         uint8_t *ptr;
 464         uint32_t a;
 465         uint32_t b;
 466         uint32_t c;
 467         uint32_t d;
 468
 469         if ((buffer == NULL) || (config == NULL)) {
 470                 return (-1);
 471         }
 472         memset(&ps, 0, sizeof(ps));
 473
 474         ps.a.currcfg = libusb20_parse_config_desc(buffer);
 475         ps.b.currcfg = config;
 476         if (ps.a.currcfg == NULL) {
 477                 /* could not parse config or out of memory */
 478                 return (-1);
 479         }
 480         /* do the pre-parse */
 481         ps.preparse = 1;
 482         usb_parse_config(&ps);
 483
 484         a = ((uint8_t *)(ps.b.currifcw) - ((uint8_t *)0));
 485         b = ((uint8_t *)(ps.b.currifc) - ((uint8_t *)0));
 486         c = ((uint8_t *)(ps.b.currep) - ((uint8_t *)0));
 487         d = ((uint8_t *)(ps.b.currextra) - ((uint8_t *)0));
 488
 489         /* allocate memory for our configuration */
 490         ptr = malloc(a + b + c + d);
 491         if (ptr == NULL) {
 492                 /* free config structure */
 493                 free(ps.a.currcfg);
 494                 return (-1);
 495         }
 496
 497         /* "currifcw" must be first, hence this pointer is freed */
 498         ps.b.currifcw = (void *)(ptr);
 499         ps.b.currifc = (void *)(ptr + a);
 500         ps.b.currep = (void *)(ptr + a + b);
 501         ps.b.currextra = (void *)(ptr + a + b + c);
 502
 503         /* generate a libusb v0.1 compatible structure */
 504         ps.preparse = 0;
 505         usb_parse_config(&ps);
 506
 507         /* free config structure */
 508         free(ps.a.currcfg);
 509
 510         return (0);                     /* success */
 511 }
 512
 513 void
 514 usb_destroy_configuration(struct usb_device *dev)
 515 {
 516         uint8_t c;
 517
 518         if (dev->config == NULL) {
 519                 return;
 520         }
 521         for (c = 0; c != dev->descriptor.bNumConfigurations; c++) {
 522                 struct usb_config_descriptor *cf = &dev->config[c];
 523
 524                 if (cf->interface != NULL) {
 525                         free(cf->interface);
 526                         cf->interface = NULL;
 527                 }
 528         }
 529
 530         free(dev->config);
 531         dev->config = NULL;
 532         return;
 533 }
 534
 535 void
 536 usb_fetch_and_parse_descriptors(usb_dev_handle * udev)
 537 {
 538         struct usb_device *dev;
 539         struct libusb20_device *pdev;
 540         uint8_t *ptr;
 541         int error;
 542         uint32_t size;
 543         uint16_t len;
 544         uint8_t x;
 545
 546         if (udev == NULL) {
 547                 /* be NULL safe */
 548                 return;
 549         }
 550         dev = usb_device(udev);
 551         pdev = (void *)udev;
 552
 553         if (dev->descriptor.bNumConfigurations == 0) {
 554                 /* invalid device */
 555                 return;
 556         }
 557         size = dev->descriptor.bNumConfigurations *
 558             sizeof(struct usb_config_descriptor);
 559
 560         dev->config = malloc(size);
 561         if (dev->config == NULL) {
 562                 /* out of memory */
 563                 return;
 564         }
 565         memset(dev->config, 0, size);
 566
 567         for (x = 0; x != dev->descriptor.bNumConfigurations; x++) {
 568
 569                 error = (pdev->methods->get_config_desc_full) (
 570                     pdev, &ptr, &len, x);
 571
 572                 if (error) {
 573                         usb_destroy_configuration(dev);
 574                         return;
 575                 }
 576                 usb_parse_configuration(dev->config + x, ptr);
 577
 578                 /* free config buffer */
 579                 free(ptr);
 580         }
 581         return;
 582 }
 583
 584 static int
 585 usb_std_io(usb_dev_handle * dev, int ep, char *bytes, int size,
 586     int timeout, int is_intr)
 587 {
 588         struct libusb20_transfer *xfer;
 589         uint32_t temp;
 590         uint32_t maxsize;
 591         uint32_t actlen;
 592         char *oldbytes;
 593
 594         xfer = usb_get_transfer_by_ep_no(dev, ep);
 595         if (xfer == NULL)
 596                 return (-1);
 597
 598         if (libusb20_tr_pending(xfer)) {
 599                 /* there is already a transfer ongoing */
 600                 return (-1);
 601         }
 602         maxsize = libusb20_tr_get_max_total_length(xfer);
 603         oldbytes = bytes;
 604
 605         /*
 606          * We allow transferring zero bytes which is the same
 607          * equivalent to a zero length USB packet.
 608          */
 609         do {
 610
 611                 temp = size;
 612                 if (temp > maxsize) {
 613                         /* find maximum possible length */
 614                         temp = maxsize;
 615                 }
 616                 if (is_intr)
 617                         libusb20_tr_setup_intr(xfer, bytes, temp, timeout);
 618                 else
 619                         libusb20_tr_setup_bulk(xfer, bytes, temp, timeout);
 620
 621                 libusb20_tr_start(xfer);
 622
 623                 while (1) {
 624
 625                         if (libusb20_dev_process((void *)dev) != 0) {
 626                                 /* device detached */
 627                                 return (-1);
 628                         }
 629                         if (libusb20_tr_pending(xfer) == 0) {
 630                                 /* transfer complete */
 631                                 break;
 632                         }
 633                         /* wait for USB event from kernel */
 634                         libusb20_dev_wait_process((void *)dev, -1);
 635                 }
 636
 637                 switch (libusb20_tr_get_status(xfer)) {
 638                 case 0:
 639                         /* success */
 640                         break;
 641                 case LIBUSB20_TRANSFER_TIMED_OUT:
 642                         /* transfer timeout */
 643                         return (-ETIMEDOUT);
 644                 default:
 645                         /* other transfer error */
 646                         return (-ENXIO);
 647                 }
 648                 actlen = libusb20_tr_get_actual_length(xfer);
 649
 650                 bytes += actlen;
 651                 size -= actlen;
 652
 653                 if (actlen != temp) {
 654                         /* short transfer */
 655                         break;
 656                 }
 657         } while (size > 0);
 658
 659         return (bytes - oldbytes);
 660 }
 661
 662 int
 663 usb_bulk_write(usb_dev_handle * dev, int ep, char *bytes,
 664     int size, int timeout)
 665 {
 666         return (usb_std_io(dev, ep & ~USB_ENDPOINT_DIR_MASK,
 667             bytes, size, timeout, 0));
 668 }
 669
 670 int
 671 usb_bulk_read(usb_dev_handle * dev, int ep, char *bytes,
 672     int size, int timeout)
 673 {
 674         return (usb_std_io(dev, ep | USB_ENDPOINT_DIR_MASK,
 675             bytes, size, timeout, 0));
 676 }
 677
 678 int
 679 usb_interrupt_write(usb_dev_handle * dev, int ep, char *bytes,
 680     int size, int timeout)
 681 {
 682         return (usb_std_io(dev, ep & ~USB_ENDPOINT_DIR_MASK,
 683             bytes, size, timeout, 1));
 684 }
 685
 686 int
 687 usb_interrupt_read(usb_dev_handle * dev, int ep, char *bytes,
 688     int size, int timeout)
 689 {
 690         return (usb_std_io(dev, ep | USB_ENDPOINT_DIR_MASK,
 691             bytes, size, timeout, 1));
 692 }
 693
 694 int
 695 usb_control_msg(usb_dev_handle * dev, int requesttype, int request,
 696     int value, int wIndex, char *bytes, int size, int timeout)
 697 {
 698         struct LIBUSB20_CONTROL_SETUP_DECODED req;
 699         int err;
 700         uint16_t actlen;
 701
 702         LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req);
 703
 704         req.bmRequestType = requesttype;
 705         req.bRequest = request;
 706         req.wValue = value;
 707         req.wIndex = wIndex;
 708         req.wLength = size;
 709
 710         err = libusb20_dev_request_sync((void *)dev, &req, bytes,
 711             &actlen, timeout, 0);
 712
 713         if (err)
 714                 return (-1);
 715
 716         return (actlen);
 717 }
 718
 719 int
 720 usb_set_configuration(usb_dev_handle * udev, int bConfigurationValue)
 721 {
 722         struct usb_device *dev;
 723         int err;
 724         uint8_t i;
 725
 726         /*
 727          * Need to translate from "bConfigurationValue" to
 728          * configuration index:
 729          */
 730
 731         if (bConfigurationValue == 0) {
 732                 /* unconfigure */
 733                 i = 255;
 734         } else {
 735                 /* lookup configuration index */
 736                 dev = usb_device(udev);
 737
 738                 /* check if the configuration array is not there */
 739                 if (dev->config == NULL) {
 740                         return (-1);
 741                 }
 742                 for (i = 0;; i++) {
 743                         if (i == dev->descriptor.bNumConfigurations) {
 744                                 /* "bConfigurationValue" not found */
 745                                 return (-1);
 746                         }
 747                         if ((dev->config + i)->bConfigurationValue ==
 748                             bConfigurationValue) {
 749                                 break;
 750                         }
 751                 }
 752         }
 753
 754         err = libusb20_dev_set_config_index((void *)udev, i);
 755
 756         if (err)
 757                 return (-1);
 758
 759         return (0);
 760 }
 761
 762 int
 763 usb_claim_interface(usb_dev_handle * dev, int interface)
 764 {
 765         struct libusb20_device *pdev = (void *)dev;
 766
 767         pdev->claimed_interface = interface;
 768
 769         return (0);
 770 }
 771
 772 int
 773 usb_release_interface(usb_dev_handle * dev, int interface)
 774 {
 775         /* do nothing */
 776         return (0);
 777 }
 778
 779 int
 780 usb_set_altinterface(usb_dev_handle * dev, int alternate)
 781 {
 782         struct libusb20_device *pdev = (void *)dev;
 783         int err;
 784         uint8_t iface;
 785
 786         iface = pdev->claimed_interface;
 787
 788         err = libusb20_dev_set_alt_index((void *)dev, iface, alternate);
 789
 790         if (err)
 791                 return (-1);
 792
 793         return (0);
 794 }
 795
 796 int
 797 usb_resetep(usb_dev_handle * dev, unsigned int ep)
 798 {
 799         /* emulate an endpoint reset through clear-STALL */
 800         return (usb_clear_halt(dev, ep));
 801 }
 802
 803 int
 804 usb_clear_halt(usb_dev_handle * dev, unsigned int ep)
 805 {
 806         struct libusb20_transfer *xfer;
 807
 808         xfer = usb_get_transfer_by_ep_no(dev, ep);
 809         if (xfer == NULL)
 810                 return (-1);
 811
 812         libusb20_tr_clear_stall_sync(xfer);
 813
 814         return (0);
 815 }
 816
 817 int
 818 usb_reset(usb_dev_handle * dev)
 819 {
 820         int err;
 821
 822         err = libusb20_dev_reset((void *)dev);
 823
 824         if (err)
 825                 return (-1);
 826
 827         /*
 828          * Be compatible with LibUSB from sourceforge and close the
 829          * handle after reset!
 830          */
 831         return (usb_close(dev));
 832 }
 833
 834 int
 835 usb_check_connected(usb_dev_handle * dev)
 836 {
 837         int err;
 838
 839         err = libusb20_dev_check_connected((void *)dev);
 840
 841         if (err)
 842                 return (-1);
 843
 844         return (0);
 845 }
 846
 847 const char *
 848 usb_strerror(void)
 849 {
 850         /* TODO */
 851         return ("Unknown error");
 852 }
 853
 854 void
 855 usb_init(void)
 856 {
 857         /* nothing to do */
 858         return;
 859 }
 860
 861 void
 862 usb_set_debug(int level)
 863 {
 864         /* use kernel UGEN debugging if you need to see what is going on */
 865         return;
 866 }
 867
 868 int
 869 usb_find_busses(void)
 870 {
 871         usb_busses = &usb_global_bus;
 872         return (1);
 873 }
 874
 875 int
 876 usb_find_devices(void)
 877 {
 878         struct libusb20_device *pdev;
 879         struct usb_device *udev;
 880         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
 881         int devnum;
 882         int err;
 883
 884         /* cleanup after last device search */
 885         /* close all opened devices, if any */
 886
 887         while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) {
 888                 udev = pdev->privLuData;
 889                 libusb20_be_dequeue_device(usb_backend, pdev);
 890                 libusb20_dev_free(pdev);
 891                 if (udev != NULL) {
 892                         LIST_DEL(usb_global_bus.devices, udev);
 893                         free(udev);
 894                 }
 895         }
 896
 897         /* free old USB backend, if any */
 898
 899         libusb20_be_free(usb_backend);
 900
 901         /* do a new backend device search */
 902         usb_backend = libusb20_be_alloc_default();
 903         if (usb_backend == NULL) {
 904                 return (-1);
 905         }
 906         /* iterate all devices */
 907
 908         devnum = 1;
 909         pdev = NULL;
 910         while ((pdev = libusb20_be_device_foreach(usb_backend, pdev))) {
 911                 udev = malloc(sizeof(*udev));
 912                 if (udev == NULL)
 913                         break;
 914
 915                 memset(udev, 0, sizeof(*udev));
 916
 917                 udev->bus = &usb_global_bus;
 918
 919                 snprintf(udev->filename, sizeof(udev->filename),
 920                     "/dev/ugen%u.%u",
 921                     libusb20_dev_get_bus_number(pdev),
 922                     libusb20_dev_get_address(pdev));
 923
 924                 ddesc = libusb20_dev_get_device_desc(pdev);
 925
 926                 udev->descriptor.bLength = sizeof(udev->descriptor);
 927                 udev->descriptor.bDescriptorType = ddesc->bDescriptorType;
 928                 udev->descriptor.bcdUSB = ddesc->bcdUSB;
 929                 udev->descriptor.bDeviceClass = ddesc->bDeviceClass;
 930                 udev->descriptor.bDeviceSubClass = ddesc->bDeviceSubClass;
 931                 udev->descriptor.bDeviceProtocol = ddesc->bDeviceProtocol;
 932                 udev->descriptor.bMaxPacketSize0 = ddesc->bMaxPacketSize0;
 933                 udev->descriptor.idVendor = ddesc->idVendor;
 934                 udev->descriptor.idProduct = ddesc->idProduct;
 935                 udev->descriptor.bcdDevice = ddesc->bcdDevice;
 936                 udev->descriptor.iManufacturer = ddesc->iManufacturer;
 937                 udev->descriptor.iProduct = ddesc->iProduct;
 938                 udev->descriptor.iSerialNumber = ddesc->iSerialNumber;
 939                 udev->descriptor.bNumConfigurations =
 940                     ddesc->bNumConfigurations;
 941                 if (udev->descriptor.bNumConfigurations > USB_MAXCONFIG) {
 942                         /* truncate number of configurations */
 943                         udev->descriptor.bNumConfigurations = USB_MAXCONFIG;
 944                 }
 945                 udev->devnum = devnum++;
 946                 /* link together the two structures */
 947                 udev->dev = pdev;
 948                 pdev->privLuData = udev;
 949
 950                 err = libusb20_dev_open(pdev, 0);
 951                 if (err == 0) {
 952                         /* XXX get all config descriptors by default */
 953                         usb_fetch_and_parse_descriptors((void *)pdev);
 954                         libusb20_dev_close(pdev);
 955                 }
 956                 LIST_ADD(usb_global_bus.devices, udev);
 957         }
 958
 959         return (devnum - 1);                    /* success */
 960 }
 961
 962 struct usb_device *
 963 usb_device(usb_dev_handle * dev)
 964 {
 965         struct libusb20_device *pdev;
 966
 967         pdev = (void *)dev;
 968
 969         return (pdev->privLuData);
 970 }
 971
 972 struct usb_bus *
 973 usb_get_busses(void)
 974 {
 975         return (usb_busses);
 976 }
 977
 978 int
 979 usb_get_driver_np(usb_dev_handle * dev, int interface, char *name, int namelen)
 980 {
 981         struct libusb20_device *pdev;
 982         char *ptr;
 983         int err;
 984
 985         pdev = (void *)dev;
 986
 987         if (pdev == NULL)
 988                 return (-1);
 989         if (namelen < 1)
 990                 return (-1);
 991         if (namelen > 255)
 992                 namelen = 255;
 993
 994         err = libusb20_dev_get_iface_desc(pdev, interface, name, namelen);
 995         if (err != 0)
 996                 return (-1);
 997
 998         /* we only want the driver name */
 999         ptr = strstr(name, ":");
1000         if (ptr != NULL)
1001                 *ptr = 0;
1002
1003         return (0);
1004 }
1005
1006 int
1007 usb_detach_kernel_driver_np(usb_dev_handle * dev, int interface)
1008 {
1009         struct libusb20_device *pdev;
1010         int err;
1011
1012         pdev = (void *)dev;
1013
1014         if (pdev == NULL)
1015                 return (-1);
1016
1017         err = libusb20_dev_detach_kernel_driver(pdev, interface);
1018         if (err != 0)
1019                 return (-1);
1020
1021         return (0);
1022 }