1 /* $FreeBSD$ */ 2 /*- 3 * Copyright (c) 2009 Sylvestre Gallon. 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 #ifdef LIBUSB_GLOBAL_INCLUDE_FILE 28 #include LIBUSB_GLOBAL_INCLUDE_FILE 29 #else 30 #include <errno.h> 31 #include <poll.h> 32 #include <pthread.h> 33 #include <stdio.h> 34 #include <stdlib.h> 35 #include <string.h> 36 #include <time.h> 37 #include <unistd.h> 38 #include <sys/queue.h> 39 #include <sys/endian.h> 40 #endif 41 42 #define libusb_device_handle libusb20_device 43 44 #include "libusb20.h" 45 #include "libusb20_desc.h" 46 #include "libusb20_int.h" 47 #include "libusb.h" 48 #include "libusb10.h" 49 50 UNEXPORTED void 51 libusb10_add_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd, 52 struct libusb20_device *pdev, int fd, short events) 53 { 54 if (ctx == NULL) 55 return; /* invalid */ 56 57 if (pollfd->entry.tqe_prev != NULL) 58 return; /* already queued */ 59 60 if (fd < 0) 61 return; /* invalid */ 62 63 pollfd->pdev = pdev; 64 pollfd->pollfd.fd = fd; 65 pollfd->pollfd.events = events; 66 67 CTX_LOCK(ctx); 68 TAILQ_INSERT_TAIL(&ctx->pollfds, pollfd, entry); 69 CTX_UNLOCK(ctx); 70 71 if (ctx->fd_added_cb) 72 ctx->fd_added_cb(fd, events, ctx->fd_cb_user_data); 73 } 74 75 UNEXPORTED void 76 libusb10_remove_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd) 77 { 78 if (ctx == NULL) 79 return; /* invalid */ 80 81 if (pollfd->entry.tqe_prev == NULL) 82 return; /* already dequeued */ 83 84 CTX_LOCK(ctx); 85 TAILQ_REMOVE(&ctx->pollfds, pollfd, entry); 86 pollfd->entry.tqe_prev = NULL; 87 CTX_UNLOCK(ctx); 88 89 if (ctx->fd_removed_cb) 90 ctx->fd_removed_cb(pollfd->pollfd.fd, ctx->fd_cb_user_data); 91 } 92 93 /* This function must be called locked */ 94 95 static int 96 libusb10_handle_events_sub(struct libusb_context *ctx, struct timeval *tv) 97 { 98 struct libusb_device *dev; 99 struct libusb20_device **ppdev; 100 struct libusb_super_pollfd *pfd; 101 struct pollfd *fds; 102 struct libusb_super_transfer *sxfer; 103 struct libusb_transfer *uxfer; 104 nfds_t nfds; 105 int timeout; 106 int i; 107 int err; 108 109 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb10_handle_events_sub enter"); 110 111 nfds = 0; 112 i = 0; 113 TAILQ_FOREACH(pfd, &ctx->pollfds, entry) 114 nfds++; 115 116 fds = alloca(sizeof(*fds) * nfds); 117 if (fds == NULL) 118 return (LIBUSB_ERROR_NO_MEM); 119 120 ppdev = alloca(sizeof(*ppdev) * nfds); 121 if (ppdev == NULL) 122 return (LIBUSB_ERROR_NO_MEM); 123 124 TAILQ_FOREACH(pfd, &ctx->pollfds, entry) { 125 fds[i].fd = pfd->pollfd.fd; 126 fds[i].events = pfd->pollfd.events; 127 fds[i].revents = 0; 128 ppdev[i] = pfd->pdev; 129 if (pfd->pdev != NULL) 130 libusb_get_device(pfd->pdev)->refcnt++; 131 i++; 132 } 133 134 if (tv == NULL) 135 timeout = -1; 136 else 137 timeout = (tv->tv_sec * 1000) + ((tv->tv_usec + 999) / 1000); 138 139 CTX_UNLOCK(ctx); 140 err = poll(fds, nfds, timeout); 141 CTX_LOCK(ctx); 142 143 if ((err == -1) && (errno == EINTR)) 144 err = LIBUSB_ERROR_INTERRUPTED; 145 else if (err < 0) 146 err = LIBUSB_ERROR_IO; 147 148 if (err < 1) { 149 for (i = 0; i != (int)nfds; i++) { 150 if (ppdev[i] != NULL) { 151 CTX_UNLOCK(ctx); 152 libusb_unref_device(libusb_get_device(ppdev[i])); 153 CTX_LOCK(ctx); 154 } 155 } 156 goto do_done; 157 } 158 for (i = 0; i != (int)nfds; i++) { 159 if (ppdev[i] != NULL) { 160 dev = libusb_get_device(ppdev[i]); 161 162 if (fds[i].revents == 0) 163 err = 0; /* nothing to do */ 164 else 165 err = libusb20_dev_process(ppdev[i]); 166 167 if (err) { 168 /* cancel all transfers - device is gone */ 169 libusb10_cancel_all_transfer(dev); 170 171 /* remove USB device from polling loop */ 172 libusb10_remove_pollfd(dev->ctx, &dev->dev_poll); 173 } 174 CTX_UNLOCK(ctx); 175 libusb_unref_device(dev); 176 CTX_LOCK(ctx); 177 178 } else { 179 uint8_t dummy; 180 181 while (1) { 182 if (read(fds[i].fd, &dummy, 1) != 1) 183 break; 184 } 185 } 186 } 187 188 err = 0; 189 190 do_done: 191 192 /* Do all done callbacks */ 193 194 while ((sxfer = TAILQ_FIRST(&ctx->tr_done))) { 195 uint8_t flags; 196 197 TAILQ_REMOVE(&ctx->tr_done, sxfer, entry); 198 sxfer->entry.tqe_prev = NULL; 199 200 ctx->tr_done_ref++; 201 202 CTX_UNLOCK(ctx); 203 204 uxfer = (struct libusb_transfer *)( 205 ((uint8_t *)sxfer) + sizeof(*sxfer)); 206 207 /* Allow the callback to free the transfer itself. */ 208 flags = uxfer->flags; 209 210 if (uxfer->callback != NULL) 211 (uxfer->callback) (uxfer); 212 213 /* Check if the USB transfer should be automatically freed. */ 214 if (flags & LIBUSB_TRANSFER_FREE_TRANSFER) 215 libusb_free_transfer(uxfer); 216 217 CTX_LOCK(ctx); 218 219 ctx->tr_done_ref--; 220 ctx->tr_done_gen++; 221 } 222 223 /* Wakeup other waiters */ 224 pthread_cond_broadcast(&ctx->ctx_cond); 225 226 return (err); 227 } 228 229 /* Polling and timing */ 230 231 int 232 libusb_try_lock_events(libusb_context *ctx) 233 { 234 int err; 235 236 ctx = GET_CONTEXT(ctx); 237 if (ctx == NULL) 238 return (1); 239 240 err = CTX_TRYLOCK(ctx); 241 if (err) 242 return (1); 243 244 err = (ctx->ctx_handler != NO_THREAD); 245 if (err) 246 CTX_UNLOCK(ctx); 247 else 248 ctx->ctx_handler = pthread_self(); 249 250 return (err); 251 } 252 253 void 254 libusb_lock_events(libusb_context *ctx) 255 { 256 ctx = GET_CONTEXT(ctx); 257 CTX_LOCK(ctx); 258 if (ctx->ctx_handler == NO_THREAD) 259 ctx->ctx_handler = pthread_self(); 260 } 261 262 void 263 libusb_unlock_events(libusb_context *ctx) 264 { 265 ctx = GET_CONTEXT(ctx); 266 if (ctx->ctx_handler == pthread_self()) { 267 ctx->ctx_handler = NO_THREAD; 268 pthread_cond_broadcast(&ctx->ctx_cond); 269 } 270 CTX_UNLOCK(ctx); 271 } 272 273 int 274 libusb_event_handling_ok(libusb_context *ctx) 275 { 276 ctx = GET_CONTEXT(ctx); 277 return (ctx->ctx_handler == pthread_self()); 278 } 279 280 int 281 libusb_event_handler_active(libusb_context *ctx) 282 { 283 ctx = GET_CONTEXT(ctx); 284 return (ctx->ctx_handler != NO_THREAD); 285 } 286 287 void 288 libusb_lock_event_waiters(libusb_context *ctx) 289 { 290 ctx = GET_CONTEXT(ctx); 291 CTX_LOCK(ctx); 292 } 293 294 void 295 libusb_unlock_event_waiters(libusb_context *ctx) 296 { 297 ctx = GET_CONTEXT(ctx); 298 CTX_UNLOCK(ctx); 299 } 300 301 int 302 libusb_wait_for_event(libusb_context *ctx, struct timeval *tv) 303 { 304 struct timespec ts; 305 int err; 306 307 ctx = GET_CONTEXT(ctx); 308 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_wait_for_event enter"); 309 310 if (tv == NULL) { 311 pthread_cond_wait(&ctx->ctx_cond, 312 &ctx->ctx_lock); 313 return (0); 314 } 315 err = clock_gettime(CLOCK_MONOTONIC, &ts); 316 if (err < 0) 317 return (LIBUSB_ERROR_OTHER); 318 319 /* 320 * The "tv" arguments points to a relative time structure and 321 * not an absolute time structure. 322 */ 323 ts.tv_sec += tv->tv_sec; 324 ts.tv_nsec += tv->tv_usec * 1000; 325 if (ts.tv_nsec >= 1000000000) { 326 ts.tv_nsec -= 1000000000; 327 ts.tv_sec++; 328 } 329 err = pthread_cond_timedwait(&ctx->ctx_cond, 330 &ctx->ctx_lock, &ts); 331 332 if (err == ETIMEDOUT) 333 return (1); 334 335 return (0); 336 } 337 338 int 339 libusb_handle_events_timeout(libusb_context *ctx, struct timeval *tv) 340 { 341 int err; 342 343 ctx = GET_CONTEXT(ctx); 344 345 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout enter"); 346 347 libusb_lock_events(ctx); 348 349 err = libusb_handle_events_locked(ctx, tv); 350 351 libusb_unlock_events(ctx); 352 353 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout leave"); 354 355 return (err); 356 } 357 358 int 359 libusb_handle_events(libusb_context *ctx) 360 { 361 return (libusb_handle_events_timeout(ctx, NULL)); 362 } 363 364 int 365 libusb_handle_events_locked(libusb_context *ctx, struct timeval *tv) 366 { 367 int err; 368 369 ctx = GET_CONTEXT(ctx); 370 371 if (libusb_event_handling_ok(ctx)) { 372 err = libusb10_handle_events_sub(ctx, tv); 373 } else { 374 libusb_wait_for_event(ctx, tv); 375 err = 0; 376 } 377 return (err); 378 } 379 380 int 381 libusb_get_next_timeout(libusb_context *ctx, struct timeval *tv) 382 { 383 /* all timeouts are currently being done by the kernel */ 384 timerclear(tv); 385 return (0); 386 } 387 388 void 389 libusb_set_pollfd_notifiers(libusb_context *ctx, 390 libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb, 391 void *user_data) 392 { 393 ctx = GET_CONTEXT(ctx); 394 395 ctx->fd_added_cb = added_cb; 396 ctx->fd_removed_cb = removed_cb; 397 ctx->fd_cb_user_data = user_data; 398 } 399 400 const struct libusb_pollfd ** 401 libusb_get_pollfds(libusb_context *ctx) 402 { 403 struct libusb_super_pollfd *pollfd; 404 libusb_pollfd **ret; 405 int i; 406 407 ctx = GET_CONTEXT(ctx); 408 409 CTX_LOCK(ctx); 410 411 i = 0; 412 TAILQ_FOREACH(pollfd, &ctx->pollfds, entry) 413 i++; 414 415 ret = calloc(i + 1, sizeof(struct libusb_pollfd *)); 416 if (ret == NULL) 417 goto done; 418 419 i = 0; 420 TAILQ_FOREACH(pollfd, &ctx->pollfds, entry) 421 ret[i++] = &pollfd->pollfd; 422 ret[i] = NULL; 423 424 done: 425 CTX_UNLOCK(ctx); 426 return ((const struct libusb_pollfd **)ret); 427 } 428 429 430 /* Synchronous device I/O */ 431 432 int 433 libusb_control_transfer(libusb_device_handle *devh, 434 uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex, 435 uint8_t *data, uint16_t wLength, unsigned int timeout) 436 { 437 struct LIBUSB20_CONTROL_SETUP_DECODED req; 438 int err; 439 uint16_t actlen; 440 441 if (devh == NULL) 442 return (LIBUSB_ERROR_INVALID_PARAM); 443 444 if ((wLength != 0) && (data == NULL)) 445 return (LIBUSB_ERROR_INVALID_PARAM); 446 447 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req); 448 449 req.bmRequestType = bmRequestType; 450 req.bRequest = bRequest; 451 req.wValue = wValue; 452 req.wIndex = wIndex; 453 req.wLength = wLength; 454 455 err = libusb20_dev_request_sync(devh, &req, data, 456 &actlen, timeout, 0); 457 458 if (err == LIBUSB20_ERROR_PIPE) 459 return (LIBUSB_ERROR_PIPE); 460 else if (err == LIBUSB20_ERROR_TIMEOUT) 461 return (LIBUSB_ERROR_TIMEOUT); 462 else if (err) 463 return (LIBUSB_ERROR_NO_DEVICE); 464 465 return (actlen); 466 } 467 468 static void 469 libusb10_do_transfer_cb(struct libusb_transfer *transfer) 470 { 471 libusb_context *ctx; 472 int *pdone; 473 474 ctx = GET_CONTEXT(NULL); 475 476 DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "sync I/O done"); 477 478 pdone = transfer->user_data; 479 *pdone = 1; 480 } 481 482 /* 483 * TODO: Replace the following function. Allocating and freeing on a 484 * per-transfer basis is slow. --HPS 485 */ 486 static int 487 libusb10_do_transfer(libusb_device_handle *devh, 488 uint8_t endpoint, uint8_t *data, int length, 489 int *transferred, unsigned int timeout, int type) 490 { 491 libusb_context *ctx; 492 struct libusb_transfer *xfer; 493 int done; 494 int ret; 495 496 if (devh == NULL) 497 return (LIBUSB_ERROR_INVALID_PARAM); 498 499 if ((length != 0) && (data == NULL)) 500 return (LIBUSB_ERROR_INVALID_PARAM); 501 502 xfer = libusb_alloc_transfer(0); 503 if (xfer == NULL) 504 return (LIBUSB_ERROR_NO_MEM); 505 506 ctx = libusb_get_device(devh)->ctx; 507 508 xfer->dev_handle = devh; 509 xfer->endpoint = endpoint; 510 xfer->type = type; 511 xfer->timeout = timeout; 512 xfer->buffer = data; 513 xfer->length = length; 514 xfer->user_data = (void *)&done; 515 xfer->callback = libusb10_do_transfer_cb; 516 done = 0; 517 518 if ((ret = libusb_submit_transfer(xfer)) < 0) { 519 libusb_free_transfer(xfer); 520 return (ret); 521 } 522 while (done == 0) { 523 if ((ret = libusb_handle_events(ctx)) < 0) { 524 libusb_cancel_transfer(xfer); 525 usleep(1000); /* nice it */ 526 } 527 } 528 529 *transferred = xfer->actual_length; 530 531 switch (xfer->status) { 532 case LIBUSB_TRANSFER_COMPLETED: 533 ret = 0; 534 break; 535 case LIBUSB_TRANSFER_TIMED_OUT: 536 ret = LIBUSB_ERROR_TIMEOUT; 537 break; 538 case LIBUSB_TRANSFER_OVERFLOW: 539 ret = LIBUSB_ERROR_OVERFLOW; 540 break; 541 case LIBUSB_TRANSFER_STALL: 542 ret = LIBUSB_ERROR_PIPE; 543 break; 544 case LIBUSB_TRANSFER_NO_DEVICE: 545 ret = LIBUSB_ERROR_NO_DEVICE; 546 break; 547 default: 548 ret = LIBUSB_ERROR_OTHER; 549 break; 550 } 551 552 libusb_free_transfer(xfer); 553 return (ret); 554 } 555 556 int 557 libusb_bulk_transfer(libusb_device_handle *devh, 558 uint8_t endpoint, uint8_t *data, int length, 559 int *transferred, unsigned int timeout) 560 { 561 libusb_context *ctx; 562 int ret; 563 564 ctx = GET_CONTEXT(NULL); 565 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer enter"); 566 567 ret = libusb10_do_transfer(devh, endpoint, data, length, transferred, 568 timeout, LIBUSB_TRANSFER_TYPE_BULK); 569 570 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer leave"); 571 return (ret); 572 } 573 574 int 575 libusb_interrupt_transfer(libusb_device_handle *devh, 576 uint8_t endpoint, uint8_t *data, int length, 577 int *transferred, unsigned int timeout) 578 { 579 libusb_context *ctx; 580 int ret; 581 582 ctx = GET_CONTEXT(NULL); 583 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer enter"); 584 585 ret = libusb10_do_transfer(devh, endpoint, data, length, transferred, 586 timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT); 587 588 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer leave"); 589 return (ret); 590 } 591 592 uint8_t * 593 libusb_get_iso_packet_buffer(struct libusb_transfer *transfer, uint32_t off) 594 { 595 uint8_t *ptr; 596 uint32_t n; 597 598 if (transfer->num_iso_packets < 0) 599 return (NULL); 600 601 if (off >= (uint32_t)transfer->num_iso_packets) 602 return (NULL); 603 604 ptr = transfer->buffer; 605 if (ptr == NULL) 606 return (NULL); 607 608 for (n = 0; n != off; n++) { 609 ptr += transfer->iso_packet_desc[n].length; 610 } 611 return (ptr); 612 } 613 614 uint8_t * 615 libusb_get_iso_packet_buffer_simple(struct libusb_transfer *transfer, uint32_t off) 616 { 617 uint8_t *ptr; 618 619 if (transfer->num_iso_packets < 0) 620 return (NULL); 621 622 if (off >= (uint32_t)transfer->num_iso_packets) 623 return (NULL); 624 625 ptr = transfer->buffer; 626 if (ptr == NULL) 627 return (NULL); 628 629 ptr += transfer->iso_packet_desc[0].length * off; 630 631 return (ptr); 632 } 633 634 void 635 libusb_set_iso_packet_lengths(struct libusb_transfer *transfer, uint32_t length) 636 { 637 int n; 638 639 if (transfer->num_iso_packets < 0) 640 return; 641 642 for (n = 0; n != transfer->num_iso_packets; n++) 643 transfer->iso_packet_desc[n].length = length; 644 } 645 646 uint8_t * 647 libusb_control_transfer_get_data(struct libusb_transfer *transfer) 648 { 649 if (transfer->buffer == NULL) 650 return (NULL); 651 652 return (transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE); 653 } 654 655 struct libusb_control_setup * 656 libusb_control_transfer_get_setup(struct libusb_transfer *transfer) 657 { 658 return ((struct libusb_control_setup *)transfer->buffer); 659 } 660 661 void 662 libusb_fill_control_setup(uint8_t *buf, uint8_t bmRequestType, 663 uint8_t bRequest, uint16_t wValue, 664 uint16_t wIndex, uint16_t wLength) 665 { 666 struct libusb_control_setup *req = (struct libusb_control_setup *)buf; 667 668 /* The alignment is OK for all fields below. */ 669 req->bmRequestType = bmRequestType; 670 req->bRequest = bRequest; 671 req->wValue = htole16(wValue); 672 req->wIndex = htole16(wIndex); 673 req->wLength = htole16(wLength); 674 } 675 676 void 677 libusb_fill_control_transfer(struct libusb_transfer *transfer, 678 libusb_device_handle *devh, uint8_t *buf, 679 libusb_transfer_cb_fn callback, void *user_data, 680 uint32_t timeout) 681 { 682 struct libusb_control_setup *setup = (struct libusb_control_setup *)buf; 683 684 transfer->dev_handle = devh; 685 transfer->endpoint = 0; 686 transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL; 687 transfer->timeout = timeout; 688 transfer->buffer = buf; 689 if (setup != NULL) 690 transfer->length = LIBUSB_CONTROL_SETUP_SIZE 691 + le16toh(setup->wLength); 692 else 693 transfer->length = 0; 694 transfer->user_data = user_data; 695 transfer->callback = callback; 696 697 } 698 699 void 700 libusb_fill_bulk_transfer(struct libusb_transfer *transfer, 701 libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf, 702 int length, libusb_transfer_cb_fn callback, void *user_data, 703 uint32_t timeout) 704 { 705 transfer->dev_handle = devh; 706 transfer->endpoint = endpoint; 707 transfer->type = LIBUSB_TRANSFER_TYPE_BULK; 708 transfer->timeout = timeout; 709 transfer->buffer = buf; 710 transfer->length = length; 711 transfer->user_data = user_data; 712 transfer->callback = callback; 713 } 714 715 void 716 libusb_fill_interrupt_transfer(struct libusb_transfer *transfer, 717 libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf, 718 int length, libusb_transfer_cb_fn callback, void *user_data, 719 uint32_t timeout) 720 { 721 transfer->dev_handle = devh; 722 transfer->endpoint = endpoint; 723 transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT; 724 transfer->timeout = timeout; 725 transfer->buffer = buf; 726 transfer->length = length; 727 transfer->user_data = user_data; 728 transfer->callback = callback; 729 } 730 731 void 732 libusb_fill_iso_transfer(struct libusb_transfer *transfer, 733 libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf, 734 int length, int npacket, libusb_transfer_cb_fn callback, 735 void *user_data, uint32_t timeout) 736 { 737 transfer->dev_handle = devh; 738 transfer->endpoint = endpoint; 739 transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS; 740 transfer->timeout = timeout; 741 transfer->buffer = buf; 742 transfer->length = length; 743 transfer->num_iso_packets = npacket; 744 transfer->user_data = user_data; 745 transfer->callback = callback; 746 } 747 748