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