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