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