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