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