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 #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