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>
38 #include <sys/types.h>
39 #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 has changed the maximum length of an individual isochronous packet
85 * over time. Initially this limit was 1,023 bytes, but Linux 2.6.18
86 * (commit 3612242e527eb47ee4756b5350f8bdf791aa5ede) increased this value to
87 * 8,192 bytes to support higher bandwidth devices. Linux 3.10
88 * (commit e2e2f0ea1c935edcf53feb4c4c8fdb4f86d57dd9) further increased this
89 * value to 49,152 bytes to support super speed devices.
91 static unsigned int max_iso_packet_len = 0;
93 /* Linux 2.6.23 adds support for O_CLOEXEC when opening files, which marks the
94 * close-on-exec flag in the underlying file descriptor. */
95 static int supports_flag_cloexec = -1;
97 /* Linux 2.6.32 adds support for a bulk continuation URB flag. this basically
98 * allows us to mark URBs as being part of a specific logical transfer when
99 * we submit them to the kernel. then, on any error except a cancellation, all
100 * URBs within that transfer will be cancelled and no more URBs will be
101 * accepted for the transfer, meaning that no more data can creep in.
103 * The BULK_CONTINUATION flag must be set on all URBs within a bulk transfer
104 * (in either direction) except the first.
105 * For IN transfers, we must also set SHORT_NOT_OK on all URBs except the
106 * last; it means that the kernel should treat a short reply as an error.
107 * For OUT transfers, SHORT_NOT_OK must not be set. it isn't needed (OUT
108 * transfers can't be short unless there's already some sort of error), and
109 * setting this flag is disallowed (a kernel with USB debugging enabled will
112 static int supports_flag_bulk_continuation = -1;
114 /* Linux 2.6.31 fixes support for the zero length packet URB flag. This
115 * allows us to mark URBs that should be followed by a zero length data
116 * packet, which can be required by device- or class-specific protocols.
118 static int supports_flag_zero_packet = -1;
120 /* clock ID for monotonic clock, as not all clock sources are available on all
121 * systems. appropriate choice made at initialization time. */
122 static clockid_t monotonic_clkid = -1;
124 /* Linux 2.6.22 (commit 83f7d958eab2fbc6b159ee92bf1493924e1d0f72) adds a busnum
125 * to sysfs, so we can relate devices. This also implies that we can read
126 * the active configuration through bConfigurationValue */
127 static int sysfs_can_relate_devices = -1;
129 /* Linux 2.6.26 (commit 217a9081d8e69026186067711131b77f0ce219ed) adds all
130 * config descriptors (rather then just the active config) to the sysfs
131 * descriptors file, so from then on we can use them. */
132 static int sysfs_has_descriptors = -1;
134 /* how many times have we initted (and not exited) ? */
135 static int init_count = 0;
137 /* Serialize hotplug start/stop */
138 static usbi_mutex_static_t linux_hotplug_startstop_lock = USBI_MUTEX_INITIALIZER;
139 /* Serialize scan-devices, event-thread, and poll */
140 usbi_mutex_static_t linux_hotplug_lock = USBI_MUTEX_INITIALIZER;
142 static int linux_start_event_monitor(void);
143 static int linux_stop_event_monitor(void);
144 static int linux_scan_devices(struct libusb_context *ctx);
145 static int sysfs_scan_device(struct libusb_context *ctx, const char *devname);
146 static int detach_kernel_driver_and_claim(struct libusb_device_handle *, int);
148 #if !defined(USE_UDEV)
149 static int linux_default_scan_devices (struct libusb_context *ctx);
152 struct kernel_version {
158 struct linux_device_priv {
160 unsigned char *descriptors;
162 int active_config; /* cache val for !sysfs_can_relate_devices */
165 struct linux_device_handle_priv {
173 /* submission failed after the first URB, so await cancellation/completion
174 * of all the others */
177 /* cancelled by user or timeout */
180 /* completed multi-URB transfer in non-final URB */
183 /* one or more urbs encountered a low-level error */
187 struct linux_transfer_priv {
189 struct usbfs_urb *urbs;
190 struct usbfs_urb **iso_urbs;
193 enum reap_action reap_action;
196 enum libusb_transfer_status reap_status;
198 /* next iso packet in user-supplied transfer to be populated */
199 int iso_packet_offset;
202 static int _open(const char *path, int flags)
204 #if defined(O_CLOEXEC)
205 if (supports_flag_cloexec)
206 return open(path, flags | O_CLOEXEC);
209 return open(path, flags);
212 static int _get_usbfs_fd(struct libusb_device *dev, mode_t mode, int silent)
214 struct libusb_context *ctx = DEVICE_CTX(dev);
220 snprintf(path, PATH_MAX, "%s/usbdev%d.%d",
221 usbfs_path, dev->bus_number, dev->device_address);
223 snprintf(path, PATH_MAX, "%s/%03d/%03d",
224 usbfs_path, dev->bus_number, dev->device_address);
226 fd = _open(path, mode);
228 return fd; /* Success */
230 if (errno == ENOENT) {
232 usbi_err(ctx, "File doesn't exist, wait %d ms and try again", delay/1000);
234 /* Wait 10ms for USB device path creation.*/
235 nanosleep(&(struct timespec){delay / 1000000, (delay * 1000) % 1000000000UL}, NULL);
237 fd = _open(path, mode);
239 return fd; /* Success */
243 usbi_err(ctx, "libusb couldn't open USB device %s: %s",
244 path, strerror(errno));
245 if (errno == EACCES && mode == O_RDWR)
246 usbi_err(ctx, "libusb requires write access to USB "
251 return LIBUSB_ERROR_ACCESS;
253 return LIBUSB_ERROR_NO_DEVICE;
254 return LIBUSB_ERROR_IO;
257 static struct linux_device_priv *_device_priv(struct libusb_device *dev)
259 return (struct linux_device_priv *) dev->os_priv;
262 static struct linux_device_handle_priv *_device_handle_priv(
263 struct libusb_device_handle *handle)
265 return (struct linux_device_handle_priv *) handle->os_priv;
268 /* check dirent for a /dev/usbdev%d.%d name
269 * optionally return bus/device on success */
270 static int _is_usbdev_entry(struct dirent *entry, int *bus_p, int *dev_p)
274 if (sscanf(entry->d_name, "usbdev%d.%d", &busnum, &devnum) != 2)
277 usbi_dbg("found: %s", entry->d_name);
285 static int check_usb_vfs(const char *dirname)
288 struct dirent *entry;
291 dir = opendir(dirname);
295 while ((entry = readdir(dir)) != NULL) {
296 if (entry->d_name[0] == '.')
299 /* We assume if we find any files that it must be the right place */
308 static const char *find_usbfs_path(void)
310 const char *path = "/dev/bus/usb";
311 const char *ret = NULL;
313 if (check_usb_vfs(path)) {
316 path = "/proc/bus/usb";
317 if (check_usb_vfs(path))
321 /* look for /dev/usbdev*.* if the normal places fail */
323 struct dirent *entry;
329 while ((entry = readdir(dir)) != NULL) {
330 if (_is_usbdev_entry(entry, NULL, NULL)) {
331 /* found one; that's enough */
341 /* On udev based systems without any usb-devices /dev/bus/usb will not
342 * exist. So if we've not found anything and we're using udev for hotplug
343 * simply assume /dev/bus/usb rather then making libusb_init fail. */
344 #if defined(USE_UDEV)
346 ret = "/dev/bus/usb";
350 usbi_dbg("found usbfs at %s", ret);
355 /* the monotonic clock is not usable on all systems (e.g. embedded ones often
356 * seem to lack it). fall back to REALTIME if we have to. */
357 static clockid_t find_monotonic_clock(void)
359 #ifdef CLOCK_MONOTONIC
363 /* Linux 2.6.28 adds CLOCK_MONOTONIC_RAW but we don't use it
364 * because it's not available through timerfd */
365 r = clock_gettime(CLOCK_MONOTONIC, &ts);
367 return CLOCK_MONOTONIC;
368 usbi_dbg("monotonic clock doesn't work, errno %d", errno);
371 return CLOCK_REALTIME;
374 static int get_kernel_version(struct libusb_context *ctx,
375 struct kernel_version *ver)
380 if (uname(&uts) < 0) {
381 usbi_err(ctx, "uname failed, errno %d", errno);
385 atoms = sscanf(uts.release, "%d.%d.%d", &ver->major, &ver->minor, &ver->sublevel);
387 usbi_err(ctx, "failed to parse uname release '%s'", uts.release);
396 usbi_dbg("reported kernel version is %s", uts.release);
401 static int kernel_version_ge(const struct kernel_version *ver,
402 int major, int minor, int sublevel)
404 if (ver->major > major)
406 else if (ver->major < major)
409 /* kmajor == major */
410 if (ver->minor == -1 && ver->sublevel == -1)
411 return 0 == minor && 0 == sublevel;
412 else if (ver->minor > minor)
414 else if (ver->minor < minor)
417 /* kminor == minor */
418 if (ver->sublevel == -1)
419 return 0 == sublevel;
421 return ver->sublevel >= sublevel;
424 static int op_init(struct libusb_context *ctx)
426 struct kernel_version kversion;
430 usbfs_path = find_usbfs_path();
432 usbi_err(ctx, "could not find usbfs");
433 return LIBUSB_ERROR_OTHER;
436 if (monotonic_clkid == -1)
437 monotonic_clkid = find_monotonic_clock();
439 if (get_kernel_version(ctx, &kversion) < 0)
440 return LIBUSB_ERROR_OTHER;
442 if (supports_flag_cloexec == -1) {
443 /* O_CLOEXEC flag available from Linux 2.6.23 */
444 supports_flag_cloexec = kernel_version_ge(&kversion,2,6,23);
447 if (supports_flag_bulk_continuation == -1) {
448 /* bulk continuation URB flag available from Linux 2.6.32 */
449 supports_flag_bulk_continuation = kernel_version_ge(&kversion,2,6,32);
452 if (supports_flag_bulk_continuation)
453 usbi_dbg("bulk continuation flag supported");
455 if (-1 == supports_flag_zero_packet) {
456 /* zero length packet URB flag fixed since Linux 2.6.31 */
457 supports_flag_zero_packet = kernel_version_ge(&kversion,2,6,31);
460 if (supports_flag_zero_packet)
461 usbi_dbg("zero length packet flag supported");
463 if (!max_iso_packet_len) {
464 if (kernel_version_ge(&kversion,3,10,0))
465 max_iso_packet_len = 49152;
466 else if (kernel_version_ge(&kversion,2,6,18))
467 max_iso_packet_len = 8192;
469 max_iso_packet_len = 1023;
472 usbi_dbg("max iso packet length is (likely) %u bytes", max_iso_packet_len);
474 if (-1 == sysfs_has_descriptors) {
475 /* sysfs descriptors has all descriptors since Linux 2.6.26 */
476 sysfs_has_descriptors = kernel_version_ge(&kversion,2,6,26);
479 if (-1 == sysfs_can_relate_devices) {
480 /* sysfs has busnum since Linux 2.6.22 */
481 sysfs_can_relate_devices = kernel_version_ge(&kversion,2,6,22);
484 if (sysfs_can_relate_devices || sysfs_has_descriptors) {
485 r = stat(SYSFS_DEVICE_PATH, &statbuf);
486 if (r != 0 || !S_ISDIR(statbuf.st_mode)) {
487 usbi_warn(ctx, "sysfs not mounted");
488 sysfs_can_relate_devices = 0;
489 sysfs_has_descriptors = 0;
493 if (sysfs_can_relate_devices)
494 usbi_dbg("sysfs can relate devices");
496 if (sysfs_has_descriptors)
497 usbi_dbg("sysfs has complete descriptors");
499 usbi_mutex_static_lock(&linux_hotplug_startstop_lock);
501 if (init_count == 0) {
502 /* start up hotplug event handler */
503 r = linux_start_event_monitor();
505 if (r == LIBUSB_SUCCESS) {
506 r = linux_scan_devices(ctx);
507 if (r == LIBUSB_SUCCESS)
509 else if (init_count == 0)
510 linux_stop_event_monitor();
512 usbi_err(ctx, "error starting hotplug event monitor");
513 usbi_mutex_static_unlock(&linux_hotplug_startstop_lock);
518 static void op_exit(struct libusb_context *ctx)
521 usbi_mutex_static_lock(&linux_hotplug_startstop_lock);
522 assert(init_count != 0);
524 /* tear down event handler */
525 (void)linux_stop_event_monitor();
527 usbi_mutex_static_unlock(&linux_hotplug_startstop_lock);
530 static int linux_start_event_monitor(void)
532 #if defined(USE_UDEV)
533 return linux_udev_start_event_monitor();
535 return linux_netlink_start_event_monitor();
539 static int linux_stop_event_monitor(void)
541 #if defined(USE_UDEV)
542 return linux_udev_stop_event_monitor();
544 return linux_netlink_stop_event_monitor();
548 static int linux_scan_devices(struct libusb_context *ctx)
552 usbi_mutex_static_lock(&linux_hotplug_lock);
554 #if defined(USE_UDEV)
555 ret = linux_udev_scan_devices(ctx);
557 ret = linux_default_scan_devices(ctx);
560 usbi_mutex_static_unlock(&linux_hotplug_lock);
565 static void op_hotplug_poll(void)
567 #if defined(USE_UDEV)
568 linux_udev_hotplug_poll();
570 linux_netlink_hotplug_poll();
574 static int _open_sysfs_attr(struct libusb_device *dev, const char *attr)
576 struct linux_device_priv *priv = _device_priv(dev);
577 char filename[PATH_MAX];
580 snprintf(filename, PATH_MAX, "%s/%s/%s",
581 SYSFS_DEVICE_PATH, priv->sysfs_dir, attr);
582 fd = _open(filename, O_RDONLY);
584 usbi_err(DEVICE_CTX(dev),
585 "open %s failed ret=%d errno=%d", filename, fd, errno);
586 return LIBUSB_ERROR_IO;
592 /* Note only suitable for attributes which always read >= 0, < 0 is error */
593 static int __read_sysfs_attr(struct libusb_context *ctx,
594 const char *devname, const char *attr)
596 char filename[PATH_MAX];
600 snprintf(filename, PATH_MAX, "%s/%s/%s", SYSFS_DEVICE_PATH,
602 fd = _open(filename, O_RDONLY);
604 if (errno == ENOENT) {
605 /* File doesn't exist. Assume the device has been
606 disconnected (see trac ticket #70). */
607 return LIBUSB_ERROR_NO_DEVICE;
609 usbi_err(ctx, "open %s failed errno=%d", filename, errno);
610 return LIBUSB_ERROR_IO;
615 usbi_err(ctx, "fdopen %s failed errno=%d", filename, errno);
617 return LIBUSB_ERROR_OTHER;
620 r = fscanf(f, "%d", &value);
623 usbi_err(ctx, "fscanf %s returned %d, errno=%d", attr, r, errno);
624 return LIBUSB_ERROR_NO_DEVICE; /* For unplug race (trac #70) */
627 usbi_err(ctx, "%s contains a negative value", filename);
628 return LIBUSB_ERROR_IO;
634 static int op_get_device_descriptor(struct libusb_device *dev,
635 unsigned char *buffer, int *host_endian)
637 struct linux_device_priv *priv = _device_priv(dev);
639 *host_endian = sysfs_has_descriptors ? 0 : 1;
640 memcpy(buffer, priv->descriptors, DEVICE_DESC_LENGTH);
645 /* read the bConfigurationValue for a device */
646 static int sysfs_get_active_config(struct libusb_device *dev, int *config)
649 char tmp[5] = {0, 0, 0, 0, 0};
654 fd = _open_sysfs_attr(dev, "bConfigurationValue");
658 r = read(fd, tmp, sizeof(tmp));
661 usbi_err(DEVICE_CTX(dev),
662 "read bConfigurationValue failed ret=%d errno=%d", r, errno);
663 return LIBUSB_ERROR_IO;
665 usbi_dbg("device unconfigured");
670 if (tmp[sizeof(tmp) - 1] != 0) {
671 usbi_err(DEVICE_CTX(dev), "not null-terminated?");
672 return LIBUSB_ERROR_IO;
673 } else if (tmp[0] == 0) {
674 usbi_err(DEVICE_CTX(dev), "no configuration value?");
675 return LIBUSB_ERROR_IO;
678 num = strtol(tmp, &endptr, 10);
680 usbi_err(DEVICE_CTX(dev), "error converting '%s' to integer", tmp);
681 return LIBUSB_ERROR_IO;
688 int linux_get_device_address (struct libusb_context *ctx, int detached,
689 uint8_t *busnum, uint8_t *devaddr,const char *dev_node,
690 const char *sys_name)
694 usbi_dbg("getting address for device: %s detached: %d", sys_name, detached);
695 /* can't use sysfs to read the bus and device number if the
696 * device has been detached */
697 if (!sysfs_can_relate_devices || detached || NULL == sys_name) {
698 if (NULL == dev_node) {
699 return LIBUSB_ERROR_OTHER;
702 /* will this work with all supported kernel versions? */
703 if (!strncmp(dev_node, "/dev/bus/usb", 12)) {
704 sscanf (dev_node, "/dev/bus/usb/%hhu/%hhu", busnum, devaddr);
705 } else if (!strncmp(dev_node, "/proc/bus/usb", 13)) {
706 sscanf (dev_node, "/proc/bus/usb/%hhu/%hhu", busnum, devaddr);
709 return LIBUSB_SUCCESS;
712 usbi_dbg("scan %s", sys_name);
714 sysfs_attr = __read_sysfs_attr(ctx, sys_name, "busnum");
717 if (sysfs_attr > 255)
718 return LIBUSB_ERROR_INVALID_PARAM;
719 *busnum = (uint8_t) sysfs_attr;
721 sysfs_attr = __read_sysfs_attr(ctx, sys_name, "devnum");
724 if (sysfs_attr > 255)
725 return LIBUSB_ERROR_INVALID_PARAM;
727 *devaddr = (uint8_t) sysfs_attr;
729 usbi_dbg("bus=%d dev=%d", *busnum, *devaddr);
731 return LIBUSB_SUCCESS;
734 /* Return offset of the next descriptor with the given type */
735 static int seek_to_next_descriptor(struct libusb_context *ctx,
736 uint8_t descriptor_type, unsigned char *buffer, int size)
738 struct usb_descriptor_header header;
741 for (i = 0; size >= 0; i += header.bLength, size -= header.bLength) {
743 return LIBUSB_ERROR_NOT_FOUND;
746 usbi_err(ctx, "short descriptor read %d/2", size);
747 return LIBUSB_ERROR_IO;
749 usbi_parse_descriptor(buffer + i, "bb", &header, 0);
751 if (i && header.bDescriptorType == descriptor_type)
754 usbi_err(ctx, "bLength overflow by %d bytes", -size);
755 return LIBUSB_ERROR_IO;
758 /* Return offset to next config */
759 static int seek_to_next_config(struct libusb_context *ctx,
760 unsigned char *buffer, int size)
762 struct libusb_config_descriptor config;
765 return LIBUSB_ERROR_NOT_FOUND;
767 if (size < LIBUSB_DT_CONFIG_SIZE) {
768 usbi_err(ctx, "short descriptor read %d/%d",
769 size, LIBUSB_DT_CONFIG_SIZE);
770 return LIBUSB_ERROR_IO;
773 usbi_parse_descriptor(buffer, "bbwbbbbb", &config, 0);
774 if (config.bDescriptorType != LIBUSB_DT_CONFIG) {
775 usbi_err(ctx, "descriptor is not a config desc (type 0x%02x)",
776 config.bDescriptorType);
777 return LIBUSB_ERROR_IO;
781 * In usbfs the config descriptors are config.wTotalLength bytes apart,
782 * with any short reads from the device appearing as holes in the file.
784 * In sysfs wTotalLength is ignored, instead the kernel returns a
785 * config descriptor with verified bLength fields, with descriptors
786 * with an invalid bLength removed.
788 if (sysfs_has_descriptors) {
789 int next = seek_to_next_descriptor(ctx, LIBUSB_DT_CONFIG,
791 if (next == LIBUSB_ERROR_NOT_FOUND)
796 if (next != config.wTotalLength)
797 usbi_warn(ctx, "config length mismatch wTotalLength "
798 "%d real %d", config.wTotalLength, next);
801 if (config.wTotalLength < LIBUSB_DT_CONFIG_SIZE) {
802 usbi_err(ctx, "invalid wTotalLength %d",
803 config.wTotalLength);
804 return LIBUSB_ERROR_IO;
805 } else if (config.wTotalLength > size) {
806 usbi_warn(ctx, "short descriptor read %d/%d",
807 size, config.wTotalLength);
810 return config.wTotalLength;
814 static int op_get_config_descriptor_by_value(struct libusb_device *dev,
815 uint8_t value, unsigned char **buffer, int *host_endian)
817 struct libusb_context *ctx = DEVICE_CTX(dev);
818 struct linux_device_priv *priv = _device_priv(dev);
819 unsigned char *descriptors = priv->descriptors;
820 int size = priv->descriptors_len;
821 struct libusb_config_descriptor *config;
824 /* Unlike the device desc. config descs. are always in raw format */
827 /* Skip device header */
828 descriptors += DEVICE_DESC_LENGTH;
829 size -= DEVICE_DESC_LENGTH;
831 /* Seek till the config is found, or till "EOF" */
833 int next = seek_to_next_config(ctx, descriptors, size);
836 config = (struct libusb_config_descriptor *)descriptors;
837 if (config->bConfigurationValue == value) {
838 *buffer = descriptors;
846 static int op_get_active_config_descriptor(struct libusb_device *dev,
847 unsigned char *buffer, size_t len, int *host_endian)
850 unsigned char *config_desc;
852 if (sysfs_can_relate_devices) {
853 r = sysfs_get_active_config(dev, &config);
857 /* Use cached bConfigurationValue */
858 struct linux_device_priv *priv = _device_priv(dev);
859 config = priv->active_config;
862 return LIBUSB_ERROR_NOT_FOUND;
864 r = op_get_config_descriptor_by_value(dev, config, &config_desc,
869 len = MIN(len, (size_t)r);
870 memcpy(buffer, config_desc, len);
874 static int op_get_config_descriptor(struct libusb_device *dev,
875 uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
877 struct linux_device_priv *priv = _device_priv(dev);
878 unsigned char *descriptors = priv->descriptors;
879 int i, r, size = priv->descriptors_len;
881 /* Unlike the device desc. config descs. are always in raw format */
884 /* Skip device header */
885 descriptors += DEVICE_DESC_LENGTH;
886 size -= DEVICE_DESC_LENGTH;
888 /* Seek till the config is found, or till "EOF" */
890 r = seek_to_next_config(DEVICE_CTX(dev), descriptors, size);
893 if (i == config_index)
899 len = MIN(len, (size_t)r);
900 memcpy(buffer, descriptors, len);
904 /* send a control message to retrieve active configuration */
905 static int usbfs_get_active_config(struct libusb_device *dev, int fd)
907 struct linux_device_priv *priv = _device_priv(dev);
908 unsigned char active_config = 0;
911 struct usbfs_ctrltransfer ctrl = {
912 .bmRequestType = LIBUSB_ENDPOINT_IN,
913 .bRequest = LIBUSB_REQUEST_GET_CONFIGURATION,
918 .data = &active_config
921 r = ioctl(fd, IOCTL_USBFS_CONTROL, &ctrl);
924 return LIBUSB_ERROR_NO_DEVICE;
926 /* we hit this error path frequently with buggy devices :( */
927 usbi_warn(DEVICE_CTX(dev),
928 "get_configuration failed ret=%d errno=%d", r, errno);
929 priv->active_config = -1;
931 if (active_config > 0) {
932 priv->active_config = active_config;
934 /* some buggy devices have a configuration 0, but we're
935 * reaching into the corner of a corner case here, so let's
936 * not support buggy devices in these circumstances.
937 * stick to the specs: a configuration value of 0 means
939 usbi_warn(DEVICE_CTX(dev),
940 "active cfg 0? assuming unconfigured device");
941 priv->active_config = -1;
945 return LIBUSB_SUCCESS;
948 static int initialize_device(struct libusb_device *dev, uint8_t busnum,
949 uint8_t devaddr, const char *sysfs_dir)
951 struct linux_device_priv *priv = _device_priv(dev);
952 struct libusb_context *ctx = DEVICE_CTX(dev);
953 int descriptors_size = 512; /* Begin with a 1024 byte alloc */
957 dev->bus_number = busnum;
958 dev->device_address = devaddr;
961 priv->sysfs_dir = strdup(sysfs_dir);
962 if (!priv->sysfs_dir)
963 return LIBUSB_ERROR_NO_MEM;
965 /* Note speed can contain 1.5, in this case __read_sysfs_attr
966 will stop parsing at the '.' and return 1 */
967 speed = __read_sysfs_attr(DEVICE_CTX(dev), sysfs_dir, "speed");
970 case 1: dev->speed = LIBUSB_SPEED_LOW; break;
971 case 12: dev->speed = LIBUSB_SPEED_FULL; break;
972 case 480: dev->speed = LIBUSB_SPEED_HIGH; break;
973 case 5000: dev->speed = LIBUSB_SPEED_SUPER; break;
974 case 10000: dev->speed = LIBUSB_SPEED_SUPER_PLUS; break;
976 usbi_warn(DEVICE_CTX(dev), "Unknown device speed: %d Mbps", speed);
981 /* cache descriptors in memory */
982 if (sysfs_has_descriptors)
983 fd = _open_sysfs_attr(dev, "descriptors");
985 fd = _get_usbfs_fd(dev, O_RDONLY, 0);
990 descriptors_size *= 2;
991 priv->descriptors = usbi_reallocf(priv->descriptors,
993 if (!priv->descriptors) {
995 return LIBUSB_ERROR_NO_MEM;
997 /* usbfs has holes in the file */
998 if (!sysfs_has_descriptors) {
999 memset(priv->descriptors + priv->descriptors_len,
1000 0, descriptors_size - priv->descriptors_len);
1002 r = read(fd, priv->descriptors + priv->descriptors_len,
1003 descriptors_size - priv->descriptors_len);
1005 usbi_err(ctx, "read descriptor failed ret=%d errno=%d",
1008 return LIBUSB_ERROR_IO;
1010 priv->descriptors_len += r;
1011 } while (priv->descriptors_len == descriptors_size);
1015 if (priv->descriptors_len < DEVICE_DESC_LENGTH) {
1016 usbi_err(ctx, "short descriptor read (%d)",
1017 priv->descriptors_len);
1018 return LIBUSB_ERROR_IO;
1021 if (sysfs_can_relate_devices)
1022 return LIBUSB_SUCCESS;
1024 /* cache active config */
1025 fd = _get_usbfs_fd(dev, O_RDWR, 1);
1027 /* cannot send a control message to determine the active
1028 * config. just assume the first one is active. */
1029 usbi_warn(ctx, "Missing rw usbfs access; cannot determine "
1030 "active configuration descriptor");
1031 if (priv->descriptors_len >=
1032 (DEVICE_DESC_LENGTH + LIBUSB_DT_CONFIG_SIZE)) {
1033 struct libusb_config_descriptor config;
1034 usbi_parse_descriptor(
1035 priv->descriptors + DEVICE_DESC_LENGTH,
1036 "bbwbbbbb", &config, 0);
1037 priv->active_config = config.bConfigurationValue;
1039 priv->active_config = -1; /* No config dt */
1041 return LIBUSB_SUCCESS;
1044 r = usbfs_get_active_config(dev, fd);
1050 static int linux_get_parent_info(struct libusb_device *dev, const char *sysfs_dir)
1052 struct libusb_context *ctx = DEVICE_CTX(dev);
1053 struct libusb_device *it;
1054 char *parent_sysfs_dir, *tmp;
1055 int ret, add_parent = 1;
1057 /* XXX -- can we figure out the topology when using usbfs? */
1058 if (NULL == sysfs_dir || 0 == strncmp(sysfs_dir, "usb", 3)) {
1059 /* either using usbfs or finding the parent of a root hub */
1060 return LIBUSB_SUCCESS;
1063 parent_sysfs_dir = strdup(sysfs_dir);
1064 if (NULL == parent_sysfs_dir) {
1065 return LIBUSB_ERROR_NO_MEM;
1067 if (NULL != (tmp = strrchr(parent_sysfs_dir, '.')) ||
1068 NULL != (tmp = strrchr(parent_sysfs_dir, '-'))) {
1069 dev->port_number = atoi(tmp + 1);
1072 usbi_warn(ctx, "Can not parse sysfs_dir: %s, no parent info",
1074 free (parent_sysfs_dir);
1075 return LIBUSB_SUCCESS;
1078 /* is the parent a root hub? */
1079 if (NULL == strchr(parent_sysfs_dir, '-')) {
1080 tmp = parent_sysfs_dir;
1081 ret = asprintf (&parent_sysfs_dir, "usb%s", tmp);
1084 return LIBUSB_ERROR_NO_MEM;
1089 /* find the parent in the context */
1090 usbi_mutex_lock(&ctx->usb_devs_lock);
1091 list_for_each_entry(it, &ctx->usb_devs, list, struct libusb_device) {
1092 struct linux_device_priv *priv = _device_priv(it);
1093 if (priv->sysfs_dir) {
1094 if (0 == strcmp (priv->sysfs_dir, parent_sysfs_dir)) {
1095 dev->parent_dev = libusb_ref_device(it);
1100 usbi_mutex_unlock(&ctx->usb_devs_lock);
1102 if (!dev->parent_dev && add_parent) {
1103 usbi_dbg("parent_dev %s not enumerated yet, enumerating now",
1105 sysfs_scan_device(ctx, parent_sysfs_dir);
1110 usbi_dbg("Dev %p (%s) has parent %p (%s) port %d", dev, sysfs_dir,
1111 dev->parent_dev, parent_sysfs_dir, dev->port_number);
1113 free (parent_sysfs_dir);
1115 return LIBUSB_SUCCESS;
1118 int linux_enumerate_device(struct libusb_context *ctx,
1119 uint8_t busnum, uint8_t devaddr, const char *sysfs_dir)
1121 unsigned long session_id;
1122 struct libusb_device *dev;
1125 /* FIXME: session ID is not guaranteed unique as addresses can wrap and
1126 * will be reused. instead we should add a simple sysfs attribute with
1128 session_id = busnum << 8 | devaddr;
1129 usbi_dbg("busnum %d devaddr %d session_id %ld", busnum, devaddr,
1132 dev = usbi_get_device_by_session_id(ctx, session_id);
1134 /* device already exists in the context */
1135 usbi_dbg("session_id %ld already exists", session_id);
1136 libusb_unref_device(dev);
1137 return LIBUSB_SUCCESS;
1140 usbi_dbg("allocating new device for %d/%d (session %ld)",
1141 busnum, devaddr, session_id);
1142 dev = usbi_alloc_device(ctx, session_id);
1144 return LIBUSB_ERROR_NO_MEM;
1146 r = initialize_device(dev, busnum, devaddr, sysfs_dir);
1149 r = usbi_sanitize_device(dev);
1153 r = linux_get_parent_info(dev, sysfs_dir);
1158 libusb_unref_device(dev);
1160 usbi_connect_device(dev);
1165 void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name)
1167 struct libusb_context *ctx;
1169 usbi_mutex_static_lock(&active_contexts_lock);
1170 list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
1171 linux_enumerate_device(ctx, busnum, devaddr, sys_name);
1173 usbi_mutex_static_unlock(&active_contexts_lock);
1176 void linux_device_disconnected(uint8_t busnum, uint8_t devaddr)
1178 struct libusb_context *ctx;
1179 struct libusb_device *dev;
1180 unsigned long session_id = busnum << 8 | devaddr;
1182 usbi_mutex_static_lock(&active_contexts_lock);
1183 list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
1184 dev = usbi_get_device_by_session_id (ctx, session_id);
1186 usbi_disconnect_device (dev);
1187 libusb_unref_device(dev);
1189 usbi_dbg("device not found for session %x", session_id);
1192 usbi_mutex_static_unlock(&active_contexts_lock);
1195 #if !defined(USE_UDEV)
1196 /* open a bus directory and adds all discovered devices to the context */
1197 static int usbfs_scan_busdir(struct libusb_context *ctx, uint8_t busnum)
1200 char dirpath[PATH_MAX];
1201 struct dirent *entry;
1202 int r = LIBUSB_ERROR_IO;
1204 snprintf(dirpath, PATH_MAX, "%s/%03d", usbfs_path, busnum);
1205 usbi_dbg("%s", dirpath);
1206 dir = opendir(dirpath);
1208 usbi_err(ctx, "opendir '%s' failed, errno=%d", dirpath, errno);
1209 /* FIXME: should handle valid race conditions like hub unplugged
1210 * during directory iteration - this is not an error */
1214 while ((entry = readdir(dir))) {
1217 if (entry->d_name[0] == '.')
1220 devaddr = atoi(entry->d_name);
1222 usbi_dbg("unknown dir entry %s", entry->d_name);
1226 if (linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL)) {
1227 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1238 static int usbfs_get_device_list(struct libusb_context *ctx)
1240 struct dirent *entry;
1241 DIR *buses = opendir(usbfs_path);
1245 usbi_err(ctx, "opendir buses failed errno=%d", errno);
1246 return LIBUSB_ERROR_IO;
1249 while ((entry = readdir(buses))) {
1252 if (entry->d_name[0] == '.')
1257 if (!_is_usbdev_entry(entry, &busnum, &devaddr))
1260 r = linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL);
1262 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1266 busnum = atoi(entry->d_name);
1268 usbi_dbg("unknown dir entry %s", entry->d_name);
1272 r = usbfs_scan_busdir(ctx, busnum);
1284 static int sysfs_scan_device(struct libusb_context *ctx, const char *devname)
1286 uint8_t busnum, devaddr;
1289 ret = linux_get_device_address (ctx, 0, &busnum, &devaddr, NULL, devname);
1290 if (LIBUSB_SUCCESS != ret) {
1294 return linux_enumerate_device(ctx, busnum & 0xff, devaddr & 0xff,
1298 #if !defined(USE_UDEV)
1299 static int sysfs_get_device_list(struct libusb_context *ctx)
1301 DIR *devices = opendir(SYSFS_DEVICE_PATH);
1302 struct dirent *entry;
1303 int num_devices = 0;
1304 int num_enumerated = 0;
1307 usbi_err(ctx, "opendir devices failed errno=%d", errno);
1308 return LIBUSB_ERROR_IO;
1311 while ((entry = readdir(devices))) {
1312 if ((!isdigit(entry->d_name[0]) && strncmp(entry->d_name, "usb", 3))
1313 || strchr(entry->d_name, ':'))
1318 if (sysfs_scan_device(ctx, entry->d_name)) {
1319 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1328 /* successful if at least one device was enumerated or no devices were found */
1329 if (num_enumerated || !num_devices)
1330 return LIBUSB_SUCCESS;
1332 return LIBUSB_ERROR_IO;
1335 static int linux_default_scan_devices (struct libusb_context *ctx)
1337 /* we can retrieve device list and descriptors from sysfs or usbfs.
1338 * sysfs is preferable, because if we use usbfs we end up resuming
1339 * any autosuspended USB devices. however, sysfs is not available
1340 * everywhere, so we need a usbfs fallback too.
1342 * as described in the "sysfs vs usbfs" comment at the top of this
1343 * file, sometimes we have sysfs but not enough information to
1344 * relate sysfs devices to usbfs nodes. op_init() determines the
1345 * adequacy of sysfs and sets sysfs_can_relate_devices.
1347 if (sysfs_can_relate_devices != 0)
1348 return sysfs_get_device_list(ctx);
1350 return usbfs_get_device_list(ctx);
1354 static int op_open(struct libusb_device_handle *handle)
1356 struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
1359 hpriv->fd = _get_usbfs_fd(handle->dev, O_RDWR, 0);
1360 if (hpriv->fd < 0) {
1361 if (hpriv->fd == LIBUSB_ERROR_NO_DEVICE) {
1362 /* device will still be marked as attached if hotplug monitor thread
1363 * hasn't processed remove event yet */
1364 usbi_mutex_static_lock(&linux_hotplug_lock);
1365 if (handle->dev->attached) {
1366 usbi_dbg("open failed with no device, but device still attached");
1367 linux_device_disconnected(handle->dev->bus_number,
1368 handle->dev->device_address);
1370 usbi_mutex_static_unlock(&linux_hotplug_lock);
1375 r = ioctl(hpriv->fd, IOCTL_USBFS_GET_CAPABILITIES, &hpriv->caps);
1377 if (errno == ENOTTY)
1378 usbi_dbg("getcap not available");
1380 usbi_err(HANDLE_CTX(handle), "getcap failed (%d)", errno);
1382 if (supports_flag_zero_packet)
1383 hpriv->caps |= USBFS_CAP_ZERO_PACKET;
1384 if (supports_flag_bulk_continuation)
1385 hpriv->caps |= USBFS_CAP_BULK_CONTINUATION;
1388 r = usbi_add_pollfd(HANDLE_CTX(handle), hpriv->fd, POLLOUT);
1395 static void op_close(struct libusb_device_handle *dev_handle)
1397 struct linux_device_handle_priv *hpriv = _device_handle_priv(dev_handle);
1398 /* fd may have already been removed by POLLERR condition in op_handle_events() */
1399 if (!hpriv->fd_removed)
1400 usbi_remove_pollfd(HANDLE_CTX(dev_handle), hpriv->fd);
1404 static int op_get_configuration(struct libusb_device_handle *handle,
1409 if (sysfs_can_relate_devices) {
1410 r = sysfs_get_active_config(handle->dev, config);
1412 r = usbfs_get_active_config(handle->dev,
1413 _device_handle_priv(handle)->fd);
1414 if (r == LIBUSB_SUCCESS)
1415 *config = _device_priv(handle->dev)->active_config;
1420 if (*config == -1) {
1421 usbi_err(HANDLE_CTX(handle), "device unconfigured");
1428 static int op_set_configuration(struct libusb_device_handle *handle, int config)
1430 struct linux_device_priv *priv = _device_priv(handle->dev);
1431 int fd = _device_handle_priv(handle)->fd;
1432 int r = ioctl(fd, IOCTL_USBFS_SETCONFIG, &config);
1434 if (errno == EINVAL)
1435 return LIBUSB_ERROR_NOT_FOUND;
1436 else if (errno == EBUSY)
1437 return LIBUSB_ERROR_BUSY;
1438 else if (errno == ENODEV)
1439 return LIBUSB_ERROR_NO_DEVICE;
1441 usbi_err(HANDLE_CTX(handle), "failed, error %d errno %d", r, errno);
1442 return LIBUSB_ERROR_OTHER;
1445 /* update our cached active config descriptor */
1446 priv->active_config = config;
1448 return LIBUSB_SUCCESS;
1451 static int claim_interface(struct libusb_device_handle *handle, int iface)
1453 int fd = _device_handle_priv(handle)->fd;
1454 int r = ioctl(fd, IOCTL_USBFS_CLAIMINTF, &iface);
1456 if (errno == ENOENT)
1457 return LIBUSB_ERROR_NOT_FOUND;
1458 else if (errno == EBUSY)
1459 return LIBUSB_ERROR_BUSY;
1460 else if (errno == ENODEV)
1461 return LIBUSB_ERROR_NO_DEVICE;
1463 usbi_err(HANDLE_CTX(handle),
1464 "claim interface failed, error %d errno %d", r, errno);
1465 return LIBUSB_ERROR_OTHER;
1470 static int release_interface(struct libusb_device_handle *handle, int iface)
1472 int fd = _device_handle_priv(handle)->fd;
1473 int r = ioctl(fd, IOCTL_USBFS_RELEASEINTF, &iface);
1475 if (errno == ENODEV)
1476 return LIBUSB_ERROR_NO_DEVICE;
1478 usbi_err(HANDLE_CTX(handle),
1479 "release interface failed, error %d errno %d", r, errno);
1480 return LIBUSB_ERROR_OTHER;
1485 static int op_set_interface(struct libusb_device_handle *handle, int iface,
1488 int fd = _device_handle_priv(handle)->fd;
1489 struct usbfs_setinterface setintf;
1492 setintf.interface = iface;
1493 setintf.altsetting = altsetting;
1494 r = ioctl(fd, IOCTL_USBFS_SETINTF, &setintf);
1496 if (errno == EINVAL)
1497 return LIBUSB_ERROR_NOT_FOUND;
1498 else if (errno == ENODEV)
1499 return LIBUSB_ERROR_NO_DEVICE;
1501 usbi_err(HANDLE_CTX(handle),
1502 "setintf failed error %d errno %d", r, errno);
1503 return LIBUSB_ERROR_OTHER;
1509 static int op_clear_halt(struct libusb_device_handle *handle,
1510 unsigned char endpoint)
1512 int fd = _device_handle_priv(handle)->fd;
1513 unsigned int _endpoint = endpoint;
1514 int r = ioctl(fd, IOCTL_USBFS_CLEAR_HALT, &_endpoint);
1516 if (errno == ENOENT)
1517 return LIBUSB_ERROR_NOT_FOUND;
1518 else if (errno == ENODEV)
1519 return LIBUSB_ERROR_NO_DEVICE;
1521 usbi_err(HANDLE_CTX(handle),
1522 "clear_halt failed error %d errno %d", r, errno);
1523 return LIBUSB_ERROR_OTHER;
1529 static int op_reset_device(struct libusb_device_handle *handle)
1531 int fd = _device_handle_priv(handle)->fd;
1534 /* Doing a device reset will cause the usbfs driver to get unbound
1535 from any interfaces it is bound to. By voluntarily unbinding
1536 the usbfs driver ourself, we stop the kernel from rebinding
1537 the interface after reset (which would end up with the interface
1538 getting bound to the in kernel driver if any). */
1539 for (i = 0; i < USB_MAXINTERFACES; i++) {
1540 if (handle->claimed_interfaces & (1L << i)) {
1541 release_interface(handle, i);
1545 usbi_mutex_lock(&handle->lock);
1546 r = ioctl(fd, IOCTL_USBFS_RESET, NULL);
1548 if (errno == ENODEV) {
1549 ret = LIBUSB_ERROR_NOT_FOUND;
1553 usbi_err(HANDLE_CTX(handle),
1554 "reset failed error %d errno %d", r, errno);
1555 ret = LIBUSB_ERROR_OTHER;
1559 /* And re-claim any interfaces which were claimed before the reset */
1560 for (i = 0; i < USB_MAXINTERFACES; i++) {
1561 if (handle->claimed_interfaces & (1L << i)) {
1563 * A driver may have completed modprobing during
1564 * IOCTL_USBFS_RESET, and bound itself as soon as
1565 * IOCTL_USBFS_RESET released the device lock
1567 r = detach_kernel_driver_and_claim(handle, i);
1569 usbi_warn(HANDLE_CTX(handle),
1570 "failed to re-claim interface %d after reset: %s",
1571 i, libusb_error_name(r));
1572 handle->claimed_interfaces &= ~(1L << i);
1573 ret = LIBUSB_ERROR_NOT_FOUND;
1578 usbi_mutex_unlock(&handle->lock);
1582 static int do_streams_ioctl(struct libusb_device_handle *handle, long req,
1583 uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
1585 int r, fd = _device_handle_priv(handle)->fd;
1586 struct usbfs_streams *streams;
1588 if (num_endpoints > 30) /* Max 15 in + 15 out eps */
1589 return LIBUSB_ERROR_INVALID_PARAM;
1591 streams = malloc(sizeof(struct usbfs_streams) + num_endpoints);
1593 return LIBUSB_ERROR_NO_MEM;
1595 streams->num_streams = num_streams;
1596 streams->num_eps = num_endpoints;
1597 memcpy(streams->eps, endpoints, num_endpoints);
1599 r = ioctl(fd, req, streams);
1604 if (errno == ENOTTY)
1605 return LIBUSB_ERROR_NOT_SUPPORTED;
1606 else if (errno == EINVAL)
1607 return LIBUSB_ERROR_INVALID_PARAM;
1608 else if (errno == ENODEV)
1609 return LIBUSB_ERROR_NO_DEVICE;
1611 usbi_err(HANDLE_CTX(handle),
1612 "streams-ioctl failed error %d errno %d", r, errno);
1613 return LIBUSB_ERROR_OTHER;
1618 static int op_alloc_streams(struct libusb_device_handle *handle,
1619 uint32_t num_streams, unsigned char *endpoints, int num_endpoints)
1621 return do_streams_ioctl(handle, IOCTL_USBFS_ALLOC_STREAMS,
1622 num_streams, endpoints, num_endpoints);
1625 static int op_free_streams(struct libusb_device_handle *handle,
1626 unsigned char *endpoints, int num_endpoints)
1628 return do_streams_ioctl(handle, IOCTL_USBFS_FREE_STREAMS, 0,
1629 endpoints, num_endpoints);
1632 static unsigned char *op_dev_mem_alloc(struct libusb_device_handle *handle,
1635 struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
1636 unsigned char *buffer = (unsigned char *)mmap(NULL, len,
1637 PROT_READ | PROT_WRITE, MAP_SHARED, hpriv->fd, 0);
1638 if (buffer == MAP_FAILED) {
1639 usbi_err(HANDLE_CTX(handle), "alloc dev mem failed errno %d",
1646 static int op_dev_mem_free(struct libusb_device_handle *handle,
1647 unsigned char *buffer, size_t len)
1649 if (munmap(buffer, len) != 0) {
1650 usbi_err(HANDLE_CTX(handle), "free dev mem failed errno %d",
1652 return LIBUSB_ERROR_OTHER;
1654 return LIBUSB_SUCCESS;
1658 static int op_kernel_driver_active(struct libusb_device_handle *handle,
1661 int fd = _device_handle_priv(handle)->fd;
1662 struct usbfs_getdriver getdrv;
1665 getdrv.interface = interface;
1666 r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1668 if (errno == ENODATA)
1670 else if (errno == ENODEV)
1671 return LIBUSB_ERROR_NO_DEVICE;
1673 usbi_err(HANDLE_CTX(handle),
1674 "get driver failed error %d errno %d", r, errno);
1675 return LIBUSB_ERROR_OTHER;
1678 return (strcmp(getdrv.driver, "usbfs") == 0) ? 0 : 1;
1681 static int op_detach_kernel_driver(struct libusb_device_handle *handle,
1684 int fd = _device_handle_priv(handle)->fd;
1685 struct usbfs_ioctl command;
1686 struct usbfs_getdriver getdrv;
1689 command.ifno = interface;
1690 command.ioctl_code = IOCTL_USBFS_DISCONNECT;
1691 command.data = NULL;
1693 getdrv.interface = interface;
1694 r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1695 if (r == 0 && strcmp(getdrv.driver, "usbfs") == 0)
1696 return LIBUSB_ERROR_NOT_FOUND;
1698 r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1700 if (errno == ENODATA)
1701 return LIBUSB_ERROR_NOT_FOUND;
1702 else if (errno == EINVAL)
1703 return LIBUSB_ERROR_INVALID_PARAM;
1704 else if (errno == ENODEV)
1705 return LIBUSB_ERROR_NO_DEVICE;
1707 usbi_err(HANDLE_CTX(handle),
1708 "detach failed error %d errno %d", r, errno);
1709 return LIBUSB_ERROR_OTHER;
1715 static int op_attach_kernel_driver(struct libusb_device_handle *handle,
1718 int fd = _device_handle_priv(handle)->fd;
1719 struct usbfs_ioctl command;
1722 command.ifno = interface;
1723 command.ioctl_code = IOCTL_USBFS_CONNECT;
1724 command.data = NULL;
1726 r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1728 if (errno == ENODATA)
1729 return LIBUSB_ERROR_NOT_FOUND;
1730 else if (errno == EINVAL)
1731 return LIBUSB_ERROR_INVALID_PARAM;
1732 else if (errno == ENODEV)
1733 return LIBUSB_ERROR_NO_DEVICE;
1734 else if (errno == EBUSY)
1735 return LIBUSB_ERROR_BUSY;
1737 usbi_err(HANDLE_CTX(handle),
1738 "attach failed error %d errno %d", r, errno);
1739 return LIBUSB_ERROR_OTHER;
1740 } else if (r == 0) {
1741 return LIBUSB_ERROR_NOT_FOUND;
1747 static int detach_kernel_driver_and_claim(struct libusb_device_handle *handle,
1750 struct usbfs_disconnect_claim dc;
1751 int r, fd = _device_handle_priv(handle)->fd;
1753 dc.interface = interface;
1754 strcpy(dc.driver, "usbfs");
1755 dc.flags = USBFS_DISCONNECT_CLAIM_EXCEPT_DRIVER;
1756 r = ioctl(fd, IOCTL_USBFS_DISCONNECT_CLAIM, &dc);
1757 if (r != 0 && errno != ENOTTY) {
1760 return LIBUSB_ERROR_BUSY;
1762 return LIBUSB_ERROR_INVALID_PARAM;
1764 return LIBUSB_ERROR_NO_DEVICE;
1766 usbi_err(HANDLE_CTX(handle),
1767 "disconnect-and-claim failed errno %d", errno);
1768 return LIBUSB_ERROR_OTHER;
1772 /* Fallback code for kernels which don't support the
1773 disconnect-and-claim ioctl */
1774 r = op_detach_kernel_driver(handle, interface);
1775 if (r != 0 && r != LIBUSB_ERROR_NOT_FOUND)
1778 return claim_interface(handle, interface);
1781 static int op_claim_interface(struct libusb_device_handle *handle, int iface)
1783 if (handle->auto_detach_kernel_driver)
1784 return detach_kernel_driver_and_claim(handle, iface);
1786 return claim_interface(handle, iface);
1789 static int op_release_interface(struct libusb_device_handle *handle, int iface)
1793 r = release_interface(handle, iface);
1797 if (handle->auto_detach_kernel_driver)
1798 op_attach_kernel_driver(handle, iface);
1803 static void op_destroy_device(struct libusb_device *dev)
1805 struct linux_device_priv *priv = _device_priv(dev);
1806 if (priv->descriptors)
1807 free(priv->descriptors);
1808 if (priv->sysfs_dir)
1809 free(priv->sysfs_dir);
1812 /* URBs are discarded in reverse order of submission to avoid races. */
1813 static int discard_urbs(struct usbi_transfer *itransfer, int first, int last_plus_one)
1815 struct libusb_transfer *transfer =
1816 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1817 struct linux_transfer_priv *tpriv =
1818 usbi_transfer_get_os_priv(itransfer);
1819 struct linux_device_handle_priv *dpriv =
1820 _device_handle_priv(transfer->dev_handle);
1822 struct usbfs_urb *urb;
1824 for (i = last_plus_one - 1; i >= first; i--) {
1825 if (LIBUSB_TRANSFER_TYPE_ISOCHRONOUS == transfer->type)
1826 urb = tpriv->iso_urbs[i];
1828 urb = &tpriv->urbs[i];
1830 if (0 == ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, urb))
1833 if (EINVAL == errno) {
1834 usbi_dbg("URB not found --> assuming ready to be reaped");
1835 if (i == (last_plus_one - 1))
1836 ret = LIBUSB_ERROR_NOT_FOUND;
1837 } else if (ENODEV == errno) {
1838 usbi_dbg("Device not found for URB --> assuming ready to be reaped");
1839 ret = LIBUSB_ERROR_NO_DEVICE;
1841 usbi_warn(TRANSFER_CTX(transfer),
1842 "unrecognised discard errno %d", errno);
1843 ret = LIBUSB_ERROR_OTHER;
1849 static void free_iso_urbs(struct linux_transfer_priv *tpriv)
1852 for (i = 0; i < tpriv->num_urbs; i++) {
1853 struct usbfs_urb *urb = tpriv->iso_urbs[i];
1859 free(tpriv->iso_urbs);
1860 tpriv->iso_urbs = NULL;
1863 static int submit_bulk_transfer(struct usbi_transfer *itransfer)
1865 struct libusb_transfer *transfer =
1866 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1867 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1868 struct linux_device_handle_priv *dpriv =
1869 _device_handle_priv(transfer->dev_handle);
1870 struct usbfs_urb *urbs;
1871 int is_out = (transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK)
1872 == LIBUSB_ENDPOINT_OUT;
1873 int bulk_buffer_len, use_bulk_continuation;
1877 if (is_out && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) &&
1878 !(dpriv->caps & USBFS_CAP_ZERO_PACKET))
1879 return LIBUSB_ERROR_NOT_SUPPORTED;
1882 * Older versions of usbfs place a 16kb limit on bulk URBs. We work
1883 * around this by splitting large transfers into 16k blocks, and then
1884 * submit all urbs at once. it would be simpler to submit one urb at
1885 * a time, but there is a big performance gain doing it this way.
1887 * Newer versions lift the 16k limit (USBFS_CAP_NO_PACKET_SIZE_LIM),
1888 * using arbritary large transfers can still be a bad idea though, as
1889 * the kernel needs to allocate physical contiguous memory for this,
1890 * which may fail for large buffers.
1892 * The kernel solves this problem by splitting the transfer into
1893 * blocks itself when the host-controller is scatter-gather capable
1894 * (USBFS_CAP_BULK_SCATTER_GATHER), which most controllers are.
1896 * Last, there is the issue of short-transfers when splitting, for
1897 * short split-transfers to work reliable USBFS_CAP_BULK_CONTINUATION
1898 * is needed, but this is not always available.
1900 if (dpriv->caps & USBFS_CAP_BULK_SCATTER_GATHER) {
1901 /* Good! Just submit everything in one go */
1902 bulk_buffer_len = transfer->length ? transfer->length : 1;
1903 use_bulk_continuation = 0;
1904 } else if (dpriv->caps & USBFS_CAP_BULK_CONTINUATION) {
1905 /* Split the transfers and use bulk-continuation to
1906 avoid issues with short-transfers */
1907 bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
1908 use_bulk_continuation = 1;
1909 } else if (dpriv->caps & USBFS_CAP_NO_PACKET_SIZE_LIM) {
1910 /* Don't split, assume the kernel can alloc the buffer
1911 (otherwise the submit will fail with -ENOMEM) */
1912 bulk_buffer_len = transfer->length ? transfer->length : 1;
1913 use_bulk_continuation = 0;
1915 /* Bad, splitting without bulk-continuation, short transfers
1916 which end before the last urb will not work reliable! */
1917 /* Note we don't warn here as this is "normal" on kernels <
1918 2.6.32 and not a problem for most applications */
1919 bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
1920 use_bulk_continuation = 0;
1923 int num_urbs = transfer->length / bulk_buffer_len;
1924 int last_urb_partial = 0;
1926 if (transfer->length == 0) {
1928 } else if ((transfer->length % bulk_buffer_len) > 0) {
1929 last_urb_partial = 1;
1932 usbi_dbg("need %d urbs for new transfer with length %d", num_urbs,
1934 urbs = calloc(num_urbs, sizeof(struct usbfs_urb));
1936 return LIBUSB_ERROR_NO_MEM;
1938 tpriv->num_urbs = num_urbs;
1939 tpriv->num_retired = 0;
1940 tpriv->reap_action = NORMAL;
1941 tpriv->reap_status = LIBUSB_TRANSFER_COMPLETED;
1943 for (i = 0; i < num_urbs; i++) {
1944 struct usbfs_urb *urb = &urbs[i];
1945 urb->usercontext = itransfer;
1946 switch (transfer->type) {
1947 case LIBUSB_TRANSFER_TYPE_BULK:
1948 urb->type = USBFS_URB_TYPE_BULK;
1951 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
1952 urb->type = USBFS_URB_TYPE_BULK;
1953 urb->stream_id = itransfer->stream_id;
1955 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1956 urb->type = USBFS_URB_TYPE_INTERRUPT;
1959 urb->endpoint = transfer->endpoint;
1960 urb->buffer = transfer->buffer + (i * bulk_buffer_len);
1961 /* don't set the short not ok flag for the last URB */
1962 if (use_bulk_continuation && !is_out && (i < num_urbs - 1))
1963 urb->flags = USBFS_URB_SHORT_NOT_OK;
1964 if (i == num_urbs - 1 && last_urb_partial)
1965 urb->buffer_length = transfer->length % bulk_buffer_len;
1966 else if (transfer->length == 0)
1967 urb->buffer_length = 0;
1969 urb->buffer_length = bulk_buffer_len;
1971 if (i > 0 && use_bulk_continuation)
1972 urb->flags |= USBFS_URB_BULK_CONTINUATION;
1974 /* we have already checked that the flag is supported */
1975 if (is_out && i == num_urbs - 1 &&
1976 transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET)
1977 urb->flags |= USBFS_URB_ZERO_PACKET;
1979 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
1981 if (errno == ENODEV) {
1982 r = LIBUSB_ERROR_NO_DEVICE;
1984 usbi_err(TRANSFER_CTX(transfer),
1985 "submiturb failed error %d errno=%d", r, errno);
1986 r = LIBUSB_ERROR_IO;
1989 /* if the first URB submission fails, we can simply free up and
1990 * return failure immediately. */
1992 usbi_dbg("first URB failed, easy peasy");
1998 /* if it's not the first URB that failed, the situation is a bit
1999 * tricky. we may need to discard all previous URBs. there are
2001 * - discarding is asynchronous - discarded urbs will be reaped
2002 * later. the user must not have freed the transfer when the
2003 * discarded URBs are reaped, otherwise libusb will be using
2005 * - the earlier URBs may have completed successfully and we do
2006 * not want to throw away any data.
2007 * - this URB failing may be no error; EREMOTEIO means that
2008 * this transfer simply didn't need all the URBs we submitted
2009 * so, we report that the transfer was submitted successfully and
2010 * in case of error we discard all previous URBs. later when
2011 * the final reap completes we can report error to the user,
2012 * or success if an earlier URB was completed successfully.
2014 tpriv->reap_action = EREMOTEIO == errno ? COMPLETED_EARLY : SUBMIT_FAILED;
2016 /* The URBs we haven't submitted yet we count as already
2018 tpriv->num_retired += num_urbs - i;
2020 /* If we completed short then don't try to discard. */
2021 if (COMPLETED_EARLY == tpriv->reap_action)
2024 discard_urbs(itransfer, 0, i);
2026 usbi_dbg("reporting successful submission but waiting for %d "
2027 "discards before reporting error", i);
2035 static int submit_iso_transfer(struct usbi_transfer *itransfer)
2037 struct libusb_transfer *transfer =
2038 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2039 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2040 struct linux_device_handle_priv *dpriv =
2041 _device_handle_priv(transfer->dev_handle);
2042 struct usbfs_urb **urbs;
2043 int num_packets = transfer->num_iso_packets;
2044 int num_packets_remaining;
2047 unsigned int packet_len;
2048 unsigned int total_len = 0;
2049 unsigned char *urb_buffer = transfer->buffer;
2051 if (num_packets < 1)
2052 return LIBUSB_ERROR_INVALID_PARAM;
2054 /* usbfs places arbitrary limits on iso URBs. this limit has changed
2055 * at least three times, but we attempt to detect this limit during
2056 * init and check it here. if the kernel rejects the request due to
2057 * its size, we return an error indicating such to the user.
2059 for (i = 0; i < num_packets; i++) {
2060 packet_len = transfer->iso_packet_desc[i].length;
2062 if (packet_len > max_iso_packet_len) {
2063 usbi_warn(TRANSFER_CTX(transfer),
2064 "iso packet length of %u bytes exceeds maximum of %u bytes",
2065 packet_len, max_iso_packet_len);
2066 return LIBUSB_ERROR_INVALID_PARAM;
2069 total_len += packet_len;
2072 if (transfer->length < (int)total_len)
2073 return LIBUSB_ERROR_INVALID_PARAM;
2075 /* usbfs limits the number of iso packets per URB */
2076 num_urbs = (num_packets + (MAX_ISO_PACKETS_PER_URB - 1)) / MAX_ISO_PACKETS_PER_URB;
2078 usbi_dbg("need %d urbs for new transfer with length %d", num_urbs,
2081 urbs = calloc(num_urbs, sizeof(*urbs));
2083 return LIBUSB_ERROR_NO_MEM;
2085 tpriv->iso_urbs = urbs;
2086 tpriv->num_urbs = num_urbs;
2087 tpriv->num_retired = 0;
2088 tpriv->reap_action = NORMAL;
2089 tpriv->iso_packet_offset = 0;
2091 /* allocate + initialize each URB with the correct number of packets */
2092 num_packets_remaining = num_packets;
2093 for (i = 0, j = 0; i < num_urbs; i++) {
2094 int num_packets_in_urb = MIN(num_packets_remaining, MAX_ISO_PACKETS_PER_URB);
2095 struct usbfs_urb *urb;
2099 alloc_size = sizeof(*urb)
2100 + (num_packets_in_urb * sizeof(struct usbfs_iso_packet_desc));
2101 urb = calloc(1, alloc_size);
2103 free_iso_urbs(tpriv);
2104 return LIBUSB_ERROR_NO_MEM;
2108 /* populate packet lengths */
2109 for (k = 0; k < num_packets_in_urb; j++, k++) {
2110 packet_len = transfer->iso_packet_desc[j].length;
2111 urb->buffer_length += packet_len;
2112 urb->iso_frame_desc[k].length = packet_len;
2115 urb->usercontext = itransfer;
2116 urb->type = USBFS_URB_TYPE_ISO;
2117 /* FIXME: interface for non-ASAP data? */
2118 urb->flags = USBFS_URB_ISO_ASAP;
2119 urb->endpoint = transfer->endpoint;
2120 urb->number_of_packets = num_packets_in_urb;
2121 urb->buffer = urb_buffer;
2123 urb_buffer += urb->buffer_length;
2124 num_packets_remaining -= num_packets_in_urb;
2128 for (i = 0; i < num_urbs; i++) {
2129 int r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urbs[i]);
2131 if (errno == ENODEV) {
2132 r = LIBUSB_ERROR_NO_DEVICE;
2133 } else if (errno == EINVAL) {
2134 usbi_warn(TRANSFER_CTX(transfer),
2135 "submiturb failed, transfer too large");
2136 r = LIBUSB_ERROR_INVALID_PARAM;
2137 } else if (errno == EMSGSIZE) {
2138 usbi_warn(TRANSFER_CTX(transfer),
2139 "submiturb failed, iso packet length too large");
2140 r = LIBUSB_ERROR_INVALID_PARAM;
2142 usbi_err(TRANSFER_CTX(transfer),
2143 "submiturb failed error %d errno=%d", r, errno);
2144 r = LIBUSB_ERROR_IO;
2147 /* if the first URB submission fails, we can simply free up and
2148 * return failure immediately. */
2150 usbi_dbg("first URB failed, easy peasy");
2151 free_iso_urbs(tpriv);
2155 /* if it's not the first URB that failed, the situation is a bit
2156 * tricky. we must discard all previous URBs. there are
2158 * - discarding is asynchronous - discarded urbs will be reaped
2159 * later. the user must not have freed the transfer when the
2160 * discarded URBs are reaped, otherwise libusb will be using
2162 * - the earlier URBs may have completed successfully and we do
2163 * not want to throw away any data.
2164 * so, in this case we discard all the previous URBs BUT we report
2165 * that the transfer was submitted successfully. then later when
2166 * the final discard completes we can report error to the user.
2168 tpriv->reap_action = SUBMIT_FAILED;
2170 /* The URBs we haven't submitted yet we count as already
2172 tpriv->num_retired = num_urbs - i;
2173 discard_urbs(itransfer, 0, i);
2175 usbi_dbg("reporting successful submission but waiting for %d "
2176 "discards before reporting error", i);
2184 static int submit_control_transfer(struct usbi_transfer *itransfer)
2186 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2187 struct libusb_transfer *transfer =
2188 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2189 struct linux_device_handle_priv *dpriv =
2190 _device_handle_priv(transfer->dev_handle);
2191 struct usbfs_urb *urb;
2194 if (transfer->length - LIBUSB_CONTROL_SETUP_SIZE > MAX_CTRL_BUFFER_LENGTH)
2195 return LIBUSB_ERROR_INVALID_PARAM;
2197 urb = calloc(1, sizeof(struct usbfs_urb));
2199 return LIBUSB_ERROR_NO_MEM;
2201 tpriv->num_urbs = 1;
2202 tpriv->reap_action = NORMAL;
2204 urb->usercontext = itransfer;
2205 urb->type = USBFS_URB_TYPE_CONTROL;
2206 urb->endpoint = transfer->endpoint;
2207 urb->buffer = transfer->buffer;
2208 urb->buffer_length = transfer->length;
2210 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
2214 if (errno == ENODEV)
2215 return LIBUSB_ERROR_NO_DEVICE;
2217 usbi_err(TRANSFER_CTX(transfer),
2218 "submiturb failed error %d errno=%d", r, errno);
2219 return LIBUSB_ERROR_IO;
2224 static int op_submit_transfer(struct usbi_transfer *itransfer)
2226 struct libusb_transfer *transfer =
2227 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2229 switch (transfer->type) {
2230 case LIBUSB_TRANSFER_TYPE_CONTROL:
2231 return submit_control_transfer(itransfer);
2232 case LIBUSB_TRANSFER_TYPE_BULK:
2233 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2234 return submit_bulk_transfer(itransfer);
2235 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2236 return submit_bulk_transfer(itransfer);
2237 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2238 return submit_iso_transfer(itransfer);
2240 usbi_err(TRANSFER_CTX(transfer),
2241 "unknown endpoint type %d", transfer->type);
2242 return LIBUSB_ERROR_INVALID_PARAM;
2246 static int op_cancel_transfer(struct usbi_transfer *itransfer)
2248 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2249 struct libusb_transfer *transfer =
2250 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2254 return LIBUSB_ERROR_NOT_FOUND;
2256 r = discard_urbs(itransfer, 0, tpriv->num_urbs);
2260 switch (transfer->type) {
2261 case LIBUSB_TRANSFER_TYPE_BULK:
2262 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2263 if (tpriv->reap_action == ERROR)
2265 /* else, fall through */
2267 tpriv->reap_action = CANCELLED;
2273 static void op_clear_transfer_priv(struct usbi_transfer *itransfer)
2275 struct libusb_transfer *transfer =
2276 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2277 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2279 switch (transfer->type) {
2280 case LIBUSB_TRANSFER_TYPE_CONTROL:
2281 case LIBUSB_TRANSFER_TYPE_BULK:
2282 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2283 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2289 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2290 if (tpriv->iso_urbs) {
2291 free_iso_urbs(tpriv);
2292 tpriv->iso_urbs = NULL;
2296 usbi_err(TRANSFER_CTX(transfer),
2297 "unknown endpoint type %d", transfer->type);
2301 static int handle_bulk_completion(struct usbi_transfer *itransfer,
2302 struct usbfs_urb *urb)
2304 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2305 struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2306 int urb_idx = urb - tpriv->urbs;
2308 usbi_mutex_lock(&itransfer->lock);
2309 usbi_dbg("handling completion status %d of bulk urb %d/%d", urb->status,
2310 urb_idx + 1, tpriv->num_urbs);
2312 tpriv->num_retired++;
2314 if (tpriv->reap_action != NORMAL) {
2315 /* cancelled, submit_fail, or completed early */
2316 usbi_dbg("abnormal reap: urb status %d", urb->status);
2318 /* even though we're in the process of cancelling, it's possible that
2319 * we may receive some data in these URBs that we don't want to lose.
2321 * 1. while the kernel is cancelling all the packets that make up an
2322 * URB, a few of them might complete. so we get back a successful
2323 * cancellation *and* some data.
2324 * 2. we receive a short URB which marks the early completion condition,
2325 * so we start cancelling the remaining URBs. however, we're too
2326 * slow and another URB completes (or at least completes partially).
2327 * (this can't happen since we always use BULK_CONTINUATION.)
2329 * When this happens, our objectives are not to lose any "surplus" data,
2330 * and also to stick it at the end of the previously-received data
2331 * (closing any holes), so that libusb reports the total amount of
2332 * transferred data and presents it in a contiguous chunk.
2334 if (urb->actual_length > 0) {
2335 unsigned char *target = transfer->buffer + itransfer->transferred;
2336 usbi_dbg("received %d bytes of surplus data", urb->actual_length);
2337 if (urb->buffer != target) {
2338 usbi_dbg("moving surplus data from offset %d to offset %d",
2339 (unsigned char *) urb->buffer - transfer->buffer,
2340 target - transfer->buffer);
2341 memmove(target, urb->buffer, urb->actual_length);
2343 itransfer->transferred += urb->actual_length;
2346 if (tpriv->num_retired == tpriv->num_urbs) {
2347 usbi_dbg("abnormal reap: last URB handled, reporting");
2348 if (tpriv->reap_action != COMPLETED_EARLY &&
2349 tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2350 tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
2356 itransfer->transferred += urb->actual_length;
2358 /* Many of these errors can occur on *any* urb of a multi-urb
2359 * transfer. When they do, we tear down the rest of the transfer.
2361 switch (urb->status) {
2364 case -EREMOTEIO: /* short transfer */
2366 case -ENOENT: /* cancelled */
2371 usbi_dbg("device removed");
2372 tpriv->reap_status = LIBUSB_TRANSFER_NO_DEVICE;
2373 goto cancel_remaining;
2375 usbi_dbg("detected endpoint stall");
2376 if (tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2377 tpriv->reap_status = LIBUSB_TRANSFER_STALL;
2378 goto cancel_remaining;
2380 /* overflow can only ever occur in the last urb */
2381 usbi_dbg("overflow, actual_length=%d", urb->actual_length);
2382 if (tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2383 tpriv->reap_status = LIBUSB_TRANSFER_OVERFLOW;
2390 usbi_dbg("low level error %d", urb->status);
2391 tpriv->reap_action = ERROR;
2392 goto cancel_remaining;
2394 usbi_warn(ITRANSFER_CTX(itransfer),
2395 "unrecognised urb status %d", urb->status);
2396 tpriv->reap_action = ERROR;
2397 goto cancel_remaining;
2400 /* if we're the last urb or we got less data than requested then we're
2402 if (urb_idx == tpriv->num_urbs - 1) {
2403 usbi_dbg("last URB in transfer --> complete!");
2405 } else if (urb->actual_length < urb->buffer_length) {
2406 usbi_dbg("short transfer %d/%d --> complete!",
2407 urb->actual_length, urb->buffer_length);
2408 if (tpriv->reap_action == NORMAL)
2409 tpriv->reap_action = COMPLETED_EARLY;
2414 if (ERROR == tpriv->reap_action && LIBUSB_TRANSFER_COMPLETED == tpriv->reap_status)
2415 tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
2417 if (tpriv->num_retired == tpriv->num_urbs) /* nothing to cancel */
2420 /* cancel remaining urbs and wait for their completion before
2421 * reporting results */
2422 discard_urbs(itransfer, urb_idx + 1, tpriv->num_urbs);
2425 usbi_mutex_unlock(&itransfer->lock);
2431 usbi_mutex_unlock(&itransfer->lock);
2432 return CANCELLED == tpriv->reap_action ?
2433 usbi_handle_transfer_cancellation(itransfer) :
2434 usbi_handle_transfer_completion(itransfer, tpriv->reap_status);
2437 static int handle_iso_completion(struct usbi_transfer *itransfer,
2438 struct usbfs_urb *urb)
2440 struct libusb_transfer *transfer =
2441 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2442 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2443 int num_urbs = tpriv->num_urbs;
2446 enum libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
2448 usbi_mutex_lock(&itransfer->lock);
2449 for (i = 0; i < num_urbs; i++) {
2450 if (urb == tpriv->iso_urbs[i]) {
2456 usbi_err(TRANSFER_CTX(transfer), "could not locate urb!");
2457 usbi_mutex_unlock(&itransfer->lock);
2458 return LIBUSB_ERROR_NOT_FOUND;
2461 usbi_dbg("handling completion status %d of iso urb %d/%d", urb->status,
2464 /* copy isochronous results back in */
2466 for (i = 0; i < urb->number_of_packets; i++) {
2467 struct usbfs_iso_packet_desc *urb_desc = &urb->iso_frame_desc[i];
2468 struct libusb_iso_packet_descriptor *lib_desc =
2469 &transfer->iso_packet_desc[tpriv->iso_packet_offset++];
2470 lib_desc->status = LIBUSB_TRANSFER_COMPLETED;
2471 switch (urb_desc->status) {
2474 case -ENOENT: /* cancelled */
2479 usbi_dbg("device removed");
2480 lib_desc->status = LIBUSB_TRANSFER_NO_DEVICE;
2483 usbi_dbg("detected endpoint stall");
2484 lib_desc->status = LIBUSB_TRANSFER_STALL;
2487 usbi_dbg("overflow error");
2488 lib_desc->status = LIBUSB_TRANSFER_OVERFLOW;
2496 usbi_dbg("low-level USB error %d", urb_desc->status);
2497 lib_desc->status = LIBUSB_TRANSFER_ERROR;
2500 usbi_warn(TRANSFER_CTX(transfer),
2501 "unrecognised urb status %d", urb_desc->status);
2502 lib_desc->status = LIBUSB_TRANSFER_ERROR;
2505 lib_desc->actual_length = urb_desc->actual_length;
2508 tpriv->num_retired++;
2510 if (tpriv->reap_action != NORMAL) { /* cancelled or submit_fail */
2511 usbi_dbg("CANCEL: urb status %d", urb->status);
2513 if (tpriv->num_retired == num_urbs) {
2514 usbi_dbg("CANCEL: last URB handled, reporting");
2515 free_iso_urbs(tpriv);
2516 if (tpriv->reap_action == CANCELLED) {
2517 usbi_mutex_unlock(&itransfer->lock);
2518 return usbi_handle_transfer_cancellation(itransfer);
2520 usbi_mutex_unlock(&itransfer->lock);
2521 return usbi_handle_transfer_completion(itransfer,
2522 LIBUSB_TRANSFER_ERROR);
2528 switch (urb->status) {
2531 case -ENOENT: /* cancelled */
2535 usbi_dbg("device removed");
2536 status = LIBUSB_TRANSFER_NO_DEVICE;
2539 usbi_warn(TRANSFER_CTX(transfer),
2540 "unrecognised urb status %d", urb->status);
2541 status = LIBUSB_TRANSFER_ERROR;
2545 /* if we're the last urb then we're done */
2546 if (urb_idx == num_urbs) {
2547 usbi_dbg("last URB in transfer --> complete!");
2548 free_iso_urbs(tpriv);
2549 usbi_mutex_unlock(&itransfer->lock);
2550 return usbi_handle_transfer_completion(itransfer, status);
2554 usbi_mutex_unlock(&itransfer->lock);
2558 static int handle_control_completion(struct usbi_transfer *itransfer,
2559 struct usbfs_urb *urb)
2561 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2564 usbi_mutex_lock(&itransfer->lock);
2565 usbi_dbg("handling completion status %d", urb->status);
2567 itransfer->transferred += urb->actual_length;
2569 if (tpriv->reap_action == CANCELLED) {
2570 if (urb->status != 0 && urb->status != -ENOENT)
2571 usbi_warn(ITRANSFER_CTX(itransfer),
2572 "cancel: unrecognised urb status %d", urb->status);
2575 usbi_mutex_unlock(&itransfer->lock);
2576 return usbi_handle_transfer_cancellation(itransfer);
2579 switch (urb->status) {
2581 status = LIBUSB_TRANSFER_COMPLETED;
2583 case -ENOENT: /* cancelled */
2584 status = LIBUSB_TRANSFER_CANCELLED;
2588 usbi_dbg("device removed");
2589 status = LIBUSB_TRANSFER_NO_DEVICE;
2592 usbi_dbg("unsupported control request");
2593 status = LIBUSB_TRANSFER_STALL;
2596 usbi_dbg("control overflow error");
2597 status = LIBUSB_TRANSFER_OVERFLOW;
2604 usbi_dbg("low-level bus error occurred");
2605 status = LIBUSB_TRANSFER_ERROR;
2608 usbi_warn(ITRANSFER_CTX(itransfer),
2609 "unrecognised urb status %d", urb->status);
2610 status = LIBUSB_TRANSFER_ERROR;
2616 usbi_mutex_unlock(&itransfer->lock);
2617 return usbi_handle_transfer_completion(itransfer, status);
2620 static int reap_for_handle(struct libusb_device_handle *handle)
2622 struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
2624 struct usbfs_urb *urb;
2625 struct usbi_transfer *itransfer;
2626 struct libusb_transfer *transfer;
2628 r = ioctl(hpriv->fd, IOCTL_USBFS_REAPURBNDELAY, &urb);
2629 if (r == -1 && errno == EAGAIN)
2632 if (errno == ENODEV)
2633 return LIBUSB_ERROR_NO_DEVICE;
2635 usbi_err(HANDLE_CTX(handle), "reap failed error %d errno=%d",
2637 return LIBUSB_ERROR_IO;
2640 itransfer = urb->usercontext;
2641 transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2643 usbi_dbg("urb type=%d status=%d transferred=%d", urb->type, urb->status,
2644 urb->actual_length);
2646 switch (transfer->type) {
2647 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2648 return handle_iso_completion(itransfer, urb);
2649 case LIBUSB_TRANSFER_TYPE_BULK:
2650 case LIBUSB_TRANSFER_TYPE_BULK_STREAM:
2651 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2652 return handle_bulk_completion(itransfer, urb);
2653 case LIBUSB_TRANSFER_TYPE_CONTROL:
2654 return handle_control_completion(itransfer, urb);
2656 usbi_err(HANDLE_CTX(handle), "unrecognised endpoint type %x",
2658 return LIBUSB_ERROR_OTHER;
2662 static int op_handle_events(struct libusb_context *ctx,
2663 struct pollfd *fds, POLL_NFDS_TYPE nfds, int num_ready)
2668 usbi_mutex_lock(&ctx->open_devs_lock);
2669 for (i = 0; i < nfds && num_ready > 0; i++) {
2670 struct pollfd *pollfd = &fds[i];
2671 struct libusb_device_handle *handle;
2672 struct linux_device_handle_priv *hpriv = NULL;
2674 if (!pollfd->revents)
2678 list_for_each_entry(handle, &ctx->open_devs, list, struct libusb_device_handle) {
2679 hpriv = _device_handle_priv(handle);
2680 if (hpriv->fd == pollfd->fd)
2684 if (!hpriv || hpriv->fd != pollfd->fd) {
2685 usbi_err(ctx, "cannot find handle for fd %d",
2690 if (pollfd->revents & POLLERR) {
2691 /* remove the fd from the pollfd set so that it doesn't continuously
2692 * trigger an event, and flag that it has been removed so op_close()
2693 * doesn't try to remove it a second time */
2694 usbi_remove_pollfd(HANDLE_CTX(handle), hpriv->fd);
2695 hpriv->fd_removed = 1;
2697 /* device will still be marked as attached if hotplug monitor thread
2698 * hasn't processed remove event yet */
2699 usbi_mutex_static_lock(&linux_hotplug_lock);
2700 if (handle->dev->attached)
2701 linux_device_disconnected(handle->dev->bus_number,
2702 handle->dev->device_address);
2703 usbi_mutex_static_unlock(&linux_hotplug_lock);
2705 if (hpriv->caps & USBFS_CAP_REAP_AFTER_DISCONNECT) {
2707 r = reap_for_handle(handle);
2711 usbi_handle_disconnect(handle);
2716 r = reap_for_handle(handle);
2718 if (r == 1 || r == LIBUSB_ERROR_NO_DEVICE)
2726 usbi_mutex_unlock(&ctx->open_devs_lock);
2730 static int op_clock_gettime(int clk_id, struct timespec *tp)
2733 case USBI_CLOCK_MONOTONIC:
2734 return clock_gettime(monotonic_clkid, tp);
2735 case USBI_CLOCK_REALTIME:
2736 return clock_gettime(CLOCK_REALTIME, tp);
2738 return LIBUSB_ERROR_INVALID_PARAM;
2742 #ifdef USBI_TIMERFD_AVAILABLE
2743 static clockid_t op_get_timerfd_clockid(void)
2745 return monotonic_clkid;
2750 const struct usbi_os_backend usbi_backend = {
2751 .name = "Linux usbfs",
2752 .caps = USBI_CAP_HAS_HID_ACCESS|USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER,
2755 .get_device_list = NULL,
2756 .hotplug_poll = op_hotplug_poll,
2757 .get_device_descriptor = op_get_device_descriptor,
2758 .get_active_config_descriptor = op_get_active_config_descriptor,
2759 .get_config_descriptor = op_get_config_descriptor,
2760 .get_config_descriptor_by_value = op_get_config_descriptor_by_value,
2764 .get_configuration = op_get_configuration,
2765 .set_configuration = op_set_configuration,
2766 .claim_interface = op_claim_interface,
2767 .release_interface = op_release_interface,
2769 .set_interface_altsetting = op_set_interface,
2770 .clear_halt = op_clear_halt,
2771 .reset_device = op_reset_device,
2773 .alloc_streams = op_alloc_streams,
2774 .free_streams = op_free_streams,
2776 .dev_mem_alloc = op_dev_mem_alloc,
2777 .dev_mem_free = op_dev_mem_free,
2779 .kernel_driver_active = op_kernel_driver_active,
2780 .detach_kernel_driver = op_detach_kernel_driver,
2781 .attach_kernel_driver = op_attach_kernel_driver,
2783 .destroy_device = op_destroy_device,
2785 .submit_transfer = op_submit_transfer,
2786 .cancel_transfer = op_cancel_transfer,
2787 .clear_transfer_priv = op_clear_transfer_priv,
2789 .handle_events = op_handle_events,
2791 .clock_gettime = op_clock_gettime,
2793 #ifdef USBI_TIMERFD_AVAILABLE
2794 .get_timerfd_clockid = op_get_timerfd_clockid,
2797 .device_priv_size = sizeof(struct linux_device_priv),
2798 .device_handle_priv_size = sizeof(struct linux_device_handle_priv),
2799 .transfer_priv_size = sizeof(struct linux_transfer_priv),