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