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