1 /* -*- Mode: C; c-basic-offset:8 ; indent-tabs-mode:t -*- */
3 * Linux usbfs backend for libusb
4 * Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
5 * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
6 * Copyright © 2013 Nathan Hjelm <hjelmn@mac.com>
7 * Copyright © 2012-2013 Hans de Goede <hdegoede@redhat.com>
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
35 #include <sys/ioctl.h>
37 #include <sys/types.h>
38 #include <sys/utsname.h>
42 #include "linux_usbfs.h"
45 * opening a usbfs node causes the device to be resumed, so we attempt to
46 * avoid this during enumeration.
48 * sysfs allows us to read the kernel's in-memory copies of device descriptors
49 * and so forth, avoiding the need to open the device:
50 * - The binary "descriptors" file contains all config descriptors since
51 * 2.6.26, commit 217a9081d8e69026186067711131b77f0ce219ed
52 * - The binary "descriptors" file was added in 2.6.23, commit
53 * 69d42a78f935d19384d1f6e4f94b65bb162b36df, but it only contains the
54 * active config descriptors
55 * - The "busnum" file was added in 2.6.22, commit
56 * 83f7d958eab2fbc6b159ee92bf1493924e1d0f72
57 * - The "devnum" file has been present since pre-2.6.18
58 * - the "bConfigurationValue" file has been present since pre-2.6.18
60 * If we have bConfigurationValue, busnum, and devnum, then we can determine
61 * the active configuration without having to open the usbfs node in RDWR mode.
62 * The busnum file is important as that is the only way we can relate sysfs
63 * devices to usbfs nodes.
65 * If we also have all descriptors, we can obtain the device descriptor and
66 * configuration without touching usbfs at all.
69 /* endianness for multi-byte fields:
71 * Descriptors exposed by usbfs have the multi-byte fields in the device
72 * descriptor as host endian. Multi-byte fields in the other descriptors are
73 * bus-endian. The kernel documentation says otherwise, but it is wrong.
75 * In sysfs all descriptors are bus-endian.
78 static const char *usbfs_path = NULL;
80 /* use usbdev*.* device names in /dev instead of the usbfs bus directories */
81 static int usbdev_names = 0;
83 /* Linux 2.6.32 adds support for a bulk continuation URB flag. this basically
84 * allows us to mark URBs as being part of a specific logical transfer when
85 * we submit them to the kernel. then, on any error except a cancellation, all
86 * URBs within that transfer will be cancelled and no more URBs will be
87 * accepted for the transfer, meaning that no more data can creep in.
89 * The BULK_CONTINUATION flag must be set on all URBs within a bulk transfer
90 * (in either direction) except the first.
91 * For IN transfers, we must also set SHORT_NOT_OK on all URBs except the
92 * last; it means that the kernel should treat a short reply as an error.
93 * For OUT transfers, SHORT_NOT_OK must not be set. it isn't needed (OUT
94 * transfers can't be short unless there's already some sort of error), and
95 * setting this flag is disallowed (a kernel with USB debugging enabled will
98 static int supports_flag_bulk_continuation = -1;
100 /* Linux 2.6.31 fixes support for the zero length packet URB flag. This
101 * allows us to mark URBs that should be followed by a zero length data
102 * packet, which can be required by device- or class-specific protocols.
104 static int supports_flag_zero_packet = -1;
106 /* clock ID for monotonic clock, as not all clock sources are available on all
107 * systems. appropriate choice made at initialization time. */
108 static clockid_t monotonic_clkid = -1;
110 /* Linux 2.6.22 (commit 83f7d958eab2fbc6b159ee92bf1493924e1d0f72) adds a busnum
111 * to sysfs, so we can relate devices. This also implies that we can read
112 * the active configuration through bConfigurationValue */
113 static int sysfs_can_relate_devices = -1;
115 /* Linux 2.6.26 (commit 217a9081d8e69026186067711131b77f0ce219ed) adds all
116 * config descriptors (rather then just the active config) to the sysfs
117 * descriptors file, so from then on we can use them. */
118 static int sysfs_has_descriptors = -1;
120 /* how many times have we initted (and not exited) ? */
121 static int init_count = 0;
123 /* Serialize hotplug start/stop */
124 static usbi_mutex_static_t linux_hotplug_startstop_lock = USBI_MUTEX_INITIALIZER;
125 /* Serialize scan-devices, event-thread, and poll */
126 usbi_mutex_static_t linux_hotplug_lock = USBI_MUTEX_INITIALIZER;
128 static int linux_start_event_monitor(void);
129 static int linux_stop_event_monitor(void);
130 static int linux_scan_devices(struct libusb_context *ctx);
131 static int sysfs_scan_device(struct libusb_context *ctx, const char *devname);
132 static int detach_kernel_driver_and_claim(struct libusb_device_handle *, int);
134 #if !defined(USE_UDEV)
135 static int linux_default_scan_devices (struct libusb_context *ctx);
138 struct linux_device_priv {
140 unsigned char *descriptors;
142 int active_config; /* cache val for !sysfs_can_relate_devices */
145 struct linux_device_handle_priv {
153 /* submission failed after the first URB, so await cancellation/completion
154 * of all the others */
157 /* cancelled by user or timeout */
160 /* completed multi-URB transfer in non-final URB */
163 /* one or more urbs encountered a low-level error */
167 struct linux_transfer_priv {
169 struct usbfs_urb *urbs;
170 struct usbfs_urb **iso_urbs;
173 enum reap_action reap_action;
176 enum libusb_transfer_status reap_status;
178 /* next iso packet in user-supplied transfer to be populated */
179 int iso_packet_offset;
182 static int _get_usbfs_fd(struct libusb_device *dev, mode_t mode, int silent)
184 struct libusb_context *ctx = DEVICE_CTX(dev);
190 snprintf(path, PATH_MAX, "%s/usbdev%d.%d",
191 usbfs_path, dev->bus_number, dev->device_address);
193 snprintf(path, PATH_MAX, "%s/%03d/%03d",
194 usbfs_path, dev->bus_number, dev->device_address);
196 fd = open(path, mode);
198 return fd; /* Success */
200 if (errno == ENOENT) {
202 usbi_err(ctx, "File doesn't exist, wait %d ms and try again", delay/1000);
204 /* Wait 10ms for USB device path creation.*/
205 nanosleep(&(struct timespec){delay / 1000000, (delay * 1000) % 1000000000UL}, NULL);
207 fd = open(path, mode);
209 return fd; /* Success */
213 usbi_err(ctx, "libusb couldn't open USB device %s: %s",
214 path, strerror(errno));
215 if (errno == EACCES && mode == O_RDWR)
216 usbi_err(ctx, "libusb requires write access to USB "
221 return LIBUSB_ERROR_ACCESS;
223 return LIBUSB_ERROR_NO_DEVICE;
224 return LIBUSB_ERROR_IO;
227 static struct linux_device_priv *_device_priv(struct libusb_device *dev)
229 return (struct linux_device_priv *) dev->os_priv;
232 static struct linux_device_handle_priv *_device_handle_priv(
233 struct libusb_device_handle *handle)
235 return (struct linux_device_handle_priv *) handle->os_priv;
238 /* check dirent for a /dev/usbdev%d.%d name
239 * optionally return bus/device on success */
240 static int _is_usbdev_entry(struct dirent *entry, int *bus_p, int *dev_p)
244 if (sscanf(entry->d_name, "usbdev%d.%d", &busnum, &devnum) != 2)
247 usbi_dbg("found: %s", entry->d_name);
255 static int check_usb_vfs(const char *dirname)
258 struct dirent *entry;
261 dir = opendir(dirname);
265 while ((entry = readdir(dir)) != NULL) {
266 if (entry->d_name[0] == '.')
269 /* We assume if we find any files that it must be the right place */
278 static const char *find_usbfs_path(void)
280 const char *path = "/dev/bus/usb";
281 const char *ret = NULL;
283 if (check_usb_vfs(path)) {
286 path = "/proc/bus/usb";
287 if (check_usb_vfs(path))
291 /* look for /dev/usbdev*.* if the normal places fail */
293 struct dirent *entry;
299 while ((entry = readdir(dir)) != NULL) {
300 if (_is_usbdev_entry(entry, NULL, NULL)) {
301 /* found one; that's enough */
311 /* On udev based systems without any usb-devices /dev/bus/usb will not
312 * exist. So if we've not found anything and we're using udev for hotplug
313 * simply assume /dev/bus/usb rather then making libusb_init fail. */
314 #if defined(USE_UDEV)
316 ret = "/dev/bus/usb";
320 usbi_dbg("found usbfs at %s", ret);
325 /* the monotonic clock is not usable on all systems (e.g. embedded ones often
326 * seem to lack it). fall back to REALTIME if we have to. */
327 static clockid_t find_monotonic_clock(void)
329 #ifdef CLOCK_MONOTONIC
333 /* Linux 2.6.28 adds CLOCK_MONOTONIC_RAW but we don't use it
334 * because it's not available through timerfd */
335 r = clock_gettime(CLOCK_MONOTONIC, &ts);
337 return CLOCK_MONOTONIC;
338 usbi_dbg("monotonic clock doesn't work, errno %d", errno);
341 return CLOCK_REALTIME;
344 static int kernel_version_ge(int major, int minor, int sublevel)
347 int atoms, kmajor, kminor, ksublevel;
351 atoms = sscanf(uts.release, "%d.%d.%d", &kmajor, &kminor, &ksublevel);
360 /* kmajor == major */
362 return 0 == minor && 0 == sublevel;
368 /* kminor == minor */
370 return 0 == sublevel;
372 return ksublevel >= sublevel;
375 static int op_init(struct libusb_context *ctx)
380 usbfs_path = find_usbfs_path();
382 usbi_err(ctx, "could not find usbfs");
383 return LIBUSB_ERROR_OTHER;
386 if (monotonic_clkid == -1)
387 monotonic_clkid = find_monotonic_clock();
389 if (supports_flag_bulk_continuation == -1) {
390 /* bulk continuation URB flag available from Linux 2.6.32 */
391 supports_flag_bulk_continuation = kernel_version_ge(2,6,32);
392 if (supports_flag_bulk_continuation == -1) {
393 usbi_err(ctx, "error checking for bulk continuation support");
394 return LIBUSB_ERROR_OTHER;
398 if (supports_flag_bulk_continuation)
399 usbi_dbg("bulk continuation flag supported");
401 if (-1 == supports_flag_zero_packet) {
402 /* zero length packet URB flag fixed since Linux 2.6.31 */
403 supports_flag_zero_packet = kernel_version_ge(2,6,31);
404 if (-1 == supports_flag_zero_packet) {
405 usbi_err(ctx, "error checking for zero length packet support");
406 return LIBUSB_ERROR_OTHER;
410 if (supports_flag_zero_packet)
411 usbi_dbg("zero length packet flag supported");
413 if (-1 == sysfs_has_descriptors) {
414 /* sysfs descriptors has all descriptors since Linux 2.6.26 */
415 sysfs_has_descriptors = kernel_version_ge(2,6,26);
416 if (-1 == sysfs_has_descriptors) {
417 usbi_err(ctx, "error checking for sysfs descriptors");
418 return LIBUSB_ERROR_OTHER;
422 if (-1 == sysfs_can_relate_devices) {
423 /* sysfs has busnum since Linux 2.6.22 */
424 sysfs_can_relate_devices = kernel_version_ge(2,6,22);
425 if (-1 == sysfs_can_relate_devices) {
426 usbi_err(ctx, "error checking for sysfs busnum");
427 return LIBUSB_ERROR_OTHER;
431 if (sysfs_can_relate_devices || sysfs_has_descriptors) {
432 r = stat(SYSFS_DEVICE_PATH, &statbuf);
433 if (r != 0 || !S_ISDIR(statbuf.st_mode)) {
434 usbi_warn(ctx, "sysfs not mounted");
435 sysfs_can_relate_devices = 0;
436 sysfs_has_descriptors = 0;
440 if (sysfs_can_relate_devices)
441 usbi_dbg("sysfs can relate devices");
443 if (sysfs_has_descriptors)
444 usbi_dbg("sysfs has complete descriptors");
446 usbi_mutex_static_lock(&linux_hotplug_startstop_lock);
448 if (init_count == 0) {
449 /* start up hotplug event handler */
450 r = linux_start_event_monitor();
452 if (r == LIBUSB_SUCCESS) {
453 r = linux_scan_devices(ctx);
454 if (r == LIBUSB_SUCCESS)
456 else if (init_count == 0)
457 linux_stop_event_monitor();
459 usbi_err(ctx, "error starting hotplug event monitor");
460 usbi_mutex_static_unlock(&linux_hotplug_startstop_lock);
465 static void op_exit(void)
467 usbi_mutex_static_lock(&linux_hotplug_startstop_lock);
468 assert(init_count != 0);
470 /* tear down event handler */
471 (void)linux_stop_event_monitor();
473 usbi_mutex_static_unlock(&linux_hotplug_startstop_lock);
476 static int linux_start_event_monitor(void)
478 #if defined(USE_UDEV)
479 return linux_udev_start_event_monitor();
481 return linux_netlink_start_event_monitor();
485 static int linux_stop_event_monitor(void)
487 #if defined(USE_UDEV)
488 return linux_udev_stop_event_monitor();
490 return linux_netlink_stop_event_monitor();
494 static int linux_scan_devices(struct libusb_context *ctx)
498 usbi_mutex_static_lock(&linux_hotplug_lock);
500 #if defined(USE_UDEV)
501 ret = linux_udev_scan_devices(ctx);
503 ret = linux_default_scan_devices(ctx);
506 usbi_mutex_static_unlock(&linux_hotplug_lock);
511 static void op_hotplug_poll(void)
513 #if defined(USE_UDEV)
514 linux_udev_hotplug_poll();
516 linux_netlink_hotplug_poll();
520 static int _open_sysfs_attr(struct libusb_device *dev, const char *attr)
522 struct linux_device_priv *priv = _device_priv(dev);
523 char filename[PATH_MAX];
526 snprintf(filename, PATH_MAX, "%s/%s/%s",
527 SYSFS_DEVICE_PATH, priv->sysfs_dir, attr);
528 fd = open(filename, O_RDONLY);
530 usbi_err(DEVICE_CTX(dev),
531 "open %s failed ret=%d errno=%d", filename, fd, errno);
532 return LIBUSB_ERROR_IO;
538 /* Note only suitable for attributes which always read >= 0, < 0 is error */
539 static int __read_sysfs_attr(struct libusb_context *ctx,
540 const char *devname, const char *attr)
542 char filename[PATH_MAX];
546 snprintf(filename, PATH_MAX, "%s/%s/%s", SYSFS_DEVICE_PATH,
548 f = fopen(filename, "r");
550 if (errno == ENOENT) {
551 /* File doesn't exist. Assume the device has been
552 disconnected (see trac ticket #70). */
553 return LIBUSB_ERROR_NO_DEVICE;
555 usbi_err(ctx, "open %s failed errno=%d", filename, errno);
556 return LIBUSB_ERROR_IO;
559 r = fscanf(f, "%d", &value);
562 usbi_err(ctx, "fscanf %s returned %d, errno=%d", attr, r, errno);
563 return LIBUSB_ERROR_NO_DEVICE; /* For unplug race (trac #70) */
566 usbi_err(ctx, "%s contains a negative value", filename);
567 return LIBUSB_ERROR_IO;
573 static int op_get_device_descriptor(struct libusb_device *dev,
574 unsigned char *buffer, int *host_endian)
576 struct linux_device_priv *priv = _device_priv(dev);
578 *host_endian = sysfs_has_descriptors ? 0 : 1;
579 memcpy(buffer, priv->descriptors, DEVICE_DESC_LENGTH);
584 /* read the bConfigurationValue for a device */
585 static int sysfs_get_active_config(struct libusb_device *dev, int *config)
588 char tmp[5] = {0, 0, 0, 0, 0};
593 fd = _open_sysfs_attr(dev, "bConfigurationValue");
597 r = read(fd, tmp, sizeof(tmp));
600 usbi_err(DEVICE_CTX(dev),
601 "read bConfigurationValue failed ret=%d errno=%d", r, errno);
602 return LIBUSB_ERROR_IO;
604 usbi_dbg("device unconfigured");
609 if (tmp[sizeof(tmp) - 1] != 0) {
610 usbi_err(DEVICE_CTX(dev), "not null-terminated?");
611 return LIBUSB_ERROR_IO;
612 } else if (tmp[0] == 0) {
613 usbi_err(DEVICE_CTX(dev), "no configuration value?");
614 return LIBUSB_ERROR_IO;
617 num = strtol(tmp, &endptr, 10);
619 usbi_err(DEVICE_CTX(dev), "error converting '%s' to integer", tmp);
620 return LIBUSB_ERROR_IO;
627 int linux_get_device_address (struct libusb_context *ctx, int detached,
628 uint8_t *busnum, uint8_t *devaddr,const char *dev_node,
629 const char *sys_name)
633 usbi_dbg("getting address for device: %s detached: %d", sys_name, detached);
634 /* can't use sysfs to read the bus and device number if the
635 * device has been detached */
636 if (!sysfs_can_relate_devices || detached || NULL == sys_name) {
637 if (NULL == dev_node) {
638 return LIBUSB_ERROR_OTHER;
641 /* will this work with all supported kernel versions? */
642 if (!strncmp(dev_node, "/dev/bus/usb", 12)) {
643 sscanf (dev_node, "/dev/bus/usb/%hhu/%hhu", busnum, devaddr);
644 } else if (!strncmp(dev_node, "/proc/bus/usb", 13)) {
645 sscanf (dev_node, "/proc/bus/usb/%hhu/%hhu", busnum, devaddr);
648 return LIBUSB_SUCCESS;
651 usbi_dbg("scan %s", sys_name);
653 sysfs_attr = __read_sysfs_attr(ctx, sys_name, "busnum");
656 if (sysfs_attr > 255)
657 return LIBUSB_ERROR_INVALID_PARAM;
658 *busnum = (uint8_t) sysfs_attr;
660 sysfs_attr = __read_sysfs_attr(ctx, sys_name, "devnum");
663 if (sysfs_attr > 255)
664 return LIBUSB_ERROR_INVALID_PARAM;
666 *devaddr = (uint8_t) sysfs_attr;
668 usbi_dbg("bus=%d dev=%d", *busnum, *devaddr);
670 return LIBUSB_SUCCESS;
673 /* Return offset of the next descriptor with the given type */
674 static int seek_to_next_descriptor(struct libusb_context *ctx,
675 uint8_t descriptor_type, unsigned char *buffer, int size)
677 struct usb_descriptor_header header;
680 for (i = 0; size >= 0; i += header.bLength, size -= header.bLength) {
682 return LIBUSB_ERROR_NOT_FOUND;
685 usbi_err(ctx, "short descriptor read %d/2", size);
686 return LIBUSB_ERROR_IO;
688 usbi_parse_descriptor(buffer + i, "bb", &header, 0);
690 if (i && header.bDescriptorType == descriptor_type)
693 usbi_err(ctx, "bLength overflow by %d bytes", -size);
694 return LIBUSB_ERROR_IO;
697 /* Return offset to next config */
698 static int seek_to_next_config(struct libusb_context *ctx,
699 unsigned char *buffer, int size)
701 struct libusb_config_descriptor config;
704 return LIBUSB_ERROR_NOT_FOUND;
706 if (size < LIBUSB_DT_CONFIG_SIZE) {
707 usbi_err(ctx, "short descriptor read %d/%d",
708 size, LIBUSB_DT_CONFIG_SIZE);
709 return LIBUSB_ERROR_IO;
712 usbi_parse_descriptor(buffer, "bbwbbbbb", &config, 0);
713 if (config.bDescriptorType != LIBUSB_DT_CONFIG) {
714 usbi_err(ctx, "descriptor is not a config desc (type 0x%02x)",
715 config.bDescriptorType);
716 return LIBUSB_ERROR_IO;
720 * In usbfs the config descriptors are config.wTotalLength bytes apart,
721 * with any short reads from the device appearing as holes in the file.
723 * In sysfs wTotalLength is ignored, instead the kernel returns a
724 * config descriptor with verified bLength fields, with descriptors
725 * with an invalid bLength removed.
727 if (sysfs_has_descriptors) {
728 int next = seek_to_next_descriptor(ctx, LIBUSB_DT_CONFIG,
730 if (next == LIBUSB_ERROR_NOT_FOUND)
735 if (next != config.wTotalLength)
736 usbi_warn(ctx, "config length mismatch wTotalLength "
737 "%d real %d", config.wTotalLength, next);
740 if (config.wTotalLength < LIBUSB_DT_CONFIG_SIZE) {
741 usbi_err(ctx, "invalid wTotalLength %d",
742 config.wTotalLength);
743 return LIBUSB_ERROR_IO;
744 } else if (config.wTotalLength > size) {
745 usbi_warn(ctx, "short descriptor read %d/%d",
746 size, config.wTotalLength);
749 return config.wTotalLength;
753 static int op_get_config_descriptor_by_value(struct libusb_device *dev,
754 uint8_t value, unsigned char **buffer, int *host_endian)
756 struct libusb_context *ctx = DEVICE_CTX(dev);
757 struct linux_device_priv *priv = _device_priv(dev);
758 unsigned char *descriptors = priv->descriptors;
759 int size = priv->descriptors_len;
760 struct libusb_config_descriptor *config;
763 /* Unlike the device desc. config descs. are always in raw format */
766 /* Skip device header */
767 descriptors += DEVICE_DESC_LENGTH;
768 size -= DEVICE_DESC_LENGTH;
770 /* Seek till the config is found, or till "EOF" */
772 int next = seek_to_next_config(ctx, descriptors, size);
775 config = (struct libusb_config_descriptor *)descriptors;
776 if (config->bConfigurationValue == value) {
777 *buffer = descriptors;
785 static int op_get_active_config_descriptor(struct libusb_device *dev,
786 unsigned char *buffer, size_t len, int *host_endian)
789 unsigned char *config_desc;
791 if (sysfs_can_relate_devices) {
792 r = sysfs_get_active_config(dev, &config);
796 /* Use cached bConfigurationValue */
797 struct linux_device_priv *priv = _device_priv(dev);
798 config = priv->active_config;
801 return LIBUSB_ERROR_NOT_FOUND;
803 r = op_get_config_descriptor_by_value(dev, config, &config_desc,
809 memcpy(buffer, config_desc, len);
813 static int op_get_config_descriptor(struct libusb_device *dev,
814 uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
816 struct linux_device_priv *priv = _device_priv(dev);
817 unsigned char *descriptors = priv->descriptors;
818 int i, r, size = priv->descriptors_len;
820 /* Unlike the device desc. config descs. are always in raw format */
823 /* Skip device header */
824 descriptors += DEVICE_DESC_LENGTH;
825 size -= DEVICE_DESC_LENGTH;
827 /* Seek till the config is found, or till "EOF" */
829 r = seek_to_next_config(DEVICE_CTX(dev), descriptors, size);
832 if (i == config_index)
839 memcpy(buffer, descriptors, len);
843 /* send a control message to retrieve active configuration */
844 static int usbfs_get_active_config(struct libusb_device *dev, int fd)
846 struct linux_device_priv *priv = _device_priv(dev);
847 unsigned char active_config = 0;
850 struct usbfs_ctrltransfer ctrl = {
851 .bmRequestType = LIBUSB_ENDPOINT_IN,
852 .bRequest = LIBUSB_REQUEST_GET_CONFIGURATION,
857 .data = &active_config
860 r = ioctl(fd, IOCTL_USBFS_CONTROL, &ctrl);
863 return LIBUSB_ERROR_NO_DEVICE;
865 /* we hit this error path frequently with buggy devices :( */
866 usbi_warn(DEVICE_CTX(dev),
867 "get_configuration failed ret=%d errno=%d", r, errno);
868 priv->active_config = -1;
870 if (active_config > 0) {
871 priv->active_config = active_config;
873 /* some buggy devices have a configuration 0, but we're
874 * reaching into the corner of a corner case here, so let's
875 * not support buggy devices in these circumstances.
876 * stick to the specs: a configuration value of 0 means
878 usbi_warn(DEVICE_CTX(dev),
879 "active cfg 0? assuming unconfigured device");
880 priv->active_config = -1;
884 return LIBUSB_SUCCESS;
887 static int initialize_device(struct libusb_device *dev, uint8_t busnum,
888 uint8_t devaddr, const char *sysfs_dir)
890 struct linux_device_priv *priv = _device_priv(dev);
891 struct libusb_context *ctx = DEVICE_CTX(dev);
892 int descriptors_size = 512; /* Begin with a 1024 byte alloc */
896 dev->bus_number = busnum;
897 dev->device_address = devaddr;
900 priv->sysfs_dir = strdup(sysfs_dir);
901 if (!priv->sysfs_dir)
902 return LIBUSB_ERROR_NO_MEM;
904 /* Note speed can contain 1.5, in this case __read_sysfs_attr
905 will stop parsing at the '.' and return 1 */
906 speed = __read_sysfs_attr(DEVICE_CTX(dev), sysfs_dir, "speed");
909 case 1: dev->speed = LIBUSB_SPEED_LOW; break;
910 case 12: dev->speed = LIBUSB_SPEED_FULL; break;
911 case 480: dev->speed = LIBUSB_SPEED_HIGH; break;
912 case 5000: dev->speed = LIBUSB_SPEED_SUPER; break;
914 usbi_warn(DEVICE_CTX(dev), "Unknown device speed: %d Mbps", speed);
919 /* cache descriptors in memory */
920 if (sysfs_has_descriptors)
921 fd = _open_sysfs_attr(dev, "descriptors");
923 fd = _get_usbfs_fd(dev, O_RDONLY, 0);
928 descriptors_size *= 2;
929 priv->descriptors = usbi_reallocf(priv->descriptors,
931 if (!priv->descriptors) {
933 return LIBUSB_ERROR_NO_MEM;
935 /* usbfs has holes in the file */
936 if (!sysfs_has_descriptors) {
937 memset(priv->descriptors + priv->descriptors_len,
938 0, descriptors_size - priv->descriptors_len);
940 r = read(fd, priv->descriptors + priv->descriptors_len,
941 descriptors_size - priv->descriptors_len);
943 usbi_err(ctx, "read descriptor failed ret=%d errno=%d",
946 return LIBUSB_ERROR_IO;
948 priv->descriptors_len += r;
949 } while (priv->descriptors_len == descriptors_size);
953 if (priv->descriptors_len < DEVICE_DESC_LENGTH) {
954 usbi_err(ctx, "short descriptor read (%d)",
955 priv->descriptors_len);
956 return LIBUSB_ERROR_IO;
959 if (sysfs_can_relate_devices)
960 return LIBUSB_SUCCESS;
962 /* cache active config */
963 fd = _get_usbfs_fd(dev, O_RDWR, 1);
965 /* cannot send a control message to determine the active
966 * config. just assume the first one is active. */
967 usbi_warn(ctx, "Missing rw usbfs access; cannot determine "
968 "active configuration descriptor");
969 if (priv->descriptors_len >=
970 (DEVICE_DESC_LENGTH + LIBUSB_DT_CONFIG_SIZE)) {
971 struct libusb_config_descriptor config;
972 usbi_parse_descriptor(
973 priv->descriptors + DEVICE_DESC_LENGTH,
974 "bbwbbbbb", &config, 0);
975 priv->active_config = config.bConfigurationValue;
977 priv->active_config = -1; /* No config dt */
979 return LIBUSB_SUCCESS;
982 r = usbfs_get_active_config(dev, fd);
988 static int linux_get_parent_info(struct libusb_device *dev, const char *sysfs_dir)
990 struct libusb_context *ctx = DEVICE_CTX(dev);
991 struct libusb_device *it;
992 char *parent_sysfs_dir, *tmp;
993 int ret, add_parent = 1;
995 /* XXX -- can we figure out the topology when using usbfs? */
996 if (NULL == sysfs_dir || 0 == strncmp(sysfs_dir, "usb", 3)) {
997 /* either using usbfs or finding the parent of a root hub */
998 return LIBUSB_SUCCESS;
1001 parent_sysfs_dir = strdup(sysfs_dir);
1002 if (NULL == parent_sysfs_dir) {
1003 return LIBUSB_ERROR_NO_MEM;
1005 if (NULL != (tmp = strrchr(parent_sysfs_dir, '.')) ||
1006 NULL != (tmp = strrchr(parent_sysfs_dir, '-'))) {
1007 dev->port_number = atoi(tmp + 1);
1010 usbi_warn(ctx, "Can not parse sysfs_dir: %s, no parent info",
1012 free (parent_sysfs_dir);
1013 return LIBUSB_SUCCESS;
1016 /* is the parent a root hub? */
1017 if (NULL == strchr(parent_sysfs_dir, '-')) {
1018 tmp = parent_sysfs_dir;
1019 ret = asprintf (&parent_sysfs_dir, "usb%s", tmp);
1022 return LIBUSB_ERROR_NO_MEM;
1027 /* find the parent in the context */
1028 usbi_mutex_lock(&ctx->usb_devs_lock);
1029 list_for_each_entry(it, &ctx->usb_devs, list, struct libusb_device) {
1030 struct linux_device_priv *priv = _device_priv(it);
1031 if (0 == strcmp (priv->sysfs_dir, parent_sysfs_dir)) {
1032 dev->parent_dev = libusb_ref_device(it);
1036 usbi_mutex_unlock(&ctx->usb_devs_lock);
1038 if (!dev->parent_dev && add_parent) {
1039 usbi_dbg("parent_dev %s not enumerated yet, enumerating now",
1041 sysfs_scan_device(ctx, parent_sysfs_dir);
1046 usbi_dbg("Dev %p (%s) has parent %p (%s) port %d", dev, sysfs_dir,
1047 dev->parent_dev, parent_sysfs_dir, dev->port_number);
1049 free (parent_sysfs_dir);
1051 return LIBUSB_SUCCESS;
1054 int linux_enumerate_device(struct libusb_context *ctx,
1055 uint8_t busnum, uint8_t devaddr, const char *sysfs_dir)
1057 unsigned long session_id;
1058 struct libusb_device *dev;
1061 /* FIXME: session ID is not guaranteed unique as addresses can wrap and
1062 * will be reused. instead we should add a simple sysfs attribute with
1064 session_id = busnum << 8 | devaddr;
1065 usbi_dbg("busnum %d devaddr %d session_id %ld", busnum, devaddr,
1068 dev = usbi_get_device_by_session_id(ctx, session_id);
1070 /* device already exists in the context */
1071 usbi_dbg("session_id %ld already exists", session_id);
1072 libusb_unref_device(dev);
1073 return LIBUSB_SUCCESS;
1076 usbi_dbg("allocating new device for %d/%d (session %ld)",
1077 busnum, devaddr, session_id);
1078 dev = usbi_alloc_device(ctx, session_id);
1080 return LIBUSB_ERROR_NO_MEM;
1082 r = initialize_device(dev, busnum, devaddr, sysfs_dir);
1085 r = usbi_sanitize_device(dev);
1089 r = linux_get_parent_info(dev, sysfs_dir);
1094 libusb_unref_device(dev);
1096 usbi_connect_device(dev);
1101 void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name)
1103 struct libusb_context *ctx;
1105 usbi_mutex_static_lock(&active_contexts_lock);
1106 list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
1107 linux_enumerate_device(ctx, busnum, devaddr, sys_name);
1109 usbi_mutex_static_unlock(&active_contexts_lock);
1112 void linux_device_disconnected(uint8_t busnum, uint8_t devaddr)
1114 struct libusb_context *ctx;
1115 struct libusb_device *dev;
1116 unsigned long session_id = busnum << 8 | devaddr;
1118 usbi_mutex_static_lock(&active_contexts_lock);
1119 list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
1120 dev = usbi_get_device_by_session_id (ctx, session_id);
1122 usbi_disconnect_device (dev);
1123 libusb_unref_device(dev);
1125 usbi_dbg("device not found for session %x", session_id);
1128 usbi_mutex_static_unlock(&active_contexts_lock);
1131 #if !defined(USE_UDEV)
1132 /* open a bus directory and adds all discovered devices to the context */
1133 static int usbfs_scan_busdir(struct libusb_context *ctx, uint8_t busnum)
1136 char dirpath[PATH_MAX];
1137 struct dirent *entry;
1138 int r = LIBUSB_ERROR_IO;
1140 snprintf(dirpath, PATH_MAX, "%s/%03d", usbfs_path, busnum);
1141 usbi_dbg("%s", dirpath);
1142 dir = opendir(dirpath);
1144 usbi_err(ctx, "opendir '%s' failed, errno=%d", dirpath, errno);
1145 /* FIXME: should handle valid race conditions like hub unplugged
1146 * during directory iteration - this is not an error */
1150 while ((entry = readdir(dir))) {
1153 if (entry->d_name[0] == '.')
1156 devaddr = atoi(entry->d_name);
1158 usbi_dbg("unknown dir entry %s", entry->d_name);
1162 if (linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL)) {
1163 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1174 static int usbfs_get_device_list(struct libusb_context *ctx)
1176 struct dirent *entry;
1177 DIR *buses = opendir(usbfs_path);
1181 usbi_err(ctx, "opendir buses failed errno=%d", errno);
1182 return LIBUSB_ERROR_IO;
1185 while ((entry = readdir(buses))) {
1188 if (entry->d_name[0] == '.')
1193 if (!_is_usbdev_entry(entry, &busnum, &devaddr))
1196 r = linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL);
1198 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1202 busnum = atoi(entry->d_name);
1204 usbi_dbg("unknown dir entry %s", entry->d_name);
1208 r = usbfs_scan_busdir(ctx, busnum);
1220 static int sysfs_scan_device(struct libusb_context *ctx, const char *devname)
1222 uint8_t busnum, devaddr;
1225 ret = linux_get_device_address (ctx, 0, &busnum, &devaddr, NULL, devname);
1226 if (LIBUSB_SUCCESS != ret) {
1230 return linux_enumerate_device(ctx, busnum & 0xff, devaddr & 0xff,
1234 #if !defined(USE_UDEV)
1235 static int sysfs_get_device_list(struct libusb_context *ctx)
1237 DIR *devices = opendir(SYSFS_DEVICE_PATH);
1238 struct dirent *entry;
1239 int r = LIBUSB_ERROR_IO;
1242 usbi_err(ctx, "opendir devices failed errno=%d", errno);
1246 while ((entry = readdir(devices))) {
1247 if ((!isdigit(entry->d_name[0]) && strncmp(entry->d_name, "usb", 3))
1248 || strchr(entry->d_name, ':'))
1251 if (sysfs_scan_device(ctx, entry->d_name)) {
1252 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1263 static int linux_default_scan_devices (struct libusb_context *ctx)
1265 /* we can retrieve device list and descriptors from sysfs or usbfs.
1266 * sysfs is preferable, because if we use usbfs we end up resuming
1267 * any autosuspended USB devices. however, sysfs is not available
1268 * everywhere, so we need a usbfs fallback too.
1270 * as described in the "sysfs vs usbfs" comment at the top of this
1271 * file, sometimes we have sysfs but not enough information to
1272 * relate sysfs devices to usbfs nodes. op_init() determines the
1273 * adequacy of sysfs and sets sysfs_can_relate_devices.
1275 if (sysfs_can_relate_devices != 0)
1276 return sysfs_get_device_list(ctx);
1278 return usbfs_get_device_list(ctx);
1282 static int op_open(struct libusb_device_handle *handle)
1284 struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
1287 hpriv->fd = _get_usbfs_fd(handle->dev, O_RDWR, 0);
1288 if (hpriv->fd < 0) {
1289 if (hpriv->fd == LIBUSB_ERROR_NO_DEVICE) {
1290 /* device will still be marked as attached if hotplug monitor thread
1291 * hasn't processed remove event yet */
1292 usbi_mutex_static_lock(&linux_hotplug_lock);
1293 if (handle->dev->attached) {
1294 usbi_dbg("open failed with no device, but device still attached");
1295 linux_device_disconnected(handle->dev->bus_number,
1296 handle->dev->device_address);
1298 usbi_mutex_static_unlock(&linux_hotplug_lock);
1303 r = ioctl(hpriv->fd, IOCTL_USBFS_GET_CAPABILITIES, &hpriv->caps);
1305 if (errno == ENOTTY)
1306 usbi_dbg("getcap not available");
1308 usbi_err(HANDLE_CTX(handle), "getcap failed (%d)", errno);
1310 if (supports_flag_zero_packet)
1311 hpriv->caps |= USBFS_CAP_ZERO_PACKET;
1312 if (supports_flag_bulk_continuation)
1313 hpriv->caps |= USBFS_CAP_BULK_CONTINUATION;
1316 r = usbi_add_pollfd(HANDLE_CTX(handle), hpriv->fd, POLLOUT);
1323 static void op_close(struct libusb_device_handle *dev_handle)
1325 struct linux_device_handle_priv *hpriv = _device_handle_priv(dev_handle);
1326 /* fd may have already been removed by POLLERR condition in op_handle_events() */
1327 if (!hpriv->fd_removed)
1328 usbi_remove_pollfd(HANDLE_CTX(dev_handle), hpriv->fd);
1332 static int op_get_configuration(struct libusb_device_handle *handle,
1337 if (sysfs_can_relate_devices) {
1338 r = sysfs_get_active_config(handle->dev, config);
1340 r = usbfs_get_active_config(handle->dev,
1341 _device_handle_priv(handle)->fd);
1342 if (r == LIBUSB_SUCCESS)
1343 *config = _device_priv(handle->dev)->active_config;
1348 if (*config == -1) {
1349 usbi_err(HANDLE_CTX(handle), "device unconfigured");
1356 static int op_set_configuration(struct libusb_device_handle *handle, int config)
1358 struct linux_device_priv *priv = _device_priv(handle->dev);
1359 int fd = _device_handle_priv(handle)->fd;
1360 int r = ioctl(fd, IOCTL_USBFS_SETCONFIG, &config);
1362 if (errno == EINVAL)
1363 return LIBUSB_ERROR_NOT_FOUND;
1364 else if (errno == EBUSY)
1365 return LIBUSB_ERROR_BUSY;
1366 else if (errno == ENODEV)
1367 return LIBUSB_ERROR_NO_DEVICE;
1369 usbi_err(HANDLE_CTX(handle), "failed, error %d errno %d", r, errno);
1370 return LIBUSB_ERROR_OTHER;
1373 /* update our cached active config descriptor */
1374 priv->active_config = config;
1376 return LIBUSB_SUCCESS;
1379 static int claim_interface(struct libusb_device_handle *handle, int iface)
1381 int fd = _device_handle_priv(handle)->fd;
1382 int r = ioctl(fd, IOCTL_USBFS_CLAIMINTF, &iface);
1384 if (errno == ENOENT)
1385 return LIBUSB_ERROR_NOT_FOUND;
1386 else if (errno == EBUSY)
1387 return LIBUSB_ERROR_BUSY;
1388 else if (errno == ENODEV)
1389 return LIBUSB_ERROR_NO_DEVICE;
1391 usbi_err(HANDLE_CTX(handle),
1392 "claim interface failed, error %d errno %d", r, errno);
1393 return LIBUSB_ERROR_OTHER;
1398 static int release_interface(struct libusb_device_handle *handle, int iface)
1400 int fd = _device_handle_priv(handle)->fd;
1401 int r = ioctl(fd, IOCTL_USBFS_RELEASEINTF, &iface);
1403 if (errno == ENODEV)
1404 return LIBUSB_ERROR_NO_DEVICE;
1406 usbi_err(HANDLE_CTX(handle),
1407 "release interface failed, error %d errno %d", r, errno);
1408 return LIBUSB_ERROR_OTHER;
1413 static int op_set_interface(struct libusb_device_handle *handle, int iface,
1416 int fd = _device_handle_priv(handle)->fd;
1417 struct usbfs_setinterface setintf;
1420 setintf.interface = iface;
1421 setintf.altsetting = altsetting;
1422 r = ioctl(fd, IOCTL_USBFS_SETINTF, &setintf);
1424 if (errno == EINVAL)
1425 return LIBUSB_ERROR_NOT_FOUND;
1426 else if (errno == ENODEV)
1427 return LIBUSB_ERROR_NO_DEVICE;
1429 usbi_err(HANDLE_CTX(handle),
1430 "setintf failed error %d errno %d", r, errno);
1431 return LIBUSB_ERROR_OTHER;
1437 static int op_clear_halt(struct libusb_device_handle *handle,
1438 unsigned char endpoint)
1440 int fd = _device_handle_priv(handle)->fd;
1441 unsigned int _endpoint = endpoint;
1442 int r = ioctl(fd, IOCTL_USBFS_CLEAR_HALT, &_endpoint);
1444 if (errno == ENOENT)
1445 return LIBUSB_ERROR_NOT_FOUND;
1446 else if (errno == ENODEV)
1447 return LIBUSB_ERROR_NO_DEVICE;
1449 usbi_err(HANDLE_CTX(handle),
1450 "clear_halt failed error %d errno %d", r, errno);
1451 return LIBUSB_ERROR_OTHER;
1457 static int op_reset_device(struct libusb_device_handle *handle)
1459 int fd = _device_handle_priv(handle)->fd;
1462 /* Doing a device reset will cause the usbfs driver to get unbound
1463 from any interfaces it is bound to. By voluntarily unbinding
1464 the usbfs driver ourself, we stop the kernel from rebinding
1465 the interface after reset (which would end up with the interface
1466 getting bound to the in kernel driver if any). */
1467 for (i = 0; i < USB_MAXINTERFACES; i++) {
1468 if (handle->claimed_interfaces & (1L << i)) {
1469 release_interface(handle, i);
1473 usbi_mutex_lock(&handle->lock);
1474 r = ioctl(fd, IOCTL_USBFS_RESET, NULL);
1476 if (errno == ENODEV) {
1477 ret = LIBUSB_ERROR_NOT_FOUND;
1481 usbi_err(HANDLE_CTX(handle),
1482 "reset failed error %d errno %d", r, errno);
1483 ret = LIBUSB_ERROR_OTHER;
1487 /* And re-claim any interfaces which were claimed before the reset */
1488 for (i = 0; i < USB_MAXINTERFACES; i++) {
1489 if (handle->claimed_interfaces & (1L << i)) {
1491 * A driver may have completed modprobing during
1492 * IOCTL_USBFS_RESET, and bound itself as soon as
1493 * IOCTL_USBFS_RESET released the device lock
1495 r = detach_kernel_driver_and_claim(handle, i);
1497 usbi_warn(HANDLE_CTX(handle),
1498 "failed to re-claim interface %d after reset: %s",
1499 i, libusb_error_name(r));
1500 handle->claimed_interfaces &= ~(1L << i);
1501 ret = LIBUSB_ERROR_NOT_FOUND;
1506 usbi_mutex_unlock(&handle->lock);
1510 static int do_streams_ioctl(struct libusb_device_handle *handle, long req,
1511 uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
1513 int r, fd = _device_handle_priv(handle)->fd;
1514 struct usbfs_streams *streams;
1516 if (num_endpoints > 30) /* Max 15 in + 15 out eps */
1517 return LIBUSB_ERROR_INVALID_PARAM;
1519 streams = malloc(sizeof(struct usbfs_streams) + num_endpoints);
1521 return LIBUSB_ERROR_NO_MEM;
1523 streams->num_streams = num_streams;
1524 streams->num_eps = num_endpoints;
1525 memcpy(streams->eps, endpoints, num_endpoints);
1527 r = ioctl(fd, req, streams);
1532 if (errno == ENOTTY)
1533 return LIBUSB_ERROR_NOT_SUPPORTED;
1534 else if (errno == EINVAL)
1535 return LIBUSB_ERROR_INVALID_PARAM;
1536 else if (errno == ENODEV)
1537 return LIBUSB_ERROR_NO_DEVICE;
1539 usbi_err(HANDLE_CTX(handle),
1540 "streams-ioctl failed error %d errno %d", r, errno);
1541 return LIBUSB_ERROR_OTHER;
1546 static int op_alloc_streams(struct libusb_device_handle *handle,
1547 uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
1549 return do_streams_ioctl(handle, IOCTL_USBFS_ALLOC_STREAMS,
1550 num_streams, endpoints, num_endpoints);
1553 static int op_free_streams(struct libusb_device_handle *handle,
1554 unsigned char *endpoints, int num_endpoints)
1556 return do_streams_ioctl(handle, IOCTL_USBFS_FREE_STREAMS, 0,
1557 endpoints, num_endpoints);
1560 static int op_kernel_driver_active(struct libusb_device_handle *handle,
1563 int fd = _device_handle_priv(handle)->fd;
1564 struct usbfs_getdriver getdrv;
1567 getdrv.interface = interface;
1568 r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1570 if (errno == ENODATA)
1572 else if (errno == ENODEV)
1573 return LIBUSB_ERROR_NO_DEVICE;
1575 usbi_err(HANDLE_CTX(handle),
1576 "get driver failed error %d errno %d", r, errno);
1577 return LIBUSB_ERROR_OTHER;
1580 return (strcmp(getdrv.driver, "usbfs") == 0) ? 0 : 1;
1583 static int op_detach_kernel_driver(struct libusb_device_handle *handle,
1586 int fd = _device_handle_priv(handle)->fd;
1587 struct usbfs_ioctl command;
1588 struct usbfs_getdriver getdrv;
1591 command.ifno = interface;
1592 command.ioctl_code = IOCTL_USBFS_DISCONNECT;
1593 command.data = NULL;
1595 getdrv.interface = interface;
1596 r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1597 if (r == 0 && strcmp(getdrv.driver, "usbfs") == 0)
1598 return LIBUSB_ERROR_NOT_FOUND;
1600 r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1602 if (errno == ENODATA)
1603 return LIBUSB_ERROR_NOT_FOUND;
1604 else if (errno == EINVAL)
1605 return LIBUSB_ERROR_INVALID_PARAM;
1606 else if (errno == ENODEV)
1607 return LIBUSB_ERROR_NO_DEVICE;
1609 usbi_err(HANDLE_CTX(handle),
1610 "detach failed error %d errno %d", r, errno);
1611 return LIBUSB_ERROR_OTHER;
1617 static int op_attach_kernel_driver(struct libusb_device_handle *handle,
1620 int fd = _device_handle_priv(handle)->fd;
1621 struct usbfs_ioctl command;
1624 command.ifno = interface;
1625 command.ioctl_code = IOCTL_USBFS_CONNECT;
1626 command.data = NULL;
1628 r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1630 if (errno == ENODATA)
1631 return LIBUSB_ERROR_NOT_FOUND;
1632 else if (errno == EINVAL)
1633 return LIBUSB_ERROR_INVALID_PARAM;
1634 else if (errno == ENODEV)
1635 return LIBUSB_ERROR_NO_DEVICE;
1636 else if (errno == EBUSY)
1637 return LIBUSB_ERROR_BUSY;
1639 usbi_err(HANDLE_CTX(handle),
1640 "attach failed error %d errno %d", r, errno);
1641 return LIBUSB_ERROR_OTHER;
1642 } else if (r == 0) {
1643 return LIBUSB_ERROR_NOT_FOUND;
1649 static int detach_kernel_driver_and_claim(struct libusb_device_handle *handle,
1652 struct usbfs_disconnect_claim dc;
1653 int r, fd = _device_handle_priv(handle)->fd;
1655 dc.interface = interface;
1656 strcpy(dc.driver, "usbfs");
1657 dc.flags = USBFS_DISCONNECT_CLAIM_EXCEPT_DRIVER;
1658 r = ioctl(fd, IOCTL_USBFS_DISCONNECT_CLAIM, &dc);
1659 if (r == 0 || (r != 0 && errno != ENOTTY)) {
1665 return LIBUSB_ERROR_BUSY;
1667 return LIBUSB_ERROR_INVALID_PARAM;
1669 return LIBUSB_ERROR_NO_DEVICE;
1671 usbi_err(HANDLE_CTX(handle),
1672 "disconnect-and-claim failed errno %d", errno);
1673 return LIBUSB_ERROR_OTHER;
1676 /* Fallback code for kernels which don't support the
1677 disconnect-and-claim ioctl */
1678 r = op_detach_kernel_driver(handle, interface);
1679 if (r != 0 && r != LIBUSB_ERROR_NOT_FOUND)
1682 return claim_interface(handle, interface);
1685 static int op_claim_interface(struct libusb_device_handle *handle, int iface)
1687 if (handle->auto_detach_kernel_driver)
1688 return detach_kernel_driver_and_claim(handle, iface);
1690 return claim_interface(handle, iface);
1693 static int op_release_interface(struct libusb_device_handle *handle, int iface)
1697 r = release_interface(handle, iface);
1701 if (handle->auto_detach_kernel_driver)
1702 op_attach_kernel_driver(handle, iface);
1707 static void op_destroy_device(struct libusb_device *dev)
1709 struct linux_device_priv *priv = _device_priv(dev);
1710 if (priv->descriptors)
1711 free(priv->descriptors);
1712 if (priv->sysfs_dir)
1713 free(priv->sysfs_dir);
1716 /* URBs are discarded in reverse order of submission to avoid races. */
1717 static int discard_urbs(struct usbi_transfer *itransfer, int first, int last_plus_one)
1719 struct libusb_transfer *transfer =
1720 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1721 struct linux_transfer_priv *tpriv =
1722 usbi_transfer_get_os_priv(itransfer);
1723 struct linux_device_handle_priv *dpriv =
1724 _device_handle_priv(transfer->dev_handle);
1726 struct usbfs_urb *urb;
1728 for (i = last_plus_one - 1; i >= first; i--) {
1729 if (LIBUSB_TRANSFER_TYPE_ISOCHRONOUS == transfer->type)
1730 urb = tpriv->iso_urbs[i];
1732 urb = &tpriv->urbs[i];
1734 if (0 == ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, urb))
1737 if (EINVAL == errno) {
1738 usbi_dbg("URB not found --> assuming ready to be reaped");
1739 if (i == (last_plus_one - 1))
1740 ret = LIBUSB_ERROR_NOT_FOUND;
1741 } else if (ENODEV == errno) {
1742 usbi_dbg("Device not found for URB --> assuming ready to be reaped");
1743 ret = LIBUSB_ERROR_NO_DEVICE;
1745 usbi_warn(TRANSFER_CTX(transfer),
1746 "unrecognised discard errno %d", errno);
1747 ret = LIBUSB_ERROR_OTHER;
1753 static void free_iso_urbs(struct linux_transfer_priv *tpriv)
1756 for (i = 0; i < tpriv->num_urbs; i++) {
1757 struct usbfs_urb *urb = tpriv->iso_urbs[i];
1763 free(tpriv->iso_urbs);
1764 tpriv->iso_urbs = NULL;
1767 static int submit_bulk_transfer(struct usbi_transfer *itransfer)
1769 struct libusb_transfer *transfer =
1770 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1771 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1772 struct linux_device_handle_priv *dpriv =
1773 _device_handle_priv(transfer->dev_handle);
1774 struct usbfs_urb *urbs;
1775 int is_out = (transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK)
1776 == LIBUSB_ENDPOINT_OUT;
1777 int bulk_buffer_len, use_bulk_continuation;
1781 if (is_out && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) &&
1782 !(dpriv->caps & USBFS_CAP_ZERO_PACKET))
1783 return LIBUSB_ERROR_NOT_SUPPORTED;
1786 * Older versions of usbfs place a 16kb limit on bulk URBs. We work
1787 * around this by splitting large transfers into 16k blocks, and then
1788 * submit all urbs at once. it would be simpler to submit one urb at
1789 * a time, but there is a big performance gain doing it this way.
1791 * Newer versions lift the 16k limit (USBFS_CAP_NO_PACKET_SIZE_LIM),
1792 * using arbritary large transfers can still be a bad idea though, as
1793 * the kernel needs to allocate physical contiguous memory for this,
1794 * which may fail for large buffers.
1796 * The kernel solves this problem by splitting the transfer into
1797 * blocks itself when the host-controller is scatter-gather capable
1798 * (USBFS_CAP_BULK_SCATTER_GATHER), which most controllers are.
1800 * Last, there is the issue of short-transfers when splitting, for
1801 * short split-transfers to work reliable USBFS_CAP_BULK_CONTINUATION
1802 * is needed, but this is not always available.
1804 if (dpriv->caps & USBFS_CAP_BULK_SCATTER_GATHER) {
1805 /* Good! Just submit everything in one go */
1806 bulk_buffer_len = transfer->length ? transfer->length : 1;
1807 use_bulk_continuation = 0;
1808 } else if (dpriv->caps & USBFS_CAP_BULK_CONTINUATION) {
1809 /* Split the transfers and use bulk-continuation to
1810 avoid issues with short-transfers */
1811 bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
1812 use_bulk_continuation = 1;
1813 } else if (dpriv->caps & USBFS_CAP_NO_PACKET_SIZE_LIM) {
1814 /* Don't split, assume the kernel can alloc the buffer
1815 (otherwise the submit will fail with -ENOMEM) */
1816 bulk_buffer_len = transfer->length ? transfer->length : 1;
1817 use_bulk_continuation = 0;
1819 /* Bad, splitting without bulk-continuation, short transfers
1820 which end before the last urb will not work reliable! */
1821 /* Note we don't warn here as this is "normal" on kernels <
1822 2.6.32 and not a problem for most applications */
1823 bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
1824 use_bulk_continuation = 0;
1827 int num_urbs = transfer->length / bulk_buffer_len;
1828 int last_urb_partial = 0;
1830 if (transfer->length == 0) {
1832 } else if ((transfer->length % bulk_buffer_len) > 0) {
1833 last_urb_partial = 1;
1836 usbi_dbg("need %d urbs for new transfer with length %d", num_urbs,
1838 urbs = calloc(num_urbs, sizeof(struct usbfs_urb));
1840 return LIBUSB_ERROR_NO_MEM;
1842 tpriv->num_urbs = num_urbs;
1843 tpriv->num_retired = 0;
1844 tpriv->reap_action = NORMAL;
1845 tpriv->reap_status = LIBUSB_TRANSFER_COMPLETED;
1847 for (i = 0; i < num_urbs; i++) {
1848 struct usbfs_urb *urb = &urbs[i];
1849 urb->usercontext = itransfer;
1850 switch (transfer->type) {
1851 case LIBUSB_TRANSFER_TYPE_BULK:
1852 urb->type = USBFS_URB_TYPE_BULK;
1855 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
1856 urb->type = USBFS_URB_TYPE_BULK;
1857 urb->stream_id = itransfer->stream_id;
1859 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1860 urb->type = USBFS_URB_TYPE_INTERRUPT;
1863 urb->endpoint = transfer->endpoint;
1864 urb->buffer = transfer->buffer + (i * bulk_buffer_len);
1865 /* don't set the short not ok flag for the last URB */
1866 if (use_bulk_continuation && !is_out && (i < num_urbs - 1))
1867 urb->flags = USBFS_URB_SHORT_NOT_OK;
1868 if (i == num_urbs - 1 && last_urb_partial)
1869 urb->buffer_length = transfer->length % bulk_buffer_len;
1870 else if (transfer->length == 0)
1871 urb->buffer_length = 0;
1873 urb->buffer_length = bulk_buffer_len;
1875 if (i > 0 && use_bulk_continuation)
1876 urb->flags |= USBFS_URB_BULK_CONTINUATION;
1878 /* we have already checked that the flag is supported */
1879 if (is_out && i == num_urbs - 1 &&
1880 transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET)
1881 urb->flags |= USBFS_URB_ZERO_PACKET;
1883 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
1885 if (errno == ENODEV) {
1886 r = LIBUSB_ERROR_NO_DEVICE;
1888 usbi_err(TRANSFER_CTX(transfer),
1889 "submiturb failed error %d errno=%d", r, errno);
1890 r = LIBUSB_ERROR_IO;
1893 /* if the first URB submission fails, we can simply free up and
1894 * return failure immediately. */
1896 usbi_dbg("first URB failed, easy peasy");
1902 /* if it's not the first URB that failed, the situation is a bit
1903 * tricky. we may need to discard all previous URBs. there are
1905 * - discarding is asynchronous - discarded urbs will be reaped
1906 * later. the user must not have freed the transfer when the
1907 * discarded URBs are reaped, otherwise libusb will be using
1909 * - the earlier URBs may have completed successfully and we do
1910 * not want to throw away any data.
1911 * - this URB failing may be no error; EREMOTEIO means that
1912 * this transfer simply didn't need all the URBs we submitted
1913 * so, we report that the transfer was submitted successfully and
1914 * in case of error we discard all previous URBs. later when
1915 * the final reap completes we can report error to the user,
1916 * or success if an earlier URB was completed successfully.
1918 tpriv->reap_action = EREMOTEIO == errno ? COMPLETED_EARLY : SUBMIT_FAILED;
1920 /* The URBs we haven't submitted yet we count as already
1922 tpriv->num_retired += num_urbs - i;
1924 /* If we completed short then don't try to discard. */
1925 if (COMPLETED_EARLY == tpriv->reap_action)
1928 discard_urbs(itransfer, 0, i);
1930 usbi_dbg("reporting successful submission but waiting for %d "
1931 "discards before reporting error", i);
1939 static int submit_iso_transfer(struct usbi_transfer *itransfer)
1941 struct libusb_transfer *transfer =
1942 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1943 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1944 struct linux_device_handle_priv *dpriv =
1945 _device_handle_priv(transfer->dev_handle);
1946 struct usbfs_urb **urbs;
1948 int num_packets = transfer->num_iso_packets;
1950 int this_urb_len = 0;
1952 int packet_offset = 0;
1953 unsigned int packet_len;
1954 unsigned char *urb_buffer = transfer->buffer;
1956 /* usbfs places arbitrary limits on iso URBs. this limit has changed
1957 * at least three times, and it's difficult to accurately detect which
1958 * limit this running kernel might impose. so we attempt to submit
1959 * whatever the user has provided. if the kernel rejects the request
1960 * due to its size, we return an error indicating such to the user.
1963 /* calculate how many URBs we need */
1964 for (i = 0; i < num_packets; i++) {
1965 unsigned int space_remaining = MAX_ISO_BUFFER_LENGTH - this_urb_len;
1966 packet_len = transfer->iso_packet_desc[i].length;
1968 if (packet_len > space_remaining) {
1970 this_urb_len = packet_len;
1971 /* check that we can actually support this packet length */
1972 if (this_urb_len > MAX_ISO_BUFFER_LENGTH)
1973 return LIBUSB_ERROR_INVALID_PARAM;
1975 this_urb_len += packet_len;
1978 usbi_dbg("need %d %dk URBs for transfer", num_urbs, MAX_ISO_BUFFER_LENGTH / 1024);
1980 urbs = calloc(num_urbs, sizeof(*urbs));
1982 return LIBUSB_ERROR_NO_MEM;
1984 tpriv->iso_urbs = urbs;
1985 tpriv->num_urbs = num_urbs;
1986 tpriv->num_retired = 0;
1987 tpriv->reap_action = NORMAL;
1988 tpriv->iso_packet_offset = 0;
1990 /* allocate + initialize each URB with the correct number of packets */
1991 for (i = 0; i < num_urbs; i++) {
1992 struct usbfs_urb *urb;
1993 unsigned int space_remaining_in_urb = MAX_ISO_BUFFER_LENGTH;
1994 int urb_packet_offset = 0;
1995 unsigned char *urb_buffer_orig = urb_buffer;
1999 /* swallow up all the packets we can fit into this URB */
2000 while (packet_offset < transfer->num_iso_packets) {
2001 packet_len = transfer->iso_packet_desc[packet_offset].length;
2002 if (packet_len <= space_remaining_in_urb) {
2004 urb_packet_offset++;
2006 space_remaining_in_urb -= packet_len;
2007 urb_buffer += packet_len;
2009 /* it can't fit, save it for the next URB */
2014 alloc_size = sizeof(*urb)
2015 + (urb_packet_offset * sizeof(struct usbfs_iso_packet_desc));
2016 urb = calloc(1, alloc_size);
2018 free_iso_urbs(tpriv);
2019 return LIBUSB_ERROR_NO_MEM;
2023 /* populate packet lengths */
2024 for (j = 0, k = packet_offset - urb_packet_offset;
2025 k < packet_offset; k++, j++) {
2026 packet_len = transfer->iso_packet_desc[k].length;
2027 urb->iso_frame_desc[j].length = packet_len;
2030 urb->usercontext = itransfer;
2031 urb->type = USBFS_URB_TYPE_ISO;
2032 /* FIXME: interface for non-ASAP data? */
2033 urb->flags = USBFS_URB_ISO_ASAP;
2034 urb->endpoint = transfer->endpoint;
2035 urb->number_of_packets = urb_packet_offset;
2036 urb->buffer = urb_buffer_orig;
2040 for (i = 0; i < num_urbs; i++) {
2041 int r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urbs[i]);
2043 if (errno == ENODEV) {
2044 r = LIBUSB_ERROR_NO_DEVICE;
2045 } else if (errno == EINVAL) {
2046 usbi_warn(TRANSFER_CTX(transfer),
2047 "submiturb failed, transfer too large");
2048 r = LIBUSB_ERROR_INVALID_PARAM;
2050 usbi_err(TRANSFER_CTX(transfer),
2051 "submiturb failed error %d errno=%d", r, errno);
2052 r = LIBUSB_ERROR_IO;
2055 /* if the first URB submission fails, we can simply free up and
2056 * return failure immediately. */
2058 usbi_dbg("first URB failed, easy peasy");
2059 free_iso_urbs(tpriv);
2063 /* if it's not the first URB that failed, the situation is a bit
2064 * tricky. we must discard all previous URBs. there are
2066 * - discarding is asynchronous - discarded urbs will be reaped
2067 * later. the user must not have freed the transfer when the
2068 * discarded URBs are reaped, otherwise libusb will be using
2070 * - the earlier URBs may have completed successfully and we do
2071 * not want to throw away any data.
2072 * so, in this case we discard all the previous URBs BUT we report
2073 * that the transfer was submitted successfully. then later when
2074 * the final discard completes we can report error to the user.
2076 tpriv->reap_action = SUBMIT_FAILED;
2078 /* The URBs we haven't submitted yet we count as already
2080 tpriv->num_retired = num_urbs - i;
2081 discard_urbs(itransfer, 0, i);
2083 usbi_dbg("reporting successful submission but waiting for %d "
2084 "discards before reporting error", i);
2092 static int submit_control_transfer(struct usbi_transfer *itransfer)
2094 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2095 struct libusb_transfer *transfer =
2096 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2097 struct linux_device_handle_priv *dpriv =
2098 _device_handle_priv(transfer->dev_handle);
2099 struct usbfs_urb *urb;
2102 if (transfer->length - LIBUSB_CONTROL_SETUP_SIZE > MAX_CTRL_BUFFER_LENGTH)
2103 return LIBUSB_ERROR_INVALID_PARAM;
2105 urb = calloc(1, sizeof(struct usbfs_urb));
2107 return LIBUSB_ERROR_NO_MEM;
2109 tpriv->num_urbs = 1;
2110 tpriv->reap_action = NORMAL;
2112 urb->usercontext = itransfer;
2113 urb->type = USBFS_URB_TYPE_CONTROL;
2114 urb->endpoint = transfer->endpoint;
2115 urb->buffer = transfer->buffer;
2116 urb->buffer_length = transfer->length;
2118 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
2122 if (errno == ENODEV)
2123 return LIBUSB_ERROR_NO_DEVICE;
2125 usbi_err(TRANSFER_CTX(transfer),
2126 "submiturb failed error %d errno=%d", r, errno);
2127 return LIBUSB_ERROR_IO;
2132 static int op_submit_transfer(struct usbi_transfer *itransfer)
2134 struct libusb_transfer *transfer =
2135 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2137 switch (transfer->type) {
2138 case LIBUSB_TRANSFER_TYPE_CONTROL:
2139 return submit_control_transfer(itransfer);
2140 case LIBUSB_TRANSFER_TYPE_BULK:
2141 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2142 return submit_bulk_transfer(itransfer);
2143 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2144 return submit_bulk_transfer(itransfer);
2145 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2146 return submit_iso_transfer(itransfer);
2148 usbi_err(TRANSFER_CTX(transfer),
2149 "unknown endpoint type %d", transfer->type);
2150 return LIBUSB_ERROR_INVALID_PARAM;
2154 static int op_cancel_transfer(struct usbi_transfer *itransfer)
2156 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2157 struct libusb_transfer *transfer =
2158 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2162 return LIBUSB_ERROR_NOT_FOUND;
2164 r = discard_urbs(itransfer, 0, tpriv->num_urbs);
2168 switch (transfer->type) {
2169 case LIBUSB_TRANSFER_TYPE_BULK:
2170 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2171 if (tpriv->reap_action == ERROR)
2173 /* else, fall through */
2175 tpriv->reap_action = CANCELLED;
2181 static void op_clear_transfer_priv(struct usbi_transfer *itransfer)
2183 struct libusb_transfer *transfer =
2184 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2185 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2187 /* urbs can be freed also in submit_transfer so lock mutex first */
2188 switch (transfer->type) {
2189 case LIBUSB_TRANSFER_TYPE_CONTROL:
2190 case LIBUSB_TRANSFER_TYPE_BULK:
2191 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2192 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2198 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2199 if (tpriv->iso_urbs) {
2200 free_iso_urbs(tpriv);
2201 tpriv->iso_urbs = NULL;
2205 usbi_err(TRANSFER_CTX(transfer),
2206 "unknown endpoint type %d", transfer->type);
2210 static int handle_bulk_completion(struct usbi_transfer *itransfer,
2211 struct usbfs_urb *urb)
2213 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2214 struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2215 int urb_idx = urb - tpriv->urbs;
2217 usbi_mutex_lock(&itransfer->lock);
2218 usbi_dbg("handling completion status %d of bulk urb %d/%d", urb->status,
2219 urb_idx + 1, tpriv->num_urbs);
2221 tpriv->num_retired++;
2223 if (tpriv->reap_action != NORMAL) {
2224 /* cancelled, submit_fail, or completed early */
2225 usbi_dbg("abnormal reap: urb status %d", urb->status);
2227 /* even though we're in the process of cancelling, it's possible that
2228 * we may receive some data in these URBs that we don't want to lose.
2230 * 1. while the kernel is cancelling all the packets that make up an
2231 * URB, a few of them might complete. so we get back a successful
2232 * cancellation *and* some data.
2233 * 2. we receive a short URB which marks the early completion condition,
2234 * so we start cancelling the remaining URBs. however, we're too
2235 * slow and another URB completes (or at least completes partially).
2236 * (this can't happen since we always use BULK_CONTINUATION.)
2238 * When this happens, our objectives are not to lose any "surplus" data,
2239 * and also to stick it at the end of the previously-received data
2240 * (closing any holes), so that libusb reports the total amount of
2241 * transferred data and presents it in a contiguous chunk.
2243 if (urb->actual_length > 0) {
2244 unsigned char *target = transfer->buffer + itransfer->transferred;
2245 usbi_dbg("received %d bytes of surplus data", urb->actual_length);
2246 if (urb->buffer != target) {
2247 usbi_dbg("moving surplus data from offset %d to offset %d",
2248 (unsigned char *) urb->buffer - transfer->buffer,
2249 target - transfer->buffer);
2250 memmove(target, urb->buffer, urb->actual_length);
2252 itransfer->transferred += urb->actual_length;
2255 if (tpriv->num_retired == tpriv->num_urbs) {
2256 usbi_dbg("abnormal reap: last URB handled, reporting");
2257 if (tpriv->reap_action != COMPLETED_EARLY &&
2258 tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2259 tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
2265 itransfer->transferred += urb->actual_length;
2267 /* Many of these errors can occur on *any* urb of a multi-urb
2268 * transfer. When they do, we tear down the rest of the transfer.
2270 switch (urb->status) {
2273 case -EREMOTEIO: /* short transfer */
2275 case -ENOENT: /* cancelled */
2280 usbi_dbg("device removed");
2281 tpriv->reap_status = LIBUSB_TRANSFER_NO_DEVICE;
2282 goto cancel_remaining;
2284 usbi_dbg("detected endpoint stall");
2285 if (tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2286 tpriv->reap_status = LIBUSB_TRANSFER_STALL;
2287 goto cancel_remaining;
2289 /* overflow can only ever occur in the last urb */
2290 usbi_dbg("overflow, actual_length=%d", urb->actual_length);
2291 if (tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2292 tpriv->reap_status = LIBUSB_TRANSFER_OVERFLOW;
2299 usbi_dbg("low level error %d", urb->status);
2300 tpriv->reap_action = ERROR;
2301 goto cancel_remaining;
2303 usbi_warn(ITRANSFER_CTX(itransfer),
2304 "unrecognised urb status %d", urb->status);
2305 tpriv->reap_action = ERROR;
2306 goto cancel_remaining;
2309 /* if we're the last urb or we got less data than requested then we're
2311 if (urb_idx == tpriv->num_urbs - 1) {
2312 usbi_dbg("last URB in transfer --> complete!");
2314 } else if (urb->actual_length < urb->buffer_length) {
2315 usbi_dbg("short transfer %d/%d --> complete!",
2316 urb->actual_length, urb->buffer_length);
2317 if (tpriv->reap_action == NORMAL)
2318 tpriv->reap_action = COMPLETED_EARLY;
2323 if (ERROR == tpriv->reap_action && LIBUSB_TRANSFER_COMPLETED == tpriv->reap_status)
2324 tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
2326 if (tpriv->num_retired == tpriv->num_urbs) /* nothing to cancel */
2329 /* cancel remaining urbs and wait for their completion before
2330 * reporting results */
2331 discard_urbs(itransfer, urb_idx + 1, tpriv->num_urbs);
2334 usbi_mutex_unlock(&itransfer->lock);
2340 usbi_mutex_unlock(&itransfer->lock);
2341 return CANCELLED == tpriv->reap_action ?
2342 usbi_handle_transfer_cancellation(itransfer) :
2343 usbi_handle_transfer_completion(itransfer, tpriv->reap_status);
2346 static int handle_iso_completion(struct usbi_transfer *itransfer,
2347 struct usbfs_urb *urb)
2349 struct libusb_transfer *transfer =
2350 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2351 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2352 int num_urbs = tpriv->num_urbs;
2355 enum libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
2357 usbi_mutex_lock(&itransfer->lock);
2358 for (i = 0; i < num_urbs; i++) {
2359 if (urb == tpriv->iso_urbs[i]) {
2365 usbi_err(TRANSFER_CTX(transfer), "could not locate urb!");
2366 usbi_mutex_unlock(&itransfer->lock);
2367 return LIBUSB_ERROR_NOT_FOUND;
2370 usbi_dbg("handling completion status %d of iso urb %d/%d", urb->status,
2373 /* copy isochronous results back in */
2375 for (i = 0; i < urb->number_of_packets; i++) {
2376 struct usbfs_iso_packet_desc *urb_desc = &urb->iso_frame_desc[i];
2377 struct libusb_iso_packet_descriptor *lib_desc =
2378 &transfer->iso_packet_desc[tpriv->iso_packet_offset++];
2379 lib_desc->status = LIBUSB_TRANSFER_COMPLETED;
2380 switch (urb_desc->status) {
2383 case -ENOENT: /* cancelled */
2388 usbi_dbg("device removed");
2389 lib_desc->status = LIBUSB_TRANSFER_NO_DEVICE;
2392 usbi_dbg("detected endpoint stall");
2393 lib_desc->status = LIBUSB_TRANSFER_STALL;
2396 usbi_dbg("overflow error");
2397 lib_desc->status = LIBUSB_TRANSFER_OVERFLOW;
2405 usbi_dbg("low-level USB error %d", urb_desc->status);
2406 lib_desc->status = LIBUSB_TRANSFER_ERROR;
2409 usbi_warn(TRANSFER_CTX(transfer),
2410 "unrecognised urb status %d", urb_desc->status);
2411 lib_desc->status = LIBUSB_TRANSFER_ERROR;
2414 lib_desc->actual_length = urb_desc->actual_length;
2417 tpriv->num_retired++;
2419 if (tpriv->reap_action != NORMAL) { /* cancelled or submit_fail */
2420 usbi_dbg("CANCEL: urb status %d", urb->status);
2422 if (tpriv->num_retired == num_urbs) {
2423 usbi_dbg("CANCEL: last URB handled, reporting");
2424 free_iso_urbs(tpriv);
2425 if (tpriv->reap_action == CANCELLED) {
2426 usbi_mutex_unlock(&itransfer->lock);
2427 return usbi_handle_transfer_cancellation(itransfer);
2429 usbi_mutex_unlock(&itransfer->lock);
2430 return usbi_handle_transfer_completion(itransfer,
2431 LIBUSB_TRANSFER_ERROR);
2437 switch (urb->status) {
2440 case -ENOENT: /* cancelled */
2444 usbi_dbg("device removed");
2445 status = LIBUSB_TRANSFER_NO_DEVICE;
2448 usbi_warn(TRANSFER_CTX(transfer),
2449 "unrecognised urb status %d", urb->status);
2450 status = LIBUSB_TRANSFER_ERROR;
2454 /* if we're the last urb then we're done */
2455 if (urb_idx == num_urbs) {
2456 usbi_dbg("last URB in transfer --> complete!");
2457 free_iso_urbs(tpriv);
2458 usbi_mutex_unlock(&itransfer->lock);
2459 return usbi_handle_transfer_completion(itransfer, status);
2463 usbi_mutex_unlock(&itransfer->lock);
2467 static int handle_control_completion(struct usbi_transfer *itransfer,
2468 struct usbfs_urb *urb)
2470 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2473 usbi_mutex_lock(&itransfer->lock);
2474 usbi_dbg("handling completion status %d", urb->status);
2476 itransfer->transferred += urb->actual_length;
2478 if (tpriv->reap_action == CANCELLED) {
2479 if (urb->status != 0 && urb->status != -ENOENT)
2480 usbi_warn(ITRANSFER_CTX(itransfer),
2481 "cancel: unrecognised urb status %d", urb->status);
2484 usbi_mutex_unlock(&itransfer->lock);
2485 return usbi_handle_transfer_cancellation(itransfer);
2488 switch (urb->status) {
2490 status = LIBUSB_TRANSFER_COMPLETED;
2492 case -ENOENT: /* cancelled */
2493 status = LIBUSB_TRANSFER_CANCELLED;
2497 usbi_dbg("device removed");
2498 status = LIBUSB_TRANSFER_NO_DEVICE;
2501 usbi_dbg("unsupported control request");
2502 status = LIBUSB_TRANSFER_STALL;
2505 usbi_dbg("control overflow error");
2506 status = LIBUSB_TRANSFER_OVERFLOW;
2513 usbi_dbg("low-level bus error occurred");
2514 status = LIBUSB_TRANSFER_ERROR;
2517 usbi_warn(ITRANSFER_CTX(itransfer),
2518 "unrecognised urb status %d", urb->status);
2519 status = LIBUSB_TRANSFER_ERROR;
2525 usbi_mutex_unlock(&itransfer->lock);
2526 return usbi_handle_transfer_completion(itransfer, status);
2529 static int reap_for_handle(struct libusb_device_handle *handle)
2531 struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
2533 struct usbfs_urb *urb;
2534 struct usbi_transfer *itransfer;
2535 struct libusb_transfer *transfer;
2537 r = ioctl(hpriv->fd, IOCTL_USBFS_REAPURBNDELAY, &urb);
2538 if (r == -1 && errno == EAGAIN)
2541 if (errno == ENODEV)
2542 return LIBUSB_ERROR_NO_DEVICE;
2544 usbi_err(HANDLE_CTX(handle), "reap failed error %d errno=%d",
2546 return LIBUSB_ERROR_IO;
2549 itransfer = urb->usercontext;
2550 transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2552 usbi_dbg("urb type=%d status=%d transferred=%d", urb->type, urb->status,
2553 urb->actual_length);
2555 switch (transfer->type) {
2556 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2557 return handle_iso_completion(itransfer, urb);
2558 case LIBUSB_TRANSFER_TYPE_BULK:
2559 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2560 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2561 return handle_bulk_completion(itransfer, urb);
2562 case LIBUSB_TRANSFER_TYPE_CONTROL:
2563 return handle_control_completion(itransfer, urb);
2565 usbi_err(HANDLE_CTX(handle), "unrecognised endpoint type %x",
2567 return LIBUSB_ERROR_OTHER;
2571 static int op_handle_events(struct libusb_context *ctx,
2572 struct pollfd *fds, POLL_NFDS_TYPE nfds, int num_ready)
2577 usbi_mutex_lock(&ctx->open_devs_lock);
2578 for (i = 0; i < nfds && num_ready > 0; i++) {
2579 struct pollfd *pollfd = &fds[i];
2580 struct libusb_device_handle *handle;
2581 struct linux_device_handle_priv *hpriv = NULL;
2583 if (!pollfd->revents)
2587 list_for_each_entry(handle, &ctx->open_devs, list, struct libusb_device_handle) {
2588 hpriv = _device_handle_priv(handle);
2589 if (hpriv->fd == pollfd->fd)
2593 if (!hpriv || hpriv->fd != pollfd->fd) {
2594 usbi_err(ctx, "cannot find handle for fd %d",
2599 if (pollfd->revents & POLLERR) {
2600 /* remove the fd from the pollfd set so that it doesn't continuously
2601 * trigger an event, and flag that it has been removed so op_close()
2602 * doesn't try to remove it a second time */
2603 usbi_remove_pollfd(HANDLE_CTX(handle), hpriv->fd);
2604 hpriv->fd_removed = 1;
2606 /* device will still be marked as attached if hotplug monitor thread
2607 * hasn't processed remove event yet */
2608 usbi_mutex_static_lock(&linux_hotplug_lock);
2609 if (handle->dev->attached)
2610 linux_device_disconnected(handle->dev->bus_number,
2611 handle->dev->device_address);
2612 usbi_mutex_static_unlock(&linux_hotplug_lock);
2614 if (!(hpriv->caps & USBFS_CAP_REAP_AFTER_DISCONNECT)) {
2615 usbi_handle_disconnect(handle);
2621 r = reap_for_handle(handle);
2623 if (r == 1 || r == LIBUSB_ERROR_NO_DEVICE)
2631 usbi_mutex_unlock(&ctx->open_devs_lock);
2635 static int op_clock_gettime(int clk_id, struct timespec *tp)
2638 case USBI_CLOCK_MONOTONIC:
2639 return clock_gettime(monotonic_clkid, tp);
2640 case USBI_CLOCK_REALTIME:
2641 return clock_gettime(CLOCK_REALTIME, tp);
2643 return LIBUSB_ERROR_INVALID_PARAM;
2647 #ifdef USBI_TIMERFD_AVAILABLE
2648 static clockid_t op_get_timerfd_clockid(void)
2650 return monotonic_clkid;
2655 const struct usbi_os_backend linux_usbfs_backend = {
2656 .name = "Linux usbfs",
2657 .caps = USBI_CAP_HAS_HID_ACCESS|USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER,
2660 .get_device_list = NULL,
2661 .hotplug_poll = op_hotplug_poll,
2662 .get_device_descriptor = op_get_device_descriptor,
2663 .get_active_config_descriptor = op_get_active_config_descriptor,
2664 .get_config_descriptor = op_get_config_descriptor,
2665 .get_config_descriptor_by_value = op_get_config_descriptor_by_value,
2669 .get_configuration = op_get_configuration,
2670 .set_configuration = op_set_configuration,
2671 .claim_interface = op_claim_interface,
2672 .release_interface = op_release_interface,
2674 .set_interface_altsetting = op_set_interface,
2675 .clear_halt = op_clear_halt,
2676 .reset_device = op_reset_device,
2678 .alloc_streams = op_alloc_streams,
2679 .free_streams = op_free_streams,
2681 .kernel_driver_active = op_kernel_driver_active,
2682 .detach_kernel_driver = op_detach_kernel_driver,
2683 .attach_kernel_driver = op_attach_kernel_driver,
2685 .destroy_device = op_destroy_device,
2687 .submit_transfer = op_submit_transfer,
2688 .cancel_transfer = op_cancel_transfer,
2689 .clear_transfer_priv = op_clear_transfer_priv,
2691 .handle_events = op_handle_events,
2693 .clock_gettime = op_clock_gettime,
2695 #ifdef USBI_TIMERFD_AVAILABLE
2696 .get_timerfd_clockid = op_get_timerfd_clockid,
2699 .device_priv_size = sizeof(struct linux_device_priv),
2700 .device_handle_priv_size = sizeof(struct linux_device_handle_priv),
2701 .transfer_priv_size = sizeof(struct linux_transfer_priv),