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