lib/libusb/libusb10_io.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2009 Sylvestre Gallon. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #ifdef LIBUSB_GLOBAL_INCLUDE_FILE
  29 #include LIBUSB_GLOBAL_INCLUDE_FILE
  30 #else
  31 #include <errno.h>
  32 #include <poll.h>
  33 #include <pthread.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <time.h>
  38 #include <unistd.h>
  39 #include <sys/queue.h>
  40 #include <sys/endian.h>
  41 #endif
  42
  43 #define libusb_device_handle libusb20_device
  44
  45 #include "libusb20.h"
  46 #include "libusb20_desc.h"
  47 #include "libusb20_int.h"
  48 #include "libusb.h"
  49 #include "libusb10.h"
  50
  51 UNEXPORTED void
  52 libusb10_add_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd,
  53     struct libusb20_device *pdev, int fd, short events)
  54 {
  55         if (ctx == NULL)
  56                 return;                 /* invalid */
  57
  58         if (pollfd->entry.tqe_prev != NULL)
  59                 return;                 /* already queued */
  60
  61         if (fd < 0)
  62                 return;                 /* invalid */
  63
  64         pollfd->pdev = pdev;
  65         pollfd->pollfd.fd = fd;
  66         pollfd->pollfd.events = events;
  67
  68         CTX_LOCK(ctx);
  69         TAILQ_INSERT_TAIL(&ctx->pollfds, pollfd, entry);
  70         CTX_UNLOCK(ctx);
  71
  72         if (ctx->fd_added_cb)
  73                 ctx->fd_added_cb(fd, events, ctx->fd_cb_user_data);
  74 }
  75
  76 UNEXPORTED void
  77 libusb10_remove_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd)
  78 {
  79         if (ctx == NULL)
  80                 return;                 /* invalid */
  81
  82         if (pollfd->entry.tqe_prev == NULL)
  83                 return;                 /* already dequeued */
  84
  85         CTX_LOCK(ctx);
  86         TAILQ_REMOVE(&ctx->pollfds, pollfd, entry);
  87         pollfd->entry.tqe_prev = NULL;
  88         CTX_UNLOCK(ctx);
  89
  90         if (ctx->fd_removed_cb)
  91                 ctx->fd_removed_cb(pollfd->pollfd.fd, ctx->fd_cb_user_data);
  92 }
  93
  94 /* This function must be called locked */
  95
  96 static int
  97 libusb10_handle_events_sub(struct libusb_context *ctx, struct timeval *tv)
  98 {
  99         struct libusb_device *dev;
 100         struct libusb20_device **ppdev;
 101         struct libusb_super_pollfd *pfd;
 102         struct pollfd *fds;
 103         struct libusb_super_transfer *sxfer;
 104         struct libusb_transfer *uxfer;
 105         nfds_t nfds;
 106         int timeout;
 107         int i;
 108         int err;
 109
 110         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb10_handle_events_sub enter");
 111
 112         nfds = 0;
 113         i = 0;
 114         TAILQ_FOREACH(pfd, &ctx->pollfds, entry)
 115             nfds++;
 116
 117         fds = alloca(sizeof(*fds) * nfds);
 118         if (fds == NULL)
 119                 return (LIBUSB_ERROR_NO_MEM);
 120
 121         ppdev = alloca(sizeof(*ppdev) * nfds);
 122         if (ppdev == NULL)
 123                 return (LIBUSB_ERROR_NO_MEM);
 124
 125         TAILQ_FOREACH(pfd, &ctx->pollfds, entry) {
 126                 fds[i].fd = pfd->pollfd.fd;
 127                 fds[i].events = pfd->pollfd.events;
 128                 fds[i].revents = 0;
 129                 ppdev[i] = pfd->pdev;
 130                 if (pfd->pdev != NULL)
 131                         libusb_get_device(pfd->pdev)->refcnt++;
 132                 i++;
 133         }
 134
 135         if (tv == NULL)
 136                 timeout = -1;
 137         else
 138                 timeout = (tv->tv_sec * 1000) + ((tv->tv_usec + 999) / 1000);
 139
 140         CTX_UNLOCK(ctx);
 141         err = poll(fds, nfds, timeout);
 142         CTX_LOCK(ctx);
 143
 144         if ((err == -1) && (errno == EINTR))
 145                 err = LIBUSB_ERROR_INTERRUPTED;
 146         else if (err < 0)
 147                 err = LIBUSB_ERROR_IO;
 148
 149         if (err < 1) {
 150                 for (i = 0; i != (int)nfds; i++) {
 151                         if (ppdev[i] != NULL) {
 152                                 CTX_UNLOCK(ctx);
 153                                 libusb_unref_device(libusb_get_device(ppdev[i]));
 154                                 CTX_LOCK(ctx);
 155                         }
 156                 }
 157                 goto do_done;
 158         }
 159         for (i = 0; i != (int)nfds; i++) {
 160                 if (ppdev[i] != NULL) {
 161                         dev = libusb_get_device(ppdev[i]);
 162
 163                         if (fds[i].revents != 0) {
 164                                 err = libusb20_dev_process(ppdev[i]);
 165
 166                                 if (err) {
 167                                         /*
 168                                          * When the device is opened
 169                                          * set the "device_is_gone"
 170                                          * flag. This prevents the
 171                                          * client from submitting new
 172                                          * USB transfers to a detached
 173                                          * device.
 174                                          */
 175                                         if (ppdev[i]->is_opened)
 176                                                 dev->device_is_gone = 1;
 177
 178                                         /* remove USB device from polling loop */
 179                                         libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
 180
 181                                         /* cancel all pending transfers */
 182                                         libusb10_cancel_all_transfer_locked(ppdev[i], dev);
 183                                 }
 184                         }
 185                         CTX_UNLOCK(ctx);
 186                         libusb_unref_device(dev);
 187                         CTX_LOCK(ctx);
 188
 189                 } else {
 190                         uint8_t dummy;
 191
 192                         while (read(fds[i].fd, &dummy, 1) == 1)
 193                                 ;
 194                 }
 195         }
 196
 197         err = 0;
 198
 199 do_done:
 200
 201         /* Do all done callbacks */
 202
 203         while ((sxfer = TAILQ_FIRST(&ctx->tr_done))) {
 204                 uint8_t flags;
 205
 206                 TAILQ_REMOVE(&ctx->tr_done, sxfer, entry);
 207                 sxfer->entry.tqe_prev = NULL;
 208
 209                 ctx->tr_done_ref++;
 210
 211                 CTX_UNLOCK(ctx);
 212
 213                 uxfer = (struct libusb_transfer *)(
 214                     ((uint8_t *)sxfer) + sizeof(*sxfer));
 215
 216                 /* Allow the callback to free the transfer itself. */
 217                 flags = uxfer->flags;
 218
 219                 if (uxfer->callback != NULL)
 220                         (uxfer->callback) (uxfer);
 221
 222                 /* Check if the USB transfer should be automatically freed. */
 223                 if (flags & LIBUSB_TRANSFER_FREE_TRANSFER)
 224                         libusb_free_transfer(uxfer);
 225
 226                 CTX_LOCK(ctx);
 227
 228                 ctx->tr_done_ref--;
 229                 ctx->tr_done_gen++;
 230         }
 231
 232         /* Wakeup other waiters */
 233         pthread_cond_broadcast(&ctx->ctx_cond);
 234
 235         return (err);
 236 }
 237
 238 /* Polling and timing */
 239
 240 int
 241 libusb_try_lock_events(libusb_context *ctx)
 242 {
 243         int err;
 244
 245         ctx = GET_CONTEXT(ctx);
 246         if (ctx == NULL)
 247                 return (1);
 248
 249         err = CTX_TRYLOCK(ctx);
 250         if (err)
 251                 return (1);
 252
 253         err = (ctx->ctx_handler != NO_THREAD);
 254         if (err)
 255                 CTX_UNLOCK(ctx);
 256         else
 257                 ctx->ctx_handler = pthread_self();
 258
 259         return (err);
 260 }
 261
 262 void
 263 libusb_lock_events(libusb_context *ctx)
 264 {
 265         ctx = GET_CONTEXT(ctx);
 266         CTX_LOCK(ctx);
 267         if (ctx->ctx_handler == NO_THREAD)
 268                 ctx->ctx_handler = pthread_self();
 269 }
 270
 271 void
 272 libusb_unlock_events(libusb_context *ctx)
 273 {
 274         ctx = GET_CONTEXT(ctx);
 275         if (ctx->ctx_handler == pthread_self()) {
 276                 ctx->ctx_handler = NO_THREAD;
 277                 pthread_cond_broadcast(&ctx->ctx_cond);
 278         }
 279         CTX_UNLOCK(ctx);
 280 }
 281
 282 int
 283 libusb_event_handling_ok(libusb_context *ctx)
 284 {
 285         ctx = GET_CONTEXT(ctx);
 286         return (ctx->ctx_handler == pthread_self());
 287 }
 288
 289 int
 290 libusb_event_handler_active(libusb_context *ctx)
 291 {
 292         ctx = GET_CONTEXT(ctx);
 293         return (ctx->ctx_handler != NO_THREAD);
 294 }
 295
 296 void
 297 libusb_lock_event_waiters(libusb_context *ctx)
 298 {
 299         ctx = GET_CONTEXT(ctx);
 300         CTX_LOCK(ctx);
 301 }
 302
 303 void
 304 libusb_unlock_event_waiters(libusb_context *ctx)
 305 {
 306         ctx = GET_CONTEXT(ctx);
 307         CTX_UNLOCK(ctx);
 308 }
 309
 310 int
 311 libusb_wait_for_event(libusb_context *ctx, struct timeval *tv)
 312 {
 313         struct timespec ts;
 314         int err;
 315
 316         ctx = GET_CONTEXT(ctx);
 317         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_wait_for_event enter");
 318
 319         if (tv == NULL) {
 320                 pthread_cond_wait(&ctx->ctx_cond,
 321                     &ctx->ctx_lock);
 322                 /* try to grab polling of actual events, if any */
 323                 if (ctx->ctx_handler == NO_THREAD)
 324                         ctx->ctx_handler = pthread_self();
 325                 return (0);
 326         }
 327         err = clock_gettime(CLOCK_MONOTONIC, &ts);
 328         if (err < 0)
 329                 return (LIBUSB_ERROR_OTHER);
 330
 331         /*
 332          * The "tv" arguments points to a relative time structure and
 333          * not an absolute time structure.
 334          */
 335         ts.tv_sec += tv->tv_sec;
 336         ts.tv_nsec += tv->tv_usec * 1000;
 337         if (ts.tv_nsec >= 1000000000) {
 338                 ts.tv_nsec -= 1000000000;
 339                 ts.tv_sec++;
 340         }
 341         err = pthread_cond_timedwait(&ctx->ctx_cond,
 342             &ctx->ctx_lock, &ts);
 343         /* try to grab polling of actual events, if any */
 344         if (ctx->ctx_handler == NO_THREAD)
 345                 ctx->ctx_handler = pthread_self();
 346
 347         if (err == ETIMEDOUT)
 348                 return (1);
 349
 350         return (0);
 351 }
 352
 353 int
 354 libusb_handle_events_timeout_completed(libusb_context *ctx,
 355     struct timeval *tv, int *completed)
 356 {
 357         int err = 0;
 358
 359         ctx = GET_CONTEXT(ctx);
 360
 361         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout_completed enter");
 362
 363         libusb_lock_events(ctx);
 364
 365         while (1) {
 366                 if (completed != NULL) {
 367                         if (*completed != 0 || err != 0)
 368                                 break;
 369                 }
 370                 err = libusb_handle_events_locked(ctx, tv);
 371                 if (completed == NULL)
 372                         break;
 373         }
 374
 375         libusb_unlock_events(ctx);
 376
 377         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout_completed exit");
 378
 379         return (err);
 380 }
 381
 382 int
 383 libusb_handle_events_completed(libusb_context *ctx, int *completed)
 384 {
 385         return (libusb_handle_events_timeout_completed(ctx, NULL, completed));
 386 }
 387
 388 int
 389 libusb_handle_events_timeout(libusb_context *ctx, struct timeval *tv)
 390 {
 391         return (libusb_handle_events_timeout_completed(ctx, tv, NULL));
 392 }
 393
 394 int
 395 libusb_handle_events(libusb_context *ctx)
 396 {
 397         return (libusb_handle_events_timeout_completed(ctx, NULL, NULL));
 398 }
 399
 400 int
 401 libusb_handle_events_locked(libusb_context *ctx, struct timeval *tv)
 402 {
 403         int err;
 404
 405         ctx = GET_CONTEXT(ctx);
 406
 407         if (libusb_event_handling_ok(ctx)) {
 408                 err = libusb10_handle_events_sub(ctx, tv);
 409         } else {
 410                 err = libusb_wait_for_event(ctx, tv);
 411                 if (err != 0)
 412                         err = LIBUSB_ERROR_TIMEOUT;
 413         }
 414         return (err);
 415 }
 416
 417 int
 418 libusb_get_next_timeout(libusb_context *ctx, struct timeval *tv)
 419 {
 420         /* all timeouts are currently being done by the kernel */
 421         timerclear(tv);
 422         return (0);
 423 }
 424
 425 void
 426 libusb_set_pollfd_notifiers(libusb_context *ctx,
 427     libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb,
 428     void *user_data)
 429 {
 430         ctx = GET_CONTEXT(ctx);
 431
 432         ctx->fd_added_cb = added_cb;
 433         ctx->fd_removed_cb = removed_cb;
 434         ctx->fd_cb_user_data = user_data;
 435 }
 436
 437 const struct libusb_pollfd **
 438 libusb_get_pollfds(libusb_context *ctx)
 439 {
 440         struct libusb_super_pollfd *pollfd;
 441         libusb_pollfd **ret;
 442         int i;
 443
 444         ctx = GET_CONTEXT(ctx);
 445
 446         CTX_LOCK(ctx);
 447
 448         i = 0;
 449         TAILQ_FOREACH(pollfd, &ctx->pollfds, entry)
 450             i++;
 451
 452         ret = calloc(i + 1, sizeof(struct libusb_pollfd *));
 453         if (ret == NULL)
 454                 goto done;
 455
 456         i = 0;
 457         TAILQ_FOREACH(pollfd, &ctx->pollfds, entry)
 458             ret[i++] = &pollfd->pollfd;
 459         ret[i] = NULL;
 460
 461 done:
 462         CTX_UNLOCK(ctx);
 463         return ((const struct libusb_pollfd **)ret);
 464 }
 465
 466
 467 /* Synchronous device I/O */
 468
 469 int
 470 libusb_control_transfer(libusb_device_handle *devh,
 471     uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
 472     uint8_t *data, uint16_t wLength, unsigned int timeout)
 473 {
 474         struct LIBUSB20_CONTROL_SETUP_DECODED req;
 475         int err;
 476         uint16_t actlen;
 477
 478         if (devh == NULL)
 479                 return (LIBUSB_ERROR_INVALID_PARAM);
 480
 481         if ((wLength != 0) && (data == NULL))
 482                 return (LIBUSB_ERROR_INVALID_PARAM);
 483
 484         LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req);
 485
 486         req.bmRequestType = bmRequestType;
 487         req.bRequest = bRequest;
 488         req.wValue = wValue;
 489         req.wIndex = wIndex;
 490         req.wLength = wLength;
 491
 492         err = libusb20_dev_request_sync(devh, &req, data,
 493             &actlen, timeout, 0);
 494
 495         if (err == LIBUSB20_ERROR_PIPE)
 496                 return (LIBUSB_ERROR_PIPE);
 497         else if (err == LIBUSB20_ERROR_TIMEOUT)
 498                 return (LIBUSB_ERROR_TIMEOUT);
 499         else if (err)
 500                 return (LIBUSB_ERROR_NO_DEVICE);
 501
 502         return (actlen);
 503 }
 504
 505 static libusb_context *
 506 libusb10_get_context_by_device_handle(libusb_device_handle *devh)
 507 {
 508         libusb_context *ctx;
 509
 510         if (devh != NULL)
 511                 ctx = libusb_get_device(devh)->ctx;
 512         else
 513                 ctx = NULL;
 514
 515         return (GET_CONTEXT(ctx));
 516 }
 517
 518 static void
 519 libusb10_do_transfer_cb(struct libusb_transfer *transfer)
 520 {
 521         libusb_context *ctx;
 522         int *pdone;
 523
 524         ctx = libusb10_get_context_by_device_handle(transfer->dev_handle);
 525
 526         DPRINTF(ctx, LIBUSB_DEBUG_TRANSFER, "sync I/O done");
 527
 528         pdone = transfer->user_data;
 529         *pdone = 1;
 530 }
 531
 532 /*
 533  * TODO: Replace the following function. Allocating and freeing on a
 534  * per-transfer basis is slow.  --HPS
 535  */
 536 static int
 537 libusb10_do_transfer(libusb_device_handle *devh,
 538     uint8_t endpoint, uint8_t *data, int length,
 539     int *transferred, unsigned int timeout, int type)
 540 {
 541         libusb_context *ctx;
 542         struct libusb_transfer *xfer;
 543         int done;
 544         int ret;
 545
 546         if (devh == NULL)
 547                 return (LIBUSB_ERROR_INVALID_PARAM);
 548
 549         if ((length != 0) && (data == NULL))
 550                 return (LIBUSB_ERROR_INVALID_PARAM);
 551
 552         xfer = libusb_alloc_transfer(0);
 553         if (xfer == NULL)
 554                 return (LIBUSB_ERROR_NO_MEM);
 555
 556         ctx = libusb_get_device(devh)->ctx;
 557
 558         xfer->dev_handle = devh;
 559         xfer->endpoint = endpoint;
 560         xfer->type = type;
 561         xfer->timeout = timeout;
 562         xfer->buffer = data;
 563         xfer->length = length;
 564         xfer->user_data = (void *)&done;
 565         xfer->callback = libusb10_do_transfer_cb;
 566         done = 0;
 567
 568         if ((ret = libusb_submit_transfer(xfer)) < 0) {
 569                 libusb_free_transfer(xfer);
 570                 return (ret);
 571         }
 572         while (done == 0) {
 573                 if ((ret = libusb_handle_events(ctx)) < 0) {
 574                         libusb_cancel_transfer(xfer);
 575                         usleep(1000);   /* nice it */
 576                 }
 577         }
 578
 579         *transferred = xfer->actual_length;
 580
 581         switch (xfer->status) {
 582         case LIBUSB_TRANSFER_COMPLETED:
 583                 ret = 0;
 584                 break;
 585         case LIBUSB_TRANSFER_TIMED_OUT:
 586                 ret = LIBUSB_ERROR_TIMEOUT;
 587                 break;
 588         case LIBUSB_TRANSFER_OVERFLOW:
 589                 ret = LIBUSB_ERROR_OVERFLOW;
 590                 break;
 591         case LIBUSB_TRANSFER_STALL:
 592                 ret = LIBUSB_ERROR_PIPE;
 593                 break;
 594         case LIBUSB_TRANSFER_NO_DEVICE:
 595                 ret = LIBUSB_ERROR_NO_DEVICE;
 596                 break;
 597         default:
 598                 ret = LIBUSB_ERROR_OTHER;
 599                 break;
 600         }
 601
 602         libusb_free_transfer(xfer);
 603         return (ret);
 604 }
 605
 606 int
 607 libusb_bulk_transfer(libusb_device_handle *devh,
 608     uint8_t endpoint, uint8_t *data, int length,
 609     int *transferred, unsigned int timeout)
 610 {
 611         libusb_context *ctx;
 612         int ret;
 613
 614         ctx = libusb10_get_context_by_device_handle(devh);
 615
 616         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer enter");
 617
 618         ret = libusb10_do_transfer(devh, endpoint, data, length, transferred,
 619             timeout, LIBUSB_TRANSFER_TYPE_BULK);
 620
 621         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer leave");
 622         return (ret);
 623 }
 624
 625 int
 626 libusb_interrupt_transfer(libusb_device_handle *devh,
 627     uint8_t endpoint, uint8_t *data, int length,
 628     int *transferred, unsigned int timeout)
 629 {
 630         libusb_context *ctx;
 631         int ret;
 632
 633         ctx = libusb10_get_context_by_device_handle(devh);
 634
 635         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer enter");
 636
 637         ret = libusb10_do_transfer(devh, endpoint, data, length, transferred,
 638             timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT);
 639
 640         DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer leave");
 641         return (ret);
 642 }
 643
 644 uint8_t *
 645 libusb_get_iso_packet_buffer(struct libusb_transfer *transfer, uint32_t off)
 646 {
 647         uint8_t *ptr;
 648         uint32_t n;
 649
 650         if (transfer->num_iso_packets < 0)
 651                 return (NULL);
 652
 653         if (off >= (uint32_t)transfer->num_iso_packets)
 654                 return (NULL);
 655
 656         ptr = transfer->buffer;
 657         if (ptr == NULL)
 658                 return (NULL);
 659
 660         for (n = 0; n != off; n++) {
 661                 ptr += transfer->iso_packet_desc[n].length;
 662         }
 663         return (ptr);
 664 }
 665
 666 uint8_t *
 667 libusb_get_iso_packet_buffer_simple(struct libusb_transfer *transfer, uint32_t off)
 668 {
 669         uint8_t *ptr;
 670
 671         if (transfer->num_iso_packets < 0)
 672                 return (NULL);
 673
 674         if (off >= (uint32_t)transfer->num_iso_packets)
 675                 return (NULL);
 676
 677         ptr = transfer->buffer;
 678         if (ptr == NULL)
 679                 return (NULL);
 680
 681         ptr += transfer->iso_packet_desc[0].length * off;
 682
 683         return (ptr);
 684 }
 685
 686 void
 687 libusb_set_iso_packet_lengths(struct libusb_transfer *transfer, uint32_t length)
 688 {
 689         int n;
 690
 691         if (transfer->num_iso_packets < 0)
 692                 return;
 693
 694         for (n = 0; n != transfer->num_iso_packets; n++)
 695                 transfer->iso_packet_desc[n].length = length;
 696 }
 697
 698 uint8_t *
 699 libusb_control_transfer_get_data(struct libusb_transfer *transfer)
 700 {
 701         if (transfer->buffer == NULL)
 702                 return (NULL);
 703
 704         return (transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE);
 705 }
 706
 707 struct libusb_control_setup *
 708 libusb_control_transfer_get_setup(struct libusb_transfer *transfer)
 709 {
 710         return ((struct libusb_control_setup *)transfer->buffer);
 711 }
 712
 713 void
 714 libusb_fill_control_setup(uint8_t *buf, uint8_t bmRequestType,
 715     uint8_t bRequest, uint16_t wValue,
 716     uint16_t wIndex, uint16_t wLength)
 717 {
 718         struct libusb_control_setup *req = (struct libusb_control_setup *)buf;
 719
 720         /* The alignment is OK for all fields below. */
 721         req->bmRequestType = bmRequestType;
 722         req->bRequest = bRequest;
 723         req->wValue = htole16(wValue);
 724         req->wIndex = htole16(wIndex);
 725         req->wLength = htole16(wLength);
 726 }
 727
 728 void
 729 libusb_fill_control_transfer(struct libusb_transfer *transfer,
 730     libusb_device_handle *devh, uint8_t *buf,
 731     libusb_transfer_cb_fn callback, void *user_data,
 732     uint32_t timeout)
 733 {
 734         struct libusb_control_setup *setup = (struct libusb_control_setup *)buf;
 735
 736         transfer->dev_handle = devh;
 737         transfer->endpoint = 0;
 738         transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL;
 739         transfer->timeout = timeout;
 740         transfer->buffer = buf;
 741         if (setup != NULL)
 742                 transfer->length = LIBUSB_CONTROL_SETUP_SIZE
 743                         + le16toh(setup->wLength);
 744         else
 745                 transfer->length = 0;
 746         transfer->user_data = user_data;
 747         transfer->callback = callback;
 748
 749 }
 750
 751 void
 752 libusb_fill_bulk_transfer(struct libusb_transfer *transfer,
 753     libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf,
 754     int length, libusb_transfer_cb_fn callback, void *user_data,
 755     uint32_t timeout)
 756 {
 757         transfer->dev_handle = devh;
 758         transfer->endpoint = endpoint;
 759         transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
 760         transfer->timeout = timeout;
 761         transfer->buffer = buf;
 762         transfer->length = length;
 763         transfer->user_data = user_data;
 764         transfer->callback = callback;
 765 }
 766
 767 void
 768 libusb_fill_interrupt_transfer(struct libusb_transfer *transfer,
 769     libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf,
 770     int length, libusb_transfer_cb_fn callback, void *user_data,
 771     uint32_t timeout)
 772 {
 773         transfer->dev_handle = devh;
 774         transfer->endpoint = endpoint;
 775         transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT;
 776         transfer->timeout = timeout;
 777         transfer->buffer = buf;
 778         transfer->length = length;
 779         transfer->user_data = user_data;
 780         transfer->callback = callback;
 781 }
 782
 783 void
 784 libusb_fill_iso_transfer(struct libusb_transfer *transfer,
 785     libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf,
 786     int length, int npacket, libusb_transfer_cb_fn callback,
 787     void *user_data, uint32_t timeout)
 788 {
 789         transfer->dev_handle = devh;
 790         transfer->endpoint = endpoint;
 791         transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
 792         transfer->timeout = timeout;
 793         transfer->buffer = buf;
 794         transfer->length = length;
 795         transfer->num_iso_packets = npacket;
 796         transfer->user_data = user_data;
 797         transfer->callback = callback;
 798 }
 799
 800 int
 801 libusb_alloc_streams(libusb_device_handle *dev, uint32_t num_streams,
 802     unsigned char *endpoints, int num_endpoints)
 803 {
 804         if (num_streams > 1)
 805                 return (LIBUSB_ERROR_INVALID_PARAM);
 806         return (0);
 807 }
 808
 809 int
 810 libusb_free_streams(libusb_device_handle *dev, unsigned char *endpoints, int num_endpoints)
 811 {
 812
 813         return (0);
 814 }
 815
 816 void
 817 libusb_transfer_set_stream_id(struct libusb_transfer *transfer, uint32_t stream_id)
 818 {
 819         struct libusb_super_transfer *sxfer;
 820
 821         if (transfer == NULL)
 822                 return;
 823
 824         sxfer = (struct libusb_super_transfer *)(
 825             ((uint8_t *)transfer) - sizeof(*sxfer));
 826
 827         /* set stream ID */
 828         sxfer->stream_id = stream_id;
 829 }
 830
 831 uint32_t
 832 libusb_transfer_get_stream_id(struct libusb_transfer *transfer)
 833 {
 834         struct libusb_super_transfer *sxfer;
 835
 836         if (transfer == NULL)
 837                 return (0);
 838
 839         sxfer = (struct libusb_super_transfer *)(
 840             ((uint8_t *)transfer) - sizeof(*sxfer));
 841
 842         /* get stream ID */
 843         return (sxfer->stream_id);
 844 }