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         sxfer = (struct libusb_super_transfer *)(
 804             (uint8_t *)uxfer - sizeof(*sxfer));
 805
 806         free(sxfer);
 807 }
 808
 809 static int
 810 libusb10_get_maxframe(struct libusb20_device *pdev, libusb_transfer *xfer)
 811 {
 812         int ret;
 813         int usb_speed;
 814
 815         usb_speed = libusb20_dev_get_speed(pdev);
 816
 817         switch (xfer->type) {
 818         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
 819                 switch (usb_speed) {
 820                 case LIBUSB20_SPEED_LOW:
 821                 case LIBUSB20_SPEED_FULL:
 822                         ret = 60 * 1;
 823                         break;
 824                 default:
 825                         ret = 60 * 8;
 826                         break;
 827                 }
 828                 break;
 829         case LIBUSB_TRANSFER_TYPE_CONTROL:
 830                 ret = 2;
 831                 break;
 832         default:
 833                 ret = 1;
 834                 break;
 835         }
 836         return (ret);
 837 }
 838
 839 static int
 840 libusb10_get_buffsize(struct libusb20_device *pdev, libusb_transfer *xfer)
 841 {
 842         int ret;
 843         int usb_speed;
 844
 845         usb_speed = libusb20_dev_get_speed(pdev);
 846
 847         switch (xfer->type) {
 848         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
 849                 ret = 0;                /* kernel will auto-select */
 850                 break;
 851         case LIBUSB_TRANSFER_TYPE_CONTROL:
 852                 ret = 1024;
 853                 break;
 854         default:
 855                 switch (usb_speed) {
 856                 case LIBUSB20_SPEED_LOW:
 857                         ret = 256;
 858                         break;
 859                 case LIBUSB20_SPEED_FULL:
 860                         ret = 4096;
 861                         break;
 862                 default:
 863                         ret = 16384;
 864                         break;
 865                 }
 866                 break;
 867         }
 868         return (ret);
 869 }
 870
 871 static int
 872 libusb10_convert_error(uint8_t status)
 873 {
 874         ;                               /* indent fix */
 875
 876         switch (status) {
 877         case LIBUSB20_TRANSFER_START:
 878         case LIBUSB20_TRANSFER_COMPLETED:
 879                 return (LIBUSB_TRANSFER_COMPLETED);
 880         case LIBUSB20_TRANSFER_OVERFLOW:
 881                 return (LIBUSB_TRANSFER_OVERFLOW);
 882         case LIBUSB20_TRANSFER_NO_DEVICE:
 883                 return (LIBUSB_TRANSFER_NO_DEVICE);
 884         case LIBUSB20_TRANSFER_STALL:
 885                 return (LIBUSB_TRANSFER_STALL);
 886         case LIBUSB20_TRANSFER_CANCELLED:
 887                 return (LIBUSB_TRANSFER_CANCELLED);
 888         case LIBUSB20_TRANSFER_TIMED_OUT:
 889                 return (LIBUSB_TRANSFER_TIMED_OUT);
 890         default:
 891                 return (LIBUSB_TRANSFER_ERROR);
 892         }
 893 }
 894
 895 /* This function must be called locked */
 896
 897 static void
 898 libusb10_complete_transfer(struct libusb20_transfer *pxfer,
 899     struct libusb_super_transfer *sxfer, int status)
 900 {
 901         struct libusb_transfer *uxfer;
 902         struct libusb_device *dev;
 903
 904         uxfer = (struct libusb_transfer *)(
 905             ((uint8_t *)sxfer) + sizeof(*sxfer));
 906
 907         if (pxfer != NULL)
 908                 libusb20_tr_set_priv_sc1(pxfer, NULL);
 909
 910         /* set transfer status */
 911         uxfer->status = status;
 912
 913         /* update super transfer state */
 914         sxfer->state = LIBUSB_SUPER_XFER_ST_NONE;
 915
 916         dev = libusb_get_device(uxfer->dev_handle);
 917
 918         TAILQ_INSERT_TAIL(&dev->ctx->tr_done, sxfer, entry);
 919 }
 920
 921 /* This function must be called locked */
 922
 923 static void
 924 libusb10_isoc_proxy(struct libusb20_transfer *pxfer)
 925 {
 926         struct libusb_super_transfer *sxfer;
 927         struct libusb_transfer *uxfer;
 928         uint32_t actlen;
 929         uint16_t iso_packets;
 930         uint16_t i;
 931         uint8_t status;
 932         uint8_t flags;
 933
 934         status = libusb20_tr_get_status(pxfer);
 935         sxfer = libusb20_tr_get_priv_sc1(pxfer);
 936         actlen = libusb20_tr_get_actual_length(pxfer);
 937         iso_packets = libusb20_tr_get_max_frames(pxfer);
 938
 939         if (sxfer == NULL)
 940                 return;                 /* cancelled - nothing to do */
 941
 942         uxfer = (struct libusb_transfer *)(
 943             ((uint8_t *)sxfer) + sizeof(*sxfer));
 944
 945         if (iso_packets > uxfer->num_iso_packets)
 946                 iso_packets = uxfer->num_iso_packets;
 947
 948         if (iso_packets == 0)
 949                 return;                 /* nothing to do */
 950
 951         /* make sure that the number of ISOCHRONOUS packets is valid */
 952         uxfer->num_iso_packets = iso_packets;
 953
 954         flags = uxfer->flags;
 955
 956         switch (status) {
 957         case LIBUSB20_TRANSFER_COMPLETED:
 958
 959                 /* update actual length */
 960                 uxfer->actual_length = actlen;
 961                 for (i = 0; i != iso_packets; i++) {
 962                         uxfer->iso_packet_desc[i].actual_length =
 963                             libusb20_tr_get_length(pxfer, i);
 964                 }
 965                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
 966                 break;
 967
 968         case LIBUSB20_TRANSFER_START:
 969
 970                 /* setup length(s) */
 971                 actlen = 0;
 972                 for (i = 0; i != iso_packets; i++) {
 973                         libusb20_tr_setup_isoc(pxfer,
 974                             &uxfer->buffer[actlen],
 975                             uxfer->iso_packet_desc[i].length, i);
 976                         actlen += uxfer->iso_packet_desc[i].length;
 977                 }
 978
 979                 /* no remainder */
 980                 sxfer->rem_len = 0;
 981
 982                 libusb20_tr_set_total_frames(pxfer, iso_packets);
 983                 libusb20_tr_submit(pxfer);
 984
 985                 /* fork another USB transfer, if any */
 986                 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
 987                 break;
 988
 989         default:
 990                 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
 991                 break;
 992         }
 993 }
 994
 995 /* This function must be called locked */
 996
 997 static void
 998 libusb10_bulk_intr_proxy(struct libusb20_transfer *pxfer)
 999 {
1000         struct libusb_super_transfer *sxfer;
1001         struct libusb_transfer *uxfer;
1002         uint32_t max_bulk;
1003         uint32_t actlen;
1004         uint8_t status;
1005         uint8_t flags;
1006
1007         status = libusb20_tr_get_status(pxfer);
1008         sxfer = libusb20_tr_get_priv_sc1(pxfer);
1009         max_bulk = libusb20_tr_get_max_total_length(pxfer);
1010         actlen = libusb20_tr_get_actual_length(pxfer);
1011
1012         if (sxfer == NULL)
1013                 return;                 /* cancelled - nothing to do */
1014
1015         uxfer = (struct libusb_transfer *)(
1016             ((uint8_t *)sxfer) + sizeof(*sxfer));
1017
1018         flags = uxfer->flags;
1019
1020         switch (status) {
1021         case LIBUSB20_TRANSFER_COMPLETED:
1022
1023                 uxfer->actual_length += actlen;
1024
1025                 /* check for short packet */
1026                 if (sxfer->last_len != actlen) {
1027                         if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
1028                                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR);
1029                         } else {
1030                                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1031                         }
1032                         break;
1033                 }
1034                 /* check for end of data */
1035                 if (sxfer->rem_len == 0) {
1036                         libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1037                         break;
1038                 }
1039                 /* FALLTHROUGH */
1040
1041         case LIBUSB20_TRANSFER_START:
1042                 if (max_bulk > sxfer->rem_len) {
1043                         max_bulk = sxfer->rem_len;
1044                 }
1045                 /* setup new BULK or INTERRUPT transaction */
1046                 libusb20_tr_setup_bulk(pxfer,
1047                     sxfer->curr_data, max_bulk, uxfer->timeout);
1048
1049                 /* update counters */
1050                 sxfer->last_len = max_bulk;
1051                 sxfer->curr_data += max_bulk;
1052                 sxfer->rem_len -= max_bulk;
1053
1054                 libusb20_tr_submit(pxfer);
1055
1056                 /* check if we can fork another USB transfer */
1057                 if (sxfer->rem_len == 0)
1058                         libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1059                 break;
1060
1061         default:
1062                 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1063                 break;
1064         }
1065 }
1066
1067 /* This function must be called locked */
1068
1069 static void
1070 libusb10_ctrl_proxy(struct libusb20_transfer *pxfer)
1071 {
1072         struct libusb_super_transfer *sxfer;
1073         struct libusb_transfer *uxfer;
1074         uint32_t max_bulk;
1075         uint32_t actlen;
1076         uint8_t status;
1077         uint8_t flags;
1078
1079         status = libusb20_tr_get_status(pxfer);
1080         sxfer = libusb20_tr_get_priv_sc1(pxfer);
1081         max_bulk = libusb20_tr_get_max_total_length(pxfer);
1082         actlen = libusb20_tr_get_actual_length(pxfer);
1083
1084         if (sxfer == NULL)
1085                 return;                 /* cancelled - nothing to do */
1086
1087         uxfer = (struct libusb_transfer *)(
1088             ((uint8_t *)sxfer) + sizeof(*sxfer));
1089
1090         flags = uxfer->flags;
1091
1092         switch (status) {
1093         case LIBUSB20_TRANSFER_COMPLETED:
1094
1095                 uxfer->actual_length += actlen;
1096
1097                 /* subtract length of SETUP packet, if any */
1098                 actlen -= libusb20_tr_get_length(pxfer, 0);
1099
1100                 /* check for short packet */
1101                 if (sxfer->last_len != actlen) {
1102                         if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
1103                                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR);
1104                         } else {
1105                                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1106                         }
1107                         break;
1108                 }
1109                 /* check for end of data */
1110                 if (sxfer->rem_len == 0) {
1111                         libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1112                         break;
1113                 }
1114                 /* FALLTHROUGH */
1115
1116         case LIBUSB20_TRANSFER_START:
1117                 if (max_bulk > sxfer->rem_len) {
1118                         max_bulk = sxfer->rem_len;
1119                 }
1120                 /* setup new CONTROL transaction */
1121                 if (status == LIBUSB20_TRANSFER_COMPLETED) {
1122                         /* next fragment - don't send SETUP packet */
1123                         libusb20_tr_set_length(pxfer, 0, 0);
1124                 } else {
1125                         /* first fragment - send SETUP packet */
1126                         libusb20_tr_set_length(pxfer, 8, 0);
1127                         libusb20_tr_set_buffer(pxfer, uxfer->buffer, 0);
1128                 }
1129
1130                 if (max_bulk != 0) {
1131                         libusb20_tr_set_length(pxfer, max_bulk, 1);
1132                         libusb20_tr_set_buffer(pxfer, sxfer->curr_data, 1);
1133                         libusb20_tr_set_total_frames(pxfer, 2);
1134                 } else {
1135                         libusb20_tr_set_total_frames(pxfer, 1);
1136                 }
1137
1138                 /* update counters */
1139                 sxfer->last_len = max_bulk;
1140                 sxfer->curr_data += max_bulk;
1141                 sxfer->rem_len -= max_bulk;
1142
1143                 libusb20_tr_submit(pxfer);
1144
1145                 /* check if we can fork another USB transfer */
1146                 if (sxfer->rem_len == 0)
1147                         libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1148                 break;
1149
1150         default:
1151                 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1152                 break;
1153         }
1154 }
1155
1156 /* The following function must be called locked */
1157
1158 static void
1159 libusb10_submit_transfer_sub(struct libusb20_device *pdev, uint8_t endpoint)
1160 {
1161         struct libusb20_transfer *pxfer0;
1162         struct libusb20_transfer *pxfer1;
1163         struct libusb_super_transfer *sxfer;
1164         struct libusb_transfer *uxfer;
1165         struct libusb_device *dev;
1166         int err;
1167         int buffsize;
1168         int maxframe;
1169         int temp;
1170         uint8_t dummy;
1171
1172         dev = libusb_get_device(pdev);
1173
1174         pxfer0 = libusb10_get_transfer(pdev, endpoint, 0);
1175         pxfer1 = libusb10_get_transfer(pdev, endpoint, 1);
1176
1177         if (pxfer0 == NULL || pxfer1 == NULL)
1178                 return;                 /* shouldn't happen */
1179
1180         temp = 0;
1181         if (libusb20_tr_pending(pxfer0))
1182                 temp |= 1;
1183         if (libusb20_tr_pending(pxfer1))
1184                 temp |= 2;
1185
1186         switch (temp) {
1187         case 3:
1188                 /* wait till one of the transfers complete */
1189                 return;
1190         case 2:
1191                 sxfer = libusb20_tr_get_priv_sc1(pxfer1);
1192                 if (sxfer == NULL)
1193                         return;         /* cancelling */
1194                 if (sxfer->rem_len)
1195                         return;         /* cannot queue another one */
1196                 /* swap transfers */
1197                 pxfer1 = pxfer0;
1198                 break;
1199         case 1:
1200                 sxfer = libusb20_tr_get_priv_sc1(pxfer0);
1201                 if (sxfer == NULL)
1202                         return;         /* cancelling */
1203                 if (sxfer->rem_len)
1204                         return;         /* cannot queue another one */
1205                 /* swap transfers */
1206                 pxfer0 = pxfer1;
1207                 break;
1208         default:
1209                 break;
1210         }
1211
1212         /* find next transfer on same endpoint */
1213         TAILQ_FOREACH(sxfer, &dev->tr_head, entry) {
1214
1215                 uxfer = (struct libusb_transfer *)(
1216                     ((uint8_t *)sxfer) + sizeof(*sxfer));
1217
1218                 if (uxfer->endpoint == endpoint) {
1219                         TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1220                         sxfer->entry.tqe_prev = NULL;
1221                         goto found;
1222                 }
1223         }
1224         return;                         /* success */
1225
1226 found:
1227
1228         libusb20_tr_set_priv_sc0(pxfer0, pdev);
1229         libusb20_tr_set_priv_sc1(pxfer0, sxfer);
1230
1231         /* reset super transfer state */
1232         sxfer->rem_len = uxfer->length;
1233         sxfer->curr_data = uxfer->buffer;
1234         uxfer->actual_length = 0;
1235
1236         switch (uxfer->type) {
1237         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1238                 libusb20_tr_set_callback(pxfer0, libusb10_isoc_proxy);
1239                 break;
1240         case LIBUSB_TRANSFER_TYPE_BULK:
1241         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1242                 libusb20_tr_set_callback(pxfer0, libusb10_bulk_intr_proxy);
1243                 break;
1244         case LIBUSB_TRANSFER_TYPE_CONTROL:
1245                 libusb20_tr_set_callback(pxfer0, libusb10_ctrl_proxy);
1246                 if (sxfer->rem_len < 8)
1247                         goto failure;
1248
1249                 /* remove SETUP packet from data */
1250                 sxfer->rem_len -= 8;
1251                 sxfer->curr_data += 8;
1252                 break;
1253         default:
1254                 goto failure;
1255         }
1256
1257         buffsize = libusb10_get_buffsize(pdev, uxfer);
1258         maxframe = libusb10_get_maxframe(pdev, uxfer);
1259
1260         /* make sure the transfer is opened */
1261         err = libusb20_tr_open(pxfer0, buffsize, maxframe, endpoint);
1262         if (err && (err != LIBUSB20_ERROR_BUSY)) {
1263                 goto failure;
1264         }
1265         libusb20_tr_start(pxfer0);
1266         return;
1267
1268 failure:
1269         libusb10_complete_transfer(pxfer0, sxfer, LIBUSB_TRANSFER_ERROR);
1270
1271         /* make sure our event loop spins the done handler */
1272         dummy = 0;
1273         write(dev->ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
1274 }
1275
1276 /* The following function must be called unlocked */
1277
1278 int
1279 libusb_submit_transfer(struct libusb_transfer *uxfer)
1280 {
1281         struct libusb20_transfer *pxfer0;
1282         struct libusb20_transfer *pxfer1;
1283         struct libusb_super_transfer *sxfer;
1284         struct libusb_device *dev;
1285         uint32_t endpoint;
1286         int err;
1287
1288         if (uxfer == NULL)
1289                 return (LIBUSB_ERROR_INVALID_PARAM);
1290
1291         if (uxfer->dev_handle == NULL)
1292                 return (LIBUSB_ERROR_INVALID_PARAM);
1293
1294         endpoint = uxfer->endpoint;
1295
1296         if (endpoint > 255)
1297                 return (LIBUSB_ERROR_INVALID_PARAM);
1298
1299         dev = libusb_get_device(uxfer->dev_handle);
1300
1301         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer enter");
1302
1303         sxfer = (struct libusb_super_transfer *)(
1304             (uint8_t *)uxfer - sizeof(*sxfer));
1305
1306         CTX_LOCK(dev->ctx);
1307
1308         pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0);
1309         pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1);
1310
1311         if (pxfer0 == NULL || pxfer1 == NULL) {
1312                 err = LIBUSB_ERROR_OTHER;
1313         } else if ((sxfer->entry.tqe_prev != NULL) ||
1314             (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) ||
1315             (libusb20_tr_get_priv_sc1(pxfer1) == sxfer)) {
1316                 err = LIBUSB_ERROR_BUSY;
1317         } else {
1318
1319                 /* set pending state */
1320                 sxfer->state = LIBUSB_SUPER_XFER_ST_PEND;
1321
1322                 /* insert transfer into transfer head list */
1323                 TAILQ_INSERT_TAIL(&dev->tr_head, sxfer, entry);
1324
1325                 /* start work transfers */
1326                 libusb10_submit_transfer_sub(
1327                     uxfer->dev_handle, endpoint);
1328
1329                 err = 0;                /* success */
1330         }
1331
1332         CTX_UNLOCK(dev->ctx);
1333
1334         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer leave %d", err);
1335
1336         return (err);
1337 }
1338
1339 /* Asynchronous transfer cancel */
1340
1341 int
1342 libusb_cancel_transfer(struct libusb_transfer *uxfer)
1343 {
1344         struct libusb20_transfer *pxfer0;
1345         struct libusb20_transfer *pxfer1;
1346         struct libusb_super_transfer *sxfer;
1347         struct libusb_device *dev;
1348         uint32_t endpoint;
1349         int retval;
1350
1351         if (uxfer == NULL)
1352                 return (LIBUSB_ERROR_INVALID_PARAM);
1353
1354         /* check if not initialised */
1355         if (uxfer->dev_handle == NULL)
1356                 return (LIBUSB_ERROR_NOT_FOUND);
1357
1358         endpoint = uxfer->endpoint;
1359
1360         if (endpoint > 255)
1361                 return (LIBUSB_ERROR_INVALID_PARAM);
1362
1363         dev = libusb_get_device(uxfer->dev_handle);
1364
1365         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer enter");
1366
1367         sxfer = (struct libusb_super_transfer *)(
1368             (uint8_t *)uxfer - sizeof(*sxfer));
1369
1370         retval = 0;
1371
1372         CTX_LOCK(dev->ctx);
1373
1374         pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0);
1375         pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1);
1376
1377         if (sxfer->state != LIBUSB_SUPER_XFER_ST_PEND) {
1378                 /* only update the transfer status */
1379                 uxfer->status = LIBUSB_TRANSFER_CANCELLED;
1380                 retval = LIBUSB_ERROR_NOT_FOUND;
1381         } else if (sxfer->entry.tqe_prev != NULL) {
1382                 /* we are lucky - transfer is on a queue */
1383                 TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1384                 sxfer->entry.tqe_prev = NULL;
1385                 libusb10_complete_transfer(NULL,
1386                     sxfer, LIBUSB_TRANSFER_CANCELLED);
1387         } else if (pxfer0 == NULL || pxfer1 == NULL) {
1388                 /* not started */
1389                 retval = LIBUSB_ERROR_NOT_FOUND;
1390         } else if (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) {
1391                 libusb10_complete_transfer(pxfer0,
1392                     sxfer, LIBUSB_TRANSFER_CANCELLED);
1393                 libusb20_tr_stop(pxfer0);
1394                 /* make sure the queue doesn't stall */
1395                 libusb10_submit_transfer_sub(
1396                     uxfer->dev_handle, endpoint);
1397         } else if (libusb20_tr_get_priv_sc1(pxfer1) == sxfer) {
1398                 libusb10_complete_transfer(pxfer1,
1399                     sxfer, LIBUSB_TRANSFER_CANCELLED);
1400                 libusb20_tr_stop(pxfer1);
1401                 /* make sure the queue doesn't stall */
1402                 libusb10_submit_transfer_sub(
1403                     uxfer->dev_handle, endpoint);
1404         } else {
1405                 /* not started */
1406                 retval = LIBUSB_ERROR_NOT_FOUND;
1407         }
1408
1409         CTX_UNLOCK(dev->ctx);
1410
1411         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer leave");
1412
1413         return (retval);
1414 }
1415
1416 UNEXPORTED void
1417 libusb10_cancel_all_transfer(libusb_device *dev)
1418 {
1419         /* TODO */
1420 }
1421
1422 uint16_t
1423 libusb_cpu_to_le16(uint16_t x)
1424 {
1425         return (htole16(x));
1426 }
1427
1428 uint16_t
1429 libusb_le16_to_cpu(uint16_t x)
1430 {
1431         return (le16toh(x));
1432 }
1433
1434 const char *
1435 libusb_strerror(int code)
1436 {
1437         /* TODO */
1438         return ("Unknown error");
1439 }