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