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