1 /* $FreeBSD: head/lib/libusb/libusb10.c 261224 2014-01-28 07:21:46Z hselasky $ */
3 * Copyright (c) 2009 Sylvestre Gallon. All rights reserved.
4 * Copyright (c) 2009 Hans Petter Selasky. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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.
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
28 #ifdef LIBUSB_GLOBAL_INCLUDE_FILE
29 #include LIBUSB_GLOBAL_INCLUDE_FILE
40 #include <sys/fcntl.h>
41 #include <sys/ioctl.h>
42 #include <sys/queue.h>
43 #include <sys/endian.h>
46 #define libusb_device_handle libusb20_device
49 #include "libusb20_desc.h"
50 #include "libusb20_int.h"
54 static pthread_mutex_t default_context_lock = PTHREAD_MUTEX_INITIALIZER;
55 struct libusb_context *usbi_default_context = NULL;
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);
68 /* Library initialisation / deinitialisation */
71 libusb_set_debug(libusb_context *ctx, int level)
73 ctx = GET_CONTEXT(ctx);
79 libusb_set_nonblocking(int f)
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
90 flags = fcntl(f, F_GETFL, NULL);
94 fcntl(f, F_SETFL, flags);
98 libusb_init(libusb_context **context)
100 struct libusb_context *ctx;
101 pthread_condattr_t attr;
105 ctx = malloc(sizeof(*ctx));
107 return (LIBUSB_ERROR_INVALID_PARAM);
109 memset(ctx, 0, sizeof(*ctx));
111 debug = getenv("LIBUSB_DEBUG");
113 ctx->debug = atoi(debug);
115 ctx->debug_fixed = 1;
117 TAILQ_INIT(&ctx->pollfds);
118 TAILQ_INIT(&ctx->tr_done);
120 if (pthread_mutex_init(&ctx->ctx_lock, NULL) != 0) {
122 return (LIBUSB_ERROR_NO_MEM);
124 if (pthread_condattr_init(&attr) != 0) {
125 pthread_mutex_destroy(&ctx->ctx_lock);
127 return (LIBUSB_ERROR_NO_MEM);
129 if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) != 0) {
130 pthread_mutex_destroy(&ctx->ctx_lock);
131 pthread_condattr_destroy(&attr);
133 return (LIBUSB_ERROR_OTHER);
135 if (pthread_cond_init(&ctx->ctx_cond, &attr) != 0) {
136 pthread_mutex_destroy(&ctx->ctx_lock);
137 pthread_condattr_destroy(&attr);
139 return (LIBUSB_ERROR_NO_MEM);
141 pthread_condattr_destroy(&attr);
143 ctx->ctx_handler = NO_THREAD;
145 ret = pipe(ctx->ctrl_pipe);
147 pthread_mutex_destroy(&ctx->ctx_lock);
148 pthread_cond_destroy(&ctx->ctx_cond);
150 return (LIBUSB_ERROR_OTHER);
152 /* set non-blocking mode on the control pipe to avoid deadlock */
153 libusb_set_nonblocking(ctx->ctrl_pipe[0]);
154 libusb_set_nonblocking(ctx->ctrl_pipe[1]);
156 libusb10_add_pollfd(ctx, &ctx->ctx_poll, NULL, ctx->ctrl_pipe[0], POLLIN);
158 pthread_mutex_lock(&default_context_lock);
159 if (usbi_default_context == NULL) {
160 usbi_default_context = ctx;
162 pthread_mutex_unlock(&default_context_lock);
167 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_init complete");
173 libusb_exit(libusb_context *ctx)
175 ctx = GET_CONTEXT(ctx);
180 /* XXX cleanup devices */
182 libusb10_remove_pollfd(ctx, &ctx->ctx_poll);
183 close(ctx->ctrl_pipe[0]);
184 close(ctx->ctrl_pipe[1]);
185 pthread_mutex_destroy(&ctx->ctx_lock);
186 pthread_cond_destroy(&ctx->ctx_cond);
188 pthread_mutex_lock(&default_context_lock);
189 if (ctx == usbi_default_context) {
190 usbi_default_context = NULL;
192 pthread_mutex_unlock(&default_context_lock);
197 /* Device handling and initialisation. */
200 libusb_get_device_list(libusb_context *ctx, libusb_device ***list)
202 struct libusb20_backend *usb_backend;
203 struct libusb20_device *pdev;
204 struct libusb_device *dev;
207 ctx = GET_CONTEXT(ctx);
210 return (LIBUSB_ERROR_INVALID_PARAM);
213 return (LIBUSB_ERROR_INVALID_PARAM);
215 usb_backend = libusb20_be_alloc_default();
216 if (usb_backend == NULL)
217 return (LIBUSB_ERROR_NO_MEM);
219 /* figure out how many USB devices are present */
222 while ((pdev = libusb20_be_device_foreach(usb_backend, pdev)))
225 /* allocate device pointer list */
226 *list = malloc((i + 1) * sizeof(void *));
228 libusb20_be_free(usb_backend);
229 return (LIBUSB_ERROR_NO_MEM);
231 /* create libusb v1.0 compliant devices */
233 while ((pdev = libusb20_be_device_foreach(usb_backend, NULL))) {
235 dev = malloc(sizeof(*dev));
238 libusb_unref_device((*list)[i - 1]);
243 libusb20_be_free(usb_backend);
244 return (LIBUSB_ERROR_NO_MEM);
246 /* get device into libUSB v1.0 list */
247 libusb20_be_dequeue_device(usb_backend, pdev);
249 memset(dev, 0, sizeof(*dev));
251 /* init transfer queues */
252 TAILQ_INIT(&dev->tr_head);
254 /* set context we belong to */
257 /* link together the two structures */
259 pdev->privLuData = dev;
261 (*list)[i] = libusb_ref_device(dev);
266 libusb20_be_free(usb_backend);
271 libusb_free_device_list(libusb_device **list, int unref_devices)
276 return; /* be NULL safe */
279 for (i = 0; list[i] != NULL; i++)
280 libusb_unref_device(list[i]);
286 libusb_get_bus_number(libusb_device *dev)
289 return (0); /* should not happen */
290 return (libusb20_dev_get_bus_number(dev->os_priv));
294 libusb_get_port_numbers(libusb_device *dev, uint8_t *buf, uint8_t bufsize)
296 return (libusb20_dev_get_port_path(dev->os_priv, buf, bufsize));
300 libusb_get_port_path(libusb_context *ctx, libusb_device *dev, uint8_t *buf,
303 return (libusb20_dev_get_port_path(dev->os_priv, buf, bufsize));
307 libusb_get_device_address(libusb_device *dev)
310 return (0); /* should not happen */
311 return (libusb20_dev_get_address(dev->os_priv));
315 libusb_get_device_speed(libusb_device *dev)
318 return (LIBUSB_SPEED_UNKNOWN); /* should not happen */
320 switch (libusb20_dev_get_speed(dev->os_priv)) {
321 case LIBUSB20_SPEED_LOW:
322 return (LIBUSB_SPEED_LOW);
323 case LIBUSB20_SPEED_FULL:
324 return (LIBUSB_SPEED_FULL);
325 case LIBUSB20_SPEED_HIGH:
326 return (LIBUSB_SPEED_HIGH);
327 case LIBUSB20_SPEED_SUPER:
328 return (LIBUSB_SPEED_SUPER);
332 return (LIBUSB_SPEED_UNKNOWN);
336 libusb_get_max_packet_size(libusb_device *dev, uint8_t endpoint)
338 struct libusb_config_descriptor *pdconf;
339 struct libusb_interface *pinf;
340 struct libusb_interface_descriptor *pdinf;
341 struct libusb_endpoint_descriptor *pdend;
348 return (LIBUSB_ERROR_NO_DEVICE);
350 ret = libusb_get_active_config_descriptor(dev, &pdconf);
354 ret = LIBUSB_ERROR_NOT_FOUND;
355 for (i = 0; i < pdconf->bNumInterfaces; i++) {
356 pinf = &pdconf->interface[i];
357 for (j = 0; j < pinf->num_altsetting; j++) {
358 pdinf = &pinf->altsetting[j];
359 for (k = 0; k < pdinf->bNumEndpoints; k++) {
360 pdend = &pdinf->endpoint[k];
361 if (pdend->bEndpointAddress == endpoint) {
362 ret = pdend->wMaxPacketSize;
370 libusb_free_config_descriptor(pdconf);
375 libusb_get_max_iso_packet_size(libusb_device *dev, uint8_t endpoint)
380 ret = libusb_get_max_packet_size(dev, endpoint);
382 switch (libusb20_dev_get_speed(dev->os_priv)) {
383 case LIBUSB20_SPEED_LOW:
384 case LIBUSB20_SPEED_FULL:
388 multiplier = (1 + ((ret >> 11) & 3));
391 ret = (ret & 0x7FF) * multiplier;
399 libusb_ref_device(libusb_device *dev)
402 return (NULL); /* be NULL safe */
406 CTX_UNLOCK(dev->ctx);
412 libusb_unref_device(libusb_device *dev)
415 return; /* be NULL safe */
419 CTX_UNLOCK(dev->ctx);
421 if (dev->refcnt == 0) {
422 libusb20_dev_free(dev->os_priv);
428 libusb_open(libusb_device *dev, libusb_device_handle **devh)
430 libusb_context *ctx = dev->ctx;
431 struct libusb20_device *pdev = dev->os_priv;
436 return (LIBUSB_ERROR_INVALID_PARAM);
438 /* set default device handle value */
441 dev = libusb_ref_device(dev);
443 return (LIBUSB_ERROR_INVALID_PARAM);
445 err = libusb20_dev_open(pdev, 16 * 4 /* number of endpoints */ );
447 libusb_unref_device(dev);
448 return (LIBUSB_ERROR_NO_MEM);
450 libusb10_add_pollfd(ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN |
451 POLLOUT | POLLRDNORM | POLLWRNORM);
453 /* make sure our event loop detects the new device */
455 err = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
456 if (err < (int)sizeof(dummy)) {
457 /* ignore error, if any */
458 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open write failed!");
465 libusb_device_handle *
466 libusb_open_device_with_vid_pid(libusb_context *ctx, uint16_t vendor_id,
469 struct libusb_device **devs;
470 struct libusb20_device *pdev;
471 struct LIBUSB20_DEVICE_DESC_DECODED *pdesc;
475 ctx = GET_CONTEXT(ctx);
477 return (NULL); /* be NULL safe */
479 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_width_vid_pid enter");
481 if ((i = libusb_get_device_list(ctx, &devs)) < 0)
485 for (j = 0; j < i; j++) {
486 struct libusb20_device *tdev;
488 tdev = devs[j]->os_priv;
489 pdesc = libusb20_dev_get_device_desc(tdev);
491 * NOTE: The USB library will automatically swap the
492 * fields in the device descriptor to be of host
495 if (pdesc->idVendor == vendor_id &&
496 pdesc->idProduct == product_id) {
497 libusb_open(devs[j], &pdev);
502 libusb_free_device_list(devs, 1);
503 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_open_device_width_vid_pid leave");
508 libusb_close(struct libusb20_device *pdev)
511 struct libusb_device *dev;
516 return; /* be NULL safe */
518 dev = libusb_get_device(pdev);
521 libusb10_remove_pollfd(ctx, &dev->dev_poll);
523 libusb20_dev_close(pdev);
525 /* unref will free the "pdev" when the refcount reaches zero */
526 libusb_unref_device(dev);
528 /* make sure our event loop detects the closed device */
530 err = write(ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
531 if (err < (int)sizeof(dummy)) {
532 /* ignore error, if any */
533 DPRINTF(ctx, LIBUSB_DEBUG_FUNCTION, "libusb_close write failed!");
538 libusb_get_device(struct libusb20_device *pdev)
542 return ((libusb_device *)pdev->privLuData);
546 libusb_get_configuration(struct libusb20_device *pdev, int *config)
548 struct libusb20_config *pconf;
550 if (pdev == NULL || config == NULL)
551 return (LIBUSB_ERROR_INVALID_PARAM);
553 pconf = libusb20_dev_alloc_config(pdev, libusb20_dev_get_config_index(pdev));
555 return (LIBUSB_ERROR_NO_MEM);
557 *config = pconf->desc.bConfigurationValue;
565 libusb_set_configuration(struct libusb20_device *pdev, int configuration)
567 struct libusb20_config *pconf;
568 struct libusb_device *dev;
572 dev = libusb_get_device(pdev);
574 return (LIBUSB_ERROR_INVALID_PARAM);
576 if (configuration < 1) {
580 for (i = 0; i != 255; i++) {
583 pconf = libusb20_dev_alloc_config(pdev, i);
585 return (LIBUSB_ERROR_INVALID_PARAM);
586 found = (pconf->desc.bConfigurationValue
593 return (LIBUSB_ERROR_INVALID_PARAM);
598 libusb10_cancel_all_transfer(dev);
600 libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
602 err = libusb20_dev_set_config_index(pdev, i);
604 libusb10_add_pollfd(dev->ctx, &dev->dev_poll, pdev, libusb20_dev_get_fd(pdev), POLLIN |
605 POLLOUT | POLLRDNORM | POLLWRNORM);
607 return (err ? LIBUSB_ERROR_INVALID_PARAM : 0);
611 libusb_claim_interface(struct libusb20_device *pdev, int interface_number)
615 dev = libusb_get_device(pdev);
617 return (LIBUSB_ERROR_INVALID_PARAM);
619 if (interface_number < 0 || interface_number > 31)
620 return (LIBUSB_ERROR_INVALID_PARAM);
623 dev->claimed_interfaces |= (1 << interface_number);
624 CTX_UNLOCK(dev->ctx);
630 libusb_release_interface(struct libusb20_device *pdev, int interface_number)
635 dev = libusb_get_device(pdev);
637 return (LIBUSB_ERROR_INVALID_PARAM);
639 if (interface_number < 0 || interface_number > 31)
640 return (LIBUSB_ERROR_INVALID_PARAM);
643 if (!(dev->claimed_interfaces & (1 << interface_number)))
644 err = LIBUSB_ERROR_NOT_FOUND;
647 dev->claimed_interfaces &= ~(1 << interface_number);
648 CTX_UNLOCK(dev->ctx);
653 libusb_set_interface_alt_setting(struct libusb20_device *pdev,
654 int interface_number, int alternate_setting)
659 dev = libusb_get_device(pdev);
661 return (LIBUSB_ERROR_INVALID_PARAM);
663 if (interface_number < 0 || interface_number > 31)
664 return (LIBUSB_ERROR_INVALID_PARAM);
667 if (!(dev->claimed_interfaces & (1 << interface_number)))
668 err = LIBUSB_ERROR_NOT_FOUND;
669 CTX_UNLOCK(dev->ctx);
674 libusb10_cancel_all_transfer(dev);
676 libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
678 err = libusb20_dev_set_alt_index(pdev,
679 interface_number, alternate_setting);
681 libusb10_add_pollfd(dev->ctx, &dev->dev_poll,
682 pdev, libusb20_dev_get_fd(pdev),
683 POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
685 return (err ? LIBUSB_ERROR_OTHER : 0);
688 static struct libusb20_transfer *
689 libusb10_get_transfer(struct libusb20_device *pdev,
690 uint8_t endpoint, uint8_t xfer_index)
692 xfer_index &= 1; /* double buffering */
694 xfer_index |= (endpoint & LIBUSB20_ENDPOINT_ADDRESS_MASK) * 4;
696 if (endpoint & LIBUSB20_ENDPOINT_DIR_MASK) {
697 /* this is an IN endpoint */
700 return (libusb20_tr_get_pointer(pdev, xfer_index));
704 libusb_clear_halt(struct libusb20_device *pdev, uint8_t endpoint)
706 struct libusb20_transfer *xfer;
707 struct libusb_device *dev;
710 xfer = libusb10_get_transfer(pdev, endpoint, 0);
712 return (LIBUSB_ERROR_INVALID_PARAM);
714 dev = libusb_get_device(pdev);
716 return (LIBUSB_ERROR_INVALID_PARAM);
719 err = libusb20_tr_open(xfer, 0, 1, endpoint);
720 CTX_UNLOCK(dev->ctx);
722 if (err != 0 && err != LIBUSB20_ERROR_BUSY)
723 return (LIBUSB_ERROR_OTHER);
725 libusb20_tr_clear_stall_sync(xfer);
727 /* check if we opened the transfer */
730 libusb20_tr_close(xfer);
731 CTX_UNLOCK(dev->ctx);
733 return (0); /* success */
737 libusb_reset_device(struct libusb20_device *pdev)
742 dev = libusb_get_device(pdev);
744 return (LIBUSB_ERROR_INVALID_PARAM);
746 libusb10_cancel_all_transfer(dev);
748 libusb10_remove_pollfd(dev->ctx, &dev->dev_poll);
750 err = libusb20_dev_reset(pdev);
752 libusb10_add_pollfd(dev->ctx, &dev->dev_poll,
753 pdev, libusb20_dev_get_fd(pdev),
754 POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM);
756 return (err ? LIBUSB_ERROR_OTHER : 0);
760 libusb_check_connected(struct libusb20_device *pdev)
765 dev = libusb_get_device(pdev);
767 return (LIBUSB_ERROR_INVALID_PARAM);
769 err = libusb20_dev_check_connected(pdev);
771 return (err ? LIBUSB_ERROR_NO_DEVICE : 0);
775 libusb_kernel_driver_active(struct libusb20_device *pdev, int interface)
778 return (LIBUSB_ERROR_INVALID_PARAM);
780 if (libusb20_dev_kernel_driver_active(pdev, interface))
781 return (0); /* no kernel driver is active */
783 return (1); /* kernel driver is active */
787 libusb_get_driver_np(struct libusb20_device *pdev, int interface,
788 char *name, int namelen)
790 return (libusb_get_driver(pdev, interface, name, namelen));
794 libusb_get_driver(struct libusb20_device *pdev, int interface,
795 char *name, int namelen)
801 return (LIBUSB_ERROR_INVALID_PARAM);
803 return (LIBUSB_ERROR_INVALID_PARAM);
807 err = libusb20_dev_get_iface_desc(
808 pdev, interface, name, namelen);
811 return (LIBUSB_ERROR_OTHER);
813 /* we only want the driver name */
814 ptr = strstr(name, ":");
822 libusb_detach_kernel_driver_np(struct libusb20_device *pdev, int interface)
824 return (libusb_detach_kernel_driver(pdev, interface));
828 libusb_detach_kernel_driver(struct libusb20_device *pdev, int interface)
833 return (LIBUSB_ERROR_INVALID_PARAM);
835 err = libusb20_dev_detach_kernel_driver(
838 return (err ? LIBUSB_ERROR_OTHER : 0);
842 libusb_attach_kernel_driver(struct libusb20_device *pdev, int interface)
845 return (LIBUSB_ERROR_INVALID_PARAM);
846 /* stub - currently not supported by libusb20 */
850 /* Asynchronous device I/O */
852 struct libusb_transfer *
853 libusb_alloc_transfer(int iso_packets)
855 struct libusb_transfer *uxfer;
856 struct libusb_super_transfer *sxfer;
859 len = sizeof(struct libusb_transfer) +
860 sizeof(struct libusb_super_transfer) +
861 (iso_packets * sizeof(libusb_iso_packet_descriptor));
867 memset(sxfer, 0, len);
869 uxfer = (struct libusb_transfer *)(
870 ((uint8_t *)sxfer) + sizeof(*sxfer));
872 /* set default value */
873 uxfer->num_iso_packets = iso_packets;
879 libusb_free_transfer(struct libusb_transfer *uxfer)
881 struct libusb_super_transfer *sxfer;
884 return; /* be NULL safe */
886 /* check if we should free the transfer buffer */
887 if (uxfer->flags & LIBUSB_TRANSFER_FREE_BUFFER)
890 sxfer = (struct libusb_super_transfer *)(
891 (uint8_t *)uxfer - sizeof(*sxfer));
897 libusb10_get_maxframe(struct libusb20_device *pdev, libusb_transfer *xfer)
901 switch (xfer->type) {
902 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
903 ret = 60 | LIBUSB20_MAX_FRAME_PRE_SCALE; /* 60ms */
905 case LIBUSB_TRANSFER_TYPE_CONTROL:
916 libusb10_get_buffsize(struct libusb20_device *pdev, libusb_transfer *xfer)
921 usb_speed = libusb20_dev_get_speed(pdev);
923 switch (xfer->type) {
924 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
925 ret = 0; /* kernel will auto-select */
927 case LIBUSB_TRANSFER_TYPE_CONTROL:
932 case LIBUSB20_SPEED_LOW:
935 case LIBUSB20_SPEED_FULL:
948 libusb10_convert_error(uint8_t status)
953 case LIBUSB20_TRANSFER_START:
954 case LIBUSB20_TRANSFER_COMPLETED:
955 return (LIBUSB_TRANSFER_COMPLETED);
956 case LIBUSB20_TRANSFER_OVERFLOW:
957 return (LIBUSB_TRANSFER_OVERFLOW);
958 case LIBUSB20_TRANSFER_NO_DEVICE:
959 return (LIBUSB_TRANSFER_NO_DEVICE);
960 case LIBUSB20_TRANSFER_STALL:
961 return (LIBUSB_TRANSFER_STALL);
962 case LIBUSB20_TRANSFER_CANCELLED:
963 return (LIBUSB_TRANSFER_CANCELLED);
964 case LIBUSB20_TRANSFER_TIMED_OUT:
965 return (LIBUSB_TRANSFER_TIMED_OUT);
967 return (LIBUSB_TRANSFER_ERROR);
971 /* This function must be called locked */
974 libusb10_complete_transfer(struct libusb20_transfer *pxfer,
975 struct libusb_super_transfer *sxfer, int status)
977 struct libusb_transfer *uxfer;
978 struct libusb_device *dev;
980 uxfer = (struct libusb_transfer *)(
981 ((uint8_t *)sxfer) + sizeof(*sxfer));
984 libusb20_tr_set_priv_sc1(pxfer, NULL);
986 /* set transfer status */
987 uxfer->status = status;
989 /* update super transfer state */
990 sxfer->state = LIBUSB_SUPER_XFER_ST_NONE;
992 dev = libusb_get_device(uxfer->dev_handle);
994 TAILQ_INSERT_TAIL(&dev->ctx->tr_done, sxfer, entry);
997 /* This function must be called locked */
1000 libusb10_isoc_proxy(struct libusb20_transfer *pxfer)
1002 struct libusb_super_transfer *sxfer;
1003 struct libusb_transfer *uxfer;
1005 uint16_t iso_packets;
1010 status = libusb20_tr_get_status(pxfer);
1011 sxfer = libusb20_tr_get_priv_sc1(pxfer);
1012 actlen = libusb20_tr_get_actual_length(pxfer);
1013 iso_packets = libusb20_tr_get_max_frames(pxfer);
1016 return; /* cancelled - nothing to do */
1018 uxfer = (struct libusb_transfer *)(
1019 ((uint8_t *)sxfer) + sizeof(*sxfer));
1021 if (iso_packets > uxfer->num_iso_packets)
1022 iso_packets = uxfer->num_iso_packets;
1024 if (iso_packets == 0)
1025 return; /* nothing to do */
1027 /* make sure that the number of ISOCHRONOUS packets is valid */
1028 uxfer->num_iso_packets = iso_packets;
1030 flags = uxfer->flags;
1033 case LIBUSB20_TRANSFER_COMPLETED:
1035 /* update actual length */
1036 uxfer->actual_length = actlen;
1037 for (i = 0; i != iso_packets; i++) {
1038 uxfer->iso_packet_desc[i].actual_length =
1039 libusb20_tr_get_length(pxfer, i);
1041 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1044 case LIBUSB20_TRANSFER_START:
1046 /* setup length(s) */
1048 for (i = 0; i != iso_packets; i++) {
1049 libusb20_tr_setup_isoc(pxfer,
1050 &uxfer->buffer[actlen],
1051 uxfer->iso_packet_desc[i].length, i);
1052 actlen += uxfer->iso_packet_desc[i].length;
1058 libusb20_tr_set_total_frames(pxfer, iso_packets);
1059 libusb20_tr_submit(pxfer);
1061 /* fork another USB transfer, if any */
1062 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1066 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1071 /* This function must be called locked */
1074 libusb10_bulk_intr_proxy(struct libusb20_transfer *pxfer)
1076 struct libusb_super_transfer *sxfer;
1077 struct libusb_transfer *uxfer;
1083 status = libusb20_tr_get_status(pxfer);
1084 sxfer = libusb20_tr_get_priv_sc1(pxfer);
1085 max_bulk = libusb20_tr_get_max_total_length(pxfer);
1086 actlen = libusb20_tr_get_actual_length(pxfer);
1089 return; /* cancelled - nothing to do */
1091 uxfer = (struct libusb_transfer *)(
1092 ((uint8_t *)sxfer) + sizeof(*sxfer));
1094 flags = uxfer->flags;
1097 case LIBUSB20_TRANSFER_COMPLETED:
1099 uxfer->actual_length += actlen;
1101 /* check for short packet */
1102 if (sxfer->last_len != actlen) {
1103 if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
1104 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR);
1106 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1110 /* check for end of data */
1111 if (sxfer->rem_len == 0) {
1112 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1117 case LIBUSB20_TRANSFER_START:
1118 if (max_bulk > sxfer->rem_len) {
1119 max_bulk = sxfer->rem_len;
1121 /* setup new BULK or INTERRUPT transaction */
1122 libusb20_tr_setup_bulk(pxfer,
1123 sxfer->curr_data, max_bulk, uxfer->timeout);
1125 /* update counters */
1126 sxfer->last_len = max_bulk;
1127 sxfer->curr_data += max_bulk;
1128 sxfer->rem_len -= max_bulk;
1130 libusb20_tr_submit(pxfer);
1132 /* check if we can fork another USB transfer */
1133 if (sxfer->rem_len == 0)
1134 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1138 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1143 /* This function must be called locked */
1146 libusb10_ctrl_proxy(struct libusb20_transfer *pxfer)
1148 struct libusb_super_transfer *sxfer;
1149 struct libusb_transfer *uxfer;
1155 status = libusb20_tr_get_status(pxfer);
1156 sxfer = libusb20_tr_get_priv_sc1(pxfer);
1157 max_bulk = libusb20_tr_get_max_total_length(pxfer);
1158 actlen = libusb20_tr_get_actual_length(pxfer);
1161 return; /* cancelled - nothing to do */
1163 uxfer = (struct libusb_transfer *)(
1164 ((uint8_t *)sxfer) + sizeof(*sxfer));
1166 flags = uxfer->flags;
1169 case LIBUSB20_TRANSFER_COMPLETED:
1171 uxfer->actual_length += actlen;
1173 /* subtract length of SETUP packet, if any */
1174 actlen -= libusb20_tr_get_length(pxfer, 0);
1176 /* check for short packet */
1177 if (sxfer->last_len != actlen) {
1178 if (flags & LIBUSB_TRANSFER_SHORT_NOT_OK) {
1179 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_ERROR);
1181 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1185 /* check for end of data */
1186 if (sxfer->rem_len == 0) {
1187 libusb10_complete_transfer(pxfer, sxfer, LIBUSB_TRANSFER_COMPLETED);
1192 case LIBUSB20_TRANSFER_START:
1193 if (max_bulk > sxfer->rem_len) {
1194 max_bulk = sxfer->rem_len;
1196 /* setup new CONTROL transaction */
1197 if (status == LIBUSB20_TRANSFER_COMPLETED) {
1198 /* next fragment - don't send SETUP packet */
1199 libusb20_tr_set_length(pxfer, 0, 0);
1201 /* first fragment - send SETUP packet */
1202 libusb20_tr_set_length(pxfer, 8, 0);
1203 libusb20_tr_set_buffer(pxfer, uxfer->buffer, 0);
1206 if (max_bulk != 0) {
1207 libusb20_tr_set_length(pxfer, max_bulk, 1);
1208 libusb20_tr_set_buffer(pxfer, sxfer->curr_data, 1);
1209 libusb20_tr_set_total_frames(pxfer, 2);
1211 libusb20_tr_set_total_frames(pxfer, 1);
1214 /* update counters */
1215 sxfer->last_len = max_bulk;
1216 sxfer->curr_data += max_bulk;
1217 sxfer->rem_len -= max_bulk;
1219 libusb20_tr_submit(pxfer);
1221 /* check if we can fork another USB transfer */
1222 if (sxfer->rem_len == 0)
1223 libusb10_submit_transfer_sub(libusb20_tr_get_priv_sc0(pxfer), uxfer->endpoint);
1227 libusb10_complete_transfer(pxfer, sxfer, libusb10_convert_error(status));
1232 /* The following function must be called locked */
1235 libusb10_submit_transfer_sub(struct libusb20_device *pdev, uint8_t endpoint)
1237 struct libusb20_transfer *pxfer0;
1238 struct libusb20_transfer *pxfer1;
1239 struct libusb_super_transfer *sxfer;
1240 struct libusb_transfer *uxfer;
1241 struct libusb_device *dev;
1248 dev = libusb_get_device(pdev);
1250 pxfer0 = libusb10_get_transfer(pdev, endpoint, 0);
1251 pxfer1 = libusb10_get_transfer(pdev, endpoint, 1);
1253 if (pxfer0 == NULL || pxfer1 == NULL)
1254 return; /* shouldn't happen */
1257 if (libusb20_tr_pending(pxfer0))
1259 if (libusb20_tr_pending(pxfer1))
1264 /* wait till one of the transfers complete */
1267 sxfer = libusb20_tr_get_priv_sc1(pxfer1);
1269 return; /* cancelling */
1271 return; /* cannot queue another one */
1272 /* swap transfers */
1276 sxfer = libusb20_tr_get_priv_sc1(pxfer0);
1278 return; /* cancelling */
1280 return; /* cannot queue another one */
1281 /* swap transfers */
1288 /* find next transfer on same endpoint */
1289 TAILQ_FOREACH(sxfer, &dev->tr_head, entry) {
1291 uxfer = (struct libusb_transfer *)(
1292 ((uint8_t *)sxfer) + sizeof(*sxfer));
1294 if (uxfer->endpoint == endpoint) {
1295 TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1296 sxfer->entry.tqe_prev = NULL;
1300 return; /* success */
1304 libusb20_tr_set_priv_sc0(pxfer0, pdev);
1305 libusb20_tr_set_priv_sc1(pxfer0, sxfer);
1307 /* reset super transfer state */
1308 sxfer->rem_len = uxfer->length;
1309 sxfer->curr_data = uxfer->buffer;
1310 uxfer->actual_length = 0;
1312 switch (uxfer->type) {
1313 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1314 libusb20_tr_set_callback(pxfer0, libusb10_isoc_proxy);
1316 case LIBUSB_TRANSFER_TYPE_BULK:
1317 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1318 libusb20_tr_set_callback(pxfer0, libusb10_bulk_intr_proxy);
1320 case LIBUSB_TRANSFER_TYPE_CONTROL:
1321 libusb20_tr_set_callback(pxfer0, libusb10_ctrl_proxy);
1322 if (sxfer->rem_len < 8)
1325 /* remove SETUP packet from data */
1326 sxfer->rem_len -= 8;
1327 sxfer->curr_data += 8;
1333 buffsize = libusb10_get_buffsize(pdev, uxfer);
1334 maxframe = libusb10_get_maxframe(pdev, uxfer);
1336 /* make sure the transfer is opened */
1337 err = libusb20_tr_open(pxfer0, buffsize, maxframe, endpoint);
1338 if (err && (err != LIBUSB20_ERROR_BUSY)) {
1341 libusb20_tr_start(pxfer0);
1345 libusb10_complete_transfer(pxfer0, sxfer, LIBUSB_TRANSFER_ERROR);
1347 /* make sure our event loop spins the done handler */
1349 err = write(dev->ctx->ctrl_pipe[1], &dummy, sizeof(dummy));
1352 /* The following function must be called unlocked */
1355 libusb_submit_transfer(struct libusb_transfer *uxfer)
1357 struct libusb20_transfer *pxfer0;
1358 struct libusb20_transfer *pxfer1;
1359 struct libusb_super_transfer *sxfer;
1360 struct libusb_device *dev;
1365 return (LIBUSB_ERROR_INVALID_PARAM);
1367 if (uxfer->dev_handle == NULL)
1368 return (LIBUSB_ERROR_INVALID_PARAM);
1370 endpoint = uxfer->endpoint;
1372 dev = libusb_get_device(uxfer->dev_handle);
1374 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer enter");
1376 sxfer = (struct libusb_super_transfer *)(
1377 (uint8_t *)uxfer - sizeof(*sxfer));
1381 pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0);
1382 pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1);
1384 if (pxfer0 == NULL || pxfer1 == NULL) {
1385 err = LIBUSB_ERROR_OTHER;
1386 } else if ((sxfer->entry.tqe_prev != NULL) ||
1387 (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) ||
1388 (libusb20_tr_get_priv_sc1(pxfer1) == sxfer)) {
1389 err = LIBUSB_ERROR_BUSY;
1392 /* set pending state */
1393 sxfer->state = LIBUSB_SUPER_XFER_ST_PEND;
1395 /* insert transfer into transfer head list */
1396 TAILQ_INSERT_TAIL(&dev->tr_head, sxfer, entry);
1398 /* start work transfers */
1399 libusb10_submit_transfer_sub(
1400 uxfer->dev_handle, endpoint);
1402 err = 0; /* success */
1405 CTX_UNLOCK(dev->ctx);
1407 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_submit_transfer leave %d", err);
1412 /* Asynchronous transfer cancel */
1415 libusb_cancel_transfer(struct libusb_transfer *uxfer)
1417 struct libusb20_transfer *pxfer0;
1418 struct libusb20_transfer *pxfer1;
1419 struct libusb_super_transfer *sxfer;
1420 struct libusb_device *dev;
1425 return (LIBUSB_ERROR_INVALID_PARAM);
1427 /* check if not initialised */
1428 if (uxfer->dev_handle == NULL)
1429 return (LIBUSB_ERROR_NOT_FOUND);
1431 endpoint = uxfer->endpoint;
1433 dev = libusb_get_device(uxfer->dev_handle);
1435 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer enter");
1437 sxfer = (struct libusb_super_transfer *)(
1438 (uint8_t *)uxfer - sizeof(*sxfer));
1444 pxfer0 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 0);
1445 pxfer1 = libusb10_get_transfer(uxfer->dev_handle, endpoint, 1);
1447 if (sxfer->state != LIBUSB_SUPER_XFER_ST_PEND) {
1448 /* only update the transfer status */
1449 uxfer->status = LIBUSB_TRANSFER_CANCELLED;
1450 retval = LIBUSB_ERROR_NOT_FOUND;
1451 } else if (sxfer->entry.tqe_prev != NULL) {
1452 /* we are lucky - transfer is on a queue */
1453 TAILQ_REMOVE(&dev->tr_head, sxfer, entry);
1454 sxfer->entry.tqe_prev = NULL;
1455 libusb10_complete_transfer(NULL,
1456 sxfer, LIBUSB_TRANSFER_CANCELLED);
1457 } else if (pxfer0 == NULL || pxfer1 == NULL) {
1459 retval = LIBUSB_ERROR_NOT_FOUND;
1460 } else if (libusb20_tr_get_priv_sc1(pxfer0) == sxfer) {
1461 libusb10_complete_transfer(pxfer0,
1462 sxfer, LIBUSB_TRANSFER_CANCELLED);
1463 libusb20_tr_stop(pxfer0);
1464 /* make sure the queue doesn't stall */
1465 libusb10_submit_transfer_sub(
1466 uxfer->dev_handle, endpoint);
1467 } else if (libusb20_tr_get_priv_sc1(pxfer1) == sxfer) {
1468 libusb10_complete_transfer(pxfer1,
1469 sxfer, LIBUSB_TRANSFER_CANCELLED);
1470 libusb20_tr_stop(pxfer1);
1471 /* make sure the queue doesn't stall */
1472 libusb10_submit_transfer_sub(
1473 uxfer->dev_handle, endpoint);
1476 retval = LIBUSB_ERROR_NOT_FOUND;
1479 CTX_UNLOCK(dev->ctx);
1481 DPRINTF(dev->ctx, LIBUSB_DEBUG_FUNCTION, "libusb_cancel_transfer leave");
1487 libusb10_cancel_all_transfer(libusb_device *dev)
1493 libusb_cpu_to_le16(uint16_t x)
1495 return (htole16(x));
1499 libusb_le16_to_cpu(uint16_t x)
1501 return (le16toh(x));
1505 libusb_strerror(int code)
1508 case LIBUSB_SUCCESS:
1510 case LIBUSB_ERROR_IO:
1511 return ("I/O error");
1512 case LIBUSB_ERROR_INVALID_PARAM:
1513 return ("Invalid parameter");
1514 case LIBUSB_ERROR_ACCESS:
1515 return ("Permissions error");
1516 case LIBUSB_ERROR_NO_DEVICE:
1517 return ("No device");
1518 case LIBUSB_ERROR_NOT_FOUND:
1519 return ("Not found");
1520 case LIBUSB_ERROR_BUSY:
1521 return ("Device busy");
1522 case LIBUSB_ERROR_TIMEOUT:
1524 case LIBUSB_ERROR_OVERFLOW:
1525 return ("Overflow");
1526 case LIBUSB_ERROR_PIPE:
1527 return ("Pipe error");
1528 case LIBUSB_ERROR_INTERRUPTED:
1529 return ("Interrupted");
1530 case LIBUSB_ERROR_NO_MEM:
1531 return ("Out of memory");
1532 case LIBUSB_ERROR_NOT_SUPPORTED:
1533 return ("Not supported");
1534 case LIBUSB_ERROR_OTHER:
1535 return ("Other error");
1537 return ("Unknown error");
1542 libusb_error_name(int code)
1545 case LIBUSB_SUCCESS:
1546 return ("LIBUSB_SUCCESS");
1547 case LIBUSB_ERROR_IO:
1548 return ("LIBUSB_ERROR_IO");
1549 case LIBUSB_ERROR_INVALID_PARAM:
1550 return ("LIBUSB_ERROR_INVALID_PARAM");
1551 case LIBUSB_ERROR_ACCESS:
1552 return ("LIBUSB_ERROR_ACCESS");
1553 case LIBUSB_ERROR_NO_DEVICE:
1554 return ("LIBUSB_ERROR_NO_DEVICE");
1555 case LIBUSB_ERROR_NOT_FOUND:
1556 return ("LIBUSB_ERROR_NOT_FOUND");
1557 case LIBUSB_ERROR_BUSY:
1558 return ("LIBUSB_ERROR_BUSY");
1559 case LIBUSB_ERROR_TIMEOUT:
1560 return ("LIBUSB_ERROR_TIMEOUT");
1561 case LIBUSB_ERROR_OVERFLOW:
1562 return ("LIBUSB_ERROR_OVERFLOW");
1563 case LIBUSB_ERROR_PIPE:
1564 return ("LIBUSB_ERROR_PIPE");
1565 case LIBUSB_ERROR_INTERRUPTED:
1566 return ("LIBUSB_ERROR_INTERRUPTED");
1567 case LIBUSB_ERROR_NO_MEM:
1568 return ("LIBUSB_ERROR_NO_MEM");
1569 case LIBUSB_ERROR_NOT_SUPPORTED:
1570 return ("LIBUSB_ERROR_NOT_SUPPORTED");
1571 case LIBUSB_ERROR_OTHER:
1572 return ("LIBUSB_ERROR_OTHER");
1574 return ("LIBUSB_ERROR_UNKNOWN");