1 /*
2 * Linux usbfs backend for libusb
3 * Copyright (C) 2007-2009 Daniel Drake <dsd@gentoo.org>
4 * Copyright (c) 2001 Johannes Erdfelt <johannes@erdfelt.com>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <config.h>
22 #include <ctype.h>
23 #include <dirent.h>
24 #include <errno.h>
25 #include <fcntl.h>
26 #include <poll.h>
27 #include <pthread.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <sys/ioctl.h>
32 #include <sys/stat.h>
33 #include <sys/types.h>
34 #include <sys/utsname.h>
35 #include <unistd.h>
36
37 #include "libusb.h"
38 #include "libusbi.h"
39 #include "linux_usbfs.h"
40
41 /* sysfs vs usbfs:
42 * opening a usbfs node causes the device to be resumed, so we attempt to
43 * avoid this during enumeration.
44 *
45 * sysfs allows us to read the kernel's in-memory copies of device descriptors
46 * and so forth, avoiding the need to open the device:
47 * - The binary "descriptors" file was added in 2.6.23.
48 * - The "busnum" file was added in 2.6.22
49 * - The "devnum" file has been present since pre-2.6.18
50 * - the "bConfigurationValue" file has been present since pre-2.6.18
51 *
52 * If we have bConfigurationValue, busnum, and devnum, then we can determine
53 * the active configuration without having to open the usbfs node in RDWR mode.
54 * We assume this is the case if we see the busnum file (indicates 2.6.22+).
55 * The busnum file is important as that is the only way we can relate sysfs
56 * devices to usbfs nodes.
57 *
58 * If we also have descriptors, we can obtain the device descriptor and active
59 * configuration without touching usbfs at all.
60 *
61 * The descriptors file originally only contained the active configuration
62 * descriptor alongside the device descriptor, but all configurations are
63 * included as of Linux 2.6.26.
64 */
65
66 /* endianness for multi-byte fields:
67 *
68 * Descriptors exposed by usbfs have the multi-byte fields in the device
69 * descriptor as host endian. Multi-byte fields in the other descriptors are
70 * bus-endian. The kernel documentation says otherwise, but it is wrong.
71 */
72
73 static const char *usbfs_path = NULL;
74
75 /* Linux 2.6.32 adds support for a bulk continuation URB flag. this basically
76 * allows us to mark URBs as being part of a specific logical transfer when
77 * we submit them to the kernel. then, on any error error except a
78 * cancellation, all URBs within that transfer will be cancelled with the
79 * endpoint is disabled, meaning that no more data can creep in during the
80 * time it takes to cancel the remaining URBs.
81 *
82 * The BULK_CONTINUATION flag must be set on all URBs within a bulk transfer
83 * (in either direction) except the first.
84 * For IN transfers, we must also set SHORT_NOT_OK on all the URBs.
85 * For OUT transfers, SHORT_NOT_OK must not be set. The effective behaviour
86 * (where an OUT transfer does not complete, the rest of the URBs in the
87 * transfer get cancelled) is already in effect, and setting this flag is
88 * disallowed (a kernel with USB debugging enabled will reject such URBs).
89 */
90 static int supports_flag_bulk_continuation = -1;
91
92 /* clock ID for monotonic clock, as not all clock sources are available on all
93 * systems. appropriate choice made at initialization time. */
94 static clockid_t monotonic_clkid = -1;
95
96 /* do we have a busnum to relate devices? this also implies that we can read
97 * the active configuration through bConfigurationValue */
98 static int sysfs_can_relate_devices = -1;
99
100 /* do we have a descriptors file? */
101 static int sysfs_has_descriptors = -1;
102
103 struct linux_device_priv {
104 char *sysfs_dir;
105 unsigned char *dev_descriptor;
106 unsigned char *config_descriptor;
107 };
108
109 struct linux_device_handle_priv {
110 int fd;
111 };
112
113 enum reap_action {
114 NORMAL = 0,
115 /* submission failed after the first URB, so await cancellation/completion
116 * of all the others */
117 SUBMIT_FAILED,
118
119 /* cancelled by user or timeout */
120 CANCELLED,
121
122 /* completed multi-URB transfer in non-final URB */
123 COMPLETED_EARLY,
124 };
125
126 struct linux_transfer_priv {
127 union {
128 struct usbfs_urb *urbs;
129 struct usbfs_urb **iso_urbs;
130 };
131
132 enum reap_action reap_action;
133 int num_urbs;
134 unsigned int num_retired;
135
136 /* next iso packet in user-supplied transfer to be populated */
137 int iso_packet_offset;
138 };
139
__get_usbfs_path(struct libusb_device * dev,char * path)140 static void __get_usbfs_path(struct libusb_device *dev, char *path)
141 {
142 snprintf(path, PATH_MAX, "%s/%03d/%03d", usbfs_path, dev->bus_number,
143 dev->device_address);
144 }
145
__device_priv(struct libusb_device * dev)146 static struct linux_device_priv *__device_priv(struct libusb_device *dev)
147 {
148 return (struct linux_device_priv *) dev->os_priv;
149 }
150
__device_handle_priv(struct libusb_device_handle * handle)151 static struct linux_device_handle_priv *__device_handle_priv(
152 struct libusb_device_handle *handle)
153 {
154 return (struct linux_device_handle_priv *) handle->os_priv;
155 }
156
check_usb_vfs(const char * dirname)157 static int check_usb_vfs(const char *dirname)
158 {
159 DIR *dir;
160 struct dirent *entry;
161 int found = 0;
162
163 dir = opendir(dirname);
164 if (!dir)
165 return 0;
166
167 while ((entry = readdir(dir)) != NULL) {
168 if (entry->d_name[0] == '.')
169 continue;
170
171 /* We assume if we find any files that it must be the right place */
172 found = 1;
173 break;
174 }
175
176 closedir(dir);
177 return found;
178 }
179
find_usbfs_path(void)180 static const char *find_usbfs_path(void)
181 {
182 const char *path = "/dev/bus/usb";
183 const char *ret = NULL;
184
185 if (check_usb_vfs(path)) {
186 ret = path;
187 } else {
188 path = "/proc/bus/usb";
189 if (check_usb_vfs(path))
190 ret = path;
191 }
192
193 usbi_dbg("found usbfs at %s", ret);
194 return ret;
195 }
196
197 /* the monotonic clock is not usable on all systems (e.g. embedded ones often
198 * seem to lack it). fall back to REALTIME if we have to. */
find_monotonic_clock(void)199 static clockid_t find_monotonic_clock(void)
200 {
201 struct timespec ts;
202 int r;
203
204 /* Linux 2.6.28 adds CLOCK_MONOTONIC_RAW but we don't use it
205 * because it's not available through timerfd */
206 r = clock_gettime(CLOCK_MONOTONIC, &ts);
207 if (r == 0) {
208 return CLOCK_MONOTONIC;
209 } else {
210 usbi_dbg("monotonic clock doesn't work, errno %d", errno);
211 return CLOCK_REALTIME;
212 }
213 }
214
215 /* bulk continuation URB flag available from Linux 2.6.32 */
check_flag_bulk_continuation(void)216 static int check_flag_bulk_continuation(void)
217 {
218 struct utsname uts;
219 int sublevel;
220
221 if (uname(&uts) < 0)
222 return -1;
223 if (strlen(uts.release) < 4)
224 return 0;
225 if (strncmp(uts.release, "2.6.", 4) != 0)
226 return 0;
227
228 sublevel = atoi(uts.release + 4);
229 return sublevel >= 32;
230 }
231
op_init(struct libusb_context * ctx)232 static int op_init(struct libusb_context *ctx)
233 {
234 struct stat statbuf;
235 int r;
236
237 usbfs_path = find_usbfs_path();
238 if (!usbfs_path) {
239 usbi_err(ctx, "could not find usbfs");
240 return LIBUSB_ERROR_OTHER;
241 }
242
243 if (monotonic_clkid == -1)
244 monotonic_clkid = find_monotonic_clock();
245
246 if (supports_flag_bulk_continuation == -1) {
247 supports_flag_bulk_continuation = check_flag_bulk_continuation();
248 if (supports_flag_bulk_continuation == -1) {
249 usbi_err(ctx, "error checking for bulk continuation support");
250 return LIBUSB_ERROR_OTHER;
251 }
252 }
253
254 if (supports_flag_bulk_continuation)
255 usbi_dbg("bulk continuation flag supported");
256
257 r = stat(SYSFS_DEVICE_PATH, &statbuf);
258 if (r == 0 && S_ISDIR(statbuf.st_mode)) {
259 usbi_dbg("found usb devices in sysfs");
260 } else {
261 usbi_dbg("sysfs usb info not available");
262 sysfs_has_descriptors = 0;
263 sysfs_can_relate_devices = 0;
264 }
265
266 return 0;
267 }
268
usbfs_get_device_descriptor(struct libusb_device * dev,unsigned char * buffer)269 static int usbfs_get_device_descriptor(struct libusb_device *dev,
270 unsigned char *buffer)
271 {
272 struct linux_device_priv *priv = __device_priv(dev);
273
274 /* return cached copy */
275 memcpy(buffer, priv->dev_descriptor, DEVICE_DESC_LENGTH);
276 return 0;
277 }
278
__open_sysfs_attr(struct libusb_device * dev,const char * attr)279 static int __open_sysfs_attr(struct libusb_device *dev, const char *attr)
280 {
281 struct linux_device_priv *priv = __device_priv(dev);
282 char filename[PATH_MAX];
283 int fd;
284
285 snprintf(filename, PATH_MAX, "%s/%s/%s",
286 SYSFS_DEVICE_PATH, priv->sysfs_dir, attr);
287 fd = open(filename, O_RDONLY);
288 if (fd < 0) {
289 usbi_err(DEVICE_CTX(dev),
290 "open %s failed ret=%d errno=%d", filename, fd, errno);
291 return LIBUSB_ERROR_IO;
292 }
293
294 return fd;
295 }
296
sysfs_get_device_descriptor(struct libusb_device * dev,unsigned char * buffer)297 static int sysfs_get_device_descriptor(struct libusb_device *dev,
298 unsigned char *buffer)
299 {
300 int fd;
301 ssize_t r;
302
303 /* sysfs provides access to an in-memory copy of the device descriptor,
304 * so we use that rather than keeping our own copy */
305
306 fd = __open_sysfs_attr(dev, "descriptors");
307 if (fd < 0)
308 return fd;
309
310 r = read(fd, buffer, DEVICE_DESC_LENGTH);;
311 close(fd);
312 if (r < 0) {
313 usbi_err(DEVICE_CTX(dev), "read failed, ret=%d errno=%d", fd, errno);
314 return LIBUSB_ERROR_IO;
315 } else if (r < DEVICE_DESC_LENGTH) {
316 usbi_err(DEVICE_CTX(dev), "short read %d/%d", r, DEVICE_DESC_LENGTH);
317 return LIBUSB_ERROR_IO;
318 }
319
320 return 0;
321 }
322
op_get_device_descriptor(struct libusb_device * dev,unsigned char * buffer,int * host_endian)323 static int op_get_device_descriptor(struct libusb_device *dev,
324 unsigned char *buffer, int *host_endian)
325 {
326 if (sysfs_has_descriptors) {
327 return sysfs_get_device_descriptor(dev, buffer);
328 } else {
329 *host_endian = 1;
330 return usbfs_get_device_descriptor(dev, buffer);
331 }
332 }
333
usbfs_get_active_config_descriptor(struct libusb_device * dev,unsigned char * buffer,size_t len)334 static int usbfs_get_active_config_descriptor(struct libusb_device *dev,
335 unsigned char *buffer, size_t len)
336 {
337 struct linux_device_priv *priv = __device_priv(dev);
338 if (!priv->config_descriptor)
339 return LIBUSB_ERROR_NOT_FOUND; /* device is unconfigured */
340
341 /* retrieve cached copy */
342 memcpy(buffer, priv->config_descriptor, len);
343 return 0;
344 }
345
346 /* read the bConfigurationValue for a device */
sysfs_get_active_config(struct libusb_device * dev,int * config)347 static int sysfs_get_active_config(struct libusb_device *dev, int *config)
348 {
349 char *endptr;
350 char tmp[4] = {0, 0, 0, 0};
351 long num;
352 int fd;
353 size_t r;
354
355 fd = __open_sysfs_attr(dev, "bConfigurationValue");
356 if (fd < 0)
357 return fd;
358
359 r = read(fd, tmp, sizeof(tmp));
360 close(fd);
361 if (r < 0) {
362 usbi_err(DEVICE_CTX(dev),
363 "read bConfigurationValue failed ret=%d errno=%d", r, errno);
364 return LIBUSB_ERROR_IO;
365 } else if (r == 0) {
366 usbi_err(DEVICE_CTX(dev), "device unconfigured");
367 *config = -1;
368 return 0;
369 }
370
371 if (tmp[sizeof(tmp) - 1] != 0) {
372 usbi_err(DEVICE_CTX(dev), "not null-terminated?");
373 return LIBUSB_ERROR_IO;
374 } else if (tmp[0] == 0) {
375 usbi_err(DEVICE_CTX(dev), "no configuration value?");
376 return LIBUSB_ERROR_IO;
377 }
378
379 num = strtol(tmp, &endptr, 10);
380 if (endptr == tmp) {
381 usbi_err(DEVICE_CTX(dev), "error converting '%s' to integer", tmp);
382 return LIBUSB_ERROR_IO;
383 }
384
385 *config = (int) num;
386 return 0;
387 }
388
389 /* takes a usbfs/descriptors fd seeked to the start of a configuration, and
390 * seeks to the next one. */
seek_to_next_config(struct libusb_context * ctx,int fd,int host_endian)391 static int seek_to_next_config(struct libusb_context *ctx, int fd,
392 int host_endian)
393 {
394 struct libusb_config_descriptor config;
395 unsigned char tmp[6];
396 off_t off;
397 int r;
398
399 /* read first 6 bytes of descriptor */
400 r = read(fd, tmp, sizeof(tmp));
401 if (r < 0) {
402 usbi_err(ctx, "read failed ret=%d errno=%d", r, errno);
403 return LIBUSB_ERROR_IO;
404 } else if (r < sizeof(tmp)) {
405 usbi_err(ctx, "short descriptor read %d/%d", r, sizeof(tmp));
406 return LIBUSB_ERROR_IO;
407 }
408
409 /* seek forward to end of config */
410 usbi_parse_descriptor(tmp, "bbwbb", &config, host_endian);
411 off = lseek(fd, config.wTotalLength - sizeof(tmp), SEEK_CUR);
412 if (off < 0) {
413 usbi_err(ctx, "seek failed ret=%d errno=%d", off, errno);
414 return LIBUSB_ERROR_IO;
415 }
416
417 return 0;
418 }
419
sysfs_get_active_config_descriptor(struct libusb_device * dev,unsigned char * buffer,size_t len)420 static int sysfs_get_active_config_descriptor(struct libusb_device *dev,
421 unsigned char *buffer, size_t len)
422 {
423 int fd;
424 ssize_t r;
425 off_t off;
426 int to_copy;
427 int config;
428 unsigned char tmp[6];
429
430 r = sysfs_get_active_config(dev, &config);
431 if (r < 0)
432 return r;
433 if (config == -1)
434 return LIBUSB_ERROR_NOT_FOUND;
435
436 usbi_dbg("active configuration %d", config);
437
438 /* sysfs provides access to an in-memory copy of the device descriptor,
439 * so we use that rather than keeping our own copy */
440
441 fd = __open_sysfs_attr(dev, "descriptors");
442 if (fd < 0)
443 return fd;
444
445 /* device might have been unconfigured since we read bConfigurationValue,
446 * so first check that there is any config descriptor data at all... */
447 off = lseek(fd, 0, SEEK_END);
448 if (off < 1) {
449 usbi_err(DEVICE_CTX(dev), "end seek failed, ret=%d errno=%d",
450 off, errno);
451 close(fd);
452 return LIBUSB_ERROR_IO;
453 } else if (off == DEVICE_DESC_LENGTH) {
454 close(fd);
455 return LIBUSB_ERROR_NOT_FOUND;
456 }
457
458 off = lseek(fd, DEVICE_DESC_LENGTH, SEEK_SET);
459 if (off < 0) {
460 usbi_err(DEVICE_CTX(dev), "seek failed, ret=%d errno=%d", off, errno);
461 close(fd);
462 return LIBUSB_ERROR_IO;
463 }
464
465 /* unbounded loop: we expect the descriptor to be present under all
466 * circumstances */
467 while (1) {
468 r = read(fd, tmp, sizeof(tmp));
469 if (r < 0) {
470 usbi_err(DEVICE_CTX(dev), "read failed, ret=%d errno=%d",
471 fd, errno);
472 return LIBUSB_ERROR_IO;
473 } else if (r < sizeof(tmp)) {
474 usbi_err(DEVICE_CTX(dev), "short read %d/%d", r, sizeof(tmp));
475 return LIBUSB_ERROR_IO;
476 }
477
478 /* check bConfigurationValue */
479 if (tmp[5] == config)
480 break;
481
482 /* try the next descriptor */
483 off = lseek(fd, 0 - sizeof(tmp), SEEK_CUR);
484 if (off < 0)
485 return LIBUSB_ERROR_IO;
486
487 r = seek_to_next_config(DEVICE_CTX(dev), fd, 1);
488 if (r < 0)
489 return r;
490 }
491
492 to_copy = (len < sizeof(tmp)) ? len : sizeof(tmp);
493 memcpy(buffer, tmp, to_copy);
494 if (len > sizeof(tmp)) {
495 r = read(fd, buffer + sizeof(tmp), len - sizeof(tmp));
496 if (r < 0) {
497 usbi_err(DEVICE_CTX(dev), "read failed, ret=%d errno=%d",
498 fd, errno);
499 r = LIBUSB_ERROR_IO;
500 } else if (r == 0) {
501 usbi_dbg("device is unconfigured");
502 r = LIBUSB_ERROR_NOT_FOUND;
503 } else if (r < len - sizeof(tmp)) {
504 usbi_err(DEVICE_CTX(dev), "short read %d/%d", r, len);
505 r = LIBUSB_ERROR_IO;
506 }
507 } else {
508 r = 0;
509 }
510
511 close(fd);
512 return r;
513 }
514
op_get_active_config_descriptor(struct libusb_device * dev,unsigned char * buffer,size_t len,int * host_endian)515 static int op_get_active_config_descriptor(struct libusb_device *dev,
516 unsigned char *buffer, size_t len, int *host_endian)
517 {
518 if (sysfs_has_descriptors) {
519 return sysfs_get_active_config_descriptor(dev, buffer, len);
520 } else {
521 return usbfs_get_active_config_descriptor(dev, buffer, len);
522 }
523 }
524
525 /* takes a usbfs fd, attempts to find the requested config and copy a certain
526 * amount of it into an output buffer. */
get_config_descriptor(struct libusb_context * ctx,int fd,uint8_t config_index,unsigned char * buffer,size_t len)527 static int get_config_descriptor(struct libusb_context *ctx, int fd,
528 uint8_t config_index, unsigned char *buffer, size_t len)
529 {
530 off_t off;
531 ssize_t r;
532
533 off = lseek(fd, DEVICE_DESC_LENGTH, SEEK_SET);
534 if (off < 0) {
535 usbi_err(ctx, "seek failed ret=%d errno=%d", off, errno);
536 return LIBUSB_ERROR_IO;
537 }
538
539 /* might need to skip some configuration descriptors to reach the
540 * requested configuration */
541 while (config_index > 0) {
542 r = seek_to_next_config(ctx, fd, 0);
543 if (r < 0)
544 return r;
545 config_index--;
546 }
547
548 /* read the rest of the descriptor */
549 r = read(fd, buffer, len);
550 if (r < 0) {
551 usbi_err(ctx, "read failed ret=%d errno=%d", r, errno);
552 return LIBUSB_ERROR_IO;
553 } else if (r < len) {
554 usbi_err(ctx, "short output read %d/%d", r, len);
555 return LIBUSB_ERROR_IO;
556 }
557
558 return 0;
559 }
560
op_get_config_descriptor(struct libusb_device * dev,uint8_t config_index,unsigned char * buffer,size_t len,int * host_endian)561 static int op_get_config_descriptor(struct libusb_device *dev,
562 uint8_t config_index, unsigned char *buffer, size_t len, int *host_endian)
563 {
564 char filename[PATH_MAX];
565 int fd;
566 int r;
567
568 /* always read from usbfs: sysfs only has the active descriptor
569 * this will involve waking the device up, but oh well! */
570
571 /* FIXME: the above is no longer true, new kernels have all descriptors
572 * in the descriptors file. but its kinda hard to detect if the kernel
573 * is sufficiently new. */
574
575 __get_usbfs_path(dev, filename);
576 fd = open(filename, O_RDONLY);
577 if (fd < 0) {
578 usbi_err(DEVICE_CTX(dev),
579 "open '%s' failed, ret=%d errno=%d", filename, fd, errno);
580 return LIBUSB_ERROR_IO;
581 }
582
583 r = get_config_descriptor(DEVICE_CTX(dev), fd, config_index, buffer, len);
584 close(fd);
585 return r;
586 }
587
588 /* cache the active config descriptor in memory. a value of -1 means that
589 * we aren't sure which one is active, so just assume the first one.
590 * only for usbfs. */
cache_active_config(struct libusb_device * dev,int fd,int active_config)591 static int cache_active_config(struct libusb_device *dev, int fd,
592 int active_config)
593 {
594 struct linux_device_priv *priv = __device_priv(dev);
595 struct libusb_config_descriptor config;
596 unsigned char tmp[8];
597 unsigned char *buf;
598 int idx;
599 int r;
600
601 if (active_config == -1) {
602 idx = 0;
603 } else {
604 r = usbi_get_config_index_by_value(dev, active_config, &idx);
605 if (r < 0)
606 return r;
607 if (idx == -1)
608 return LIBUSB_ERROR_NOT_FOUND;
609 }
610
611 r = get_config_descriptor(DEVICE_CTX(dev), fd, idx, tmp, sizeof(tmp));
612 if (r < 0) {
613 usbi_err(DEVICE_CTX(dev), "first read error %d", r);
614 return r;
615 }
616
617 usbi_parse_descriptor(tmp, "bbw", &config, 0);
618 buf = malloc(config.wTotalLength);
619 if (!buf)
620 return LIBUSB_ERROR_NO_MEM;
621
622 r = get_config_descriptor(DEVICE_CTX(dev), fd, idx, buf,
623 config.wTotalLength);
624 if (r < 0) {
625 free(buf);
626 return r;
627 }
628
629 if (priv->config_descriptor)
630 free(priv->config_descriptor);
631 priv->config_descriptor = buf;
632 return 0;
633 }
634
635 /* send a control message to retrieve active configuration */
usbfs_get_active_config(struct libusb_device * dev,int fd)636 static int usbfs_get_active_config(struct libusb_device *dev, int fd)
637 {
638 unsigned char active_config = 0;
639 int r;
640
641 struct usbfs_ctrltransfer ctrl = {
642 .bmRequestType = LIBUSB_ENDPOINT_IN,
643 .bRequest = LIBUSB_REQUEST_GET_CONFIGURATION,
644 .wValue = 0,
645 .wIndex = 0,
646 .wLength = 1,
647 .timeout = 1000,
648 .data = &active_config
649 };
650
651 r = ioctl(fd, IOCTL_USBFS_CONTROL, &ctrl);
652 if (r < 0) {
653 if (errno == ENODEV)
654 return LIBUSB_ERROR_NO_DEVICE;
655
656 /* we hit this error path frequently with buggy devices :( */
657 usbi_warn(DEVICE_CTX(dev),
658 "get_configuration failed ret=%d errno=%d", r, errno);
659 return LIBUSB_ERROR_IO;
660 }
661
662 return active_config;
663 }
664
initialize_device(struct libusb_device * dev,uint8_t busnum,uint8_t devaddr,const char * sysfs_dir)665 static int initialize_device(struct libusb_device *dev, uint8_t busnum,
666 uint8_t devaddr, const char *sysfs_dir)
667 {
668 struct linux_device_priv *priv = __device_priv(dev);
669 unsigned char *dev_buf;
670 char path[PATH_MAX];
671 int fd;
672 int active_config = 0;
673 int device_configured = 1;
674 ssize_t r;
675
676 dev->bus_number = busnum;
677 dev->device_address = devaddr;
678
679 if (sysfs_dir) {
680 priv->sysfs_dir = malloc(strlen(sysfs_dir) + 1);
681 if (!priv->sysfs_dir)
682 return LIBUSB_ERROR_NO_MEM;
683 strcpy(priv->sysfs_dir, sysfs_dir);
684 }
685
686 if (sysfs_has_descriptors)
687 return 0;
688
689 /* cache device descriptor in memory so that we can retrieve it later
690 * without waking the device up (op_get_device_descriptor) */
691
692 priv->dev_descriptor = NULL;
693 priv->config_descriptor = NULL;
694
695 if (sysfs_can_relate_devices) {
696 int tmp = sysfs_get_active_config(dev, &active_config);
697 if (tmp < 0)
698 return tmp;
699 if (active_config == -1)
700 device_configured = 0;
701 }
702
703 __get_usbfs_path(dev, path);
704 fd = open(path, O_RDWR);
705 if (fd < 0 && errno == EACCES) {
706 fd = open(path, O_RDONLY);
707 /* if we only have read-only access to the device, we cannot
708 * send a control message to determine the active config. just
709 * assume the first one is active. */
710 active_config = -1;
711 }
712
713 if (fd < 0) {
714 usbi_err(DEVICE_CTX(dev), "open failed, ret=%d errno=%d", fd, errno);
715 return LIBUSB_ERROR_IO;
716 }
717
718 if (!sysfs_can_relate_devices) {
719 if (active_config == -1) {
720 /* if we only have read-only access to the device, we cannot
721 * send a control message to determine the active config. just
722 * assume the first one is active. */
723 usbi_warn(DEVICE_CTX(dev), "access to %s is read-only; cannot "
724 "determine active configuration descriptor", path);
725 } else {
726 active_config = usbfs_get_active_config(dev, fd);
727 if (active_config == LIBUSB_ERROR_IO) {
728 /* buggy devices sometimes fail to report their active config.
729 * assume unconfigured and continue the probing */
730 usbi_warn(DEVICE_CTX(dev), "couldn't query active "
731 "configuration, assumung unconfigured");
732 device_configured = 0;
733 } else if (active_config < 0) {
734 close(fd);
735 return active_config;
736 } else if (active_config == 0) {
737 /* some buggy devices have a configuration 0, but we're
738 * reaching into the corner of a corner case here, so let's
739 * not support buggy devices in these circumstances.
740 * stick to the specs: a configuration value of 0 means
741 * unconfigured. */
742 usbi_dbg("active cfg 0? assuming unconfigured device");
743 device_configured = 0;
744 }
745 }
746 }
747
748 dev_buf = malloc(DEVICE_DESC_LENGTH);
749 if (!dev_buf) {
750 close(fd);
751 return LIBUSB_ERROR_NO_MEM;
752 }
753
754 r = read(fd, dev_buf, DEVICE_DESC_LENGTH);
755 if (r < 0) {
756 usbi_err(DEVICE_CTX(dev),
757 "read descriptor failed ret=%d errno=%d", fd, errno);
758 free(dev_buf);
759 close(fd);
760 return LIBUSB_ERROR_IO;
761 } else if (r < DEVICE_DESC_LENGTH) {
762 usbi_err(DEVICE_CTX(dev), "short descriptor read (%d)", r);
763 free(dev_buf);
764 close(fd);
765 return LIBUSB_ERROR_IO;
766 }
767
768 /* bit of a hack: set num_configurations now because cache_active_config()
769 * calls usbi_get_config_index_by_value() which uses it */
770 dev->num_configurations = dev_buf[DEVICE_DESC_LENGTH - 1];
771
772 if (device_configured) {
773 r = cache_active_config(dev, fd, active_config);
774 if (r < 0) {
775 close(fd);
776 free(dev_buf);
777 return r;
778 }
779 }
780
781 close(fd);
782 priv->dev_descriptor = dev_buf;
783 return 0;
784 }
785
enumerate_device(struct libusb_context * ctx,struct discovered_devs ** _discdevs,uint8_t busnum,uint8_t devaddr,const char * sysfs_dir)786 static int enumerate_device(struct libusb_context *ctx,
787 struct discovered_devs **_discdevs, uint8_t busnum, uint8_t devaddr,
788 const char *sysfs_dir)
789 {
790 struct discovered_devs *discdevs;
791 unsigned long session_id;
792 int need_unref = 0;
793 struct libusb_device *dev;
794 int r = 0;
795
796 /* FIXME: session ID is not guaranteed unique as addresses can wrap and
797 * will be reused. instead we should add a simple sysfs attribute with
798 * a session ID. */
799 session_id = busnum << 8 | devaddr;
800 usbi_dbg("busnum %d devaddr %d session_id %ld", busnum, devaddr,
801 session_id);
802
803 dev = usbi_get_device_by_session_id(ctx, session_id);
804 if (dev) {
805 usbi_dbg("using existing device for %d/%d (session %ld)",
806 busnum, devaddr, session_id);
807 } else {
808 usbi_dbg("allocating new device for %d/%d (session %ld)",
809 busnum, devaddr, session_id);
810 dev = usbi_alloc_device(ctx, session_id);
811 if (!dev)
812 return LIBUSB_ERROR_NO_MEM;
813 need_unref = 1;
814 r = initialize_device(dev, busnum, devaddr, sysfs_dir);
815 if (r < 0)
816 goto out;
817 r = usbi_sanitize_device(dev);
818 if (r < 0)
819 goto out;
820 }
821
822 discdevs = discovered_devs_append(*_discdevs, dev);
823 if (!discdevs)
824 r = LIBUSB_ERROR_NO_MEM;
825 else
826 *_discdevs = discdevs;
827
828 out:
829 if (need_unref)
830 libusb_unref_device(dev);
831 return r;
832 }
833
834 /* open a bus directory and adds all discovered devices to discdevs. on
835 * failure (non-zero return) the pre-existing discdevs should be destroyed
836 * (and devices freed). on success, the new discdevs pointer should be used
837 * as it may have been moved. */
usbfs_scan_busdir(struct libusb_context * ctx,struct discovered_devs ** _discdevs,uint8_t busnum)838 static int usbfs_scan_busdir(struct libusb_context *ctx,
839 struct discovered_devs **_discdevs, uint8_t busnum)
840 {
841 DIR *dir;
842 char dirpath[PATH_MAX];
843 struct dirent *entry;
844 struct discovered_devs *discdevs = *_discdevs;
845 int r = 0;
846
847 snprintf(dirpath, PATH_MAX, "%s/%03d", usbfs_path, busnum);
848 usbi_dbg("%s", dirpath);
849 dir = opendir(dirpath);
850 if (!dir) {
851 usbi_err(ctx, "opendir '%s' failed, errno=%d", dirpath, errno);
852 /* FIXME: should handle valid race conditions like hub unplugged
853 * during directory iteration - this is not an error */
854 return LIBUSB_ERROR_IO;
855 }
856
857 while ((entry = readdir(dir))) {
858 int devaddr;
859
860 if (entry->d_name[0] == '.')
861 continue;
862
863 devaddr = atoi(entry->d_name);
864 if (devaddr == 0) {
865 usbi_dbg("unknown dir entry %s", entry->d_name);
866 continue;
867 }
868
869 r = enumerate_device(ctx, &discdevs, busnum, (uint8_t) devaddr, NULL);
870 if (r < 0)
871 goto out;
872 }
873
874 *_discdevs = discdevs;
875 out:
876 closedir(dir);
877 return r;
878 }
879
usbfs_get_device_list(struct libusb_context * ctx,struct discovered_devs ** _discdevs)880 static int usbfs_get_device_list(struct libusb_context *ctx,
881 struct discovered_devs **_discdevs)
882 {
883 struct dirent *entry;
884 DIR *buses = opendir(usbfs_path);
885 struct discovered_devs *discdevs = *_discdevs;
886 int r = 0;
887
888 if (!buses) {
889 usbi_err(ctx, "opendir buses failed errno=%d", errno);
890 return LIBUSB_ERROR_IO;
891 }
892
893 while ((entry = readdir(buses))) {
894 struct discovered_devs *discdevs_new = discdevs;
895 int busnum;
896
897 if (entry->d_name[0] == '.')
898 continue;
899
900 busnum = atoi(entry->d_name);
901 if (busnum == 0) {
902 usbi_dbg("unknown dir entry %s", entry->d_name);
903 continue;
904 }
905
906 r = usbfs_scan_busdir(ctx, &discdevs_new, busnum);
907 if (r < 0)
908 goto out;
909 discdevs = discdevs_new;
910 }
911
912 out:
913 closedir(buses);
914 *_discdevs = discdevs;
915 return r;
916
917 }
918
sysfs_scan_device(struct libusb_context * ctx,struct discovered_devs ** _discdevs,const char * devname,int * usbfs_fallback)919 static int sysfs_scan_device(struct libusb_context *ctx,
920 struct discovered_devs **_discdevs, const char *devname,
921 int *usbfs_fallback)
922 {
923 int r;
924 FILE *fd;
925 char filename[PATH_MAX];
926 int busnum;
927 int devaddr;
928
929 usbi_dbg("scan %s", devname);
930
931 /* determine descriptors presence ahead of time, we need to know this
932 * when we reach initialize_device */
933 if (sysfs_has_descriptors == -1) {
934 struct stat statbuf;
935
936 snprintf(filename, PATH_MAX, "%s/%s/descriptors", SYSFS_DEVICE_PATH,
937 devname);
938 r = stat(filename, &statbuf);
939 if (r == 0 && S_ISREG(statbuf.st_mode)) {
940 usbi_dbg("sysfs descriptors available");
941 sysfs_has_descriptors = 1;
942 } else {
943 usbi_dbg("sysfs descriptors not available");
944 sysfs_has_descriptors = 0;
945 }
946 }
947
948 snprintf(filename, PATH_MAX, "%s/%s/busnum", SYSFS_DEVICE_PATH, devname);
949 fd = fopen(filename, "r");
950 if (!fd) {
951 if (errno == ENOENT) {
952 usbi_dbg("busnum not found, cannot relate sysfs to usbfs, "
953 "falling back on pure usbfs");
954 sysfs_can_relate_devices = 0;
955 *usbfs_fallback = 1;
956 return LIBUSB_ERROR_OTHER;
957 }
958 usbi_err(ctx, "open busnum failed, errno=%d", errno);
959 return LIBUSB_ERROR_IO;
960 }
961
962 sysfs_can_relate_devices = 1;
963
964 r = fscanf(fd, "%d", &busnum);
965 fclose(fd);
966 if (r != 1) {
967 usbi_err(ctx, "fscanf busnum returned %d, errno=%d", r, errno);
968 return LIBUSB_ERROR_IO;
969 }
970
971 snprintf(filename, PATH_MAX, "%s/%s/devnum", SYSFS_DEVICE_PATH, devname);
972 fd = fopen(filename, "r");
973 if (!fd) {
974 usbi_err(ctx, "open devnum failed, errno=%d", errno);
975 return LIBUSB_ERROR_IO;
976 }
977
978 r = fscanf(fd, "%d", &devaddr);
979 fclose(fd);
980 if (r != 1) {
981 usbi_err(ctx, "fscanf devnum returned %d, errno=%d", r, errno);
982 return LIBUSB_ERROR_IO;
983 }
984
985 usbi_dbg("bus=%d dev=%d", busnum, devaddr);
986 if (busnum > 255 || devaddr > 255)
987 return LIBUSB_ERROR_INVALID_PARAM;
988
989 return enumerate_device(ctx, _discdevs, busnum & 0xff, devaddr & 0xff,
990 devname);
991 }
992
sysfs_get_device_list(struct libusb_context * ctx,struct discovered_devs ** _discdevs,int * usbfs_fallback)993 static int sysfs_get_device_list(struct libusb_context *ctx,
994 struct discovered_devs **_discdevs, int *usbfs_fallback)
995 {
996 struct discovered_devs *discdevs = *_discdevs;
997 DIR *devices = opendir(SYSFS_DEVICE_PATH);
998 struct dirent *entry;
999 int r = 0;
1000
1001 if (!devices) {
1002 usbi_err(ctx, "opendir devices failed errno=%d", errno);
1003 return LIBUSB_ERROR_IO;
1004 }
1005
1006 while ((entry = readdir(devices))) {
1007 struct discovered_devs *discdevs_new = discdevs;
1008
1009 if ((!isdigit(entry->d_name[0]) && strncmp(entry->d_name, "usb", 3))
1010 || strchr(entry->d_name, ':'))
1011 continue;
1012
1013 r = sysfs_scan_device(ctx, &discdevs_new, entry->d_name,
1014 usbfs_fallback);
1015 if (r < 0)
1016 goto out;
1017 discdevs = discdevs_new;
1018 }
1019
1020 out:
1021 closedir(devices);
1022 *_discdevs = discdevs;
1023 return r;
1024 }
1025
op_get_device_list(struct libusb_context * ctx,struct discovered_devs ** _discdevs)1026 static int op_get_device_list(struct libusb_context *ctx,
1027 struct discovered_devs **_discdevs)
1028 {
1029 /* we can retrieve device list and descriptors from sysfs or usbfs.
1030 * sysfs is preferable, because if we use usbfs we end up resuming
1031 * any autosuspended USB devices. however, sysfs is not available
1032 * everywhere, so we need a usbfs fallback too.
1033 *
1034 * as described in the "sysfs vs usbfs" comment, sometimes we have
1035 * sysfs but not enough information to relate sysfs devices to usbfs
1036 * nodes. the usbfs_fallback variable is used to indicate that we should
1037 * fall back on usbfs.
1038 */
1039 if (sysfs_can_relate_devices != 0) {
1040 int usbfs_fallback = 0;
1041 int r = sysfs_get_device_list(ctx, _discdevs, &usbfs_fallback);
1042 if (!usbfs_fallback)
1043 return r;
1044 }
1045
1046 return usbfs_get_device_list(ctx, _discdevs);
1047 }
1048
op_open(struct libusb_device_handle * handle)1049 static int op_open(struct libusb_device_handle *handle)
1050 {
1051 struct linux_device_handle_priv *hpriv = __device_handle_priv(handle);
1052 char filename[PATH_MAX];
1053
1054 __get_usbfs_path(handle->dev, filename);
1055 hpriv->fd = open(filename, O_RDWR);
1056 if (hpriv->fd < 0) {
1057 if (errno == EACCES) {
1058 fprintf(stderr, "libusb couldn't open USB device %s: "
1059 "Permission denied.\n"
1060 "libusb requires write access to USB device nodes.\n",
1061 filename);
1062 return LIBUSB_ERROR_ACCESS;
1063 } else if (errno == ENOENT) {
1064 return LIBUSB_ERROR_NO_DEVICE;
1065 } else {
1066 usbi_err(HANDLE_CTX(handle),
1067 "open failed, code %d errno %d", hpriv->fd, errno);
1068 return LIBUSB_ERROR_IO;
1069 }
1070 }
1071
1072 return usbi_add_pollfd(HANDLE_CTX(handle), hpriv->fd, POLLOUT);
1073 }
1074
op_close(struct libusb_device_handle * dev_handle)1075 static void op_close(struct libusb_device_handle *dev_handle)
1076 {
1077 int fd = __device_handle_priv(dev_handle)->fd;
1078 usbi_remove_pollfd(HANDLE_CTX(dev_handle), fd);
1079 close(fd);
1080 }
1081
op_get_configuration(struct libusb_device_handle * handle,int * config)1082 static int op_get_configuration(struct libusb_device_handle *handle,
1083 int *config)
1084 {
1085 int r;
1086 if (sysfs_can_relate_devices != 1)
1087 return LIBUSB_ERROR_NOT_SUPPORTED;
1088
1089 r = sysfs_get_active_config(handle->dev, config);
1090 if (*config == -1)
1091 *config = 0;
1092
1093 return 0;
1094 }
1095
op_set_configuration(struct libusb_device_handle * handle,int config)1096 static int op_set_configuration(struct libusb_device_handle *handle, int config)
1097 {
1098 struct linux_device_priv *priv = __device_priv(handle->dev);
1099 int fd = __device_handle_priv(handle)->fd;
1100 int r = ioctl(fd, IOCTL_USBFS_SETCONFIG, &config);
1101 if (r) {
1102 if (errno == EINVAL)
1103 return LIBUSB_ERROR_NOT_FOUND;
1104 else if (errno == EBUSY)
1105 return LIBUSB_ERROR_BUSY;
1106 else if (errno == ENODEV)
1107 return LIBUSB_ERROR_NO_DEVICE;
1108
1109 usbi_err(HANDLE_CTX(handle), "failed, error %d errno %d", r, errno);
1110 return LIBUSB_ERROR_OTHER;
1111 }
1112
1113 if (!sysfs_has_descriptors) {
1114 /* update our cached active config descriptor */
1115 if (config == -1) {
1116 if (priv->config_descriptor) {
1117 free(priv->config_descriptor);
1118 priv->config_descriptor = NULL;
1119 }
1120 } else {
1121 r = cache_active_config(handle->dev, fd, config);
1122 if (r < 0)
1123 usbi_warn(HANDLE_CTX(handle),
1124 "failed to update cached config descriptor, error %d", r);
1125 }
1126 }
1127
1128 return 0;
1129 }
1130
op_claim_interface(struct libusb_device_handle * handle,int iface)1131 static int op_claim_interface(struct libusb_device_handle *handle, int iface)
1132 {
1133 int fd = __device_handle_priv(handle)->fd;
1134 int r = ioctl(fd, IOCTL_USBFS_CLAIMINTF, &iface);
1135 if (r) {
1136 if (errno == ENOENT)
1137 return LIBUSB_ERROR_NOT_FOUND;
1138 else if (errno == EBUSY)
1139 return LIBUSB_ERROR_BUSY;
1140 else if (errno == ENODEV)
1141 return LIBUSB_ERROR_NO_DEVICE;
1142
1143 usbi_err(HANDLE_CTX(handle),
1144 "claim interface failed, error %d errno %d", r, errno);
1145 return LIBUSB_ERROR_OTHER;
1146 }
1147 return 0;
1148 }
1149
op_release_interface(struct libusb_device_handle * handle,int iface)1150 static int op_release_interface(struct libusb_device_handle *handle, int iface)
1151 {
1152 int fd = __device_handle_priv(handle)->fd;
1153 int r = ioctl(fd, IOCTL_USBFS_RELEASEINTF, &iface);
1154 if (r) {
1155 if (errno == ENODEV)
1156 return LIBUSB_ERROR_NO_DEVICE;
1157
1158 usbi_err(HANDLE_CTX(handle),
1159 "release interface failed, error %d errno %d", r, errno);
1160 return LIBUSB_ERROR_OTHER;
1161 }
1162 return 0;
1163 }
1164
op_set_interface(struct libusb_device_handle * handle,int iface,int altsetting)1165 static int op_set_interface(struct libusb_device_handle *handle, int iface,
1166 int altsetting)
1167 {
1168 int fd = __device_handle_priv(handle)->fd;
1169 struct usbfs_setinterface setintf;
1170 int r;
1171
1172 setintf.interface = iface;
1173 setintf.altsetting = altsetting;
1174 r = ioctl(fd, IOCTL_USBFS_SETINTF, &setintf);
1175 if (r) {
1176 if (errno == EINVAL)
1177 return LIBUSB_ERROR_NOT_FOUND;
1178 else if (errno == ENODEV)
1179 return LIBUSB_ERROR_NO_DEVICE;
1180
1181 usbi_err(HANDLE_CTX(handle),
1182 "setintf failed error %d errno %d", r, errno);
1183 return LIBUSB_ERROR_OTHER;
1184 }
1185
1186 return 0;
1187 }
1188
op_clear_halt(struct libusb_device_handle * handle,unsigned char endpoint)1189 static int op_clear_halt(struct libusb_device_handle *handle,
1190 unsigned char endpoint)
1191 {
1192 int fd = __device_handle_priv(handle)->fd;
1193 unsigned int _endpoint = endpoint;
1194 int r = ioctl(fd, IOCTL_USBFS_CLEAR_HALT, &_endpoint);
1195 if (r) {
1196 if (errno == ENOENT)
1197 return LIBUSB_ERROR_NOT_FOUND;
1198 else if (errno == ENODEV)
1199 return LIBUSB_ERROR_NO_DEVICE;
1200
1201 usbi_err(HANDLE_CTX(handle),
1202 "clear_halt failed error %d errno %d", r, errno);
1203 return LIBUSB_ERROR_OTHER;
1204 }
1205
1206 return 0;
1207 }
1208
op_reset_device(struct libusb_device_handle * handle)1209 static int op_reset_device(struct libusb_device_handle *handle)
1210 {
1211 int fd = __device_handle_priv(handle)->fd;
1212 int r = ioctl(fd, IOCTL_USBFS_RESET, NULL);
1213 if (r) {
1214 if (errno == ENODEV)
1215 return LIBUSB_ERROR_NOT_FOUND;
1216
1217 usbi_err(HANDLE_CTX(handle),
1218 "reset failed error %d errno %d", r, errno);
1219 return LIBUSB_ERROR_OTHER;
1220 }
1221
1222 return 0;
1223 }
1224
op_kernel_driver_active(struct libusb_device_handle * handle,int interface)1225 static int op_kernel_driver_active(struct libusb_device_handle *handle,
1226 int interface)
1227 {
1228 int fd = __device_handle_priv(handle)->fd;
1229 struct usbfs_getdriver getdrv;
1230 int r;
1231
1232 getdrv.interface = interface;
1233 r = ioctl(fd, IOCTL_USBFS_GETDRIVER, &getdrv);
1234 if (r) {
1235 if (errno == ENODATA)
1236 return 0;
1237 else if (errno == ENODEV)
1238 return LIBUSB_ERROR_NO_DEVICE;
1239
1240 usbi_err(HANDLE_CTX(handle),
1241 "get driver failed error %d errno %d", r, errno);
1242 return LIBUSB_ERROR_OTHER;
1243 }
1244
1245 return 1;
1246 }
1247
op_detach_kernel_driver(struct libusb_device_handle * handle,int interface)1248 static int op_detach_kernel_driver(struct libusb_device_handle *handle,
1249 int interface)
1250 {
1251 int fd = __device_handle_priv(handle)->fd;
1252 struct usbfs_ioctl command;
1253 int r;
1254
1255 command.ifno = interface;
1256 command.ioctl_code = IOCTL_USBFS_DISCONNECT;
1257 command.data = NULL;
1258
1259 r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1260 if (r) {
1261 if (errno == ENODATA)
1262 return LIBUSB_ERROR_NOT_FOUND;
1263 else if (errno == EINVAL)
1264 return LIBUSB_ERROR_INVALID_PARAM;
1265 else if (errno == ENODEV)
1266 return LIBUSB_ERROR_NO_DEVICE;
1267
1268 usbi_err(HANDLE_CTX(handle),
1269 "detach failed error %d errno %d", r, errno);
1270 return LIBUSB_ERROR_OTHER;
1271 }
1272
1273 return 0;
1274 }
1275
op_attach_kernel_driver(struct libusb_device_handle * handle,int interface)1276 static int op_attach_kernel_driver(struct libusb_device_handle *handle,
1277 int interface)
1278 {
1279 int fd = __device_handle_priv(handle)->fd;
1280 struct usbfs_ioctl command;
1281 int r;
1282
1283 command.ifno = interface;
1284 command.ioctl_code = IOCTL_USBFS_CONNECT;
1285 command.data = NULL;
1286
1287 r = ioctl(fd, IOCTL_USBFS_IOCTL, &command);
1288 if (r < 0) {
1289 if (errno == ENODATA)
1290 return LIBUSB_ERROR_NOT_FOUND;
1291 else if (errno == EINVAL)
1292 return LIBUSB_ERROR_INVALID_PARAM;
1293 else if (errno == ENODEV)
1294 return LIBUSB_ERROR_NO_DEVICE;
1295 else if (errno == EBUSY)
1296 return LIBUSB_ERROR_BUSY;
1297
1298 usbi_err(HANDLE_CTX(handle),
1299 "attach failed error %d errno %d", r, errno);
1300 return LIBUSB_ERROR_OTHER;
1301 } else if (r == 0) {
1302 return LIBUSB_ERROR_NOT_FOUND;
1303 }
1304
1305 return 0;
1306 }
1307
op_destroy_device(struct libusb_device * dev)1308 static void op_destroy_device(struct libusb_device *dev)
1309 {
1310 struct linux_device_priv *priv = __device_priv(dev);
1311 if (!sysfs_has_descriptors) {
1312 if (priv->dev_descriptor)
1313 free(priv->dev_descriptor);
1314 if (priv->config_descriptor)
1315 free(priv->config_descriptor);
1316 }
1317 if (priv->sysfs_dir)
1318 free(priv->sysfs_dir);
1319 }
1320
free_iso_urbs(struct linux_transfer_priv * tpriv)1321 static void free_iso_urbs(struct linux_transfer_priv *tpriv)
1322 {
1323 int i;
1324 for (i = 0; i < tpriv->num_urbs; i++) {
1325 struct usbfs_urb *urb = tpriv->iso_urbs[i];
1326 if (!urb)
1327 break;
1328 free(urb);
1329 }
1330
1331 free(tpriv->iso_urbs);
1332 tpriv->iso_urbs = NULL;
1333 }
1334
submit_bulk_transfer(struct usbi_transfer * itransfer,unsigned char urb_type)1335 static int submit_bulk_transfer(struct usbi_transfer *itransfer,
1336 unsigned char urb_type)
1337 {
1338 struct libusb_transfer *transfer =
1339 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1340 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1341 struct linux_device_handle_priv *dpriv =
1342 __device_handle_priv(transfer->dev_handle);
1343 struct usbfs_urb *urbs;
1344 int is_out = (transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK)
1345 == LIBUSB_ENDPOINT_OUT;
1346 int r;
1347 int i;
1348 size_t alloc_size;
1349
1350 if (tpriv->urbs)
1351 return LIBUSB_ERROR_BUSY;
1352
1353 /* usbfs places a 16kb limit on bulk URBs. we divide up larger requests
1354 * into smaller units to meet such restriction, then fire off all the
1355 * units at once. it would be simpler if we just fired one unit at a time,
1356 * but there is a big performance gain through doing it this way. */
1357 int num_urbs = transfer->length / MAX_BULK_BUFFER_LENGTH;
1358 int last_urb_partial = 0;
1359
1360 if (transfer->length == 0) {
1361 num_urbs = 1;
1362 } else if ((transfer->length % MAX_BULK_BUFFER_LENGTH) > 0) {
1363 last_urb_partial = 1;
1364 num_urbs++;
1365 }
1366 usbi_dbg("need %d urbs for new transfer with length %d", num_urbs,
1367 transfer->length);
1368 alloc_size = num_urbs * sizeof(struct usbfs_urb);
1369 urbs = malloc(alloc_size);
1370 if (!urbs)
1371 return LIBUSB_ERROR_NO_MEM;
1372 memset(urbs, 0, alloc_size);
1373 tpriv->urbs = urbs;
1374 tpriv->num_urbs = num_urbs;
1375 tpriv->num_retired = 0;
1376 tpriv->reap_action = NORMAL;
1377
1378 for (i = 0; i < num_urbs; i++) {
1379 struct usbfs_urb *urb = &urbs[i];
1380 urb->usercontext = itransfer;
1381 urb->type = urb_type;
1382 urb->endpoint = transfer->endpoint;
1383 urb->buffer = transfer->buffer + (i * MAX_BULK_BUFFER_LENGTH);
1384 if (supports_flag_bulk_continuation && !is_out)
1385 urb->flags = USBFS_URB_SHORT_NOT_OK;
1386 if (i == num_urbs - 1 && last_urb_partial)
1387 urb->buffer_length = transfer->length % MAX_BULK_BUFFER_LENGTH;
1388 else if (transfer->length == 0)
1389 urb->buffer_length = 0;
1390 else
1391 urb->buffer_length = MAX_BULK_BUFFER_LENGTH;
1392
1393 if (i > 0 && supports_flag_bulk_continuation)
1394 urb->flags |= USBFS_URB_BULK_CONTINUATION;
1395
1396 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
1397 if (r < 0) {
1398 int j;
1399
1400 if (errno == ENODEV) {
1401 r = LIBUSB_ERROR_NO_DEVICE;
1402 } else {
1403 usbi_err(TRANSFER_CTX(transfer),
1404 "submiturb failed error %d errno=%d", r, errno);
1405 r = LIBUSB_ERROR_IO;
1406 }
1407
1408 /* if the first URB submission fails, we can simply free up and
1409 * return failure immediately. */
1410 if (i == 0) {
1411 usbi_dbg("first URB failed, easy peasy");
1412 free(urbs);
1413 tpriv->urbs = NULL;
1414 return r;
1415 }
1416
1417 /* if it's not the first URB that failed, the situation is a bit
1418 * tricky. we must discard all previous URBs. there are
1419 * complications:
1420 * - discarding is asynchronous - discarded urbs will be reaped
1421 * later. the user must not have freed the transfer when the
1422 * discarded URBs are reaped, otherwise libusb will be using
1423 * freed memory.
1424 * - the earlier URBs may have completed successfully and we do
1425 * not want to throw away any data.
1426 * so, in this case we discard all the previous URBs BUT we report
1427 * that the transfer was submitted successfully. then later when
1428 * the final discard completes we can report error to the user.
1429 */
1430 tpriv->reap_action = SUBMIT_FAILED;
1431
1432 /* The URBs we haven't submitted yet we count as already
1433 * retired. */
1434 tpriv->num_retired += num_urbs - i;
1435 for (j = 0; j < i; j++) {
1436 int tmp = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, &urbs[j]);
1437 if (tmp && errno != EINVAL)
1438 usbi_warn(TRANSFER_CTX(transfer),
1439 "unrecognised discard errno %d", errno);
1440 }
1441
1442 usbi_dbg("reporting successful submission but waiting for %d "
1443 "discards before reporting error", i);
1444 return 0;
1445 }
1446 }
1447
1448 return 0;
1449 }
1450
submit_iso_transfer(struct usbi_transfer * itransfer)1451 static int submit_iso_transfer(struct usbi_transfer *itransfer)
1452 {
1453 struct libusb_transfer *transfer =
1454 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1455 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1456 struct linux_device_handle_priv *dpriv =
1457 __device_handle_priv(transfer->dev_handle);
1458 struct usbfs_urb **urbs;
1459 size_t alloc_size;
1460 int num_packets = transfer->num_iso_packets;
1461 int i;
1462 int this_urb_len = 0;
1463 int num_urbs = 1;
1464 int packet_offset = 0;
1465 unsigned int packet_len;
1466 unsigned char *urb_buffer = transfer->buffer;
1467
1468 if (tpriv->iso_urbs)
1469 return LIBUSB_ERROR_BUSY;
1470
1471 /* usbfs places a 32kb limit on iso URBs. we divide up larger requests
1472 * into smaller units to meet such restriction, then fire off all the
1473 * units at once. it would be simpler if we just fired one unit at a time,
1474 * but there is a big performance gain through doing it this way. */
1475
1476 /* calculate how many URBs we need */
1477 for (i = 0; i < num_packets; i++) {
1478 int space_remaining = MAX_ISO_BUFFER_LENGTH - this_urb_len;
1479 packet_len = transfer->iso_packet_desc[i].length;
1480
1481 if (packet_len > space_remaining) {
1482 num_urbs++;
1483 this_urb_len = packet_len;
1484 } else {
1485 this_urb_len += packet_len;
1486 }
1487 }
1488 usbi_dbg("need %d 32k URBs for transfer", num_urbs);
1489
1490 alloc_size = num_urbs * sizeof(*urbs);
1491 urbs = malloc(alloc_size);
1492 if (!urbs)
1493 return LIBUSB_ERROR_NO_MEM;
1494 memset(urbs, 0, alloc_size);
1495
1496 tpriv->iso_urbs = urbs;
1497 tpriv->num_urbs = num_urbs;
1498 tpriv->num_retired = 0;
1499 tpriv->reap_action = NORMAL;
1500 tpriv->iso_packet_offset = 0;
1501
1502 /* allocate + initialize each URB with the correct number of packets */
1503 for (i = 0; i < num_urbs; i++) {
1504 struct usbfs_urb *urb;
1505 int space_remaining_in_urb = MAX_ISO_BUFFER_LENGTH;
1506 int urb_packet_offset = 0;
1507 unsigned char *urb_buffer_orig = urb_buffer;
1508 int j;
1509 int k;
1510
1511 /* swallow up all the packets we can fit into this URB */
1512 while (packet_offset < transfer->num_iso_packets) {
1513 packet_len = transfer->iso_packet_desc[packet_offset].length;
1514 if (packet_len <= space_remaining_in_urb) {
1515 /* throw it in */
1516 urb_packet_offset++;
1517 packet_offset++;
1518 space_remaining_in_urb -= packet_len;
1519 urb_buffer += packet_len;
1520 } else {
1521 /* it can't fit, save it for the next URB */
1522 break;
1523 }
1524 }
1525
1526 alloc_size = sizeof(*urb)
1527 + (urb_packet_offset * sizeof(struct usbfs_iso_packet_desc));
1528 urb = malloc(alloc_size);
1529 if (!urb) {
1530 free_iso_urbs(tpriv);
1531 return LIBUSB_ERROR_NO_MEM;
1532 }
1533 memset(urb, 0, alloc_size);
1534 urbs[i] = urb;
1535
1536 /* populate packet lengths */
1537 for (j = 0, k = packet_offset - urb_packet_offset;
1538 k < packet_offset; k++, j++) {
1539 packet_len = transfer->iso_packet_desc[k].length;
1540 urb->iso_frame_desc[j].length = packet_len;
1541 }
1542
1543 urb->usercontext = itransfer;
1544 urb->type = USBFS_URB_TYPE_ISO;
1545 /* FIXME: interface for non-ASAP data? */
1546 urb->flags = USBFS_URB_ISO_ASAP;
1547 urb->endpoint = transfer->endpoint;
1548 urb->number_of_packets = urb_packet_offset;
1549 urb->buffer = urb_buffer_orig;
1550 }
1551
1552 /* submit URBs */
1553 for (i = 0; i < num_urbs; i++) {
1554 int r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urbs[i]);
1555 if (r < 0) {
1556 int j;
1557
1558 if (errno == ENODEV) {
1559 r = LIBUSB_ERROR_NO_DEVICE;
1560 } else {
1561 usbi_err(TRANSFER_CTX(transfer),
1562 "submiturb failed error %d errno=%d", r, errno);
1563 r = LIBUSB_ERROR_IO;
1564 }
1565
1566 /* if the first URB submission fails, we can simply free up and
1567 * return failure immediately. */
1568 if (i == 0) {
1569 usbi_dbg("first URB failed, easy peasy");
1570 free_iso_urbs(tpriv);
1571 return r;
1572 }
1573
1574 /* if it's not the first URB that failed, the situation is a bit
1575 * tricky. we must discard all previous URBs. there are
1576 * complications:
1577 * - discarding is asynchronous - discarded urbs will be reaped
1578 * later. the user must not have freed the transfer when the
1579 * discarded URBs are reaped, otherwise libusb will be using
1580 * freed memory.
1581 * - the earlier URBs may have completed successfully and we do
1582 * not want to throw away any data.
1583 * so, in this case we discard all the previous URBs BUT we report
1584 * that the transfer was submitted successfully. then later when
1585 * the final discard completes we can report error to the user.
1586 */
1587 tpriv->reap_action = SUBMIT_FAILED;
1588
1589 /* The URBs we haven't submitted yet we count as already
1590 * retired. */
1591 tpriv->num_retired = num_urbs - i;
1592 for (j = 0; j < i; j++) {
1593 int tmp = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, urbs[j]);
1594 if (tmp && errno != EINVAL)
1595 usbi_warn(TRANSFER_CTX(transfer),
1596 "unrecognised discard errno %d", errno);
1597 }
1598
1599 usbi_dbg("reporting successful submission but waiting for %d "
1600 "discards before reporting error", i);
1601 return 0;
1602 }
1603 }
1604
1605 return 0;
1606 }
1607
submit_control_transfer(struct usbi_transfer * itransfer)1608 static int submit_control_transfer(struct usbi_transfer *itransfer)
1609 {
1610 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1611 struct libusb_transfer *transfer =
1612 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1613 struct linux_device_handle_priv *dpriv =
1614 __device_handle_priv(transfer->dev_handle);
1615 struct usbfs_urb *urb;
1616 int r;
1617
1618 if (tpriv->urbs)
1619 return LIBUSB_ERROR_BUSY;
1620
1621 if (transfer->length - LIBUSB_CONTROL_SETUP_SIZE > MAX_CTRL_BUFFER_LENGTH)
1622 return LIBUSB_ERROR_INVALID_PARAM;
1623
1624 urb = malloc(sizeof(struct usbfs_urb));
1625 if (!urb)
1626 return LIBUSB_ERROR_NO_MEM;
1627 memset(urb, 0, sizeof(struct usbfs_urb));
1628 tpriv->urbs = urb;
1629 tpriv->reap_action = NORMAL;
1630
1631 urb->usercontext = itransfer;
1632 urb->type = USBFS_URB_TYPE_CONTROL;
1633 urb->endpoint = transfer->endpoint;
1634 urb->buffer = transfer->buffer;
1635 urb->buffer_length = transfer->length;
1636
1637 r = ioctl(dpriv->fd, IOCTL_USBFS_SUBMITURB, urb);
1638 if (r < 0) {
1639 free(urb);
1640 tpriv->urbs = NULL;
1641 if (errno == ENODEV)
1642 return LIBUSB_ERROR_NO_DEVICE;
1643
1644 usbi_err(TRANSFER_CTX(transfer),
1645 "submiturb failed error %d errno=%d", r, errno);
1646 return LIBUSB_ERROR_IO;
1647 }
1648 return 0;
1649 }
1650
op_submit_transfer(struct usbi_transfer * itransfer)1651 static int op_submit_transfer(struct usbi_transfer *itransfer)
1652 {
1653 struct libusb_transfer *transfer =
1654 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1655
1656 switch (transfer->type) {
1657 case LIBUSB_TRANSFER_TYPE_CONTROL:
1658 return submit_control_transfer(itransfer);
1659 case LIBUSB_TRANSFER_TYPE_BULK:
1660 return submit_bulk_transfer(itransfer, USBFS_URB_TYPE_BULK);
1661 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1662 return submit_bulk_transfer(itransfer, USBFS_URB_TYPE_INTERRUPT);
1663 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1664 return submit_iso_transfer(itransfer);
1665 default:
1666 usbi_err(TRANSFER_CTX(transfer),
1667 "unknown endpoint type %d", transfer->type);
1668 return LIBUSB_ERROR_INVALID_PARAM;
1669 }
1670 }
1671
cancel_control_transfer(struct usbi_transfer * itransfer)1672 static int cancel_control_transfer(struct usbi_transfer *itransfer)
1673 {
1674 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1675 struct libusb_transfer *transfer =
1676 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1677 struct linux_device_handle_priv *dpriv =
1678 __device_handle_priv(transfer->dev_handle);
1679 int r;
1680
1681 if (!tpriv->urbs)
1682 return LIBUSB_ERROR_NOT_FOUND;
1683
1684 tpriv->reap_action = CANCELLED;
1685 r = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, tpriv->urbs);
1686 if(r) {
1687 if (errno == EINVAL) {
1688 usbi_dbg("URB not found --> assuming ready to be reaped");
1689 return 0;
1690 } else {
1691 usbi_err(TRANSFER_CTX(transfer),
1692 "unrecognised DISCARD code %d", errno);
1693 return LIBUSB_ERROR_OTHER;
1694 }
1695 }
1696
1697 return 0;
1698 }
1699
cancel_bulk_transfer(struct usbi_transfer * itransfer)1700 static int cancel_bulk_transfer(struct usbi_transfer *itransfer)
1701 {
1702 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1703 struct libusb_transfer *transfer =
1704 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1705 struct linux_device_handle_priv *dpriv =
1706 __device_handle_priv(transfer->dev_handle);
1707 int i;
1708
1709 if (!tpriv->urbs)
1710 return LIBUSB_ERROR_NOT_FOUND;
1711
1712 tpriv->reap_action = CANCELLED;
1713 for (i = 0; i < tpriv->num_urbs; i++) {
1714 int tmp = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, &tpriv->urbs[i]);
1715 if (tmp && errno != EINVAL)
1716 usbi_warn(TRANSFER_CTX(transfer),
1717 "unrecognised discard errno %d", errno);
1718 }
1719 return 0;
1720 }
1721
cancel_iso_transfer(struct usbi_transfer * itransfer)1722 static int cancel_iso_transfer(struct usbi_transfer *itransfer)
1723 {
1724 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1725 struct libusb_transfer *transfer =
1726 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1727 struct linux_device_handle_priv *dpriv =
1728 __device_handle_priv(transfer->dev_handle);
1729 int i;
1730
1731 if (!tpriv->iso_urbs)
1732 return LIBUSB_ERROR_NOT_FOUND;
1733
1734 tpriv->reap_action = CANCELLED;
1735 for (i = 0; i < tpriv->num_urbs; i++) {
1736 int tmp = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, tpriv->iso_urbs[i]);
1737 if (tmp && errno != EINVAL)
1738 usbi_warn(TRANSFER_CTX(transfer),
1739 "unrecognised discard errno %d", errno);
1740 }
1741 return 0;
1742 }
1743
op_cancel_transfer(struct usbi_transfer * itransfer)1744 static int op_cancel_transfer(struct usbi_transfer *itransfer)
1745 {
1746 struct libusb_transfer *transfer =
1747 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1748
1749 switch (transfer->type) {
1750 case LIBUSB_TRANSFER_TYPE_CONTROL:
1751 return cancel_control_transfer(itransfer);
1752 case LIBUSB_TRANSFER_TYPE_BULK:
1753 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1754 return cancel_bulk_transfer(itransfer);
1755 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1756 return cancel_iso_transfer(itransfer);
1757 default:
1758 usbi_err(TRANSFER_CTX(transfer),
1759 "unknown endpoint type %d", transfer->type);
1760 return LIBUSB_ERROR_INVALID_PARAM;
1761 }
1762 }
1763
op_clear_transfer_priv(struct usbi_transfer * itransfer)1764 static void op_clear_transfer_priv(struct usbi_transfer *itransfer)
1765 {
1766 struct libusb_transfer *transfer =
1767 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1768 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1769
1770 switch (transfer->type) {
1771 case LIBUSB_TRANSFER_TYPE_CONTROL:
1772 case LIBUSB_TRANSFER_TYPE_BULK:
1773 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
1774 free(tpriv->urbs);
1775 tpriv->urbs = NULL;
1776 break;
1777 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
1778 free_iso_urbs(tpriv);
1779 break;
1780 default:
1781 usbi_err(TRANSFER_CTX(transfer),
1782 "unknown endpoint type %d", transfer->type);
1783 }
1784 }
1785
handle_bulk_completion(struct usbi_transfer * itransfer,struct usbfs_urb * urb)1786 static int handle_bulk_completion(struct usbi_transfer *itransfer,
1787 struct usbfs_urb *urb)
1788 {
1789 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1790 int num_urbs = tpriv->num_urbs;
1791 int urb_idx = urb - tpriv->urbs;
1792 enum libusb_transfer_status status = LIBUSB_TRANSFER_COMPLETED;
1793 int r = 0;
1794
1795 pthread_mutex_lock(&itransfer->lock);
1796 usbi_dbg("handling completion status %d of bulk urb %d/%d", urb->status,
1797 urb_idx + 1, num_urbs);
1798
1799 tpriv->num_retired++;
1800
1801 if (tpriv->reap_action != NORMAL) {
1802 /* cancelled, submit_fail, or completed early */
1803 usbi_dbg("abnormal reap: urb status %d", urb->status);
1804
1805 /* even though we're in the process of cancelling, it's possible that
1806 * we may receive some data in these URBs that we don't want to lose.
1807 * examples:
1808 * 1. while the kernel is cancelling all the packets that make up an
1809 * URB, a few of them might complete. so we get back a successful
1810 * cancellation *and* some data.
1811 * 2. we receive a short URB which marks the early completion condition,
1812 * so we start cancelling the remaining URBs. however, we're too
1813 * slow and another URB completes (or at least completes partially).
1814 *
1815 * When this happens, our objectives are not to lose any "surplus" data,
1816 * and also to stick it at the end of the previously-received data
1817 * (closing any holes), so that libusb reports the total amount of
1818 * transferred data and presents it in a contiguous chunk.
1819 */
1820 if (urb->actual_length > 0) {
1821 struct libusb_transfer *transfer =
1822 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1823 unsigned char *target = transfer->buffer + itransfer->transferred;
1824 usbi_dbg("received %d bytes of surplus data", urb->actual_length);
1825 if (urb->buffer != target) {
1826 usbi_dbg("moving surplus data from offset %d to offset %d",
1827 (unsigned char *) urb->buffer - transfer->buffer,
1828 target - transfer->buffer);
1829 memmove(target, urb->buffer, urb->actual_length);
1830 }
1831 itransfer->transferred += urb->actual_length;
1832 }
1833
1834 if (tpriv->num_retired == num_urbs) {
1835 usbi_dbg("abnormal reap: last URB handled, reporting");
1836 if (tpriv->reap_action == CANCELLED) {
1837 free(tpriv->urbs);
1838 tpriv->urbs = NULL;
1839 pthread_mutex_unlock(&itransfer->lock);
1840 r = usbi_handle_transfer_cancellation(itransfer);
1841 goto out_unlock;
1842 }
1843 if (tpriv->reap_action != COMPLETED_EARLY)
1844 status = LIBUSB_TRANSFER_ERROR;
1845 goto completed;
1846 }
1847 goto out_unlock;
1848 }
1849
1850 if (urb->status == 0 || urb->status == -EREMOTEIO ||
1851 (urb->status == -EOVERFLOW && urb->actual_length > 0))
1852 itransfer->transferred += urb->actual_length;
1853
1854
1855 switch (urb->status) {
1856 case 0:
1857 break;
1858 case -EREMOTEIO: /* short transfer */
1859 break;
1860 case -EPIPE:
1861 usbi_dbg("detected endpoint stall");
1862 status = LIBUSB_TRANSFER_STALL;
1863 goto completed;
1864 case -EOVERFLOW:
1865 /* overflow can only ever occur in the last urb */
1866 usbi_dbg("overflow, actual_length=%d", urb->actual_length);
1867 status = LIBUSB_TRANSFER_OVERFLOW;
1868 goto completed;
1869 case -ETIME:
1870 case -EPROTO:
1871 case -EILSEQ:
1872 usbi_dbg("low level error %d", urb->status);
1873 status = LIBUSB_TRANSFER_ERROR;
1874 goto completed;
1875 default:
1876 usbi_warn(ITRANSFER_CTX(itransfer),
1877 "unrecognised urb status %d", urb->status);
1878 status = LIBUSB_TRANSFER_ERROR;
1879 goto completed;
1880 }
1881
1882 /* if we're the last urb or we got less data than requested then we're
1883 * done */
1884 if (urb_idx == num_urbs - 1) {
1885 usbi_dbg("last URB in transfer --> complete!");
1886 } else if (urb->actual_length < urb->buffer_length) {
1887 struct libusb_transfer *transfer =
1888 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1889 struct linux_device_handle_priv *dpriv =
1890 __device_handle_priv(transfer->dev_handle);
1891 int i;
1892
1893 usbi_dbg("short transfer %d/%d --> complete!", urb->actual_length,
1894 urb->buffer_length);
1895
1896 /* we have to cancel the remaining urbs and wait for their completion
1897 * before reporting results */
1898 tpriv->reap_action = COMPLETED_EARLY;
1899 for (i = urb_idx + 1; i < tpriv->num_urbs; i++) {
1900 /* remaining URBs with continuation flag are automatically
1901 * cancelled by the kernel */
1902 if (tpriv->urbs[i].flags & USBFS_URB_BULK_CONTINUATION)
1903 continue;
1904 int tmp = ioctl(dpriv->fd, IOCTL_USBFS_DISCARDURB, &tpriv->urbs[i]);
1905 if (tmp && errno != EINVAL)
1906 usbi_warn(TRANSFER_CTX(transfer),
1907 "unrecognised discard errno %d", errno);
1908 }
1909 goto out_unlock;
1910 } else {
1911 goto out_unlock;
1912 }
1913
1914 completed:
1915 free(tpriv->urbs);
1916 tpriv->urbs = NULL;
1917 pthread_mutex_unlock(&itransfer->lock);
1918 return usbi_handle_transfer_completion(itransfer, status);
1919 out_unlock:
1920 pthread_mutex_unlock(&itransfer->lock);
1921 return r;
1922 }
1923
handle_iso_completion(struct usbi_transfer * itransfer,struct usbfs_urb * urb)1924 static int handle_iso_completion(struct usbi_transfer *itransfer,
1925 struct usbfs_urb *urb)
1926 {
1927 struct libusb_transfer *transfer =
1928 __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
1929 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
1930 int num_urbs = tpriv->num_urbs;
1931 int urb_idx = 0;
1932 int i;
1933
1934 pthread_mutex_lock(&itransfer->lock);
1935 for (i = 0; i < num_urbs; i++) {
1936 if (urb == tpriv->iso_urbs[i]) {
1937 urb_idx = i + 1;
1938 break;
1939 }
1940 }
1941 if (urb_idx == 0) {
1942 usbi_err(TRANSFER_CTX(transfer), "could not locate urb!");
1943 pthread_mutex_unlock(&itransfer->lock);
1944 return LIBUSB_ERROR_NOT_FOUND;
1945 }
1946
1947 usbi_dbg("handling completion status %d of iso urb %d/%d", urb->status,
1948 urb_idx, num_urbs);
1949
1950 if (urb->status == 0) {
1951 /* copy isochronous results back in */
1952
1953 for (i = 0; i < urb->number_of_packets; i++) {
1954 struct usbfs_iso_packet_desc *urb_desc = &urb->iso_frame_desc[i];
1955 struct libusb_iso_packet_descriptor *lib_desc =
1956 &transfer->iso_packet_desc[tpriv->iso_packet_offset++];
1957 lib_desc->status = urb_desc->status;
1958 lib_desc->actual_length = urb_desc->actual_length;
1959 }
1960 }
1961
1962 tpriv->num_retired++;
1963
1964 if (tpriv->reap_action != NORMAL) { /* cancelled or submit_fail */
1965 usbi_dbg("CANCEL: urb status %d", urb->status);
1966
1967 if (tpriv->num_retired == num_urbs) {
1968 usbi_dbg("CANCEL: last URB handled, reporting");
1969 free_iso_urbs(tpriv);
1970 if (tpriv->reap_action == CANCELLED) {
1971 pthread_mutex_unlock(&itransfer->lock);
1972 return usbi_handle_transfer_cancellation(itransfer);
1973 } else {
1974 pthread_mutex_unlock(&itransfer->lock);
1975 return usbi_handle_transfer_completion(itransfer,
1976 LIBUSB_TRANSFER_ERROR);
1977 }
1978 }
1979 goto out;
1980 }
1981
1982 switch (urb->status) {
1983 case 0:
1984 break;
1985 case -ETIME:
1986 case -EPROTO:
1987 case -EILSEQ:
1988 usbi_dbg("low-level USB error %d", urb->status);
1989 break;
1990 default:
1991 usbi_warn(TRANSFER_CTX(transfer),
1992 "unrecognised urb status %d", urb->status);
1993 break;
1994 }
1995
1996 /* if we're the last urb or we got less data than requested then we're
1997 * done */
1998 if (urb_idx == num_urbs) {
1999 usbi_dbg("last URB in transfer --> complete!");
2000 free_iso_urbs(tpriv);
2001 pthread_mutex_unlock(&itransfer->lock);
2002 return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
2003 }
2004
2005 out:
2006 pthread_mutex_unlock(&itransfer->lock);
2007 return 0;
2008 }
2009
handle_control_completion(struct usbi_transfer * itransfer,struct usbfs_urb * urb)2010 static int handle_control_completion(struct usbi_transfer *itransfer,
2011 struct usbfs_urb *urb)
2012 {
2013 struct linux_transfer_priv *tpriv = usbi_transfer_get_os_priv(itransfer);
2014 int status;
2015
2016 pthread_mutex_lock(&itransfer->lock);
2017 usbi_dbg("handling completion status %d", urb->status);
2018
2019 if (urb->status == 0)
2020 itransfer->transferred += urb->actual_length;
2021
2022 if (tpriv->reap_action == CANCELLED) {
2023 if (urb->status != 0 && urb->status != -ENOENT)
2024 usbi_warn(ITRANSFER_CTX(itransfer),
2025 "cancel: unrecognised urb status %d", urb->status);
2026 free(tpriv->urbs);
2027 tpriv->urbs = NULL;
2028 pthread_mutex_unlock(&itransfer->lock);
2029 return usbi_handle_transfer_cancellation(itransfer);
2030 }
2031
2032 switch (urb->status) {
2033 case 0:
2034 itransfer->transferred = urb->actual_length;
2035 status = LIBUSB_TRANSFER_COMPLETED;
2036 break;
2037 case -EPIPE:
2038 usbi_dbg("unsupported control request");
2039 status = LIBUSB_TRANSFER_STALL;
2040 break;
2041 case -ETIME:
2042 case -EPROTO:
2043 case -EILSEQ:
2044 usbi_dbg("low-level bus error occurred");
2045 status = LIBUSB_TRANSFER_ERROR;
2046 break;
2047 default:
2048 usbi_warn(ITRANSFER_CTX(itransfer),
2049 "unrecognised urb status %d", urb->status);
2050 status = LIBUSB_TRANSFER_ERROR;
2051 break;
2052 }
2053
2054 free(tpriv->urbs);
2055 tpriv->urbs = NULL;
2056 pthread_mutex_unlock(&itransfer->lock);
2057 return usbi_handle_transfer_completion(itransfer, status);
2058 }
2059
reap_for_handle(struct libusb_device_handle * handle)2060 static int reap_for_handle(struct libusb_device_handle *handle)
2061 {
2062 struct linux_device_handle_priv *hpriv = __device_handle_priv(handle);
2063 int r;
2064 struct usbfs_urb *urb;
2065 struct usbi_transfer *itransfer;
2066 struct libusb_transfer *transfer;
2067
2068 r = ioctl(hpriv->fd, IOCTL_USBFS_REAPURBNDELAY, &urb);
2069 if (r == -1 && errno == EAGAIN)
2070 return 1;
2071 if (r < 0) {
2072 if (errno == ENODEV)
2073 return LIBUSB_ERROR_NO_DEVICE;
2074
2075 usbi_err(HANDLE_CTX(handle), "reap failed error %d errno=%d",
2076 r, errno);
2077 return LIBUSB_ERROR_IO;
2078 }
2079
2080 itransfer = urb->usercontext;
2081 transfer = __USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
2082
2083 usbi_dbg("urb type=%d status=%d transferred=%d", urb->type, urb->status,
2084 urb->actual_length);
2085
2086 switch (transfer->type) {
2087 case LIBUSB_TRANSFER_TYPE_ISOCHRONOUS:
2088 return handle_iso_completion(itransfer, urb);
2089 case LIBUSB_TRANSFER_TYPE_BULK:
2090 case LIBUSB_TRANSFER_TYPE_INTERRUPT:
2091 return handle_bulk_completion(itransfer, urb);
2092 case LIBUSB_TRANSFER_TYPE_CONTROL:
2093 return handle_control_completion(itransfer, urb);
2094 default:
2095 usbi_err(HANDLE_CTX(handle), "unrecognised endpoint type %x",
2096 transfer->type);
2097 return LIBUSB_ERROR_OTHER;
2098 }
2099 }
2100
op_handle_events(struct libusb_context * ctx,struct pollfd * fds,nfds_t nfds,int num_ready)2101 static int op_handle_events(struct libusb_context *ctx,
2102 struct pollfd *fds, nfds_t nfds, int num_ready)
2103 {
2104 int r;
2105 int i = 0;
2106
2107 pthread_mutex_lock(&ctx->open_devs_lock);
2108 for (i = 0; i < nfds && num_ready > 0; i++) {
2109 struct pollfd *pollfd = &fds[i];
2110 struct libusb_device_handle *handle;
2111 struct linux_device_handle_priv *hpriv = NULL;
2112
2113 if (!pollfd->revents)
2114 continue;
2115
2116 num_ready--;
2117 list_for_each_entry(handle, &ctx->open_devs, list) {
2118 hpriv = __device_handle_priv(handle);
2119 if (hpriv->fd == pollfd->fd)
2120 break;
2121 }
2122
2123 if (pollfd->revents & POLLERR) {
2124 usbi_remove_pollfd(HANDLE_CTX(handle), hpriv->fd);
2125 usbi_handle_disconnect(handle);
2126 continue;
2127 }
2128
2129 r = reap_for_handle(handle);
2130 if (r == 1 || r == LIBUSB_ERROR_NO_DEVICE)
2131 continue;
2132 else if (r < 0)
2133 goto out;
2134 }
2135
2136 r = 0;
2137 out:
2138 pthread_mutex_unlock(&ctx->open_devs_lock);
2139 return r;
2140 }
2141
op_clock_gettime(int clk_id,struct timespec * tp)2142 static int op_clock_gettime(int clk_id, struct timespec *tp)
2143 {
2144 switch (clk_id) {
2145 case USBI_CLOCK_MONOTONIC:
2146 return clock_gettime(monotonic_clkid, tp);
2147 case USBI_CLOCK_REALTIME:
2148 return clock_gettime(CLOCK_REALTIME, tp);
2149 default:
2150 return LIBUSB_ERROR_INVALID_PARAM;
2151 }
2152 }
2153
2154 #ifdef USBI_TIMERFD_AVAILABLE
op_get_timerfd_clockid(void)2155 static clockid_t op_get_timerfd_clockid(void)
2156 {
2157 return monotonic_clkid;
2158
2159 }
2160 #endif
2161
2162 const struct usbi_os_backend linux_usbfs_backend = {
2163 .name = "Linux usbfs",
2164 .init = op_init,
2165 .exit = NULL,
2166 .get_device_list = op_get_device_list,
2167 .get_device_descriptor = op_get_device_descriptor,
2168 .get_active_config_descriptor = op_get_active_config_descriptor,
2169 .get_config_descriptor = op_get_config_descriptor,
2170
2171 .open = op_open,
2172 .close = op_close,
2173 .get_configuration = op_get_configuration,
2174 .set_configuration = op_set_configuration,
2175 .claim_interface = op_claim_interface,
2176 .release_interface = op_release_interface,
2177
2178 .set_interface_altsetting = op_set_interface,
2179 .clear_halt = op_clear_halt,
2180 .reset_device = op_reset_device,
2181
2182 .kernel_driver_active = op_kernel_driver_active,
2183 .detach_kernel_driver = op_detach_kernel_driver,
2184 .attach_kernel_driver = op_attach_kernel_driver,
2185
2186 .destroy_device = op_destroy_device,
2187
2188 .submit_transfer = op_submit_transfer,
2189 .cancel_transfer = op_cancel_transfer,
2190 .clear_transfer_priv = op_clear_transfer_priv,
2191
2192 .handle_events = op_handle_events,
2193
2194 .clock_gettime = op_clock_gettime,
2195
2196 #ifdef USBI_TIMERFD_AVAILABLE
2197 .get_timerfd_clockid = op_get_timerfd_clockid,
2198 #endif
2199
2200 .device_priv_size = sizeof(struct linux_device_priv),
2201 .device_handle_priv_size = sizeof(struct linux_device_handle_priv),
2202 .transfer_priv_size = sizeof(struct linux_transfer_priv),
2203 .add_iso_packet_size = 0,
2204 };
2205
2206