libusb10.c revision 213848
1/* $FreeBSD: head/lib/libusb/libusb10.c 213848 2010-10-14 20:04:36Z hselasky $ */ 2/*- 3 * Copyright (c) 2009 Sylvestre Gallon. All rights reserved. 4 * Copyright (c) 2009 Hans Petter Selasky. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28#include <sys/fcntl.h> 29#include <sys/ioctl.h> 30#include <sys/queue.h> 31 32#include <assert.h> 33#include <errno.h> 34#include <poll.h> 35#include <pthread.h> 36#include <stdio.h> 37#include <stdlib.h> 38#include <unistd.h> 39 40#define libusb_device_handle libusb20_device 41 42#include "libusb20.h" 43#include "libusb20_desc.h" 44#include "libusb20_int.h" 45#include "libusb.h" 46#include "libusb10.h" 47 48static pthread_mutex_t default_context_lock = PTHREAD_MUTEX_INITIALIZER; 49struct libusb_context *usbi_default_context = NULL; 50 51/* Prototypes */ 52 53static struct libusb20_transfer *libusb10_get_transfer(struct libusb20_device *, uint8_t, uint8_t); 54static int libusb10_get_maxframe(struct libusb20_device *, libusb_transfer *); 55static int libusb10_get_buffsize(struct libusb20_device *, libusb_transfer *); 56static int libusb10_convert_error(uint8_t status); 57static void libusb10_complete_transfer(struct libusb20_transfer *, struct libusb_super_transfer *, int); 58static void libusb10_isoc_proxy(struct libusb20_transfer *); 59static void libusb10_bulk_intr_proxy(struct libusb20_transfer *); 60static void libusb10_ctrl_proxy(struct libusb20_transfer *); 61static void libusb10_submit_transfer_sub(struct libusb20_device *, uint8_t); 62 63/* Library initialisation / deinitialisation */ 64 65void 66libusb_set_debug(libusb_context *ctx, int level) 67{ 68 ctx = GET_CONTEXT(ctx); 69 if (ctx) 70 ctx->debug = level; 71} 72 73int 74libusb_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 132void 133libusb_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 159ssize_t 160libusb_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 231void 232libusb_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 246uint8_t 247libusb_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 254uint8_t 255libusb_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 262int 263libusb_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 296out: 297 libusb_free_config_descriptor(pdconf); 298 return (ret); 299} 300 301libusb_device * 302libusb_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 314void 315libusb_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 330int 331libusb_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 368libusb_device_handle * 369libusb_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 410void 411libusb_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 440libusb_device * 441libusb_get_device(struct libusb20_device *pdev) 442{ 443 if (pdev == NULL) 444 return (NULL); 445 return ((libusb_device *)pdev->privLuData); 446} 447 448int 449libusb_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 467int 468libusb_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 500set_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 514int 515libusb_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 537int 538libusb_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 560int 561libusb_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 596static struct libusb20_transfer * 597libusb10_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 611int 612libusb_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 642int 643libusb_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 665int 666libusb_check_connected(struct libusb20_device *pdev) 667{ 668 libusb_device *dev; 669 int err; 670 671 dev = libusb_get_device(pdev); 672 if (dev == NULL) 673 return (LIBUSB_ERROR_INVALID_PARAM); 674 675 err = libusb20_dev_check_connected(pdev); 676 677 return (err ? LIBUSB_ERROR_NO_DEVICE : 0); 678} 679 680int 681libusb_kernel_driver_active(struct libusb20_device *pdev, int interface) 682{ 683 if (pdev == NULL) 684 return (LIBUSB_ERROR_INVALID_PARAM); 685 686 return (libusb20_dev_kernel_driver_active( 687 pdev, interface)); 688} 689 690int 691libusb_detach_kernel_driver(struct libusb20_device *pdev, int interface) 692{ 693 int err; 694 695 if (pdev == NULL) 696 return (LIBUSB_ERROR_INVALID_PARAM); 697 698 err = libusb20_dev_detach_kernel_driver( 699 pdev, interface); 700 701 return (err ? LIBUSB20_ERROR_OTHER : 0); 702} 703 704int 705libusb_attach_kernel_driver(struct libusb20_device *pdev, int interface) 706{ 707 if (pdev == NULL) 708 return (LIBUSB_ERROR_INVALID_PARAM); 709 /* stub - currently not supported by libusb20 */ 710 return (0); 711} 712 713/* Asynchronous device I/O */ 714 715struct libusb_transfer * 716libusb_alloc_transfer(int iso_packets) 717{ 718 struct libusb_transfer *uxfer; 719 struct libusb_super_transfer *sxfer; 720 int len; 721 722 len = sizeof(struct libusb_transfer) + 723 sizeof(struct libusb_super_transfer) + 724 (iso_packets * sizeof(libusb_iso_packet_descriptor)); 725 726 sxfer = malloc(len); 727 if (sxfer == NULL) 728 return (NULL); 729 730 memset(sxfer, 0, len); 731 732 uxfer = (struct libusb_transfer *)( 733 ((uint8_t *)sxfer) + sizeof(*sxfer)); 734 735 /* set default value */ 736 uxfer->num_iso_packets = iso_packets; 737 738 return (uxfer); 739} 740 741void 742libusb_free_transfer(struct libusb_transfer *uxfer) 743{ 744 struct libusb_super_transfer *sxfer; 745 746 if (uxfer == NULL) 747 return; /* be NULL safe */ 748 749 sxfer = (struct libusb_super_transfer *)( 750 (uint8_t *)uxfer - sizeof(*sxfer)); 751 752 free(sxfer); 753} 754 755static int 756libusb10_get_maxframe(struct libusb20_device *pdev, libusb_transfer *xfer) 757{ 758 int ret; 759 int usb_speed; 760 761 usb_speed = libusb20_dev_get_speed(pdev); 762 763 switch (xfer->type) { 764 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: 765 switch (usb_speed) { 766 case LIBUSB20_SPEED_LOW: 767 case LIBUSB20_SPEED_FULL: 768 ret = 60 * 1; 769 break; 770 default: 771 ret = 60 * 8; 772 break; 773 } 774 break; 775 case LIBUSB_TRANSFER_TYPE_CONTROL: 776 ret = 2; 777 break; 778 default: 779 ret = 1; 780 break; 781 } 782 return (ret); 783} 784 785static int 786libusb10_get_buffsize(struct libusb20_device *pdev, libusb_transfer *xfer) 787{ 788 int ret; 789 int usb_speed; 790 791 usb_speed = libusb20_dev_get_speed(pdev); 792 793 switch (xfer->type) { 794 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: 795 ret = 0; /* kernel will auto-select */ 796 break; 797 case LIBUSB_TRANSFER_TYPE_CONTROL: 798 ret = 1024; 799 break; 800 default: 801 switch (usb_speed) { 802 case LIBUSB20_SPEED_LOW: 803 ret = 256; 804 break; 805 case LIBUSB20_SPEED_FULL: 806 ret = 4096; 807 break; 808 default: 809 ret = 16384; 810 break; 811 } 812 break; 813 } 814 return (ret); 815} 816 817static int 818libusb10_convert_error(uint8_t status) 819{ 820 ; /* indent fix */ 821 822 switch (status) { 823 case LIBUSB20_TRANSFER_START: 824 case LIBUSB20_TRANSFER_COMPLETED: 825 return (LIBUSB_TRANSFER_COMPLETED); 826 case LIBUSB20_TRANSFER_OVERFLOW: 827 return (LIBUSB_TRANSFER_OVERFLOW); 828 case LIBUSB20_TRANSFER_NO_DEVICE: 829 return (LIBUSB_TRANSFER_NO_DEVICE); 830 case LIBUSB20_TRANSFER_STALL: 831 return (LIBUSB_TRANSFER_STALL); 832 case LIBUSB20_TRANSFER_CANCELLED: 833 return (LIBUSB_TRANSFER_CANCELLED); 834 case LIBUSB20_TRANSFER_TIMED_OUT: 835 return (LIBUSB_TRANSFER_TIMED_OUT); 836 default: 837 return (LIBUSB_TRANSFER_ERROR); 838 } 839} 840 841/* This function must be called locked */ 842 843static void 844libusb10_complete_transfer(struct libusb20_transfer *pxfer, 845 struct libusb_super_transfer *sxfer, int status) 846{ 847 struct libusb_transfer *uxfer; 848 struct libusb_device *dev; 849 850 uxfer = (struct libusb_transfer *)( 851 ((uint8_t *)sxfer) + sizeof(*sxfer)); 852 853 if (pxfer != NULL) 854 libusb20_tr_set_priv_sc1(pxfer, NULL); 855 856 /* set transfer status */ 857 uxfer->status = status; 858 859 /* update super transfer state */ 860 sxfer->state = LIBUSB_SUPER_XFER_ST_NONE; 861 862 dev = libusb_get_device(uxfer->dev_handle); 863 864 TAILQ_INSERT_TAIL(&dev->ctx->tr_done, sxfer, entry); 865} 866 867/* This function must be called locked */ 868 869static void 870libusb10_isoc_proxy(struct libusb20_transfer *pxfer) 871{ 872 struct libusb_super_transfer *sxfer; 873 struct libusb_transfer *uxfer; 874 uint32_t actlen; 875 uint16_t iso_packets; 876 uint16_t i; 877 uint8_t status; 878 uint8_t flags; 879 880 status = libusb20_tr_get_status(pxfer); 881 sxfer = libusb20_tr_get_priv_sc1(pxfer); 882 actlen = libusb20_tr_get_actual_length(pxfer); 883 iso_packets = libusb20_tr_get_max_frames(pxfer); 884 885 if (sxfer == NULL) 886 return; /* cancelled - nothing to do */ 887 888 uxfer = (struct libusb_transfer *)( 889 ((uint8_t *)sxfer) + sizeof(*sxfer)); 890 891 if (iso_packets > uxfer->num_iso_packets) 892 iso_packets = uxfer->num_iso_packets; 893 894 if (iso_packets == 0) 895 return; /* nothing to do */ 896 897 /* make sure that the number of ISOCHRONOUS packets is valid */ 898 uxfer->num_iso_packets = iso_packets; 899 900 flags = uxfer->flags; 901 902 switch (status) { 903 case LIBUSB20_TRANSFER_COMPLETED: 904 905 /* update actual length */ 906 uxfer->actual_length = actlen; 907 for (i = 0; i != iso_packets; i++) { 908 uxfer->iso_packet_desc[i].actual_length = 909 libusb20_tr_get_length(pxfer, i); 910 } 911 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED); 912 break; 913 914 case LIBUSB20_TRANSFER_START: 915 916 /* setup length(s) */ 917 actlen = 0; 918 for (i = 0; i != iso_packets; i++) { 919 libusb20_tr_setup_isoc(pxfer, 920 &uxfer->buffer[actlen], 921 uxfer->iso_packet_desc[i].length, i); 922 actlen += uxfer->iso_packet_desc[i].length; 923 } 924 925 /* no remainder */ 926 sxfer->rem_len = 0; 927 928 libusb20_tr_set_total_frames(pxfer, iso_packets); 929 libusb20_tr_submit(pxfer); 930 931 /* fork another USB transfer, if any */ 932 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint); 933 break; 934 935 default: 936 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status)); 937 break; 938 } 939} 940 941/* This function must be called locked */ 942 943static void 944libusb10_bulk_intr_proxy(struct libusb20_transfer *pxfer) 945{ 946 struct libusb_super_transfer *sxfer; 947 struct libusb_transfer *uxfer; 948 uint32_t max_bulk; 949 uint32_t actlen; 950 uint8_t status; 951 uint8_t flags; 952 953 status = libusb20_tr_get_status(pxfer); 954 sxfer = libusb20_tr_get_priv_sc1(pxfer); 955 max_bulk = libusb20_tr_get_max_total_length(pxfer); 956 actlen = libusb20_tr_get_actual_length(pxfer); 957 958 if (sxfer == NULL) 959 return; /* cancelled - nothing to do */ 960 961 uxfer = (struct libusb_transfer *)( 962 ((uint8_t *)sxfer) + sizeof(*sxfer)); 963 964 flags = uxfer->flags; 965 966 switch (status) { 967 case LIBUSB20_TRANSFER_COMPLETED: 968 969 uxfer->actual_length += actlen; 970 971 /* check for short packet */ 972 if (sxfer->last_len != actlen) { 973 if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) { 974 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR); 975 } else { 976 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED); 977 } 978 break; 979 } 980 /* check for end of data */ 981 if (sxfer->rem_len == 0) { 982 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED); 983 break; 984 } 985 /* FALLTHROUGH */ 986 987 case LIBUSB20_TRANSFER_START: 988 if (max_bulk > sxfer->rem_len) { 989 max_bulk = sxfer->rem_len; 990 } 991 /* setup new BULK or INTERRUPT transaction */ 992 libusb20_tr_setup_bulk(pxfer, 993 sxfer->curr_data, max_bulk, uxfer->timeout); 994 995 /* update counters */ 996 sxfer->last_len = max_bulk; 997 sxfer->curr_data += max_bulk; 998 sxfer->rem_len -= max_bulk; 999 1000 libusb20_tr_submit(pxfer); 1001 1002 /* check if we can fork another USB transfer */ 1003 if (sxfer->rem_len == 0) 1004 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint); 1005 break; 1006 1007 default: 1008 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status)); 1009 break; 1010 } 1011} 1012 1013/* This function must be called locked */ 1014 1015static void 1016libusb10_ctrl_proxy(struct libusb20_transfer *pxfer) 1017{ 1018 struct libusb_super_transfer *sxfer; 1019 struct libusb_transfer *uxfer; 1020 uint32_t max_bulk; 1021 uint32_t actlen; 1022 uint8_t status; 1023 uint8_t flags; 1024 1025 status = libusb20_tr_get_status(pxfer); 1026 sxfer = libusb20_tr_get_priv_sc1(pxfer); 1027 max_bulk = libusb20_tr_get_max_total_length(pxfer); 1028 actlen = libusb20_tr_get_actual_length(pxfer); 1029 1030 if (sxfer == NULL) 1031 return; /* cancelled - nothing to do */ 1032 1033 uxfer = (struct libusb_transfer *)( 1034 ((uint8_t *)sxfer) + sizeof(*sxfer)); 1035 1036 flags = uxfer->flags; 1037 1038 switch (status) { 1039 case LIBUSB20_TRANSFER_COMPLETED: 1040 1041 uxfer->actual_length += actlen; 1042 1043 /* subtract length of SETUP packet, if any */ 1044 actlen -= libusb20_tr_get_length(pxfer, 0); 1045 1046 /* check for short packet */ 1047 if (sxfer->last_len != actlen) { 1048 if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) { 1049 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR); 1050 } else { 1051 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED); 1052 } 1053 break; 1054 } 1055 /* check for end of data */ 1056 if (sxfer->rem_len == 0) { 1057 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED); 1058 break; 1059 } 1060 /* FALLTHROUGH */ 1061 1062 case LIBUSB20_TRANSFER_START: 1063 if (max_bulk > sxfer->rem_len) { 1064 max_bulk = sxfer->rem_len; 1065 } 1066 /* setup new CONTROL transaction */ 1067 if (status == LIBUSB20_TRANSFER_COMPLETED) { 1068 /* next fragment - don't send SETUP packet */ 1069 libusb20_tr_set_length(pxfer, 0, 0); 1070 } else { 1071 /* first fragment - send SETUP packet */ 1072 libusb20_tr_set_length(pxfer, 8, 0); 1073 libusb20_tr_set_buffer(pxfer, uxfer->buffer, 0); 1074 } 1075 1076 if (max_bulk != 0) { 1077 libusb20_tr_set_length(pxfer, max_bulk, 1); 1078 libusb20_tr_set_buffer(pxfer, sxfer->curr_data, 1); 1079 libusb20_tr_set_total_frames(pxfer, 2); 1080 } else { 1081 libusb20_tr_set_total_frames(pxfer, 1); 1082 } 1083 1084 /* update counters */ 1085 sxfer->last_len = max_bulk; 1086 sxfer->curr_data += max_bulk; 1087 sxfer->rem_len -= max_bulk; 1088 1089 libusb20_tr_submit(pxfer); 1090 1091 /* check if we can fork another USB transfer */ 1092 if (sxfer->rem_len == 0) 1093 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint); 1094 break; 1095 1096 default: 1097 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status)); 1098 break; 1099 } 1100} 1101 1102/* The following function must be called locked */ 1103 1104static void 1105libusb10_submit_transfer_sub(struct libusb20_device *pdev, uint8_t endpoint) 1106{ 1107 struct libusb20_transfer *pxfer0; 1108 struct libusb20_transfer *pxfer1; 1109 struct libusb_super_transfer *sxfer; 1110 struct libusb_transfer *uxfer; 1111 struct libusb_device *dev; 1112 int err; 1113 int buffsize; 1114 int maxframe; 1115 int temp; 1116 uint8_t dummy; 1117 1118 dev = libusb_get_device(pdev); 1119 1120 pxfer0 = libusb10_get_transfer(pdev, endpoint, 0); 1121 pxfer1 = libusb10_get_transfer(pdev, endpoint, 1); 1122 1123 if (pxfer0 == NULL || pxfer1 == NULL) 1124 return; /* shouldn't happen */ 1125 1126 temp = 0; 1127 if (libusb20_tr_pending(pxfer0)) 1128 temp |= 1; 1129 if (libusb20_tr_pending(pxfer1)) 1130 temp |= 2; 1131 1132 switch (temp) { 1133 case 3: 1134 /* wait till one of the transfers complete */ 1135 return; 1136 case 2: 1137 sxfer = libusb20_tr_get_priv_sc1(pxfer1); 1138 if (sxfer == NULL) 1139 return; /* cancelling */ 1140 if (sxfer->rem_len) 1141 return; /* cannot queue another one */ 1142 /* swap transfers */ 1143 pxfer1 = pxfer0; 1144 break; 1145 case 1: 1146 sxfer = libusb20_tr_get_priv_sc1(pxfer0); 1147 if (sxfer == NULL) 1148 return; /* cancelling */ 1149 if (sxfer->rem_len) 1150 return; /* cannot queue another one */ 1151 /* swap transfers */ 1152 pxfer0 = pxfer1; 1153 break; 1154 default: 1155 break; 1156 } 1157 1158 /* find next transfer on same endpoint */ 1159 TAILQ_FOREACH(sxfer, &dev->tr_head, entry) { 1160 1161 uxfer = (struct libusb_transfer *)( 1162 ((uint8_t *)sxfer) + sizeof(*sxfer)); 1163 1164 if (uxfer->endpoint == endpoint) { 1165 TAILQ_REMOVE(&dev->tr_head, sxfer, entry); 1166 sxfer->entry.tqe_prev = NULL; 1167 goto found; 1168 } 1169 } 1170 return; /* success */ 1171 1172found: 1173 1174 libusb20_tr_set_priv_sc0(pxfer0, pdev); 1175 libusb20_tr_set_priv_sc1(pxfer0, sxfer); 1176 1177 /* reset super transfer state */ 1178 sxfer->rem_len = uxfer->length; 1179 sxfer->curr_data = uxfer->buffer; 1180 uxfer->actual_length = 0; 1181 1182 switch (uxfer->type) { 1183 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS: 1184 libusb20_tr_set_callback(pxfer0, libusb10_isoc_proxy); 1185 break; 1186 case LIBUSB_TRANSFER_TYPE_BULK: 1187 case LIBUSB_TRANSFER_TYPE_INTERRUPT: 1188 libusb20_tr_set_callback(pxfer0, libusb10_bulk_intr_proxy); 1189 break; 1190 case LIBUSB_TRANSFER_TYPE_CONTROL: 1191 libusb20_tr_set_callback(pxfer0, libusb10_ctrl_proxy); 1192 if (sxfer->rem_len < 8) 1193 goto failure; 1194 1195 /* remove SETUP packet from data */ 1196 sxfer->rem_len -= 8; 1197 sxfer->curr_data += 8; 1198 break; 1199 default: 1200 goto failure; 1201 } 1202 1203 buffsize = libusb10_get_buffsize(pdev, uxfer); 1204 maxframe = libusb10_get_maxframe(pdev, uxfer); 1205 1206 /* make sure the transfer is opened */ 1207 err = libusb20_tr_open(pxfer0, buffsize, maxframe, endpoint); 1208 if (err && (err != LIBUSB20_ERROR_BUSY)) { 1209 goto failure; 1210 } 1211 libusb20_tr_start(pxfer0); 1212 return; 1213 1214failure: 1215 libusb10_complete_transfer(pxfer0, sxfer, LIBUSB_TRANSFER_ERROR); 1216 1217 /* make sure our event loop spins the done handler */ 1218 dummy = 0; 1219 write(dev->ctx->ctrl_pipe[1], &dummy, sizeof(dummy)); 1220} 1221 1222/* The following function must be called unlocked */ 1223 1224int 1225libusb_submit_transfer(struct libusb_transfer *uxfer) 1226{ 1227 struct libusb20_transfer *pxfer0; 1228 struct libusb20_transfer *pxfer1; 1229 struct libusb_super_transfer *sxfer; 1230 struct libusb_device *dev; 1231 uint32_t endpoint; 1232 int err; 1233 1234 if (uxfer == NULL) 1235 return (LIBUSB_ERROR_INVALID_PARAM); 1236 1237 if (uxfer->dev_handle == NULL) 1238 return (LIBUSB_ERROR_INVALID_PARAM); 1239 1240 endpoint = uxfer->endpoint; 1241 1242 if (endpoint > 255) 1243 return (LIBUSB_ERROR_INVALID_PARAM); 1244 1245 dev = libusb_get_device(uxfer->dev_handle); 1246 1247 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer enter"); 1248 1249 sxfer = (struct libusb_super_transfer *)( 1250 (uint8_t *)uxfer - sizeof(*sxfer)); 1251 1252 CTX_LOCK(dev->ctx); 1253 1254 pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0); 1255 pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1); 1256 1257 if (pxfer0 == NULL || pxfer1 == NULL) { 1258 err = LIBUSB_ERROR_OTHER; 1259 } else if ((sxfer->entry.tqe_prev != NULL) || 1260 (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) || 1261 (libusb20_tr_get_priv_sc1(pxfer1) == sxfer)) { 1262 err = LIBUSB_ERROR_BUSY; 1263 } else { 1264 1265 /* set pending state */ 1266 sxfer->state = LIBUSB_SUPER_XFER_ST_PEND; 1267 1268 /* insert transfer into transfer head list */ 1269 TAILQ_INSERT_TAIL(&dev->tr_head, sxfer, entry); 1270 1271 /* start work transfers */ 1272 libusb10_submit_transfer_sub( 1273 uxfer->dev_handle, endpoint); 1274 1275 err = 0; /* success */ 1276 } 1277 1278 CTX_UNLOCK(dev->ctx); 1279 1280 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer leave %d", err); 1281 1282 return (err); 1283} 1284 1285/* Asynchronous transfer cancel */ 1286 1287int 1288libusb_cancel_transfer(struct libusb_transfer *uxfer) 1289{ 1290 struct libusb20_transfer *pxfer0; 1291 struct libusb20_transfer *pxfer1; 1292 struct libusb_super_transfer *sxfer; 1293 struct libusb_device *dev; 1294 uint32_t endpoint; 1295 int retval; 1296 1297 if (uxfer == NULL) 1298 return (LIBUSB_ERROR_INVALID_PARAM); 1299 1300 /* check if not initialised */ 1301 if (uxfer->dev_handle == NULL) 1302 return (LIBUSB_ERROR_NOT_FOUND); 1303 1304 endpoint = uxfer->endpoint; 1305 1306 if (endpoint > 255) 1307 return (LIBUSB_ERROR_INVALID_PARAM); 1308 1309 dev = libusb_get_device(uxfer->dev_handle); 1310 1311 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer enter"); 1312 1313 sxfer = (struct libusb_super_transfer *)( 1314 (uint8_t *)uxfer - sizeof(*sxfer)); 1315 1316 retval = 0; 1317 1318 CTX_LOCK(dev->ctx); 1319 1320 pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0); 1321 pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1); 1322 1323 if (sxfer->state != LIBUSB_SUPER_XFER_ST_PEND) { 1324 /* only update the transfer status */ 1325 uxfer->status = LIBUSB_TRANSFER_CANCELLED; 1326 retval = LIBUSB_ERROR_NOT_FOUND; 1327 } else if (sxfer->entry.tqe_prev != NULL) { 1328 /* we are lucky - transfer is on a queue */ 1329 TAILQ_REMOVE(&dev->tr_head, sxfer, entry); 1330 sxfer->entry.tqe_prev = NULL; 1331 libusb10_complete_transfer(NULL, 1332 sxfer, LIBUSB_TRANSFER_CANCELLED); 1333 } else if (pxfer0 == NULL || pxfer1 == NULL) { 1334 /* not started */ 1335 retval = LIBUSB_ERROR_NOT_FOUND; 1336 } else if (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) { 1337 libusb10_complete_transfer(pxfer0, 1338 sxfer, LIBUSB_TRANSFER_CANCELLED); 1339 libusb20_tr_stop(pxfer0); 1340 /* make sure the queue doesn't stall */ 1341 libusb10_submit_transfer_sub( 1342 uxfer->dev_handle, endpoint); 1343 } else if (libusb20_tr_get_priv_sc1(pxfer1) == sxfer) { 1344 libusb10_complete_transfer(pxfer1, 1345 sxfer, LIBUSB_TRANSFER_CANCELLED); 1346 libusb20_tr_stop(pxfer1); 1347 /* make sure the queue doesn't stall */ 1348 libusb10_submit_transfer_sub( 1349 uxfer->dev_handle, endpoint); 1350 } else { 1351 /* not started */ 1352 retval = LIBUSB_ERROR_NOT_FOUND; 1353 } 1354 1355 CTX_UNLOCK(dev->ctx); 1356 1357 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer leave"); 1358 1359 return (retval); 1360} 1361 1362UNEXPORTED void 1363libusb10_cancel_all_transfer(libusb_device *dev) 1364{ 1365 /* TODO */ 1366} 1367 1368uint16_t 1369libusb_cpu_to_le16(uint16_t x) 1370{ 1371 return (htole16(x)); 1372} 1373 1374uint16_t 1375libusb_le16_to_cpu(uint16_t x) 1376{ 1377 return (le16toh(x)); 1378} 1379 1380