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