lib/libusb/libusb10.c

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