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