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 <assert.h>
32 #include <errno.h>
33 #include <poll.h>
34 #include <pthread.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <time.h>
39 #include <unistd.h>
40 #include <sys/eventfd.h>
41 #include <sys/queue.h>
42 #include <sys/endian.h>
43 #endif
44
45 #define libusb_device_handle libusb20_device
46
47 #include "libusb20.h"
48 #include "libusb20_desc.h"
49 #include "libusb20_int.h"
50 #include "libusb.h"
51 #include "libusb10.h"
52
53 UNEXPORTED void
libusb10_add_pollfd(libusb_context * ctx,struct libusb_super_pollfd * pollfd,struct libusb20_device * pdev,int fd,short events)54 libusb10_add_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd,
55 struct libusb20_device *pdev, int fd, short events)
56 {
57 if (ctx == NULL)
58 return; /* invalid */
59
60 if (pollfd->entry.tqe_prev != NULL)
61 return; /* already queued */
62
63 if (fd < 0)
64 return; /* invalid */
65
66 pollfd->pdev = pdev;
67 pollfd->pollfd.fd = fd;
68 pollfd->pollfd.events = events;
69
70 CTX_LOCK(ctx);
71 TAILQ_INSERT_TAIL(&ctx->pollfds, pollfd, entry);
72 CTX_UNLOCK(ctx);
73
74 if (ctx->fd_added_cb)
75 ctx->fd_added_cb(fd, events, ctx->fd_cb_user_data);
76 }
77
78 UNEXPORTED void
libusb10_remove_pollfd(libusb_context * ctx,struct libusb_super_pollfd * pollfd)79 libusb10_remove_pollfd(libusb_context *ctx, struct libusb_super_pollfd *pollfd)
80 {
81 if (ctx == NULL)
82 return; /* invalid */
83
84 if (pollfd->entry.tqe_prev == NULL)
85 return; /* already dequeued */
86
87 CTX_LOCK(ctx);
88 TAILQ_REMOVE(&ctx->pollfds, pollfd, entry);
89 pollfd->entry.tqe_prev = NULL;
90 CTX_UNLOCK(ctx);
91
92 if (ctx->fd_removed_cb)
93 ctx->fd_removed_cb(pollfd->pollfd.fd, ctx->fd_cb_user_data);
94 }
95
96 /* This function must be called locked */
97
98 static int
libusb10_handle_events_sub(struct libusb_context * ctx,struct timeval * tv)99 libusb10_handle_events_sub(struct libusb_context *ctx, struct timeval *tv)
100 {
101 struct libusb_device *dev;
102 struct libusb20_device **ppdev;
103 struct libusb_super_pollfd *pfd;
104 struct pollfd *fds;
105 struct libusb_super_transfer *sxfer;
106 struct libusb_transfer *uxfer;
107 nfds_t nfds;
108 int timeout;
109 int i;
110 int err;
111
112 DPRINTF(ctx, LIBUSB_LOG_LEVEL_DEBUG, "libusb10_handle_events_sub enter");
113
114 nfds = 0;
115 i = 0;
116 TAILQ_FOREACH(pfd, &ctx->pollfds, entry)
117 nfds++;
118
119 fds = alloca(sizeof(*fds) * nfds);
120 if (fds == NULL)
121 return (LIBUSB_ERROR_NO_MEM);
122
123 ppdev = alloca(sizeof(*ppdev) * nfds);
124 if (ppdev == NULL)
125 return (LIBUSB_ERROR_NO_MEM);
126
127 TAILQ_FOREACH(pfd, &ctx->pollfds, entry) {
128 fds[i].fd = pfd->pollfd.fd;
129 fds[i].events = pfd->pollfd.events;
130 fds[i].revents = 0;
131 ppdev[i] = pfd->pdev;
132 if (pfd->pdev != NULL)
133 libusb_get_device(pfd->pdev)->refcnt++;
134 i++;
135 }
136
137 if (tv == NULL)
138 timeout = -1;
139 else
140 timeout = (tv->tv_sec * 1000) + ((tv->tv_usec + 999) / 1000);
141
142 CTX_UNLOCK(ctx);
143 err = poll(fds, nfds, timeout);
144 CTX_LOCK(ctx);
145
146 if ((err == -1) && (errno == EINTR))
147 err = LIBUSB_ERROR_INTERRUPTED;
148 else if (err < 0)
149 err = LIBUSB_ERROR_IO;
150
151 if (err < 1) {
152 for (i = 0; i != (int)nfds; i++) {
153 if (ppdev[i] != NULL) {
154 CTX_UNLOCK(ctx);
155 libusb_unref_device(libusb_get_device(ppdev[i]));
156 CTX_LOCK(ctx);
157 }
158 }
159 goto do_done;
160 }
161 for (i = 0; i != (int)nfds; i++) {
162 if (ppdev[i] != NULL) {
163 dev = libusb_get_device(ppdev[i]);
164
165 if (fds[i].revents != 0) {
166 err = libusb20_dev_process(ppdev[i]);
167
168 if (err) {
169 /*
170 * When the device is opened
171 * set the "device_is_gone"
172 * flag. This prevents the
173 * client from submitting new
174 * USB transfers to a detached
175 * device.
176 */
177 if (ppdev[i]->is_opened)
178 dev->device_is_gone = 1;
179
180 /* remove USB device from polling loop */
181 libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
182
183 /* cancel all pending transfers */
184 libusb10_cancel_all_transfer_locked(ppdev[i], dev);
185 }
186 }
187 CTX_UNLOCK(ctx);
188 libusb_unref_device(dev);
189 CTX_LOCK(ctx);
190
191 } else {
192 eventfd_read(fds[i].fd, &(eventfd_t){0});
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 DPRINTF(ctx, LIBUSB_LOG_LEVEL_DEBUG, "libusb10_handle_events_sub complete");
235
236 return (err);
237 }
238
239 /* Polling and timing */
240
241 int
libusb_try_lock_events(libusb_context * ctx)242 libusb_try_lock_events(libusb_context *ctx)
243 {
244 int err;
245
246 ctx = GET_CONTEXT(ctx);
247 if (ctx == NULL)
248 return (1);
249
250 err = CTX_TRYLOCK(ctx);
251 if (err)
252 return (1);
253
254 err = (ctx->ctx_handler != NO_THREAD);
255 if (err)
256 CTX_UNLOCK(ctx);
257 else
258 ctx->ctx_handler = pthread_self();
259
260 return (err);
261 }
262
263 void
libusb_lock_events(libusb_context * ctx)264 libusb_lock_events(libusb_context *ctx)
265 {
266 ctx = GET_CONTEXT(ctx);
267 CTX_LOCK(ctx);
268 if (ctx->ctx_handler == NO_THREAD)
269 ctx->ctx_handler = pthread_self();
270 }
271
272 void
libusb_unlock_events(libusb_context * ctx)273 libusb_unlock_events(libusb_context *ctx)
274 {
275 ctx = GET_CONTEXT(ctx);
276 if (ctx->ctx_handler == pthread_self()) {
277 ctx->ctx_handler = NO_THREAD;
278 pthread_cond_broadcast(&ctx->ctx_cond);
279 }
280 CTX_UNLOCK(ctx);
281 }
282
283 int
libusb_event_handling_ok(libusb_context * ctx)284 libusb_event_handling_ok(libusb_context *ctx)
285 {
286 ctx = GET_CONTEXT(ctx);
287 return (ctx->ctx_handler == pthread_self());
288 }
289
290 int
libusb_event_handler_active(libusb_context * ctx)291 libusb_event_handler_active(libusb_context *ctx)
292 {
293 ctx = GET_CONTEXT(ctx);
294 return (ctx->ctx_handler != NO_THREAD);
295 }
296
297 void
libusb_lock_event_waiters(libusb_context * ctx)298 libusb_lock_event_waiters(libusb_context *ctx)
299 {
300 ctx = GET_CONTEXT(ctx);
301 CTX_LOCK(ctx);
302 }
303
304 void
libusb_unlock_event_waiters(libusb_context * ctx)305 libusb_unlock_event_waiters(libusb_context *ctx)
306 {
307 ctx = GET_CONTEXT(ctx);
308 CTX_UNLOCK(ctx);
309 }
310
311 int
libusb_wait_for_event(libusb_context * ctx,struct timeval * tv)312 libusb_wait_for_event(libusb_context *ctx, struct timeval *tv)
313 {
314 struct timespec ts;
315 int err;
316
317 ctx = GET_CONTEXT(ctx);
318 DPRINTF(ctx, LIBUSB_LOG_LEVEL_DEBUG, "libusb_wait_for_event enter");
319
320 if (tv == NULL) {
321 pthread_cond_wait(&ctx->ctx_cond,
322 &ctx->ctx_lock);
323 /* try to grab polling of actual events, if any */
324 if (ctx->ctx_handler == NO_THREAD)
325 ctx->ctx_handler = pthread_self();
326 return (0);
327 }
328 err = clock_gettime(CLOCK_MONOTONIC, &ts);
329 if (err < 0)
330 return (LIBUSB_ERROR_OTHER);
331
332 /*
333 * The "tv" arguments points to a relative time structure and
334 * not an absolute time structure.
335 */
336 ts.tv_sec += tv->tv_sec;
337 ts.tv_nsec += tv->tv_usec * 1000;
338 if (ts.tv_nsec >= 1000000000) {
339 ts.tv_nsec -= 1000000000;
340 ts.tv_sec++;
341 }
342 err = pthread_cond_timedwait(&ctx->ctx_cond,
343 &ctx->ctx_lock, &ts);
344 /* try to grab polling of actual events, if any */
345 if (ctx->ctx_handler == NO_THREAD)
346 ctx->ctx_handler = pthread_self();
347
348 if (err == ETIMEDOUT)
349 return (1);
350
351 return (0);
352 }
353
354 int
libusb_handle_events_timeout_completed(libusb_context * ctx,struct timeval * tv,int * completed)355 libusb_handle_events_timeout_completed(libusb_context *ctx,
356 struct timeval *tv, int *completed)
357 {
358 int err = 0;
359
360 ctx = GET_CONTEXT(ctx);
361
362 DPRINTF(ctx, LIBUSB_LOG_LEVEL_DEBUG, "libusb_handle_events_timeout_completed enter");
363
364 libusb_lock_events(ctx);
365
366 while (1) {
367 if (completed != NULL) {
368 if (*completed != 0 || err != 0)
369 break;
370 }
371 err = libusb_handle_events_locked(ctx, tv);
372 if (completed == NULL)
373 break;
374 }
375
376 libusb_unlock_events(ctx);
377
378 DPRINTF(ctx, LIBUSB_LOG_LEVEL_DEBUG, "libusb_handle_events_timeout_completed exit");
379
380 return (err);
381 }
382
383 int
libusb_handle_events_completed(libusb_context * ctx,int * completed)384 libusb_handle_events_completed(libusb_context *ctx, int *completed)
385 {
386 return (libusb_handle_events_timeout_completed(ctx, NULL, completed));
387 }
388
389 int
libusb_handle_events_timeout(libusb_context * ctx,struct timeval * tv)390 libusb_handle_events_timeout(libusb_context *ctx, struct timeval *tv)
391 {
392 return (libusb_handle_events_timeout_completed(ctx, tv, NULL));
393 }
394
395 int
libusb_handle_events(libusb_context * ctx)396 libusb_handle_events(libusb_context *ctx)
397 {
398 return (libusb_handle_events_timeout_completed(ctx, NULL, NULL));
399 }
400
401 int
libusb_handle_events_locked(libusb_context * ctx,struct timeval * tv)402 libusb_handle_events_locked(libusb_context *ctx, struct timeval *tv)
403 {
404 int err;
405
406 ctx = GET_CONTEXT(ctx);
407
408 if (libusb_event_handling_ok(ctx)) {
409 err = libusb10_handle_events_sub(ctx, tv);
410 } else {
411 err = libusb_wait_for_event(ctx, tv);
412 if (err != 0)
413 err = LIBUSB_ERROR_TIMEOUT;
414 }
415 return (err);
416 }
417
418 int
libusb_get_next_timeout(libusb_context * ctx,struct timeval * tv)419 libusb_get_next_timeout(libusb_context *ctx, struct timeval *tv)
420 {
421 /* all timeouts are currently being done by the kernel */
422 timerclear(tv);
423 return (0);
424 }
425
426 int
libusb_pollfds_handle_timeouts(libusb_context * ctx)427 libusb_pollfds_handle_timeouts(libusb_context *ctx)
428 {
429 return (1);
430 }
431
432 void
libusb_set_pollfd_notifiers(libusb_context * ctx,libusb_pollfd_added_cb added_cb,libusb_pollfd_removed_cb removed_cb,void * user_data)433 libusb_set_pollfd_notifiers(libusb_context *ctx,
434 libusb_pollfd_added_cb added_cb, libusb_pollfd_removed_cb removed_cb,
435 void *user_data)
436 {
437 ctx = GET_CONTEXT(ctx);
438
439 ctx->fd_added_cb = added_cb;
440 ctx->fd_removed_cb = removed_cb;
441 ctx->fd_cb_user_data = user_data;
442 }
443
444 const struct libusb_pollfd **
libusb_get_pollfds(libusb_context * ctx)445 libusb_get_pollfds(libusb_context *ctx)
446 {
447 struct libusb_super_pollfd *pollfd;
448 libusb_pollfd **ret;
449 int i;
450
451 ctx = GET_CONTEXT(ctx);
452
453 CTX_LOCK(ctx);
454
455 i = 0;
456 TAILQ_FOREACH(pollfd, &ctx->pollfds, entry)
457 i++;
458
459 ret = calloc(i + 1, sizeof(struct libusb_pollfd *));
460 if (ret == NULL)
461 goto done;
462
463 i = 0;
464 TAILQ_FOREACH(pollfd, &ctx->pollfds, entry)
465 ret[i++] = &pollfd->pollfd;
466 ret[i] = NULL;
467
468 done:
469 CTX_UNLOCK(ctx);
470 return ((const struct libusb_pollfd **)ret);
471 }
472
473
474 /* Synchronous device I/O */
475
476 static int
libusb10_convert_libusb20_error(int err)477 libusb10_convert_libusb20_error(int err)
478 {
479 /* LIBUSB20_ERROR_* values are always non-positive */
480 assert(err <= 0);
481
482 switch (err) {
483 case LIBUSB20_SUCCESS:
484 return (0);
485 case LIBUSB20_ERROR_IO:
486 return (LIBUSB_ERROR_IO);
487 case LIBUSB20_ERROR_INVALID_PARAM:
488 return (LIBUSB_ERROR_INVALID_PARAM);
489 case LIBUSB20_ERROR_ACCESS:
490 return (LIBUSB_ERROR_ACCESS);
491 case LIBUSB20_ERROR_NO_DEVICE:
492 return (LIBUSB_ERROR_NO_DEVICE);
493 case LIBUSB20_ERROR_NOT_FOUND:
494 return (LIBUSB_ERROR_NOT_FOUND);
495 case LIBUSB20_ERROR_BUSY:
496 return (LIBUSB_ERROR_BUSY);
497 case LIBUSB20_ERROR_TIMEOUT:
498 return (LIBUSB_ERROR_TIMEOUT);
499 case LIBUSB20_ERROR_OVERFLOW:
500 return (LIBUSB_ERROR_OVERFLOW);
501 case LIBUSB20_ERROR_PIPE:
502 return (LIBUSB_ERROR_PIPE);
503 case LIBUSB20_ERROR_INTERRUPTED:
504 return (LIBUSB_ERROR_INTERRUPTED);
505 case LIBUSB20_ERROR_NO_MEM:
506 return (LIBUSB_ERROR_NO_MEM);
507 case LIBUSB20_ERROR_NOT_SUPPORTED:
508 return (LIBUSB_ERROR_NOT_SUPPORTED);
509 default:
510 return (LIBUSB_ERROR_OTHER);
511 }
512 }
513
514 int
libusb_control_transfer(libusb_device_handle * devh,uint8_t bmRequestType,uint8_t bRequest,uint16_t wValue,uint16_t wIndex,uint8_t * data,uint16_t wLength,unsigned int timeout)515 libusb_control_transfer(libusb_device_handle *devh,
516 uint8_t bmRequestType, uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
517 uint8_t *data, uint16_t wLength, unsigned int timeout)
518 {
519 struct LIBUSB20_CONTROL_SETUP_DECODED req;
520 int err;
521 uint16_t actlen;
522
523 if (devh == NULL)
524 return (LIBUSB_ERROR_INVALID_PARAM);
525
526 if ((wLength != 0) && (data == NULL))
527 return (LIBUSB_ERROR_INVALID_PARAM);
528
529 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req);
530
531 req.bmRequestType = bmRequestType;
532 req.bRequest = bRequest;
533 req.wValue = wValue;
534 req.wIndex = wIndex;
535 req.wLength = wLength;
536
537 err = libusb20_dev_request_sync(devh, &req, data,
538 &actlen, timeout, 0);
539
540 if (err)
541 return (libusb10_convert_libusb20_error(err));
542
543 return (actlen);
544 }
545
546 static libusb_context *
libusb10_get_context_by_device_handle(libusb_device_handle * devh)547 libusb10_get_context_by_device_handle(libusb_device_handle *devh)
548 {
549 libusb_context *ctx;
550
551 if (devh != NULL)
552 ctx = libusb_get_device(devh)->ctx;
553 else
554 ctx = NULL;
555
556 return (GET_CONTEXT(ctx));
557 }
558
559 static void
libusb10_do_transfer_cb(struct libusb_transfer * transfer)560 libusb10_do_transfer_cb(struct libusb_transfer *transfer)
561 {
562 libusb_context *ctx;
563 int *pdone;
564
565 ctx = libusb10_get_context_by_device_handle(transfer->dev_handle);
566
567 DPRINTF(ctx, LIBUSB_LOG_LEVEL_DEBUG, "sync I/O done");
568
569 pdone = transfer->user_data;
570 *pdone = 1;
571 }
572
573 /*
574 * TODO: Replace the following function. Allocating and freeing on a
575 * per-transfer basis is slow. --HPS
576 */
577 static int
libusb10_do_transfer(libusb_device_handle * devh,uint8_t endpoint,uint8_t * data,int length,int * transferred,unsigned int timeout,int type)578 libusb10_do_transfer(libusb_device_handle *devh,
579 uint8_t endpoint, uint8_t *data, int length,
580 int *transferred, unsigned int timeout, int type)
581 {
582 libusb_context *ctx;
583 struct libusb_transfer *xfer;
584 int done;
585 int ret;
586
587 if (devh == NULL)
588 return (LIBUSB_ERROR_INVALID_PARAM);
589
590 if ((length != 0) && (data == NULL))
591 return (LIBUSB_ERROR_INVALID_PARAM);
592
593 xfer = libusb_alloc_transfer(0);
594 if (xfer == NULL)
595 return (LIBUSB_ERROR_NO_MEM);
596
597 ctx = libusb_get_device(devh)->ctx;
598
599 xfer->dev_handle = devh;
600 xfer->endpoint = endpoint;
601 xfer->type = type;
602 xfer->timeout = timeout;
603 xfer->buffer = data;
604 xfer->length = length;
605 xfer->user_data = (void *)&done;
606 xfer->callback = libusb10_do_transfer_cb;
607 done = 0;
608
609 if ((ret = libusb_submit_transfer(xfer)) < 0) {
610 libusb_free_transfer(xfer);
611 return (ret);
612 }
613 while (done == 0) {
614 if ((ret = libusb_handle_events(ctx)) < 0) {
615 libusb_cancel_transfer(xfer);
616 usleep(1000); /* nice it */
617 }
618 }
619
620 *transferred = xfer->actual_length;
621
622 switch (xfer->status) {
623 case LIBUSB_TRANSFER_COMPLETED:
624 ret = 0;
625 break;
626 case LIBUSB_TRANSFER_TIMED_OUT:
627 ret = LIBUSB_ERROR_TIMEOUT;
628 break;
629 case LIBUSB_TRANSFER_OVERFLOW:
630 ret = LIBUSB_ERROR_OVERFLOW;
631 break;
632 case LIBUSB_TRANSFER_STALL:
633 ret = LIBUSB_ERROR_PIPE;
634 break;
635 case LIBUSB_TRANSFER_NO_DEVICE:
636 ret = LIBUSB_ERROR_NO_DEVICE;
637 break;
638 default:
639 ret = LIBUSB_ERROR_OTHER;
640 break;
641 }
642
643 libusb_free_transfer(xfer);
644 return (ret);
645 }
646
647 int
libusb_bulk_transfer(libusb_device_handle * devh,uint8_t endpoint,uint8_t * data,int length,int * transferred,unsigned int timeout)648 libusb_bulk_transfer(libusb_device_handle *devh,
649 uint8_t endpoint, uint8_t *data, int length,
650 int *transferred, unsigned int timeout)
651 {
652 libusb_context *ctx;
653 int ret;
654
655 ctx = libusb10_get_context_by_device_handle(devh);
656
657 DPRINTF(ctx, LIBUSB_LOG_LEVEL_DEBUG, "libusb_bulk_transfer enter");
658
659 ret = libusb10_do_transfer(devh, endpoint, data, length, transferred,
660 timeout, LIBUSB_TRANSFER_TYPE_BULK);
661
662 DPRINTF(ctx, LIBUSB_LOG_LEVEL_DEBUG, "libusb_bulk_transfer leave");
663 return (ret);
664 }
665
666 int
libusb_interrupt_transfer(libusb_device_handle * devh,uint8_t endpoint,uint8_t * data,int length,int * transferred,unsigned int timeout)667 libusb_interrupt_transfer(libusb_device_handle *devh,
668 uint8_t endpoint, uint8_t *data, int length,
669 int *transferred, unsigned int timeout)
670 {
671 libusb_context *ctx;
672 int ret;
673
674 ctx = libusb10_get_context_by_device_handle(devh);
675
676 DPRINTF(ctx, LIBUSB_LOG_LEVEL_DEBUG, "libusb_interrupt_transfer enter");
677
678 ret = libusb10_do_transfer(devh, endpoint, data, length, transferred,
679 timeout, LIBUSB_TRANSFER_TYPE_INTERRUPT);
680
681 DPRINTF(ctx, LIBUSB_LOG_LEVEL_DEBUG, "libusb_interrupt_transfer leave");
682 return (ret);
683 }
684
685 uint8_t *
libusb_get_iso_packet_buffer(struct libusb_transfer * transfer,uint32_t off)686 libusb_get_iso_packet_buffer(struct libusb_transfer *transfer, uint32_t off)
687 {
688 uint8_t *ptr;
689 uint32_t n;
690
691 if (transfer->num_iso_packets < 0)
692 return (NULL);
693
694 if (off >= (uint32_t)transfer->num_iso_packets)
695 return (NULL);
696
697 ptr = transfer->buffer;
698 if (ptr == NULL)
699 return (NULL);
700
701 for (n = 0; n != off; n++) {
702 ptr += transfer->iso_packet_desc[n].length;
703 }
704 return (ptr);
705 }
706
707 uint8_t *
libusb_get_iso_packet_buffer_simple(struct libusb_transfer * transfer,uint32_t off)708 libusb_get_iso_packet_buffer_simple(struct libusb_transfer *transfer, uint32_t off)
709 {
710 uint8_t *ptr;
711
712 if (transfer->num_iso_packets < 0)
713 return (NULL);
714
715 if (off >= (uint32_t)transfer->num_iso_packets)
716 return (NULL);
717
718 ptr = transfer->buffer;
719 if (ptr == NULL)
720 return (NULL);
721
722 ptr += transfer->iso_packet_desc[0].length * off;
723
724 return (ptr);
725 }
726
727 void
libusb_set_iso_packet_lengths(struct libusb_transfer * transfer,uint32_t length)728 libusb_set_iso_packet_lengths(struct libusb_transfer *transfer, uint32_t length)
729 {
730 int n;
731
732 if (transfer->num_iso_packets < 0)
733 return;
734
735 for (n = 0; n != transfer->num_iso_packets; n++)
736 transfer->iso_packet_desc[n].length = length;
737 }
738
739 uint8_t *
libusb_control_transfer_get_data(struct libusb_transfer * transfer)740 libusb_control_transfer_get_data(struct libusb_transfer *transfer)
741 {
742 if (transfer->buffer == NULL)
743 return (NULL);
744
745 return (transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE);
746 }
747
748 struct libusb_control_setup *
libusb_control_transfer_get_setup(struct libusb_transfer * transfer)749 libusb_control_transfer_get_setup(struct libusb_transfer *transfer)
750 {
751 return ((struct libusb_control_setup *)transfer->buffer);
752 }
753
754 void
libusb_fill_control_setup(uint8_t * buf,uint8_t bmRequestType,uint8_t bRequest,uint16_t wValue,uint16_t wIndex,uint16_t wLength)755 libusb_fill_control_setup(uint8_t *buf, uint8_t bmRequestType,
756 uint8_t bRequest, uint16_t wValue,
757 uint16_t wIndex, uint16_t wLength)
758 {
759 struct libusb_control_setup *req = (struct libusb_control_setup *)buf;
760
761 /* The alignment is OK for all fields below. */
762 req->bmRequestType = bmRequestType;
763 req->bRequest = bRequest;
764 req->wValue = htole16(wValue);
765 req->wIndex = htole16(wIndex);
766 req->wLength = htole16(wLength);
767 }
768
769 void
libusb_fill_control_transfer(struct libusb_transfer * transfer,libusb_device_handle * devh,uint8_t * buf,libusb_transfer_cb_fn callback,void * user_data,uint32_t timeout)770 libusb_fill_control_transfer(struct libusb_transfer *transfer,
771 libusb_device_handle *devh, uint8_t *buf,
772 libusb_transfer_cb_fn callback, void *user_data,
773 uint32_t timeout)
774 {
775 struct libusb_control_setup *setup = (struct libusb_control_setup *)buf;
776
777 transfer->dev_handle = devh;
778 transfer->endpoint = 0;
779 transfer->type = LIBUSB_TRANSFER_TYPE_CONTROL;
780 transfer->timeout = timeout;
781 transfer->buffer = buf;
782 if (setup != NULL)
783 transfer->length = LIBUSB_CONTROL_SETUP_SIZE
784 + le16toh(setup->wLength);
785 else
786 transfer->length = 0;
787 transfer->user_data = user_data;
788 transfer->callback = callback;
789
790 }
791
792 void
libusb_fill_bulk_transfer(struct libusb_transfer * transfer,libusb_device_handle * devh,uint8_t endpoint,uint8_t * buf,int length,libusb_transfer_cb_fn callback,void * user_data,uint32_t timeout)793 libusb_fill_bulk_transfer(struct libusb_transfer *transfer,
794 libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf,
795 int length, libusb_transfer_cb_fn callback, void *user_data,
796 uint32_t timeout)
797 {
798 transfer->dev_handle = devh;
799 transfer->endpoint = endpoint;
800 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
801 transfer->timeout = timeout;
802 transfer->buffer = buf;
803 transfer->length = length;
804 transfer->user_data = user_data;
805 transfer->callback = callback;
806 }
807
808 void
libusb_fill_interrupt_transfer(struct libusb_transfer * transfer,libusb_device_handle * devh,uint8_t endpoint,uint8_t * buf,int length,libusb_transfer_cb_fn callback,void * user_data,uint32_t timeout)809 libusb_fill_interrupt_transfer(struct libusb_transfer *transfer,
810 libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf,
811 int length, libusb_transfer_cb_fn callback, void *user_data,
812 uint32_t timeout)
813 {
814 transfer->dev_handle = devh;
815 transfer->endpoint = endpoint;
816 transfer->type = LIBUSB_TRANSFER_TYPE_INTERRUPT;
817 transfer->timeout = timeout;
818 transfer->buffer = buf;
819 transfer->length = length;
820 transfer->user_data = user_data;
821 transfer->callback = callback;
822 }
823
824 void
libusb_fill_bulk_stream_transfer(struct libusb_transfer * transfer,libusb_device_handle * dev_handle,unsigned char endpoint,uint32_t stream_id,unsigned char * buffer,int length,libusb_transfer_cb_fn callback,void * user_data,unsigned int timeout)825 libusb_fill_bulk_stream_transfer(struct libusb_transfer *transfer,
826 libusb_device_handle *dev_handle, unsigned char endpoint,
827 uint32_t stream_id, unsigned char *buffer, int length,
828 libusb_transfer_cb_fn callback, void *user_data, unsigned int timeout)
829 {
830 libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer,
831 length, callback, user_data, timeout);
832 transfer->type = LIBUSB_TRANSFER_TYPE_BULK_STREAM;
833
834 libusb_transfer_set_stream_id(transfer, stream_id);
835 }
836
837 void
libusb_fill_iso_transfer(struct libusb_transfer * transfer,libusb_device_handle * devh,uint8_t endpoint,uint8_t * buf,int length,int npacket,libusb_transfer_cb_fn callback,void * user_data,uint32_t timeout)838 libusb_fill_iso_transfer(struct libusb_transfer *transfer,
839 libusb_device_handle *devh, uint8_t endpoint, uint8_t *buf,
840 int length, int npacket, libusb_transfer_cb_fn callback,
841 void *user_data, uint32_t timeout)
842 {
843 transfer->dev_handle = devh;
844 transfer->endpoint = endpoint;
845 transfer->type = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS;
846 transfer->timeout = timeout;
847 transfer->buffer = buf;
848 transfer->length = length;
849 transfer->num_iso_packets = npacket;
850 transfer->user_data = user_data;
851 transfer->callback = callback;
852 }
853
854 int
libusb_alloc_streams(libusb_device_handle * dev,uint32_t num_streams,unsigned char * endpoints,int num_endpoints)855 libusb_alloc_streams(libusb_device_handle *dev, uint32_t num_streams,
856 unsigned char *endpoints, int num_endpoints)
857 {
858 if (num_streams > 1)
859 return (LIBUSB_ERROR_INVALID_PARAM);
860 return (0);
861 }
862
863 int
libusb_free_streams(libusb_device_handle * dev,unsigned char * endpoints,int num_endpoints)864 libusb_free_streams(libusb_device_handle *dev, unsigned char *endpoints, int num_endpoints)
865 {
866
867 return (0);
868 }
869
870 void
libusb_transfer_set_stream_id(struct libusb_transfer * transfer,uint32_t stream_id)871 libusb_transfer_set_stream_id(struct libusb_transfer *transfer, uint32_t stream_id)
872 {
873 struct libusb_super_transfer *sxfer;
874
875 if (transfer == NULL)
876 return;
877
878 sxfer = (struct libusb_super_transfer *)(
879 ((uint8_t *)transfer) - sizeof(*sxfer));
880
881 /* set stream ID */
882 sxfer->stream_id = stream_id;
883 }
884
885 uint32_t
libusb_transfer_get_stream_id(struct libusb_transfer * transfer)886 libusb_transfer_get_stream_id(struct libusb_transfer *transfer)
887 {
888 struct libusb_super_transfer *sxfer;
889
890 if (transfer == NULL)
891 return (0);
892
893 sxfer = (struct libusb_super_transfer *)(
894 ((uint8_t *)transfer) - sizeof(*sxfer));
895
896 /* get stream ID */
897 return (sxfer->stream_id);
898 }
899
900 void
libusb_free_pollfds(const struct libusb_pollfd ** pollfds)901 libusb_free_pollfds(const struct libusb_pollfd **pollfds)
902 {
903 if (pollfds == NULL)
904 return;
905
906 free(pollfds);
907 }
908