2 * Linux usbfs backend for libusbx
3 * Copyright © 2007-2009 Daniel Drake <dsd@gentoo.org>
4 * Copyright © 2001 Johannes Erdfelt <johannes@erdfelt.com>
5 * Copyright © 2013 Nathan Hjelm <hjelmn@mac.com>
6 * Copyright © 2012-2013 Hans de Goede <hdegoede@redhat.com>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34 #include <sys/ioctl.h>
36 #include <sys/types.h>
37 #include <sys/utsname.h>
42 #include "linux_usbfs.h"
45 * opening a usbfs node causes the device to be resumed, so we attempt to
46 * avoid this during enumeration.
48 * sysfs allows us to read the kernel's in-memory copies of device descriptors
49 * and so forth, avoiding the need to open the device:
50 * - The binary "descriptors" file contains all config descriptors since
51 * 2.6.26, commit 217a9081d8e69026186067711131b77f0ce219ed
52 * - The binary "descriptors" file was added in 2.6.23, commit
53 * 69d42a78f935d19384d1f6e4f94b65bb162b36df, but it only contains the
54 * active config descriptors
55 * - The "busnum" file was added in 2.6.22, commit
56 * 83f7d958eab2fbc6b159ee92bf1493924e1d0f72
57 * - The "devnum" file has been present since pre-2.6.18
58 * - the "bConfigurationValue" file has been present since pre-2.6.18
60 * If we have bConfigurationValue, busnum, and devnum, then we can determine
61 * the active configuration without having to open the usbfs node in RDWR mode.
62 * The busnum file is important as that is the only way we can relate sysfs
63 * devices to usbfs nodes.
65 * If we also have all descriptors, we can obtain the device descriptor and
66 * configuration without touching usbfs at all.
69 /* endianness for multi-byte fields:
71 * Descriptors exposed by usbfs have the multi-byte fields in the device
72 * descriptor as host endian. Multi-byte fields in the other descriptors are
73 * bus-endian. The kernel documentation says otherwise, but it is wrong.
75 * In sysfs all descriptors are bus-endian.
78 static const char *usbfs_path = NULL;
80 /* use usbdev*.* device names in /dev instead of the usbfs bus directories */
81 static int usbdev_names = 0;
83 /* Linux 2.6.32 adds support for a bulk continuation URB flag. this basically
84 * allows us to mark URBs as being part of a specific logical transfer when
85 * we submit them to the kernel. then, on any error except a cancellation, all
86 * URBs within that transfer will be cancelled and no more URBs will be
87 * accepted for the transfer, meaning that no more data can creep in.
89 * The BULK_CONTINUATION flag must be set on all URBs within a bulk transfer
90 * (in either direction) except the first.
91 * For IN transfers, we must also set SHORT_NOT_OK on all URBs except the
92 * last; it means that the kernel should treat a short reply as an error.
93 * For OUT transfers, SHORT_NOT_OK must not be set. it isn't needed (OUT
94 * transfers can't be short unless there's already some sort of error), and
95 * setting this flag is disallowed (a kernel with USB debugging enabled will
98 static int supports_flag_bulk_continuation = -1;
100 /* Linux 2.6.31 fixes support for the zero length packet URB flag. This
101 * allows us to mark URBs that should be followed by a zero length data
102 * packet, which can be required by device- or class-specific protocols.
104 static int supports_flag_zero_packet = -1;
106 /* clock ID for monotonic clock, as not all clock sources are available on all
107 * systems. appropriate choice made at initialization time. */
108 static clockid_t monotonic_clkid = -1;
110 /* Linux 2.6.22 (commit 83f7d958eab2fbc6b159ee92bf1493924e1d0f72) adds a busnum
111 * to sysfs, so we can relate devices. This also implies that we can read
112 * the active configuration through bConfigurationValue */
113 static int sysfs_can_relate_devices = -1;
115 /* Linux 2.6.26 (commit 217a9081d8e69026186067711131b77f0ce219ed) adds all
116 * config descriptors (rather then just the active config) to the sysfs
117 * descriptors file, so from then on we can use them. */
118 static int sysfs_has_descriptors = -1;
120 /* how many times have we initted (and not exited) ? */
121 static volatile int init_count = 0;
123 /* Serialize hotplug start/stop, scan-devices, event-thread, and poll */
124 usbi_mutex_static_t linux_hotplug_lock = USBI_MUTEX_INITIALIZER;
126 static int linux_start_event_monitor(void);
127 static int linux_stop_event_monitor(void);
128 static int linux_scan_devices(struct libusb_context *ctx);
129 static int sysfs_scan_device(struct libusb_context *ctx, const char *devname);
131 #if !defined(USE_UDEV)
132 static int linux_default_scan_devices (struct libusb_context *ctx);
135 struct linux_device_priv {
137 unsigned char *descriptors;
139 int active_config; /* cache val for !sysfs_can_relate_devices */
142 struct linux_device_handle_priv {
149 /* submission failed after the first URB, so await cancellation/completion
150 * of all the others */
153 /* cancelled by user or timeout */
156 /* completed multi-URB transfer in non-final URB */
159 /* one or more urbs encountered a low-level error */
163 struct linux_transfer_priv {
165 struct usbfs_urb *urbs;
166 struct usbfs_urb **iso_urbs;
169 enum reap_action reap_action;
172 enum libusb_transfer_status reap_status;
174 /* next iso packet in user-supplied transfer to be populated */
175 int iso_packet_offset;
178 static int _get_usbfs_fd(struct libusb_device *dev, mode_t mode, int silent)
180 struct libusb_context *ctx = DEVICE_CTX(dev);
185 snprintf(path, PATH_MAX, "%s/usbdev%d.%d",
186 usbfs_path, dev->bus_number, dev->device_address);
188 snprintf(path, PATH_MAX, "%s/%03d/%03d",
189 usbfs_path, dev->bus_number, dev->device_address);
191 fd = open(path, mode);
193 return fd; /* Success */
196 usbi_err(ctx, "libusbx couldn't open USB device %s: %s",
197 path, strerror(errno));
198 if (errno == EACCES && mode == O_RDWR)
199 usbi_err(ctx, "libusbx requires write access to USB "
204 return LIBUSB_ERROR_ACCESS;
206 return LIBUSB_ERROR_NO_DEVICE;
207 return LIBUSB_ERROR_IO;
210 static struct linux_device_priv *_device_priv(struct libusb_device *dev)
212 return (struct linux_device_priv *) dev->os_priv;
215 static struct linux_device_handle_priv *_device_handle_priv(
216 struct libusb_device_handle *handle)
218 return (struct linux_device_handle_priv *) handle->os_priv;
221 /* check dirent for a /dev/usbdev%d.%d name
222 * optionally return bus/device on success */
223 static int _is_usbdev_entry(struct dirent *entry, int *bus_p, int *dev_p)
227 if (sscanf(entry->d_name, "usbdev%d.%d", &busnum, &devnum) != 2)
230 usbi_dbg("found: %s", entry->d_name);
238 static int check_usb_vfs(const char *dirname)
241 struct dirent *entry;
244 dir = opendir(dirname);
248 while ((entry = readdir(dir)) != NULL) {
249 if (entry->d_name[0] == '.')
252 /* We assume if we find any files that it must be the right place */
261 static const char *find_usbfs_path(void)
263 const char *path = "/dev/bus/usb";
264 const char *ret = NULL;
266 if (check_usb_vfs(path)) {
269 path = "/proc/bus/usb";
270 if (check_usb_vfs(path))
274 /* look for /dev/usbdev*.* if the normal places fail */
276 struct dirent *entry;
282 while ((entry = readdir(dir)) != NULL) {
283 if (_is_usbdev_entry(entry, NULL, NULL)) {
284 /* found one; that's enough */
295 usbi_dbg("found usbfs at %s", ret);
300 /* the monotonic clock is not usable on all systems (e.g. embedded ones often
301 * seem to lack it). fall back to REALTIME if we have to. */
302 static clockid_t find_monotonic_clock(void)
304 #ifdef CLOCK_MONOTONIC
308 /* Linux 2.6.28 adds CLOCK_MONOTONIC_RAW but we don't use it
309 * because it's not available through timerfd */
310 r = clock_gettime(CLOCK_MONOTONIC, &ts);
312 return CLOCK_MONOTONIC;
313 usbi_dbg("monotonic clock doesn't work, errno %d", errno);
316 return CLOCK_REALTIME;
319 static int kernel_version_ge(int major, int minor, int sublevel)
322 int atoms, kmajor, kminor, ksublevel;
326 atoms = sscanf(uts.release, "%d.%d.%d", &kmajor, &kminor, &ksublevel);
335 /* kmajor == major */
337 return 0 == minor && 0 == sublevel;
343 /* kminor == minor */
345 return 0 == sublevel;
347 return ksublevel >= sublevel;
350 static int op_init(struct libusb_context *ctx)
355 usbfs_path = find_usbfs_path();
357 usbi_err(ctx, "could not find usbfs");
358 return LIBUSB_ERROR_OTHER;
361 if (monotonic_clkid == -1)
362 monotonic_clkid = find_monotonic_clock();
364 if (supports_flag_bulk_continuation == -1) {
365 /* bulk continuation URB flag available from Linux 2.6.32 */
366 supports_flag_bulk_continuation = kernel_version_ge(2,6,32);
367 if (supports_flag_bulk_continuation == -1) {
368 usbi_err(ctx, "error checking for bulk continuation support");
369 return LIBUSB_ERROR_OTHER;
373 if (supports_flag_bulk_continuation)
374 usbi_dbg("bulk continuation flag supported");
376 if (-1 == supports_flag_zero_packet) {
377 /* zero length packet URB flag fixed since Linux 2.6.31 */
378 supports_flag_zero_packet = kernel_version_ge(2,6,31);
379 if (-1 == supports_flag_zero_packet) {
380 usbi_err(ctx, "error checking for zero length packet support");
381 return LIBUSB_ERROR_OTHER;
385 if (supports_flag_zero_packet)
386 usbi_dbg("zero length packet flag supported");
388 if (-1 == sysfs_has_descriptors) {
389 /* sysfs descriptors has all descriptors since Linux 2.6.26 */
390 sysfs_has_descriptors = kernel_version_ge(2,6,26);
391 if (-1 == sysfs_has_descriptors) {
392 usbi_err(ctx, "error checking for sysfs descriptors");
393 return LIBUSB_ERROR_OTHER;
397 if (-1 == sysfs_can_relate_devices) {
398 /* sysfs has busnum since Linux 2.6.22 */
399 sysfs_can_relate_devices = kernel_version_ge(2,6,22);
400 if (-1 == sysfs_can_relate_devices) {
401 usbi_err(ctx, "error checking for sysfs busnum");
402 return LIBUSB_ERROR_OTHER;
406 if (sysfs_can_relate_devices || sysfs_has_descriptors) {
407 r = stat(SYSFS_DEVICE_PATH, &statbuf);
408 if (r != 0 || !S_ISDIR(statbuf.st_mode)) {
409 usbi_warn(ctx, "sysfs not mounted");
410 sysfs_can_relate_devices = 0;
411 sysfs_has_descriptors = 0;
415 if (sysfs_can_relate_devices)
416 usbi_dbg("sysfs can relate devices");
418 if (sysfs_has_descriptors)
419 usbi_dbg("sysfs has complete descriptors");
421 usbi_mutex_static_lock(&linux_hotplug_lock);
423 if (init_count == 0) {
424 /* start up hotplug event handler */
425 r = linux_start_event_monitor();
427 if (r == LIBUSB_SUCCESS) {
428 r = linux_scan_devices(ctx);
429 if (r == LIBUSB_SUCCESS)
431 else if (init_count == 0)
432 linux_stop_event_monitor();
434 usbi_err(ctx, "error starting hotplug event monitor");
435 usbi_mutex_static_unlock(&linux_hotplug_lock);
440 static void op_exit(void)
442 usbi_mutex_static_lock(&linux_hotplug_lock);
443 assert(init_count != 0);
445 /* tear down event handler */
446 (void)linux_stop_event_monitor();
448 usbi_mutex_static_unlock(&linux_hotplug_lock);
451 static int linux_start_event_monitor(void)
453 #if defined(USE_UDEV)
454 return linux_udev_start_event_monitor();
456 return linux_netlink_start_event_monitor();
460 static int linux_stop_event_monitor(void)
462 #if defined(USE_UDEV)
463 return linux_udev_stop_event_monitor();
465 return linux_netlink_stop_event_monitor();
469 static int linux_scan_devices(struct libusb_context *ctx)
471 #if defined(USE_UDEV)
472 return linux_udev_scan_devices(ctx);
474 return linux_default_scan_devices(ctx);
478 static void op_hotplug_poll(void)
480 #if defined(USE_UDEV)
481 linux_udev_hotplug_poll();
483 linux_netlink_hotplug_poll();
487 static int _open_sysfs_attr(struct libusb_device *dev, const char *attr)
489 struct linux_device_priv *priv = _device_priv(dev);
490 char filename[PATH_MAX];
493 snprintf(filename, PATH_MAX, "%s/%s/%s",
494 SYSFS_DEVICE_PATH, priv->sysfs_dir, attr);
495 fd = open(filename, O_RDONLY);
497 usbi_err(DEVICE_CTX(dev),
498 "open %s failed ret=%d errno=%d", filename, fd, errno);
499 return LIBUSB_ERROR_IO;
505 /* Note only suitable for attributes which always read >= 0, < 0 is error */
506 static int __read_sysfs_attr(struct libusb_context *ctx,
507 const char *devname, const char *attr)
509 char filename[PATH_MAX];
513 snprintf(filename, PATH_MAX, "%s/%s/%s", SYSFS_DEVICE_PATH,
515 f = fopen(filename, "r");
517 if (errno == ENOENT) {
518 /* File doesn't exist. Assume the device has been
519 disconnected (see trac ticket #70). */
520 return LIBUSB_ERROR_NO_DEVICE;
522 usbi_err(ctx, "open %s failed errno=%d", filename, errno);
523 return LIBUSB_ERROR_IO;
526 r = fscanf(f, "%d", &value);
529 usbi_err(ctx, "fscanf %s returned %d, errno=%d", attr, r, errno);
530 return LIBUSB_ERROR_NO_DEVICE; /* For unplug race (trac #70) */
533 usbi_err(ctx, "%s contains a negative value", filename);
534 return LIBUSB_ERROR_IO;
540 static int op_get_device_descriptor(struct libusb_device *dev,
541 unsigned char *buffer, int *host_endian)
543 struct linux_device_priv *priv = _device_priv(dev);
545 *host_endian = sysfs_has_descriptors ? 0 : 1;
546 memcpy(buffer, priv->descriptors, DEVICE_DESC_LENGTH);
551 /* read the bConfigurationValue for a device */
552 static int sysfs_get_active_config(struct libusb_device *dev, int *config)
555 char tmp[4] = {0, 0, 0, 0};
560 fd = _open_sysfs_attr(dev, "bConfigurationValue");
564 r = read(fd, tmp, sizeof(tmp));
567 usbi_err(DEVICE_CTX(dev),
568 "read bConfigurationValue failed ret=%d errno=%d", r, errno);
569 return LIBUSB_ERROR_IO;
571 usbi_dbg("device unconfigured");
576 if (tmp[sizeof(tmp) - 1] != 0) {
577 usbi_err(DEVICE_CTX(dev), "not null-terminated?");
578 return LIBUSB_ERROR_IO;
579 } else if (tmp[0] == 0) {
580 usbi_err(DEVICE_CTX(dev), "no configuration value?");
581 return LIBUSB_ERROR_IO;
584 num = strtol(tmp, &endptr, 10);
586 usbi_err(DEVICE_CTX(dev), "error converting '%s' to integer", tmp);
587 return LIBUSB_ERROR_IO;
594 int linux_get_device_address (struct libusb_context *ctx, int detached,
595 uint8_t *busnum, uint8_t *devaddr,const char *dev_node,
596 const char *sys_name)
598 usbi_dbg("getting address for device: %s detached: %d", sys_name, detached);
599 /* can't use sysfs to read the bus and device number if the
600 * device has been detached */
601 if (!sysfs_can_relate_devices || detached || NULL == sys_name) {
602 if (NULL == dev_node) {
603 return LIBUSB_ERROR_OTHER;
606 /* will this work with all supported kernel versions? */
607 if (!strncmp(dev_node, "/dev/bus/usb", 12)) {
608 sscanf (dev_node, "/dev/bus/usb/%hhd/%hhd", busnum, devaddr);
609 } else if (!strncmp(dev_node, "/proc/bus/usb", 13)) {
610 sscanf (dev_node, "/proc/bus/usb/%hhd/%hhd", busnum, devaddr);
613 return LIBUSB_SUCCESS;
616 usbi_dbg("scan %s", sys_name);
618 *busnum = __read_sysfs_attr(ctx, sys_name, "busnum");
622 *devaddr = __read_sysfs_attr(ctx, sys_name, "devnum");
626 usbi_dbg("bus=%d dev=%d", *busnum, *devaddr);
627 if (*busnum > 255 || *devaddr > 255)
628 return LIBUSB_ERROR_INVALID_PARAM;
630 return LIBUSB_SUCCESS;
633 /* Return offset of the next descriptor with the given type */
634 static int seek_to_next_descriptor(struct libusb_context *ctx,
635 uint8_t descriptor_type, unsigned char *buffer, int size)
637 struct usb_descriptor_header header;
640 for (i = 0; size >= 0; i += header.bLength, size -= header.bLength) {
642 return LIBUSB_ERROR_NOT_FOUND;
645 usbi_err(ctx, "short descriptor read %d/2", size);
646 return LIBUSB_ERROR_IO;
648 usbi_parse_descriptor(buffer + i, "bb", &header, 0);
650 if (i && header.bDescriptorType == descriptor_type)
653 usbi_err(ctx, "bLength overflow by %d bytes", -size);
654 return LIBUSB_ERROR_IO;
657 /* Return offset to next config */
658 static int seek_to_next_config(struct libusb_context *ctx,
659 unsigned char *buffer, int size)
661 struct libusb_config_descriptor config;
664 return LIBUSB_ERROR_NOT_FOUND;
666 if (size < LIBUSB_DT_CONFIG_SIZE) {
667 usbi_err(ctx, "short descriptor read %d/%d",
668 size, LIBUSB_DT_CONFIG_SIZE);
669 return LIBUSB_ERROR_IO;
672 usbi_parse_descriptor(buffer, "bbwbbbbb", &config, 0);
673 if (config.bDescriptorType != LIBUSB_DT_CONFIG) {
674 usbi_err(ctx, "descriptor is not a config desc (type 0x%02x)",
675 config.bDescriptorType);
676 return LIBUSB_ERROR_IO;
680 * In usbfs the config descriptors are config.wTotalLength bytes apart,
681 * with any short reads from the device appearing as holes in the file.
683 * In sysfs wTotalLength is ignored, instead the kernel returns a
684 * config descriptor with verified bLength fields, with descriptors
685 * with an invalid bLength removed.
687 if (sysfs_has_descriptors) {
688 int next = seek_to_next_descriptor(ctx, LIBUSB_DT_CONFIG,
690 if (next == LIBUSB_ERROR_NOT_FOUND)
695 if (next != config.wTotalLength)
696 usbi_warn(ctx, "config length mismatch wTotalLength "
697 "%d real %d", config.wTotalLength, next);
700 if (config.wTotalLength < LIBUSB_DT_CONFIG_SIZE) {
701 usbi_err(ctx, "invalid wTotalLength %d",
702 config.wTotalLength);
703 return LIBUSB_ERROR_IO;
704 } else if (config.wTotalLength > size) {
705 usbi_warn(ctx, "short descriptor read %d/%d",
706 size, config.wTotalLength);
709 return config.wTotalLength;
713 static int op_get_config_descriptor_by_value(struct libusb_device *dev,
714 uint8_t value, unsigned char **buffer, int *host_endian)
716 struct libusb_context *ctx = DEVICE_CTX(dev);
717 struct linux_device_priv *priv = _device_priv(dev);
718 unsigned char *descriptors = priv->descriptors;
719 int size = priv->descriptors_len;
720 struct libusb_config_descriptor *config;
723 /* Unlike the device desc. config descs. are always in raw format */
726 /* Skip device header */
727 descriptors += DEVICE_DESC_LENGTH;
728 size -= DEVICE_DESC_LENGTH;
730 /* Seek till the config is found, or till "EOF" */
732 int next = seek_to_next_config(ctx, descriptors, size);
735 config = (struct libusb_config_descriptor *)descriptors;
736 if (config->bConfigurationValue == value) {
737 *buffer = descriptors;
745 static int op_get_active_config_descriptor(struct libusb_device *dev,
746 unsigned char *buffer, size_t len, int *host_endian)
749 unsigned char *config_desc;
751 if (sysfs_can_relate_devices) {
752 r = sysfs_get_active_config(dev, &config);
756 /* Use cached bConfigurationValue */
757 struct linux_device_priv *priv = _device_priv(dev);
758 config = priv->active_config;
761 return LIBUSB_ERROR_NOT_FOUND;
763 r = op_get_config_descriptor_by_value(dev, config, &config_desc,
769 memcpy(buffer, config_desc, len);
773 static int op_get_config_descriptor(struct libusb_device *dev,
774 uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
776 struct linux_device_priv *priv = _device_priv(dev);
777 unsigned char *descriptors = priv->descriptors;
778 int i, r, size = priv->descriptors_len;
780 /* Unlike the device desc. config descs. are always in raw format */
783 /* Skip device header */
784 descriptors += DEVICE_DESC_LENGTH;
785 size -= DEVICE_DESC_LENGTH;
787 /* Seek till the config is found, or till "EOF" */
789 r = seek_to_next_config(DEVICE_CTX(dev), descriptors, size);
792 if (i == config_index)
799 memcpy(buffer, descriptors, len);
803 /* send a control message to retrieve active configuration */
804 static int usbfs_get_active_config(struct libusb_device *dev, int fd)
806 unsigned char active_config = 0;
809 struct usbfs_ctrltransfer ctrl = {
810 .bmRequestType = LIBUSB_ENDPOINT_IN,
811 .bRequest = LIBUSB_REQUEST_GET_CONFIGURATION,
816 .data = &active_config
819 r = ioctl(fd, IOCTL_USBFS_CONTROL, &ctrl);
822 return LIBUSB_ERROR_NO_DEVICE;
824 /* we hit this error path frequently with buggy devices :( */
825 usbi_warn(DEVICE_CTX(dev),
826 "get_configuration failed ret=%d errno=%d", r, errno);
827 return LIBUSB_ERROR_IO;
830 return active_config;
833 static int initialize_device(struct libusb_device *dev, uint8_t busnum,
834 uint8_t devaddr, const char *sysfs_dir)
836 struct linux_device_priv *priv = _device_priv(dev);
837 struct libusb_context *ctx = DEVICE_CTX(dev);
838 int descriptors_size = 512; /* Begin with a 1024 byte alloc */
842 dev->bus_number = busnum;
843 dev->device_address = devaddr;
846 priv->sysfs_dir = malloc(strlen(sysfs_dir) + 1);
847 if (!priv->sysfs_dir)
848 return LIBUSB_ERROR_NO_MEM;
849 strcpy(priv->sysfs_dir, sysfs_dir);
851 /* Note speed can contain 1.5, in this case __read_sysfs_attr
852 will stop parsing at the '.' and return 1 */
853 speed = __read_sysfs_attr(DEVICE_CTX(dev), sysfs_dir, "speed");
856 case 1: dev->speed = LIBUSB_SPEED_LOW; break;
857 case 12: dev->speed = LIBUSB_SPEED_FULL; break;
858 case 480: dev->speed = LIBUSB_SPEED_HIGH; break;
859 case 5000: dev->speed = LIBUSB_SPEED_SUPER; break;
861 usbi_warn(DEVICE_CTX(dev), "Unknown device speed: %d Mbps", speed);
866 /* cache descriptors in memory */
867 if (sysfs_has_descriptors)
868 fd = _open_sysfs_attr(dev, "descriptors");
870 fd = _get_usbfs_fd(dev, O_RDONLY, 0);
875 descriptors_size *= 2;
876 priv->descriptors = usbi_reallocf(priv->descriptors,
878 if (!priv->descriptors) {
880 return LIBUSB_ERROR_NO_MEM;
882 /* usbfs has holes in the file */
883 if (!sysfs_has_descriptors) {
884 memset(priv->descriptors + priv->descriptors_len,
885 0, descriptors_size - priv->descriptors_len);
887 r = read(fd, priv->descriptors + priv->descriptors_len,
888 descriptors_size - priv->descriptors_len);
890 usbi_err(ctx, "read descriptor failed ret=%d errno=%d",
893 return LIBUSB_ERROR_IO;
895 priv->descriptors_len += r;
896 } while (priv->descriptors_len == descriptors_size);
900 if (priv->descriptors_len < DEVICE_DESC_LENGTH) {
901 usbi_err(ctx, "short descriptor read (%d)",
902 priv->descriptors_len);
903 return LIBUSB_ERROR_IO;
906 if (sysfs_can_relate_devices)
907 return LIBUSB_SUCCESS;
909 /* cache active config */
910 fd = _get_usbfs_fd(dev, O_RDWR, 1);
912 /* cannot send a control message to determine the active
913 * config. just assume the first one is active. */
914 usbi_warn(ctx, "Missing rw usbfs access; cannot determine "
915 "active configuration descriptor");
916 if (priv->descriptors_len >=
917 (DEVICE_DESC_LENGTH + LIBUSB_DT_CONFIG_SIZE)) {
918 struct libusb_config_descriptor config;
919 usbi_parse_descriptor(
920 priv->descriptors + DEVICE_DESC_LENGTH,
921 "bbwbbbbb", &config, 0);
922 priv->active_config = config.bConfigurationValue;
924 priv->active_config = -1; /* No config dt */
926 return LIBUSB_SUCCESS;
929 r = usbfs_get_active_config(dev, fd);
931 priv->active_config = r;
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_dbg("active cfg 0? assuming unconfigured device");
940 priv->active_config = -1;
942 } else if (r == LIBUSB_ERROR_IO) {
943 /* buggy devices sometimes fail to report their active config.
944 * assume unconfigured and continue the probing */
945 usbi_warn(ctx, "couldn't query active configuration, assuming"
947 priv->active_config = -1;
949 } /* else r < 0, just return the error code */
955 static int linux_get_parent_info(struct libusb_device *dev, const char *sysfs_dir)
957 struct libusb_context *ctx = DEVICE_CTX(dev);
958 struct libusb_device *it;
959 char *parent_sysfs_dir, *tmp;
960 int ret, add_parent = 1;
962 /* XXX -- can we figure out the topology when using usbfs? */
963 if (NULL == sysfs_dir || 0 == strncmp(sysfs_dir, "usb", 3)) {
964 /* either using usbfs or finding the parent of a root hub */
965 return LIBUSB_SUCCESS;
968 parent_sysfs_dir = strdup(sysfs_dir);
969 if (NULL != (tmp = strrchr(parent_sysfs_dir, '.')) ||
970 NULL != (tmp = strrchr(parent_sysfs_dir, '-'))) {
971 dev->port_number = atoi(tmp + 1);
974 usbi_warn(ctx, "Can not parse sysfs_dir: %s, no parent info",
976 free (parent_sysfs_dir);
977 return LIBUSB_SUCCESS;
980 /* is the parent a root hub? */
981 if (NULL == strchr(parent_sysfs_dir, '-')) {
982 tmp = parent_sysfs_dir;
983 ret = asprintf (&parent_sysfs_dir, "usb%s", tmp);
986 return LIBUSB_ERROR_NO_MEM;
991 /* find the parent in the context */
992 usbi_mutex_lock(&ctx->usb_devs_lock);
993 list_for_each_entry(it, &ctx->usb_devs, list, struct libusb_device) {
994 struct linux_device_priv *priv = _device_priv(it);
995 if (0 == strcmp (priv->sysfs_dir, parent_sysfs_dir)) {
996 dev->parent_dev = libusb_ref_device(it);
1000 usbi_mutex_unlock(&ctx->usb_devs_lock);
1002 if (!dev->parent_dev && add_parent) {
1003 usbi_dbg("parent_dev %s not enumerated yet, enumerating now",
1005 sysfs_scan_device(ctx, parent_sysfs_dir);
1010 usbi_dbg("Dev %p (%s) has parent %p (%s) port %d", dev, sysfs_dir,
1011 dev->parent_dev, parent_sysfs_dir, dev->port_number);
1013 free (parent_sysfs_dir);
1015 return LIBUSB_SUCCESS;
1018 int linux_enumerate_device(struct libusb_context *ctx,
1019 uint8_t busnum, uint8_t devaddr, const char *sysfs_dir)
1021 unsigned long session_id;
1022 struct libusb_device *dev;
1025 /* FIXME: session ID is not guaranteed unique as addresses can wrap and
1026 * will be reused. instead we should add a simple sysfs attribute with
1028 session_id = busnum << 8 | devaddr;
1029 usbi_dbg("busnum %d devaddr %d session_id %ld", busnum, devaddr,
1032 if (usbi_get_device_by_session_id(ctx, session_id)) {
1033 /* device already exists in the context */
1034 usbi_dbg("session_id %ld already exists", session_id);
1035 return LIBUSB_SUCCESS;
1038 usbi_dbg("allocating new device for %d/%d (session %ld)",
1039 busnum, devaddr, session_id);
1040 dev = usbi_alloc_device(ctx, session_id);
1042 return LIBUSB_ERROR_NO_MEM;
1044 r = initialize_device(dev, busnum, devaddr, sysfs_dir);
1047 r = usbi_sanitize_device(dev);
1051 r = linux_get_parent_info(dev, sysfs_dir);
1056 libusb_unref_device(dev);
1058 usbi_connect_device(dev);
1063 void linux_hotplug_enumerate(uint8_t busnum, uint8_t devaddr, const char *sys_name)
1065 struct libusb_context *ctx;
1067 usbi_mutex_static_lock(&active_contexts_lock);
1068 list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
1069 linux_enumerate_device(ctx, busnum, devaddr, sys_name);
1071 usbi_mutex_static_unlock(&active_contexts_lock);
1074 void linux_hotplug_disconnected(uint8_t busnum, uint8_t devaddr, const char *sys_name)
1076 struct libusb_context *ctx;
1077 struct libusb_device *dev;
1078 unsigned long session_id = busnum << 8 | devaddr;
1080 usbi_mutex_static_lock(&active_contexts_lock);
1081 list_for_each_entry(ctx, &active_contexts_list, list, struct libusb_context) {
1082 dev = usbi_get_device_by_session_id (ctx, session_id);
1084 usbi_disconnect_device (dev);
1086 usbi_dbg("device not found for session %x", session_id);
1089 usbi_mutex_static_unlock(&active_contexts_lock);
1092 #if !defined(USE_UDEV)
1093 /* open a bus directory and adds all discovered devices to the context */
1094 static int usbfs_scan_busdir(struct libusb_context *ctx, uint8_t busnum)
1097 char dirpath[PATH_MAX];
1098 struct dirent *entry;
1099 int r = LIBUSB_ERROR_IO;
1101 snprintf(dirpath, PATH_MAX, "%s/%03d", usbfs_path, busnum);
1102 usbi_dbg("%s", dirpath);
1103 dir = opendir(dirpath);
1105 usbi_err(ctx, "opendir '%s' failed, errno=%d", dirpath, errno);
1106 /* FIXME: should handle valid race conditions like hub unplugged
1107 * during directory iteration - this is not an error */
1111 while ((entry = readdir(dir))) {
1114 if (entry->d_name[0] == '.')
1117 devaddr = atoi(entry->d_name);
1119 usbi_dbg("unknown dir entry %s", entry->d_name);
1123 if (linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL)) {
1124 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1135 static int usbfs_get_device_list(struct libusb_context *ctx)
1137 struct dirent *entry;
1138 DIR *buses = opendir(usbfs_path);
1142 usbi_err(ctx, "opendir buses failed errno=%d", errno);
1143 return LIBUSB_ERROR_IO;
1146 while ((entry = readdir(buses))) {
1149 if (entry->d_name[0] == '.')
1154 if (!_is_usbdev_entry(entry, &busnum, &devaddr))
1157 r = linux_enumerate_device(ctx, busnum, (uint8_t) devaddr, NULL);
1159 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1163 busnum = atoi(entry->d_name);
1165 usbi_dbg("unknown dir entry %s", entry->d_name);
1169 r = usbfs_scan_busdir(ctx, busnum);
1181 static int sysfs_scan_device(struct libusb_context *ctx, const char *devname)
1183 uint8_t busnum, devaddr;
1186 ret = linux_get_device_address (ctx, 0, &busnum, &devaddr, NULL, devname);
1187 if (LIBUSB_SUCCESS != ret) {
1191 return linux_enumerate_device(ctx, busnum & 0xff, devaddr & 0xff,
1195 #if !defined(USE_UDEV)
1196 static int sysfs_get_device_list(struct libusb_context *ctx)
1198 DIR *devices = opendir(SYSFS_DEVICE_PATH);
1199 struct dirent *entry;
1200 int r = LIBUSB_ERROR_IO;
1203 usbi_err(ctx, "opendir devices failed errno=%d", errno);
1207 while ((entry = readdir(devices))) {
1208 if ((!isdigit(entry->d_name[0]) && strncmp(entry->d_name, "usb", 3))
1209 || strchr(entry->d_name, ':'))
1212 if (sysfs_scan_device(ctx, entry->d_name)) {
1213 usbi_dbg("failed to enumerate dir entry %s", entry->d_name);
1224 static int linux_default_scan_devices (struct libusb_context *ctx)
1226 /* we can retrieve device list and descriptors from sysfs or usbfs.
1227 * sysfs is preferable, because if we use usbfs we end up resuming
1228 * any autosuspended USB devices. however, sysfs is not available
1229 * everywhere, so we need a usbfs fallback too.
1231 * as described in the "sysfs vs usbfs" comment at the top of this
1232 * file, sometimes we have sysfs but not enough information to
1233 * relate sysfs devices to usbfs nodes. op_init() determines the
1234 * adequacy of sysfs and sets sysfs_can_relate_devices.
1236 if (sysfs_can_relate_devices != 0)
1237 return sysfs_get_device_list(ctx);
1239 return usbfs_get_device_list(ctx);
1243 static int op_open(struct libusb_device_handle *handle)
1245 struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
1248 hpriv->fd = _get_usbfs_fd(handle->dev, O_RDWR, 0);
1252 r = ioctl(hpriv->fd, IOCTL_USBFS_GET_CAPABILITIES, &hpriv->caps);
1254 if (errno == ENOTTY)
1255 usbi_dbg("getcap not available");
1257 usbi_err(HANDLE_CTX(handle), "getcap failed (%d)", errno);
1259 if (supports_flag_zero_packet)
1260 hpriv->caps |= USBFS_CAP_ZERO_PACKET;
1261 if (supports_flag_bulk_continuation)
1262 hpriv->caps |= USBFS_CAP_BULK_CONTINUATION;
1265 return usbi_add_pollfd(HANDLE_CTX(handle), hpriv->fd, POLLOUT);
1268 static void op_close(struct libusb_device_handle *dev_handle)
1270 int fd = _device_handle_priv(dev_handle)->fd;
1271 usbi_remove_pollfd(HANDLE_CTX(dev_handle), fd);
1275 static int op_get_configuration(struct libusb_device_handle *handle,
1280 if (sysfs_can_relate_devices) {
1281 r = sysfs_get_active_config(handle->dev, config);
1283 r = usbfs_get_active_config(handle->dev,
1284 _device_handle_priv(handle)->fd);
1289 if (*config == -1) {
1290 usbi_err(HANDLE_CTX(handle), "device unconfigured");
1297 static int op_set_configuration(struct libusb_device_handle *handle, int config)
1299 struct linux_device_priv *priv = _device_priv(handle->dev);
1300 int fd = _device_handle_priv(handle)->fd;
1301 int r = ioctl(fd, IOCTL_USBFS_SETCONFIG, &config);
1303 if (errno == EINVAL)
1304 return LIBUSB_ERROR_NOT_FOUND;
1305 else if (errno == EBUSY)
1306 return LIBUSB_ERROR_BUSY;
1307 else if (errno == ENODEV)
1308 return LIBUSB_ERROR_NO_DEVICE;
1310 usbi_err(HANDLE_CTX(handle), "failed, error %d errno %d", r, errno);
1311 return LIBUSB_ERROR_OTHER;
1314 /* update our cached active config descriptor */
1315 priv->active_config = config;
1317 return LIBUSB_SUCCESS;
1320 static int claim_interface(struct libusb_device_handle *handle, int iface)
1322 int fd = _device_handle_priv(handle)->fd;
1323 int r = ioctl(fd, IOCTL_USBFS_CLAIMINTF, &iface);
1325 if (errno == ENOENT)
1326 return LIBUSB_ERROR_NOT_FOUND;
1327 else if (errno == EBUSY)
1328 return LIBUSB_ERROR_BUSY;
1329 else if (errno == ENODEV)
1330 return LIBUSB_ERROR_NO_DEVICE;
1332 usbi_err(HANDLE_CTX(handle),
1333 "claim interface failed, error %d errno %d", r, errno);
1334 return LIBUSB_ERROR_OTHER;
1339 static int release_interface(struct libusb_device_handle *handle, int iface)
1341 int fd = _device_handle_priv(handle)->fd;
1342 int r = ioctl(fd, IOCTL_USBFS_RELEASEINTF, &iface);
1344 if (errno == ENODEV)
1345 return LIBUSB_ERROR_NO_DEVICE;
1347 usbi_err(HANDLE_CTX(handle),
1348 "release interface failed, error %d errno %d", r, errno);
1349 return LIBUSB_ERROR_OTHER;
1354 static int op_set_interface(struct libusb_device_handle *handle, int iface,
1357 int fd = _device_handle_priv(handle)->fd;
1358 struct usbfs_setinterface setintf;
1361 setintf.interface = iface;
1362 setintf.altsetting = altsetting;
1363 r = ioctl(fd, IOCTL_USBFS_SETINTF, &setintf);
1365 if (errno == EINVAL)
1366 return LIBUSB_ERROR_NOT_FOUND;
1367 else if (errno == ENODEV)
1368 return LIBUSB_ERROR_NO_DEVICE;
1370 usbi_err(HANDLE_CTX(handle),
1371 "setintf failed error %d errno %d", r, errno);
1372 return LIBUSB_ERROR_OTHER;
1378 static int op_clear_halt(struct libusb_device_handle *handle,
1379 unsigned char endpoint)
1381 int fd = _device_handle_priv(handle)->fd;
1382 unsigned int _endpoint = endpoint;
1383 int r = ioctl(fd, IOCTL_USBFS_CLEAR_HALT, &_endpoint);
1385 if (errno == ENOENT)
1386 return LIBUSB_ERROR_NOT_FOUND;
1387 else if (errno == ENODEV)
1388 return LIBUSB_ERROR_NO_DEVICE;
1390 usbi_err(HANDLE_CTX(handle),
1391 "clear_halt failed error %d errno %d", r, errno);
1392 return LIBUSB_ERROR_OTHER;
1398 static int op_reset_device(struct libusb_device_handle *handle)
1400 int fd = _device_handle_priv(handle)->fd;
1403 /* Doing a device reset will cause the usbfs driver to get unbound
1404 from any interfaces it is bound to. By voluntarily unbinding
1405 the usbfs driver ourself, we stop the kernel from rebinding
1406 the interface after reset (which would end up with the interface
1407 getting bound to the in kernel driver if any). */
1408 for (i = 0; i < USB_MAXINTERFACES; i++) {
1409 if (handle->claimed_interfaces & (1L << i)) {
1410 release_interface(handle, i);
1414 usbi_mutex_lock(&handle->lock);
1415 r = ioctl(fd, IOCTL_USBFS_RESET, NULL);
1417 if (errno == ENODEV) {
1418 ret = LIBUSB_ERROR_NOT_FOUND;
1422 usbi_err(HANDLE_CTX(handle),
1423 "reset failed error %d errno %d", r, errno);
1424 ret = LIBUSB_ERROR_OTHER;
1428 /* And re-claim any interfaces which were claimed before the reset */
1429 for (i = 0; i < USB_MAXINTERFACES; i++) {
1430 if (handle->claimed_interfaces & (1L << i)) {
1431 r = claim_interface(handle, i);
1433 usbi_warn(HANDLE_CTX(handle),
1434 "failed to re-claim interface %d after reset", i);
1435 handle->claimed_interfaces &= ~(1L << i);
1440 usbi_mutex_unlock(&handle->lock);
1444 static int op_kernel_driver_active(struct libusb_device_handle *handle,
1447 int fd = _device_handle_priv(handle)->fd;
1448 struct usbfs_getdriver getdrv;
1451 getdrv.interface = interface;
1452 r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1454 if (errno == ENODATA)
1456 else if (errno == ENODEV)
1457 return LIBUSB_ERROR_NO_DEVICE;
1459 usbi_err(HANDLE_CTX(handle),
1460 "get driver failed error %d errno %d", r, errno);
1461 return LIBUSB_ERROR_OTHER;
1467 static int op_detach_kernel_driver(struct libusb_device_handle *handle,
1470 int fd = _device_handle_priv(handle)->fd;
1471 struct usbfs_ioctl command;
1472 struct usbfs_getdriver getdrv;
1475 command.ifno = interface;
1476 command.ioctl_code = IOCTL_USBFS_DISCONNECT;
1477 command.data = NULL;
1479 getdrv.interface = interface;
1480 r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1481 if (r == 0 && strcmp(getdrv.driver, "usbfs") == 0)
1482 return LIBUSB_ERROR_NOT_FOUND;
1484 r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1486 if (errno == ENODATA)
1487 return LIBUSB_ERROR_NOT_FOUND;
1488 else if (errno == EINVAL)
1489 return LIBUSB_ERROR_INVALID_PARAM;
1490 else if (errno == ENODEV)
1491 return LIBUSB_ERROR_NO_DEVICE;
1493 usbi_err(HANDLE_CTX(handle),
1494 "detach failed error %d errno %d", r, errno);
1495 return LIBUSB_ERROR_OTHER;
1501 static int op_attach_kernel_driver(struct libusb_device_handle *handle,
1504 int fd = _device_handle_priv(handle)->fd;
1505 struct usbfs_ioctl command;
1508 command.ifno = interface;
1509 command.ioctl_code = IOCTL_USBFS_CONNECT;
1510 command.data = NULL;
1512 r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1514 if (errno == ENODATA)
1515 return LIBUSB_ERROR_NOT_FOUND;
1516 else if (errno == EINVAL)
1517 return LIBUSB_ERROR_INVALID_PARAM;
1518 else if (errno == ENODEV)
1519 return LIBUSB_ERROR_NO_DEVICE;
1520 else if (errno == EBUSY)
1521 return LIBUSB_ERROR_BUSY;
1523 usbi_err(HANDLE_CTX(handle),
1524 "attach failed error %d errno %d", r, errno);
1525 return LIBUSB_ERROR_OTHER;
1526 } else if (r == 0) {
1527 return LIBUSB_ERROR_NOT_FOUND;
1533 static int detach_kernel_driver_and_claim(struct libusb_device_handle *handle,
1538 r = op_detach_kernel_driver(handle, interface);
1539 if (r != 0 && r != LIBUSB_ERROR_NOT_FOUND)
1542 return claim_interface(handle, interface);
1545 static int op_claim_interface(struct libusb_device_handle *handle, int iface)
1547 if (handle->auto_detach_kernel_driver)
1548 return detach_kernel_driver_and_claim(handle, iface);
1550 return claim_interface(handle, iface);
1553 static int op_release_interface(struct libusb_device_handle *handle, int iface)
1557 r = release_interface(handle, iface);
1561 if (handle->auto_detach_kernel_driver)
1562 op_attach_kernel_driver(handle, iface);
1567 static void op_destroy_device(struct libusb_device *dev)
1569 struct linux_device_priv *priv = _device_priv(dev);
1570 if (priv->descriptors)
1571 free(priv->descriptors);
1572 if (priv->sysfs_dir)
1573 free(priv->sysfs_dir);
1576 /* URBs are discarded in reverse order of submission to avoid races. */
1577 static int discard_urbs(struct usbi_transfer *itransfer, int first, int last_plus_one)
1579 struct libusb_transfer *transfer =
1580 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1581 struct linux_transfer_priv *tpriv =
1582 usbi_transfer_get_os_priv(itransfer);
1583 struct linux_device_handle_priv *dpriv =
1584 _device_handle_priv(transfer->dev_handle);
1586 struct usbfs_urb *urb;
1588 for (i = last_plus_one - 1; i >= first; i--) {
1589 if (LIBUSB_TRANSFER_TYPE_ISOCHRONOUS == transfer->type)
1590 urb = tpriv->iso_urbs[i];
1592 urb = &tpriv->urbs[i];
1594 if (0 == ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, urb))
1597 if (EINVAL == errno) {
1598 usbi_dbg("URB not found --> assuming ready to be reaped");
1599 if (i == (last_plus_one - 1))
1600 ret = LIBUSB_ERROR_NOT_FOUND;
1601 } else if (ENODEV == errno) {
1602 usbi_dbg("Device not found for URB --> assuming ready to be reaped");
1603 ret = LIBUSB_ERROR_NO_DEVICE;
1605 usbi_warn(TRANSFER_CTX(transfer),
1606 "unrecognised discard errno %d", errno);
1607 ret = LIBUSB_ERROR_OTHER;
1613 static void free_iso_urbs(struct linux_transfer_priv *tpriv)
1616 for (i = 0; i < tpriv->num_urbs; i++) {
1617 struct usbfs_urb *urb = tpriv->iso_urbs[i];
1623 free(tpriv->iso_urbs);
1624 tpriv->iso_urbs = NULL;
1627 static int submit_bulk_transfer(struct usbi_transfer *itransfer,
1628 unsigned char urb_type)
1630 struct libusb_transfer *transfer =
1631 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1632 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1633 struct linux_device_handle_priv *dpriv =
1634 _device_handle_priv(transfer->dev_handle);
1635 struct usbfs_urb *urbs;
1636 int is_out = (transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK)
1637 == LIBUSB_ENDPOINT_OUT;
1638 int bulk_buffer_len, use_bulk_continuation;
1644 return LIBUSB_ERROR_BUSY;
1646 if (is_out && (transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET) &&
1647 !(dpriv->caps & USBFS_CAP_ZERO_PACKET))
1648 return LIBUSB_ERROR_NOT_SUPPORTED;
1651 * Older versions of usbfs place a 16kb limit on bulk URBs. We work
1652 * around this by splitting large transfers into 16k blocks, and then
1653 * submit all urbs at once. it would be simpler to submit one urb at
1654 * a time, but there is a big performance gain doing it this way.
1656 * Newer versions lift the 16k limit (USBFS_CAP_NO_PACKET_SIZE_LIM),
1657 * using arbritary large transfers can still be a bad idea though, as
1658 * the kernel needs to allocate physical contiguous memory for this,
1659 * which may fail for large buffers.
1661 * The kernel solves this problem by splitting the transfer into
1662 * blocks itself when the host-controller is scatter-gather capable
1663 * (USBFS_CAP_BULK_SCATTER_GATHER), which most controllers are.
1665 * Last, there is the issue of short-transfers when splitting, for
1666 * short split-transfers to work reliable USBFS_CAP_BULK_CONTINUATION
1667 * is needed, but this is not always available.
1669 if (dpriv->caps & USBFS_CAP_BULK_SCATTER_GATHER) {
1670 /* Good! Just submit everything in one go */
1671 bulk_buffer_len = transfer->length ? transfer->length : 1;
1672 use_bulk_continuation = 0;
1673 } else if (dpriv->caps & USBFS_CAP_BULK_CONTINUATION) {
1674 /* Split the transfers and use bulk-continuation to
1675 avoid issues with short-transfers */
1676 bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
1677 use_bulk_continuation = 1;
1678 } else if (dpriv->caps & USBFS_CAP_NO_PACKET_SIZE_LIM) {
1679 /* Don't split, assume the kernel can alloc the buffer
1680 (otherwise the submit will fail with -ENOMEM) */
1681 bulk_buffer_len = transfer->length ? transfer->length : 1;
1682 use_bulk_continuation = 0;
1684 /* Bad, splitting without bulk-continuation, short transfers
1685 which end before the last urb will not work reliable! */
1686 /* Note we don't warn here as this is "normal" on kernels <
1687 2.6.32 and not a problem for most applications */
1688 bulk_buffer_len = MAX_BULK_BUFFER_LENGTH;
1689 use_bulk_continuation = 0;
1692 int num_urbs = transfer->length / bulk_buffer_len;
1693 int last_urb_partial = 0;
1695 if (transfer->length == 0) {
1697 } else if ((transfer->length % bulk_buffer_len) > 0) {
1698 last_urb_partial = 1;
1701 usbi_dbg("need %d urbs for new transfer with length %d", num_urbs,
1703 alloc_size = num_urbs * sizeof(struct usbfs_urb);
1704 urbs = calloc(1, alloc_size);
1706 return LIBUSB_ERROR_NO_MEM;
1708 tpriv->num_urbs = num_urbs;
1709 tpriv->num_retired = 0;
1710 tpriv->reap_action = NORMAL;
1711 tpriv->reap_status = LIBUSB_TRANSFER_COMPLETED;
1713 for (i = 0; i < num_urbs; i++) {
1714 struct usbfs_urb *urb = &urbs[i];
1715 urb->usercontext = itransfer;
1716 urb->type = urb_type;
1717 urb->endpoint = transfer->endpoint;
1718 urb->buffer = transfer->buffer + (i * bulk_buffer_len);
1719 /* don't set the short not ok flag for the last URB */
1720 if (use_bulk_continuation && !is_out && (i < num_urbs - 1))
1721 urb->flags = USBFS_URB_SHORT_NOT_OK;
1722 if (i == num_urbs - 1 && last_urb_partial)
1723 urb->buffer_length = transfer->length % bulk_buffer_len;
1724 else if (transfer->length == 0)
1725 urb->buffer_length = 0;
1727 urb->buffer_length = bulk_buffer_len;
1729 if (i > 0 && use_bulk_continuation)
1730 urb->flags |= USBFS_URB_BULK_CONTINUATION;
1732 /* we have already checked that the flag is supported */
1733 if (is_out && i == num_urbs - 1 &&
1734 transfer->flags & LIBUSB_TRANSFER_ADD_ZERO_PACKET)
1735 urb->flags |= USBFS_URB_ZERO_PACKET;
1737 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
1739 if (errno == ENODEV) {
1740 r = LIBUSB_ERROR_NO_DEVICE;
1742 usbi_err(TRANSFER_CTX(transfer),
1743 "submiturb failed error %d errno=%d", r, errno);
1744 r = LIBUSB_ERROR_IO;
1747 /* if the first URB submission fails, we can simply free up and
1748 * return failure immediately. */
1750 usbi_dbg("first URB failed, easy peasy");
1756 /* if it's not the first URB that failed, the situation is a bit
1757 * tricky. we may need to discard all previous URBs. there are
1759 * - discarding is asynchronous - discarded urbs will be reaped
1760 * later. the user must not have freed the transfer when the
1761 * discarded URBs are reaped, otherwise libusbx will be using
1763 * - the earlier URBs may have completed successfully and we do
1764 * not want to throw away any data.
1765 * - this URB failing may be no error; EREMOTEIO means that
1766 * this transfer simply didn't need all the URBs we submitted
1767 * so, we report that the transfer was submitted successfully and
1768 * in case of error we discard all previous URBs. later when
1769 * the final reap completes we can report error to the user,
1770 * or success if an earlier URB was completed successfully.
1772 tpriv->reap_action = EREMOTEIO == errno ? COMPLETED_EARLY : SUBMIT_FAILED;
1774 /* The URBs we haven't submitted yet we count as already
1776 tpriv->num_retired += num_urbs - i;
1778 /* If we completed short then don't try to discard. */
1779 if (COMPLETED_EARLY == tpriv->reap_action)
1782 discard_urbs(itransfer, 0, i);
1784 usbi_dbg("reporting successful submission but waiting for %d "
1785 "discards before reporting error", i);
1793 static int submit_iso_transfer(struct usbi_transfer *itransfer)
1795 struct libusb_transfer *transfer =
1796 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1797 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1798 struct linux_device_handle_priv *dpriv =
1799 _device_handle_priv(transfer->dev_handle);
1800 struct usbfs_urb **urbs;
1802 int num_packets = transfer->num_iso_packets;
1804 int this_urb_len = 0;
1806 int packet_offset = 0;
1807 unsigned int packet_len;
1808 unsigned char *urb_buffer = transfer->buffer;
1810 if (tpriv->iso_urbs)
1811 return LIBUSB_ERROR_BUSY;
1813 /* usbfs places a 32kb limit on iso URBs. we divide up larger requests
1814 * into smaller units to meet such restriction, then fire off all the
1815 * units at once. it would be simpler if we just fired one unit at a time,
1816 * but there is a big performance gain through doing it this way.
1818 * Newer kernels lift the 32k limit (USBFS_CAP_NO_PACKET_SIZE_LIM),
1819 * using arbritary large transfers is still be a bad idea though, as
1820 * the kernel needs to allocate physical contiguous memory for this,
1821 * which may fail for large buffers.
1824 /* calculate how many URBs we need */
1825 for (i = 0; i < num_packets; i++) {
1826 unsigned int space_remaining = MAX_ISO_BUFFER_LENGTH - this_urb_len;
1827 packet_len = transfer->iso_packet_desc[i].length;
1829 if (packet_len > space_remaining) {
1831 this_urb_len = packet_len;
1833 this_urb_len += packet_len;
1836 usbi_dbg("need %d 32k URBs for transfer", num_urbs);
1838 alloc_size = num_urbs * sizeof(*urbs);
1839 urbs = calloc(1, alloc_size);
1841 return LIBUSB_ERROR_NO_MEM;
1843 tpriv->iso_urbs = urbs;
1844 tpriv->num_urbs = num_urbs;
1845 tpriv->num_retired = 0;
1846 tpriv->reap_action = NORMAL;
1847 tpriv->iso_packet_offset = 0;
1849 /* allocate + initialize each URB with the correct number of packets */
1850 for (i = 0; i < num_urbs; i++) {
1851 struct usbfs_urb *urb;
1852 unsigned int space_remaining_in_urb = MAX_ISO_BUFFER_LENGTH;
1853 int urb_packet_offset = 0;
1854 unsigned char *urb_buffer_orig = urb_buffer;
1858 /* swallow up all the packets we can fit into this URB */
1859 while (packet_offset < transfer->num_iso_packets) {
1860 packet_len = transfer->iso_packet_desc[packet_offset].length;
1861 if (packet_len <= space_remaining_in_urb) {
1863 urb_packet_offset++;
1865 space_remaining_in_urb -= packet_len;
1866 urb_buffer += packet_len;
1868 /* it can't fit, save it for the next URB */
1873 alloc_size = sizeof(*urb)
1874 + (urb_packet_offset * sizeof(struct usbfs_iso_packet_desc));
1875 urb = calloc(1, alloc_size);
1877 free_iso_urbs(tpriv);
1878 return LIBUSB_ERROR_NO_MEM;
1882 /* populate packet lengths */
1883 for (j = 0, k = packet_offset - urb_packet_offset;
1884 k < packet_offset; k++, j++) {
1885 packet_len = transfer->iso_packet_desc[k].length;
1886 urb->iso_frame_desc[j].length = packet_len;
1889 urb->usercontext = itransfer;
1890 urb->type = USBFS_URB_TYPE_ISO;
1891 /* FIXME: interface for non-ASAP data? */
1892 urb->flags = USBFS_URB_ISO_ASAP;
1893 urb->endpoint = transfer->endpoint;
1894 urb->number_of_packets = urb_packet_offset;
1895 urb->buffer = urb_buffer_orig;
1899 for (i = 0; i < num_urbs; i++) {
1900 int r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urbs[i]);
1902 if (errno == ENODEV) {
1903 r = LIBUSB_ERROR_NO_DEVICE;
1905 usbi_err(TRANSFER_CTX(transfer),
1906 "submiturb failed error %d errno=%d", r, errno);
1907 r = LIBUSB_ERROR_IO;
1910 /* if the first URB submission fails, we can simply free up and
1911 * return failure immediately. */
1913 usbi_dbg("first URB failed, easy peasy");
1914 free_iso_urbs(tpriv);
1918 /* if it's not the first URB that failed, the situation is a bit
1919 * tricky. we must discard all previous URBs. there are
1921 * - discarding is asynchronous - discarded urbs will be reaped
1922 * later. the user must not have freed the transfer when the
1923 * discarded URBs are reaped, otherwise libusbx will be using
1925 * - the earlier URBs may have completed successfully and we do
1926 * not want to throw away any data.
1927 * so, in this case we discard all the previous URBs BUT we report
1928 * that the transfer was submitted successfully. then later when
1929 * the final discard completes we can report error to the user.
1931 tpriv->reap_action = SUBMIT_FAILED;
1933 /* The URBs we haven't submitted yet we count as already
1935 tpriv->num_retired = num_urbs - i;
1936 discard_urbs(itransfer, 0, i);
1938 usbi_dbg("reporting successful submission but waiting for %d "
1939 "discards before reporting error", i);
1947 static int submit_control_transfer(struct usbi_transfer *itransfer)
1949 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1950 struct libusb_transfer *transfer =
1951 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1952 struct linux_device_handle_priv *dpriv =
1953 _device_handle_priv(transfer->dev_handle);
1954 struct usbfs_urb *urb;
1958 return LIBUSB_ERROR_BUSY;
1960 if (transfer->length - LIBUSB_CONTROL_SETUP_SIZE > MAX_CTRL_BUFFER_LENGTH)
1961 return LIBUSB_ERROR_INVALID_PARAM;
1963 urb = calloc(1, sizeof(struct usbfs_urb));
1965 return LIBUSB_ERROR_NO_MEM;
1967 tpriv->num_urbs = 1;
1968 tpriv->reap_action = NORMAL;
1970 urb->usercontext = itransfer;
1971 urb->type = USBFS_URB_TYPE_CONTROL;
1972 urb->endpoint = transfer->endpoint;
1973 urb->buffer = transfer->buffer;
1974 urb->buffer_length = transfer->length;
1976 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
1980 if (errno == ENODEV)
1981 return LIBUSB_ERROR_NO_DEVICE;
1983 usbi_err(TRANSFER_CTX(transfer),
1984 "submiturb failed error %d errno=%d", r, errno);
1985 return LIBUSB_ERROR_IO;
1990 static int op_submit_transfer(struct usbi_transfer *itransfer)
1992 struct libusb_transfer *transfer =
1993 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1995 switch (transfer->type) {
1996 case LIBUSB_TRANSFER_TYPE_CONTROL:
1997 return submit_control_transfer(itransfer);
1998 case LIBUSB_TRANSFER_TYPE_BULK:
1999 return submit_bulk_transfer(itransfer, USBFS_URB_TYPE_BULK);
2000 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2001 return submit_bulk_transfer(itransfer, USBFS_URB_TYPE_INTERRUPT);
2002 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2003 return submit_iso_transfer(itransfer);
2005 usbi_err(TRANSFER_CTX(transfer),
2006 "unknown endpoint type %d", transfer->type);
2007 return LIBUSB_ERROR_INVALID_PARAM;
2011 static int op_cancel_transfer(struct usbi_transfer *itransfer)
2013 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2014 struct libusb_transfer *transfer =
2015 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2017 switch (transfer->type) {
2018 case LIBUSB_TRANSFER_TYPE_BULK:
2019 if (tpriv->reap_action == ERROR)
2021 /* else, fall through */
2022 case LIBUSB_TRANSFER_TYPE_CONTROL:
2023 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2024 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2025 tpriv->reap_action = CANCELLED;
2028 usbi_err(TRANSFER_CTX(transfer),
2029 "unknown endpoint type %d", transfer->type);
2030 return LIBUSB_ERROR_INVALID_PARAM;
2034 return LIBUSB_ERROR_NOT_FOUND;
2036 return discard_urbs(itransfer, 0, tpriv->num_urbs);
2039 static void op_clear_transfer_priv(struct usbi_transfer *itransfer)
2041 struct libusb_transfer *transfer =
2042 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2043 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2045 /* urbs can be freed also in submit_transfer so lock mutex first */
2046 switch (transfer->type) {
2047 case LIBUSB_TRANSFER_TYPE_CONTROL:
2048 case LIBUSB_TRANSFER_TYPE_BULK:
2049 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2050 usbi_mutex_lock(&itransfer->lock);
2054 usbi_mutex_unlock(&itransfer->lock);
2056 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2057 usbi_mutex_lock(&itransfer->lock);
2058 if (tpriv->iso_urbs)
2059 free_iso_urbs(tpriv);
2060 usbi_mutex_unlock(&itransfer->lock);
2063 usbi_err(TRANSFER_CTX(transfer),
2064 "unknown endpoint type %d", transfer->type);
2068 static int handle_bulk_completion(struct usbi_transfer *itransfer,
2069 struct usbfs_urb *urb)
2071 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2072 struct libusb_transfer *transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2073 int urb_idx = urb - tpriv->urbs;
2075 usbi_mutex_lock(&itransfer->lock);
2076 usbi_dbg("handling completion status %d of bulk urb %d/%d", urb->status,
2077 urb_idx + 1, tpriv->num_urbs);
2079 tpriv->num_retired++;
2081 if (tpriv->reap_action != NORMAL) {
2082 /* cancelled, submit_fail, or completed early */
2083 usbi_dbg("abnormal reap: urb status %d", urb->status);
2085 /* even though we're in the process of cancelling, it's possible that
2086 * we may receive some data in these URBs that we don't want to lose.
2088 * 1. while the kernel is cancelling all the packets that make up an
2089 * URB, a few of them might complete. so we get back a successful
2090 * cancellation *and* some data.
2091 * 2. we receive a short URB which marks the early completion condition,
2092 * so we start cancelling the remaining URBs. however, we're too
2093 * slow and another URB completes (or at least completes partially).
2094 * (this can't happen since we always use BULK_CONTINUATION.)
2096 * When this happens, our objectives are not to lose any "surplus" data,
2097 * and also to stick it at the end of the previously-received data
2098 * (closing any holes), so that libusbx reports the total amount of
2099 * transferred data and presents it in a contiguous chunk.
2101 if (urb->actual_length > 0) {
2102 unsigned char *target = transfer->buffer + itransfer->transferred;
2103 usbi_dbg("received %d bytes of surplus data", urb->actual_length);
2104 if (urb->buffer != target) {
2105 usbi_dbg("moving surplus data from offset %d to offset %d",
2106 (unsigned char *) urb->buffer - transfer->buffer,
2107 target - transfer->buffer);
2108 memmove(target, urb->buffer, urb->actual_length);
2110 itransfer->transferred += urb->actual_length;
2113 if (tpriv->num_retired == tpriv->num_urbs) {
2114 usbi_dbg("abnormal reap: last URB handled, reporting");
2115 if (tpriv->reap_action != COMPLETED_EARLY &&
2116 tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2117 tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
2123 itransfer->transferred += urb->actual_length;
2125 /* Many of these errors can occur on *any* urb of a multi-urb
2126 * transfer. When they do, we tear down the rest of the transfer.
2128 switch (urb->status) {
2131 case -EREMOTEIO: /* short transfer */
2133 case -ENOENT: /* cancelled */
2138 usbi_dbg("device removed");
2139 tpriv->reap_status = LIBUSB_TRANSFER_NO_DEVICE;
2140 goto cancel_remaining;
2142 usbi_dbg("detected endpoint stall");
2143 if (tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2144 tpriv->reap_status = LIBUSB_TRANSFER_STALL;
2145 goto cancel_remaining;
2147 /* overflow can only ever occur in the last urb */
2148 usbi_dbg("overflow, actual_length=%d", urb->actual_length);
2149 if (tpriv->reap_status == LIBUSB_TRANSFER_COMPLETED)
2150 tpriv->reap_status = LIBUSB_TRANSFER_OVERFLOW;
2157 usbi_dbg("low level error %d", urb->status);
2158 tpriv->reap_action = ERROR;
2159 goto cancel_remaining;
2161 usbi_warn(ITRANSFER_CTX(itransfer),
2162 "unrecognised urb status %d", urb->status);
2163 tpriv->reap_action = ERROR;
2164 goto cancel_remaining;
2167 /* if we're the last urb or we got less data than requested then we're
2169 if (urb_idx == tpriv->num_urbs - 1) {
2170 usbi_dbg("last URB in transfer --> complete!");
2172 } else if (urb->actual_length < urb->buffer_length) {
2173 usbi_dbg("short transfer %d/%d --> complete!",
2174 urb->actual_length, urb->buffer_length);
2175 if (tpriv->reap_action == NORMAL)
2176 tpriv->reap_action = COMPLETED_EARLY;
2181 if (ERROR == tpriv->reap_action && LIBUSB_TRANSFER_COMPLETED == tpriv->reap_status)
2182 tpriv->reap_status = LIBUSB_TRANSFER_ERROR;
2184 if (tpriv->num_retired == tpriv->num_urbs) /* nothing to cancel */
2187 /* cancel remaining urbs and wait for their completion before
2188 * reporting results */
2189 discard_urbs(itransfer, urb_idx + 1, tpriv->num_urbs);
2192 usbi_mutex_unlock(&itransfer->lock);
2198 usbi_mutex_unlock(&itransfer->lock);
2199 return CANCELLED == tpriv->reap_action ?
2200 usbi_handle_transfer_cancellation(itransfer) :
2201 usbi_handle_transfer_completion(itransfer, tpriv->reap_status);
2204 static int handle_iso_completion(struct usbi_transfer *itransfer,
2205 struct usbfs_urb *urb)
2207 struct libusb_transfer *transfer =
2208 USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2209 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2210 int num_urbs = tpriv->num_urbs;
2213 enum libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
2215 usbi_mutex_lock(&itransfer->lock);
2216 for (i = 0; i < num_urbs; i++) {
2217 if (urb == tpriv->iso_urbs[i]) {
2223 usbi_err(TRANSFER_CTX(transfer), "could not locate urb!");
2224 usbi_mutex_unlock(&itransfer->lock);
2225 return LIBUSB_ERROR_NOT_FOUND;
2228 usbi_dbg("handling completion status %d of iso urb %d/%d", urb->status,
2231 /* copy isochronous results back in */
2233 for (i = 0; i < urb->number_of_packets; i++) {
2234 struct usbfs_iso_packet_desc *urb_desc = &urb->iso_frame_desc[i];
2235 struct libusb_iso_packet_descriptor *lib_desc =
2236 &transfer->iso_packet_desc[tpriv->iso_packet_offset++];
2237 lib_desc->status = LIBUSB_TRANSFER_COMPLETED;
2238 switch (urb_desc->status) {
2241 case -ENOENT: /* cancelled */
2246 usbi_dbg("device removed");
2247 lib_desc->status = LIBUSB_TRANSFER_NO_DEVICE;
2250 usbi_dbg("detected endpoint stall");
2251 lib_desc->status = LIBUSB_TRANSFER_STALL;
2254 usbi_dbg("overflow error");
2255 lib_desc->status = LIBUSB_TRANSFER_OVERFLOW;
2263 usbi_dbg("low-level USB error %d", urb_desc->status);
2264 lib_desc->status = LIBUSB_TRANSFER_ERROR;
2267 usbi_warn(TRANSFER_CTX(transfer),
2268 "unrecognised urb status %d", urb_desc->status);
2269 lib_desc->status = LIBUSB_TRANSFER_ERROR;
2272 lib_desc->actual_length = urb_desc->actual_length;
2275 tpriv->num_retired++;
2277 if (tpriv->reap_action != NORMAL) { /* cancelled or submit_fail */
2278 usbi_dbg("CANCEL: urb status %d", urb->status);
2280 if (tpriv->num_retired == num_urbs) {
2281 usbi_dbg("CANCEL: last URB handled, reporting");
2282 free_iso_urbs(tpriv);
2283 if (tpriv->reap_action == CANCELLED) {
2284 usbi_mutex_unlock(&itransfer->lock);
2285 return usbi_handle_transfer_cancellation(itransfer);
2287 usbi_mutex_unlock(&itransfer->lock);
2288 return usbi_handle_transfer_completion(itransfer,
2289 LIBUSB_TRANSFER_ERROR);
2295 switch (urb->status) {
2298 case -ENOENT: /* cancelled */
2302 usbi_dbg("device removed");
2303 status = LIBUSB_TRANSFER_NO_DEVICE;
2306 usbi_warn(TRANSFER_CTX(transfer),
2307 "unrecognised urb status %d", urb->status);
2308 status = LIBUSB_TRANSFER_ERROR;
2312 /* if we're the last urb then we're done */
2313 if (urb_idx == num_urbs) {
2314 usbi_dbg("last URB in transfer --> complete!");
2315 free_iso_urbs(tpriv);
2316 usbi_mutex_unlock(&itransfer->lock);
2317 return usbi_handle_transfer_completion(itransfer, status);
2321 usbi_mutex_unlock(&itransfer->lock);
2325 static int handle_control_completion(struct usbi_transfer *itransfer,
2326 struct usbfs_urb *urb)
2328 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2331 usbi_mutex_lock(&itransfer->lock);
2332 usbi_dbg("handling completion status %d", urb->status);
2334 itransfer->transferred += urb->actual_length;
2336 if (tpriv->reap_action == CANCELLED) {
2337 if (urb->status != 0 && urb->status != -ENOENT)
2338 usbi_warn(ITRANSFER_CTX(itransfer),
2339 "cancel: unrecognised urb status %d", urb->status);
2342 usbi_mutex_unlock(&itransfer->lock);
2343 return usbi_handle_transfer_cancellation(itransfer);
2346 switch (urb->status) {
2348 status = LIBUSB_TRANSFER_COMPLETED;
2350 case -ENOENT: /* cancelled */
2351 status = LIBUSB_TRANSFER_CANCELLED;
2355 usbi_dbg("device removed");
2356 status = LIBUSB_TRANSFER_NO_DEVICE;
2359 usbi_dbg("unsupported control request");
2360 status = LIBUSB_TRANSFER_STALL;
2363 usbi_dbg("control overflow error");
2364 status = LIBUSB_TRANSFER_OVERFLOW;
2371 usbi_dbg("low-level bus error occurred");
2372 status = LIBUSB_TRANSFER_ERROR;
2375 usbi_warn(ITRANSFER_CTX(itransfer),
2376 "unrecognised urb status %d", urb->status);
2377 status = LIBUSB_TRANSFER_ERROR;
2383 usbi_mutex_unlock(&itransfer->lock);
2384 return usbi_handle_transfer_completion(itransfer, status);
2387 static int reap_for_handle(struct libusb_device_handle *handle)
2389 struct linux_device_handle_priv *hpriv = _device_handle_priv(handle);
2391 struct usbfs_urb *urb;
2392 struct usbi_transfer *itransfer;
2393 struct libusb_transfer *transfer;
2395 r = ioctl(hpriv->fd, IOCTL_USBFS_REAPURBNDELAY, &urb);
2396 if (r == -1 && errno == EAGAIN)
2399 if (errno == ENODEV)
2400 return LIBUSB_ERROR_NO_DEVICE;
2402 usbi_err(HANDLE_CTX(handle), "reap failed error %d errno=%d",
2404 return LIBUSB_ERROR_IO;
2407 itransfer = urb->usercontext;
2408 transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2410 usbi_dbg("urb type=%d status=%d transferred=%d", urb->type, urb->status,
2411 urb->actual_length);
2413 switch (transfer->type) {
2414 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2415 return handle_iso_completion(itransfer, urb);
2416 case LIBUSB_TRANSFER_TYPE_BULK:
2417 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2418 return handle_bulk_completion(itransfer, urb);
2419 case LIBUSB_TRANSFER_TYPE_CONTROL:
2420 return handle_control_completion(itransfer, urb);
2422 usbi_err(HANDLE_CTX(handle), "unrecognised endpoint type %x",
2424 return LIBUSB_ERROR_OTHER;
2428 static int op_handle_events(struct libusb_context *ctx,
2429 struct pollfd *fds, POLL_NFDS_TYPE nfds, int num_ready)
2434 usbi_mutex_lock(&ctx->open_devs_lock);
2435 for (i = 0; i < nfds && num_ready > 0; i++) {
2436 struct pollfd *pollfd = &fds[i];
2437 struct libusb_device_handle *handle;
2438 struct linux_device_handle_priv *hpriv = NULL;
2440 if (!pollfd->revents)
2444 list_for_each_entry(handle, &ctx->open_devs, list, struct libusb_device_handle) {
2445 hpriv = _device_handle_priv(handle);
2446 if (hpriv->fd == pollfd->fd)
2450 if (pollfd->revents & POLLERR) {
2451 usbi_remove_pollfd(HANDLE_CTX(handle), hpriv->fd);
2452 usbi_handle_disconnect(handle);
2457 r = reap_for_handle(handle);
2459 if (r == 1 || r == LIBUSB_ERROR_NO_DEVICE)
2467 usbi_mutex_unlock(&ctx->open_devs_lock);
2471 static int op_clock_gettime(int clk_id, struct timespec *tp)
2474 case USBI_CLOCK_MONOTONIC:
2475 return clock_gettime(monotonic_clkid, tp);
2476 case USBI_CLOCK_REALTIME:
2477 return clock_gettime(CLOCK_REALTIME, tp);
2479 return LIBUSB_ERROR_INVALID_PARAM;
2483 #ifdef USBI_TIMERFD_AVAILABLE
2484 static clockid_t op_get_timerfd_clockid(void)
2486 return monotonic_clkid;
2491 const struct usbi_os_backend linux_usbfs_backend = {
2492 .name = "Linux usbfs",
2493 .caps = USBI_CAP_HAS_HID_ACCESS|USBI_CAP_SUPPORTS_DETACH_KERNEL_DRIVER,
2496 .get_device_list = NULL,
2497 .hotplug_poll = op_hotplug_poll,
2498 .get_device_descriptor = op_get_device_descriptor,
2499 .get_active_config_descriptor = op_get_active_config_descriptor,
2500 .get_config_descriptor = op_get_config_descriptor,
2501 .get_config_descriptor_by_value = op_get_config_descriptor_by_value,
2505 .get_configuration = op_get_configuration,
2506 .set_configuration = op_set_configuration,
2507 .claim_interface = op_claim_interface,
2508 .release_interface = op_release_interface,
2510 .set_interface_altsetting = op_set_interface,
2511 .clear_halt = op_clear_halt,
2512 .reset_device = op_reset_device,
2514 .kernel_driver_active = op_kernel_driver_active,
2515 .detach_kernel_driver = op_detach_kernel_driver,
2516 .attach_kernel_driver = op_attach_kernel_driver,
2518 .destroy_device = op_destroy_device,
2520 .submit_transfer = op_submit_transfer,
2521 .cancel_transfer = op_cancel_transfer,
2522 .clear_transfer_priv = op_clear_transfer_priv,
2524 .handle_events = op_handle_events,
2526 .clock_gettime = op_clock_gettime,
2528 #ifdef USBI_TIMERFD_AVAILABLE
2529 .get_timerfd_clockid = op_get_timerfd_clockid,
2532 .device_priv_size = sizeof(struct linux_device_priv),
2533 .device_handle_priv_size = sizeof(struct linux_device_handle_priv),
2534 .transfer_priv_size = sizeof(struct linux_transfer_priv),
2535 .add_iso_packet_size = 0,