lib/libusb/libusb10_io.c

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