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