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 <sys/queue.h>
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <stdio.h>
  31 #include <poll.h>
  32 #include <pthread.h>
  33 #include <time.h>
  34 #include <errno.h>
  35
  36 #include "libusb20.h"
  37 #include "libusb20_desc.h"
  38 #include "libusb20_int.h"
  39 #include "libusb.h"
  40 #include "libusb10.h"
  41
  42 static int
  43 get_next_timeout(libusb_context *ctx, struct timeval *tv, struct timeval *out)
  44 {
  45         struct timeval timeout;
  46         int ret;
  47
  48         ret = libusb_get_next_timeout(ctx, &timeout);
  49
  50         if (ret) {
  51                 if (timerisset(&timeout) == 0)
  52                         return 1;
  53                 if (timercmp(&timeout, tv, <) != 0)
  54                         *out = timeout;
  55                 else
  56                         *out = *tv;
  57         } else {
  58                 *out = *tv;
  59         }
  60
  61         return (0);
  62 }
  63
  64 static int
  65 handle_timeouts(struct libusb_context *ctx)
  66 {
  67         struct timespec sys_ts;
  68         struct timeval sys_tv;
  69         struct timeval *cur_tv;
  70         struct usb_transfer *xfer;
  71         struct libusb_transfer *uxfer;
  72         int ret;
  73
  74         GET_CONTEXT(ctx);
  75         ret = 0;
  76
  77         pthread_mutex_lock(&ctx->flying_transfers_lock);
  78         if (USB_LIST_EMPTY(&ctx->flying_transfers))
  79                 goto out;
  80
  81         ret = clock_gettime(CLOCK_MONOTONIC, &sys_ts);
  82         TIMESPEC_TO_TIMEVAL(&sys_tv, &sys_ts);
  83
  84         LIST_FOREACH_ENTRY(xfer, &ctx->flying_transfers, list) {
  85                 cur_tv = &xfer->timeout;
  86
  87                 if (timerisset(cur_tv) == 0)
  88                         goto out;
  89
  90                 if (xfer->flags & USB_TIMED_OUT)
  91                         continue;
  92
  93                 if ((cur_tv->tv_sec > sys_tv.tv_sec) || (cur_tv->tv_sec == sys_tv.tv_sec &&
  94                     cur_tv->tv_usec > sys_tv.tv_usec))
  95                         goto out;
  96
  97                 xfer->flags |= USB_TIMED_OUT;
  98                 uxfer = (libusb_transfer *) ((uint8_t *)xfer +
  99                     sizeof(struct usb_transfer));
 100                 ret = libusb_cancel_transfer(uxfer);
 101         }
 102 out:
 103         pthread_mutex_unlock(&ctx->flying_transfers_lock);
 104         return (ret);
 105 }
 106
 107 static int
 108 handle_events(struct libusb_context *ctx, struct timeval *tv)
 109 {
 110         struct libusb_pollfd *tmppollfd;
 111         struct libusb_device_handle *devh;
 112         struct usb_pollfd *ipollfd;
 113         struct usb_transfer *cur;
 114         struct usb_transfer *cancel;
 115         struct libusb_transfer *xfer;
 116         struct pollfd *fds;
 117         struct pollfd *tfds;
 118         nfds_t nfds;
 119         int tmpfd;
 120         int tmp;
 121         int ret;
 122         int timeout;
 123         int i;
 124
 125         GET_CONTEXT(ctx);
 126         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "handle_events enter");
 127
 128         nfds = 0;
 129         i = -1;
 130
 131         pthread_mutex_lock(&ctx->pollfds_lock);
 132         LIST_FOREACH_ENTRY(ipollfd, &ctx->pollfds, list)
 133                 nfds++;
 134
 135         fds = malloc(sizeof(*fds) * nfds);
 136         if (fds == NULL)
 137                 return (LIBUSB_ERROR_NO_MEM);
 138
 139         LIST_FOREACH_ENTRY(ipollfd, &ctx->pollfds, list) {
 140                 tmppollfd = &ipollfd->pollfd;
 141                 tmpfd = tmppollfd->fd;
 142                 i++;
 143                 fds[i].fd = tmpfd;
 144                 fds[i].events = tmppollfd->events;
 145                 fds[i].revents = 0;
 146         }
 147
 148         pthread_mutex_unlock(&ctx->pollfds_lock);
 149
 150         timeout = (tv->tv_sec * 1000) + (tv->tv_usec / 1000);
 151         if (tv->tv_usec % 1000)
 152                 timeout++;
 153
 154         ret = poll(fds, nfds, timeout);
 155         if (ret == 0) {
 156                 free(fds);
 157                 return (handle_timeouts(ctx));
 158         } else if (ret == -1 && errno == EINTR) {
 159                 free(fds);
 160                 return (LIBUSB_ERROR_INTERRUPTED);
 161         } else if (ret < 0) {
 162                 free(fds);
 163                 return (LIBUSB_ERROR_IO);
 164         }
 165
 166         if (fds[0].revents) {
 167                 if (ret == 1){
 168                         ret = 0;
 169                         goto handled;
 170                 } else {
 171                         fds[0].revents = 0;
 172                         ret--;
 173                 }
 174         }
 175
 176         pthread_mutex_lock(&ctx->open_devs_lock);
 177         for (i = 0 ; i < nfds && ret > 0 ; i++) {
 178
 179                 tfds = &fds[i];
 180                 if (!tfds->revents)
 181                         continue;
 182
 183                 ret--;
 184                 LIST_FOREACH_ENTRY(devh, &ctx->open_devs, list) {
 185                         if (libusb20_dev_get_fd(devh->os_priv) == tfds->fd)
 186                                 break ;
 187                 }
 188
 189                 if (tfds->revents & POLLERR) {
 190                         usb_remove_pollfd(ctx, libusb20_dev_get_fd(devh->os_priv));
 191                         usb_handle_disconnect(devh);
 192                         continue ;
 193                 }
 194
 195
 196                 pthread_mutex_lock(&libusb20_lock);
 197                 dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "LIBUSB20_PROCESS");
 198                 ret = libusb20_dev_process(devh->os_priv);
 199                 pthread_mutex_unlock(&libusb20_lock);
 200
 201
 202                 if (ret == 0 || ret == LIBUSB20_ERROR_NO_DEVICE)
 203                         continue;
 204                 else if (ret < 0)
 205                         goto out;
 206         }
 207
 208         ret = 0;
 209 out:
 210         pthread_mutex_unlock(&ctx->open_devs_lock);
 211
 212 handled:
 213         free(fds);
 214         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "handle_events leave");
 215         return ret;
 216 }
 217
 218 /* Polling and timing */
 219
 220 int
 221 libusb_try_lock_events(libusb_context * ctx)
 222 {
 223         int ret;
 224
 225         GET_CONTEXT(ctx);
 226         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_try_lock_events enter");
 227
 228         pthread_mutex_lock(&ctx->pollfd_modify_lock);
 229         ret = ctx->pollfd_modify;
 230         pthread_mutex_unlock(&ctx->pollfd_modify_lock);
 231
 232         if (ret != 0)
 233                 return (1);
 234
 235         ret = pthread_mutex_trylock(&ctx->events_lock);
 236
 237         if (ret != 0)
 238                 return (1);
 239
 240         ctx->event_handler_active = 1;
 241
 242         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_try_lock_events leave");
 243         return (0);
 244 }
 245
 246 void
 247 libusb_lock_events(libusb_context * ctx)
 248 {
 249         GET_CONTEXT(ctx);
 250         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_events enter");
 251
 252         pthread_mutex_lock(&ctx->events_lock);
 253         ctx->event_handler_active = 1;
 254
 255         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_events leave");
 256 }
 257
 258 void
 259 libusb_unlock_events(libusb_context * ctx)
 260 {
 261         GET_CONTEXT(ctx);
 262         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_events enter");
 263
 264         ctx->event_handler_active = 0;
 265         pthread_mutex_unlock(&ctx->events_lock);
 266
 267         pthread_mutex_lock(&ctx->event_waiters_lock);
 268         pthread_cond_broadcast(&ctx->event_waiters_cond);
 269         pthread_mutex_unlock(&ctx->event_waiters_lock);
 270
 271         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_events leave");
 272 }
 273
 274 int
 275 libusb_event_handling_ok(libusb_context * ctx)
 276 {
 277         int ret;
 278
 279         GET_CONTEXT(ctx);
 280         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handling_ok enter");
 281
 282         pthread_mutex_lock(&ctx->pollfd_modify_lock);
 283         ret = ctx->pollfd_modify;
 284         pthread_mutex_unlock(&ctx->pollfd_modify_lock);
 285
 286         if (ret != 0)
 287                 return (0);
 288
 289         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handling_ok leave");
 290         return (1);
 291 }
 292
 293 int
 294 libusb_event_handler_active(libusb_context * ctx)
 295 {
 296         int ret;
 297
 298         GET_CONTEXT(ctx);
 299         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handler_active enter");
 300
 301         pthread_mutex_lock(&ctx->pollfd_modify_lock);
 302         ret = ctx->pollfd_modify;
 303         pthread_mutex_unlock(&ctx->pollfd_modify_lock);
 304
 305         if (ret != 0)
 306                 return (1);
 307
 308         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_event_handler_active leave");
 309         return (ctx->event_handler_active);
 310 }
 311
 312 void
 313 libusb_lock_event_waiters(libusb_context * ctx)
 314 {
 315         GET_CONTEXT(ctx);
 316         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_event_waiters enter");
 317
 318         pthread_mutex_lock(&ctx->event_waiters_lock);
 319
 320         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_lock_event_waiters leave");
 321 }
 322
 323 void
 324 libusb_unlock_event_waiters(libusb_context * ctx)
 325 {
 326         GET_CONTEXT(ctx);
 327         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_event_waiters enter");
 328
 329         pthread_mutex_unlock(&ctx->event_waiters_lock);
 330
 331         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_unlock_event_waiters leave");
 332 }
 333
 334 int
 335 libusb_wait_for_event(libusb_context * ctx, struct timeval *tv)
 336 {
 337         int ret;
 338         struct timespec ts;
 339
 340         GET_CONTEXT(ctx);
 341         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_wait_for_event enter");
 342
 343         if (tv == NULL) {
 344                 pthread_cond_wait(&ctx->event_waiters_cond,
 345                     &ctx->event_waiters_lock);
 346                 return (0);
 347         }
 348
 349         ret = clock_gettime(CLOCK_REALTIME, &ts);
 350         if (ret < 0)
 351                 return (LIBUSB_ERROR_OTHER);
 352
 353         ts.tv_sec = tv->tv_sec;
 354         ts.tv_nsec = tv->tv_usec * 1000;
 355         if (ts.tv_nsec > 1000000000) {
 356                 ts.tv_nsec -= 1000000000;
 357                 ts.tv_sec++;
 358         }
 359
 360         ret = pthread_cond_timedwait(&ctx->event_waiters_cond,
 361             &ctx->event_waiters_lock, &ts);
 362
 363         if (ret == ETIMEDOUT)
 364                 return (1);
 365
 366         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_wait_for_event leave");
 367         return (0);
 368 }
 369
 370 int
 371 libusb_handle_events_timeout(libusb_context * ctx, struct timeval *tv)
 372 {
 373         struct timeval timeout;
 374         struct timeval poll_timeout;
 375         int ret;
 376
 377         GET_CONTEXT(ctx);
 378         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout enter");
 379
 380         ret = get_next_timeout(ctx, tv, &poll_timeout);
 381         if (ret != 0) {
 382                 return handle_timeouts(ctx);
 383         }
 384 retry:
 385         if (libusb_try_lock_events(ctx) == 0) {
 386                 ret = handle_events(ctx, &poll_timeout);
 387                 libusb_unlock_events(ctx);
 388                 return ret;
 389         }
 390
 391         libusb_lock_event_waiters(ctx);
 392         if (libusb_event_handler_active(ctx) == 0) {
 393                 libusb_unlock_event_waiters(ctx);
 394                 goto retry;
 395         }
 396
 397         ret = libusb_wait_for_event(ctx, &poll_timeout);
 398         libusb_unlock_event_waiters(ctx);
 399
 400         if (ret < 0)
 401                 return ret;
 402         else if (ret == 1)
 403                 return (handle_timeouts(ctx));
 404
 405         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_timeout leave");
 406         return (0);
 407 }
 408
 409 int
 410 libusb_handle_events(libusb_context * ctx)
 411 {
 412         struct timeval tv;
 413         int ret;
 414
 415         GET_CONTEXT(ctx);
 416         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events enter");
 417
 418         tv.tv_sec = 2;
 419         tv.tv_usec = 0;
 420         ret = libusb_handle_events_timeout(ctx, &tv);
 421
 422         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events leave");
 423         return (ret);
 424 }
 425
 426 int
 427 libusb_handle_events_locked(libusb_context * ctx, struct timeval *tv)
 428 {
 429         int ret;
 430         struct timeval poll_tv;
 431
 432         GET_CONTEXT(ctx);
 433         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_locked enter");
 434
 435         ret = get_next_timeout(ctx, tv, &poll_tv);
 436         if (ret != 0) {
 437                 return handle_timeouts(ctx);
 438         }
 439
 440         ret = handle_events(ctx, &poll_tv);
 441
 442         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_handle_events_locked leave");
 443         return (ret);
 444 }
 445
 446 int
 447 libusb_get_next_timeout(libusb_context * ctx, struct timeval *tv)
 448 {
 449         struct usb_transfer *xfer;
 450         struct timeval *next_tv;
 451         struct timeval cur_tv;
 452         struct timespec cur_ts;
 453         int found;
 454         int ret;
 455
 456         GET_CONTEXT(ctx);
 457         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_next_timeout enter");
 458
 459         found = 0;
 460         pthread_mutex_lock(&ctx->flying_transfers_lock);
 461         if (USB_LIST_EMPTY(&ctx->flying_transfers)) {
 462                 pthread_mutex_unlock(&ctx->flying_transfers_lock);
 463                 return (0);
 464         }
 465
 466         LIST_FOREACH_ENTRY(xfer, &ctx->flying_transfers, list) {
 467                 if (!(xfer->flags & USB_TIMED_OUT)) {
 468                         found = 1;
 469                         break ;
 470                 }
 471         }
 472         pthread_mutex_unlock(&ctx->flying_transfers_lock);
 473
 474         if (found == 0) {
 475                 return 0;
 476         }
 477
 478         next_tv = &xfer->timeout;
 479         if (timerisset(next_tv) == 0)
 480                 return (0);
 481
 482         ret = clock_gettime(CLOCK_MONOTONIC, &cur_ts);
 483         if (ret < 0)
 484                 return (LIBUSB_ERROR_OTHER);
 485         TIMESPEC_TO_TIMEVAL(&cur_tv, &cur_ts);
 486
 487         if (timercmp(&cur_tv, next_tv, >=) != 0)
 488                 timerclear(tv);
 489         else
 490                 timersub(next_tv, &cur_tv, tv);
 491
 492         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_next_timeout leave");
 493         return (1);
 494 }
 495
 496 void
 497 libusb_set_pollfd_notifiers(libusb_context * ctx,
 498     libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb,
 499     void *user_data)
 500 {
 501         GET_CONTEXT(ctx);
 502         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_pollfd_notifiers enter");
 503
 504         ctx->fd_added_cb = added_cb;
 505         ctx->fd_removed_cb = removed_cb;
 506         ctx->fd_cb_user_data = user_data;
 507
 508         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_set_pollfd_notifiers leave");
 509 }
 510
 511 struct libusb_pollfd **
 512 libusb_get_pollfds(libusb_context * ctx)
 513 {
 514         struct usb_pollfd *pollfd;
 515         libusb_pollfd **ret;
 516         int i;
 517
 518         GET_CONTEXT(ctx);
 519         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_pollfds enter");
 520
 521         i = 0;
 522         pthread_mutex_lock(&ctx->pollfds_lock);
 523         LIST_FOREACH_ENTRY(pollfd, &ctx->pollfds, list)
 524                 i++;
 525
 526         ret = calloc(i + 1 , sizeof(struct libusb_pollfd *));
 527         if (ret == NULL) {
 528                 pthread_mutex_unlock(&ctx->pollfds_lock);
 529                 return (ret);
 530         }
 531
 532         i = 0;
 533         LIST_FOREACH_ENTRY(pollfd, &ctx->pollfds, list)
 534                 ret[i++] = (struct libusb_pollfd *) pollfd;
 535         ret[i] = NULL;
 536
 537         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_get_pollfds leave");
 538         return (ret);
 539 }
 540
 541
 542 /* Synchronous device I/O */
 543
 544 static void ctrl_tr_cb(struct libusb_transfer *transfer)
 545 {
 546         libusb_context *ctx;
 547         int *complet;
 548
 549         ctx = NULL;
 550         GET_CONTEXT(ctx);
 551         dprintf(ctx, LIBUSB_DEBUG_TRANSFER, "CALLBACK ENTER");
 552
 553         complet = transfer->user_data;
 554         *complet = 1;
 555 }
 556
 557 int
 558 libusb_control_transfer(libusb_device_handle * devh,
 559     uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
 560     unsigned char *data, uint16_t wLength, unsigned int timeout)
 561 {
 562         struct libusb_transfer *xfer;
 563         struct libusb_control_setup *ctr;
 564         libusb_context *ctx;
 565         unsigned char *buff;
 566         int complet;
 567         int ret;
 568
 569         ctx = devh->dev->ctx;
 570         GET_CONTEXT(ctx);
 571         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_control_transfer enter");
 572
 573         if (devh == NULL || data == NULL)
 574                 return (LIBUSB_ERROR_NO_MEM);
 575
 576         xfer = libusb_alloc_transfer(0);
 577         if (xfer == NULL)
 578                 return (LIBUSB_ERROR_NO_MEM);
 579
 580         buff = malloc(sizeof(libusb_control_setup) + wLength);
 581         if (buff == NULL) {
 582                 libusb_free_transfer(xfer);
 583                 return (LIBUSB_ERROR_NO_MEM);
 584         }
 585
 586         ctr = (libusb_control_setup *)buff;
 587         ctr->bmRequestType = bmRequestType;
 588         ctr->bRequest = bRequest;
 589         ctr->wValue = wValue;
 590         ctr->wIndex = wIndex;
 591         ctr->wLength = wLength;
 592         if ((bmRequestType & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_OUT)
 593                 memcpy(buff + sizeof(libusb_control_setup), data, wLength);
 594
 595         xfer->dev_handle = devh;
 596         xfer->endpoint = 0;
 597         xfer->type = LIBUSB_TRANSFER_TYPE_CONTROL;
 598         xfer->timeout = timeout;
 599         xfer->buffer = buff;
 600         xfer->length = sizeof(libusb_control_setup) + wLength;
 601         xfer->user_data = &complet;
 602         xfer->callback = ctrl_tr_cb;
 603         xfer->flags = LIBUSB_TRANSFER_FREE_TRANSFER;
 604         complet = 0;
 605
 606         if ((ret = libusb_submit_transfer(xfer)) < 0) {
 607                 libusb_free_transfer(xfer);
 608                 return (ret);
 609         }
 610
 611         while (complet == 0)
 612                 if ((ret = libusb_handle_events(ctx)) < 0) {
 613                         libusb_cancel_transfer(xfer);
 614                         while (complet == 0)
 615                                 if (libusb_handle_events(ctx) < 0) {
 616                                         break;
 617                                 }
 618                         libusb_free_transfer(xfer);
 619                         return (ret);
 620                 }
 621
 622
 623         if ((bmRequestType & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN)
 624                 memcpy(data, buff + sizeof(libusb_control_setup), wLength);
 625
 626         switch (xfer->status) {
 627         case LIBUSB_TRANSFER_COMPLETED:
 628                 ret = xfer->actual_length;
 629                 break;
 630         case LIBUSB_TRANSFER_TIMED_OUT:
 631         case LIBUSB_TRANSFER_STALL:
 632         case LIBUSB_TRANSFER_NO_DEVICE:
 633                 ret = xfer->status;
 634                 break;
 635         default:
 636                 ret = LIBUSB_ERROR_OTHER;
 637         }
 638         libusb_free_transfer(xfer);
 639
 640         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_control_transfer leave");
 641         return (ret);
 642 }
 643
 644 static int
 645 do_transfer(struct libusb_device_handle *devh,
 646     unsigned char endpoint, unsigned char *data, int length,
 647     int *transferred, unsigned int timeout, int type)
 648 {
 649         struct libusb_transfer *xfer;
 650         libusb_context *ctx;
 651         int complet;
 652         int ret;
 653
 654         if (devh == NULL || data == NULL)
 655                 return (LIBUSB_ERROR_NO_MEM);
 656
 657         xfer = libusb_alloc_transfer(0);
 658         if (xfer == NULL)
 659                 return (LIBUSB_ERROR_NO_MEM);
 660
 661         ctx = devh->dev->ctx;
 662
 663         xfer->dev_handle = devh;
 664         xfer->endpoint = endpoint;
 665         xfer->type = type;
 666         xfer->timeout = timeout;
 667         xfer->buffer = data;
 668         xfer->length = length;
 669         xfer->user_data = &complet;
 670         xfer->callback = ctrl_tr_cb;
 671         complet = 0;
 672
 673         if ((ret = libusb_submit_transfer(xfer)) < 0) {
 674                 libusb_free_transfer(xfer);
 675                 return (ret);
 676         }
 677
 678         while (complet == 0) {
 679                 if ((ret = libusb_handle_events(ctx)) < 0) {
 680                         libusb_cancel_transfer(xfer);
 681                         libusb_free_transfer(xfer);
 682                         while (complet == 0) {
 683                                 if (libusb_handle_events(ctx) < 0)
 684                                         break ;
 685                         }
 686                         return (ret);
 687                 }
 688         }
 689
 690         *transferred = xfer->actual_length;
 691         switch (xfer->status) {
 692         case LIBUSB_TRANSFER_COMPLETED:
 693                 ret = xfer->actual_length;
 694                 break;
 695         case LIBUSB_TRANSFER_TIMED_OUT:
 696         case LIBUSB_TRANSFER_OVERFLOW:
 697         case LIBUSB_TRANSFER_STALL:
 698         case LIBUSB_TRANSFER_NO_DEVICE:
 699                 ret = xfer->status;
 700                 break;
 701         default:
 702                 ret = LIBUSB_ERROR_OTHER;
 703         }
 704
 705         libusb_free_transfer(xfer);
 706         return (ret);
 707 }
 708
 709 int
 710 libusb_bulk_transfer(struct libusb_device_handle *devh,
 711     unsigned char endpoint, unsigned char *data, int length,
 712     int *transferred, unsigned int timeout)
 713 {
 714         libusb_context *ctx;
 715         int ret;
 716
 717         ctx = NULL;
 718         GET_CONTEXT(ctx);
 719         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer enter");
 720
 721         ret = do_transfer(devh, endpoint, data, length, transferred,
 722             timeout, LIBUSB_TRANSFER_TYPE_BULK);
 723
 724         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_bulk_transfer leave");
 725         return (ret);
 726 }
 727
 728 /*
 729  * Need to fix xfer->type
 730  */
 731 int
 732 libusb_interrupt_transfer(struct libusb_device_handle *devh,
 733     unsigned char endpoint, unsigned char *data, int length,
 734     int *transferred, unsigned int timeout)
 735 {
 736         libusb_context *ctx;
 737         int ret;
 738
 739         ctx = NULL;
 740         GET_CONTEXT(ctx);
 741         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer enter");
 742
 743         ret = do_transfer(devh, endpoint, data, length, transferred,
 744             timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT);
 745
 746         dprintf(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_interrupt_transfer leave");
 747         return (ret);
 748 }