1 /* $FreeBSD$ */ 2 /*- 3 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 4 * 5 * Copyright (c) 2008 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 /* 30 * This file contains the emulation layer for LibUSB v0.1 from sourceforge. 31 */ 32 33 #ifdef LIBUSB_GLOBAL_INCLUDE_FILE 34 #include LIBUSB_GLOBAL_INCLUDE_FILE 35 #else 36 #include <errno.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <string.h> 40 #include <time.h> 41 #include <sys/queue.h> 42 #endif 43 44 #include "libusb20.h" 45 #include "libusb20_desc.h" 46 #include "libusb20_int.h" 47 #include "usb.h" 48 49 /* 50 * The two following macros were taken from the original LibUSB v0.1 51 * for sake of compatibility: 52 */ 53 #define LIST_ADD(begin, ent) \ 54 do { \ 55 if (begin) { \ 56 ent->next = begin; \ 57 ent->next->prev = ent; \ 58 } else { \ 59 ent->next = NULL; \ 60 } \ 61 ent->prev = NULL; \ 62 begin = ent; \ 63 } while(0) 64 65 #define LIST_DEL(begin, ent) \ 66 do { \ 67 if (ent->prev) { \ 68 ent->prev->next = ent->next; \ 69 } else { \ 70 begin = ent->next; \ 71 } \ 72 if (ent->next) { \ 73 ent->next->prev = ent->prev; \ 74 } \ 75 ent->prev = NULL; \ 76 ent->next = NULL; \ 77 } while (0) 78 79 struct usb_bus *usb_busses = NULL; 80 81 static struct usb_bus usb_global_bus = { 82 .dirname = {"/dev/usb"}, 83 .root_dev = NULL, 84 .devices = NULL, 85 }; 86 87 static struct libusb20_backend *usb_backend = NULL; 88 89 struct usb_parse_state { 90 91 struct { 92 struct libusb20_endpoint *currep; 93 struct libusb20_interface *currifc; 94 struct libusb20_config *currcfg; 95 struct libusb20_me_struct *currextra; 96 } a; 97 98 struct { 99 struct usb_config_descriptor *currcfg; 100 struct usb_interface_descriptor *currifc; 101 struct usb_endpoint_descriptor *currep; 102 struct usb_interface *currifcw; 103 uint8_t *currextra; 104 } b; 105 106 uint8_t preparse; 107 }; 108 109 static struct libusb20_transfer * 110 usb_get_transfer_by_ep_no(usb_dev_handle * dev, uint8_t ep_no) 111 { 112 struct libusb20_device *pdev = (void *)dev; 113 struct libusb20_transfer *xfer; 114 int err; 115 uint32_t bufsize; 116 uint8_t x; 117 uint8_t speed; 118 119 x = (ep_no & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 2; 120 121 if (ep_no & LIBUSB20_ENDPOINT_DIR_MASK) { 122 /* this is an IN endpoint */ 123 x |= 1; 124 } 125 speed = libusb20_dev_get_speed(pdev); 126 127 /* select a sensible buffer size */ 128 if (speed == LIBUSB20_SPEED_LOW) { 129 bufsize = 256; 130 } else if (speed == LIBUSB20_SPEED_FULL) { 131 bufsize = 4096; 132 } else if (speed == LIBUSB20_SPEED_SUPER) { 133 bufsize = 65536; 134 } else { 135 bufsize = 16384; 136 } 137 138 xfer = libusb20_tr_get_pointer(pdev, x); 139 140 if (xfer == NULL) 141 return (xfer); 142 143 err = libusb20_tr_open(xfer, bufsize, 1, ep_no); 144 if (err == LIBUSB20_ERROR_BUSY) { 145 /* already opened */ 146 return (xfer); 147 } else if (err) { 148 return (NULL); 149 } 150 /* success */ 151 return (xfer); 152 } 153 154 usb_dev_handle * 155 usb_open(struct usb_device *dev) 156 { 157 int err; 158 159 err = libusb20_dev_open(dev->dev, 16 * 2); 160 if (err == LIBUSB20_ERROR_BUSY) { 161 /* 162 * Workaround buggy USB applications which open the USB 163 * device multiple times: 164 */ 165 return (dev->dev); 166 } 167 if (err) 168 return (NULL); 169 170 /* 171 * Dequeue USB device from backend queue so that it does not get 172 * freed when the backend is re-scanned: 173 */ 174 libusb20_be_dequeue_device(usb_backend, dev->dev); 175 176 return (dev->dev); 177 } 178 179 int 180 usb_close(usb_dev_handle * udev) 181 { 182 struct usb_device *dev; 183 int err; 184 185 err = libusb20_dev_close((void *)udev); 186 187 if (err) 188 return (-1); 189 190 if (usb_backend != NULL) { 191 /* 192 * Enqueue USB device to backend queue so that it gets freed 193 * when the backend is re-scanned: 194 */ 195 libusb20_be_enqueue_device(usb_backend, (void *)udev); 196 } else { 197 /* 198 * The backend is gone. Free device data so that we 199 * don't start leaking memory! 200 */ 201 dev = usb_device(udev); 202 libusb20_dev_free((void *)udev); 203 LIST_DEL(usb_global_bus.devices, dev); 204 free(dev); 205 } 206 return (0); 207 } 208 209 int 210 usb_get_string(usb_dev_handle * dev, int strindex, 211 int langid, char *buf, size_t buflen) 212 { 213 int err; 214 215 if (dev == NULL) 216 return (-1); 217 218 if (buflen > 65535) 219 buflen = 65535; 220 221 err = libusb20_dev_req_string_sync((void *)dev, 222 strindex, langid, buf, buflen); 223 224 if (err) 225 return (-1); 226 227 return (0); 228 } 229 230 int 231 usb_get_string_simple(usb_dev_handle * dev, int strindex, 232 char *buf, size_t buflen) 233 { 234 int err; 235 236 if (dev == NULL) 237 return (-1); 238 239 if (buflen > 65535) 240 buflen = 65535; 241 242 err = libusb20_dev_req_string_simple_sync((void *)dev, 243 strindex, buf, buflen); 244 245 if (err) 246 return (-1); 247 248 return (strlen(buf)); 249 } 250 251 int 252 usb_get_descriptor_by_endpoint(usb_dev_handle * udev, int ep, uint8_t type, 253 uint8_t ep_index, void *buf, int size) 254 { 255 memset(buf, 0, size); 256 257 if (udev == NULL) 258 return (-1); 259 260 if (size > 65535) 261 size = 65535; 262 263 return (usb_control_msg(udev, ep | USB_ENDPOINT_IN, 264 USB_REQ_GET_DESCRIPTOR, (type << 8) + ep_index, 0, 265 buf, size, 1000)); 266 } 267 268 int 269 usb_get_descriptor(usb_dev_handle * udev, uint8_t type, uint8_t desc_index, 270 void *buf, int size) 271 { 272 memset(buf, 0, size); 273 274 if (udev == NULL) 275 return (-1); 276 277 if (size > 65535) 278 size = 65535; 279 280 return (usb_control_msg(udev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR, 281 (type << 8) + desc_index, 0, buf, size, 1000)); 282 } 283 284 int 285 usb_parse_descriptor(uint8_t *source, char *description, void *dest) 286 { 287 uint8_t *sp = source; 288 uint8_t *dp = dest; 289 uint16_t w; 290 uint32_t d; 291 char *cp; 292 293 for (cp = description; *cp; cp++) { 294 switch (*cp) { 295 case 'b': /* 8-bit byte */ 296 *dp++ = *sp++; 297 break; 298 /* 299 * 16-bit word, convert from little endian to CPU 300 */ 301 case 'w': 302 w = (sp[1] << 8) | sp[0]; 303 sp += 2; 304 /* Align to word boundary */ 305 dp += ((dp - (uint8_t *)0) & 1); 306 *((uint16_t *)dp) = w; 307 dp += 2; 308 break; 309 /* 310 * 32-bit dword, convert from little endian to CPU 311 */ 312 case 'd': 313 d = (sp[3] << 24) | (sp[2] << 16) | 314 (sp[1] << 8) | sp[0]; 315 sp += 4; 316 /* Align to word boundary */ 317 dp += ((dp - (uint8_t *)0) & 1); 318 /* Align to double word boundary */ 319 dp += ((dp - (uint8_t *)0) & 2); 320 *((uint32_t *)dp) = d; 321 dp += 4; 322 break; 323 } 324 } 325 return (sp - source); 326 } 327 328 static void 329 usb_parse_extra(struct usb_parse_state *ps, uint8_t **pptr, int *plen) 330 { 331 void *ptr; 332 uint16_t len; 333 334 ptr = ps->a.currextra->ptr; 335 len = ps->a.currextra->len; 336 337 if (ps->preparse == 0) { 338 memcpy(ps->b.currextra, ptr, len); 339 *pptr = ps->b.currextra; 340 *plen = len; 341 } 342 ps->b.currextra += len; 343 return; 344 } 345 346 static void 347 usb_parse_endpoint(struct usb_parse_state *ps) 348 { 349 struct usb_endpoint_descriptor *bep; 350 struct libusb20_endpoint *aep; 351 352 aep = ps->a.currep; 353 bep = ps->b.currep++; 354 355 if (ps->preparse == 0) { 356 /* copy descriptor fields */ 357 bep->bLength = aep->desc.bLength; 358 bep->bDescriptorType = aep->desc.bDescriptorType; 359 bep->bEndpointAddress = aep->desc.bEndpointAddress; 360 bep->bmAttributes = aep->desc.bmAttributes; 361 bep->wMaxPacketSize = aep->desc.wMaxPacketSize; 362 bep->bInterval = aep->desc.bInterval; 363 bep->bRefresh = aep->desc.bRefresh; 364 bep->bSynchAddress = aep->desc.bSynchAddress; 365 } 366 ps->a.currextra = &aep->extra; 367 usb_parse_extra(ps, &bep->extra, &bep->extralen); 368 return; 369 } 370 371 static void 372 usb_parse_iface_sub(struct usb_parse_state *ps) 373 { 374 struct libusb20_interface *aifc; 375 struct usb_interface_descriptor *bifc; 376 uint8_t x; 377 378 aifc = ps->a.currifc; 379 bifc = ps->b.currifc++; 380 381 if (ps->preparse == 0) { 382 /* copy descriptor fields */ 383 bifc->bLength = aifc->desc.bLength; 384 bifc->bDescriptorType = aifc->desc.bDescriptorType; 385 bifc->bInterfaceNumber = aifc->desc.bInterfaceNumber; 386 bifc->bAlternateSetting = aifc->desc.bAlternateSetting; 387 bifc->bNumEndpoints = aifc->num_endpoints; 388 bifc->bInterfaceClass = aifc->desc.bInterfaceClass; 389 bifc->bInterfaceSubClass = aifc->desc.bInterfaceSubClass; 390 bifc->bInterfaceProtocol = aifc->desc.bInterfaceProtocol; 391 bifc->iInterface = aifc->desc.iInterface; 392 bifc->endpoint = ps->b.currep; 393 } 394 for (x = 0; x != aifc->num_endpoints; x++) { 395 ps->a.currep = aifc->endpoints + x; 396 usb_parse_endpoint(ps); 397 } 398 399 ps->a.currextra = &aifc->extra; 400 usb_parse_extra(ps, &bifc->extra, &bifc->extralen); 401 return; 402 } 403 404 static void 405 usb_parse_iface(struct usb_parse_state *ps) 406 { 407 struct libusb20_interface *aifc; 408 struct usb_interface *bifc; 409 uint8_t x; 410 411 aifc = ps->a.currifc; 412 bifc = ps->b.currifcw++; 413 414 if (ps->preparse == 0) { 415 /* initialise interface wrapper */ 416 bifc->altsetting = ps->b.currifc; 417 bifc->num_altsetting = aifc->num_altsetting + 1; 418 } 419 usb_parse_iface_sub(ps); 420 421 for (x = 0; x != aifc->num_altsetting; x++) { 422 ps->a.currifc = aifc->altsetting + x; 423 usb_parse_iface_sub(ps); 424 } 425 return; 426 } 427 428 static void 429 usb_parse_config(struct usb_parse_state *ps) 430 { 431 struct libusb20_config *acfg; 432 struct usb_config_descriptor *bcfg; 433 uint8_t x; 434 435 acfg = ps->a.currcfg; 436 bcfg = ps->b.currcfg; 437 438 if (ps->preparse == 0) { 439 /* initialise config wrapper */ 440 bcfg->bLength = acfg->desc.bLength; 441 bcfg->bDescriptorType = acfg->desc.bDescriptorType; 442 bcfg->wTotalLength = acfg->desc.wTotalLength; 443 bcfg->bNumInterfaces = acfg->num_interface; 444 bcfg->bConfigurationValue = acfg->desc.bConfigurationValue; 445 bcfg->iConfiguration = acfg->desc.iConfiguration; 446 bcfg->bmAttributes = acfg->desc.bmAttributes; 447 bcfg->MaxPower = acfg->desc.bMaxPower; 448 bcfg->interface = ps->b.currifcw; 449 } 450 for (x = 0; x != acfg->num_interface; x++) { 451 ps->a.currifc = acfg->interface + x; 452 usb_parse_iface(ps); 453 } 454 455 ps->a.currextra = &acfg->extra; 456 usb_parse_extra(ps, &bcfg->extra, &bcfg->extralen); 457 return; 458 } 459 460 int 461 usb_parse_configuration(struct usb_config_descriptor *config, 462 uint8_t *buffer) 463 { 464 struct usb_parse_state ps; 465 uint8_t *ptr; 466 uint32_t a; 467 uint32_t b; 468 uint32_t c; 469 uint32_t d; 470 471 if ((buffer == NULL) || (config == NULL)) { 472 return (-1); 473 } 474 memset(&ps, 0, sizeof(ps)); 475 476 ps.a.currcfg = libusb20_parse_config_desc(buffer); 477 ps.b.currcfg = config; 478 if (ps.a.currcfg == NULL) { 479 /* could not parse config or out of memory */ 480 return (-1); 481 } 482 /* do the pre-parse */ 483 ps.preparse = 1; 484 usb_parse_config(&ps); 485 486 a = ((uint8_t *)(ps.b.currifcw) - ((uint8_t *)0)); 487 b = ((uint8_t *)(ps.b.currifc) - ((uint8_t *)0)); 488 c = ((uint8_t *)(ps.b.currep) - ((uint8_t *)0)); 489 d = ((uint8_t *)(ps.b.currextra) - ((uint8_t *)0)); 490 491 /* allocate memory for our configuration */ 492 ptr = malloc(a + b + c + d); 493 if (ptr == NULL) { 494 /* free config structure */ 495 free(ps.a.currcfg); 496 return (-1); 497 } 498 499 /* "currifcw" must be first, hence this pointer is freed */ 500 ps.b.currifcw = (void *)(ptr); 501 ps.b.currifc = (void *)(ptr + a); 502 ps.b.currep = (void *)(ptr + a + b); 503 ps.b.currextra = (void *)(ptr + a + b + c); 504 505 /* generate a libusb v0.1 compatible structure */ 506 ps.preparse = 0; 507 usb_parse_config(&ps); 508 509 /* free config structure */ 510 free(ps.a.currcfg); 511 512 return (0); /* success */ 513 } 514 515 void 516 usb_destroy_configuration(struct usb_device *dev) 517 { 518 uint8_t c; 519 520 if (dev->config == NULL) { 521 return; 522 } 523 for (c = 0; c != dev->descriptor.bNumConfigurations; c++) { 524 struct usb_config_descriptor *cf = &dev->config[c]; 525 526 if (cf->interface != NULL) { 527 free(cf->interface); 528 cf->interface = NULL; 529 } 530 } 531 532 free(dev->config); 533 dev->config = NULL; 534 return; 535 } 536 537 void 538 usb_fetch_and_parse_descriptors(usb_dev_handle * udev) 539 { 540 struct usb_device *dev; 541 struct libusb20_device *pdev; 542 uint8_t *ptr; 543 int error; 544 uint32_t size; 545 uint16_t len; 546 uint8_t x; 547 548 if (udev == NULL) { 549 /* be NULL safe */ 550 return; 551 } 552 dev = usb_device(udev); 553 pdev = (void *)udev; 554 555 if (dev->descriptor.bNumConfigurations == 0) { 556 /* invalid device */ 557 return; 558 } 559 size = dev->descriptor.bNumConfigurations * 560 sizeof(struct usb_config_descriptor); 561 562 dev->config = malloc(size); 563 if (dev->config == NULL) { 564 /* out of memory */ 565 return; 566 } 567 memset(dev->config, 0, size); 568 569 for (x = 0; x != dev->descriptor.bNumConfigurations; x++) { 570 571 error = (pdev->methods->get_config_desc_full) ( 572 pdev, &ptr, &len, x); 573 574 if (error) { 575 usb_destroy_configuration(dev); 576 return; 577 } 578 usb_parse_configuration(dev->config + x, ptr); 579 580 /* free config buffer */ 581 free(ptr); 582 } 583 return; 584 } 585 586 static int 587 usb_std_io(usb_dev_handle * dev, int ep, char *bytes, int size, 588 int timeout, int is_intr) 589 { 590 struct libusb20_transfer *xfer; 591 uint32_t temp; 592 uint32_t maxsize; 593 uint32_t actlen; 594 char *oldbytes; 595 596 xfer = usb_get_transfer_by_ep_no(dev, ep); 597 if (xfer == NULL) 598 return (-1); 599 600 if (libusb20_tr_pending(xfer)) { 601 /* there is already a transfer ongoing */ 602 return (-1); 603 } 604 maxsize = libusb20_tr_get_max_total_length(xfer); 605 oldbytes = bytes; 606 607 /* 608 * We allow transferring zero bytes which is the same 609 * equivalent to a zero length USB packet. 610 */ 611 do { 612 613 temp = size; 614 if (temp > maxsize) { 615 /* find maximum possible length */ 616 temp = maxsize; 617 } 618 if (is_intr) 619 libusb20_tr_setup_intr(xfer, bytes, temp, timeout); 620 else 621 libusb20_tr_setup_bulk(xfer, bytes, temp, timeout); 622 623 libusb20_tr_start(xfer); 624 625 while (1) { 626 627 if (libusb20_dev_process((void *)dev) != 0) { 628 /* device detached */ 629 return (-1); 630 } 631 if (libusb20_tr_pending(xfer) == 0) { 632 /* transfer complete */ 633 break; 634 } 635 /* wait for USB event from kernel */ 636 libusb20_dev_wait_process((void *)dev, -1); 637 } 638 639 switch (libusb20_tr_get_status(xfer)) { 640 case 0: 641 /* success */ 642 break; 643 case LIBUSB20_TRANSFER_TIMED_OUT: 644 /* transfer timeout */ 645 return (-ETIMEDOUT); 646 default: 647 /* other transfer error */ 648 return (-ENXIO); 649 } 650 actlen = libusb20_tr_get_actual_length(xfer); 651 652 bytes += actlen; 653 size -= actlen; 654 655 if (actlen != temp) { 656 /* short transfer */ 657 break; 658 } 659 } while (size > 0); 660 661 return (bytes - oldbytes); 662 } 663 664 int 665 usb_bulk_write(usb_dev_handle * dev, int ep, char *bytes, 666 int size, int timeout) 667 { 668 return (usb_std_io(dev, ep & ~USB_ENDPOINT_DIR_MASK, 669 bytes, size, timeout, 0)); 670 } 671 672 int 673 usb_bulk_read(usb_dev_handle * dev, int ep, char *bytes, 674 int size, int timeout) 675 { 676 return (usb_std_io(dev, ep | USB_ENDPOINT_DIR_MASK, 677 bytes, size, timeout, 0)); 678 } 679 680 int 681 usb_interrupt_write(usb_dev_handle * dev, int ep, char *bytes, 682 int size, int timeout) 683 { 684 return (usb_std_io(dev, ep & ~USB_ENDPOINT_DIR_MASK, 685 bytes, size, timeout, 1)); 686 } 687 688 int 689 usb_interrupt_read(usb_dev_handle * dev, int ep, char *bytes, 690 int size, int timeout) 691 { 692 return (usb_std_io(dev, ep | USB_ENDPOINT_DIR_MASK, 693 bytes, size, timeout, 1)); 694 } 695 696 int 697 usb_control_msg(usb_dev_handle * dev, int requesttype, int request, 698 int value, int wIndex, char *bytes, int size, int timeout) 699 { 700 struct LIBUSB20_CONTROL_SETUP_DECODED req; 701 int err; 702 uint16_t actlen; 703 704 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req); 705 706 req.bmRequestType = requesttype; 707 req.bRequest = request; 708 req.wValue = value; 709 req.wIndex = wIndex; 710 req.wLength = size; 711 712 err = libusb20_dev_request_sync((void *)dev, &req, bytes, 713 &actlen, timeout, 0); 714 715 if (err) 716 return (-1); 717 718 return (actlen); 719 } 720 721 int 722 usb_set_configuration(usb_dev_handle * udev, int bConfigurationValue) 723 { 724 struct usb_device *dev; 725 int err; 726 uint8_t i; 727 728 /* 729 * Need to translate from "bConfigurationValue" to 730 * configuration index: 731 */ 732 733 if (bConfigurationValue == 0) { 734 /* unconfigure */ 735 i = 255; 736 } else { 737 /* lookup configuration index */ 738 dev = usb_device(udev); 739 740 /* check if the configuration array is not there */ 741 if (dev->config == NULL) { 742 return (-1); 743 } 744 for (i = 0;; i++) { 745 if (i == dev->descriptor.bNumConfigurations) { 746 /* "bConfigurationValue" not found */ 747 return (-1); 748 } 749 if ((dev->config + i)->bConfigurationValue == 750 bConfigurationValue) { 751 break; 752 } 753 } 754 } 755 756 err = libusb20_dev_set_config_index((void *)udev, i); 757 758 if (err) 759 return (-1); 760 761 return (0); 762 } 763 764 int 765 usb_claim_interface(usb_dev_handle * dev, int interface) 766 { 767 struct libusb20_device *pdev = (void *)dev; 768 769 pdev->claimed_interface = interface; 770 771 return (0); 772 } 773 774 int 775 usb_release_interface(usb_dev_handle * dev, int interface) 776 { 777 /* do nothing */ 778 return (0); 779 } 780 781 int 782 usb_set_altinterface(usb_dev_handle * dev, int alternate) 783 { 784 struct libusb20_device *pdev = (void *)dev; 785 int err; 786 uint8_t iface; 787 788 iface = pdev->claimed_interface; 789 790 err = libusb20_dev_set_alt_index((void *)dev, iface, alternate); 791 792 if (err) 793 return (-1); 794 795 return (0); 796 } 797 798 int 799 usb_resetep(usb_dev_handle * dev, unsigned int ep) 800 { 801 /* emulate an endpoint reset through clear-STALL */ 802 return (usb_clear_halt(dev, ep)); 803 } 804 805 int 806 usb_clear_halt(usb_dev_handle * dev, unsigned int ep) 807 { 808 struct libusb20_transfer *xfer; 809 810 xfer = usb_get_transfer_by_ep_no(dev, ep); 811 if (xfer == NULL) 812 return (-1); 813 814 libusb20_tr_clear_stall_sync(xfer); 815 816 return (0); 817 } 818 819 int 820 usb_reset(usb_dev_handle * dev) 821 { 822 int err; 823 824 err = libusb20_dev_reset((void *)dev); 825 826 if (err) 827 return (-1); 828 829 /* 830 * Be compatible with LibUSB from sourceforge and close the 831 * handle after reset! 832 */ 833 return (usb_close(dev)); 834 } 835 836 int 837 usb_check_connected(usb_dev_handle * dev) 838 { 839 int err; 840 841 err = libusb20_dev_check_connected((void *)dev); 842 843 if (err) 844 return (-1); 845 846 return (0); 847 } 848 849 const char * 850 usb_strerror(void) 851 { 852 /* TODO */ 853 return ("Unknown error"); 854 } 855 856 void 857 usb_init(void) 858 { 859 /* nothing to do */ 860 return; 861 } 862 863 void 864 usb_set_debug(int level) 865 { 866 /* use kernel UGEN debugging if you need to see what is going on */ 867 return; 868 } 869 870 int 871 usb_find_busses(void) 872 { 873 usb_busses = &usb_global_bus; 874 return (1); 875 } 876 877 int 878 usb_find_devices(void) 879 { 880 struct libusb20_device *pdev; 881 struct usb_device *udev; 882 struct LIBUSB20_DEVICE_DESC_DECODED *ddesc; 883 int devnum; 884 int err; 885 886 /* cleanup after last device search */ 887 /* close all opened devices, if any */ 888 889 while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) { 890 udev = pdev->privLuData; 891 libusb20_be_dequeue_device(usb_backend, pdev); 892 libusb20_dev_free(pdev); 893 if (udev != NULL) { 894 LIST_DEL(usb_global_bus.devices, udev); 895 free(udev); 896 } 897 } 898 899 /* free old USB backend, if any */ 900 901 libusb20_be_free(usb_backend); 902 903 /* do a new backend device search */ 904 usb_backend = libusb20_be_alloc_default(); 905 if (usb_backend == NULL) { 906 return (-1); 907 } 908 /* iterate all devices */ 909 910 devnum = 1; 911 pdev = NULL; 912 while ((pdev = libusb20_be_device_foreach(usb_backend, pdev))) { 913 udev = malloc(sizeof(*udev)); 914 if (udev == NULL) 915 break; 916 917 memset(udev, 0, sizeof(*udev)); 918 919 udev->bus = &usb_global_bus; 920 921 snprintf(udev->filename, sizeof(udev->filename), 922 "/dev/ugen%u.%u", 923 libusb20_dev_get_bus_number(pdev), 924 libusb20_dev_get_address(pdev)); 925 926 ddesc = libusb20_dev_get_device_desc(pdev); 927 928 udev->descriptor.bLength = sizeof(udev->descriptor); 929 udev->descriptor.bDescriptorType = ddesc->bDescriptorType; 930 udev->descriptor.bcdUSB = ddesc->bcdUSB; 931 udev->descriptor.bDeviceClass = ddesc->bDeviceClass; 932 udev->descriptor.bDeviceSubClass = ddesc->bDeviceSubClass; 933 udev->descriptor.bDeviceProtocol = ddesc->bDeviceProtocol; 934 udev->descriptor.bMaxPacketSize0 = ddesc->bMaxPacketSize0; 935 udev->descriptor.idVendor = ddesc->idVendor; 936 udev->descriptor.idProduct = ddesc->idProduct; 937 udev->descriptor.bcdDevice = ddesc->bcdDevice; 938 udev->descriptor.iManufacturer = ddesc->iManufacturer; 939 udev->descriptor.iProduct = ddesc->iProduct; 940 udev->descriptor.iSerialNumber = ddesc->iSerialNumber; 941 udev->descriptor.bNumConfigurations = 942 ddesc->bNumConfigurations; 943 if (udev->descriptor.bNumConfigurations > USB_MAXCONFIG) { 944 /* truncate number of configurations */ 945 udev->descriptor.bNumConfigurations = USB_MAXCONFIG; 946 } 947 udev->devnum = devnum++; 948 /* link together the two structures */ 949 udev->dev = pdev; 950 pdev->privLuData = udev; 951 952 err = libusb20_dev_open(pdev, 0); 953 if (err == 0) { 954 /* XXX get all config descriptors by default */ 955 usb_fetch_and_parse_descriptors((void *)pdev); 956 libusb20_dev_close(pdev); 957 } 958 LIST_ADD(usb_global_bus.devices, udev); 959 } 960 961 return (devnum - 1); /* success */ 962 } 963 964 struct usb_device * 965 usb_device(usb_dev_handle * dev) 966 { 967 struct libusb20_device *pdev; 968 969 pdev = (void *)dev; 970 971 return (pdev->privLuData); 972 } 973 974 struct usb_bus * 975 usb_get_busses(void) 976 { 977 return (usb_busses); 978 } 979 980 int 981 usb_get_driver_np(usb_dev_handle * dev, int interface, char *name, int namelen) 982 { 983 struct libusb20_device *pdev; 984 char *ptr; 985 int err; 986 987 pdev = (void *)dev; 988 989 if (pdev == NULL) 990 return (-1); 991 if (namelen < 1) 992 return (-1); 993 if (namelen > 255) 994 namelen = 255; 995 996 err = libusb20_dev_get_iface_desc(pdev, interface, name, namelen); 997 if (err != 0) 998 return (-1); 999 1000 /* we only want the driver name */ 1001 ptr = strstr(name, ":"); 1002 if (ptr != NULL) 1003 *ptr = 0; 1004 1005 return (0); 1006 } 1007 1008 int 1009 usb_detach_kernel_driver_np(usb_dev_handle * dev, int interface) 1010 { 1011 struct libusb20_device *pdev; 1012 int err; 1013 1014 pdev = (void *)dev; 1015 1016 if (pdev == NULL) 1017 return (-1); 1018 1019 err = libusb20_dev_detach_kernel_driver(pdev, interface); 1020 if (err != 0) 1021 return (-1); 1022 1023 return (0); 1024 } 1025