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