lib/libusb/libusb10.c

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