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