lib/libusb/libusb10.c

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