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