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