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