lib/libusb/libusb10.c

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