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