1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2009 Sylvestre Gallon. All rights reserved.
5 * Copyright (c) 2009-2023 Hans Petter Selasky
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #ifdef LIBUSB_GLOBAL_INCLUDE_FILE
30 #include LIBUSB_GLOBAL_INCLUDE_FILE
31 #else
32 #include <assert.h>
33 #include <errno.h>
34 #include <poll.h>
35 #include <pthread.h>
36 #include <signal.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <unistd.h>
41 #include <time.h>
42 #include <sys/fcntl.h>
43 #include <sys/ioctl.h>
44 #include <sys/queue.h>
45 #include <sys/endian.h>
46 #endif
47
48 #define libusb_device_handle libusb20_device
49
50 #include "libusb20.h"
51 #include "libusb20_desc.h"
52 #include "libusb20_int.h"
53 #include "libusb.h"
54 #include "libusb10.h"
55
56 #define LIBUSB_NUM_SW_ENDPOINTS (16 * 4)
57
58 static pthread_mutex_t default_context_lock = PTHREAD_MUTEX_INITIALIZER;
59 struct libusb_context *usbi_default_context = NULL;
60
61 /* Prototypes */
62
63 static struct libusb20_transfer *libusb10_get_transfer(struct libusb20_device *, uint8_t, uint8_t);
64 static int libusb10_get_buffsize(struct libusb20_device *, libusb_transfer *);
65 static int libusb10_convert_error(uint8_t status);
66 static void libusb10_complete_transfer(struct libusb20_transfer *, struct libusb_super_transfer *, int);
67 static void libusb10_isoc_proxy(struct libusb20_transfer *);
68 static void libusb10_bulk_intr_proxy(struct libusb20_transfer *);
69 static void libusb10_ctrl_proxy(struct libusb20_transfer *);
70 static void libusb10_submit_transfer_sub(struct libusb20_device *, uint8_t);
71
72 /* Library initialisation / deinitialisation */
73
74 static const struct libusb_version libusb_version = {
75 .major = 1,
76 .minor = 0,
77 .micro = 0,
78 .nano = 2016,
79 .rc = "",
80 .describe = "https://www.freebsd.org"
81 };
82
83 const struct libusb_version *
libusb_get_version(void)84 libusb_get_version(void)
85 {
86
87 return (&libusb_version);
88 }
89
90 void
libusb_set_debug(libusb_context * ctx,int level)91 libusb_set_debug(libusb_context *ctx, int level)
92 {
93 ctx = GET_CONTEXT(ctx);
94 /* debug_fixed is set when the environment overrides libusb_set_debug */
95 if (ctx && ctx->debug_fixed == 0)
96 ctx->debug = level;
97 }
98
99 static void
libusb_set_nonblocking(int f)100 libusb_set_nonblocking(int f)
101 {
102 int flags;
103
104 /*
105 * We ignore any failures in this function, hence the
106 * non-blocking flag is not critical to the operation of
107 * libUSB. We use F_GETFL and F_SETFL to be compatible with
108 * Linux.
109 */
110
111 flags = fcntl(f, F_GETFL, NULL);
112 if (flags == -1)
113 return;
114 flags |= O_NONBLOCK;
115 fcntl(f, F_SETFL, flags);
116 }
117
118 void
libusb_interrupt_event_handler(libusb_context * ctx)119 libusb_interrupt_event_handler(libusb_context *ctx)
120 {
121 uint8_t dummy;
122 int err;
123
124 if (ctx == NULL)
125 return;
126
127 dummy = 0;
128 err = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
129 if (err < (int)sizeof(dummy)) {
130 /* ignore error, if any */
131 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "Waking up event loop failed!");
132 }
133 }
134
135 int
libusb_init(libusb_context ** context)136 libusb_init(libusb_context **context)
137 {
138 return (libusb_init_context(context, NULL, 0));
139 }
140
141 int
libusb_init_context(libusb_context ** context,const struct libusb_init_option option[],int num_options)142 libusb_init_context(libusb_context **context,
143 const struct libusb_init_option option[], int num_options)
144 {
145 struct libusb_context *ctx;
146 pthread_condattr_t attr;
147 char *debug, *ep;
148 int ret;
149
150 if (num_options < 0)
151 return (LIBUSB_ERROR_INVALID_PARAM);
152
153 ctx = malloc(sizeof(*ctx));
154 if (!ctx)
155 return (LIBUSB_ERROR_INVALID_PARAM);
156
157 memset(ctx, 0, sizeof(*ctx));
158 ctx->devd_pipe = -1;
159
160 debug = getenv("LIBUSB_DEBUG");
161 if (debug != NULL) {
162 /*
163 * If LIBUSB_DEBUG is set, we'll honor that first and
164 * use it to override any future libusb_set_debug()
165 * calls or init options.
166 */
167 errno = 0;
168 ctx->debug = strtol(debug, &ep, 10);
169 if (errno == 0 && *ep == '\0') {
170 ctx->debug_fixed = 1;
171 } else {
172 /*
173 * LIBUSB_DEBUG conversion failed for some reason, but
174 * we don't care about the specifics all that much. We
175 * can't use it either way. Force it to the default,
176 * 0, in case we had a partial number.
177 */
178 ctx->debug = 0;
179 }
180 } else {
181 /*
182 * If the LIBUSB_OPTION_LOG_LEVEL is set, honor that.
183 */
184 for (int i = 0; i != num_options; i++) {
185 if (option[i].option != LIBUSB_OPTION_LOG_LEVEL)
186 continue;
187
188 ctx->debug = (int)option[i].value.ival;
189 if ((int64_t)ctx->debug == option[i].value.ival) {
190 ctx->debug_fixed = 1;
191 } else {
192 free(ctx);
193 return (LIBUSB_ERROR_INVALID_PARAM);
194 }
195 }
196 }
197
198 TAILQ_INIT(&ctx->pollfds);
199 TAILQ_INIT(&ctx->tr_done);
200 TAILQ_INIT(&ctx->hotplug_cbh);
201 TAILQ_INIT(&ctx->hotplug_devs);
202
203 if (pthread_mutex_init(&ctx->ctx_lock, NULL) != 0) {
204 free(ctx);
205 return (LIBUSB_ERROR_NO_MEM);
206 }
207 if (pthread_mutex_init(&ctx->hotplug_lock, NULL) != 0) {
208 pthread_mutex_destroy(&ctx->ctx_lock);
209 free(ctx);
210 return (LIBUSB_ERROR_NO_MEM);
211 }
212 if (pthread_condattr_init(&attr) != 0) {
213 pthread_mutex_destroy(&ctx->ctx_lock);
214 pthread_mutex_destroy(&ctx->hotplug_lock);
215 free(ctx);
216 return (LIBUSB_ERROR_NO_MEM);
217 }
218 if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) != 0) {
219 pthread_mutex_destroy(&ctx->ctx_lock);
220 pthread_mutex_destroy(&ctx->hotplug_lock);
221 pthread_condattr_destroy(&attr);
222 free(ctx);
223 return (LIBUSB_ERROR_OTHER);
224 }
225 if (pthread_cond_init(&ctx->ctx_cond, &attr) != 0) {
226 pthread_mutex_destroy(&ctx->ctx_lock);
227 pthread_mutex_destroy(&ctx->hotplug_lock);
228 pthread_condattr_destroy(&attr);
229 free(ctx);
230 return (LIBUSB_ERROR_NO_MEM);
231 }
232 pthread_condattr_destroy(&attr);
233
234 ctx->ctx_handler = NO_THREAD;
235 ctx->hotplug_handler = NO_THREAD;
236
237 ret = pipe(ctx->ctrl_pipe);
238 if (ret < 0) {
239 pthread_mutex_destroy(&ctx->ctx_lock);
240 pthread_mutex_destroy(&ctx->hotplug_lock);
241 pthread_cond_destroy(&ctx->ctx_cond);
242 free(ctx);
243 return (LIBUSB_ERROR_OTHER);
244 }
245 /* set non-blocking mode on the control pipe to avoid deadlock */
246 libusb_set_nonblocking(ctx->ctrl_pipe[0]);
247 libusb_set_nonblocking(ctx->ctrl_pipe[1]);
248
249 libusb10_add_pollfd(ctx, &ctx->ctx_poll, NULL, ctx->ctrl_pipe[0], POLLIN);
250
251 pthread_mutex_lock(&default_context_lock);
252 if (usbi_default_context == NULL) {
253 usbi_default_context = ctx;
254 }
255 pthread_mutex_unlock(&default_context_lock);
256
257 if (context)
258 *context = ctx;
259
260 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_init complete");
261
262 signal(SIGPIPE, SIG_IGN);
263
264 return (0);
265 }
266
267 void
libusb_exit(libusb_context * ctx)268 libusb_exit(libusb_context *ctx)
269 {
270 ctx = GET_CONTEXT(ctx);
271
272 if (ctx == NULL)
273 return;
274
275 /* stop hotplug thread, if any */
276
277 if (ctx->hotplug_handler != NO_THREAD) {
278 pthread_t td;
279 void *ptr;
280
281 HOTPLUG_LOCK(ctx);
282 td = ctx->hotplug_handler;
283 ctx->hotplug_handler = NO_THREAD;
284 if (ctx->usb_event_mode == usb_event_devd) {
285 close(ctx->devd_pipe);
286 ctx->devd_pipe = -1;
287 } else if (ctx->usb_event_mode == usb_event_netlink) {
288 close(ctx->ss.fd);
289 ctx->ss.fd = -1;
290 }
291 HOTPLUG_UNLOCK(ctx);
292
293 pthread_join(td, &ptr);
294 }
295
296 /* XXX cleanup devices */
297
298 libusb10_remove_pollfd(ctx, &ctx->ctx_poll);
299 close(ctx->ctrl_pipe[0]);
300 close(ctx->ctrl_pipe[1]);
301 pthread_mutex_destroy(&ctx->ctx_lock);
302 pthread_mutex_destroy(&ctx->hotplug_lock);
303 pthread_cond_destroy(&ctx->ctx_cond);
304
305 pthread_mutex_lock(&default_context_lock);
306 if (ctx == usbi_default_context) {
307 usbi_default_context = NULL;
308 }
309 pthread_mutex_unlock(&default_context_lock);
310
311 free(ctx);
312 }
313
314 /* Device handling and initialisation. */
315
316 ssize_t
libusb_get_device_list(libusb_context * ctx,libusb_device *** list)317 libusb_get_device_list(libusb_context *ctx, libusb_device ***list)
318 {
319 struct libusb20_backend *usb_backend;
320 struct libusb20_device *pdev;
321 struct libusb_device *dev;
322 int i;
323
324 ctx = GET_CONTEXT(ctx);
325
326 if (ctx == NULL)
327 return (LIBUSB_ERROR_INVALID_PARAM);
328
329 if (list == NULL)
330 return (LIBUSB_ERROR_INVALID_PARAM);
331
332 usb_backend = libusb20_be_alloc_default();
333 if (usb_backend == NULL)
334 return (LIBUSB_ERROR_NO_MEM);
335
336 /* figure out how many USB devices are present */
337 pdev = NULL;
338 i = 0;
339 while ((pdev = libusb20_be_device_foreach(usb_backend, pdev)))
340 i++;
341
342 /* allocate device pointer list */
343 *list = malloc((i + 1) * sizeof(void *));
344 if (*list == NULL) {
345 libusb20_be_free(usb_backend);
346 return (LIBUSB_ERROR_NO_MEM);
347 }
348 /* create libusb v1.0 compliant devices */
349 i = 0;
350 while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) {
351
352 dev = malloc(sizeof(*dev));
353 if (dev == NULL) {
354 while (i != 0) {
355 libusb_unref_device((*list)[i - 1]);
356 i--;
357 }
358 free(*list);
359 *list = NULL;
360 libusb20_be_free(usb_backend);
361 return (LIBUSB_ERROR_NO_MEM);
362 }
363 /* get device into libUSB v1.0 list */
364 libusb20_be_dequeue_device(usb_backend, pdev);
365
366 memset(dev, 0, sizeof(*dev));
367
368 /* init transfer queues */
369 TAILQ_INIT(&dev->tr_head);
370
371 /* set context we belong to */
372 dev->ctx = ctx;
373
374 /* link together the two structures */
375 dev->os_priv = pdev;
376 pdev->privLuData = dev;
377
378 (*list)[i] = libusb_ref_device(dev);
379 i++;
380 }
381 (*list)[i] = NULL;
382
383 libusb20_be_free(usb_backend);
384 return (i);
385 }
386
387 void
libusb_free_device_list(libusb_device ** list,int unref_devices)388 libusb_free_device_list(libusb_device **list, int unref_devices)
389 {
390 int i;
391
392 if (list == NULL)
393 return; /* be NULL safe */
394
395 if (unref_devices) {
396 for (i = 0; list[i] != NULL; i++)
397 libusb_unref_device(list[i]);
398 }
399 free(list);
400 }
401
402 uint8_t
libusb_get_bus_number(libusb_device * dev)403 libusb_get_bus_number(libusb_device *dev)
404 {
405 if (dev == NULL)
406 return (0); /* should not happen */
407 return (libusb20_dev_get_bus_number(dev->os_priv));
408 }
409
410 uint8_t
libusb_get_port_number(libusb_device * dev)411 libusb_get_port_number(libusb_device *dev)
412 {
413 if (dev == NULL)
414 return (0); /* should not happen */
415 return (libusb20_dev_get_parent_port(dev->os_priv));
416 }
417
418 int
libusb_get_port_numbers(libusb_device * dev,uint8_t * buf,uint8_t bufsize)419 libusb_get_port_numbers(libusb_device *dev, uint8_t *buf, uint8_t bufsize)
420 {
421 return (libusb20_dev_get_port_path(dev->os_priv, buf, bufsize));
422 }
423
424 int
libusb_get_port_path(libusb_context * ctx,libusb_device * dev,uint8_t * buf,uint8_t bufsize)425 libusb_get_port_path(libusb_context *ctx, libusb_device *dev, uint8_t *buf,
426 uint8_t bufsize)
427 {
428 return (libusb20_dev_get_port_path(dev->os_priv, buf, bufsize));
429 }
430
431 uint8_t
libusb_get_device_address(libusb_device * dev)432 libusb_get_device_address(libusb_device *dev)
433 {
434 if (dev == NULL)
435 return (0); /* should not happen */
436 return (libusb20_dev_get_address(dev->os_priv));
437 }
438
439 enum libusb_speed
libusb_get_device_speed(libusb_device * dev)440 libusb_get_device_speed(libusb_device *dev)
441 {
442 if (dev == NULL)
443 return (LIBUSB_SPEED_UNKNOWN); /* should not happen */
444
445 switch (libusb20_dev_get_speed(dev->os_priv)) {
446 case LIBUSB20_SPEED_LOW:
447 return (LIBUSB_SPEED_LOW);
448 case LIBUSB20_SPEED_FULL:
449 return (LIBUSB_SPEED_FULL);
450 case LIBUSB20_SPEED_HIGH:
451 return (LIBUSB_SPEED_HIGH);
452 case LIBUSB20_SPEED_SUPER:
453 return (LIBUSB_SPEED_SUPER);
454 default:
455 break;
456 }
457 return (LIBUSB_SPEED_UNKNOWN);
458 }
459
460 int
libusb_get_max_packet_size(libusb_device * dev,uint8_t endpoint)461 libusb_get_max_packet_size(libusb_device *dev, uint8_t endpoint)
462 {
463 struct libusb_config_descriptor *pdconf;
464 struct libusb_interface *pinf;
465 struct libusb_interface_descriptor *pdinf;
466 struct libusb_endpoint_descriptor *pdend;
467 int i;
468 int j;
469 int k;
470 int ret;
471
472 if (dev == NULL)
473 return (LIBUSB_ERROR_NO_DEVICE);
474
475 ret = libusb_get_active_config_descriptor(dev, &pdconf);
476 if (ret < 0)
477 return (ret);
478
479 ret = LIBUSB_ERROR_NOT_FOUND;
480 for (i = 0; i < pdconf->bNumInterfaces; i++) {
481 pinf = &pdconf->interface[i];
482 for (j = 0; j < pinf->num_altsetting; j++) {
483 pdinf = &pinf->altsetting[j];
484 for (k = 0; k < pdinf->bNumEndpoints; k++) {
485 pdend = &pdinf->endpoint[k];
486 if (pdend->bEndpointAddress == endpoint) {
487 ret = pdend->wMaxPacketSize;
488 goto out;
489 }
490 }
491 }
492 }
493
494 out:
495 libusb_free_config_descriptor(pdconf);
496 return (ret);
497 }
498
499 int
libusb_get_max_iso_packet_size(libusb_device * dev,uint8_t endpoint)500 libusb_get_max_iso_packet_size(libusb_device *dev, uint8_t endpoint)
501 {
502 int multiplier;
503 int ret;
504
505 ret = libusb_get_max_packet_size(dev, endpoint);
506
507 switch (libusb20_dev_get_speed(dev->os_priv)) {
508 case LIBUSB20_SPEED_LOW:
509 case LIBUSB20_SPEED_FULL:
510 break;
511 default:
512 if (ret > -1) {
513 multiplier = (1 + ((ret >> 11) & 3));
514 if (multiplier > 3)
515 multiplier = 3;
516 ret = (ret & 0x7FF) * multiplier;
517 }
518 break;
519 }
520 return (ret);
521 }
522
523 libusb_device *
libusb_ref_device(libusb_device * dev)524 libusb_ref_device(libusb_device *dev)
525 {
526 if (dev == NULL)
527 return (NULL); /* be NULL safe */
528
529 CTX_LOCK(dev->ctx);
530 dev->refcnt++;
531 CTX_UNLOCK(dev->ctx);
532
533 return (dev);
534 }
535
536 void
libusb_unref_device(libusb_device * dev)537 libusb_unref_device(libusb_device *dev)
538 {
539 if (dev == NULL)
540 return; /* be NULL safe */
541
542 CTX_LOCK(dev->ctx);
543 dev->refcnt--;
544 CTX_UNLOCK(dev->ctx);
545
546 if (dev->refcnt == 0) {
547 libusb20_dev_free(dev->os_priv);
548 free(dev);
549 }
550 }
551
552 int
libusb_open(libusb_device * dev,libusb_device_handle ** devh)553 libusb_open(libusb_device *dev, libusb_device_handle **devh)
554 {
555 libusb_context *ctx = dev->ctx;
556 struct libusb20_device *pdev = dev->os_priv;
557 int err;
558
559 if (devh == NULL)
560 return (LIBUSB_ERROR_INVALID_PARAM);
561
562 /* set default device handle value */
563 *devh = NULL;
564
565 dev = libusb_ref_device(dev);
566 if (dev == NULL)
567 return (LIBUSB_ERROR_INVALID_PARAM);
568
569 err = libusb20_dev_open(pdev, LIBUSB_NUM_SW_ENDPOINTS);
570 if (err) {
571 libusb_unref_device(dev);
572 return (LIBUSB_ERROR_NO_MEM);
573 }
574
575 /*
576 * Clear the device gone flag, in case the device was opened
577 * after a re-attach, to allow new transaction:
578 */
579 CTX_LOCK(ctx);
580 dev->device_is_gone = 0;
581 CTX_UNLOCK(ctx);
582
583 libusb10_add_pollfd(ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN |
584 POLLOUT | POLLRDNORM | POLLWRNORM);
585
586 /* make sure our event loop detects the new device */
587 libusb_interrupt_event_handler(ctx);
588
589 *devh = pdev;
590
591 return (0);
592 }
593
594 libusb_device_handle *
libusb_open_device_with_vid_pid(libusb_context * ctx,uint16_t vendor_id,uint16_t product_id)595 libusb_open_device_with_vid_pid(libusb_context *ctx, uint16_t vendor_id,
596 uint16_t product_id)
597 {
598 struct libusb_device **devs;
599 struct libusb20_device *pdev;
600 struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
601 int i;
602 int j;
603
604 ctx = GET_CONTEXT(ctx);
605 if (ctx == NULL)
606 return (NULL); /* be NULL safe */
607
608 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_with_vid_pid enter");
609
610 if ((i = libusb_get_device_list(ctx, &devs)) < 0)
611 return (NULL);
612
613 pdev = NULL;
614 for (j = 0; j < i; j++) {
615 struct libusb20_device *tdev;
616
617 tdev = devs[j]->os_priv;
618 pdesc = libusb20_dev_get_device_desc(tdev);
619 /*
620 * NOTE: The USB library will automatically swap the
621 * fields in the device descriptor to be of host
622 * endian type!
623 */
624 if (pdesc->idVendor == vendor_id &&
625 pdesc->idProduct == product_id) {
626 libusb_open(devs[j], &pdev);
627 break;
628 }
629 }
630
631 libusb_free_device_list(devs, 1);
632 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_with_vid_pid leave");
633 return (pdev);
634 }
635
636 void
libusb_close(struct libusb20_device * pdev)637 libusb_close(struct libusb20_device *pdev)
638 {
639 libusb_context *ctx;
640 struct libusb_device *dev;
641
642 if (pdev == NULL)
643 return; /* be NULL safe */
644
645 dev = libusb_get_device(pdev);
646 ctx = dev->ctx;
647
648 libusb10_remove_pollfd(ctx, &dev->dev_poll);
649
650 libusb20_dev_close(pdev);
651
652 /* unref will free the "pdev" when the refcount reaches zero */
653 libusb_unref_device(dev);
654
655 /* make sure our event loop detects the closed device */
656 libusb_interrupt_event_handler(ctx);
657 }
658
659 libusb_device *
libusb_get_device(struct libusb20_device * pdev)660 libusb_get_device(struct libusb20_device *pdev)
661 {
662 if (pdev == NULL)
663 return (NULL);
664 return ((libusb_device *)pdev->privLuData);
665 }
666
667 int
libusb_get_configuration(struct libusb20_device * pdev,int * config)668 libusb_get_configuration(struct libusb20_device *pdev, int *config)
669 {
670 struct libusb20_config *pconf;
671
672 if (pdev == NULL || config == NULL)
673 return (LIBUSB_ERROR_INVALID_PARAM);
674
675 pconf = libusb20_dev_alloc_config(pdev, libusb20_dev_get_config_index(pdev));
676 if (pconf == NULL)
677 return (LIBUSB_ERROR_NO_MEM);
678
679 *config = pconf->desc.bConfigurationValue;
680
681 free(pconf);
682
683 return (0);
684 }
685
686 int
libusb_set_configuration(struct libusb20_device * pdev,int configuration)687 libusb_set_configuration(struct libusb20_device *pdev, int configuration)
688 {
689 struct libusb20_config *pconf;
690 struct libusb_device *dev;
691 int err;
692 uint8_t i;
693
694 dev = libusb_get_device(pdev);
695 if (dev == NULL)
696 return (LIBUSB_ERROR_INVALID_PARAM);
697
698 if (configuration < 1) {
699 /* unconfigure */
700 i = 255;
701 } else {
702 for (i = 0; i != 255; i++) {
703 uint8_t found;
704
705 pconf = libusb20_dev_alloc_config(pdev, i);
706 if (pconf == NULL)
707 return (LIBUSB_ERROR_INVALID_PARAM);
708 found = (pconf->desc.bConfigurationValue
709 == configuration);
710 free(pconf);
711
712 if (found)
713 goto set_config;
714 }
715 return (LIBUSB_ERROR_INVALID_PARAM);
716 }
717
718 set_config:
719
720 libusb10_cancel_all_transfer(dev);
721
722 libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
723
724 err = libusb20_dev_set_config_index(pdev, i);
725
726 libusb10_add_pollfd(dev->ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN |
727 POLLOUT | POLLRDNORM | POLLWRNORM);
728
729 return (err ? LIBUSB_ERROR_INVALID_PARAM : 0);
730 }
731
732 int
libusb_claim_interface(struct libusb20_device * pdev,int interface_number)733 libusb_claim_interface(struct libusb20_device *pdev, int interface_number)
734 {
735 libusb_device *dev;
736 int err = 0;
737
738 dev = libusb_get_device(pdev);
739 if (dev == NULL)
740 return (LIBUSB_ERROR_INVALID_PARAM);
741
742 if (interface_number < 0 || interface_number > 31)
743 return (LIBUSB_ERROR_INVALID_PARAM);
744
745 if (pdev->auto_detach != 0) {
746 err = libusb_detach_kernel_driver(pdev, interface_number);
747 if (err != 0)
748 goto done;
749 }
750
751 CTX_LOCK(dev->ctx);
752 dev->claimed_interfaces |= (1 << interface_number);
753 CTX_UNLOCK(dev->ctx);
754 done:
755 return (err);
756 }
757
758 int
libusb_release_interface(struct libusb20_device * pdev,int interface_number)759 libusb_release_interface(struct libusb20_device *pdev, int interface_number)
760 {
761 libusb_device *dev;
762 int err = 0;
763
764 dev = libusb_get_device(pdev);
765 if (dev == NULL)
766 return (LIBUSB_ERROR_INVALID_PARAM);
767
768 if (interface_number < 0 || interface_number > 31)
769 return (LIBUSB_ERROR_INVALID_PARAM);
770
771 if (pdev->auto_detach != 0) {
772 err = libusb_attach_kernel_driver(pdev, interface_number);
773 if (err != 0)
774 goto done;
775 }
776
777 CTX_LOCK(dev->ctx);
778 if (!(dev->claimed_interfaces & (1 << interface_number)))
779 err = LIBUSB_ERROR_NOT_FOUND;
780 else
781 dev->claimed_interfaces &= ~(1 << interface_number);
782 CTX_UNLOCK(dev->ctx);
783 done:
784 return (err);
785 }
786
787 int
libusb_set_interface_alt_setting(struct libusb20_device * pdev,int interface_number,int alternate_setting)788 libusb_set_interface_alt_setting(struct libusb20_device *pdev,
789 int interface_number, int alternate_setting)
790 {
791 libusb_device *dev;
792 int err = 0;
793
794 dev = libusb_get_device(pdev);
795 if (dev == NULL)
796 return (LIBUSB_ERROR_INVALID_PARAM);
797
798 if (interface_number < 0 || interface_number > 31)
799 return (LIBUSB_ERROR_INVALID_PARAM);
800
801 CTX_LOCK(dev->ctx);
802 if (!(dev->claimed_interfaces & (1 << interface_number)))
803 err = LIBUSB_ERROR_NOT_FOUND;
804 CTX_UNLOCK(dev->ctx);
805
806 if (err)
807 return (err);
808
809 libusb10_cancel_all_transfer(dev);
810
811 libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
812
813 err = libusb20_dev_set_alt_index(pdev,
814 interface_number, alternate_setting);
815
816 libusb10_add_pollfd(dev->ctx, &dev->dev_poll,
817 pdev, libusb20_dev_get_fd(pdev),
818 POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
819
820 return (err ? LIBUSB_ERROR_OTHER : 0);
821 }
822
823 static struct libusb20_transfer *
libusb10_get_transfer(struct libusb20_device * pdev,uint8_t endpoint,uint8_t xfer_index)824 libusb10_get_transfer(struct libusb20_device *pdev,
825 uint8_t endpoint, uint8_t xfer_index)
826 {
827 xfer_index &= 1; /* double buffering */
828
829 xfer_index |= (endpoint & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 4;
830
831 if (endpoint & LIBUSB20_ENDPOINT_DIR_MASK) {
832 /* this is an IN endpoint */
833 xfer_index |= 2;
834 }
835 return (libusb20_tr_get_pointer(pdev, xfer_index));
836 }
837
838 int
libusb_clear_halt(struct libusb20_device * pdev,uint8_t endpoint)839 libusb_clear_halt(struct libusb20_device *pdev, uint8_t endpoint)
840 {
841 struct libusb20_transfer *xfer;
842 struct libusb_device *dev;
843 int err;
844
845 xfer = libusb10_get_transfer(pdev, endpoint, 0);
846 if (xfer == NULL)
847 return (LIBUSB_ERROR_INVALID_PARAM);
848
849 dev = libusb_get_device(pdev);
850 if (dev == NULL)
851 return (LIBUSB_ERROR_INVALID_PARAM);
852
853 CTX_LOCK(dev->ctx);
854 err = libusb20_tr_open(xfer, 0, 1, endpoint);
855 CTX_UNLOCK(dev->ctx);
856
857 if (err != 0 && err != LIBUSB20_ERROR_BUSY)
858 return (LIBUSB_ERROR_OTHER);
859
860 libusb20_tr_clear_stall_sync(xfer);
861
862 /* check if we opened the transfer */
863 if (err == 0) {
864 CTX_LOCK(dev->ctx);
865 libusb20_tr_close(xfer);
866 CTX_UNLOCK(dev->ctx);
867 }
868 return (0); /* success */
869 }
870
871 int
libusb_reset_device(struct libusb20_device * pdev)872 libusb_reset_device(struct libusb20_device *pdev)
873 {
874 libusb_device *dev;
875 int err;
876
877 dev = libusb_get_device(pdev);
878 if (dev == NULL)
879 return (LIBUSB_ERROR_INVALID_PARAM);
880
881 libusb10_cancel_all_transfer(dev);
882
883 libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
884
885 err = libusb20_dev_reset(pdev);
886
887 libusb10_add_pollfd(dev->ctx, &dev->dev_poll,
888 pdev, libusb20_dev_get_fd(pdev),
889 POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
890
891 return (err ? LIBUSB_ERROR_OTHER : 0);
892 }
893
894 int
libusb_check_connected(struct libusb20_device * pdev)895 libusb_check_connected(struct libusb20_device *pdev)
896 {
897 libusb_device *dev;
898 int err;
899
900 dev = libusb_get_device(pdev);
901 if (dev == NULL)
902 return (LIBUSB_ERROR_INVALID_PARAM);
903
904 err = libusb20_dev_check_connected(pdev);
905
906 return (err ? LIBUSB_ERROR_NO_DEVICE : 0);
907 }
908
909 int
libusb_kernel_driver_active(struct libusb20_device * pdev,int interface)910 libusb_kernel_driver_active(struct libusb20_device *pdev, int interface)
911 {
912 if (pdev == NULL)
913 return (LIBUSB_ERROR_INVALID_PARAM);
914
915 if (libusb20_dev_kernel_driver_active(pdev, interface))
916 return (0); /* no kernel driver is active */
917 else
918 return (1); /* kernel driver is active */
919 }
920
921 int
libusb_get_driver_np(struct libusb20_device * pdev,int interface,char * name,int namelen)922 libusb_get_driver_np(struct libusb20_device *pdev, int interface,
923 char *name, int namelen)
924 {
925 return (libusb_get_driver(pdev, interface, name, namelen));
926 }
927
928 int
libusb_get_driver(struct libusb20_device * pdev,int interface,char * name,int namelen)929 libusb_get_driver(struct libusb20_device *pdev, int interface,
930 char *name, int namelen)
931 {
932 char *ptr;
933 int err;
934
935 if (pdev == NULL)
936 return (LIBUSB_ERROR_INVALID_PARAM);
937 if (namelen < 1)
938 return (LIBUSB_ERROR_INVALID_PARAM);
939 if (namelen > 255)
940 namelen = 255;
941
942 err = libusb20_dev_get_iface_desc(
943 pdev, interface, name, namelen);
944
945 if (err != 0)
946 return (LIBUSB_ERROR_OTHER);
947
948 /* we only want the driver name */
949 ptr = strstr(name, ":");
950 if (ptr != NULL)
951 *ptr = 0;
952
953 return (0);
954 }
955
956 int
libusb_detach_kernel_driver_np(struct libusb20_device * pdev,int interface)957 libusb_detach_kernel_driver_np(struct libusb20_device *pdev, int interface)
958 {
959 return (libusb_detach_kernel_driver(pdev, interface));
960 }
961
962 int
libusb_detach_kernel_driver(struct libusb20_device * pdev,int interface)963 libusb_detach_kernel_driver(struct libusb20_device *pdev, int interface)
964 {
965 int err;
966
967 if (pdev == NULL)
968 return (LIBUSB_ERROR_INVALID_PARAM);
969
970 err = libusb20_dev_detach_kernel_driver(
971 pdev, interface);
972
973 return (err ? LIBUSB_ERROR_OTHER : 0);
974 }
975
976 int
libusb_attach_kernel_driver(struct libusb20_device * pdev,int interface)977 libusb_attach_kernel_driver(struct libusb20_device *pdev, int interface)
978 {
979 if (pdev == NULL)
980 return (LIBUSB_ERROR_INVALID_PARAM);
981 /* stub - currently not supported by libusb20 */
982 return (0);
983 }
984
985 int
libusb_set_auto_detach_kernel_driver(libusb_device_handle * dev,int enable)986 libusb_set_auto_detach_kernel_driver(libusb_device_handle *dev, int enable)
987 {
988 dev->auto_detach = (enable ? 1 : 0);
989 return (0);
990 }
991
992 /* Asynchronous device I/O */
993
994 struct libusb_transfer *
libusb_alloc_transfer(int iso_packets)995 libusb_alloc_transfer(int iso_packets)
996 {
997 struct libusb_transfer *uxfer;
998 struct libusb_super_transfer *sxfer;
999 int len;
1000
1001 len = sizeof(struct libusb_transfer) +
1002 sizeof(struct libusb_super_transfer) +
1003 (iso_packets * sizeof(libusb_iso_packet_descriptor));
1004
1005 sxfer = malloc(len);
1006 if (sxfer == NULL)
1007 return (NULL);
1008
1009 memset(sxfer, 0, len);
1010
1011 uxfer = (struct libusb_transfer *)(
1012 ((uint8_t *)sxfer) + sizeof(*sxfer));
1013
1014 /* set default value */
1015 uxfer->num_iso_packets = iso_packets;
1016
1017 return (uxfer);
1018 }
1019
1020 void
libusb_free_transfer(struct libusb_transfer * uxfer)1021 libusb_free_transfer(struct libusb_transfer *uxfer)
1022 {
1023 struct libusb_super_transfer *sxfer;
1024
1025 if (uxfer == NULL)
1026 return; /* be NULL safe */
1027
1028 /* check if we should free the transfer buffer */
1029 if (uxfer->flags & LIBUSB_TRANSFER_FREE_BUFFER)
1030 free(uxfer->buffer);
1031
1032 sxfer = (struct libusb_super_transfer *)(
1033 (uint8_t *)uxfer - sizeof(*sxfer));
1034
1035 free(sxfer);
1036 }
1037
1038 static uint32_t
libusb10_get_maxframe(struct libusb20_device * pdev,libusb_transfer * xfer)1039 libusb10_get_maxframe(struct libusb20_device *pdev, libusb_transfer *xfer)
1040 {
1041 uint32_t ret;
1042
1043 switch (xfer->type) {
1044 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1045 ret = 60 | LIBUSB20_MAX_FRAME_PRE_SCALE; /* 60ms */
1046 break;
1047 case LIBUSB_TRANSFER_TYPE_CONTROL:
1048 ret = 2;
1049 break;
1050 default:
1051 ret = 1;
1052 break;
1053 }
1054 return (ret);
1055 }
1056
1057 static int
libusb10_get_buffsize(struct libusb20_device * pdev,libusb_transfer * xfer)1058 libusb10_get_buffsize(struct libusb20_device *pdev, libusb_transfer *xfer)
1059 {
1060 int ret;
1061 int usb_speed;
1062
1063 usb_speed = libusb20_dev_get_speed(pdev);
1064
1065 switch (xfer->type) {
1066 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1067 ret = 0; /* kernel will auto-select */
1068 break;
1069 case LIBUSB_TRANSFER_TYPE_CONTROL:
1070 ret = 1024;
1071 break;
1072 default:
1073 switch (usb_speed) {
1074 case LIBUSB20_SPEED_LOW:
1075 ret = 256;
1076 break;
1077 case LIBUSB20_SPEED_FULL:
1078 ret = 4096;
1079 break;
1080 case LIBUSB20_SPEED_SUPER:
1081 ret = 65536;
1082 break;
1083 default:
1084 ret = 16384;
1085 break;
1086 }
1087 break;
1088 }
1089 return (ret);
1090 }
1091
1092 static int
libusb10_convert_error(uint8_t status)1093 libusb10_convert_error(uint8_t status)
1094 {
1095 ; /* indent fix */
1096
1097 switch (status) {
1098 case LIBUSB20_TRANSFER_START:
1099 case LIBUSB20_TRANSFER_COMPLETED:
1100 return (LIBUSB_TRANSFER_COMPLETED);
1101 case LIBUSB20_TRANSFER_OVERFLOW:
1102 return (LIBUSB_TRANSFER_OVERFLOW);
1103 case LIBUSB20_TRANSFER_NO_DEVICE:
1104 return (LIBUSB_TRANSFER_NO_DEVICE);
1105 case LIBUSB20_TRANSFER_STALL:
1106 return (LIBUSB_TRANSFER_STALL);
1107 case LIBUSB20_TRANSFER_CANCELLED:
1108 return (LIBUSB_TRANSFER_CANCELLED);
1109 case LIBUSB20_TRANSFER_TIMED_OUT:
1110 return (LIBUSB_TRANSFER_TIMED_OUT);
1111 default:
1112 return (LIBUSB_TRANSFER_ERROR);
1113 }
1114 }
1115
1116 /* This function must be called locked */
1117
1118 static void
libusb10_complete_transfer(struct libusb20_transfer * pxfer,struct libusb_super_transfer * sxfer,int status)1119 libusb10_complete_transfer(struct libusb20_transfer *pxfer,
1120 struct libusb_super_transfer *sxfer, int status)
1121 {
1122 struct libusb_transfer *uxfer;
1123 struct libusb_device *dev;
1124
1125 uxfer = (struct libusb_transfer *)(
1126 ((uint8_t *)sxfer) + sizeof(*sxfer));
1127
1128 if (pxfer != NULL)
1129 libusb20_tr_set_priv_sc1(pxfer, NULL);
1130
1131 /* set transfer status */
1132 uxfer->status = status;
1133
1134 /* update super transfer state */
1135 sxfer->state = LIBUSB_SUPER_XFER_ST_NONE;
1136
1137 dev = libusb_get_device(uxfer->dev_handle);
1138
1139 TAILQ_INSERT_TAIL(&dev->ctx->tr_done, sxfer, entry);
1140 }
1141
1142 /* This function must be called locked */
1143
1144 static void
libusb10_isoc_proxy(struct libusb20_transfer * pxfer)1145 libusb10_isoc_proxy(struct libusb20_transfer *pxfer)
1146 {
1147 struct libusb_super_transfer *sxfer;
1148 struct libusb_transfer *uxfer;
1149 uint32_t actlen;
1150 uint16_t iso_packets;
1151 uint16_t i;
1152 uint8_t status;
1153
1154 status = libusb20_tr_get_status(pxfer);
1155 sxfer = libusb20_tr_get_priv_sc1(pxfer);
1156 actlen = libusb20_tr_get_actual_length(pxfer);
1157 iso_packets = libusb20_tr_get_max_frames(pxfer);
1158
1159 if (sxfer == NULL)
1160 return; /* cancelled - nothing to do */
1161
1162 uxfer = (struct libusb_transfer *)(
1163 ((uint8_t *)sxfer) + sizeof(*sxfer));
1164
1165 if (iso_packets > uxfer->num_iso_packets)
1166 iso_packets = uxfer->num_iso_packets;
1167
1168 if (iso_packets == 0)
1169 return; /* nothing to do */
1170
1171 /* make sure that the number of ISOCHRONOUS packets is valid */
1172 uxfer->num_iso_packets = iso_packets;
1173
1174 switch (status) {
1175 case LIBUSB20_TRANSFER_COMPLETED:
1176 /* update actual length */
1177 uxfer->actual_length = actlen;
1178 for (i = 0; i != iso_packets; i++) {
1179 uxfer->iso_packet_desc[i].actual_length =
1180 libusb20_tr_get_length(pxfer, i);
1181 }
1182 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1183 break;
1184 case LIBUSB20_TRANSFER_START:
1185 /* setup length(s) */
1186 actlen = 0;
1187 for (i = 0; i != iso_packets; i++) {
1188 libusb20_tr_setup_isoc(pxfer,
1189 &uxfer->buffer[actlen],
1190 uxfer->iso_packet_desc[i].length, i);
1191 actlen += uxfer->iso_packet_desc[i].length;
1192 }
1193
1194 /* no remainder */
1195 sxfer->rem_len = 0;
1196
1197 libusb20_tr_set_total_frames(pxfer, iso_packets);
1198 libusb20_tr_submit(pxfer);
1199
1200 /* fork another USB transfer, if any */
1201 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1202 break;
1203 default:
1204 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1205 break;
1206 }
1207 }
1208
1209 /* This function must be called locked */
1210
1211 static void
libusb10_bulk_intr_proxy(struct libusb20_transfer * pxfer)1212 libusb10_bulk_intr_proxy(struct libusb20_transfer *pxfer)
1213 {
1214 struct libusb_super_transfer *sxfer;
1215 struct libusb_transfer *uxfer;
1216 uint32_t max_bulk;
1217 uint32_t actlen;
1218 uint8_t status;
1219 uint8_t flags;
1220
1221 status = libusb20_tr_get_status(pxfer);
1222 sxfer = libusb20_tr_get_priv_sc1(pxfer);
1223 max_bulk = libusb20_tr_get_max_total_length(pxfer);
1224 actlen = libusb20_tr_get_actual_length(pxfer);
1225
1226 if (sxfer == NULL)
1227 return; /* cancelled - nothing to do */
1228
1229 uxfer = (struct libusb_transfer *)(
1230 ((uint8_t *)sxfer) + sizeof(*sxfer));
1231
1232 flags = uxfer->flags;
1233
1234 switch (status) {
1235 case LIBUSB20_TRANSFER_COMPLETED:
1236
1237 uxfer->actual_length += actlen;
1238
1239 /* check for short packet */
1240 if (sxfer->last_len != actlen) {
1241 if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
1242 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR);
1243 } else {
1244 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1245 }
1246 break;
1247 }
1248 /* check for end of data */
1249 if (sxfer->rem_len == 0) {
1250 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1251 break;
1252 }
1253 /* FALLTHROUGH */
1254
1255 case LIBUSB20_TRANSFER_START:
1256 if (max_bulk > sxfer->rem_len) {
1257 max_bulk = sxfer->rem_len;
1258 }
1259 /* setup new BULK or INTERRUPT transaction */
1260 libusb20_tr_setup_bulk(pxfer,
1261 sxfer->curr_data, max_bulk, uxfer->timeout);
1262
1263 /* update counters */
1264 sxfer->last_len = max_bulk;
1265 sxfer->curr_data += max_bulk;
1266 sxfer->rem_len -= max_bulk;
1267
1268 libusb20_tr_submit(pxfer);
1269
1270 /* check if we can fork another USB transfer */
1271 if (sxfer->rem_len == 0)
1272 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1273 break;
1274
1275 default:
1276 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1277 break;
1278 }
1279 }
1280
1281 /* This function must be called locked */
1282
1283 static void
libusb10_ctrl_proxy(struct libusb20_transfer * pxfer)1284 libusb10_ctrl_proxy(struct libusb20_transfer *pxfer)
1285 {
1286 struct libusb_super_transfer *sxfer;
1287 struct libusb_transfer *uxfer;
1288 uint32_t max_bulk;
1289 uint32_t actlen;
1290 uint8_t status;
1291 uint8_t flags;
1292
1293 status = libusb20_tr_get_status(pxfer);
1294 sxfer = libusb20_tr_get_priv_sc1(pxfer);
1295 max_bulk = libusb20_tr_get_max_total_length(pxfer);
1296 actlen = libusb20_tr_get_actual_length(pxfer);
1297
1298 if (sxfer == NULL)
1299 return; /* cancelled - nothing to do */
1300
1301 uxfer = (struct libusb_transfer *)(
1302 ((uint8_t *)sxfer) + sizeof(*sxfer));
1303
1304 flags = uxfer->flags;
1305
1306 switch (status) {
1307 case LIBUSB20_TRANSFER_COMPLETED:
1308
1309 uxfer->actual_length += actlen;
1310
1311 /* subtract length of SETUP packet, if any */
1312 actlen -= libusb20_tr_get_length(pxfer, 0);
1313
1314 /* check for short packet */
1315 if (sxfer->last_len != actlen) {
1316 if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
1317 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR);
1318 } else {
1319 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1320 }
1321 break;
1322 }
1323 /* check for end of data */
1324 if (sxfer->rem_len == 0) {
1325 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1326 break;
1327 }
1328 /* FALLTHROUGH */
1329
1330 case LIBUSB20_TRANSFER_START:
1331 if (max_bulk > sxfer->rem_len) {
1332 max_bulk = sxfer->rem_len;
1333 }
1334 /* setup new CONTROL transaction */
1335 if (status == LIBUSB20_TRANSFER_COMPLETED) {
1336 /* next fragment - don't send SETUP packet */
1337 libusb20_tr_set_length(pxfer, 0, 0);
1338 } else {
1339 /* first fragment - send SETUP packet */
1340 libusb20_tr_set_length(pxfer, 8, 0);
1341 libusb20_tr_set_buffer(pxfer, uxfer->buffer, 0);
1342 }
1343
1344 if (max_bulk != 0) {
1345 libusb20_tr_set_length(pxfer, max_bulk, 1);
1346 libusb20_tr_set_buffer(pxfer, sxfer->curr_data, 1);
1347 libusb20_tr_set_total_frames(pxfer, 2);
1348 } else {
1349 libusb20_tr_set_total_frames(pxfer, 1);
1350 }
1351
1352 /* update counters */
1353 sxfer->last_len = max_bulk;
1354 sxfer->curr_data += max_bulk;
1355 sxfer->rem_len -= max_bulk;
1356
1357 libusb20_tr_submit(pxfer);
1358
1359 /* check if we can fork another USB transfer */
1360 if (sxfer->rem_len == 0)
1361 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1362 break;
1363
1364 default:
1365 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1366 break;
1367 }
1368 }
1369
1370 /* The following function must be called locked */
1371
1372 static void
libusb10_submit_transfer_sub(struct libusb20_device * pdev,uint8_t endpoint)1373 libusb10_submit_transfer_sub(struct libusb20_device *pdev, uint8_t endpoint)
1374 {
1375 struct libusb20_transfer *pxfer0;
1376 struct libusb20_transfer *pxfer1;
1377 struct libusb_super_transfer *sxfer;
1378 struct libusb_transfer *uxfer;
1379 struct libusb_device *dev;
1380 int err;
1381 int buffsize;
1382 int maxframe;
1383 int temp;
1384
1385 dev = libusb_get_device(pdev);
1386
1387 pxfer0 = libusb10_get_transfer(pdev, endpoint, 0);
1388 pxfer1 = libusb10_get_transfer(pdev, endpoint, 1);
1389
1390 if (pxfer0 == NULL || pxfer1 == NULL)
1391 return; /* shouldn't happen */
1392
1393 temp = 0;
1394 if (libusb20_tr_pending(pxfer0))
1395 temp |= 1;
1396 if (libusb20_tr_pending(pxfer1))
1397 temp |= 2;
1398
1399 switch (temp) {
1400 case 3:
1401 /* wait till one of the transfers complete */
1402 return;
1403 case 2:
1404 sxfer = libusb20_tr_get_priv_sc1(pxfer1);
1405 if (sxfer == NULL)
1406 return; /* cancelling */
1407 if (sxfer->rem_len)
1408 return; /* cannot queue another one */
1409 /* swap transfers */
1410 pxfer1 = pxfer0;
1411 break;
1412 case 1:
1413 sxfer = libusb20_tr_get_priv_sc1(pxfer0);
1414 if (sxfer == NULL)
1415 return; /* cancelling */
1416 if (sxfer->rem_len)
1417 return; /* cannot queue another one */
1418 /* swap transfers */
1419 pxfer0 = pxfer1;
1420 break;
1421 default:
1422 break;
1423 }
1424
1425 /* find next transfer on same endpoint */
1426 TAILQ_FOREACH(sxfer, &dev->tr_head, entry) {
1427
1428 uxfer = (struct libusb_transfer *)(
1429 ((uint8_t *)sxfer) + sizeof(*sxfer));
1430
1431 if (uxfer->endpoint == endpoint) {
1432 TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1433 sxfer->entry.tqe_prev = NULL;
1434 goto found;
1435 }
1436 }
1437 return; /* success */
1438
1439 found:
1440
1441 libusb20_tr_set_priv_sc0(pxfer0, pdev);
1442 libusb20_tr_set_priv_sc1(pxfer0, sxfer);
1443
1444 /* reset super transfer state */
1445 sxfer->rem_len = uxfer->length;
1446 sxfer->curr_data = uxfer->buffer;
1447 uxfer->actual_length = 0;
1448
1449 switch (uxfer->type) {
1450 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1451 libusb20_tr_set_callback(pxfer0, libusb10_isoc_proxy);
1452 break;
1453 case LIBUSB_TRANSFER_TYPE_BULK:
1454 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1455 libusb20_tr_set_callback(pxfer0, libusb10_bulk_intr_proxy);
1456 break;
1457 case LIBUSB_TRANSFER_TYPE_CONTROL:
1458 libusb20_tr_set_callback(pxfer0, libusb10_ctrl_proxy);
1459 if (sxfer->rem_len < 8)
1460 goto failure;
1461
1462 /* remove SETUP packet from data */
1463 sxfer->rem_len -= 8;
1464 sxfer->curr_data += 8;
1465 break;
1466 default:
1467 goto failure;
1468 }
1469
1470 buffsize = libusb10_get_buffsize(pdev, uxfer);
1471 maxframe = libusb10_get_maxframe(pdev, uxfer);
1472
1473 /* make sure the transfer is opened */
1474 err = libusb20_tr_open_stream(pxfer0, buffsize, maxframe,
1475 endpoint, sxfer->stream_id);
1476 if (err && (err != LIBUSB20_ERROR_BUSY)) {
1477 goto failure;
1478 }
1479 libusb20_tr_start(pxfer0);
1480 return;
1481
1482 failure:
1483 libusb10_complete_transfer(pxfer0, sxfer, LIBUSB_TRANSFER_ERROR);
1484 /* make sure our event loop spins the done handler */
1485 libusb_interrupt_event_handler(dev->ctx);
1486 }
1487
1488 /* The following function must be called unlocked */
1489
1490 int
libusb_submit_transfer(struct libusb_transfer * uxfer)1491 libusb_submit_transfer(struct libusb_transfer *uxfer)
1492 {
1493 struct libusb20_transfer *pxfer0;
1494 struct libusb20_transfer *pxfer1;
1495 struct libusb_super_transfer *sxfer;
1496 struct libusb_device *dev;
1497 uint8_t endpoint;
1498 int err;
1499
1500 if (uxfer == NULL)
1501 return (LIBUSB_ERROR_INVALID_PARAM);
1502
1503 if (uxfer->dev_handle == NULL)
1504 return (LIBUSB_ERROR_INVALID_PARAM);
1505
1506 endpoint = uxfer->endpoint;
1507
1508 dev = libusb_get_device(uxfer->dev_handle);
1509
1510 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer enter");
1511
1512 sxfer = (struct libusb_super_transfer *)(
1513 (uint8_t *)uxfer - sizeof(*sxfer));
1514
1515 CTX_LOCK(dev->ctx);
1516
1517 pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0);
1518 pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1);
1519
1520 if (pxfer0 == NULL || pxfer1 == NULL) {
1521 err = LIBUSB_ERROR_OTHER;
1522 } else if ((sxfer->entry.tqe_prev != NULL) ||
1523 (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) ||
1524 (libusb20_tr_get_priv_sc1(pxfer1) == sxfer)) {
1525 err = LIBUSB_ERROR_BUSY;
1526 } else if (dev->device_is_gone != 0) {
1527 err = LIBUSB_ERROR_NO_DEVICE;
1528 } else {
1529
1530 /* set pending state */
1531 sxfer->state = LIBUSB_SUPER_XFER_ST_PEND;
1532
1533 /* insert transfer into transfer head list */
1534 TAILQ_INSERT_TAIL(&dev->tr_head, sxfer, entry);
1535
1536 /* start work transfers */
1537 libusb10_submit_transfer_sub(
1538 uxfer->dev_handle, endpoint);
1539
1540 err = 0; /* success */
1541 }
1542
1543 CTX_UNLOCK(dev->ctx);
1544
1545 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer leave %d", err);
1546
1547 return (err);
1548 }
1549
1550 /* Asynchronous transfer cancel */
1551
1552 int
libusb_cancel_transfer(struct libusb_transfer * uxfer)1553 libusb_cancel_transfer(struct libusb_transfer *uxfer)
1554 {
1555 struct libusb20_transfer *pxfer0;
1556 struct libusb20_transfer *pxfer1;
1557 struct libusb_super_transfer *sxfer;
1558 struct libusb_device *dev;
1559 struct libusb_device_handle *devh;
1560 uint8_t endpoint;
1561 int retval;
1562
1563 if (uxfer == NULL)
1564 return (LIBUSB_ERROR_INVALID_PARAM);
1565
1566 /* check if not initialised */
1567 if ((devh = uxfer->dev_handle) == NULL)
1568 return (LIBUSB_ERROR_NOT_FOUND);
1569
1570 endpoint = uxfer->endpoint;
1571
1572 dev = libusb_get_device(devh);
1573
1574 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer enter");
1575
1576 sxfer = (struct libusb_super_transfer *)(
1577 (uint8_t *)uxfer - sizeof(*sxfer));
1578
1579 retval = 0;
1580
1581 CTX_LOCK(dev->ctx);
1582
1583 pxfer0 = libusb10_get_transfer(devh, endpoint, 0);
1584 pxfer1 = libusb10_get_transfer(devh, endpoint, 1);
1585
1586 if (sxfer->state != LIBUSB_SUPER_XFER_ST_PEND) {
1587 /* only update the transfer status */
1588 uxfer->status = LIBUSB_TRANSFER_CANCELLED;
1589 retval = LIBUSB_ERROR_NOT_FOUND;
1590 } else if (sxfer->entry.tqe_prev != NULL) {
1591 /* we are lucky - transfer is on a queue */
1592 TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1593 sxfer->entry.tqe_prev = NULL;
1594 libusb10_complete_transfer(NULL,
1595 sxfer, LIBUSB_TRANSFER_CANCELLED);
1596 /* make sure our event loop spins the done handler */
1597 libusb_interrupt_event_handler(dev->ctx);
1598 } else if (pxfer0 == NULL || pxfer1 == NULL) {
1599 /* not started */
1600 retval = LIBUSB_ERROR_NOT_FOUND;
1601 } else if (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) {
1602 libusb10_complete_transfer(pxfer0,
1603 sxfer, LIBUSB_TRANSFER_CANCELLED);
1604 if (dev->device_is_gone != 0) {
1605 /* clear transfer pointer */
1606 libusb20_tr_set_priv_sc1(pxfer0, NULL);
1607 /* make sure our event loop spins the done handler */
1608 libusb_interrupt_event_handler(dev->ctx);
1609 } else {
1610 libusb20_tr_stop(pxfer0);
1611 /* make sure the queue doesn't stall */
1612 libusb10_submit_transfer_sub(devh, endpoint);
1613 }
1614 } else if (libusb20_tr_get_priv_sc1(pxfer1) == sxfer) {
1615 libusb10_complete_transfer(pxfer1,
1616 sxfer, LIBUSB_TRANSFER_CANCELLED);
1617 /* check if handle is still active */
1618 if (dev->device_is_gone != 0) {
1619 /* clear transfer pointer */
1620 libusb20_tr_set_priv_sc1(pxfer1, NULL);
1621 /* make sure our event loop spins the done handler */
1622 libusb_interrupt_event_handler(dev->ctx);
1623 } else {
1624 libusb20_tr_stop(pxfer1);
1625 /* make sure the queue doesn't stall */
1626 libusb10_submit_transfer_sub(devh, endpoint);
1627 }
1628 } else {
1629 /* not started */
1630 retval = LIBUSB_ERROR_NOT_FOUND;
1631 }
1632
1633 CTX_UNLOCK(dev->ctx);
1634
1635 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer leave");
1636
1637 return (retval);
1638 }
1639
1640 UNEXPORTED void
libusb10_cancel_all_transfer(libusb_device * dev)1641 libusb10_cancel_all_transfer(libusb_device *dev)
1642 {
1643 struct libusb20_device *pdev = dev->os_priv;
1644 unsigned x;
1645
1646 for (x = 0; x != LIBUSB_NUM_SW_ENDPOINTS; x++) {
1647 struct libusb20_transfer *xfer;
1648
1649 xfer = libusb20_tr_get_pointer(pdev, x);
1650 if (xfer == NULL)
1651 continue;
1652 libusb20_tr_close(xfer);
1653 }
1654 }
1655
1656 UNEXPORTED void
libusb10_cancel_all_transfer_locked(struct libusb20_device * pdev,struct libusb_device * dev)1657 libusb10_cancel_all_transfer_locked(struct libusb20_device *pdev, struct libusb_device *dev)
1658 {
1659 struct libusb_super_transfer *sxfer;
1660 unsigned x;
1661
1662 for (x = 0; x != LIBUSB_NUM_SW_ENDPOINTS; x++) {
1663 struct libusb20_transfer *xfer;
1664
1665 xfer = libusb20_tr_get_pointer(pdev, x);
1666 if (xfer == NULL)
1667 continue;
1668 if (libusb20_tr_pending(xfer) == 0)
1669 continue;
1670 sxfer = libusb20_tr_get_priv_sc1(xfer);
1671 if (sxfer == NULL)
1672 continue;
1673 /* complete pending transfer */
1674 libusb10_complete_transfer(xfer, sxfer, LIBUSB_TRANSFER_ERROR);
1675 }
1676
1677 while ((sxfer = TAILQ_FIRST(&dev->tr_head))) {
1678 TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1679
1680 /* complete pending transfer */
1681 libusb10_complete_transfer(NULL, sxfer, LIBUSB_TRANSFER_ERROR);
1682 }
1683 }
1684
1685 uint16_t
libusb_cpu_to_le16(uint16_t x)1686 libusb_cpu_to_le16(uint16_t x)
1687 {
1688 return (htole16(x));
1689 }
1690
1691 uint16_t
libusb_le16_to_cpu(uint16_t x)1692 libusb_le16_to_cpu(uint16_t x)
1693 {
1694 return (le16toh(x));
1695 }
1696
1697 const char *
libusb_strerror(int code)1698 libusb_strerror(int code)
1699 {
1700 switch (code) {
1701 case LIBUSB_SUCCESS:
1702 return ("Success");
1703 case LIBUSB_ERROR_IO:
1704 return ("I/O error");
1705 case LIBUSB_ERROR_INVALID_PARAM:
1706 return ("Invalid parameter");
1707 case LIBUSB_ERROR_ACCESS:
1708 return ("Permissions error");
1709 case LIBUSB_ERROR_NO_DEVICE:
1710 return ("No device");
1711 case LIBUSB_ERROR_NOT_FOUND:
1712 return ("Not found");
1713 case LIBUSB_ERROR_BUSY:
1714 return ("Device busy");
1715 case LIBUSB_ERROR_TIMEOUT:
1716 return ("Timeout");
1717 case LIBUSB_ERROR_OVERFLOW:
1718 return ("Overflow");
1719 case LIBUSB_ERROR_PIPE:
1720 return ("Pipe error");
1721 case LIBUSB_ERROR_INTERRUPTED:
1722 return ("Interrupted");
1723 case LIBUSB_ERROR_NO_MEM:
1724 return ("Out of memory");
1725 case LIBUSB_ERROR_NOT_SUPPORTED:
1726 return ("Not supported");
1727 case LIBUSB_ERROR_OTHER:
1728 return ("Other error");
1729 default:
1730 return ("Unknown error");
1731 }
1732 }
1733
1734 const char *
libusb_error_name(int code)1735 libusb_error_name(int code)
1736 {
1737 switch (code) {
1738 case LIBUSB_SUCCESS:
1739 return ("LIBUSB_SUCCESS");
1740 case LIBUSB_ERROR_IO:
1741 return ("LIBUSB_ERROR_IO");
1742 case LIBUSB_ERROR_INVALID_PARAM:
1743 return ("LIBUSB_ERROR_INVALID_PARAM");
1744 case LIBUSB_ERROR_ACCESS:
1745 return ("LIBUSB_ERROR_ACCESS");
1746 case LIBUSB_ERROR_NO_DEVICE:
1747 return ("LIBUSB_ERROR_NO_DEVICE");
1748 case LIBUSB_ERROR_NOT_FOUND:
1749 return ("LIBUSB_ERROR_NOT_FOUND");
1750 case LIBUSB_ERROR_BUSY:
1751 return ("LIBUSB_ERROR_BUSY");
1752 case LIBUSB_ERROR_TIMEOUT:
1753 return ("LIBUSB_ERROR_TIMEOUT");
1754 case LIBUSB_ERROR_OVERFLOW:
1755 return ("LIBUSB_ERROR_OVERFLOW");
1756 case LIBUSB_ERROR_PIPE:
1757 return ("LIBUSB_ERROR_PIPE");
1758 case LIBUSB_ERROR_INTERRUPTED:
1759 return ("LIBUSB_ERROR_INTERRUPTED");
1760 case LIBUSB_ERROR_NO_MEM:
1761 return ("LIBUSB_ERROR_NO_MEM");
1762 case LIBUSB_ERROR_NOT_SUPPORTED:
1763 return ("LIBUSB_ERROR_NOT_SUPPORTED");
1764 case LIBUSB_ERROR_OTHER:
1765 return ("LIBUSB_ERROR_OTHER");
1766 default:
1767 return ("LIBUSB_ERROR_UNKNOWN");
1768 }
1769 }
1770
1771 int
libusb_has_capability(uint32_t capability)1772 libusb_has_capability(uint32_t capability)
1773 {
1774
1775 switch (capability) {
1776 case LIBUSB_CAP_HAS_CAPABILITY:
1777 case LIBUSB_CAP_HAS_HOTPLUG:
1778 case LIBUSB_CAP_HAS_HID_ACCESS:
1779 case LIBUSB_CAP_SUPPORTS_DETACH_KERNEL_DRIVER:
1780 return (1);
1781 default:
1782 return (0);
1783 }
1784 }
1785