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