lib/libusb/libusb10.c

   1 /* $FreeBSD$ */
   2 /*-
   3  * Copyright (c) 2009 Sylvestre Gallon. All rights reserved.
   4  * Copyright (c) 2009 Hans Petter Selasky. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <stdio.h>
  31 #include <poll.h>
  32 #include <pthread.h>
  33 #include <time.h>
  34 #include <errno.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/filio.h>
  37 #include <sys/queue.h>
  38 #include <sys/endian.h>
  39
  40 #include "libusb20.h"
  41 #include "libusb20_desc.h"
  42 #include "libusb20_int.h"
  43 #include "libusb.h"
  44 #include "libusb10.h"
  45
  46 static pthread_mutex_t default_context_lock = PTHREAD_MUTEX_INITIALIZER;
  47 struct libusb_context *usbi_default_context = NULL;
  48
  49 /* Prototypes */
  50
  51 static struct libusb20_transfer *libusb10_get_transfer(struct libusb20_device *, uint8_t, uint8_t);
  52 static int libusb10_get_maxframe(struct libusb20_device *, libusb_transfer *);
  53 static int libusb10_get_buffsize(struct libusb20_device *, libusb_transfer *);
  54 static int libusb10_convert_error(uint8_t status);
  55 static void libusb10_complete_transfer(struct libusb20_transfer *, struct libusb_super_transfer *, int);
  56 static void libusb10_isoc_proxy(struct libusb20_transfer *);
  57 static void libusb10_bulk_intr_proxy(struct libusb20_transfer *);
  58 static void libusb10_ctrl_proxy(struct libusb20_transfer *);
  59 static void libusb10_submit_transfer_sub(struct libusb20_device *, uint8_t);
  60
  61 /*  Library initialisation / deinitialisation */
  62
  63 void
  64 libusb_set_debug(libusb_context *ctx, int level)
  65 {
  66         ctx = GET_CONTEXT(ctx);
  67         if (ctx)
  68                 ctx->debug = level;
  69 }
  70
  71 int
  72 libusb_init(libusb_context **context)
  73 {
  74         struct libusb_context *ctx;
  75         char *debug;
  76         int ret;
  77
  78         ctx = malloc(sizeof(*ctx));
  79         if (!ctx)
  80                 return (LIBUSB_ERROR_INVALID_PARAM);
  81
  82         memset(ctx, 0, sizeof(*ctx));
  83
  84         debug = getenv("LIBUSB_DEBUG");
  85         if (debug != NULL) {
  86                 ctx->debug = atoi(debug);
  87                 if (ctx->debug != 0)
  88                         ctx->debug_fixed = 1;
  89         }
  90         TAILQ_INIT(&ctx->pollfds);
  91         TAILQ_INIT(&ctx->tr_done);
  92
  93         pthread_mutex_init(&ctx->ctx_lock, NULL);
  94         pthread_cond_init(&ctx->ctx_cond, NULL);
  95
  96         ctx->ctx_handler = NO_THREAD;
  97
  98         ret = pipe(ctx->ctrl_pipe);
  99         if (ret < 0) {
 100                 pthread_mutex_destroy(&ctx->ctx_lock);
 101                 pthread_cond_destroy(&ctx->ctx_cond);
 102                 free(ctx);
 103                 return (LIBUSB_ERROR_OTHER);
 104         }
 105         /* set non-blocking mode on the control pipe to avoid deadlock */
 106         ret = 1;
 107         ioctl(ctx->ctrl_pipe[0], FIONBIO, &ret);
 108         ret = 1;
 109         ioctl(ctx->ctrl_pipe[1], FIONBIO, &ret);
 110
 111         libusb10_add_pollfd(ctx, &ctx->ctx_poll, NULL, ctx->ctrl_pipe[0], POLLIN);
 112
 113         pthread_mutex_lock(&default_context_lock);
 114         if (usbi_default_context == NULL) {
 115                 usbi_default_context = ctx;
 116         }
 117         pthread_mutex_unlock(&default_context_lock);
 118
 119         if (context)
 120                 *context = ctx;
 121
 122         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_init complete");
 123
 124         return (0);
 125 }
 126
 127 void
 128 libusb_exit(libusb_context *ctx)
 129 {
 130         ctx = GET_CONTEXT(ctx);
 131
 132         if (ctx == NULL)
 133                 return;
 134
 135         /* XXX cleanup devices */
 136
 137         libusb10_remove_pollfd(ctx, &ctx->ctx_poll);
 138         close(ctx->ctrl_pipe[0]);
 139         close(ctx->ctrl_pipe[1]);
 140         pthread_mutex_destroy(&ctx->ctx_lock);
 141         pthread_cond_destroy(&ctx->ctx_cond);
 142
 143         pthread_mutex_lock(&default_context_lock);
 144         if (ctx == usbi_default_context) {
 145                 usbi_default_context = NULL;
 146         }
 147         pthread_mutex_unlock(&default_context_lock);
 148
 149         free(ctx);
 150 }
 151
 152 /* Device handling and initialisation. */
 153
 154 ssize_t
 155 libusb_get_device_list(libusb_context *ctx, libusb_device ***list)
 156 {
 157         struct libusb20_backend *usb_backend;
 158         struct libusb20_device *pdev;
 159         struct libusb_device *dev;
 160         int i;
 161
 162         ctx = GET_CONTEXT(ctx);
 163
 164         if (ctx == NULL)
 165                 return (LIBUSB_ERROR_INVALID_PARAM);
 166
 167         if (list == NULL)
 168                 return (LIBUSB_ERROR_INVALID_PARAM);
 169
 170         usb_backend = libusb20_be_alloc_default();
 171         if (usb_backend == NULL)
 172                 return (LIBUSB_ERROR_NO_MEM);
 173
 174         /* figure out how many USB devices are present */
 175         pdev = NULL;
 176         i = 0;
 177         while ((pdev = libusb20_be_device_foreach(usb_backend, pdev)))
 178                 i++;
 179
 180         /* allocate device pointer list */
 181         *list = malloc((i + 1) * sizeof(void *));
 182         if (*list == NULL) {
 183                 libusb20_be_free(usb_backend);
 184                 return (LIBUSB_ERROR_NO_MEM);
 185         }
 186         /* create libusb v1.0 compliant devices */
 187         i = 0;
 188         while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) {
 189
 190                 dev = malloc(sizeof(*dev));
 191                 if (dev == NULL) {
 192                         while (i != 0) {
 193                                 libusb_unref_device((*list)[i - 1]);
 194                                 i--;
 195                         }
 196                         free(*list);
 197                         *list = NULL;
 198                         libusb20_be_free(usb_backend);
 199                         return (LIBUSB_ERROR_NO_MEM);
 200                 }
 201
 202                 /* get device into libUSB v1.0 list */
 203                 libusb20_be_dequeue_device(usb_backend, pdev);
 204
 205                 memset(dev, 0, sizeof(*dev));
 206
 207                 /* init transfer queues */
 208                 TAILQ_INIT(&dev->tr_head);
 209
 210                 /* set context we belong to */
 211                 dev->ctx = ctx;
 212
 213                 /* link together the two structures */
 214                 dev->os_priv = pdev;
 215                 pdev->privLuData = dev;
 216
 217                 (*list)[i] = libusb_ref_device(dev);
 218                 i++;
 219         }
 220         (*list)[i] = NULL;
 221
 222         libusb20_be_free(usb_backend);
 223         return (i);
 224 }
 225
 226 void
 227 libusb_free_device_list(libusb_device **list, int unref_devices)
 228 {
 229         int i;
 230
 231         if (list == NULL)
 232                 return;                 /* be NULL safe */
 233
 234         if (unref_devices) {
 235                 for (i = 0; list[i] != NULL; i++)
 236                         libusb_unref_device(list[i]);
 237         }
 238         free(list);
 239 }
 240
 241 uint8_t
 242 libusb_get_bus_number(libusb_device *dev)
 243 {
 244         if (dev == NULL)
 245                 return (0);             /* should not happen */
 246         return (libusb20_dev_get_bus_number(dev->os_priv));
 247 }
 248
 249 uint8_t
 250 libusb_get_device_address(libusb_device *dev)
 251 {
 252         if (dev == NULL)
 253                 return (0);             /* should not happen */
 254         return (libusb20_dev_get_address(dev->os_priv));
 255 }
 256
 257 int
 258 libusb_get_max_packet_size(libusb_device *dev, uint8_t endpoint)
 259 {
 260         struct libusb_config_descriptor *pdconf;
 261         struct libusb_interface *pinf;
 262         struct libusb_interface_descriptor *pdinf;
 263         struct libusb_endpoint_descriptor *pdend;
 264         int i;
 265         int j;
 266         int k;
 267         int ret;
 268
 269         if (dev == NULL)
 270                 return (LIBUSB_ERROR_NO_DEVICE);
 271
 272         ret = libusb_get_active_config_descriptor(dev, &pdconf);
 273         if (ret < 0)
 274                 return (ret);
 275
 276         ret = LIBUSB_ERROR_NOT_FOUND;
 277         for (i = 0; i < pdconf->bNumInterfaces; i++) {
 278                 pinf = &pdconf->interface[i];
 279                 for (j = 0; j < pinf->num_altsetting; j++) {
 280                         pdinf = &pinf->altsetting[j];
 281                         for (k = 0; k < pdinf->bNumEndpoints; k++) {
 282                                 pdend = &pdinf->endpoint[k];
 283                                 if (pdend->bEndpointAddress == endpoint) {
 284                                         ret = pdend->wMaxPacketSize;
 285                                         goto out;
 286                                 }
 287                         }
 288                 }
 289         }
 290
 291 out:
 292         libusb_free_config_descriptor(pdconf);
 293         return (ret);
 294 }
 295
 296 libusb_device *
 297 libusb_ref_device(libusb_device *dev)
 298 {
 299         if (dev == NULL)
 300                 return (NULL);          /* be NULL safe */
 301
 302         CTX_LOCK(dev->ctx);
 303         dev->refcnt++;
 304         CTX_UNLOCK(dev->ctx);
 305
 306         return (dev);
 307 }
 308
 309 void
 310 libusb_unref_device(libusb_device *dev)
 311 {
 312         if (dev == NULL)
 313                 return;                 /* be NULL safe */
 314
 315         CTX_LOCK(dev->ctx);
 316         dev->refcnt--;
 317         CTX_UNLOCK(dev->ctx);
 318
 319         if (dev->refcnt == 0) {
 320                 libusb20_dev_free(dev->os_priv);
 321                 free(dev);
 322         }
 323 }
 324
 325 int
 326 libusb_open(libusb_device *dev, libusb_device_handle **devh)
 327 {
 328         libusb_context *ctx = dev->ctx;
 329         struct libusb20_device *pdev = dev->os_priv;
 330         uint8_t dummy;
 331         int err;
 332
 333         if (devh == NULL)
 334                 return (LIBUSB_ERROR_INVALID_PARAM);
 335
 336         /* set default device handle value */
 337         *devh = NULL;
 338
 339         dev = libusb_ref_device(dev);
 340         if (dev == NULL)
 341                 return (LIBUSB_ERROR_INVALID_PARAM);
 342
 343         err = libusb20_dev_open(pdev, 16 * 4 /* number of endpoints */ );
 344         if (err) {
 345                 libusb_unref_device(dev);
 346                 return (LIBUSB_ERROR_NO_MEM);
 347         }
 348         libusb10_add_pollfd(ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN |
 349             POLLOUT | POLLRDNORM | POLLWRNORM);
 350
 351         /* make sure our event loop detects the new device */
 352         dummy = 0;
 353         err = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
 354         if (err < sizeof(dummy)) {
 355                 /* ignore error, if any */
 356                 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open write failed!");
 357         }
 358         *devh = pdev;
 359
 360         return (0);
 361 }
 362
 363 libusb_device_handle *
 364 libusb_open_device_with_vid_pid(libusb_context *ctx, uint16_t vendor_id,
 365     uint16_t product_id)
 366 {
 367         struct libusb_device **devs;
 368         struct libusb20_device *pdev;
 369         struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
 370         int i;
 371         int j;
 372
 373         ctx = GET_CONTEXT(ctx);
 374         if (ctx == NULL)
 375                 return (NULL);          /* be NULL safe */
 376
 377         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_width_vid_pid enter");
 378
 379         if ((i = libusb_get_device_list(ctx, &devs)) < 0)
 380                 return (NULL);
 381
 382         pdev = NULL;
 383
 384         for (j = 0; j < i; j++) {
 385                 pdev = devs[j]->os_priv;
 386                 pdesc = libusb20_dev_get_device_desc(pdev);
 387                 /*
 388                  * NOTE: The USB library will automatically swap the
 389                  * fields in the device descriptor to be of host
 390                  * endian type!
 391                  */
 392                 if (pdesc->idVendor == vendor_id &&
 393                     pdesc->idProduct == product_id) {
 394                         if (libusb_open(devs[j], &pdev) < 0)
 395                                 pdev = NULL;
 396                         break;
 397                 }
 398         }
 399
 400         libusb_free_device_list(devs, 1);
 401         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_width_vid_pid leave");
 402         return (pdev);
 403 }
 404
 405 void
 406 libusb_close(struct libusb20_device *pdev)
 407 {
 408         libusb_context *ctx;
 409         struct libusb_device *dev;
 410         uint8_t dummy;
 411         int err;
 412
 413         if (pdev == NULL)
 414                 return;                 /* be NULL safe */
 415
 416         dev = libusb_get_device(pdev);
 417         ctx = dev->ctx;
 418
 419         libusb10_remove_pollfd(ctx, &dev->dev_poll);
 420
 421         libusb20_dev_close(pdev);
 422
 423         /* unref will free the "pdev" when the refcount reaches zero */
 424         libusb_unref_device(dev);
 425
 426         /* make sure our event loop detects the closed device */
 427         dummy = 0;
 428         err = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
 429         if (err < sizeof(dummy)) {
 430                 /* ignore error, if any */
 431                 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_close write failed!");
 432         }
 433 }
 434
 435 libusb_device *
 436 libusb_get_device(struct libusb20_device *pdev)
 437 {
 438         if (pdev == NULL)
 439                 return (NULL);
 440         return ((libusb_device *)pdev->privLuData);
 441 }
 442
 443 int
 444 libusb_get_configuration(struct libusb20_device *pdev, int *config)
 445 {
 446         struct libusb20_config *pconf;
 447
 448         if (pdev == NULL || config == NULL)
 449                 return (LIBUSB_ERROR_INVALID_PARAM);
 450
 451         pconf = libusb20_dev_alloc_config(pdev, libusb20_dev_get_config_index(pdev));
 452         if (pconf == NULL)
 453                 return (LIBUSB_ERROR_NO_MEM);
 454
 455         *config = pconf->desc.bConfigurationValue;
 456
 457         free(pconf);
 458
 459         return (0);
 460 }
 461
 462 int
 463 libusb_set_configuration(struct libusb20_device *pdev, int configuration)
 464 {
 465         struct libusb20_config *pconf;
 466         struct libusb_device *dev;
 467         int err;
 468         uint8_t i;
 469
 470         dev = libusb_get_device(pdev);
 471
 472         if (dev == NULL)
 473                 return (LIBUSB_ERROR_INVALID_PARAM);
 474
 475         if (configuration < 1) {
 476                 /* unconfigure */
 477                 i = 255;
 478         } else {
 479                 for (i = 0; i != 255; i++) {
 480                         uint8_t found;
 481
 482                         pconf = libusb20_dev_alloc_config(pdev, i);
 483                         if (pconf == NULL)
 484                                 return (LIBUSB_ERROR_INVALID_PARAM);
 485                         found = (pconf->desc.bConfigurationValue
 486                             == configuration);
 487                         free(pconf);
 488
 489                         if (found)
 490                                 goto set_config;
 491                 }
 492                 return (LIBUSB_ERROR_INVALID_PARAM);
 493         }
 494
 495 set_config:
 496
 497         libusb10_cancel_all_transfer(dev);
 498
 499         libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
 500
 501         err = libusb20_dev_set_config_index(pdev, i);
 502
 503         libusb10_add_pollfd(dev->ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN |
 504             POLLOUT | POLLRDNORM | POLLWRNORM);
 505
 506         return (err ? LIBUSB_ERROR_INVALID_PARAM : 0);
 507 }
 508
 509 int
 510 libusb_claim_interface(struct libusb20_device *pdev, int interface_number)
 511 {
 512         libusb_device *dev;
 513         int err = 0;
 514
 515         dev = libusb_get_device(pdev);
 516         if (dev == NULL)
 517                 return (LIBUSB_ERROR_INVALID_PARAM);
 518
 519         if (interface_number < 0 || interface_number > 31)
 520                 return (LIBUSB_ERROR_INVALID_PARAM);
 521
 522         CTX_LOCK(dev->ctx);
 523         if (dev->claimed_interfaces & (1 << interface_number))
 524                 err = LIBUSB_ERROR_BUSY;
 525
 526         if (!err)
 527                 dev->claimed_interfaces |= (1 << interface_number);
 528         CTX_UNLOCK(dev->ctx);
 529         return (err);
 530 }
 531
 532 int
 533 libusb_release_interface(struct libusb20_device *pdev, int interface_number)
 534 {
 535         libusb_device *dev;
 536         int err = 0;
 537
 538         dev = libusb_get_device(pdev);
 539         if (dev == NULL)
 540                 return (LIBUSB_ERROR_INVALID_PARAM);
 541
 542         if (interface_number < 0 || interface_number > 31)
 543                 return (LIBUSB_ERROR_INVALID_PARAM);
 544
 545         CTX_LOCK(dev->ctx);
 546         if (!(dev->claimed_interfaces & (1 << interface_number)))
 547                 err = LIBUSB_ERROR_NOT_FOUND;
 548
 549         if (!err)
 550                 dev->claimed_interfaces &= ~(1 << interface_number);
 551         CTX_UNLOCK(dev->ctx);
 552         return (err);
 553 }
 554
 555 int
 556 libusb_set_interface_alt_setting(struct libusb20_device *pdev,
 557     int interface_number, int alternate_setting)
 558 {
 559         libusb_device *dev;
 560         int err = 0;
 561
 562         dev = libusb_get_device(pdev);
 563         if (dev == NULL)
 564                 return (LIBUSB_ERROR_INVALID_PARAM);
 565
 566         if (interface_number < 0 || interface_number > 31)
 567                 return (LIBUSB_ERROR_INVALID_PARAM);
 568
 569         CTX_LOCK(dev->ctx);
 570         if (!(dev->claimed_interfaces & (1 << interface_number)))
 571                 err = LIBUSB_ERROR_NOT_FOUND;
 572         CTX_UNLOCK(dev->ctx);
 573
 574         if (err)
 575                 return (err);
 576
 577         libusb10_cancel_all_transfer(dev);
 578
 579         libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
 580
 581         err = libusb20_dev_set_alt_index(pdev,
 582             interface_number, alternate_setting);
 583
 584         libusb10_add_pollfd(dev->ctx, &dev->dev_poll,
 585             pdev, libusb20_dev_get_fd(pdev),
 586             POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
 587
 588         return (err ? LIBUSB_ERROR_OTHER : 0);
 589 }
 590
 591 static struct libusb20_transfer *
 592 libusb10_get_transfer(struct libusb20_device *pdev,
 593     uint8_t endpoint, uint8_t index)
 594 {
 595         index &= 1;                     /* double buffering */
 596
 597         index |= (endpoint & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 4;
 598
 599         if (endpoint & LIBUSB20_ENDPOINT_DIR_MASK) {
 600                 /* this is an IN endpoint */
 601                 index |= 2;
 602         }
 603         return (libusb20_tr_get_pointer(pdev, index));
 604 }
 605
 606 int
 607 libusb_clear_halt(struct libusb20_device *pdev, uint8_t endpoint)
 608 {
 609         struct libusb20_transfer *xfer;
 610         struct libusb_device *dev;
 611         int err;
 612
 613         xfer = libusb10_get_transfer(pdev, endpoint, 0);
 614         if (xfer == NULL)
 615                 return (LIBUSB_ERROR_INVALID_PARAM);
 616
 617         dev = libusb_get_device(pdev);
 618
 619         CTX_LOCK(dev->ctx);
 620         err = libusb20_tr_open(xfer, 0, 0, endpoint);
 621         CTX_UNLOCK(dev->ctx);
 622
 623         if (err != 0 && err != LIBUSB20_ERROR_BUSY)
 624                 return (LIBUSB_ERROR_OTHER);
 625
 626         libusb20_tr_clear_stall_sync(xfer);
 627
 628         /* check if we opened the transfer */
 629         if (err == 0) {
 630                 CTX_LOCK(dev->ctx);
 631                 libusb20_tr_close(xfer);
 632                 CTX_UNLOCK(dev->ctx);
 633         }
 634         return (0);                     /* success */
 635 }
 636
 637 int
 638 libusb_reset_device(struct libusb20_device *pdev)
 639 {
 640         libusb_device *dev;
 641         int err;
 642
 643         dev = libusb_get_device(pdev);
 644         if (dev == NULL)
 645                 return (LIBUSB20_ERROR_INVALID_PARAM);
 646
 647         libusb10_cancel_all_transfer(dev);
 648
 649         libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
 650
 651         err = libusb20_dev_reset(pdev);
 652
 653         libusb10_add_pollfd(dev->ctx, &dev->dev_poll,
 654             pdev, libusb20_dev_get_fd(pdev),
 655             POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
 656
 657         return (err ? LIBUSB_ERROR_OTHER : 0);
 658 }
 659
 660 int
 661 libusb_kernel_driver_active(struct libusb20_device *pdev, int interface)
 662 {
 663         if (pdev == NULL)
 664                 return (LIBUSB_ERROR_INVALID_PARAM);
 665
 666         return (libusb20_dev_kernel_driver_active(
 667             pdev, interface));
 668 }
 669
 670 int
 671 libusb_detach_kernel_driver(struct libusb20_device *pdev, int interface)
 672 {
 673         int err;
 674
 675         if (pdev == NULL)
 676                 return (LIBUSB_ERROR_INVALID_PARAM);
 677
 678         err = libusb20_dev_detach_kernel_driver(
 679             pdev, interface);
 680
 681         return (err ? LIBUSB20_ERROR_OTHER : 0);
 682 }
 683
 684 int
 685 libusb_attach_kernel_driver(struct libusb20_device *pdev, int interface)
 686 {
 687         if (pdev == NULL)
 688                 return (LIBUSB_ERROR_INVALID_PARAM);
 689         /* stub - currently not supported by libusb20 */
 690         return (0);
 691 }
 692
 693 /* Asynchronous device I/O */
 694
 695 struct libusb_transfer *
 696 libusb_alloc_transfer(int iso_packets)
 697 {
 698         struct libusb_transfer *uxfer;
 699         struct libusb_super_transfer *sxfer;
 700         int len;
 701
 702         len = sizeof(struct libusb_transfer) +
 703             sizeof(struct libusb_super_transfer) +
 704             (iso_packets * sizeof(libusb_iso_packet_descriptor));
 705
 706         sxfer = malloc(len);
 707         if (sxfer == NULL)
 708                 return (NULL);
 709
 710         memset(sxfer, 0, len);
 711
 712         uxfer = (struct libusb_transfer *)(
 713             ((uint8_t *)sxfer) + sizeof(*sxfer));
 714
 715         /* set default value */
 716         uxfer->num_iso_packets = iso_packets;
 717
 718         return (uxfer);
 719 }
 720
 721 void
 722 libusb_free_transfer(struct libusb_transfer *uxfer)
 723 {
 724         struct libusb_super_transfer *sxfer;
 725
 726         if (uxfer == NULL)
 727                 return;                 /* be NULL safe */
 728
 729         sxfer = (struct libusb_super_transfer *)(
 730             (uint8_t *)uxfer - sizeof(*sxfer));
 731
 732         free(sxfer);
 733 }
 734
 735 static int
 736 libusb10_get_maxframe(struct libusb20_device *pdev, libusb_transfer *xfer)
 737 {
 738         int ret;
 739         int usb_speed;
 740
 741         usb_speed = libusb20_dev_get_speed(pdev);
 742
 743         switch (xfer->type) {
 744         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
 745                 switch (usb_speed) {
 746                 case LIBUSB20_SPEED_LOW:
 747                 case LIBUSB20_SPEED_FULL:
 748                         ret = 60 * 1;
 749                         break;
 750                 default:
 751                         ret = 60 * 8;
 752                         break;
 753                 }
 754                 break;
 755         case LIBUSB_TRANSFER_TYPE_CONTROL:
 756                 ret = 2;
 757                 break;
 758         default:
 759                 ret = 1;
 760                 break;
 761         }
 762         return (ret);
 763 }
 764
 765 static int
 766 libusb10_get_buffsize(struct libusb20_device *pdev, libusb_transfer *xfer)
 767 {
 768         int ret;
 769         int usb_speed;
 770
 771         usb_speed = libusb20_dev_get_speed(pdev);
 772
 773         switch (xfer->type) {
 774         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
 775                 ret = 0;                /* kernel will auto-select */
 776                 break;
 777         case LIBUSB_TRANSFER_TYPE_CONTROL:
 778                 ret = 1024;
 779                 break;
 780         default:
 781                 switch (usb_speed) {
 782                 case LIBUSB20_SPEED_LOW:
 783                         ret = 256;
 784                         break;
 785                 case LIBUSB20_SPEED_FULL:
 786                         ret = 4096;
 787                         break;
 788                 default:
 789                         ret = 16384;
 790                         break;
 791                 }
 792                 break;
 793         }
 794         return (ret);
 795 }
 796
 797 static int
 798 libusb10_convert_error(uint8_t status)
 799 {
 800         ;                               /* indent fix */
 801
 802         switch (status) {
 803         case LIBUSB20_TRANSFER_START:
 804         case LIBUSB20_TRANSFER_COMPLETED:
 805                 return (LIBUSB_TRANSFER_COMPLETED);
 806         case LIBUSB20_TRANSFER_OVERFLOW:
 807                 return (LIBUSB_TRANSFER_OVERFLOW);
 808         case LIBUSB20_TRANSFER_NO_DEVICE:
 809                 return (LIBUSB_TRANSFER_NO_DEVICE);
 810         case LIBUSB20_TRANSFER_STALL:
 811                 return (LIBUSB_TRANSFER_STALL);
 812         case LIBUSB20_TRANSFER_CANCELLED:
 813                 return (LIBUSB_TRANSFER_CANCELLED);
 814         case LIBUSB20_TRANSFER_TIMED_OUT:
 815                 return (LIBUSB_TRANSFER_TIMED_OUT);
 816         default:
 817                 return (LIBUSB_TRANSFER_ERROR);
 818         }
 819 }
 820
 821 /* This function must be called locked */
 822
 823 static void
 824 libusb10_complete_transfer(struct libusb20_transfer *pxfer,
 825     struct libusb_super_transfer *sxfer, int status)
 826 {
 827         struct libusb_transfer *uxfer;
 828         struct libusb_device *dev;
 829
 830         uxfer = (struct libusb_transfer *)(
 831             ((uint8_t *)sxfer) + sizeof(*sxfer));
 832
 833         if (pxfer != NULL)
 834                 libusb20_tr_set_priv_sc1(pxfer, NULL);
 835
 836         uxfer->status = status;
 837
 838         dev = libusb_get_device(uxfer->dev_handle);
 839
 840         TAILQ_INSERT_TAIL(&dev->ctx->tr_done, sxfer, entry);
 841 }
 842
 843 /* This function must be called locked */
 844
 845 static void
 846 libusb10_isoc_proxy(struct libusb20_transfer *pxfer)
 847 {
 848         struct libusb_super_transfer *sxfer;
 849         struct libusb_transfer *uxfer;
 850         uint32_t actlen;
 851         uint16_t iso_packets;
 852         uint16_t i;
 853         uint8_t status;
 854         uint8_t flags;
 855
 856         status = libusb20_tr_get_status(pxfer);
 857         sxfer = libusb20_tr_get_priv_sc1(pxfer);
 858         actlen = libusb20_tr_get_actual_length(pxfer);
 859         iso_packets = libusb20_tr_get_max_frames(pxfer);
 860
 861         if (sxfer == NULL)
 862                 return;                 /* cancelled - nothing to do */
 863
 864         uxfer = (struct libusb_transfer *)(
 865             ((uint8_t *)sxfer) + sizeof(*sxfer));
 866
 867         if (iso_packets > uxfer->num_iso_packets)
 868                 iso_packets = uxfer->num_iso_packets;
 869
 870         if (iso_packets == 0)
 871                 return;                 /* nothing to do */
 872
 873         /* make sure that the number of ISOCHRONOUS packets is valid */
 874         uxfer->num_iso_packets = iso_packets;
 875
 876         flags = uxfer->flags;
 877
 878         switch (status) {
 879         case LIBUSB20_TRANSFER_COMPLETED:
 880
 881                 /* update actual length */
 882                 uxfer->actual_length = actlen;
 883                 for (i = 0; i != iso_packets; i++) {
 884                         uxfer->iso_packet_desc[i].actual_length =
 885                             libusb20_tr_get_length(pxfer, i);
 886                 }
 887                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
 888                 break;
 889
 890         case LIBUSB20_TRANSFER_START:
 891
 892                 /* setup length(s) */
 893                 actlen = 0;
 894                 for (i = 0; i != iso_packets; i++) {
 895                         libusb20_tr_setup_isoc(pxfer,
 896                             &uxfer->buffer[actlen],
 897                             uxfer->iso_packet_desc[i].length, i);
 898                         actlen += uxfer->iso_packet_desc[i].length;
 899                 }
 900
 901                 /* no remainder */
 902                 sxfer->rem_len = 0;
 903
 904                 libusb20_tr_set_total_frames(pxfer, iso_packets);
 905                 libusb20_tr_submit(pxfer);
 906
 907                 /* fork another USB transfer, if any */
 908                 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
 909                 break;
 910
 911         default:
 912                 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
 913                 break;
 914         }
 915 }
 916
 917 /* This function must be called locked */
 918
 919 static void
 920 libusb10_bulk_intr_proxy(struct libusb20_transfer *pxfer)
 921 {
 922         struct libusb_super_transfer *sxfer;
 923         struct libusb_transfer *uxfer;
 924         uint32_t max_bulk;
 925         uint32_t actlen;
 926         uint8_t status;
 927         uint8_t flags;
 928
 929         status = libusb20_tr_get_status(pxfer);
 930         sxfer = libusb20_tr_get_priv_sc1(pxfer);
 931         max_bulk = libusb20_tr_get_max_total_length(pxfer);
 932         actlen = libusb20_tr_get_actual_length(pxfer);
 933
 934         if (sxfer == NULL)
 935                 return;                 /* cancelled - nothing to do */
 936
 937         uxfer = (struct libusb_transfer *)(
 938             ((uint8_t *)sxfer) + sizeof(*sxfer));
 939
 940         flags = uxfer->flags;
 941
 942         switch (status) {
 943         case LIBUSB20_TRANSFER_COMPLETED:
 944
 945                 uxfer->actual_length += actlen;
 946
 947                 /* check for short packet */
 948                 if (sxfer->last_len != actlen) {
 949                         if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
 950                                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR);
 951                         } else {
 952                                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
 953                         }
 954                         break;
 955                 }
 956                 /* check for end of data */
 957                 if (sxfer->rem_len == 0) {
 958                         libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
 959                         break;
 960                 }
 961                 /* FALLTHROUGH */
 962
 963         case LIBUSB20_TRANSFER_START:
 964                 if (max_bulk > sxfer->rem_len) {
 965                         max_bulk = sxfer->rem_len;
 966                 }
 967                 /* setup new BULK or INTERRUPT transaction */
 968                 libusb20_tr_setup_bulk(pxfer,
 969                     sxfer->curr_data, max_bulk, uxfer->timeout);
 970
 971                 /* update counters */
 972                 sxfer->last_len = max_bulk;
 973                 sxfer->curr_data += max_bulk;
 974                 sxfer->rem_len -= max_bulk;
 975
 976                 libusb20_tr_submit(pxfer);
 977
 978                 /* check if we can fork another USB transfer */
 979                 if (sxfer->rem_len == 0)
 980                         libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
 981                 break;
 982
 983         default:
 984                 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
 985                 break;
 986         }
 987 }
 988
 989 /* This function must be called locked */
 990
 991 static void
 992 libusb10_ctrl_proxy(struct libusb20_transfer *pxfer)
 993 {
 994         struct libusb_super_transfer *sxfer;
 995         struct libusb_transfer *uxfer;
 996         uint32_t max_bulk;
 997         uint32_t actlen;
 998         uint8_t status;
 999         uint8_t flags;
1000
1001         status = libusb20_tr_get_status(pxfer);
1002         sxfer = libusb20_tr_get_priv_sc1(pxfer);
1003         max_bulk = libusb20_tr_get_max_total_length(pxfer);
1004         actlen = libusb20_tr_get_actual_length(pxfer);
1005
1006         if (sxfer == NULL)
1007                 return;                 /* cancelled - nothing to do */
1008
1009         uxfer = (struct libusb_transfer *)(
1010             ((uint8_t *)sxfer) + sizeof(*sxfer));
1011
1012         flags = uxfer->flags;
1013
1014         switch (status) {
1015         case LIBUSB20_TRANSFER_COMPLETED:
1016
1017                 uxfer->actual_length += actlen;
1018
1019                 /* subtract length of SETUP packet, if any */
1020                 actlen -= libusb20_tr_get_length(pxfer, 0);
1021
1022                 /* check for short packet */
1023                 if (sxfer->last_len != actlen) {
1024                         if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
1025                                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR);
1026                         } else {
1027                                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1028                         }
1029                         break;
1030                 }
1031                 /* check for end of data */
1032                 if (sxfer->rem_len == 0) {
1033                         libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1034                         break;
1035                 }
1036                 /* FALLTHROUGH */
1037
1038         case LIBUSB20_TRANSFER_START:
1039                 if (max_bulk > sxfer->rem_len) {
1040                         max_bulk = sxfer->rem_len;
1041                 }
1042                 /* setup new CONTROL transaction */
1043                 if (status == LIBUSB20_TRANSFER_COMPLETED) {
1044                         /* next fragment - don't send SETUP packet */
1045                         libusb20_tr_set_length(pxfer, 0, 0);
1046                 } else {
1047                         /* first fragment - send SETUP packet */
1048                         libusb20_tr_set_length(pxfer, 8, 0);
1049                         libusb20_tr_set_buffer(pxfer, uxfer->buffer, 0);
1050                 }
1051
1052                 if (max_bulk != 0) {
1053                         libusb20_tr_set_length(pxfer, max_bulk, 1);
1054                         libusb20_tr_set_buffer(pxfer, sxfer->curr_data, 1);
1055                         libusb20_tr_set_total_frames(pxfer, 2);
1056                 } else {
1057                         libusb20_tr_set_total_frames(pxfer, 1);
1058                 }
1059
1060                 /* update counters */
1061                 sxfer->last_len = max_bulk;
1062                 sxfer->curr_data += max_bulk;
1063                 sxfer->rem_len -= max_bulk;
1064
1065                 libusb20_tr_submit(pxfer);
1066
1067                 /* check if we can fork another USB transfer */
1068                 if (sxfer->rem_len == 0)
1069                         libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1070                 break;
1071
1072         default:
1073                 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1074                 break;
1075         }
1076 }
1077
1078 /* The following function must be called locked */
1079
1080 static void
1081 libusb10_submit_transfer_sub(struct libusb20_device *pdev, uint8_t endpoint)
1082 {
1083         struct libusb20_transfer *pxfer0;
1084         struct libusb20_transfer *pxfer1;
1085         struct libusb_super_transfer *sxfer;
1086         struct libusb_transfer *uxfer;
1087         struct libusb_device *dev;
1088         int err;
1089         int buffsize;
1090         int maxframe;
1091         int temp;
1092         uint8_t dummy;
1093
1094         dev = libusb_get_device(pdev);
1095
1096         pxfer0 = libusb10_get_transfer(pdev, endpoint, 0);
1097         pxfer1 = libusb10_get_transfer(pdev, endpoint, 1);
1098
1099         if (pxfer0 == NULL || pxfer1 == NULL)
1100                 return;                 /* shouldn't happen */
1101
1102         temp = 0;
1103         if (libusb20_tr_pending(pxfer0))
1104                 temp |= 1;
1105         if (libusb20_tr_pending(pxfer1))
1106                 temp |= 2;
1107
1108         switch (temp) {
1109         case 3:
1110                 /* wait till one of the transfers complete */
1111                 return;
1112         case 2:
1113                 sxfer = libusb20_tr_get_priv_sc1(pxfer1);
1114                 if (sxfer->rem_len)
1115                         return;         /* cannot queue another one */
1116                 /* swap transfers */
1117                 pxfer1 = pxfer0;
1118                 break;
1119         case 1:
1120                 sxfer = libusb20_tr_get_priv_sc1(pxfer0);
1121                 if (sxfer->rem_len)
1122                         return;         /* cannot queue another one */
1123                 /* swap transfers */
1124                 pxfer0 = pxfer1;
1125                 break;
1126         default:
1127                 break;
1128         }
1129
1130         /* find next transfer on same endpoint */
1131         TAILQ_FOREACH(sxfer, &dev->tr_head, entry) {
1132
1133                 uxfer = (struct libusb_transfer *)(
1134                     ((uint8_t *)sxfer) + sizeof(*sxfer));
1135
1136                 if (uxfer->endpoint == endpoint) {
1137                         TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1138                         sxfer->entry.tqe_prev = NULL;
1139                         goto found;
1140                 }
1141         }
1142         return;                         /* success */
1143
1144 found:
1145
1146         libusb20_tr_set_priv_sc0(pxfer0, pdev);
1147         libusb20_tr_set_priv_sc1(pxfer0, sxfer);
1148
1149         /* reset super transfer state */
1150         sxfer->rem_len = uxfer->length;
1151         sxfer->curr_data = uxfer->buffer;
1152         uxfer->actual_length = 0;
1153
1154         switch (uxfer->type) {
1155         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1156                 libusb20_tr_set_callback(pxfer0, libusb10_isoc_proxy);
1157                 break;
1158         case LIBUSB_TRANSFER_TYPE_BULK:
1159         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1160                 libusb20_tr_set_callback(pxfer0, libusb10_bulk_intr_proxy);
1161                 break;
1162         case LIBUSB_TRANSFER_TYPE_CONTROL:
1163                 libusb20_tr_set_callback(pxfer0, libusb10_ctrl_proxy);
1164                 if (sxfer->rem_len < 8)
1165                         goto failure;
1166
1167                 /* remove SETUP packet from data */
1168                 sxfer->rem_len -= 8;
1169                 sxfer->curr_data += 8;
1170                 break;
1171         default:
1172                 goto failure;
1173         }
1174
1175         buffsize = libusb10_get_buffsize(pdev, uxfer);
1176         maxframe = libusb10_get_maxframe(pdev, uxfer);
1177
1178         /* make sure the transfer is opened */
1179         err = libusb20_tr_open(pxfer0, buffsize, maxframe, endpoint);
1180         if (err && (err != LIBUSB20_ERROR_BUSY)) {
1181                 goto failure;
1182         }
1183         libusb20_tr_start(pxfer0);
1184         return;
1185
1186 failure:
1187         libusb10_complete_transfer(pxfer0, sxfer, LIBUSB_TRANSFER_ERROR);
1188
1189         /* make sure our event loop spins the done handler */
1190         dummy = 0;
1191         write(dev->ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
1192 }
1193
1194 /* The following function must be called unlocked */
1195
1196 int
1197 libusb_submit_transfer(struct libusb_transfer *uxfer)
1198 {
1199         struct libusb20_transfer *pxfer0;
1200         struct libusb20_transfer *pxfer1;
1201         struct libusb_super_transfer *sxfer;
1202         struct libusb_device *dev;
1203         uint32_t endpoint;
1204         int err;
1205
1206         if (uxfer == NULL)
1207                 return (LIBUSB_ERROR_INVALID_PARAM);
1208
1209         if (uxfer->dev_handle == NULL)
1210                 return (LIBUSB_ERROR_INVALID_PARAM);
1211
1212         endpoint = uxfer->endpoint;
1213
1214         if (endpoint > 255)
1215                 return (LIBUSB_ERROR_INVALID_PARAM);
1216
1217         dev = libusb_get_device(uxfer->dev_handle);
1218
1219         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer enter");
1220
1221         sxfer = (struct libusb_super_transfer *)(
1222             (uint8_t *)uxfer - sizeof(*sxfer));
1223
1224         CTX_LOCK(dev->ctx);
1225
1226         pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0);
1227         pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1);
1228
1229         if (pxfer0 == NULL || pxfer1 == NULL) {
1230                 err = LIBUSB_ERROR_OTHER;
1231         } else if ((sxfer->entry.tqe_prev != NULL) ||
1232                     (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) ||
1233             (libusb20_tr_get_priv_sc1(pxfer1) == sxfer)) {
1234                 err = LIBUSB_ERROR_BUSY;
1235         } else {
1236                 TAILQ_INSERT_TAIL(&dev->tr_head, sxfer, entry);
1237
1238                 libusb10_submit_transfer_sub(
1239                     uxfer->dev_handle, endpoint);
1240
1241                 err = 0;                /* success */
1242         }
1243
1244         CTX_UNLOCK(dev->ctx);
1245
1246         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer leave %d", err);
1247
1248         return (err);
1249 }
1250
1251 /* Asynchronous transfer cancel */
1252
1253 int
1254 libusb_cancel_transfer(struct libusb_transfer *uxfer)
1255 {
1256         struct libusb20_transfer *pxfer0;
1257         struct libusb20_transfer *pxfer1;
1258         struct libusb_super_transfer *sxfer;
1259         struct libusb_device *dev;
1260         uint32_t endpoint;
1261
1262         if (uxfer == NULL)
1263                 return (LIBUSB_ERROR_INVALID_PARAM);
1264
1265         if (uxfer->dev_handle == NULL)
1266                 return (LIBUSB_ERROR_INVALID_PARAM);
1267
1268         endpoint = uxfer->endpoint;
1269
1270         if (endpoint > 255)
1271                 return (LIBUSB_ERROR_INVALID_PARAM);
1272
1273         dev = libusb_get_device(uxfer->dev_handle);
1274
1275         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer enter");
1276
1277         sxfer = (struct libusb_super_transfer *)(
1278             (uint8_t *)uxfer - sizeof(*sxfer));
1279
1280         CTX_LOCK(dev->ctx);
1281
1282         pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0);
1283         pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1);
1284
1285         if (sxfer->entry.tqe_prev != NULL) {
1286                 /* we are lucky - transfer is on a queue */
1287                 TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1288                 sxfer->entry.tqe_prev = NULL;
1289                 libusb10_complete_transfer(NULL, sxfer, LIBUSB_TRANSFER_CANCELLED);
1290         } else if (pxfer0 == NULL || pxfer1 == NULL) {
1291                 /* not started */
1292         } else if (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) {
1293                 libusb10_complete_transfer(pxfer0, sxfer, LIBUSB_TRANSFER_CANCELLED);
1294                 libusb20_tr_stop(pxfer0);
1295                 /* make sure the queue doesn't stall */
1296                 libusb10_submit_transfer_sub(
1297                     uxfer->dev_handle, endpoint);
1298         } else if (libusb20_tr_get_priv_sc1(pxfer1) == sxfer) {
1299                 libusb10_complete_transfer(pxfer1, sxfer, LIBUSB_TRANSFER_CANCELLED);
1300                 libusb20_tr_stop(pxfer1);
1301                 /* make sure the queue doesn't stall */
1302                 libusb10_submit_transfer_sub(
1303                     uxfer->dev_handle, endpoint);
1304         } else {
1305                 /* not started */
1306         }
1307
1308         CTX_UNLOCK(dev->ctx);
1309
1310         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer leave");
1311
1312         return (0);
1313 }
1314
1315 UNEXPORTED void
1316 libusb10_cancel_all_transfer(libusb_device *dev)
1317 {
1318         /* TODO */
1319 }
1320
1321 uint16_t
1322 libusb_cpu_to_le16(uint16_t x)
1323 {
1324         return (htole16(x));
1325 }
1326
1327 uint16_t
1328 libusb_le16_to_cpu(uint16_t x)
1329 {
1330         return (le16toh(x));
1331 }
1332