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