1 /* $FreeBSD$ */ 2 /*- 3 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 4 * 5 * Copyright (c) 2008-2009 Hans Petter Selasky. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #ifdef LIBUSB_GLOBAL_INCLUDE_FILE 30 #include LIBUSB_GLOBAL_INCLUDE_FILE 31 #else 32 #include <ctype.h> 33 #include <poll.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <string.h> 37 #include <time.h> 38 #include <sys/queue.h> 39 #endif 40 41 #include "libusb20.h" 42 #include "libusb20_desc.h" 43 #include "libusb20_int.h" 44 45 static int 46 dummy_int(void) 47 { 48 return (LIBUSB20_ERROR_NOT_SUPPORTED); 49 } 50 51 static void 52 dummy_void(void) 53 { 54 return; 55 } 56 57 static void 58 dummy_callback(struct libusb20_transfer *xfer) 59 { 60 ; /* style fix */ 61 switch (libusb20_tr_get_status(xfer)) { 62 case LIBUSB20_TRANSFER_START: 63 libusb20_tr_submit(xfer); 64 break; 65 default: 66 /* complete or error */ 67 break; 68 } 69 return; 70 } 71 72 #define dummy_get_config_desc_full (void *)dummy_int 73 #define dummy_get_config_index (void *)dummy_int 74 #define dummy_set_config_index (void *)dummy_int 75 #define dummy_set_alt_index (void *)dummy_int 76 #define dummy_reset_device (void *)dummy_int 77 #define dummy_check_connected (void *)dummy_int 78 #define dummy_set_power_mode (void *)dummy_int 79 #define dummy_get_power_mode (void *)dummy_int 80 #define dummy_get_power_usage (void *)dummy_int 81 #define dummy_kernel_driver_active (void *)dummy_int 82 #define dummy_detach_kernel_driver (void *)dummy_int 83 #define dummy_do_request_sync (void *)dummy_int 84 #define dummy_tr_open (void *)dummy_int 85 #define dummy_tr_close (void *)dummy_int 86 #define dummy_tr_clear_stall_sync (void *)dummy_int 87 #define dummy_process (void *)dummy_int 88 #define dummy_dev_info (void *)dummy_int 89 #define dummy_dev_get_iface_driver (void *)dummy_int 90 91 #define dummy_tr_submit (void *)dummy_void 92 #define dummy_tr_cancel_async (void *)dummy_void 93 94 static const struct libusb20_device_methods libusb20_dummy_methods = { 95 LIBUSB20_DEVICE(LIBUSB20_DECLARE, dummy) 96 }; 97 98 void 99 libusb20_tr_callback_wrapper(struct libusb20_transfer *xfer) 100 { 101 ; /* style fix */ 102 103 repeat: 104 105 if (!xfer->is_pending) { 106 xfer->status = LIBUSB20_TRANSFER_START; 107 } else { 108 xfer->is_pending = 0; 109 } 110 111 xfer->callback(xfer); 112 113 if (xfer->is_restart) { 114 xfer->is_restart = 0; 115 goto repeat; 116 } 117 if (xfer->is_draining && 118 (!xfer->is_pending)) { 119 xfer->is_draining = 0; 120 xfer->status = LIBUSB20_TRANSFER_DRAINED; 121 xfer->callback(xfer); 122 } 123 return; 124 } 125 126 int 127 libusb20_tr_close(struct libusb20_transfer *xfer) 128 { 129 int error; 130 131 if (!xfer->is_opened) { 132 return (LIBUSB20_ERROR_OTHER); 133 } 134 error = xfer->pdev->methods->tr_close(xfer); 135 136 if (xfer->pLength) { 137 free(xfer->pLength); 138 } 139 if (xfer->ppBuffer) { 140 free(xfer->ppBuffer); 141 } 142 /* reset variable fields in case the transfer is opened again */ 143 xfer->priv_sc0 = NULL; 144 xfer->priv_sc1 = NULL; 145 xfer->is_opened = 0; 146 xfer->is_pending = 0; 147 xfer->is_cancel = 0; 148 xfer->is_draining = 0; 149 xfer->is_restart = 0; 150 xfer->status = 0; 151 xfer->flags = 0; 152 xfer->nFrames = 0; 153 xfer->aFrames = 0; 154 xfer->timeout = 0; 155 xfer->maxFrames = 0; 156 xfer->maxTotalLength = 0; 157 xfer->maxPacketLen = 0; 158 return (error); 159 } 160 161 int 162 libusb20_tr_open(struct libusb20_transfer *xfer, uint32_t MaxBufSize, 163 uint32_t MaxFrameCount, uint8_t ep_no) 164 { 165 return (libusb20_tr_open_stream(xfer, MaxBufSize, MaxFrameCount, ep_no, 0)); 166 } 167 168 int 169 libusb20_tr_open_stream(struct libusb20_transfer *xfer, uint32_t MaxBufSize, 170 uint32_t MaxFrameCount, uint8_t ep_no, uint16_t stream_id) 171 { 172 uint32_t size; 173 uint8_t pre_scale; 174 int error; 175 176 if (xfer->is_opened) 177 return (LIBUSB20_ERROR_BUSY); 178 if (MaxFrameCount & LIBUSB20_MAX_FRAME_PRE_SCALE) { 179 MaxFrameCount &= ~LIBUSB20_MAX_FRAME_PRE_SCALE; 180 /* 181 * The kernel can setup 8 times more frames when 182 * pre-scaling ISOCHRONOUS transfers. Make sure the 183 * length and pointer buffers are big enough: 184 */ 185 MaxFrameCount *= 8; 186 pre_scale = 1; 187 } else { 188 pre_scale = 0; 189 } 190 if (MaxFrameCount == 0) 191 return (LIBUSB20_ERROR_INVALID_PARAM); 192 193 xfer->maxFrames = MaxFrameCount; 194 195 size = MaxFrameCount * sizeof(xfer->pLength[0]); 196 xfer->pLength = malloc(size); 197 if (xfer->pLength == NULL) { 198 return (LIBUSB20_ERROR_NO_MEM); 199 } 200 memset(xfer->pLength, 0, size); 201 202 size = MaxFrameCount * sizeof(xfer->ppBuffer[0]); 203 xfer->ppBuffer = malloc(size); 204 if (xfer->ppBuffer == NULL) { 205 free(xfer->pLength); 206 return (LIBUSB20_ERROR_NO_MEM); 207 } 208 memset(xfer->ppBuffer, 0, size); 209 210 if (pre_scale) { 211 error = xfer->pdev->methods->tr_open(xfer, MaxBufSize, 212 MaxFrameCount / 8, ep_no, stream_id, 1); 213 } else { 214 error = xfer->pdev->methods->tr_open(xfer, MaxBufSize, 215 MaxFrameCount, ep_no, stream_id, 0); 216 } 217 218 if (error) { 219 free(xfer->ppBuffer); 220 free(xfer->pLength); 221 } else { 222 xfer->is_opened = 1; 223 } 224 return (error); 225 } 226 227 struct libusb20_transfer * 228 libusb20_tr_get_pointer(struct libusb20_device *pdev, uint16_t trIndex) 229 { 230 if (trIndex >= pdev->nTransfer) { 231 return (NULL); 232 } 233 return (pdev->pTransfer + trIndex); 234 } 235 236 uint32_t 237 libusb20_tr_get_actual_frames(struct libusb20_transfer *xfer) 238 { 239 return (xfer->aFrames); 240 } 241 242 uint16_t 243 libusb20_tr_get_time_complete(struct libusb20_transfer *xfer) 244 { 245 return (xfer->timeComplete); 246 } 247 248 uint32_t 249 libusb20_tr_get_actual_length(struct libusb20_transfer *xfer) 250 { 251 uint32_t x; 252 uint32_t actlen = 0; 253 254 for (x = 0; x != xfer->aFrames; x++) { 255 actlen += xfer->pLength[x]; 256 } 257 return (actlen); 258 } 259 260 uint32_t 261 libusb20_tr_get_max_frames(struct libusb20_transfer *xfer) 262 { 263 return (xfer->maxFrames); 264 } 265 266 uint32_t 267 libusb20_tr_get_max_packet_length(struct libusb20_transfer *xfer) 268 { 269 /* 270 * Special Case NOTE: If the packet multiplier is non-zero for 271 * High Speed USB, the value returned is equal to 272 * "wMaxPacketSize * multiplier" ! 273 */ 274 return (xfer->maxPacketLen); 275 } 276 277 uint32_t 278 libusb20_tr_get_max_total_length(struct libusb20_transfer *xfer) 279 { 280 return (xfer->maxTotalLength); 281 } 282 283 uint8_t 284 libusb20_tr_get_status(struct libusb20_transfer *xfer) 285 { 286 return (xfer->status); 287 } 288 289 uint8_t 290 libusb20_tr_pending(struct libusb20_transfer *xfer) 291 { 292 return (xfer->is_pending); 293 } 294 295 void * 296 libusb20_tr_get_priv_sc0(struct libusb20_transfer *xfer) 297 { 298 return (xfer->priv_sc0); 299 } 300 301 void * 302 libusb20_tr_get_priv_sc1(struct libusb20_transfer *xfer) 303 { 304 return (xfer->priv_sc1); 305 } 306 307 void 308 libusb20_tr_stop(struct libusb20_transfer *xfer) 309 { 310 if (!xfer->is_opened) { 311 /* transfer is not opened */ 312 return; 313 } 314 if (!xfer->is_pending) { 315 /* transfer not pending */ 316 return; 317 } 318 if (xfer->is_cancel) { 319 /* already cancelling */ 320 return; 321 } 322 xfer->is_cancel = 1; /* we are cancelling */ 323 324 xfer->pdev->methods->tr_cancel_async(xfer); 325 return; 326 } 327 328 void 329 libusb20_tr_drain(struct libusb20_transfer *xfer) 330 { 331 if (!xfer->is_opened) { 332 /* transfer is not opened */ 333 return; 334 } 335 /* make sure that we are cancelling */ 336 libusb20_tr_stop(xfer); 337 338 if (xfer->is_pending) { 339 xfer->is_draining = 1; 340 } 341 return; 342 } 343 344 void 345 libusb20_tr_clear_stall_sync(struct libusb20_transfer *xfer) 346 { 347 xfer->pdev->methods->tr_clear_stall_sync(xfer); 348 return; 349 } 350 351 void 352 libusb20_tr_set_buffer(struct libusb20_transfer *xfer, void *buffer, uint16_t frIndex) 353 { 354 xfer->ppBuffer[frIndex] = libusb20_pass_ptr(buffer); 355 return; 356 } 357 358 void 359 libusb20_tr_set_callback(struct libusb20_transfer *xfer, libusb20_tr_callback_t *cb) 360 { 361 xfer->callback = cb; 362 return; 363 } 364 365 void 366 libusb20_tr_set_flags(struct libusb20_transfer *xfer, uint8_t flags) 367 { 368 xfer->flags = flags; 369 return; 370 } 371 372 uint32_t 373 libusb20_tr_get_length(struct libusb20_transfer *xfer, uint16_t frIndex) 374 { 375 return (xfer->pLength[frIndex]); 376 } 377 378 void 379 libusb20_tr_set_length(struct libusb20_transfer *xfer, uint32_t length, uint16_t frIndex) 380 { 381 xfer->pLength[frIndex] = length; 382 return; 383 } 384 385 void 386 libusb20_tr_set_priv_sc0(struct libusb20_transfer *xfer, void *sc0) 387 { 388 xfer->priv_sc0 = sc0; 389 return; 390 } 391 392 void 393 libusb20_tr_set_priv_sc1(struct libusb20_transfer *xfer, void *sc1) 394 { 395 xfer->priv_sc1 = sc1; 396 return; 397 } 398 399 void 400 libusb20_tr_set_timeout(struct libusb20_transfer *xfer, uint32_t timeout) 401 { 402 xfer->timeout = timeout; 403 return; 404 } 405 406 void 407 libusb20_tr_set_total_frames(struct libusb20_transfer *xfer, uint32_t nFrames) 408 { 409 if (nFrames > xfer->maxFrames) { 410 /* should not happen */ 411 nFrames = xfer->maxFrames; 412 } 413 xfer->nFrames = nFrames; 414 return; 415 } 416 417 void 418 libusb20_tr_setup_bulk(struct libusb20_transfer *xfer, void *pBuf, uint32_t length, uint32_t timeout) 419 { 420 xfer->ppBuffer[0] = libusb20_pass_ptr(pBuf); 421 xfer->pLength[0] = length; 422 xfer->timeout = timeout; 423 xfer->nFrames = 1; 424 return; 425 } 426 427 void 428 libusb20_tr_setup_control(struct libusb20_transfer *xfer, void *psetup, void *pBuf, uint32_t timeout) 429 { 430 uint16_t len; 431 432 xfer->ppBuffer[0] = libusb20_pass_ptr(psetup); 433 xfer->pLength[0] = 8; /* fixed */ 434 xfer->timeout = timeout; 435 436 len = ((uint8_t *)psetup)[6] | (((uint8_t *)psetup)[7] << 8); 437 438 if (len != 0) { 439 xfer->nFrames = 2; 440 xfer->ppBuffer[1] = libusb20_pass_ptr(pBuf); 441 xfer->pLength[1] = len; 442 } else { 443 xfer->nFrames = 1; 444 } 445 return; 446 } 447 448 void 449 libusb20_tr_setup_intr(struct libusb20_transfer *xfer, void *pBuf, uint32_t length, uint32_t timeout) 450 { 451 xfer->ppBuffer[0] = libusb20_pass_ptr(pBuf); 452 xfer->pLength[0] = length; 453 xfer->timeout = timeout; 454 xfer->nFrames = 1; 455 return; 456 } 457 458 void 459 libusb20_tr_setup_isoc(struct libusb20_transfer *xfer, void *pBuf, uint32_t length, uint16_t frIndex) 460 { 461 if (frIndex >= xfer->maxFrames) { 462 /* should not happen */ 463 return; 464 } 465 xfer->ppBuffer[frIndex] = libusb20_pass_ptr(pBuf); 466 xfer->pLength[frIndex] = length; 467 return; 468 } 469 470 uint8_t 471 libusb20_tr_bulk_intr_sync(struct libusb20_transfer *xfer, 472 void *pbuf, uint32_t length, uint32_t *pactlen, 473 uint32_t timeout) 474 { 475 struct libusb20_device *pdev = xfer->pdev; 476 uint32_t transfer_max; 477 uint32_t transfer_act; 478 uint8_t retval; 479 480 /* set some sensible default value */ 481 if (pactlen != NULL) 482 *pactlen = 0; 483 484 /* check for error condition */ 485 if (libusb20_tr_pending(xfer)) 486 return (LIBUSB20_ERROR_OTHER); 487 488 do { 489 /* compute maximum transfer length */ 490 transfer_max = 491 libusb20_tr_get_max_total_length(xfer); 492 493 if (transfer_max > length) 494 transfer_max = length; 495 496 /* setup bulk or interrupt transfer */ 497 libusb20_tr_setup_bulk(xfer, pbuf, 498 transfer_max, timeout); 499 500 /* start the transfer */ 501 libusb20_tr_start(xfer); 502 503 /* wait for transfer completion */ 504 while (libusb20_dev_process(pdev) == 0) { 505 506 if (libusb20_tr_pending(xfer) == 0) 507 break; 508 509 libusb20_dev_wait_process(pdev, -1); 510 } 511 512 transfer_act = libusb20_tr_get_actual_length(xfer); 513 514 /* update actual length, if any */ 515 if (pactlen != NULL) 516 pactlen[0] += transfer_act; 517 518 /* check transfer status */ 519 retval = libusb20_tr_get_status(xfer); 520 if (retval) 521 break; 522 523 /* check for short transfer */ 524 if (transfer_act != transfer_max) 525 break; 526 527 /* update buffer pointer and length */ 528 pbuf = ((uint8_t *)pbuf) + transfer_max; 529 length = length - transfer_max; 530 531 } while (length != 0); 532 533 return (retval); 534 } 535 536 void 537 libusb20_tr_submit(struct libusb20_transfer *xfer) 538 { 539 if (!xfer->is_opened) { 540 /* transfer is not opened */ 541 return; 542 } 543 if (xfer->is_pending) { 544 /* should not happen */ 545 return; 546 } 547 xfer->is_pending = 1; /* we are pending */ 548 xfer->is_cancel = 0; /* not cancelling */ 549 xfer->is_restart = 0; /* not restarting */ 550 551 xfer->pdev->methods->tr_submit(xfer); 552 return; 553 } 554 555 void 556 libusb20_tr_start(struct libusb20_transfer *xfer) 557 { 558 if (!xfer->is_opened) { 559 /* transfer is not opened */ 560 return; 561 } 562 if (xfer->is_pending) { 563 if (xfer->is_cancel) { 564 /* cancelling - restart */ 565 xfer->is_restart = 1; 566 } 567 /* transfer not pending */ 568 return; 569 } 570 /* get into the callback */ 571 libusb20_tr_callback_wrapper(xfer); 572 return; 573 } 574 575 /* USB device operations */ 576 577 int 578 libusb20_dev_close(struct libusb20_device *pdev) 579 { 580 struct libusb20_transfer *xfer; 581 uint16_t x; 582 int error = 0; 583 584 if (!pdev->is_opened) { 585 return (LIBUSB20_ERROR_OTHER); 586 } 587 for (x = 0; x != pdev->nTransfer; x++) { 588 xfer = pdev->pTransfer + x; 589 590 if (!xfer->is_opened) { 591 /* transfer is not opened */ 592 continue; 593 } 594 595 libusb20_tr_drain(xfer); 596 597 libusb20_tr_close(xfer); 598 } 599 600 if (pdev->pTransfer != NULL) { 601 free(pdev->pTransfer); 602 pdev->pTransfer = NULL; 603 } 604 error = pdev->beMethods->close_device(pdev); 605 606 pdev->methods = &libusb20_dummy_methods; 607 608 pdev->is_opened = 0; 609 610 /* 611 * The following variable is only used by the libusb v0.1 612 * compat layer: 613 */ 614 pdev->claimed_interface = 0; 615 616 /* 617 * The following variable is only used by the libusb v1.0 618 * compat layer: 619 */ 620 pdev->auto_detach = 0; 621 622 return (error); 623 } 624 625 int 626 libusb20_dev_detach_kernel_driver(struct libusb20_device *pdev, uint8_t ifaceIndex) 627 { 628 int error; 629 630 error = pdev->methods->detach_kernel_driver(pdev, ifaceIndex); 631 return (error); 632 } 633 634 struct LIBUSB20_DEVICE_DESC_DECODED * 635 libusb20_dev_get_device_desc(struct libusb20_device *pdev) 636 { 637 return (&(pdev->ddesc)); 638 } 639 640 int 641 libusb20_dev_get_fd(struct libusb20_device *pdev) 642 { 643 return (pdev->file); 644 } 645 646 int 647 libusb20_dev_kernel_driver_active(struct libusb20_device *pdev, uint8_t ifaceIndex) 648 { 649 int error; 650 651 error = pdev->methods->kernel_driver_active(pdev, ifaceIndex); 652 return (error); 653 } 654 655 int 656 libusb20_dev_open(struct libusb20_device *pdev, uint16_t nTransferMax) 657 { 658 struct libusb20_transfer *xfer; 659 uint32_t size; 660 uint16_t x; 661 int error; 662 663 if (pdev->is_opened) { 664 return (LIBUSB20_ERROR_BUSY); 665 } 666 if (nTransferMax >= 256) { 667 return (LIBUSB20_ERROR_INVALID_PARAM); 668 } else if (nTransferMax != 0) { 669 size = sizeof(pdev->pTransfer[0]) * nTransferMax; 670 pdev->pTransfer = malloc(size); 671 if (pdev->pTransfer == NULL) { 672 return (LIBUSB20_ERROR_NO_MEM); 673 } 674 memset(pdev->pTransfer, 0, size); 675 } 676 /* initialise all transfers */ 677 for (x = 0; x != nTransferMax; x++) { 678 679 xfer = pdev->pTransfer + x; 680 681 xfer->pdev = pdev; 682 xfer->trIndex = x; 683 xfer->callback = &dummy_callback; 684 } 685 686 /* set "nTransfer" early */ 687 pdev->nTransfer = nTransferMax; 688 689 error = pdev->beMethods->open_device(pdev, nTransferMax); 690 691 if (error) { 692 if (pdev->pTransfer != NULL) { 693 free(pdev->pTransfer); 694 pdev->pTransfer = NULL; 695 } 696 pdev->file = -1; 697 pdev->file_ctrl = -1; 698 pdev->nTransfer = 0; 699 } else { 700 pdev->is_opened = 1; 701 } 702 return (error); 703 } 704 705 int 706 libusb20_dev_reset(struct libusb20_device *pdev) 707 { 708 int error; 709 710 error = pdev->methods->reset_device(pdev); 711 return (error); 712 } 713 714 int 715 libusb20_dev_check_connected(struct libusb20_device *pdev) 716 { 717 int error; 718 719 error = pdev->methods->check_connected(pdev); 720 return (error); 721 } 722 723 int 724 libusb20_dev_set_power_mode(struct libusb20_device *pdev, uint8_t power_mode) 725 { 726 int error; 727 728 error = pdev->methods->set_power_mode(pdev, power_mode); 729 return (error); 730 } 731 732 uint8_t 733 libusb20_dev_get_power_mode(struct libusb20_device *pdev) 734 { 735 int error; 736 uint8_t power_mode; 737 738 error = pdev->methods->get_power_mode(pdev, &power_mode); 739 if (error) 740 power_mode = LIBUSB20_POWER_ON; /* fake power mode */ 741 return (power_mode); 742 } 743 744 int 745 libusb20_dev_get_port_path(struct libusb20_device *pdev, uint8_t *buf, uint8_t bufsize) 746 { 747 748 if (pdev->port_level == 0) { 749 /* 750 * Fallback for backends without port path: 751 */ 752 if (bufsize < 2) 753 return (LIBUSB20_ERROR_OVERFLOW); 754 buf[0] = pdev->parent_address; 755 buf[1] = pdev->parent_port; 756 return (2); 757 } 758 759 /* check if client buffer is too small */ 760 if (pdev->port_level > bufsize) 761 return (LIBUSB20_ERROR_OVERFLOW); 762 763 /* copy port number information */ 764 memcpy(buf, pdev->port_path, pdev->port_level); 765 766 return (pdev->port_level); /* success */ 767 } 768 769 uint16_t 770 libusb20_dev_get_power_usage(struct libusb20_device *pdev) 771 { 772 int error; 773 uint16_t power_usage; 774 775 error = pdev->methods->get_power_usage(pdev, &power_usage); 776 if (error) 777 power_usage = 0; 778 return (power_usage); 779 } 780 781 int 782 libusb20_dev_set_alt_index(struct libusb20_device *pdev, uint8_t ifaceIndex, uint8_t altIndex) 783 { 784 int error; 785 786 error = pdev->methods->set_alt_index(pdev, ifaceIndex, altIndex); 787 return (error); 788 } 789 790 int 791 libusb20_dev_set_config_index(struct libusb20_device *pdev, uint8_t configIndex) 792 { 793 int error; 794 795 error = pdev->methods->set_config_index(pdev, configIndex); 796 return (error); 797 } 798 799 int 800 libusb20_dev_request_sync(struct libusb20_device *pdev, 801 struct LIBUSB20_CONTROL_SETUP_DECODED *setup, void *data, 802 uint16_t *pactlen, uint32_t timeout, uint8_t flags) 803 { 804 int error; 805 806 error = pdev->methods->do_request_sync(pdev, 807 setup, data, pactlen, timeout, flags); 808 return (error); 809 } 810 811 int 812 libusb20_dev_req_string_sync(struct libusb20_device *pdev, 813 uint8_t str_index, uint16_t langid, void *ptr, uint16_t len) 814 { 815 struct LIBUSB20_CONTROL_SETUP_DECODED req; 816 int error; 817 int flags; 818 819 /* make sure memory is initialised */ 820 memset(ptr, 0, len); 821 822 if (len < 4) { 823 /* invalid length */ 824 return (LIBUSB20_ERROR_INVALID_PARAM); 825 } 826 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req); 827 828 /* 829 * We need to read the USB string in two steps else some USB 830 * devices will complain. 831 */ 832 req.bmRequestType = 833 LIBUSB20_REQUEST_TYPE_STANDARD | 834 LIBUSB20_RECIPIENT_DEVICE | 835 LIBUSB20_ENDPOINT_IN; 836 req.bRequest = LIBUSB20_REQUEST_GET_DESCRIPTOR; 837 req.wValue = (LIBUSB20_DT_STRING << 8) | str_index; 838 req.wIndex = langid; 839 req.wLength = 4; /* bytes */ 840 841 error = libusb20_dev_request_sync(pdev, &req, 842 ptr, NULL, 1000, LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK); 843 if (error) { 844 /* try to request full string */ 845 req.wLength = 255; 846 flags = 0; 847 } else { 848 /* extract length and request full string */ 849 req.wLength = *(uint8_t *)ptr; 850 flags = LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK; 851 } 852 if (req.wLength > len) { 853 /* partial string read */ 854 req.wLength = len; 855 } 856 error = libusb20_dev_request_sync(pdev, &req, ptr, NULL, 1000, flags); 857 if (error) 858 return (error); 859 860 if (((uint8_t *)ptr)[1] != LIBUSB20_DT_STRING) 861 return (LIBUSB20_ERROR_OTHER); 862 return (0); /* success */ 863 } 864 865 int 866 libusb20_dev_req_string_simple_sync(struct libusb20_device *pdev, 867 uint8_t str_index, void *ptr, uint16_t len) 868 { 869 char *buf; 870 int error; 871 uint16_t langid; 872 uint16_t n; 873 uint16_t i; 874 uint16_t c; 875 uint8_t temp[255]; 876 uint8_t swap; 877 878 /* the following code derives from the FreeBSD USB kernel */ 879 880 if ((len < 1) || (ptr == NULL)) { 881 /* too short buffer */ 882 return (LIBUSB20_ERROR_INVALID_PARAM); 883 } 884 error = libusb20_dev_req_string_sync(pdev, 885 0, 0, temp, sizeof(temp)); 886 if (error < 0) { 887 *(uint8_t *)ptr = 0; /* zero terminate */ 888 return (error); 889 } 890 langid = temp[2] | (temp[3] << 8); 891 892 error = libusb20_dev_req_string_sync(pdev, str_index, 893 langid, temp, sizeof(temp)); 894 if (error < 0) { 895 *(uint8_t *)ptr = 0; /* zero terminate */ 896 return (error); 897 } 898 if (temp[0] < 2) { 899 /* string length is too short */ 900 *(uint8_t *)ptr = 0; /* zero terminate */ 901 return (LIBUSB20_ERROR_OTHER); 902 } 903 /* reserve one byte for terminating zero */ 904 len--; 905 906 /* find maximum length */ 907 n = (temp[0] / 2) - 1; 908 if (n > len) { 909 n = len; 910 } 911 /* reset swap state */ 912 swap = 3; 913 914 /* setup output buffer pointer */ 915 buf = ptr; 916 917 /* convert and filter */ 918 for (i = 0; (i != n); i++) { 919 c = temp[(2 * i) + 2] | (temp[(2 * i) + 3] << 8); 920 921 /* convert from Unicode, handle buggy strings */ 922 if (((c & 0xff00) == 0) && (swap & 1)) { 923 /* Little Endian, default */ 924 *buf = c; 925 swap = 1; 926 } else if (((c & 0x00ff) == 0) && (swap & 2)) { 927 /* Big Endian */ 928 *buf = c >> 8; 929 swap = 2; 930 } else { 931 /* skip invalid character */ 932 continue; 933 } 934 /* 935 * Filter by default - we don't allow greater and less than 936 * signs because they might confuse the dmesg printouts! 937 */ 938 if ((*buf == '<') || (*buf == '>') || (!isprint(*buf))) { 939 /* skip invalid character */ 940 continue; 941 } 942 buf++; 943 } 944 *buf = 0; /* zero terminate string */ 945 946 return (0); 947 } 948 949 struct libusb20_config * 950 libusb20_dev_alloc_config(struct libusb20_device *pdev, uint8_t configIndex) 951 { 952 struct libusb20_config *retval = NULL; 953 uint8_t *ptr; 954 uint16_t len; 955 uint8_t do_close; 956 int error; 957 958 /* 959 * Catch invalid configuration descriptor reads early on to 960 * avoid issues with devices that don't check for a valid USB 961 * configuration read request. 962 */ 963 if (configIndex >= pdev->ddesc.bNumConfigurations) 964 return (NULL); 965 966 if (!pdev->is_opened) { 967 error = libusb20_dev_open(pdev, 0); 968 if (error) { 969 return (NULL); 970 } 971 do_close = 1; 972 } else { 973 do_close = 0; 974 } 975 error = pdev->methods->get_config_desc_full(pdev, 976 &ptr, &len, configIndex); 977 978 if (error) { 979 goto done; 980 } 981 /* parse new config descriptor */ 982 retval = libusb20_parse_config_desc(ptr); 983 984 /* free config descriptor */ 985 free(ptr); 986 987 done: 988 if (do_close) { 989 error = libusb20_dev_close(pdev); 990 } 991 return (retval); 992 } 993 994 struct libusb20_device * 995 libusb20_dev_alloc(void) 996 { 997 struct libusb20_device *pdev; 998 999 pdev = malloc(sizeof(*pdev)); 1000 if (pdev == NULL) { 1001 return (NULL); 1002 } 1003 memset(pdev, 0, sizeof(*pdev)); 1004 1005 pdev->file = -1; 1006 pdev->file_ctrl = -1; 1007 pdev->methods = &libusb20_dummy_methods; 1008 return (pdev); 1009 } 1010 1011 uint8_t 1012 libusb20_dev_get_config_index(struct libusb20_device *pdev) 1013 { 1014 int error; 1015 uint8_t cfg_index; 1016 uint8_t do_close; 1017 1018 if (!pdev->is_opened) { 1019 error = libusb20_dev_open(pdev, 0); 1020 if (error == 0) { 1021 do_close = 1; 1022 } else { 1023 do_close = 0; 1024 } 1025 } else { 1026 do_close = 0; 1027 } 1028 1029 error = pdev->methods->get_config_index(pdev, &cfg_index); 1030 if (error) 1031 cfg_index = 0xFF; /* current config index */ 1032 if (do_close) { 1033 if (libusb20_dev_close(pdev)) { 1034 /* ignore */ 1035 } 1036 } 1037 return (cfg_index); 1038 } 1039 1040 uint8_t 1041 libusb20_dev_get_mode(struct libusb20_device *pdev) 1042 { 1043 return (pdev->usb_mode); 1044 } 1045 1046 uint8_t 1047 libusb20_dev_get_speed(struct libusb20_device *pdev) 1048 { 1049 return (pdev->usb_speed); 1050 } 1051 1052 /* if this function returns an error, the device is gone */ 1053 int 1054 libusb20_dev_process(struct libusb20_device *pdev) 1055 { 1056 int error; 1057 1058 error = pdev->methods->process(pdev); 1059 return (error); 1060 } 1061 1062 void 1063 libusb20_dev_wait_process(struct libusb20_device *pdev, int timeout) 1064 { 1065 struct pollfd pfd[1]; 1066 1067 if (!pdev->is_opened) { 1068 return; 1069 } 1070 pfd[0].fd = pdev->file; 1071 pfd[0].events = (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM); 1072 pfd[0].revents = 0; 1073 1074 if (poll(pfd, 1, timeout)) { 1075 /* ignore any error */ 1076 } 1077 return; 1078 } 1079 1080 void 1081 libusb20_dev_free(struct libusb20_device *pdev) 1082 { 1083 if (pdev == NULL) { 1084 /* be NULL safe */ 1085 return; 1086 } 1087 if (pdev->is_opened) { 1088 if (libusb20_dev_close(pdev)) { 1089 /* ignore any errors */ 1090 } 1091 } 1092 free(pdev); 1093 return; 1094 } 1095 1096 int 1097 libusb20_dev_get_info(struct libusb20_device *pdev, 1098 struct usb_device_info *pinfo) 1099 { 1100 if (pinfo == NULL) 1101 return (LIBUSB20_ERROR_INVALID_PARAM); 1102 1103 return (pdev->beMethods->dev_get_info(pdev, pinfo)); 1104 } 1105 1106 const char * 1107 libusb20_dev_get_backend_name(struct libusb20_device *pdev) 1108 { 1109 return (pdev->beMethods->get_backend_name()); 1110 } 1111 1112 const char * 1113 libusb20_dev_get_desc(struct libusb20_device *pdev) 1114 { 1115 return (pdev->usb_desc); 1116 } 1117 1118 void 1119 libusb20_dev_set_debug(struct libusb20_device *pdev, int debug) 1120 { 1121 pdev->debug = debug; 1122 return; 1123 } 1124 1125 int 1126 libusb20_dev_get_debug(struct libusb20_device *pdev) 1127 { 1128 return (pdev->debug); 1129 } 1130 1131 uint8_t 1132 libusb20_dev_get_address(struct libusb20_device *pdev) 1133 { 1134 return (pdev->device_address); 1135 } 1136 1137 uint8_t 1138 libusb20_dev_get_parent_address(struct libusb20_device *pdev) 1139 { 1140 return (pdev->parent_address); 1141 } 1142 1143 uint8_t 1144 libusb20_dev_get_parent_port(struct libusb20_device *pdev) 1145 { 1146 return (pdev->parent_port); 1147 } 1148 1149 uint8_t 1150 libusb20_dev_get_bus_number(struct libusb20_device *pdev) 1151 { 1152 return (pdev->bus_number); 1153 } 1154 1155 int 1156 libusb20_dev_get_iface_desc(struct libusb20_device *pdev, 1157 uint8_t iface_index, char *buf, uint8_t len) 1158 { 1159 if ((buf == NULL) || (len == 0)) 1160 return (LIBUSB20_ERROR_INVALID_PARAM); 1161 1162 buf[0] = 0; /* set default string value */ 1163 1164 return (pdev->beMethods->dev_get_iface_desc( 1165 pdev, iface_index, buf, len)); 1166 } 1167 1168 /* USB backend operations */ 1169 1170 int 1171 libusb20_be_get_dev_quirk(struct libusb20_backend *pbe, 1172 uint16_t quirk_index, struct libusb20_quirk *pq) 1173 { 1174 return (pbe->methods->root_get_dev_quirk(pbe, quirk_index, pq)); 1175 } 1176 1177 int 1178 libusb20_be_get_quirk_name(struct libusb20_backend *pbe, 1179 uint16_t quirk_index, struct libusb20_quirk *pq) 1180 { 1181 return (pbe->methods->root_get_quirk_name(pbe, quirk_index, pq)); 1182 } 1183 1184 int 1185 libusb20_be_add_dev_quirk(struct libusb20_backend *pbe, 1186 struct libusb20_quirk *pq) 1187 { 1188 return (pbe->methods->root_add_dev_quirk(pbe, pq)); 1189 } 1190 1191 int 1192 libusb20_be_remove_dev_quirk(struct libusb20_backend *pbe, 1193 struct libusb20_quirk *pq) 1194 { 1195 return (pbe->methods->root_remove_dev_quirk(pbe, pq)); 1196 } 1197 1198 int 1199 libusb20_be_set_template(struct libusb20_backend *pbe, int temp) 1200 { 1201 return (pbe->methods->root_set_template(pbe, temp)); 1202 } 1203 1204 int 1205 libusb20_be_get_template(struct libusb20_backend *pbe, int *ptemp) 1206 { 1207 int temp; 1208 1209 if (ptemp == NULL) 1210 ptemp = &temp; 1211 1212 return (pbe->methods->root_get_template(pbe, ptemp)); 1213 } 1214 1215 struct libusb20_device * 1216 libusb20_be_device_foreach(struct libusb20_backend *pbe, struct libusb20_device *pdev) 1217 { 1218 if (pbe == NULL) { 1219 pdev = NULL; 1220 } else if (pdev == NULL) { 1221 pdev = TAILQ_FIRST(&(pbe->usb_devs)); 1222 } else { 1223 pdev = TAILQ_NEXT(pdev, dev_entry); 1224 } 1225 return (pdev); 1226 } 1227 1228 struct libusb20_backend * 1229 libusb20_be_alloc(const struct libusb20_backend_methods *methods) 1230 { 1231 struct libusb20_backend *pbe; 1232 1233 pbe = malloc(sizeof(*pbe)); 1234 if (pbe == NULL) { 1235 return (NULL); 1236 } 1237 memset(pbe, 0, sizeof(*pbe)); 1238 1239 TAILQ_INIT(&(pbe->usb_devs)); 1240 1241 pbe->methods = methods; /* set backend methods */ 1242 1243 /* do the initial device scan */ 1244 if (pbe->methods->init_backend) { 1245 pbe->methods->init_backend(pbe); 1246 } 1247 return (pbe); 1248 } 1249 1250 struct libusb20_backend * 1251 libusb20_be_alloc_linux(void) 1252 { 1253 return (NULL); 1254 } 1255 1256 struct libusb20_backend * 1257 libusb20_be_alloc_ugen20(void) 1258 { 1259 return (libusb20_be_alloc(&libusb20_ugen20_backend)); 1260 } 1261 1262 struct libusb20_backend * 1263 libusb20_be_alloc_default(void) 1264 { 1265 struct libusb20_backend *pbe; 1266 1267 #ifdef __linux__ 1268 pbe = libusb20_be_alloc_linux(); 1269 if (pbe) { 1270 return (pbe); 1271 } 1272 #endif 1273 pbe = libusb20_be_alloc_ugen20(); 1274 if (pbe) { 1275 return (pbe); 1276 } 1277 return (NULL); /* no backend found */ 1278 } 1279 1280 void 1281 libusb20_be_free(struct libusb20_backend *pbe) 1282 { 1283 struct libusb20_device *pdev; 1284 1285 if (pbe == NULL) { 1286 /* be NULL safe */ 1287 return; 1288 } 1289 while ((pdev = libusb20_be_device_foreach(pbe, NULL))) { 1290 libusb20_be_dequeue_device(pbe, pdev); 1291 libusb20_dev_free(pdev); 1292 } 1293 if (pbe->methods->exit_backend) { 1294 pbe->methods->exit_backend(pbe); 1295 } 1296 /* free backend */ 1297 free(pbe); 1298 } 1299 1300 void 1301 libusb20_be_enqueue_device(struct libusb20_backend *pbe, struct libusb20_device *pdev) 1302 { 1303 pdev->beMethods = pbe->methods; /* copy backend methods */ 1304 TAILQ_INSERT_TAIL(&(pbe->usb_devs), pdev, dev_entry); 1305 } 1306 1307 void 1308 libusb20_be_dequeue_device(struct libusb20_backend *pbe, 1309 struct libusb20_device *pdev) 1310 { 1311 TAILQ_REMOVE(&(pbe->usb_devs), pdev, dev_entry); 1312 } 1313 1314 const char * 1315 libusb20_strerror(int code) 1316 { 1317 switch (code) { 1318 case LIBUSB20_SUCCESS: 1319 return ("Success"); 1320 case LIBUSB20_ERROR_IO: 1321 return ("I/O error"); 1322 case LIBUSB20_ERROR_INVALID_PARAM: 1323 return ("Invalid parameter"); 1324 case LIBUSB20_ERROR_ACCESS: 1325 return ("Permissions error"); 1326 case LIBUSB20_ERROR_NO_DEVICE: 1327 return ("No device"); 1328 case LIBUSB20_ERROR_NOT_FOUND: 1329 return ("Not found"); 1330 case LIBUSB20_ERROR_BUSY: 1331 return ("Device busy"); 1332 case LIBUSB20_ERROR_TIMEOUT: 1333 return ("Timeout"); 1334 case LIBUSB20_ERROR_OVERFLOW: 1335 return ("Overflow"); 1336 case LIBUSB20_ERROR_PIPE: 1337 return ("Pipe error"); 1338 case LIBUSB20_ERROR_INTERRUPTED: 1339 return ("Interrupted"); 1340 case LIBUSB20_ERROR_NO_MEM: 1341 return ("Out of memory"); 1342 case LIBUSB20_ERROR_NOT_SUPPORTED: 1343 return ("Not supported"); 1344 case LIBUSB20_ERROR_OTHER: 1345 return ("Other error"); 1346 default: 1347 return ("Unknown error"); 1348 } 1349 } 1350 1351 const char * 1352 libusb20_error_name(int code) 1353 { 1354 switch (code) { 1355 case LIBUSB20_SUCCESS: 1356 return ("LIBUSB20_SUCCESS"); 1357 case LIBUSB20_ERROR_IO: 1358 return ("LIBUSB20_ERROR_IO"); 1359 case LIBUSB20_ERROR_INVALID_PARAM: 1360 return ("LIBUSB20_ERROR_INVALID_PARAM"); 1361 case LIBUSB20_ERROR_ACCESS: 1362 return ("LIBUSB20_ERROR_ACCESS"); 1363 case LIBUSB20_ERROR_NO_DEVICE: 1364 return ("LIBUSB20_ERROR_NO_DEVICE"); 1365 case LIBUSB20_ERROR_NOT_FOUND: 1366 return ("LIBUSB20_ERROR_NOT_FOUND"); 1367 case LIBUSB20_ERROR_BUSY: 1368 return ("LIBUSB20_ERROR_BUSY"); 1369 case LIBUSB20_ERROR_TIMEOUT: 1370 return ("LIBUSB20_ERROR_TIMEOUT"); 1371 case LIBUSB20_ERROR_OVERFLOW: 1372 return ("LIBUSB20_ERROR_OVERFLOW"); 1373 case LIBUSB20_ERROR_PIPE: 1374 return ("LIBUSB20_ERROR_PIPE"); 1375 case LIBUSB20_ERROR_INTERRUPTED: 1376 return ("LIBUSB20_ERROR_INTERRUPTED"); 1377 case LIBUSB20_ERROR_NO_MEM: 1378 return ("LIBUSB20_ERROR_NO_MEM"); 1379 case LIBUSB20_ERROR_NOT_SUPPORTED: 1380 return ("LIBUSB20_ERROR_NOT_SUPPORTED"); 1381 case LIBUSB20_ERROR_OTHER: 1382 return ("LIBUSB20_ERROR_OTHER"); 1383 default: 1384 return ("LIBUSB20_ERROR_UNKNOWN"); 1385 } 1386 } 1387