1 /* $FreeBSD: src/lib/libusb/libusb20_ugen20.c,v 1.13 2012/04/20 14:29:45 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 #include <sys/queue.h> 28 #include <sys/types.h> 29 30 #include <errno.h> 31 #include <fcntl.h> 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <string.h> 35 #include <unistd.h> 36 37 #include "libusb20.h" 38 #include "libusb20_desc.h" 39 #include "libusb20_int.h" 40 41 #include <bus/u4b/usb.h> 42 #include <bus/u4b/usbdi.h> 43 #include <bus/u4b/usb_ioctl.h> 44 45 static libusb20_init_backend_t ugen20_init_backend; 46 static libusb20_open_device_t ugen20_open_device; 47 static libusb20_close_device_t ugen20_close_device; 48 static libusb20_get_backend_name_t ugen20_get_backend_name; 49 static libusb20_exit_backend_t ugen20_exit_backend; 50 static libusb20_dev_get_iface_desc_t ugen20_dev_get_iface_desc; 51 static libusb20_dev_get_info_t ugen20_dev_get_info; 52 static libusb20_root_get_dev_quirk_t ugen20_root_get_dev_quirk; 53 static libusb20_root_get_quirk_name_t ugen20_root_get_quirk_name; 54 static libusb20_root_add_dev_quirk_t ugen20_root_add_dev_quirk; 55 static libusb20_root_remove_dev_quirk_t ugen20_root_remove_dev_quirk; 56 static libusb20_root_set_template_t ugen20_root_set_template; 57 static libusb20_root_get_template_t ugen20_root_get_template; 58 59 const struct libusb20_backend_methods libusb20_ugen20_backend = { 60 LIBUSB20_BACKEND(LIBUSB20_DECLARE, ugen20) 61 }; 62 63 /* USB device specific */ 64 static libusb20_get_config_desc_full_t ugen20_get_config_desc_full; 65 static libusb20_get_config_index_t ugen20_get_config_index; 66 static libusb20_set_config_index_t ugen20_set_config_index; 67 static libusb20_set_alt_index_t ugen20_set_alt_index; 68 static libusb20_reset_device_t ugen20_reset_device; 69 static libusb20_check_connected_t ugen20_check_connected; 70 static libusb20_set_power_mode_t ugen20_set_power_mode; 71 static libusb20_get_power_mode_t ugen20_get_power_mode; 72 static libusb20_kernel_driver_active_t ugen20_kernel_driver_active; 73 static libusb20_detach_kernel_driver_t ugen20_detach_kernel_driver; 74 static libusb20_do_request_sync_t ugen20_do_request_sync; 75 static libusb20_process_t ugen20_process; 76 77 /* USB transfer specific */ 78 static libusb20_tr_open_t ugen20_tr_open; 79 static libusb20_tr_close_t ugen20_tr_close; 80 static libusb20_tr_clear_stall_sync_t ugen20_tr_clear_stall_sync; 81 static libusb20_tr_submit_t ugen20_tr_submit; 82 static libusb20_tr_cancel_async_t ugen20_tr_cancel_async; 83 84 static const struct libusb20_device_methods libusb20_ugen20_device_methods = { 85 LIBUSB20_DEVICE(LIBUSB20_DECLARE, ugen20) 86 }; 87 88 static const char * 89 ugen20_get_backend_name(void) 90 { 91 return ("FreeBSD UGEN 2.0"); 92 } 93 94 static uint32_t 95 ugen20_path_convert_one(const char **pp) 96 { 97 const char *ptr; 98 uint32_t temp = 0; 99 100 ptr = *pp; 101 102 while ((*ptr >= '0') && (*ptr <= '9')) { 103 temp *= 10; 104 temp += (*ptr - '0'); 105 if (temp >= 1000000) { 106 /* catch overflow early */ 107 return (0xFFFFFFFF); 108 } 109 ptr++; 110 } 111 112 if (*ptr == '.') { 113 /* skip dot */ 114 ptr++; 115 } 116 *pp = ptr; 117 118 return (temp); 119 } 120 121 static int 122 ugen20_enumerate(struct libusb20_device *pdev, const char *id) 123 { 124 const char *tmp = id; 125 struct usb_device_descriptor ddesc; 126 struct usb_device_info devinfo; 127 uint32_t plugtime; 128 char buf[64]; 129 int f; 130 int error; 131 132 pdev->bus_number = ugen20_path_convert_one(&tmp); 133 pdev->device_address = ugen20_path_convert_one(&tmp); 134 135 snprintf(buf, sizeof(buf), "/dev/" USB_GENERIC_NAME "%u.%u", 136 pdev->bus_number, pdev->device_address); 137 138 f = open(buf, O_RDWR); 139 if (f < 0) { 140 return (LIBUSB20_ERROR_OTHER); 141 } 142 if (ioctl(f, USB_GET_PLUGTIME, &plugtime)) { 143 error = LIBUSB20_ERROR_OTHER; 144 goto done; 145 } 146 /* store when the device was plugged */ 147 pdev->session_data.plugtime = plugtime; 148 149 if (ioctl(f, USB_GET_DEVICE_DESC, &ddesc)) { 150 error = LIBUSB20_ERROR_OTHER; 151 goto done; 152 } 153 LIBUSB20_INIT(LIBUSB20_DEVICE_DESC, &(pdev->ddesc)); 154 155 libusb20_me_decode(&ddesc, sizeof(ddesc), &(pdev->ddesc)); 156 157 if (pdev->ddesc.bNumConfigurations == 0) { 158 error = LIBUSB20_ERROR_OTHER; 159 goto done; 160 } else if (pdev->ddesc.bNumConfigurations >= 8) { 161 error = LIBUSB20_ERROR_OTHER; 162 goto done; 163 } 164 if (ioctl(f, USB_GET_DEVICEINFO, &devinfo)) { 165 error = LIBUSB20_ERROR_OTHER; 166 goto done; 167 } 168 switch (devinfo.udi_mode) { 169 case USB_MODE_DEVICE: 170 pdev->usb_mode = LIBUSB20_MODE_DEVICE; 171 break; 172 default: 173 pdev->usb_mode = LIBUSB20_MODE_HOST; 174 break; 175 } 176 177 switch (devinfo.udi_speed) { 178 case USB_SPEED_LOW: 179 pdev->usb_speed = LIBUSB20_SPEED_LOW; 180 break; 181 case USB_SPEED_FULL: 182 pdev->usb_speed = LIBUSB20_SPEED_FULL; 183 break; 184 case USB_SPEED_HIGH: 185 pdev->usb_speed = LIBUSB20_SPEED_HIGH; 186 break; 187 case USB_SPEED_VARIABLE: 188 pdev->usb_speed = LIBUSB20_SPEED_VARIABLE; 189 break; 190 case USB_SPEED_SUPER: 191 pdev->usb_speed = LIBUSB20_SPEED_SUPER; 192 break; 193 default: 194 pdev->usb_speed = LIBUSB20_SPEED_UNKNOWN; 195 break; 196 } 197 198 /* get parent HUB index and port */ 199 200 pdev->parent_address = devinfo.udi_hubindex; 201 pdev->parent_port = devinfo.udi_hubport; 202 203 /* generate a nice description for printout */ 204 205 snprintf(pdev->usb_desc, sizeof(pdev->usb_desc), 206 USB_GENERIC_NAME "%u.%u: <%s %s> at usbus%u", pdev->bus_number, 207 pdev->device_address, devinfo.udi_product, 208 devinfo.udi_vendor, pdev->bus_number); 209 210 error = 0; 211 done: 212 close(f); 213 return (error); 214 } 215 216 struct ugen20_urd_state { 217 struct usb_read_dir urd; 218 uint32_t nparsed; 219 int f; 220 uint8_t *ptr; 221 const char *src; 222 const char *dst; 223 uint8_t buf[256]; 224 uint8_t dummy_zero[1]; 225 }; 226 227 static int 228 ugen20_readdir(struct ugen20_urd_state *st) 229 { 230 ; /* style fix */ 231 repeat: 232 if (st->ptr == NULL) { 233 st->urd.urd_startentry += st->nparsed; 234 st->urd.urd_data = libusb20_pass_ptr(st->buf); 235 st->urd.urd_maxlen = sizeof(st->buf); 236 st->nparsed = 0; 237 238 if (ioctl(st->f, USB_READ_DIR, &st->urd)) { 239 return (EINVAL); 240 } 241 st->ptr = st->buf; 242 } 243 if (st->ptr[0] == 0) { 244 if (st->nparsed) { 245 st->ptr = NULL; 246 goto repeat; 247 } else { 248 return (ENXIO); 249 } 250 } 251 st->src = (void *)(st->ptr + 1); 252 st->dst = st->src + strlen(st->src) + 1; 253 st->ptr = st->ptr + st->ptr[0]; 254 st->nparsed++; 255 256 if ((st->ptr < st->buf) || 257 (st->ptr > st->dummy_zero)) { 258 /* invalid entry */ 259 return (EINVAL); 260 } 261 return (0); 262 } 263 264 static int 265 ugen20_init_backend(struct libusb20_backend *pbe) 266 { 267 struct ugen20_urd_state state; 268 struct libusb20_device *pdev; 269 270 memset(&state, 0, sizeof(state)); 271 272 state.f = open("/dev/" USB_DEVICE_NAME, O_RDONLY); 273 if (state.f < 0) 274 return (LIBUSB20_ERROR_OTHER); 275 276 while (ugen20_readdir(&state) == 0) { 277 278 if ((state.src[0] != 'u') || 279 (state.src[1] != 'g') || 280 (state.src[2] != 'e') || 281 (state.src[3] != 'n')) { 282 continue; 283 } 284 pdev = libusb20_dev_alloc(); 285 if (pdev == NULL) { 286 continue; 287 } 288 if (ugen20_enumerate(pdev, state.src + 4)) { 289 libusb20_dev_free(pdev); 290 continue; 291 } 292 /* put the device on the backend list */ 293 libusb20_be_enqueue_device(pbe, pdev); 294 } 295 close(state.f); 296 return (0); /* success */ 297 } 298 299 static void 300 ugen20_tr_release(struct libusb20_device *pdev) 301 { 302 struct usb_fs_uninit fs_uninit; 303 304 if (pdev->nTransfer == 0) { 305 return; 306 } 307 /* release all pending USB transfers */ 308 if (pdev->privBeData != NULL) { 309 memset(&fs_uninit, 0, sizeof(fs_uninit)); 310 if (ioctl(pdev->file, USB_FS_UNINIT, &fs_uninit)) { 311 /* ignore any errors of this kind */ 312 } 313 } 314 return; 315 } 316 317 static int 318 ugen20_tr_renew(struct libusb20_device *pdev) 319 { 320 struct usb_fs_init fs_init; 321 struct usb_fs_endpoint *pfse; 322 int error; 323 uint32_t size; 324 uint16_t nMaxTransfer; 325 326 nMaxTransfer = pdev->nTransfer; 327 error = 0; 328 329 if (nMaxTransfer == 0) { 330 goto done; 331 } 332 size = nMaxTransfer * sizeof(*pfse); 333 334 if (pdev->privBeData == NULL) { 335 pfse = malloc(size); 336 if (pfse == NULL) { 337 error = LIBUSB20_ERROR_NO_MEM; 338 goto done; 339 } 340 pdev->privBeData = pfse; 341 } 342 /* reset endpoint data */ 343 memset(pdev->privBeData, 0, size); 344 345 memset(&fs_init, 0, sizeof(fs_init)); 346 347 fs_init.pEndpoints = libusb20_pass_ptr(pdev->privBeData); 348 fs_init.ep_index_max = nMaxTransfer; 349 350 if (ioctl(pdev->file, USB_FS_INIT, &fs_init)) { 351 error = LIBUSB20_ERROR_OTHER; 352 goto done; 353 } 354 done: 355 return (error); 356 } 357 358 static int 359 ugen20_open_device(struct libusb20_device *pdev, uint16_t nMaxTransfer) 360 { 361 uint32_t plugtime; 362 char buf[64]; 363 int f; 364 int g; 365 int error; 366 367 snprintf(buf, sizeof(buf), "/dev/" USB_GENERIC_NAME "%u.%u", 368 pdev->bus_number, pdev->device_address); 369 370 /* 371 * We need two file handles, one for the control endpoint and one 372 * for BULK, INTERRUPT and ISOCHRONOUS transactions due to optimised 373 * kernel locking. 374 */ 375 g = open(buf, O_RDWR); 376 if (g < 0) { 377 return (LIBUSB20_ERROR_NO_DEVICE); 378 } 379 f = open(buf, O_RDWR); 380 if (f < 0) { 381 close(g); 382 return (LIBUSB20_ERROR_NO_DEVICE); 383 } 384 if (ioctl(f, USB_GET_PLUGTIME, &plugtime)) { 385 error = LIBUSB20_ERROR_OTHER; 386 goto done; 387 } 388 /* check that the correct device is still plugged */ 389 if (pdev->session_data.plugtime != plugtime) { 390 error = LIBUSB20_ERROR_NO_DEVICE; 391 goto done; 392 } 393 /* need to set this before "tr_renew()" */ 394 pdev->file = f; 395 pdev->file_ctrl = g; 396 397 /* renew all USB transfers */ 398 error = ugen20_tr_renew(pdev); 399 if (error) { 400 goto done; 401 } 402 /* set methods */ 403 pdev->methods = &libusb20_ugen20_device_methods; 404 405 done: 406 if (error) { 407 if (pdev->privBeData) { 408 /* cleanup after "tr_renew()" */ 409 free(pdev->privBeData); 410 pdev->privBeData = NULL; 411 } 412 pdev->file = -1; 413 pdev->file_ctrl = -1; 414 close(f); 415 close(g); 416 } 417 return (error); 418 } 419 420 static int 421 ugen20_close_device(struct libusb20_device *pdev) 422 { 423 struct usb_fs_uninit fs_uninit; 424 425 if (pdev->privBeData) { 426 memset(&fs_uninit, 0, sizeof(fs_uninit)); 427 if (ioctl(pdev->file, USB_FS_UNINIT, &fs_uninit)) { 428 /* ignore this error */ 429 } 430 free(pdev->privBeData); 431 } 432 pdev->nTransfer = 0; 433 pdev->privBeData = NULL; 434 close(pdev->file); 435 close(pdev->file_ctrl); 436 pdev->file = -1; 437 pdev->file_ctrl = -1; 438 return (0); /* success */ 439 } 440 441 static void 442 ugen20_exit_backend(struct libusb20_backend *pbe) 443 { 444 return; /* nothing to do */ 445 } 446 447 static int 448 ugen20_get_config_desc_full(struct libusb20_device *pdev, 449 uint8_t **ppbuf, uint16_t *plen, uint8_t cfg_index) 450 { 451 struct usb_gen_descriptor gen_desc; 452 struct usb_config_descriptor cdesc; 453 uint8_t *ptr; 454 uint16_t len; 455 int error; 456 457 /* make sure memory is initialised */ 458 memset(&cdesc, 0, sizeof(cdesc)); 459 memset(&gen_desc, 0, sizeof(gen_desc)); 460 461 gen_desc.ugd_data = libusb20_pass_ptr(&cdesc); 462 gen_desc.ugd_maxlen = sizeof(cdesc); 463 gen_desc.ugd_config_index = cfg_index; 464 465 error = ioctl(pdev->file_ctrl, USB_GET_FULL_DESC, &gen_desc); 466 if (error) { 467 return (LIBUSB20_ERROR_OTHER); 468 } 469 len = UGETW(cdesc.wTotalLength); 470 if (len < sizeof(cdesc)) { 471 /* corrupt descriptor */ 472 return (LIBUSB20_ERROR_OTHER); 473 } 474 ptr = malloc(len); 475 if (!ptr) { 476 return (LIBUSB20_ERROR_NO_MEM); 477 } 478 479 /* make sure memory is initialised */ 480 memset(ptr, 0, len); 481 482 gen_desc.ugd_data = libusb20_pass_ptr(ptr); 483 gen_desc.ugd_maxlen = len; 484 485 error = ioctl(pdev->file_ctrl, USB_GET_FULL_DESC, &gen_desc); 486 if (error) { 487 free(ptr); 488 return (LIBUSB20_ERROR_OTHER); 489 } 490 /* make sure that the device doesn't fool us */ 491 memcpy(ptr, &cdesc, sizeof(cdesc)); 492 493 *ppbuf = ptr; 494 *plen = len; 495 496 return (0); /* success */ 497 } 498 499 static int 500 ugen20_get_config_index(struct libusb20_device *pdev, uint8_t *pindex) 501 { 502 int temp; 503 504 if (ioctl(pdev->file_ctrl, USB_GET_CONFIG, &temp)) { 505 return (LIBUSB20_ERROR_OTHER); 506 } 507 *pindex = temp; 508 509 return (0); 510 } 511 512 static int 513 ugen20_set_config_index(struct libusb20_device *pdev, uint8_t cfg_index) 514 { 515 int temp = cfg_index; 516 517 /* release all active USB transfers */ 518 ugen20_tr_release(pdev); 519 520 if (ioctl(pdev->file_ctrl, USB_SET_CONFIG, &temp)) { 521 return (LIBUSB20_ERROR_OTHER); 522 } 523 return (ugen20_tr_renew(pdev)); 524 } 525 526 static int 527 ugen20_set_alt_index(struct libusb20_device *pdev, 528 uint8_t iface_index, uint8_t alt_index) 529 { 530 struct usb_alt_interface alt_iface; 531 532 memset(&alt_iface, 0, sizeof(alt_iface)); 533 534 alt_iface.uai_interface_index = iface_index; 535 alt_iface.uai_alt_index = alt_index; 536 537 /* release all active USB transfers */ 538 ugen20_tr_release(pdev); 539 540 if (ioctl(pdev->file_ctrl, USB_SET_ALTINTERFACE, &alt_iface)) { 541 return (LIBUSB20_ERROR_OTHER); 542 } 543 return (ugen20_tr_renew(pdev)); 544 } 545 546 static int 547 ugen20_reset_device(struct libusb20_device *pdev) 548 { 549 int temp = 0; 550 551 /* release all active USB transfers */ 552 ugen20_tr_release(pdev); 553 554 if (ioctl(pdev->file_ctrl, USB_DEVICEENUMERATE, &temp)) { 555 return (LIBUSB20_ERROR_OTHER); 556 } 557 return (ugen20_tr_renew(pdev)); 558 } 559 560 static int 561 ugen20_check_connected(struct libusb20_device *pdev) 562 { 563 uint32_t plugtime; 564 int error = 0; 565 566 if (ioctl(pdev->file_ctrl, USB_GET_PLUGTIME, &plugtime)) { 567 error = LIBUSB20_ERROR_NO_DEVICE; 568 goto done; 569 } 570 571 if (pdev->session_data.plugtime != plugtime) { 572 error = LIBUSB20_ERROR_NO_DEVICE; 573 goto done; 574 } 575 done: 576 return (error); 577 } 578 579 static int 580 ugen20_set_power_mode(struct libusb20_device *pdev, uint8_t power_mode) 581 { 582 int temp; 583 584 switch (power_mode) { 585 case LIBUSB20_POWER_OFF: 586 temp = USB_POWER_MODE_OFF; 587 break; 588 case LIBUSB20_POWER_ON: 589 temp = USB_POWER_MODE_ON; 590 break; 591 case LIBUSB20_POWER_SAVE: 592 temp = USB_POWER_MODE_SAVE; 593 break; 594 case LIBUSB20_POWER_SUSPEND: 595 temp = USB_POWER_MODE_SUSPEND; 596 break; 597 case LIBUSB20_POWER_RESUME: 598 temp = USB_POWER_MODE_RESUME; 599 break; 600 default: 601 return (LIBUSB20_ERROR_INVALID_PARAM); 602 } 603 if (ioctl(pdev->file_ctrl, USB_SET_POWER_MODE, &temp)) { 604 return (LIBUSB20_ERROR_OTHER); 605 } 606 return (0); 607 } 608 609 static int 610 ugen20_get_power_mode(struct libusb20_device *pdev, uint8_t *power_mode) 611 { 612 int temp; 613 614 if (ioctl(pdev->file_ctrl, USB_GET_POWER_MODE, &temp)) { 615 return (LIBUSB20_ERROR_OTHER); 616 } 617 switch (temp) { 618 case USB_POWER_MODE_OFF: 619 temp = LIBUSB20_POWER_OFF; 620 break; 621 case USB_POWER_MODE_ON: 622 temp = LIBUSB20_POWER_ON; 623 break; 624 case USB_POWER_MODE_SAVE: 625 temp = LIBUSB20_POWER_SAVE; 626 break; 627 case USB_POWER_MODE_SUSPEND: 628 temp = LIBUSB20_POWER_SUSPEND; 629 break; 630 case USB_POWER_MODE_RESUME: 631 temp = LIBUSB20_POWER_RESUME; 632 break; 633 default: 634 temp = LIBUSB20_POWER_ON; 635 break; 636 } 637 *power_mode = temp; 638 return (0); /* success */ 639 } 640 641 static int 642 ugen20_kernel_driver_active(struct libusb20_device *pdev, 643 uint8_t iface_index) 644 { 645 int temp = iface_index; 646 647 if (ioctl(pdev->file_ctrl, USB_IFACE_DRIVER_ACTIVE, &temp)) { 648 return (LIBUSB20_ERROR_OTHER); 649 } 650 return (0); /* kernel driver is active */ 651 } 652 653 static int 654 ugen20_detach_kernel_driver(struct libusb20_device *pdev, 655 uint8_t iface_index) 656 { 657 int temp = iface_index; 658 659 if (ioctl(pdev->file_ctrl, USB_IFACE_DRIVER_DETACH, &temp)) { 660 return (LIBUSB20_ERROR_OTHER); 661 } 662 return (0); /* kernel driver is active */ 663 } 664 665 static int 666 ugen20_do_request_sync(struct libusb20_device *pdev, 667 struct LIBUSB20_CONTROL_SETUP_DECODED *setup, 668 void *data, uint16_t *pactlen, uint32_t timeout, uint8_t flags) 669 { 670 struct usb_ctl_request req; 671 672 memset(&req, 0, sizeof(req)); 673 674 req.ucr_data = libusb20_pass_ptr(data); 675 if (!(flags & LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK)) { 676 req.ucr_flags |= USB_SHORT_XFER_OK; 677 } 678 if (libusb20_me_encode(&req.ucr_request, 679 sizeof(req.ucr_request), setup)) { 680 /* ignore */ 681 } 682 if (ioctl(pdev->file_ctrl, USB_DO_REQUEST, &req)) { 683 return (LIBUSB20_ERROR_OTHER); 684 } 685 if (pactlen) { 686 /* get actual length */ 687 *pactlen = req.ucr_actlen; 688 } 689 return (0); /* kernel driver is active */ 690 } 691 692 static int 693 ugen20_process(struct libusb20_device *pdev) 694 { 695 struct usb_fs_complete temp; 696 struct usb_fs_endpoint *fsep; 697 struct libusb20_transfer *xfer; 698 699 while (1) { 700 701 if (ioctl(pdev->file, USB_FS_COMPLETE, &temp)) { 702 if (errno == EBUSY) { 703 break; 704 } else { 705 /* device detached */ 706 return (LIBUSB20_ERROR_OTHER); 707 } 708 } 709 fsep = pdev->privBeData; 710 xfer = pdev->pTransfer; 711 fsep += temp.ep_index; 712 xfer += temp.ep_index; 713 714 /* update transfer status */ 715 716 if (fsep->status == 0) { 717 xfer->aFrames = fsep->aFrames; 718 xfer->timeComplete = fsep->isoc_time_complete; 719 xfer->status = LIBUSB20_TRANSFER_COMPLETED; 720 } else if (fsep->status == USB_ERR_CANCELLED) { 721 xfer->aFrames = 0; 722 xfer->timeComplete = 0; 723 xfer->status = LIBUSB20_TRANSFER_CANCELLED; 724 } else if (fsep->status == USB_ERR_STALLED) { 725 xfer->aFrames = 0; 726 xfer->timeComplete = 0; 727 xfer->status = LIBUSB20_TRANSFER_STALL; 728 } else if (fsep->status == USB_ERR_TIMEOUT) { 729 xfer->aFrames = 0; 730 xfer->timeComplete = 0; 731 xfer->status = LIBUSB20_TRANSFER_TIMED_OUT; 732 } else { 733 xfer->aFrames = 0; 734 xfer->timeComplete = 0; 735 xfer->status = LIBUSB20_TRANSFER_ERROR; 736 } 737 libusb20_tr_callback_wrapper(xfer); 738 } 739 return (0); /* done */ 740 } 741 742 static int 743 ugen20_tr_open(struct libusb20_transfer *xfer, uint32_t MaxBufSize, 744 uint32_t MaxFrameCount, uint8_t ep_no, uint8_t pre_scale) 745 { 746 struct usb_fs_open temp; 747 struct usb_fs_endpoint *fsep; 748 749 if (pre_scale) 750 MaxFrameCount |= USB_FS_MAX_FRAMES_PRE_SCALE; 751 752 memset(&temp, 0, sizeof(temp)); 753 754 fsep = xfer->pdev->privBeData; 755 fsep += xfer->trIndex; 756 757 temp.max_bufsize = MaxBufSize; 758 temp.max_frames = MaxFrameCount; 759 temp.ep_index = xfer->trIndex; 760 temp.ep_no = ep_no; 761 762 if (ioctl(xfer->pdev->file, USB_FS_OPEN, &temp)) { 763 return (LIBUSB20_ERROR_INVALID_PARAM); 764 } 765 /* maximums might have changed - update */ 766 xfer->maxFrames = temp.max_frames; 767 768 /* "max_bufsize" should be multiple of "max_packet_length" */ 769 xfer->maxTotalLength = temp.max_bufsize; 770 xfer->maxPacketLen = temp.max_packet_length; 771 772 /* setup buffer and length lists using zero copy */ 773 fsep->ppBuffer = libusb20_pass_ptr(xfer->ppBuffer); 774 fsep->pLength = libusb20_pass_ptr(xfer->pLength); 775 776 return (0); /* success */ 777 } 778 779 static int 780 ugen20_tr_close(struct libusb20_transfer *xfer) 781 { 782 struct usb_fs_close temp; 783 784 memset(&temp, 0, sizeof(temp)); 785 786 temp.ep_index = xfer->trIndex; 787 788 if (ioctl(xfer->pdev->file, USB_FS_CLOSE, &temp)) { 789 return (LIBUSB20_ERROR_INVALID_PARAM); 790 } 791 return (0); /* success */ 792 } 793 794 static int 795 ugen20_tr_clear_stall_sync(struct libusb20_transfer *xfer) 796 { 797 struct usb_fs_clear_stall_sync temp; 798 799 memset(&temp, 0, sizeof(temp)); 800 801 /* if the transfer is active, an error will be returned */ 802 803 temp.ep_index = xfer->trIndex; 804 805 if (ioctl(xfer->pdev->file, USB_FS_CLEAR_STALL_SYNC, &temp)) { 806 return (LIBUSB20_ERROR_INVALID_PARAM); 807 } 808 return (0); /* success */ 809 } 810 811 static void 812 ugen20_tr_submit(struct libusb20_transfer *xfer) 813 { 814 struct usb_fs_start temp; 815 struct usb_fs_endpoint *fsep; 816 817 memset(&temp, 0, sizeof(temp)); 818 819 fsep = xfer->pdev->privBeData; 820 fsep += xfer->trIndex; 821 822 fsep->nFrames = xfer->nFrames; 823 fsep->flags = 0; 824 if (!(xfer->flags & LIBUSB20_TRANSFER_SINGLE_SHORT_NOT_OK)) { 825 fsep->flags |= USB_FS_FLAG_SINGLE_SHORT_OK; 826 } 827 if (!(xfer->flags & LIBUSB20_TRANSFER_MULTI_SHORT_NOT_OK)) { 828 fsep->flags |= USB_FS_FLAG_MULTI_SHORT_OK; 829 } 830 if (xfer->flags & LIBUSB20_TRANSFER_FORCE_SHORT) { 831 fsep->flags |= USB_FS_FLAG_FORCE_SHORT; 832 } 833 if (xfer->flags & LIBUSB20_TRANSFER_DO_CLEAR_STALL) { 834 fsep->flags |= USB_FS_FLAG_CLEAR_STALL; 835 } 836 /* NOTE: The "fsep->timeout" variable is 16-bit. */ 837 if (xfer->timeout > 65535) 838 fsep->timeout = 65535; 839 else 840 fsep->timeout = xfer->timeout; 841 842 temp.ep_index = xfer->trIndex; 843 844 if (ioctl(xfer->pdev->file, USB_FS_START, &temp)) { 845 /* ignore any errors - should never happen */ 846 } 847 return; /* success */ 848 } 849 850 static void 851 ugen20_tr_cancel_async(struct libusb20_transfer *xfer) 852 { 853 struct usb_fs_stop temp; 854 855 memset(&temp, 0, sizeof(temp)); 856 857 temp.ep_index = xfer->trIndex; 858 859 if (ioctl(xfer->pdev->file, USB_FS_STOP, &temp)) { 860 /* ignore any errors - should never happen */ 861 } 862 return; 863 } 864 865 static int 866 ugen20_be_ioctl(uint32_t cmd, void *data) 867 { 868 int f; 869 int error; 870 871 f = open("/dev/" USB_DEVICE_NAME, O_RDONLY); 872 if (f < 0) 873 return (LIBUSB20_ERROR_OTHER); 874 error = ioctl(f, cmd, data); 875 if (error == -1) { 876 if (errno == EPERM) { 877 error = LIBUSB20_ERROR_ACCESS; 878 } else { 879 error = LIBUSB20_ERROR_OTHER; 880 } 881 } 882 close(f); 883 return (error); 884 } 885 886 static int 887 ugen20_dev_get_iface_desc(struct libusb20_device *pdev, 888 uint8_t iface_index, char *buf, uint8_t len) 889 { 890 struct usb_gen_descriptor ugd; 891 892 memset(&ugd, 0, sizeof(ugd)); 893 894 ugd.ugd_data = libusb20_pass_ptr(buf); 895 ugd.ugd_maxlen = len; 896 ugd.ugd_iface_index = iface_index; 897 898 if (ioctl(pdev->file, USB_GET_IFACE_DRIVER, &ugd)) { 899 return (LIBUSB20_ERROR_INVALID_PARAM); 900 } 901 return (0); 902 } 903 904 static int 905 ugen20_dev_get_info(struct libusb20_device *pdev, 906 struct usb_device_info *pinfo) 907 { 908 if (ioctl(pdev->file, USB_GET_DEVICEINFO, pinfo)) { 909 return (LIBUSB20_ERROR_INVALID_PARAM); 910 } 911 return (0); 912 } 913 914 static int 915 ugen20_root_get_dev_quirk(struct libusb20_backend *pbe, 916 uint16_t quirk_index, struct libusb20_quirk *pq) 917 { 918 struct usb_gen_quirk q; 919 int error; 920 921 memset(&q, 0, sizeof(q)); 922 923 q.index = quirk_index; 924 925 error = ugen20_be_ioctl(USB_DEV_QUIRK_GET, &q); 926 927 if (error) { 928 if (errno == EINVAL) { 929 return (LIBUSB20_ERROR_NOT_FOUND); 930 } 931 } else { 932 pq->vid = q.vid; 933 pq->pid = q.pid; 934 pq->bcdDeviceLow = q.bcdDeviceLow; 935 pq->bcdDeviceHigh = q.bcdDeviceHigh; 936 strlcpy(pq->quirkname, q.quirkname, sizeof(pq->quirkname)); 937 } 938 return (error); 939 } 940 941 static int 942 ugen20_root_get_quirk_name(struct libusb20_backend *pbe, uint16_t quirk_index, 943 struct libusb20_quirk *pq) 944 { 945 struct usb_gen_quirk q; 946 int error; 947 948 memset(&q, 0, sizeof(q)); 949 950 q.index = quirk_index; 951 952 error = ugen20_be_ioctl(USB_QUIRK_NAME_GET, &q); 953 954 if (error) { 955 if (errno == EINVAL) { 956 return (LIBUSB20_ERROR_NOT_FOUND); 957 } 958 } else { 959 strlcpy(pq->quirkname, q.quirkname, sizeof(pq->quirkname)); 960 } 961 return (error); 962 } 963 964 static int 965 ugen20_root_add_dev_quirk(struct libusb20_backend *pbe, 966 struct libusb20_quirk *pq) 967 { 968 struct usb_gen_quirk q; 969 int error; 970 971 memset(&q, 0, sizeof(q)); 972 973 q.vid = pq->vid; 974 q.pid = pq->pid; 975 q.bcdDeviceLow = pq->bcdDeviceLow; 976 q.bcdDeviceHigh = pq->bcdDeviceHigh; 977 strlcpy(q.quirkname, pq->quirkname, sizeof(q.quirkname)); 978 979 error = ugen20_be_ioctl(USB_DEV_QUIRK_ADD, &q); 980 if (error) { 981 if (errno == ENOMEM) { 982 return (LIBUSB20_ERROR_NO_MEM); 983 } 984 } 985 return (error); 986 } 987 988 static int 989 ugen20_root_remove_dev_quirk(struct libusb20_backend *pbe, 990 struct libusb20_quirk *pq) 991 { 992 struct usb_gen_quirk q; 993 int error; 994 995 memset(&q, 0, sizeof(q)); 996 997 q.vid = pq->vid; 998 q.pid = pq->pid; 999 q.bcdDeviceLow = pq->bcdDeviceLow; 1000 q.bcdDeviceHigh = pq->bcdDeviceHigh; 1001 strlcpy(q.quirkname, pq->quirkname, sizeof(q.quirkname)); 1002 1003 error = ugen20_be_ioctl(USB_DEV_QUIRK_REMOVE, &q); 1004 if (error) { 1005 if (errno == EINVAL) { 1006 return (LIBUSB20_ERROR_NOT_FOUND); 1007 } 1008 } 1009 return (error); 1010 } 1011 1012 static int 1013 ugen20_root_set_template(struct libusb20_backend *pbe, int temp) 1014 { 1015 return (ugen20_be_ioctl(USB_SET_TEMPLATE, &temp)); 1016 } 1017 1018 static int 1019 ugen20_root_get_template(struct libusb20_backend *pbe, int *ptemp) 1020 { 1021 return (ugen20_be_ioctl(USB_GET_TEMPLATE, ptemp)); 1022 } 1023