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