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