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 #define LIBUSB_NUM_SW_ENDPOINTS (16 * 4)
  49
  50 static pthread_mutex_t default_context_lock = PTHREAD_MUTEX_INITIALIZER;
  51 struct libusb_context *usbi_default_context = NULL;
  52
  53 /* Prototypes */
  54
  55 static struct libusb20_transfer *libusb10_get_transfer(struct libusb20_device *, uint8_t, uint8_t);
  56 static int libusb10_get_buffsize(struct libusb20_device *, libusb_transfer *);
  57 static int libusb10_convert_error(uint8_t status);
  58 static void libusb10_complete_transfer(struct libusb20_transfer *, struct libusb_super_transfer *, int);
  59 static void libusb10_isoc_proxy(struct libusb20_transfer *);
  60 static void libusb10_bulk_intr_proxy(struct libusb20_transfer *);
  61 static void libusb10_ctrl_proxy(struct libusb20_transfer *);
  62 static void libusb10_submit_transfer_sub(struct libusb20_device *, uint8_t);
  63
  64 /*  Library initialisation / deinitialisation */
  65
  66 static const struct libusb_version libusb_version = {
  67         .major = 1,
  68         .minor = 0,
  69         .micro = 0,
  70         .nano = 2016,
  71         .rc = "",
  72         .describe = "http://www.freebsd.org"
  73 };
  74
  75 const struct libusb_version *
  76 libusb_get_version(void)
  77 {
  78
  79         return (&libusb_version);
  80 }
  81
  82 void
  83 libusb_set_debug(libusb_context *ctx, int level)
  84 {
  85         ctx = GET_CONTEXT(ctx);
  86         if (ctx)
  87                 ctx->debug = level;
  88 }
  89
  90 static void
  91 libusb_set_nonblocking(int f)
  92 {
  93         int flags;
  94
  95         /*
  96          * We ignore any failures in this function, hence the
  97          * non-blocking flag is not critical to the operation of
  98          * libUSB. We use F_GETFL and F_SETFL to be compatible with
  99          * Linux.
 100          */
 101
 102         flags = fcntl(f, F_GETFL, NULL);
 103         if (flags == -1)
 104                 return;
 105         flags |= O_NONBLOCK;
 106         fcntl(f, F_SETFL, flags);
 107 }
 108
 109 static void
 110 libusb10_wakeup_event_loop(libusb_context *ctx)
 111 {
 112         uint8_t dummy = 0;
 113         int err;
 114
 115         err = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
 116         if (err < (int)sizeof(dummy)) {
 117                 /* ignore error, if any */
 118                 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "Waking up event loop failed!");
 119         }
 120 }
 121
 122 int
 123 libusb_init(libusb_context **context)
 124 {
 125         struct libusb_context *ctx;
 126         pthread_condattr_t attr;
 127         char *debug;
 128         int ret;
 129
 130         ctx = malloc(sizeof(*ctx));
 131         if (!ctx)
 132                 return (LIBUSB_ERROR_INVALID_PARAM);
 133
 134         memset(ctx, 0, sizeof(*ctx));
 135
 136         debug = getenv("LIBUSB_DEBUG");
 137         if (debug != NULL) {
 138                 ctx->debug = atoi(debug);
 139                 if (ctx->debug != 0)
 140                         ctx->debug_fixed = 1;
 141         }
 142         TAILQ_INIT(&ctx->pollfds);
 143         TAILQ_INIT(&ctx->tr_done);
 144         TAILQ_INIT(&ctx->hotplug_cbh);
 145         TAILQ_INIT(&ctx->hotplug_devs);
 146
 147         if (pthread_mutex_init(&ctx->ctx_lock, NULL) != 0) {
 148                 free(ctx);
 149                 return (LIBUSB_ERROR_NO_MEM);
 150         }
 151         if (pthread_mutex_init(&ctx->hotplug_lock, NULL) != 0) {
 152                 pthread_mutex_destroy(&ctx->ctx_lock);
 153                 free(ctx);
 154                 return (LIBUSB_ERROR_NO_MEM);
 155         }
 156         if (pthread_condattr_init(&attr) != 0) {
 157                 pthread_mutex_destroy(&ctx->ctx_lock);
 158                 pthread_mutex_destroy(&ctx->hotplug_lock);
 159                 free(ctx);
 160                 return (LIBUSB_ERROR_NO_MEM);
 161         }
 162         if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) != 0) {
 163                 pthread_mutex_destroy(&ctx->ctx_lock);
 164                 pthread_mutex_destroy(&ctx->hotplug_lock);
 165                 pthread_condattr_destroy(&attr);
 166                 free(ctx);
 167                 return (LIBUSB_ERROR_OTHER);
 168         }
 169         if (pthread_cond_init(&ctx->ctx_cond, &attr) != 0) {
 170                 pthread_mutex_destroy(&ctx->ctx_lock);
 171                 pthread_mutex_destroy(&ctx->hotplug_lock);
 172                 pthread_condattr_destroy(&attr);
 173                 free(ctx);
 174                 return (LIBUSB_ERROR_NO_MEM);
 175         }
 176         pthread_condattr_destroy(&attr);
 177
 178         ctx->ctx_handler = NO_THREAD;
 179         ctx->hotplug_handler = NO_THREAD;
 180
 181         ret = pipe(ctx->ctrl_pipe);
 182         if (ret < 0) {
 183                 pthread_mutex_destroy(&ctx->ctx_lock);
 184                 pthread_mutex_destroy(&ctx->hotplug_lock);
 185                 pthread_cond_destroy(&ctx->ctx_cond);
 186                 free(ctx);
 187                 return (LIBUSB_ERROR_OTHER);
 188         }
 189         /* set non-blocking mode on the control pipe to avoid deadlock */
 190         libusb_set_nonblocking(ctx->ctrl_pipe[0]);
 191         libusb_set_nonblocking(ctx->ctrl_pipe[1]);
 192
 193         libusb10_add_pollfd(ctx, &ctx->ctx_poll, NULL, ctx->ctrl_pipe[0], POLLIN);
 194
 195         pthread_mutex_lock(&default_context_lock);
 196         if (usbi_default_context == NULL) {
 197                 usbi_default_context = ctx;
 198         }
 199         pthread_mutex_unlock(&default_context_lock);
 200
 201         if (context)
 202                 *context = ctx;
 203
 204         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_init complete");
 205
 206         return (0);
 207 }
 208
 209 void
 210 libusb_exit(libusb_context *ctx)
 211 {
 212         ctx = GET_CONTEXT(ctx);
 213
 214         if (ctx == NULL)
 215                 return;
 216
 217         /* stop hotplug thread, if any */
 218
 219         if (ctx->hotplug_handler != NO_THREAD) {
 220                 pthread_t td;
 221                 void *ptr;
 222
 223                 HOTPLUG_LOCK(ctx);
 224                 td = ctx->hotplug_handler;
 225                 ctx->hotplug_handler = NO_THREAD;
 226                 HOTPLUG_UNLOCK(ctx);
 227
 228                 pthread_join(td, &ptr);
 229         }
 230
 231         /* XXX cleanup devices */
 232
 233         libusb10_remove_pollfd(ctx, &ctx->ctx_poll);
 234         close(ctx->ctrl_pipe[0]);
 235         close(ctx->ctrl_pipe[1]);
 236         pthread_mutex_destroy(&ctx->ctx_lock);
 237         pthread_mutex_destroy(&ctx->hotplug_lock);
 238         pthread_cond_destroy(&ctx->ctx_cond);
 239
 240         pthread_mutex_lock(&default_context_lock);
 241         if (ctx == usbi_default_context) {
 242                 usbi_default_context = NULL;
 243         }
 244         pthread_mutex_unlock(&default_context_lock);
 245
 246         free(ctx);
 247 }
 248
 249 /* Device handling and initialisation. */
 250
 251 ssize_t
 252 libusb_get_device_list(libusb_context *ctx, libusb_device ***list)
 253 {
 254         struct libusb20_backend *usb_backend;
 255         struct libusb20_device *pdev;
 256         struct libusb_device *dev;
 257         int i;
 258
 259         ctx = GET_CONTEXT(ctx);
 260
 261         if (ctx == NULL)
 262                 return (LIBUSB_ERROR_INVALID_PARAM);
 263
 264         if (list == NULL)
 265                 return (LIBUSB_ERROR_INVALID_PARAM);
 266
 267         usb_backend = libusb20_be_alloc_default();
 268         if (usb_backend == NULL)
 269                 return (LIBUSB_ERROR_NO_MEM);
 270
 271         /* figure out how many USB devices are present */
 272         pdev = NULL;
 273         i = 0;
 274         while ((pdev = libusb20_be_device_foreach(usb_backend, pdev)))
 275                 i++;
 276
 277         /* allocate device pointer list */
 278         *list = malloc((i + 1) * sizeof(void *));
 279         if (*list == NULL) {
 280                 libusb20_be_free(usb_backend);
 281                 return (LIBUSB_ERROR_NO_MEM);
 282         }
 283         /* create libusb v1.0 compliant devices */
 284         i = 0;
 285         while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) {
 286
 287                 dev = malloc(sizeof(*dev));
 288                 if (dev == NULL) {
 289                         while (i != 0) {
 290                                 libusb_unref_device((*list)[i - 1]);
 291                                 i--;
 292                         }
 293                         free(*list);
 294                         *list = NULL;
 295                         libusb20_be_free(usb_backend);
 296                         return (LIBUSB_ERROR_NO_MEM);
 297                 }
 298                 /* get device into libUSB v1.0 list */
 299                 libusb20_be_dequeue_device(usb_backend, pdev);
 300
 301                 memset(dev, 0, sizeof(*dev));
 302
 303                 /* init transfer queues */
 304                 TAILQ_INIT(&dev->tr_head);
 305
 306                 /* set context we belong to */
 307                 dev->ctx = ctx;
 308
 309                 /* link together the two structures */
 310                 dev->os_priv = pdev;
 311                 pdev->privLuData = dev;
 312
 313                 (*list)[i] = libusb_ref_device(dev);
 314                 i++;
 315         }
 316         (*list)[i] = NULL;
 317
 318         libusb20_be_free(usb_backend);
 319         return (i);
 320 }
 321
 322 void
 323 libusb_free_device_list(libusb_device **list, int unref_devices)
 324 {
 325         int i;
 326
 327         if (list == NULL)
 328                 return;                 /* be NULL safe */
 329
 330         if (unref_devices) {
 331                 for (i = 0; list[i] != NULL; i++)
 332                         libusb_unref_device(list[i]);
 333         }
 334         free(list);
 335 }
 336
 337 uint8_t
 338 libusb_get_bus_number(libusb_device *dev)
 339 {
 340         if (dev == NULL)
 341                 return (0);             /* should not happen */
 342         return (libusb20_dev_get_bus_number(dev->os_priv));
 343 }
 344
 345 uint8_t
 346 libusb_get_port_number(libusb_device *dev)
 347 {
 348         if (dev == NULL)
 349                 return (0);             /* should not happen */
 350         return (libusb20_dev_get_parent_port(dev->os_priv));
 351 }
 352
 353 int
 354 libusb_get_port_numbers(libusb_device *dev, uint8_t *buf, uint8_t bufsize)
 355 {
 356         return (libusb20_dev_get_port_path(dev->os_priv, buf, bufsize));
 357 }
 358
 359 int
 360 libusb_get_port_path(libusb_context *ctx, libusb_device *dev, uint8_t *buf,
 361     uint8_t bufsize)
 362 {
 363         return (libusb20_dev_get_port_path(dev->os_priv, buf, bufsize));
 364 }
 365
 366 uint8_t
 367 libusb_get_device_address(libusb_device *dev)
 368 {
 369         if (dev == NULL)
 370                 return (0);             /* should not happen */
 371         return (libusb20_dev_get_address(dev->os_priv));
 372 }
 373
 374 enum libusb_speed
 375 libusb_get_device_speed(libusb_device *dev)
 376 {
 377         if (dev == NULL)
 378                 return (LIBUSB_SPEED_UNKNOWN);  /* should not happen */
 379
 380         switch (libusb20_dev_get_speed(dev->os_priv)) {
 381         case LIBUSB20_SPEED_LOW:
 382                 return (LIBUSB_SPEED_LOW);
 383         case LIBUSB20_SPEED_FULL:
 384                 return (LIBUSB_SPEED_FULL);
 385         case LIBUSB20_SPEED_HIGH:
 386                 return (LIBUSB_SPEED_HIGH);
 387         case LIBUSB20_SPEED_SUPER:
 388                 return (LIBUSB_SPEED_SUPER);
 389         default:
 390                 break;
 391         }
 392         return (LIBUSB_SPEED_UNKNOWN);
 393 }
 394
 395 int
 396 libusb_get_max_packet_size(libusb_device *dev, uint8_t endpoint)
 397 {
 398         struct libusb_config_descriptor *pdconf;
 399         struct libusb_interface *pinf;
 400         struct libusb_interface_descriptor *pdinf;
 401         struct libusb_endpoint_descriptor *pdend;
 402         int i;
 403         int j;
 404         int k;
 405         int ret;
 406
 407         if (dev == NULL)
 408                 return (LIBUSB_ERROR_NO_DEVICE);
 409
 410         ret = libusb_get_active_config_descriptor(dev, &pdconf);
 411         if (ret < 0)
 412                 return (ret);
 413
 414         ret = LIBUSB_ERROR_NOT_FOUND;
 415         for (i = 0; i < pdconf->bNumInterfaces; i++) {
 416                 pinf = &pdconf->interface[i];
 417                 for (j = 0; j < pinf->num_altsetting; j++) {
 418                         pdinf = &pinf->altsetting[j];
 419                         for (k = 0; k < pdinf->bNumEndpoints; k++) {
 420                                 pdend = &pdinf->endpoint[k];
 421                                 if (pdend->bEndpointAddress == endpoint) {
 422                                         ret = pdend->wMaxPacketSize;
 423                                         goto out;
 424                                 }
 425                         }
 426                 }
 427         }
 428
 429 out:
 430         libusb_free_config_descriptor(pdconf);
 431         return (ret);
 432 }
 433
 434 int
 435 libusb_get_max_iso_packet_size(libusb_device *dev, uint8_t endpoint)
 436 {
 437         int multiplier;
 438         int ret;
 439
 440         ret = libusb_get_max_packet_size(dev, endpoint);
 441
 442         switch (libusb20_dev_get_speed(dev->os_priv)) {
 443         case LIBUSB20_SPEED_LOW:
 444         case LIBUSB20_SPEED_FULL:
 445                 break;
 446         default:
 447                 if (ret > -1) {
 448                         multiplier = (1 + ((ret >> 11) & 3));
 449                         if (multiplier > 3)
 450                                 multiplier = 3;
 451                         ret = (ret & 0x7FF) * multiplier;
 452                 }
 453                 break;
 454         }
 455         return (ret);
 456 }
 457
 458 libusb_device *
 459 libusb_ref_device(libusb_device *dev)
 460 {
 461         if (dev == NULL)
 462                 return (NULL);          /* be NULL safe */
 463
 464         CTX_LOCK(dev->ctx);
 465         dev->refcnt++;
 466         CTX_UNLOCK(dev->ctx);
 467
 468         return (dev);
 469 }
 470
 471 void
 472 libusb_unref_device(libusb_device *dev)
 473 {
 474         if (dev == NULL)
 475                 return;                 /* be NULL safe */
 476
 477         CTX_LOCK(dev->ctx);
 478         dev->refcnt--;
 479         CTX_UNLOCK(dev->ctx);
 480
 481         if (dev->refcnt == 0) {
 482                 libusb20_dev_free(dev->os_priv);
 483                 free(dev);
 484         }
 485 }
 486
 487 int
 488 libusb_open(libusb_device *dev, libusb_device_handle **devh)
 489 {
 490         libusb_context *ctx = dev->ctx;
 491         struct libusb20_device *pdev = dev->os_priv;
 492         int err;
 493
 494         if (devh == NULL)
 495                 return (LIBUSB_ERROR_INVALID_PARAM);
 496
 497         /* set default device handle value */
 498         *devh = NULL;
 499
 500         dev = libusb_ref_device(dev);
 501         if (dev == NULL)
 502                 return (LIBUSB_ERROR_INVALID_PARAM);
 503
 504         err = libusb20_dev_open(pdev, LIBUSB_NUM_SW_ENDPOINTS);
 505         if (err) {
 506                 libusb_unref_device(dev);
 507                 return (LIBUSB_ERROR_NO_MEM);
 508         }
 509         libusb10_add_pollfd(ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN |
 510             POLLOUT | POLLRDNORM | POLLWRNORM);
 511
 512         /* make sure our event loop detects the new device */
 513         libusb10_wakeup_event_loop(ctx);
 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
 568         if (pdev == NULL)
 569                 return;                 /* be NULL safe */
 570
 571         dev = libusb_get_device(pdev);
 572         ctx = dev->ctx;
 573
 574         libusb10_remove_pollfd(ctx, &dev->dev_poll);
 575
 576         libusb20_dev_close(pdev);
 577
 578         /* unref will free the "pdev" when the refcount reaches zero */
 579         libusb_unref_device(dev);
 580
 581         /* make sure our event loop detects the closed device */
 582         libusb10_wakeup_event_loop(ctx);
 583 }
 584
 585 libusb_device *
 586 libusb_get_device(struct libusb20_device *pdev)
 587 {
 588         if (pdev == NULL)
 589                 return (NULL);
 590         return ((libusb_device *)pdev->privLuData);
 591 }
 592
 593 int
 594 libusb_get_configuration(struct libusb20_device *pdev, int *config)
 595 {
 596         struct libusb20_config *pconf;
 597
 598         if (pdev == NULL || config == NULL)
 599                 return (LIBUSB_ERROR_INVALID_PARAM);
 600
 601         pconf = libusb20_dev_alloc_config(pdev, libusb20_dev_get_config_index(pdev));
 602         if (pconf == NULL)
 603                 return (LIBUSB_ERROR_NO_MEM);
 604
 605         *config = pconf->desc.bConfigurationValue;
 606
 607         free(pconf);
 608
 609         return (0);
 610 }
 611
 612 int
 613 libusb_set_configuration(struct libusb20_device *pdev, int configuration)
 614 {
 615         struct libusb20_config *pconf;
 616         struct libusb_device *dev;
 617         int err;
 618         uint8_t i;
 619
 620         dev = libusb_get_device(pdev);
 621         if (dev == NULL)
 622                 return (LIBUSB_ERROR_INVALID_PARAM);
 623
 624         if (configuration < 1) {
 625                 /* unconfigure */
 626                 i = 255;
 627         } else {
 628                 for (i = 0; i != 255; i++) {
 629                         uint8_t found;
 630
 631                         pconf = libusb20_dev_alloc_config(pdev, i);
 632                         if (pconf == NULL)
 633                                 return (LIBUSB_ERROR_INVALID_PARAM);
 634                         found = (pconf->desc.bConfigurationValue
 635                             == configuration);
 636                         free(pconf);
 637
 638                         if (found)
 639                                 goto set_config;
 640                 }
 641                 return (LIBUSB_ERROR_INVALID_PARAM);
 642         }
 643
 644 set_config:
 645
 646         libusb10_cancel_all_transfer(dev);
 647
 648         libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
 649
 650         err = libusb20_dev_set_config_index(pdev, i);
 651
 652         libusb10_add_pollfd(dev->ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN |
 653             POLLOUT | POLLRDNORM | POLLWRNORM);
 654
 655         return (err ? LIBUSB_ERROR_INVALID_PARAM : 0);
 656 }
 657
 658 int
 659 libusb_claim_interface(struct libusb20_device *pdev, int interface_number)
 660 {
 661         libusb_device *dev;
 662         int err = 0;
 663
 664         dev = libusb_get_device(pdev);
 665         if (dev == NULL)
 666                 return (LIBUSB_ERROR_INVALID_PARAM);
 667
 668         if (interface_number < 0 || interface_number > 31)
 669                 return (LIBUSB_ERROR_INVALID_PARAM);
 670
 671         if (pdev->auto_detach != 0) {
 672                 err = libusb_detach_kernel_driver(pdev, interface_number);
 673                 if (err != 0)
 674                         goto done;
 675         }
 676
 677         CTX_LOCK(dev->ctx);
 678         dev->claimed_interfaces |= (1 << interface_number);
 679         CTX_UNLOCK(dev->ctx);
 680 done:
 681         return (err);
 682 }
 683
 684 int
 685 libusb_release_interface(struct libusb20_device *pdev, int interface_number)
 686 {
 687         libusb_device *dev;
 688         int err = 0;
 689
 690         dev = libusb_get_device(pdev);
 691         if (dev == NULL)
 692                 return (LIBUSB_ERROR_INVALID_PARAM);
 693
 694         if (interface_number < 0 || interface_number > 31)
 695                 return (LIBUSB_ERROR_INVALID_PARAM);
 696
 697         if (pdev->auto_detach != 0) {
 698                 err = libusb_attach_kernel_driver(pdev, interface_number);
 699                 if (err != 0)
 700                         goto done;
 701         }
 702
 703         CTX_LOCK(dev->ctx);
 704         if (!(dev->claimed_interfaces & (1 << interface_number)))
 705                 err = LIBUSB_ERROR_NOT_FOUND;
 706         else
 707                 dev->claimed_interfaces &= ~(1 << interface_number);
 708         CTX_UNLOCK(dev->ctx);
 709 done:
 710         return (err);
 711 }
 712
 713 int
 714 libusb_set_interface_alt_setting(struct libusb20_device *pdev,
 715     int interface_number, int alternate_setting)
 716 {
 717         libusb_device *dev;
 718         int err = 0;
 719
 720         dev = libusb_get_device(pdev);
 721         if (dev == NULL)
 722                 return (LIBUSB_ERROR_INVALID_PARAM);
 723
 724         if (interface_number < 0 || interface_number > 31)
 725                 return (LIBUSB_ERROR_INVALID_PARAM);
 726
 727         CTX_LOCK(dev->ctx);
 728         if (!(dev->claimed_interfaces & (1 << interface_number)))
 729                 err = LIBUSB_ERROR_NOT_FOUND;
 730         CTX_UNLOCK(dev->ctx);
 731
 732         if (err)
 733                 return (err);
 734
 735         libusb10_cancel_all_transfer(dev);
 736
 737         libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
 738
 739         err = libusb20_dev_set_alt_index(pdev,
 740             interface_number, alternate_setting);
 741
 742         libusb10_add_pollfd(dev->ctx, &dev->dev_poll,
 743             pdev, libusb20_dev_get_fd(pdev),
 744             POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
 745
 746         return (err ? LIBUSB_ERROR_OTHER : 0);
 747 }
 748
 749 static struct libusb20_transfer *
 750 libusb10_get_transfer(struct libusb20_device *pdev,
 751     uint8_t endpoint, uint8_t xfer_index)
 752 {
 753         xfer_index &= 1;        /* double buffering */
 754
 755         xfer_index |= (endpoint & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 4;
 756
 757         if (endpoint & LIBUSB20_ENDPOINT_DIR_MASK) {
 758                 /* this is an IN endpoint */
 759                 xfer_index |= 2;
 760         }
 761         return (libusb20_tr_get_pointer(pdev, xfer_index));
 762 }
 763
 764 int
 765 libusb_clear_halt(struct libusb20_device *pdev, uint8_t endpoint)
 766 {
 767         struct libusb20_transfer *xfer;
 768         struct libusb_device *dev;
 769         int err;
 770
 771         xfer = libusb10_get_transfer(pdev, endpoint, 0);
 772         if (xfer == NULL)
 773                 return (LIBUSB_ERROR_INVALID_PARAM);
 774
 775         dev = libusb_get_device(pdev);
 776         if (dev == NULL)
 777                 return (LIBUSB_ERROR_INVALID_PARAM);
 778
 779         CTX_LOCK(dev->ctx);
 780         err = libusb20_tr_open(xfer, 0, 1, endpoint);
 781         CTX_UNLOCK(dev->ctx);
 782
 783         if (err != 0 && err != LIBUSB20_ERROR_BUSY)
 784                 return (LIBUSB_ERROR_OTHER);
 785
 786         libusb20_tr_clear_stall_sync(xfer);
 787
 788         /* check if we opened the transfer */
 789         if (err == 0) {
 790                 CTX_LOCK(dev->ctx);
 791                 libusb20_tr_close(xfer);
 792                 CTX_UNLOCK(dev->ctx);
 793         }
 794         return (0);                     /* success */
 795 }
 796
 797 int
 798 libusb_reset_device(struct libusb20_device *pdev)
 799 {
 800         libusb_device *dev;
 801         int err;
 802
 803         dev = libusb_get_device(pdev);
 804         if (dev == NULL)
 805                 return (LIBUSB_ERROR_INVALID_PARAM);
 806
 807         libusb10_cancel_all_transfer(dev);
 808
 809         libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
 810
 811         err = libusb20_dev_reset(pdev);
 812
 813         libusb10_add_pollfd(dev->ctx, &dev->dev_poll,
 814             pdev, libusb20_dev_get_fd(pdev),
 815             POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
 816
 817         return (err ? LIBUSB_ERROR_OTHER : 0);
 818 }
 819
 820 int
 821 libusb_check_connected(struct libusb20_device *pdev)
 822 {
 823         libusb_device *dev;
 824         int err;
 825
 826         dev = libusb_get_device(pdev);
 827         if (dev == NULL)
 828                 return (LIBUSB_ERROR_INVALID_PARAM);
 829
 830         err = libusb20_dev_check_connected(pdev);
 831
 832         return (err ? LIBUSB_ERROR_NO_DEVICE : 0);
 833 }
 834
 835 int
 836 libusb_kernel_driver_active(struct libusb20_device *pdev, int interface)
 837 {
 838         if (pdev == NULL)
 839                 return (LIBUSB_ERROR_INVALID_PARAM);
 840
 841         if (libusb20_dev_kernel_driver_active(pdev, interface))
 842                 return (0);             /* no kernel driver is active */
 843         else
 844                 return (1);             /* kernel driver is active */
 845 }
 846
 847 int
 848 libusb_get_driver_np(struct libusb20_device *pdev, int interface,
 849     char *name, int namelen)
 850 {
 851         return (libusb_get_driver(pdev, interface, name, namelen));
 852 }
 853
 854 int
 855 libusb_get_driver(struct libusb20_device *pdev, int interface,
 856     char *name, int namelen)
 857 {
 858         char *ptr;
 859         int err;
 860
 861         if (pdev == NULL)
 862                 return (LIBUSB_ERROR_INVALID_PARAM);
 863         if (namelen < 1)
 864                 return (LIBUSB_ERROR_INVALID_PARAM);
 865         if (namelen > 255)
 866                 namelen = 255;
 867
 868         err = libusb20_dev_get_iface_desc(
 869             pdev, interface, name, namelen);
 870
 871         if (err != 0)
 872                 return (LIBUSB_ERROR_OTHER);
 873
 874         /* we only want the driver name */
 875         ptr = strstr(name, ":");
 876         if (ptr != NULL)
 877                 *ptr = 0;
 878
 879         return (0);
 880 }
 881
 882 int
 883 libusb_detach_kernel_driver_np(struct libusb20_device *pdev, int interface)
 884 {
 885         return (libusb_detach_kernel_driver(pdev, interface));
 886 }
 887
 888 int
 889 libusb_detach_kernel_driver(struct libusb20_device *pdev, int interface)
 890 {
 891         int err;
 892
 893         if (pdev == NULL)
 894                 return (LIBUSB_ERROR_INVALID_PARAM);
 895
 896         err = libusb20_dev_detach_kernel_driver(
 897             pdev, interface);
 898
 899         return (err ? LIBUSB_ERROR_OTHER : 0);
 900 }
 901
 902 int
 903 libusb_attach_kernel_driver(struct libusb20_device *pdev, int interface)
 904 {
 905         if (pdev == NULL)
 906                 return (LIBUSB_ERROR_INVALID_PARAM);
 907         /* stub - currently not supported by libusb20 */
 908         return (0);
 909 }
 910
 911 int
 912 libusb_set_auto_detach_kernel_driver(libusb_device_handle *dev, int enable)
 913 {
 914         dev->auto_detach = (enable ? 1 : 0);
 915         return (0);
 916 }
 917
 918 /* Asynchronous device I/O */
 919
 920 struct libusb_transfer *
 921 libusb_alloc_transfer(int iso_packets)
 922 {
 923         struct libusb_transfer *uxfer;
 924         struct libusb_super_transfer *sxfer;
 925         int len;
 926
 927         len = sizeof(struct libusb_transfer) +
 928             sizeof(struct libusb_super_transfer) +
 929             (iso_packets * sizeof(libusb_iso_packet_descriptor));
 930
 931         sxfer = malloc(len);
 932         if (sxfer == NULL)
 933                 return (NULL);
 934
 935         memset(sxfer, 0, len);
 936
 937         uxfer = (struct libusb_transfer *)(
 938             ((uint8_t *)sxfer) + sizeof(*sxfer));
 939
 940         /* set default value */
 941         uxfer->num_iso_packets = iso_packets;
 942
 943         return (uxfer);
 944 }
 945
 946 void
 947 libusb_free_transfer(struct libusb_transfer *uxfer)
 948 {
 949         struct libusb_super_transfer *sxfer;
 950
 951         if (uxfer == NULL)
 952                 return;                 /* be NULL safe */
 953
 954         /* check if we should free the transfer buffer */
 955         if (uxfer->flags & LIBUSB_TRANSFER_FREE_BUFFER)
 956                 free(uxfer->buffer);
 957
 958         sxfer = (struct libusb_super_transfer *)(
 959             (uint8_t *)uxfer - sizeof(*sxfer));
 960
 961         free(sxfer);
 962 }
 963
 964 static uint32_t
 965 libusb10_get_maxframe(struct libusb20_device *pdev, libusb_transfer *xfer)
 966 {
 967         uint32_t ret;
 968
 969         switch (xfer->type) {
 970         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
 971                 ret = 60 | LIBUSB20_MAX_FRAME_PRE_SCALE;        /* 60ms */
 972                 break;
 973         case LIBUSB_TRANSFER_TYPE_CONTROL:
 974                 ret = 2;
 975                 break;
 976         default:
 977                 ret = 1;
 978                 break;
 979         }
 980         return (ret);
 981 }
 982
 983 static int
 984 libusb10_get_buffsize(struct libusb20_device *pdev, libusb_transfer *xfer)
 985 {
 986         int ret;
 987         int usb_speed;
 988
 989         usb_speed = libusb20_dev_get_speed(pdev);
 990
 991         switch (xfer->type) {
 992         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
 993                 ret = 0;                /* kernel will auto-select */
 994                 break;
 995         case LIBUSB_TRANSFER_TYPE_CONTROL:
 996                 ret = 1024;
 997                 break;
 998         default:
 999                 switch (usb_speed) {
1000                 case LIBUSB20_SPEED_LOW:
1001                         ret = 256;
1002                         break;
1003                 case LIBUSB20_SPEED_FULL:
1004                         ret = 4096;
1005                         break;
1006                 case LIBUSB20_SPEED_SUPER:
1007                         ret = 65536;
1008                         break;
1009                 default:
1010                         ret = 16384;
1011                         break;
1012                 }
1013                 break;
1014         }
1015         return (ret);
1016 }
1017
1018 static int
1019 libusb10_convert_error(uint8_t status)
1020 {
1021         ;                               /* indent fix */
1022
1023         switch (status) {
1024         case LIBUSB20_TRANSFER_START:
1025         case LIBUSB20_TRANSFER_COMPLETED:
1026                 return (LIBUSB_TRANSFER_COMPLETED);
1027         case LIBUSB20_TRANSFER_OVERFLOW:
1028                 return (LIBUSB_TRANSFER_OVERFLOW);
1029         case LIBUSB20_TRANSFER_NO_DEVICE:
1030                 return (LIBUSB_TRANSFER_NO_DEVICE);
1031         case LIBUSB20_TRANSFER_STALL:
1032                 return (LIBUSB_TRANSFER_STALL);
1033         case LIBUSB20_TRANSFER_CANCELLED:
1034                 return (LIBUSB_TRANSFER_CANCELLED);
1035         case LIBUSB20_TRANSFER_TIMED_OUT:
1036                 return (LIBUSB_TRANSFER_TIMED_OUT);
1037         default:
1038                 return (LIBUSB_TRANSFER_ERROR);
1039         }
1040 }
1041
1042 /* This function must be called locked */
1043
1044 static void
1045 libusb10_complete_transfer(struct libusb20_transfer *pxfer,
1046     struct libusb_super_transfer *sxfer, int status)
1047 {
1048         struct libusb_transfer *uxfer;
1049         struct libusb_device *dev;
1050
1051         uxfer = (struct libusb_transfer *)(
1052             ((uint8_t *)sxfer) + sizeof(*sxfer));
1053
1054         if (pxfer != NULL)
1055                 libusb20_tr_set_priv_sc1(pxfer, NULL);
1056
1057         /* set transfer status */
1058         uxfer->status = status;
1059
1060         /* update super transfer state */
1061         sxfer->state = LIBUSB_SUPER_XFER_ST_NONE;
1062
1063         dev = libusb_get_device(uxfer->dev_handle);
1064
1065         TAILQ_INSERT_TAIL(&dev->ctx->tr_done, sxfer, entry);
1066 }
1067
1068 /* This function must be called locked */
1069
1070 static void
1071 libusb10_isoc_proxy(struct libusb20_transfer *pxfer)
1072 {
1073         struct libusb_super_transfer *sxfer;
1074         struct libusb_transfer *uxfer;
1075         uint32_t actlen;
1076         uint16_t iso_packets;
1077         uint16_t i;
1078         uint8_t status;
1079         uint8_t flags;
1080
1081         status = libusb20_tr_get_status(pxfer);
1082         sxfer = libusb20_tr_get_priv_sc1(pxfer);
1083         actlen = libusb20_tr_get_actual_length(pxfer);
1084         iso_packets = libusb20_tr_get_max_frames(pxfer);
1085
1086         if (sxfer == NULL)
1087                 return;                 /* cancelled - nothing to do */
1088
1089         uxfer = (struct libusb_transfer *)(
1090             ((uint8_t *)sxfer) + sizeof(*sxfer));
1091
1092         if (iso_packets > uxfer->num_iso_packets)
1093                 iso_packets = uxfer->num_iso_packets;
1094
1095         if (iso_packets == 0)
1096                 return;                 /* nothing to do */
1097
1098         /* make sure that the number of ISOCHRONOUS packets is valid */
1099         uxfer->num_iso_packets = iso_packets;
1100
1101         flags = uxfer->flags;
1102
1103         switch (status) {
1104         case LIBUSB20_TRANSFER_COMPLETED:
1105
1106                 /* update actual length */
1107                 uxfer->actual_length = actlen;
1108                 for (i = 0; i != iso_packets; i++) {
1109                         uxfer->iso_packet_desc[i].actual_length =
1110                             libusb20_tr_get_length(pxfer, i);
1111                 }
1112                 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1113                 break;
1114
1115         case LIBUSB20_TRANSFER_START:
1116
1117                 /* setup length(s) */
1118                 actlen = 0;
1119                 for (i = 0; i != iso_packets; i++) {
1120                         libusb20_tr_setup_isoc(pxfer,
1121                             &uxfer->buffer[actlen],
1122                             uxfer->iso_packet_desc[i].length, i);
1123                         actlen += uxfer->iso_packet_desc[i].length;
1124                 }
1125
1126                 /* no remainder */
1127                 sxfer->rem_len = 0;
1128
1129                 libusb20_tr_set_total_frames(pxfer, iso_packets);
1130                 libusb20_tr_submit(pxfer);
1131
1132                 /* fork another USB transfer, if any */
1133                 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1134                 break;
1135
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
1318         dev = libusb_get_device(pdev);
1319
1320         pxfer0 = libusb10_get_transfer(pdev, endpoint, 0);
1321         pxfer1 = libusb10_get_transfer(pdev, endpoint, 1);
1322
1323         if (pxfer0 == NULL || pxfer1 == NULL)
1324                 return;                 /* shouldn't happen */
1325
1326         temp = 0;
1327         if (libusb20_tr_pending(pxfer0))
1328                 temp |= 1;
1329         if (libusb20_tr_pending(pxfer1))
1330                 temp |= 2;
1331
1332         switch (temp) {
1333         case 3:
1334                 /* wait till one of the transfers complete */
1335                 return;
1336         case 2:
1337                 sxfer = libusb20_tr_get_priv_sc1(pxfer1);
1338                 if (sxfer == NULL)
1339                         return;         /* cancelling */
1340                 if (sxfer->rem_len)
1341                         return;         /* cannot queue another one */
1342                 /* swap transfers */
1343                 pxfer1 = pxfer0;
1344                 break;
1345         case 1:
1346                 sxfer = libusb20_tr_get_priv_sc1(pxfer0);
1347                 if (sxfer == NULL)
1348                         return;         /* cancelling */
1349                 if (sxfer->rem_len)
1350                         return;         /* cannot queue another one */
1351                 /* swap transfers */
1352                 pxfer0 = pxfer1;
1353                 break;
1354         default:
1355                 break;
1356         }
1357
1358         /* find next transfer on same endpoint */
1359         TAILQ_FOREACH(sxfer, &dev->tr_head, entry) {
1360
1361                 uxfer = (struct libusb_transfer *)(
1362                     ((uint8_t *)sxfer) + sizeof(*sxfer));
1363
1364                 if (uxfer->endpoint == endpoint) {
1365                         TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1366                         sxfer->entry.tqe_prev = NULL;
1367                         goto found;
1368                 }
1369         }
1370         return;                         /* success */
1371
1372 found:
1373
1374         libusb20_tr_set_priv_sc0(pxfer0, pdev);
1375         libusb20_tr_set_priv_sc1(pxfer0, sxfer);
1376
1377         /* reset super transfer state */
1378         sxfer->rem_len = uxfer->length;
1379         sxfer->curr_data = uxfer->buffer;
1380         uxfer->actual_length = 0;
1381
1382         switch (uxfer->type) {
1383         case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1384                 libusb20_tr_set_callback(pxfer0, libusb10_isoc_proxy);
1385                 break;
1386         case LIBUSB_TRANSFER_TYPE_BULK:
1387         case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1388                 libusb20_tr_set_callback(pxfer0, libusb10_bulk_intr_proxy);
1389                 break;
1390         case LIBUSB_TRANSFER_TYPE_CONTROL:
1391                 libusb20_tr_set_callback(pxfer0, libusb10_ctrl_proxy);
1392                 if (sxfer->rem_len < 8)
1393                         goto failure;
1394
1395                 /* remove SETUP packet from data */
1396                 sxfer->rem_len -= 8;
1397                 sxfer->curr_data += 8;
1398                 break;
1399         default:
1400                 goto failure;
1401         }
1402
1403         buffsize = libusb10_get_buffsize(pdev, uxfer);
1404         maxframe = libusb10_get_maxframe(pdev, uxfer);
1405
1406         /* make sure the transfer is opened */
1407         err = libusb20_tr_open(pxfer0, buffsize, maxframe, endpoint);
1408         if (err && (err != LIBUSB20_ERROR_BUSY)) {
1409                 goto failure;
1410         }
1411         libusb20_tr_start(pxfer0);
1412         return;
1413
1414 failure:
1415         libusb10_complete_transfer(pxfer0, sxfer, LIBUSB_TRANSFER_ERROR);
1416         /* make sure our event loop spins the done handler */
1417         libusb10_wakeup_event_loop(dev->ctx);
1418 }
1419
1420 /* The following function must be called unlocked */
1421
1422 int
1423 libusb_submit_transfer(struct libusb_transfer *uxfer)
1424 {
1425         struct libusb20_transfer *pxfer0;
1426         struct libusb20_transfer *pxfer1;
1427         struct libusb_super_transfer *sxfer;
1428         struct libusb_device *dev;
1429         uint32_t endpoint;
1430         int err;
1431
1432         if (uxfer == NULL)
1433                 return (LIBUSB_ERROR_INVALID_PARAM);
1434
1435         if (uxfer->dev_handle == NULL)
1436                 return (LIBUSB_ERROR_INVALID_PARAM);
1437
1438         endpoint = uxfer->endpoint;
1439
1440         if (endpoint > 255)
1441                 return (LIBUSB_ERROR_INVALID_PARAM);
1442
1443         dev = libusb_get_device(uxfer->dev_handle);
1444
1445         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer enter");
1446
1447         sxfer = (struct libusb_super_transfer *)(
1448             (uint8_t *)uxfer - sizeof(*sxfer));
1449
1450         CTX_LOCK(dev->ctx);
1451
1452         pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0);
1453         pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1);
1454
1455         if (pxfer0 == NULL || pxfer1 == NULL) {
1456                 err = LIBUSB_ERROR_OTHER;
1457         } else if ((sxfer->entry.tqe_prev != NULL) ||
1458             (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) ||
1459             (libusb20_tr_get_priv_sc1(pxfer1) == sxfer)) {
1460                 err = LIBUSB_ERROR_BUSY;
1461         } else if (dev->device_is_gone != 0) {
1462                 err = LIBUSB_ERROR_NO_DEVICE;
1463         } else {
1464
1465                 /* set pending state */
1466                 sxfer->state = LIBUSB_SUPER_XFER_ST_PEND;
1467
1468                 /* insert transfer into transfer head list */
1469                 TAILQ_INSERT_TAIL(&dev->tr_head, sxfer, entry);
1470
1471                 /* start work transfers */
1472                 libusb10_submit_transfer_sub(
1473                     uxfer->dev_handle, endpoint);
1474
1475                 err = 0;                /* success */
1476         }
1477
1478         CTX_UNLOCK(dev->ctx);
1479
1480         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer leave %d", err);
1481
1482         return (err);
1483 }
1484
1485 /* Asynchronous transfer cancel */
1486
1487 int
1488 libusb_cancel_transfer(struct libusb_transfer *uxfer)
1489 {
1490         struct libusb20_transfer *pxfer0;
1491         struct libusb20_transfer *pxfer1;
1492         struct libusb_super_transfer *sxfer;
1493         struct libusb_device *dev;
1494         struct libusb_device_handle *devh;
1495         uint32_t endpoint;
1496         int retval;
1497
1498         if (uxfer == NULL)
1499                 return (LIBUSB_ERROR_INVALID_PARAM);
1500
1501         /* check if not initialised */
1502         if ((devh = uxfer->dev_handle) == NULL)
1503                 return (LIBUSB_ERROR_NOT_FOUND);
1504
1505         endpoint = uxfer->endpoint;
1506
1507         if (endpoint > 255)
1508                 return (LIBUSB_ERROR_INVALID_PARAM);
1509
1510         dev = libusb_get_device(devh);
1511
1512         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer enter");
1513
1514         sxfer = (struct libusb_super_transfer *)(
1515             (uint8_t *)uxfer - sizeof(*sxfer));
1516
1517         retval = 0;
1518
1519         CTX_LOCK(dev->ctx);
1520
1521         pxfer0 = libusb10_get_transfer(devh, endpoint, 0);
1522         pxfer1 = libusb10_get_transfer(devh, endpoint, 1);
1523
1524         if (sxfer->state != LIBUSB_SUPER_XFER_ST_PEND) {
1525                 /* only update the transfer status */
1526                 uxfer->status = LIBUSB_TRANSFER_CANCELLED;
1527                 retval = LIBUSB_ERROR_NOT_FOUND;
1528         } else if (sxfer->entry.tqe_prev != NULL) {
1529                 /* we are lucky - transfer is on a queue */
1530                 TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1531                 sxfer->entry.tqe_prev = NULL;
1532                 libusb10_complete_transfer(NULL,
1533                     sxfer, LIBUSB_TRANSFER_CANCELLED);
1534                 /* make sure our event loop spins the done handler */
1535                 libusb10_wakeup_event_loop(dev->ctx);
1536         } else if (pxfer0 == NULL || pxfer1 == NULL) {
1537                 /* not started */
1538                 retval = LIBUSB_ERROR_NOT_FOUND;
1539         } else if (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) {
1540                 libusb10_complete_transfer(pxfer0,
1541                     sxfer, LIBUSB_TRANSFER_CANCELLED);
1542                 if (dev->device_is_gone != 0) {
1543                         /* clear transfer pointer */
1544                         libusb20_tr_set_priv_sc1(pxfer0, NULL);
1545                         /* make sure our event loop spins the done handler */
1546                         libusb10_wakeup_event_loop(dev->ctx);
1547                 } else {
1548                         libusb20_tr_stop(pxfer0);
1549                         /* make sure the queue doesn't stall */
1550                         libusb10_submit_transfer_sub(devh, endpoint);
1551                 }
1552         } else if (libusb20_tr_get_priv_sc1(pxfer1) == sxfer) {
1553                 libusb10_complete_transfer(pxfer1,
1554                     sxfer, LIBUSB_TRANSFER_CANCELLED);
1555                 /* check if handle is still active */
1556                 if (dev->device_is_gone != 0) {
1557                         /* clear transfer pointer */
1558                         libusb20_tr_set_priv_sc1(pxfer1, NULL);
1559                         /* make sure our event loop spins the done handler */
1560                         libusb10_wakeup_event_loop(dev->ctx);
1561                 } else {
1562                         libusb20_tr_stop(pxfer1);
1563                         /* make sure the queue doesn't stall */
1564                         libusb10_submit_transfer_sub(devh, endpoint);
1565                 }
1566         } else {
1567                 /* not started */
1568                 retval = LIBUSB_ERROR_NOT_FOUND;
1569         }
1570
1571         CTX_UNLOCK(dev->ctx);
1572
1573         DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer leave");
1574
1575         return (retval);
1576 }
1577
1578 UNEXPORTED void
1579 libusb10_cancel_all_transfer(libusb_device *dev)
1580 {
1581         struct libusb20_device *pdev = dev->os_priv;
1582         unsigned x;
1583
1584         for (x = 0; x != LIBUSB_NUM_SW_ENDPOINTS; x++) {
1585                 struct libusb20_transfer *xfer;
1586
1587                 xfer = libusb20_tr_get_pointer(pdev, x);
1588                 if (xfer == NULL)
1589                         continue;
1590                 libusb20_tr_close(xfer);
1591         }
1592 }
1593
1594 UNEXPORTED void
1595 libusb10_cancel_all_transfer_locked(struct libusb20_device *pdev, struct libusb_device *dev)
1596 {
1597         struct libusb_super_transfer *sxfer;
1598         unsigned x;
1599
1600         for (x = 0; x != LIBUSB_NUM_SW_ENDPOINTS; x++) {
1601                 struct libusb20_transfer *xfer;
1602
1603                 xfer = libusb20_tr_get_pointer(pdev, x);
1604                 if (xfer == NULL)
1605                         continue;
1606                 if (libusb20_tr_pending(xfer) == 0)
1607                         continue;
1608                 sxfer = libusb20_tr_get_priv_sc1(xfer);
1609                 if (sxfer == NULL)
1610                         continue;
1611                 /* complete pending transfer */
1612                 libusb10_complete_transfer(xfer, sxfer, LIBUSB_TRANSFER_ERROR);
1613         }
1614
1615         while ((sxfer = TAILQ_FIRST(&dev->tr_head))) {
1616                 TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1617
1618                 /* complete pending transfer */
1619                 libusb10_complete_transfer(NULL, sxfer, LIBUSB_TRANSFER_ERROR);
1620         }
1621 }
1622
1623 uint16_t
1624 libusb_cpu_to_le16(uint16_t x)
1625 {
1626         return (htole16(x));
1627 }
1628
1629 uint16_t
1630 libusb_le16_to_cpu(uint16_t x)
1631 {
1632         return (le16toh(x));
1633 }
1634
1635 const char *
1636 libusb_strerror(int code)
1637 {
1638         switch (code) {
1639         case LIBUSB_SUCCESS:
1640                 return ("Success");
1641         case LIBUSB_ERROR_IO:
1642                 return ("I/O error");
1643         case LIBUSB_ERROR_INVALID_PARAM:
1644                 return ("Invalid parameter");
1645         case LIBUSB_ERROR_ACCESS:
1646                 return ("Permissions error");
1647         case LIBUSB_ERROR_NO_DEVICE:
1648                 return ("No device");
1649         case LIBUSB_ERROR_NOT_FOUND:
1650                 return ("Not found");
1651         case LIBUSB_ERROR_BUSY:
1652                 return ("Device busy");
1653         case LIBUSB_ERROR_TIMEOUT:
1654                 return ("Timeout");
1655         case LIBUSB_ERROR_OVERFLOW:
1656                 return ("Overflow");
1657         case LIBUSB_ERROR_PIPE:
1658                 return ("Pipe error");
1659         case LIBUSB_ERROR_INTERRUPTED:
1660                 return ("Interrupted");
1661         case LIBUSB_ERROR_NO_MEM:
1662                 return ("Out of memory");
1663         case LIBUSB_ERROR_NOT_SUPPORTED:
1664                 return ("Not supported");
1665         case LIBUSB_ERROR_OTHER:
1666                 return ("Other error");
1667         default:
1668                 return ("Unknown error");
1669         }
1670 }
1671
1672 const char *
1673 libusb_error_name(int code)
1674 {
1675         switch (code) {
1676         case LIBUSB_SUCCESS:
1677                 return ("LIBUSB_SUCCESS");
1678         case LIBUSB_ERROR_IO:
1679                 return ("LIBUSB_ERROR_IO");
1680         case LIBUSB_ERROR_INVALID_PARAM:
1681                 return ("LIBUSB_ERROR_INVALID_PARAM");
1682         case LIBUSB_ERROR_ACCESS:
1683                 return ("LIBUSB_ERROR_ACCESS");
1684         case LIBUSB_ERROR_NO_DEVICE:
1685                 return ("LIBUSB_ERROR_NO_DEVICE");
1686         case LIBUSB_ERROR_NOT_FOUND:
1687                 return ("LIBUSB_ERROR_NOT_FOUND");
1688         case LIBUSB_ERROR_BUSY:
1689                 return ("LIBUSB_ERROR_BUSY");
1690         case LIBUSB_ERROR_TIMEOUT:
1691                 return ("LIBUSB_ERROR_TIMEOUT");
1692         case LIBUSB_ERROR_OVERFLOW:
1693                 return ("LIBUSB_ERROR_OVERFLOW");
1694         case LIBUSB_ERROR_PIPE:
1695                 return ("LIBUSB_ERROR_PIPE");
1696         case LIBUSB_ERROR_INTERRUPTED:
1697                 return ("LIBUSB_ERROR_INTERRUPTED");
1698         case LIBUSB_ERROR_NO_MEM:
1699                 return ("LIBUSB_ERROR_NO_MEM");
1700         case LIBUSB_ERROR_NOT_SUPPORTED:
1701                 return ("LIBUSB_ERROR_NOT_SUPPORTED");
1702         case LIBUSB_ERROR_OTHER:
1703                 return ("LIBUSB_ERROR_OTHER");
1704         default:
1705                 return ("LIBUSB_ERROR_UNKNOWN");
1706         }
1707 }
1708
1709 int
1710 libusb_has_capability(uint32_t capability)
1711 {
1712
1713         switch (capability) {
1714         case LIBUSB_CAP_HAS_CAPABILITY:
1715         case LIBUSB_CAP_HAS_HOTPLUG:
1716         case LIBUSB_CAP_HAS_HID_ACCESS:
1717         case LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER:
1718                 return (1);
1719         default:
1720                 return (0);
1721         }
1722 }