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