lib/libusb/libusb10.c

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