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>
43 #include "linux_usbfs.h"
46 * opening a usbfs node causes the device to be resumed, so we attempt to
47 * avoid this during enumeration.
49 * sysfs allows us to read the kernel's in-memory copies of device descriptors
50 * and so forth, avoiding the need to open the device:
51 * - The binary "descriptors" file contains all config descriptors since
52 * 2.6.26, commit 217a9081d8e69026186067711131b77f0ce219ed
53 * - The binary "descriptors" file was added in 2.6.23, commit
54 * 69d42a78f935d19384d1f6e4f94b65bb162b36df, but it only contains the
55 * active config descriptors
56 * - The "busnum" file was added in 2.6.22, commit
57 * 83f7d958eab2fbc6b159ee92bf1493924e1d0f72
58 * - The "devnum" file has been present since pre-2.6.18
59 * - the "bConfigurationValue" file has been present since pre-2.6.18
61 * If we have bConfigurationValue, busnum, and devnum, then we can determine
62 * the active configuration without having to open the usbfs node in RDWR mode.
63 * The busnum file is important as that is the only way we can relate sysfs
64 * devices to usbfs nodes.
66 * If we also have all descriptors, we can obtain the device descriptor and
67 * configuration without touching usbfs at all.
70 /* endianness for multi-byte fields:
72 * Descriptors exposed by usbfs have the multi-byte fields in the device
73 * descriptor as host endian. Multi-byte fields in the other descriptors are
74 * bus-endian. The kernel documentation says otherwise, but it is wrong.
76 * In sysfs all descriptors are bus-endian.
79 static const char *usbfs_path = NULL;
81 /* use usbdev*.* device names in /dev instead of the usbfs bus directories */
82 static int usbdev_names = 0;
84 /* Linux 2.6.32 adds support for a bulk continuation URB flag. this basically
85 * allows us to mark URBs as being part of a specific logical transfer when
86 * we submit them to the kernel. then, on any error except a cancellation, all
87 * URBs within that transfer will be cancelled and no more URBs will be
88 * accepted for the transfer, meaning that no more data can creep in.
90 * The BULK_CONTINUATION flag must be set on all URBs within a bulk transfer
91 * (in either direction) except the first.
92 * For IN transfers, we must also set SHORT_NOT_OK on all URBs except the
93 * last; it means that the kernel should treat a short reply as an error.
94 * For OUT transfers, SHORT_NOT_OK must not be set. it isn't needed (OUT
95 * transfers can't be short unless there's already some sort of error), and
96 * setting this flag is disallowed (a kernel with USB debugging enabled will
99 static int supports_flag_bulk_continuation = -1;
101 /* Linux 2.6.31 fixes support for the zero length packet URB flag. This
102 * allows us to mark URBs that should be followed by a zero length data
103 * packet, which can be required by device- or class-specific protocols.
105 static int supports_flag_zero_packet = -1;
107 /* clock ID for monotonic clock, as not all clock sources are available on all
108 * systems. appropriate choice made at initialization time. */
109 static clockid_t monotonic_clkid = -1;
111 /* Linux 2.6.22 (commit 83f7d958eab2fbc6b159ee92bf1493924e1d0f72) adds a busnum
112 * to sysfs, so we can relate devices. This also implies that we can read
113 * the active configuration through bConfigurationValue */
114 static int sysfs_can_relate_devices = -1;
116 /* Linux 2.6.26 (commit 217a9081d8e69026186067711131b77f0ce219ed) adds all
117 * config descriptors (rather then just the active config) to the sysfs
118 * descriptors file, so from then on we can use them. */
119 static int sysfs_has_descriptors = -1;
121 /* how many times have we initted (and not exited) ? */
122 static int init_count = 0;
124 /* Serialize hotplug start/stop */
125 usbi_mutex_static_t linux_hotplug_startstop_lock = USBI_MUTEX_INITIALIZER;
126 /* Serialize scan-devices, event-thread, and poll */
127 usbi_mutex_static_t linux_hotplug_lock = USBI_MUTEX_INITIALIZER;
129 static int linux_start_event_monitor(void);
130 static int linux_stop_event_monitor(void);
131 static int linux_scan_devices(struct libusb_context *ctx);
132 static int sysfs_scan_device(struct libusb_context *ctx, const char *devname);
133 static int detach_kernel_driver_and_claim(struct libusb_device_handle *, int);
135 #if !defined(USE_UDEV)
136 static int linux_default_scan_devices (struct libusb_context *ctx);
139 struct linux_device_priv {
141 unsigned char *descriptors;
143 int active_config; /* cache val for !sysfs_can_relate_devices */
146 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\n", delay/1000);
204 /* Wait 10ms for USB device path creation.*/
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 */
312 usbi_dbg("found usbfs at %s", ret);
317 /* the monotonic clock is not usable on all systems (e.g. embedded ones often
318 * seem to lack it). fall back to REALTIME if we have to. */
319 static clockid_t find_monotonic_clock(void)
321 #ifdef CLOCK_MONOTONIC
325 /* Linux 2.6.28 adds CLOCK_MONOTONIC_RAW but we don't use it
326 * because it's not available through timerfd */
327 r = clock_gettime(CLOCK_MONOTONIC, &ts);
329 return CLOCK_MONOTONIC;
330 usbi_dbg("monotonic clock doesn't work, errno %d", errno);
333 return CLOCK_REALTIME;
336 static int kernel_version_ge(int major, int minor, int sublevel)
339 int atoms, kmajor, kminor, ksublevel;
343 atoms = sscanf(uts.release, "%d.%d.%d", &kmajor, &kminor, &ksublevel);
352 /* kmajor == major */
354 return 0 == minor && 0 == sublevel;
360 /* kminor == minor */
362 return 0 == sublevel;
364 return ksublevel >= sublevel;
367 static int op_init(struct libusb_context *ctx)
372 usbfs_path = find_usbfs_path();
374 usbi_err(ctx, "could not find usbfs");
375 return LIBUSB_ERROR_OTHER;
378 if (monotonic_clkid == -1)
379 monotonic_clkid = find_monotonic_clock();
381 if (supports_flag_bulk_continuation == -1) {
382 /* bulk continuation URB flag available from Linux 2.6.32 */
383 supports_flag_bulk_continuation = kernel_version_ge(2,6,32);
384 if (supports_flag_bulk_continuation == -1) {
385 usbi_err(ctx, "error checking for bulk continuation support");
386 return LIBUSB_ERROR_OTHER;
390 if (supports_flag_bulk_continuation)
391 usbi_dbg("bulk continuation flag supported");
393 if (-1 == supports_flag_zero_packet) {
394 /* zero length packet URB flag fixed since Linux 2.6.31 */
395 supports_flag_zero_packet = kernel_version_ge(2,6,31);
396 if (-1 == supports_flag_zero_packet) {
397 usbi_err(ctx, "error checking for zero length packet support");
398 return LIBUSB_ERROR_OTHER;
402 if (supports_flag_zero_packet)
403 usbi_dbg("zero length packet flag supported");
405 if (-1 == sysfs_has_descriptors) {
406 /* sysfs descriptors has all descriptors since Linux 2.6.26 */
407 sysfs_has_descriptors = kernel_version_ge(2,6,26);
408 if (-1 == sysfs_has_descriptors) {
409 usbi_err(ctx, "error checking for sysfs descriptors");
410 return LIBUSB_ERROR_OTHER;
414 if (-1 == sysfs_can_relate_devices) {
415 /* sysfs has busnum since Linux 2.6.22 */
416 sysfs_can_relate_devices = kernel_version_ge(2,6,22);
417 if (-1 == sysfs_can_relate_devices) {
418 usbi_err(ctx, "error checking for sysfs busnum");
419 return LIBUSB_ERROR_OTHER;
423 if (sysfs_can_relate_devices || sysfs_has_descriptors) {
424 r = stat(SYSFS_DEVICE_PATH, &statbuf);
425 if (r != 0 || !S_ISDIR(statbuf.st_mode)) {
426 usbi_warn(ctx, "sysfs not mounted");
427 sysfs_can_relate_devices = 0;
428 sysfs_has_descriptors = 0;
432 if (sysfs_can_relate_devices)
433 usbi_dbg("sysfs can relate devices");
435 if (sysfs_has_descriptors)
436 usbi_dbg("sysfs has complete descriptors");
438 usbi_mutex_static_lock(&linux_hotplug_startstop_lock);
440 if (init_count == 0) {
441 /* start up hotplug event handler */
442 r = linux_start_event_monitor();
444 if (r == LIBUSB_SUCCESS) {
445 r = linux_scan_devices(ctx);
446 if (r == LIBUSB_SUCCESS)
448 else if (init_count == 0)
449 linux_stop_event_monitor();
451 usbi_err(ctx, "error starting hotplug event monitor");
452 usbi_mutex_static_unlock(&linux_hotplug_startstop_lock);
457 static void op_exit(void)
459 usbi_mutex_static_lock(&linux_hotplug_startstop_lock);
460 assert(init_count != 0);
462 /* tear down event handler */
463 (void)linux_stop_event_monitor();
465 usbi_mutex_static_unlock(&linux_hotplug_startstop_lock);
468 static int linux_start_event_monitor(void)
470 #if defined(USE_UDEV)
471 return linux_udev_start_event_monitor();
473 return linux_netlink_start_event_monitor();
477 static int linux_stop_event_monitor(void)
479 #if defined(USE_UDEV)
480 return linux_udev_stop_event_monitor();
482 return linux_netlink_stop_event_monitor();
486 static int linux_scan_devices(struct libusb_context *ctx)
490 usbi_mutex_static_lock(&linux_hotplug_lock);
492 #if defined(USE_UDEV)
493 ret = linux_udev_scan_devices(ctx);
495 ret = linux_default_scan_devices(ctx);
498 usbi_mutex_static_unlock(&linux_hotplug_lock);
503 static void op_hotplug_poll(void)
505 #if defined(USE_UDEV)
506 linux_udev_hotplug_poll();
508 linux_netlink_hotplug_poll();
512 static int _open_sysfs_attr(struct libusb_device *dev, const char *attr)
514 struct linux_device_priv *priv = _device_priv(dev);
515 char filename[PATH_MAX];
518 snprintf(filename, PATH_MAX, "%s/%s/%s",
519 SYSFS_DEVICE_PATH, priv->sysfs_dir, attr);
520 fd = open(filename, O_RDONLY);
522 usbi_err(DEVICE_CTX(dev),
523 "open %s failed ret=%d errno=%d", filename, fd, errno);
524 return LIBUSB_ERROR_IO;
530 /* Note only suitable for attributes which always read >= 0, < 0 is error */
531 static int __read_sysfs_attr(struct libusb_context *ctx,
532 const char *devname, const char *attr)
534 char filename[PATH_MAX];
538 snprintf(filename, PATH_MAX, "%s/%s/%s", SYSFS_DEVICE_PATH,
540 f = fopen(filename, "r");
542 if (errno == ENOENT) {
543 /* File doesn't exist. Assume the device has been
544 disconnected (see trac ticket #70). */
545 return LIBUSB_ERROR_NO_DEVICE;
547 usbi_err(ctx, "open %s failed errno=%d", filename, errno);
548 return LIBUSB_ERROR_IO;
551 r = fscanf(f, "%d", &value);
554 usbi_err(ctx, "fscanf %s returned %d, errno=%d", attr, r, errno);
555 return LIBUSB_ERROR_NO_DEVICE; /* For unplug race (trac #70) */
558 usbi_err(ctx, "%s contains a negative value", filename);
559 return LIBUSB_ERROR_IO;
565 static int op_get_device_descriptor(struct libusb_device *dev,
566 unsigned char *buffer, int *host_endian)
568 struct linux_device_priv *priv = _device_priv(dev);
570 *host_endian = sysfs_has_descriptors ? 0 : 1;
571 memcpy(buffer, priv->descriptors, DEVICE_DESC_LENGTH);
576 /* read the bConfigurationValue for a device */
577 static int sysfs_get_active_config(struct libusb_device *dev, int *config)
580 char tmp[5] = {0, 0, 0, 0, 0};
585 fd = _open_sysfs_attr(dev, "bConfigurationValue");
589 r = read(fd, tmp, sizeof(tmp));
592 usbi_err(DEVICE_CTX(dev),
593 "read bConfigurationValue failed ret=%d errno=%d", r, errno);
594 return LIBUSB_ERROR_IO;
596 usbi_dbg("device unconfigured");
601 if (tmp[sizeof(tmp) - 1] != 0) {
602 usbi_err(DEVICE_CTX(dev), "not null-terminated?");
603 return LIBUSB_ERROR_IO;
604 } else if (tmp[0] == 0) {
605 usbi_err(DEVICE_CTX(dev), "no configuration value?");
606 return LIBUSB_ERROR_IO;
609 num = strtol(tmp, &endptr, 10);
611 usbi_err(DEVICE_CTX(dev), "error converting '%s' to integer", tmp);
612 return LIBUSB_ERROR_IO;
619 int linux_get_device_address (struct libusb_context *ctx, int detached,
620 uint8_t *busnum, uint8_t *devaddr,const char *dev_node,
621 const char *sys_name)
625 usbi_dbg("getting address for device: %s detached: %d", sys_name, detached);
626 /* can't use sysfs to read the bus and device number if the
627 * device has been detached */
628 if (!sysfs_can_relate_devices || detached || NULL == sys_name) {
629 if (NULL == dev_node) {
630 return LIBUSB_ERROR_OTHER;
633 /* will this work with all supported kernel versions? */
634 if (!strncmp(dev_node, "/dev/bus/usb", 12)) {
635 sscanf (dev_node, "/dev/bus/usb/%hhd/%hhd", busnum, devaddr);
636 } else if (!strncmp(dev_node, "/proc/bus/usb", 13)) {
637 sscanf (dev_node, "/proc/bus/usb/%hhd/%hhd", busnum, devaddr);
640 return LIBUSB_SUCCESS;
643 usbi_dbg("scan %s", sys_name);
645 sysfs_attr = __read_sysfs_attr(ctx, sys_name, "busnum");
648 if (sysfs_attr > 255)
649 return LIBUSB_ERROR_INVALID_PARAM;
650 *busnum = (uint8_t) sysfs_attr;
652 sysfs_attr = __read_sysfs_attr(ctx, sys_name, "devnum");
655 if (sysfs_attr > 255)
656 return LIBUSB_ERROR_INVALID_PARAM;
658 *devaddr = (uint8_t) sysfs_attr;
660 usbi_dbg("bus=%d dev=%d", *busnum, *devaddr);
662 return LIBUSB_SUCCESS;
665 /* Return offset of the next descriptor with the given type */
666 static int seek_to_next_descriptor(struct libusb_context *ctx,
667 uint8_t descriptor_type, unsigned char *buffer, int size)
669 struct usb_descriptor_header header;
672 for (i = 0; size >= 0; i += header.bLength, size -= header.bLength) {
674 return LIBUSB_ERROR_NOT_FOUND;
677 usbi_err(ctx, "short descriptor read %d/2", size);
678 return LIBUSB_ERROR_IO;
680 usbi_parse_descriptor(buffer + i, "bb", &header, 0);
682 if (i && header.bDescriptorType == descriptor_type)
685 usbi_err(ctx, "bLength overflow by %d bytes", -size);
686 return LIBUSB_ERROR_IO;
689 /* Return offset to next config */
690 static int seek_to_next_config(struct libusb_context *ctx,
691 unsigned char *buffer, int size)
693 struct libusb_config_descriptor config;
696 return LIBUSB_ERROR_NOT_FOUND;
698 if (size < LIBUSB_DT_CONFIG_SIZE) {
699 usbi_err(ctx, "short descriptor read %d/%d",
700 size, LIBUSB_DT_CONFIG_SIZE);
701 return LIBUSB_ERROR_IO;
704 usbi_parse_descriptor(buffer, "bbwbbbbb", &config, 0);
705 if (config.bDescriptorType != LIBUSB_DT_CONFIG) {
706 usbi_err(ctx, "descriptor is not a config desc (type 0x%02x)",
707 config.bDescriptorType);
708 return LIBUSB_ERROR_IO;
712 * In usbfs the config descriptors are config.wTotalLength bytes apart,
713 * with any short reads from the device appearing as holes in the file.
715 * In sysfs wTotalLength is ignored, instead the kernel returns a
716 * config descriptor with verified bLength fields, with descriptors
717 * with an invalid bLength removed.
719 if (sysfs_has_descriptors) {
720 int next = seek_to_next_descriptor(ctx, LIBUSB_DT_CONFIG,
722 if (next == LIBUSB_ERROR_NOT_FOUND)
727 if (next != config.wTotalLength)
728 usbi_warn(ctx, "config length mismatch wTotalLength "
729 "%d real %d", config.wTotalLength, next);
732 if (config.wTotalLength < LIBUSB_DT_CONFIG_SIZE) {
733 usbi_err(ctx, "invalid wTotalLength %d",
734 config.wTotalLength);
735 return LIBUSB_ERROR_IO;
736 } else if (config.wTotalLength > size) {
737 usbi_warn(ctx, "short descriptor read %d/%d",
738 size, config.wTotalLength);
741 return config.wTotalLength;
745 static int op_get_config_descriptor_by_value(struct libusb_device *dev,
746 uint8_t value, unsigned char **buffer, int *host_endian)
748 struct libusb_context *ctx = DEVICE_CTX(dev);
749 struct linux_device_priv *priv = _device_priv(dev);
750 unsigned char *descriptors = priv->descriptors;
751 int size = priv->descriptors_len;
752 struct libusb_config_descriptor *config;
755 /* Unlike the device desc. config descs. are always in raw format */
758 /* Skip device header */
759 descriptors += DEVICE_DESC_LENGTH;
760 size -= DEVICE_DESC_LENGTH;
762 /* Seek till the config is found, or till "EOF" */
764 int next = seek_to_next_config(ctx, descriptors, size);
767 config = (struct libusb_config_descriptor *)descriptors;
768 if (config->bConfigurationValue == value) {
769 *buffer = descriptors;
777 static int op_get_active_config_descriptor(struct libusb_device *dev,
778 unsigned char *buffer, size_t len, int *host_endian)
781 unsigned char *config_desc;
783 if (sysfs_can_relate_devices) {
784 r = sysfs_get_active_config(dev, &config);
788 /* Use cached bConfigurationValue */
789 struct linux_device_priv *priv = _device_priv(dev);
790 config = priv->active_config;
793 return LIBUSB_ERROR_NOT_FOUND;
795 r = op_get_config_descriptor_by_value(dev, config, &config_desc,
801 memcpy(buffer, config_desc, len);
805 static int op_get_config_descriptor(struct libusb_device *dev,
806 uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
808 struct linux_device_priv *priv = _device_priv(dev);
809 unsigned char *descriptors = priv->descriptors;
810 int i, r, size = priv->descriptors_len;
812 /* Unlike the device desc. config descs. are always in raw format */
815 /* Skip device header */
816 descriptors += DEVICE_DESC_LENGTH;
817 size -= DEVICE_DESC_LENGTH;
819 /* Seek till the config is found, or till "EOF" */
821 r = seek_to_next_config(DEVICE_CTX(dev), descriptors, size);
824 if (i == config_index)
831 memcpy(buffer, descriptors, len);
835 /* send a control message to retrieve active configuration */
836 static int usbfs_get_active_config(struct libusb_device *dev, int fd)
838 unsigned char active_config = 0;
841 struct usbfs_ctrltransfer ctrl = {
842 .bmRequestType = LIBUSB_ENDPOINT_IN,
843 .bRequest = LIBUSB_REQUEST_GET_CONFIGURATION,
848 .data = &active_config
851 r = ioctl(fd, IOCTL_USBFS_CONTROL, &ctrl);
854 return LIBUSB_ERROR_NO_DEVICE;
856 /* we hit this error path frequently with buggy devices :( */
857 usbi_warn(DEVICE_CTX(dev),
858 "get_configuration failed ret=%d errno=%d", r, errno);
859 return LIBUSB_ERROR_IO;
862 return active_config;
865 static int initialize_device(struct libusb_device *dev, uint8_t busnum,
866 uint8_t devaddr, const char *sysfs_dir)
868 struct linux_device_priv *priv = _device_priv(dev);
869 struct libusb_context *ctx = DEVICE_CTX(dev);
870 int descriptors_size = 512; /* Begin with a 1024 byte alloc */
874 dev->bus_number = busnum;
875 dev->device_address = devaddr;
878 priv->sysfs_dir = malloc(strlen(sysfs_dir) + 1);
879 if (!priv->sysfs_dir)
880 return LIBUSB_ERROR_NO_MEM;
881 strcpy(priv->sysfs_dir, sysfs_dir);
883 /* Note speed can contain 1.5, in this case __read_sysfs_attr
884 will stop parsing at the '.' and return 1 */
885 speed = __read_sysfs_attr(DEVICE_CTX(dev), sysfs_dir, "speed");
888 case 1: dev->speed = LIBUSB_SPEED_LOW; break;
889 case 12: dev->speed = LIBUSB_SPEED_FULL; break;
890 case 480: dev->speed = LIBUSB_SPEED_HIGH; break;
891 case 5000: dev->speed = LIBUSB_SPEED_SUPER; break;
893 usbi_warn(DEVICE_CTX(dev), "Unknown device speed: %d Mbps", speed);
898 /* cache descriptors in memory */
899 if (sysfs_has_descriptors)
900 fd = _open_sysfs_attr(dev, "descriptors");
902 fd = _get_usbfs_fd(dev, O_RDONLY, 0);
907 descriptors_size *= 2;
908 priv->descriptors = usbi_reallocf(priv->descriptors,
910 if (!priv->descriptors) {
912 return LIBUSB_ERROR_NO_MEM;
914 /* usbfs has holes in the file */
915 if (!sysfs_has_descriptors) {
916 memset(priv->descriptors + priv->descriptors_len,
917 0, descriptors_size - priv->descriptors_len);
919 r = read(fd, priv->descriptors + priv->descriptors_len,
920 descriptors_size - priv->descriptors_len);
922 usbi_err(ctx, "read descriptor failed ret=%d errno=%d",
925 return LIBUSB_ERROR_IO;
927 priv->descriptors_len += r;
928 } while (priv->descriptors_len == descriptors_size);
932 if (priv->descriptors_len < DEVICE_DESC_LENGTH) {
933 usbi_err(ctx, "short descriptor read (%d)",
934 priv->descriptors_len);
935 return LIBUSB_ERROR_IO;
938 if (sysfs_can_relate_devices)
939 return LIBUSB_SUCCESS;
941 /* cache active config */
942 fd = _get_usbfs_fd(dev, O_RDWR, 1);
944 /* cannot send a control message to determine the active
945 * config. just assume the first one is active. */
946 usbi_warn(ctx, "Missing rw usbfs access; cannot determine "
947 "active configuration descriptor");
948 if (priv->descriptors_len >=
949 (DEVICE_DESC_LENGTH + LIBUSB_DT_CONFIG_SIZE)) {
950 struct libusb_config_descriptor config;
951 usbi_parse_descriptor(
952 priv->descriptors + DEVICE_DESC_LENGTH,
953 "bbwbbbbb", &config, 0);
954 priv->active_config = config.bConfigurationValue;
956 priv->active_config = -1; /* No config dt */
958 return LIBUSB_SUCCESS;
961 r = usbfs_get_active_config(dev, fd);
963 priv->active_config = r;
966 /* some buggy devices have a configuration 0, but we're
967 * reaching into the corner of a corner case here, so let's
968 * not support buggy devices in these circumstances.
969 * stick to the specs: a configuration value of 0 means
971 usbi_dbg("active cfg 0? assuming unconfigured device");
972 priv->active_config = -1;
974 } else if (r == LIBUSB_ERROR_IO) {
975 /* buggy devices sometimes fail to report their active config.
976 * assume unconfigured and continue the probing */
977 usbi_warn(ctx, "couldn't query active configuration, assuming"
979 priv->active_config = -1;
981 } /* else r < 0, just return the error code */
987 static int linux_get_parent_info(struct libusb_device *dev, const char *sysfs_dir)
989 struct libusb_context *ctx = DEVICE_CTX(dev);
990 struct libusb_device *it;
991 char *parent_sysfs_dir, *tmp;
992 int ret, add_parent = 1;
994 /* XXX -- can we figure out the topology when using usbfs? */
995 if (NULL == sysfs_dir || 0 == strncmp(sysfs_dir, "usb", 3)) {
996 /* either using usbfs or finding the parent of a root hub */
997 return LIBUSB_SUCCESS;
1000 parent_sysfs_dir = strdup(sysfs_dir);
1001 if (NULL != (tmp = strrchr(parent_sysfs_dir, '.')) ||
1002 NULL != (tmp = strrchr(parent_sysfs_dir, '-'))) {
1003 dev->port_number = atoi(tmp + 1);
1006 usbi_warn(ctx, "Can not parse sysfs_dir: %s, no parent info",
1008 free (parent_sysfs_dir);
1009 return LIBUSB_SUCCESS;
1012 /* is the parent a root hub? */
1013 if (NULL == strchr(parent_sysfs_dir, '-')) {
1014 tmp = parent_sysfs_dir;
1015 ret = asprintf (&parent_sysfs_dir, "usb%s", tmp);
1018 return LIBUSB_ERROR_NO_MEM;
1023 /* find the parent in the context */
1024 usbi_mutex_lock(&ctx->usb_devs_lock);
1025 list_for_each_entry(it, &ctx->usb_devs, list, struct libusb_device) {
1026 struct linux_device_priv *priv = _device_priv(it);
1027 if (0 == strcmp (priv->sysfs_dir, parent_sysfs_dir)) {
1028 dev->parent_dev = libusb_ref_device(it);
1032 usbi_mutex_unlock(&ctx->usb_devs_lock);
1034 if (!dev->parent_dev && add_parent) {
1035 usbi_dbg("parent_dev %s not enumerated yet, enumerating now",
1037 sysfs_scan_device(ctx, parent_sysfs_dir);
1042 usbi_dbg("Dev %p (%s) has parent %p (%s) port %d", dev, sysfs_dir,
1043 dev->parent_dev, parent_sysfs_dir, dev->port_number);
1045 free (parent_sysfs_dir);
1047 return LIBUSB_SUCCESS;
1050 int linux_enumerate_device(struct libusb_context *ctx,
1051 uint8_t busnum, uint8_t devaddr, const char *sysfs_dir)
1053 unsigned long session_id;
1054 struct libusb_device *dev;
1057 /* FIXME: session ID is not guaranteed unique as addresses can wrap and
1058 * will be reused. instead we should add a simple sysfs attribute with
1060 session_id = busnum << 8 | devaddr;
1061 usbi_dbg("busnum %d devaddr %d session_id %ld", busnum, devaddr,
1064 dev = usbi_get_device_by_session_id(ctx, session_id);
1066 /* device already exists in the context */
1067 usbi_dbg("session_id %ld already exists", session_id);
1068 libusb_unref_device(dev);
1069 return LIBUSB_SUCCESS;
1072 usbi_dbg("allocating new device for %d/%d (session %ld)",
1073 busnum, devaddr, session_id);
1074 dev = usbi_alloc_device(ctx, session_id);
1076 return LIBUSB_ERROR_NO_MEM;
1078 r = initialize_device(dev, busnum, devaddr, sysfs_dir);
1081 r = usbi_sanitize_device(dev);
1085 r = linux_get_parent_info(dev, sysfs_dir);
1090 libusb_unref_device(dev);
1092 usbi_connect_device(dev);
1097 void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name)
1099 struct libusb_context *ctx;
1101 usbi_mutex_static_lock(&active_contexts_lock);
1102 list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
1103 linux_enumerate_device(ctx, busnum, devaddr, sys_name);
1105 usbi_mutex_static_unlock(&active_contexts_lock);
1108 void linux_device_disconnected(uint8_t busnum, uint8_t devaddr, const char *sys_name)
1110 struct libusb_context *ctx;
1111 struct libusb_device *dev;
1112 unsigned long session_id = busnum << 8 | devaddr;
1114 usbi_mutex_static_lock(&active_contexts_lock);
1115 list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
1116 dev = usbi_get_device_by_session_id (ctx, session_id);
1118 usbi_disconnect_device (dev);
1119 libusb_unref_device(dev);
1121 usbi_dbg("device not found for session %x", session_id);
1124 usbi_mutex_static_unlock(&active_contexts_lock);
1127 #if !defined(USE_UDEV)
1128 /* open a bus directory and adds all discovered devices to the context */
1129 static int usbfs_scan_busdir(struct libusb_context *ctx, uint8_t busnum)
1132 char dirpath[PATH_MAX];
1133 struct dirent *entry;
1134 int r = LIBUSB_ERROR_IO;
1136 snprintf(dirpath, PATH_MAX, "%s/%03d", usbfs_path, busnum);
1137 usbi_dbg("%s", dirpath);
1138 dir = opendir(dirpath);
1140 usbi_err(ctx, "opendir '%s' failed, errno=%d", dirpath, errno);
1141 /* FIXME: should handle valid race conditions like hub unplugged
1142 * during directory iteration - this is not an error */
1146 while ((entry = readdir(dir))) {
1149 if (entry->d_name[0] == '.')
1152 devaddr = atoi(entry->d_name);
1154 usbi_dbg("unknown dir entry %s", entry->d_name);
1158 if (linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL)) {
1159 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1170 static int usbfs_get_device_list(struct libusb_context *ctx)
1172 struct dirent *entry;
1173 DIR *buses = opendir(usbfs_path);
1177 usbi_err(ctx, "opendir buses failed errno=%d", errno);
1178 return LIBUSB_ERROR_IO;
1181 while ((entry = readdir(buses))) {
1184 if (entry->d_name[0] == '.')
1189 if (!_is_usbdev_entry(entry, &busnum, &devaddr))
1192 r = linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL);
1194 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1198 busnum = atoi(entry->d_name);
1200 usbi_dbg("unknown dir entry %s", entry->d_name);
1204 r = usbfs_scan_busdir(ctx, busnum);
1216 static int sysfs_scan_device(struct libusb_context *ctx, const char *devname)
1218 uint8_t busnum, devaddr;
1221 ret = linux_get_device_address (ctx, 0, &busnum, &devaddr, NULL, devname);
1222 if (LIBUSB_SUCCESS != ret) {
1226 return linux_enumerate_device(ctx, busnum & 0xff, devaddr & 0xff,
1230 #if !defined(USE_UDEV)
1231 static int sysfs_get_device_list(struct libusb_context *ctx)
1233 DIR *devices = opendir(SYSFS_DEVICE_PATH);
1234 struct dirent *entry;
1235 int r = LIBUSB_ERROR_IO;
1238 usbi_err(ctx, "opendir devices failed errno=%d", errno);
1242 while ((entry = readdir(devices))) {
1243 if ((!isdigit(entry->d_name[0]) && strncmp(entry->d_name, "usb", 3))
1244 || strchr(entry->d_name, ':'))
1247 if (sysfs_scan_device(ctx, entry->d_name)) {
1248 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1259 static int linux_default_scan_devices (struct libusb_context *ctx)
1261 /* we can retrieve device list and descriptors from sysfs or usbfs.
1262 * sysfs is preferable, because if we use usbfs we end up resuming
1263 * any autosuspended USB devices. however, sysfs is not available
1264 * everywhere, so we need a usbfs fallback too.
1266 * as described in the "sysfs vs usbfs" comment at the top of this
1267 * file, sometimes we have sysfs but not enough information to
1268 * relate sysfs devices to usbfs nodes. op_init() determines the
1269 * adequacy of sysfs and sets sysfs_can_relate_devices.
1271 if (sysfs_can_relate_devices != 0)
1272 return sysfs_get_device_list(ctx);
1274 return usbfs_get_device_list(ctx);
1278 static int op_open(struct libusb_device_handle *handle)
1280 struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
1283 hpriv->fd = _get_usbfs_fd(handle->dev, O_RDWR, 0);
1284 if (hpriv->fd < 0) {
1285 if (hpriv->fd == LIBUSB_ERROR_NO_DEVICE) {
1286 /* device will still be marked as attached if hotplug monitor thread
1287 * hasn't processed remove event yet */
1288 usbi_mutex_static_lock(&linux_hotplug_lock);
1289 if (handle->dev->attached) {
1290 usbi_dbg("open failed with no device, but device still attached");
1291 linux_device_disconnected(handle->dev->bus_number,
1292 handle->dev->device_address, NULL);
1294 usbi_mutex_static_unlock(&linux_hotplug_lock);
1299 r = ioctl(hpriv->fd, IOCTL_USBFS_GET_CAPABILITIES, &hpriv->caps);
1301 if (errno == ENOTTY)
1302 usbi_dbg("getcap not available");
1304 usbi_err(HANDLE_CTX(handle), "getcap failed (%d)", errno);
1306 if (supports_flag_zero_packet)
1307 hpriv->caps |= USBFS_CAP_ZERO_PACKET;
1308 if (supports_flag_bulk_continuation)
1309 hpriv->caps |= USBFS_CAP_BULK_CONTINUATION;
1312 return usbi_add_pollfd(HANDLE_CTX(handle), hpriv->fd, POLLOUT);
1315 static void op_close(struct libusb_device_handle *dev_handle)
1317 int fd = _device_handle_priv(dev_handle)->fd;
1318 usbi_remove_pollfd(HANDLE_CTX(dev_handle), fd);
1322 static int op_get_configuration(struct libusb_device_handle *handle,
1327 if (sysfs_can_relate_devices) {
1328 r = sysfs_get_active_config(handle->dev, config);
1330 r = usbfs_get_active_config(handle->dev,
1331 _device_handle_priv(handle)->fd);
1336 if (*config == -1) {
1337 usbi_err(HANDLE_CTX(handle), "device unconfigured");
1344 static int op_set_configuration(struct libusb_device_handle *handle, int config)
1346 struct linux_device_priv *priv = _device_priv(handle->dev);
1347 int fd = _device_handle_priv(handle)->fd;
1348 int r = ioctl(fd, IOCTL_USBFS_SETCONFIG, &config);
1350 if (errno == EINVAL)
1351 return LIBUSB_ERROR_NOT_FOUND;
1352 else if (errno == EBUSY)
1353 return LIBUSB_ERROR_BUSY;
1354 else if (errno == ENODEV)
1355 return LIBUSB_ERROR_NO_DEVICE;
1357 usbi_err(HANDLE_CTX(handle), "failed, error %d errno %d", r, errno);
1358 return LIBUSB_ERROR_OTHER;
1361 /* update our cached active config descriptor */
1362 priv->active_config = config;
1364 return LIBUSB_SUCCESS;
1367 static int claim_interface(struct libusb_device_handle *handle, int iface)
1369 int fd = _device_handle_priv(handle)->fd;
1370 int r = ioctl(fd, IOCTL_USBFS_CLAIMINTF, &iface);
1372 if (errno == ENOENT)
1373 return LIBUSB_ERROR_NOT_FOUND;
1374 else if (errno == EBUSY)
1375 return LIBUSB_ERROR_BUSY;
1376 else if (errno == ENODEV)
1377 return LIBUSB_ERROR_NO_DEVICE;
1379 usbi_err(HANDLE_CTX(handle),
1380 "claim interface failed, error %d errno %d", r, errno);
1381 return LIBUSB_ERROR_OTHER;
1386 static int release_interface(struct libusb_device_handle *handle, int iface)
1388 int fd = _device_handle_priv(handle)->fd;
1389 int r = ioctl(fd, IOCTL_USBFS_RELEASEINTF, &iface);
1391 if (errno == ENODEV)
1392 return LIBUSB_ERROR_NO_DEVICE;
1394 usbi_err(HANDLE_CTX(handle),
1395 "release interface failed, error %d errno %d", r, errno);
1396 return LIBUSB_ERROR_OTHER;
1401 static int op_set_interface(struct libusb_device_handle *handle, int iface,
1404 int fd = _device_handle_priv(handle)->fd;
1405 struct usbfs_setinterface setintf;
1408 setintf.interface = iface;
1409 setintf.altsetting = altsetting;
1410 r = ioctl(fd, IOCTL_USBFS_SETINTF, &setintf);
1412 if (errno == EINVAL)
1413 return LIBUSB_ERROR_NOT_FOUND;
1414 else if (errno == ENODEV)
1415 return LIBUSB_ERROR_NO_DEVICE;
1417 usbi_err(HANDLE_CTX(handle),
1418 "setintf failed error %d errno %d", r, errno);
1419 return LIBUSB_ERROR_OTHER;
1425 static int op_clear_halt(struct libusb_device_handle *handle,
1426 unsigned char endpoint)
1428 int fd = _device_handle_priv(handle)->fd;
1429 unsigned int _endpoint = endpoint;
1430 int r = ioctl(fd, IOCTL_USBFS_CLEAR_HALT, &_endpoint);
1432 if (errno == ENOENT)
1433 return LIBUSB_ERROR_NOT_FOUND;
1434 else if (errno == ENODEV)
1435 return LIBUSB_ERROR_NO_DEVICE;
1437 usbi_err(HANDLE_CTX(handle),
1438 "clear_halt failed error %d errno %d", r, errno);
1439 return LIBUSB_ERROR_OTHER;
1445 static int op_reset_device(struct libusb_device_handle *handle)
1447 int fd = _device_handle_priv(handle)->fd;
1450 /* Doing a device reset will cause the usbfs driver to get unbound
1451 from any interfaces it is bound to. By voluntarily unbinding
1452 the usbfs driver ourself, we stop the kernel from rebinding
1453 the interface after reset (which would end up with the interface
1454 getting bound to the in kernel driver if any). */
1455 for (i = 0; i < USB_MAXINTERFACES; i++) {
1456 if (handle->claimed_interfaces & (1L << i)) {
1457 release_interface(handle, i);
1461 usbi_mutex_lock(&handle->lock);
1462 r = ioctl(fd, IOCTL_USBFS_RESET, NULL);
1464 if (errno == ENODEV) {
1465 ret = LIBUSB_ERROR_NOT_FOUND;
1469 usbi_err(HANDLE_CTX(handle),
1470 "reset failed error %d errno %d", r, errno);
1471 ret = LIBUSB_ERROR_OTHER;
1475 /* And re-claim any interfaces which were claimed before the reset */
1476 for (i = 0; i < USB_MAXINTERFACES; i++) {
1477 if (handle->claimed_interfaces & (1L << i)) {
1479 * A driver may have completed modprobing during
1480 * IOCTL_USBFS_RESET, and bound itself as soon as
1481 * IOCTL_USBFS_RESET released the device lock
1483 r = detach_kernel_driver_and_claim(handle, i);
1485 usbi_warn(HANDLE_CTX(handle),
1486 "failed to re-claim interface %d after reset: %s",
1487 i, libusb_error_name(r));
1488 handle->claimed_interfaces &= ~(1L << i);
1489 ret = LIBUSB_ERROR_NOT_FOUND;
1494 usbi_mutex_unlock(&handle->lock);
1498 static int do_streams_ioctl(struct libusb_device_handle *handle, long req,
1499 uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
1501 int r, fd = _device_handle_priv(handle)->fd;
1502 struct usbfs_streams *streams;
1504 if (num_endpoints > 30) /* Max 15 in + 15 out eps */
1505 return LIBUSB_ERROR_INVALID_PARAM;
1507 streams = malloc(sizeof(struct usbfs_streams) + num_endpoints);
1509 return LIBUSB_ERROR_NO_MEM;
1511 streams->num_streams = num_streams;
1512 streams->num_eps = num_endpoints;
1513 memcpy(streams->eps, endpoints, num_endpoints);
1515 r = ioctl(fd, req, streams);
1520 if (errno == ENOTTY)
1521 return LIBUSB_ERROR_NOT_SUPPORTED;
1522 else if (errno == EINVAL)
1523 return LIBUSB_ERROR_INVALID_PARAM;
1524 else if (errno == ENODEV)
1525 return LIBUSB_ERROR_NO_DEVICE;
1527 usbi_err(HANDLE_CTX(handle),
1528 "streams-ioctl failed error %d errno %d", r, errno);
1529 return LIBUSB_ERROR_OTHER;
1534 static int op_alloc_streams(struct libusb_device_handle *handle,
1535 uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
1537 return do_streams_ioctl(handle, IOCTL_USBFS_ALLOC_STREAMS,
1538 num_streams, endpoints, num_endpoints);
1541 static int op_free_streams(struct libusb_device_handle *handle,
1542 unsigned char *endpoints, int num_endpoints)
1544 return do_streams_ioctl(handle, IOCTL_USBFS_FREE_STREAMS, 0,
1545 endpoints, num_endpoints);
1548 static int op_kernel_driver_active(struct libusb_device_handle *handle,
1551 int fd = _device_handle_priv(handle)->fd;
1552 struct usbfs_getdriver getdrv;
1555 getdrv.interface = interface;
1556 r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1558 if (errno == ENODATA)
1560 else if (errno == ENODEV)
1561 return LIBUSB_ERROR_NO_DEVICE;
1563 usbi_err(HANDLE_CTX(handle),
1564 "get driver failed error %d errno %d", r, errno);
1565 return LIBUSB_ERROR_OTHER;
1568 return (strcmp(getdrv.driver, "usbfs") == 0) ? 0 : 1;
1571 static int op_detach_kernel_driver(struct libusb_device_handle *handle,
1574 int fd = _device_handle_priv(handle)->fd;
1575 struct usbfs_ioctl command;
1576 struct usbfs_getdriver getdrv;
1579 command.ifno = interface;
1580 command.ioctl_code = IOCTL_USBFS_DISCONNECT;
1581 command.data = NULL;
1583 getdrv.interface = interface;
1584 r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1585 if (r == 0 && strcmp(getdrv.driver, "usbfs") == 0)
1586 return LIBUSB_ERROR_NOT_FOUND;
1588 r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1590 if (errno == ENODATA)
1591 return LIBUSB_ERROR_NOT_FOUND;
1592 else if (errno == EINVAL)
1593 return LIBUSB_ERROR_INVALID_PARAM;
1594 else if (errno == ENODEV)
1595 return LIBUSB_ERROR_NO_DEVICE;
1597 usbi_err(HANDLE_CTX(handle),
1598 "detach failed error %d errno %d", r, errno);
1599 return LIBUSB_ERROR_OTHER;
1605 static int op_attach_kernel_driver(struct libusb_device_handle *handle,
1608 int fd = _device_handle_priv(handle)->fd;
1609 struct usbfs_ioctl command;
1612 command.ifno = interface;
1613 command.ioctl_code = IOCTL_USBFS_CONNECT;
1614 command.data = NULL;
1616 r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1618 if (errno == ENODATA)
1619 return LIBUSB_ERROR_NOT_FOUND;
1620 else if (errno == EINVAL)
1621 return LIBUSB_ERROR_INVALID_PARAM;
1622 else if (errno == ENODEV)
1623 return LIBUSB_ERROR_NO_DEVICE;
1624 else if (errno == EBUSY)
1625 return LIBUSB_ERROR_BUSY;
1627 usbi_err(HANDLE_CTX(handle),
1628 "attach failed error %d errno %d", r, errno);
1629 return LIBUSB_ERROR_OTHER;
1630 } else if (r == 0) {
1631 return LIBUSB_ERROR_NOT_FOUND;
1637 static int detach_kernel_driver_and_claim(struct libusb_device_handle *handle,
1640 struct usbfs_disconnect_claim dc;
1641 int r, fd = _device_handle_priv(handle)->fd;
1643 dc.interface = interface;
1644 strcpy(dc.driver, "usbfs");
1645 dc.flags = USBFS_DISCONNECT_CLAIM_EXCEPT_DRIVER;
1646 r = ioctl(fd, IOCTL_USBFS_DISCONNECT_CLAIM, &dc);
1647 if (r == 0 || (r != 0 && errno != ENOTTY)) {
1653 return LIBUSB_ERROR_BUSY;
1655 return LIBUSB_ERROR_INVALID_PARAM;
1657 return LIBUSB_ERROR_NO_DEVICE;
1659 usbi_err(HANDLE_CTX(handle),
1660 "disconnect-and-claim failed errno %d", errno);
1661 return LIBUSB_ERROR_OTHER;
1664 /* Fallback code for kernels which don't support the
1665 disconnect-and-claim ioctl */
1666 r = op_detach_kernel_driver(handle, interface);
1667 if (r != 0 && r != LIBUSB_ERROR_NOT_FOUND)
1670 return claim_interface(handle, interface);
1673 static int op_claim_interface(struct libusb_device_handle *handle, int iface)
1675 if (handle->auto_detach_kernel_driver)
1676 return detach_kernel_driver_and_claim(handle, iface);
1678 return claim_interface(handle, iface);
1681 static int op_release_interface(struct libusb_device_handle *handle, int iface)
1685 r = release_interface(handle, iface);
1689 if (handle->auto_detach_kernel_driver)
1690 op_attach_kernel_driver(handle, iface);
1695 static void op_destroy_device(struct libusb_device *dev)
1697 struct linux_device_priv *priv = _device_priv(dev);
1698 if (priv->descriptors)
1699 free(priv->descriptors);
1700 if (priv->sysfs_dir)
1701 free(priv->sysfs_dir);
1704 /* URBs are discarded in reverse order of submission to avoid races. */
1705 static int discard_urbs(struct usbi_transfer *itransfer, int first, int last_plus_one)
1707 struct libusb_transfer *transfer =
1708 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1709 struct linux_transfer_priv *tpriv =
1710 usbi_transfer_get_os_priv(itransfer);
1711 struct linux_device_handle_priv *dpriv =
1712 _device_handle_priv(transfer->dev_handle);
1714 struct usbfs_urb *urb;
1716 for (i = last_plus_one - 1; i >= first; i--) {
1717 if (LIBUSB_TRANSFER_TYPE_ISOCHRONOUS == transfer->type)
1718 urb = tpriv->iso_urbs[i];
1720 urb = &tpriv->urbs[i];
1722 if (0 == ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, urb))
1725 if (EINVAL == errno) {
1726 usbi_dbg("URB not found --> assuming ready to be reaped");
1727 if (i == (last_plus_one - 1))
1728 ret = LIBUSB_ERROR_NOT_FOUND;
1729 } else if (ENODEV == errno) {
1730 usbi_dbg("Device not found for URB --> assuming ready to be reaped");
1731 ret = LIBUSB_ERROR_NO_DEVICE;
1733 usbi_warn(TRANSFER_CTX(transfer),
1734 "unrecognised discard errno %d", errno);
1735 ret = LIBUSB_ERROR_OTHER;
1741 static void free_iso_urbs(struct linux_transfer_priv *tpriv)
1744 for (i = 0; i < tpriv->num_urbs; i++) {
1745 struct usbfs_urb *urb = tpriv->iso_urbs[i];
1751 free(tpriv->iso_urbs);
1752 tpriv->iso_urbs = NULL;
1755 static int submit_bulk_transfer(struct usbi_transfer *itransfer)
1757 struct libusb_transfer *transfer =
1758 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1759 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1760 struct linux_device_handle_priv *dpriv =
1761 _device_handle_priv(transfer->dev_handle);
1762 struct usbfs_urb *urbs;
1763 int is_out = (transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK)
1764 == LIBUSB_ENDPOINT_OUT;
1765 int bulk_buffer_len, use_bulk_continuation;
1771 return LIBUSB_ERROR_BUSY;
1773 if (is_out && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) &&
1774 !(dpriv->caps & USBFS_CAP_ZERO_PACKET))
1775 return LIBUSB_ERROR_NOT_SUPPORTED;
1778 * Older versions of usbfs place a 16kb limit on bulk URBs. We work
1779 * around this by splitting large transfers into 16k blocks, and then
1780 * submit all urbs at once. it would be simpler to submit one urb at
1781 * a time, but there is a big performance gain doing it this way.
1783 * Newer versions lift the 16k limit (USBFS_CAP_NO_PACKET_SIZE_LIM),
1784 * using arbritary large transfers can still be a bad idea though, as
1785 * the kernel needs to allocate physical contiguous memory for this,
1786 * which may fail for large buffers.
1788 * The kernel solves this problem by splitting the transfer into
1789 * blocks itself when the host-controller is scatter-gather capable
1790 * (USBFS_CAP_BULK_SCATTER_GATHER), which most controllers are.
1792 * Last, there is the issue of short-transfers when splitting, for
1793 * short split-transfers to work reliable USBFS_CAP_BULK_CONTINUATION
1794 * is needed, but this is not always available.
1796 if (dpriv->caps & USBFS_CAP_BULK_SCATTER_GATHER) {
1797 /* Good! Just submit everything in one go */
1798 bulk_buffer_len = transfer->length ? transfer->length : 1;
1799 use_bulk_continuation = 0;
1800 } else if (dpriv->caps & USBFS_CAP_BULK_CONTINUATION) {
1801 /* Split the transfers and use bulk-continuation to
1802 avoid issues with short-transfers */
1803 bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
1804 use_bulk_continuation = 1;
1805 } else if (dpriv->caps & USBFS_CAP_NO_PACKET_SIZE_LIM) {
1806 /* Don't split, assume the kernel can alloc the buffer
1807 (otherwise the submit will fail with -ENOMEM) */
1808 bulk_buffer_len = transfer->length ? transfer->length : 1;
1809 use_bulk_continuation = 0;
1811 /* Bad, splitting without bulk-continuation, short transfers
1812 which end before the last urb will not work reliable! */
1813 /* Note we don't warn here as this is "normal" on kernels <
1814 2.6.32 and not a problem for most applications */
1815 bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
1816 use_bulk_continuation = 0;
1819 int num_urbs = transfer->length / bulk_buffer_len;
1820 int last_urb_partial = 0;
1822 if (transfer->length == 0) {
1824 } else if ((transfer->length % bulk_buffer_len) > 0) {
1825 last_urb_partial = 1;
1828 usbi_dbg("need %d urbs for new transfer with length %d", num_urbs,
1830 alloc_size = num_urbs * sizeof(struct usbfs_urb);
1831 urbs = calloc(1, alloc_size);
1833 return LIBUSB_ERROR_NO_MEM;
1835 tpriv->num_urbs = num_urbs;
1836 tpriv->num_retired = 0;
1837 tpriv->reap_action = NORMAL;
1838 tpriv->reap_status = LIBUSB_TRANSFER_COMPLETED;
1840 for (i = 0; i < num_urbs; i++) {
1841 struct usbfs_urb *urb = &urbs[i];
1842 urb->usercontext = itransfer;
1843 switch (transfer->type) {
1844 case LIBUSB_TRANSFER_TYPE_BULK:
1845 urb->type = USBFS_URB_TYPE_BULK;
1848 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
1849 urb->type = USBFS_URB_TYPE_BULK;
1850 urb->stream_id = itransfer->stream_id;
1852 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1853 urb->type = USBFS_URB_TYPE_INTERRUPT;
1856 urb->endpoint = transfer->endpoint;
1857 urb->buffer = transfer->buffer + (i * bulk_buffer_len);
1858 /* don't set the short not ok flag for the last URB */
1859 if (use_bulk_continuation && !is_out && (i < num_urbs - 1))
1860 urb->flags = USBFS_URB_SHORT_NOT_OK;
1861 if (i == num_urbs - 1 && last_urb_partial)
1862 urb->buffer_length = transfer->length % bulk_buffer_len;
1863 else if (transfer->length == 0)
1864 urb->buffer_length = 0;
1866 urb->buffer_length = bulk_buffer_len;
1868 if (i > 0 && use_bulk_continuation)
1869 urb->flags |= USBFS_URB_BULK_CONTINUATION;
1871 /* we have already checked that the flag is supported */
1872 if (is_out && i == num_urbs - 1 &&
1873 transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET)
1874 urb->flags |= USBFS_URB_ZERO_PACKET;
1876 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
1878 if (errno == ENODEV) {
1879 r = LIBUSB_ERROR_NO_DEVICE;
1881 usbi_err(TRANSFER_CTX(transfer),
1882 "submiturb failed error %d errno=%d", r, errno);
1883 r = LIBUSB_ERROR_IO;
1886 /* if the first URB submission fails, we can simply free up and
1887 * return failure immediately. */
1889 usbi_dbg("first URB failed, easy peasy");
1895 /* if it's not the first URB that failed, the situation is a bit
1896 * tricky. we may need to discard all previous URBs. there are
1898 * - discarding is asynchronous - discarded urbs will be reaped
1899 * later. the user must not have freed the transfer when the
1900 * discarded URBs are reaped, otherwise libusb will be using
1902 * - the earlier URBs may have completed successfully and we do
1903 * not want to throw away any data.
1904 * - this URB failing may be no error; EREMOTEIO means that
1905 * this transfer simply didn't need all the URBs we submitted
1906 * so, we report that the transfer was submitted successfully and
1907 * in case of error we discard all previous URBs. later when
1908 * the final reap completes we can report error to the user,
1909 * or success if an earlier URB was completed successfully.
1911 tpriv->reap_action = EREMOTEIO == errno ? COMPLETED_EARLY : SUBMIT_FAILED;
1913 /* The URBs we haven't submitted yet we count as already
1915 tpriv->num_retired += num_urbs - i;
1917 /* If we completed short then don't try to discard. */
1918 if (COMPLETED_EARLY == tpriv->reap_action)
1921 discard_urbs(itransfer, 0, i);
1923 usbi_dbg("reporting successful submission but waiting for %d "
1924 "discards before reporting error", i);
1932 static int submit_iso_transfer(struct usbi_transfer *itransfer)
1934 struct libusb_transfer *transfer =
1935 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1936 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1937 struct linux_device_handle_priv *dpriv =
1938 _device_handle_priv(transfer->dev_handle);
1939 struct usbfs_urb **urbs;
1941 int num_packets = transfer->num_iso_packets;
1943 int this_urb_len = 0;
1945 int packet_offset = 0;
1946 unsigned int packet_len;
1947 unsigned char *urb_buffer = transfer->buffer;
1949 if (tpriv->iso_urbs)
1950 return LIBUSB_ERROR_BUSY;
1952 /* usbfs places a 32kb limit on iso URBs. we divide up larger requests
1953 * into smaller units to meet such restriction, then fire off all the
1954 * units at once. it would be simpler if we just fired one unit at a time,
1955 * but there is a big performance gain through doing it this way.
1957 * Newer kernels lift the 32k limit (USBFS_CAP_NO_PACKET_SIZE_LIM),
1958 * using arbritary large transfers is still be a bad idea though, as
1959 * the kernel needs to allocate physical contiguous memory for this,
1960 * which may fail for large buffers.
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;
1972 this_urb_len += packet_len;
1975 usbi_dbg("need %d 32k URBs for transfer", num_urbs);
1977 alloc_size = num_urbs * sizeof(*urbs);
1978 urbs = calloc(1, alloc_size);
1980 return LIBUSB_ERROR_NO_MEM;
1982 tpriv->iso_urbs = urbs;
1983 tpriv->num_urbs = num_urbs;
1984 tpriv->num_retired = 0;
1985 tpriv->reap_action = NORMAL;
1986 tpriv->iso_packet_offset = 0;
1988 /* allocate + initialize each URB with the correct number of packets */
1989 for (i = 0; i < num_urbs; i++) {
1990 struct usbfs_urb *urb;
1991 unsigned int space_remaining_in_urb = MAX_ISO_BUFFER_LENGTH;
1992 int urb_packet_offset = 0;
1993 unsigned char *urb_buffer_orig = urb_buffer;
1997 /* swallow up all the packets we can fit into this URB */
1998 while (packet_offset < transfer->num_iso_packets) {
1999 packet_len = transfer->iso_packet_desc[packet_offset].length;
2000 if (packet_len <= space_remaining_in_urb) {
2002 urb_packet_offset++;
2004 space_remaining_in_urb -= packet_len;
2005 urb_buffer += packet_len;
2007 /* it can't fit, save it for the next URB */
2012 alloc_size = sizeof(*urb)
2013 + (urb_packet_offset * sizeof(struct usbfs_iso_packet_desc));
2014 urb = calloc(1, alloc_size);
2016 free_iso_urbs(tpriv);
2017 return LIBUSB_ERROR_NO_MEM;
2021 /* populate packet lengths */
2022 for (j = 0, k = packet_offset - urb_packet_offset;
2023 k < packet_offset; k++, j++) {
2024 packet_len = transfer->iso_packet_desc[k].length;
2025 urb->iso_frame_desc[j].length = packet_len;
2028 urb->usercontext = itransfer;
2029 urb->type = USBFS_URB_TYPE_ISO;
2030 /* FIXME: interface for non-ASAP data? */
2031 urb->flags = USBFS_URB_ISO_ASAP;
2032 urb->endpoint = transfer->endpoint;
2033 urb->number_of_packets = urb_packet_offset;
2034 urb->buffer = urb_buffer_orig;
2038 for (i = 0; i < num_urbs; i++) {
2039 int r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urbs[i]);
2041 if (errno == ENODEV) {
2042 r = LIBUSB_ERROR_NO_DEVICE;
2044 usbi_err(TRANSFER_CTX(transfer),
2045 "submiturb failed error %d errno=%d", r, errno);
2046 r = LIBUSB_ERROR_IO;
2049 /* if the first URB submission fails, we can simply free up and
2050 * return failure immediately. */
2052 usbi_dbg("first URB failed, easy peasy");
2053 free_iso_urbs(tpriv);
2057 /* if it's not the first URB that failed, the situation is a bit
2058 * tricky. we must discard all previous URBs. there are
2060 * - discarding is asynchronous - discarded urbs will be reaped
2061 * later. the user must not have freed the transfer when the
2062 * discarded URBs are reaped, otherwise libusb will be using
2064 * - the earlier URBs may have completed successfully and we do
2065 * not want to throw away any data.
2066 * so, in this case we discard all the previous URBs BUT we report
2067 * that the transfer was submitted successfully. then later when
2068 * the final discard completes we can report error to the user.
2070 tpriv->reap_action = SUBMIT_FAILED;
2072 /* The URBs we haven't submitted yet we count as already
2074 tpriv->num_retired = num_urbs - i;
2075 discard_urbs(itransfer, 0, i);
2077 usbi_dbg("reporting successful submission but waiting for %d "
2078 "discards before reporting error", i);
2086 static int submit_control_transfer(struct usbi_transfer *itransfer)
2088 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2089 struct libusb_transfer *transfer =
2090 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2091 struct linux_device_handle_priv *dpriv =
2092 _device_handle_priv(transfer->dev_handle);
2093 struct usbfs_urb *urb;
2097 return LIBUSB_ERROR_BUSY;
2099 if (transfer->length - LIBUSB_CONTROL_SETUP_SIZE > MAX_CTRL_BUFFER_LENGTH)
2100 return LIBUSB_ERROR_INVALID_PARAM;
2102 urb = calloc(1, sizeof(struct usbfs_urb));
2104 return LIBUSB_ERROR_NO_MEM;
2106 tpriv->num_urbs = 1;
2107 tpriv->reap_action = NORMAL;
2109 urb->usercontext = itransfer;
2110 urb->type = USBFS_URB_TYPE_CONTROL;
2111 urb->endpoint = transfer->endpoint;
2112 urb->buffer = transfer->buffer;
2113 urb->buffer_length = transfer->length;
2115 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
2119 if (errno == ENODEV)
2120 return LIBUSB_ERROR_NO_DEVICE;
2122 usbi_err(TRANSFER_CTX(transfer),
2123 "submiturb failed error %d errno=%d", r, errno);
2124 return LIBUSB_ERROR_IO;
2129 static int op_submit_transfer(struct usbi_transfer *itransfer)
2131 struct libusb_transfer *transfer =
2132 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2134 switch (transfer->type) {
2135 case LIBUSB_TRANSFER_TYPE_CONTROL:
2136 return submit_control_transfer(itransfer);
2137 case LIBUSB_TRANSFER_TYPE_BULK:
2138 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2139 return submit_bulk_transfer(itransfer);
2140 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2141 return submit_bulk_transfer(itransfer);
2142 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2143 return submit_iso_transfer(itransfer);
2145 usbi_err(TRANSFER_CTX(transfer),
2146 "unknown endpoint type %d", transfer->type);
2147 return LIBUSB_ERROR_INVALID_PARAM;
2151 static int op_cancel_transfer(struct usbi_transfer *itransfer)
2153 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2154 struct libusb_transfer *transfer =
2155 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2157 switch (transfer->type) {
2158 case LIBUSB_TRANSFER_TYPE_BULK:
2159 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2160 if (tpriv->reap_action == ERROR)
2162 /* else, fall through */
2163 case LIBUSB_TRANSFER_TYPE_CONTROL:
2164 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2165 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2166 tpriv->reap_action = CANCELLED;
2169 usbi_err(TRANSFER_CTX(transfer),
2170 "unknown endpoint type %d", transfer->type);
2171 return LIBUSB_ERROR_INVALID_PARAM;
2175 return LIBUSB_ERROR_NOT_FOUND;
2177 return discard_urbs(itransfer, 0, tpriv->num_urbs);
2180 static void op_clear_transfer_priv(struct usbi_transfer *itransfer)
2182 struct libusb_transfer *transfer =
2183 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2184 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2186 /* urbs can be freed also in submit_transfer so lock mutex first */
2187 switch (transfer->type) {
2188 case LIBUSB_TRANSFER_TYPE_CONTROL:
2189 case LIBUSB_TRANSFER_TYPE_BULK:
2190 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2191 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2192 usbi_mutex_lock(&itransfer->lock);
2196 usbi_mutex_unlock(&itransfer->lock);
2198 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2199 usbi_mutex_lock(&itransfer->lock);
2200 if (tpriv->iso_urbs)
2201 free_iso_urbs(tpriv);
2202 usbi_mutex_unlock(&itransfer->lock);
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\n",
2599 if (pollfd->revents & POLLERR) {
2600 usbi_remove_pollfd(HANDLE_CTX(handle), hpriv->fd);
2601 usbi_handle_disconnect(handle);
2602 /* device will still be marked as attached if hotplug monitor thread
2603 * hasn't processed remove event yet */
2604 usbi_mutex_static_lock(&linux_hotplug_lock);
2605 if (handle->dev->attached)
2606 linux_device_disconnected(handle->dev->bus_number,
2607 handle->dev->device_address, NULL);
2608 usbi_mutex_static_unlock(&linux_hotplug_lock);
2613 r = reap_for_handle(handle);
2615 if (r == 1 || r == LIBUSB_ERROR_NO_DEVICE)
2623 usbi_mutex_unlock(&ctx->open_devs_lock);
2627 static int op_clock_gettime(int clk_id, struct timespec *tp)
2630 case USBI_CLOCK_MONOTONIC:
2631 return clock_gettime(monotonic_clkid, tp);
2632 case USBI_CLOCK_REALTIME:
2633 return clock_gettime(CLOCK_REALTIME, tp);
2635 return LIBUSB_ERROR_INVALID_PARAM;
2639 #ifdef USBI_TIMERFD_AVAILABLE
2640 static clockid_t op_get_timerfd_clockid(void)
2642 return monotonic_clkid;
2647 const struct usbi_os_backend linux_usbfs_backend = {
2648 .name = "Linux usbfs",
2649 .caps = USBI_CAP_HAS_HID_ACCESS|USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER|USBI_CAP_HAS_POLLABLE_DEVICE_FD,
2652 .get_device_list = NULL,
2653 .hotplug_poll = op_hotplug_poll,
2654 .get_device_descriptor = op_get_device_descriptor,
2655 .get_active_config_descriptor = op_get_active_config_descriptor,
2656 .get_config_descriptor = op_get_config_descriptor,
2657 .get_config_descriptor_by_value = op_get_config_descriptor_by_value,
2661 .get_configuration = op_get_configuration,
2662 .set_configuration = op_set_configuration,
2663 .claim_interface = op_claim_interface,
2664 .release_interface = op_release_interface,
2666 .set_interface_altsetting = op_set_interface,
2667 .clear_halt = op_clear_halt,
2668 .reset_device = op_reset_device,
2670 .alloc_streams = op_alloc_streams,
2671 .free_streams = op_free_streams,
2673 .kernel_driver_active = op_kernel_driver_active,
2674 .detach_kernel_driver = op_detach_kernel_driver,
2675 .attach_kernel_driver = op_attach_kernel_driver,
2677 .destroy_device = op_destroy_device,
2679 .submit_transfer = op_submit_transfer,
2680 .cancel_transfer = op_cancel_transfer,
2681 .clear_transfer_priv = op_clear_transfer_priv,
2683 .handle_events = op_handle_events,
2685 .clock_gettime = op_clock_gettime,
2687 #ifdef USBI_TIMERFD_AVAILABLE
2688 .get_timerfd_clockid = op_get_timerfd_clockid,
2691 .device_priv_size = sizeof(struct linux_device_priv),
2692 .device_handle_priv_size = sizeof(struct linux_device_handle_priv),
2693 .transfer_priv_size = sizeof(struct linux_transfer_priv),
2694 .add_iso_packet_size = 0,