Commit | Line | Data |
---|---|---|
5bc9661c | 1 | /* $(CROSS_COMPILE)cc -Wall -Wextra -g -lpthread -o testusb testusb.c */ |
2201d6b1 DB |
2 | |
3 | /* | |
4 | * Copyright (c) 2002 by David Brownell | |
5bc9661c | 5 | * Copyright (c) 2010 by Samsung Electronics |
54b8360f | 6 | * Author: Michal Nazarewicz <mina86@mina86.com> |
2201d6b1 DB |
7 | * |
8 | * This program is free software; you can redistribute it and/or modify it | |
9 | * under the terms of the GNU General Public License as published by the | |
10 | * Free Software Foundation; either version 2 of the License, or (at your | |
11 | * option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, but | |
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
15 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 | * for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software Foundation, | |
20 | * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
21 | */ | |
22 | ||
5bc9661c MN |
23 | /* |
24 | * This program issues ioctls to perform the tests implemented by the | |
25 | * kernel driver. It can generate a variety of transfer patterns; you | |
26 | * should make sure to test both regular streaming and mixes of | |
27 | * transfer sizes (including short transfers). | |
28 | * | |
29 | * For more information on how this can be used and on USB testing | |
30 | * refer to <URL:http://www.linux-usb.org/usbtest/>. | |
31 | */ | |
32 | ||
2201d6b1 DB |
33 | #include <stdio.h> |
34 | #include <string.h> | |
35 | #include <ftw.h> | |
36 | #include <stdlib.h> | |
37 | #include <pthread.h> | |
38 | #include <unistd.h> | |
39 | #include <errno.h> | |
5bc9661c | 40 | #include <limits.h> |
2201d6b1 DB |
41 | |
42 | #include <sys/types.h> | |
43 | #include <sys/stat.h> | |
44 | #include <fcntl.h> | |
45 | ||
46 | #include <sys/ioctl.h> | |
47 | #include <linux/usbdevice_fs.h> | |
48 | ||
49 | /*-------------------------------------------------------------------------*/ | |
50 | ||
51 | #define TEST_CASES 30 | |
52 | ||
53 | // FIXME make these public somewhere; usbdevfs.h? | |
54 | ||
55 | struct usbtest_param { | |
56 | // inputs | |
57 | unsigned test_num; /* 0..(TEST_CASES-1) */ | |
58 | unsigned iterations; | |
59 | unsigned length; | |
60 | unsigned vary; | |
61 | unsigned sglen; | |
62 | ||
63 | // outputs | |
64 | struct timeval duration; | |
65 | }; | |
66 | #define USBTEST_REQUEST _IOWR('U', 100, struct usbtest_param) | |
67 | ||
68 | /*-------------------------------------------------------------------------*/ | |
69 | ||
70 | /* #include <linux/usb_ch9.h> */ | |
71 | ||
5bc9661c MN |
72 | #define USB_DT_DEVICE 0x01 |
73 | #define USB_DT_INTERFACE 0x04 | |
74 | ||
75 | #define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */ | |
76 | #define USB_CLASS_VENDOR_SPEC 0xff | |
77 | ||
78 | ||
2201d6b1 DB |
79 | struct usb_device_descriptor { |
80 | __u8 bLength; | |
81 | __u8 bDescriptorType; | |
82 | __u16 bcdUSB; | |
83 | __u8 bDeviceClass; | |
84 | __u8 bDeviceSubClass; | |
85 | __u8 bDeviceProtocol; | |
86 | __u8 bMaxPacketSize0; | |
87 | __u16 idVendor; | |
88 | __u16 idProduct; | |
89 | __u16 bcdDevice; | |
90 | __u8 iManufacturer; | |
91 | __u8 iProduct; | |
92 | __u8 iSerialNumber; | |
93 | __u8 bNumConfigurations; | |
94 | } __attribute__ ((packed)); | |
95 | ||
5bc9661c MN |
96 | struct usb_interface_descriptor { |
97 | __u8 bLength; | |
98 | __u8 bDescriptorType; | |
99 | ||
100 | __u8 bInterfaceNumber; | |
101 | __u8 bAlternateSetting; | |
102 | __u8 bNumEndpoints; | |
103 | __u8 bInterfaceClass; | |
104 | __u8 bInterfaceSubClass; | |
105 | __u8 bInterfaceProtocol; | |
106 | __u8 iInterface; | |
107 | } __attribute__ ((packed)); | |
108 | ||
2201d6b1 DB |
109 | enum usb_device_speed { |
110 | USB_SPEED_UNKNOWN = 0, /* enumerating */ | |
111 | USB_SPEED_LOW, USB_SPEED_FULL, /* usb 1.1 */ | |
112 | USB_SPEED_HIGH /* usb 2.0 */ | |
113 | }; | |
114 | ||
115 | /*-------------------------------------------------------------------------*/ | |
116 | ||
117 | static char *speed (enum usb_device_speed s) | |
118 | { | |
119 | switch (s) { | |
120 | case USB_SPEED_UNKNOWN: return "unknown"; | |
121 | case USB_SPEED_LOW: return "low"; | |
122 | case USB_SPEED_FULL: return "full"; | |
123 | case USB_SPEED_HIGH: return "high"; | |
124 | default: return "??"; | |
125 | } | |
126 | } | |
127 | ||
128 | struct testdev { | |
129 | struct testdev *next; | |
130 | char *name; | |
131 | pthread_t thread; | |
132 | enum usb_device_speed speed; | |
133 | unsigned ifnum : 8; | |
134 | unsigned forever : 1; | |
135 | int test; | |
136 | ||
137 | struct usbtest_param param; | |
138 | }; | |
139 | static struct testdev *testdevs; | |
140 | ||
5bc9661c | 141 | static int testdev_ffs_ifnum(FILE *fd) |
2201d6b1 | 142 | { |
5bc9661c MN |
143 | union { |
144 | char buf[255]; | |
145 | struct usb_interface_descriptor intf; | |
146 | } u; | |
147 | ||
148 | for (;;) { | |
149 | if (fread(u.buf, 1, 1, fd) != 1) | |
150 | return -1; | |
151 | if (fread(u.buf + 1, (unsigned char)u.buf[0] - 1, 1, fd) != 1) | |
152 | return -1; | |
153 | ||
154 | if (u.intf.bLength == sizeof u.intf | |
155 | && u.intf.bDescriptorType == USB_DT_INTERFACE | |
156 | && u.intf.bNumEndpoints == 2 | |
157 | && u.intf.bInterfaceClass == USB_CLASS_VENDOR_SPEC | |
158 | && u.intf.bInterfaceSubClass == 0 | |
159 | && u.intf.bInterfaceProtocol == 0) | |
160 | return (unsigned char)u.intf.bInterfaceNumber; | |
161 | } | |
162 | } | |
163 | ||
164 | static int testdev_ifnum(FILE *fd) | |
165 | { | |
166 | struct usb_device_descriptor dev; | |
167 | ||
168 | if (fread(&dev, sizeof dev, 1, fd) != 1) | |
169 | return -1; | |
170 | ||
171 | if (dev.bLength != sizeof dev || dev.bDescriptorType != USB_DT_DEVICE) | |
172 | return -1; | |
173 | ||
2201d6b1 | 174 | /* FX2 with (tweaked) bulksrc firmware */ |
5bc9661c MN |
175 | if (dev.idVendor == 0x0547 && dev.idProduct == 0x1002) |
176 | return 0; | |
2201d6b1 DB |
177 | |
178 | /*----------------------------------------------------*/ | |
179 | ||
180 | /* devices that start up using the EZ-USB default device and | |
181 | * which we can use after loading simple firmware. hotplug | |
182 | * can fxload it, and then run this test driver. | |
183 | * | |
184 | * we return false positives in two cases: | |
185 | * - the device has a "real" driver (maybe usb-serial) that | |
186 | * renumerates. the device should vanish quickly. | |
187 | * - the device doesn't have the test firmware installed. | |
188 | */ | |
189 | ||
190 | /* generic EZ-USB FX controller */ | |
5bc9661c MN |
191 | if (dev.idVendor == 0x0547 && dev.idProduct == 0x2235) |
192 | return 0; | |
2201d6b1 DB |
193 | |
194 | /* generic EZ-USB FX2 controller */ | |
5bc9661c MN |
195 | if (dev.idVendor == 0x04b4 && dev.idProduct == 0x8613) |
196 | return 0; | |
2201d6b1 DB |
197 | |
198 | /* CY3671 development board with EZ-USB FX */ | |
5bc9661c MN |
199 | if (dev.idVendor == 0x0547 && dev.idProduct == 0x0080) |
200 | return 0; | |
2201d6b1 DB |
201 | |
202 | /* Keyspan 19Qi uses an21xx (original EZ-USB) */ | |
5bc9661c MN |
203 | if (dev.idVendor == 0x06cd && dev.idProduct == 0x010b) |
204 | return 0; | |
2201d6b1 DB |
205 | |
206 | /*----------------------------------------------------*/ | |
207 | ||
208 | /* "gadget zero", Linux-USB test software */ | |
5bc9661c MN |
209 | if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a0) |
210 | return 0; | |
2201d6b1 DB |
211 | |
212 | /* user mode subset of that */ | |
5bc9661c MN |
213 | if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a4) |
214 | return testdev_ffs_ifnum(fd); | |
215 | /* return 0; */ | |
2201d6b1 DB |
216 | |
217 | /* iso version of usermode code */ | |
5bc9661c MN |
218 | if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a3) |
219 | return 0; | |
2201d6b1 DB |
220 | |
221 | /* some GPL'd test firmware uses these IDs */ | |
222 | ||
5bc9661c MN |
223 | if (dev.idVendor == 0xfff0 && dev.idProduct == 0xfff0) |
224 | return 0; | |
2201d6b1 DB |
225 | |
226 | /*----------------------------------------------------*/ | |
227 | ||
228 | /* iBOT2 high speed webcam */ | |
5bc9661c MN |
229 | if (dev.idVendor == 0x0b62 && dev.idProduct == 0x0059) |
230 | return 0; | |
2201d6b1 | 231 | |
5bc9661c MN |
232 | /*----------------------------------------------------*/ |
233 | ||
234 | /* the FunctionFS gadget can have the source/sink interface | |
235 | * anywhere. We look for an interface descriptor that match | |
236 | * what we expect. We ignore configuratiens thou. */ | |
237 | ||
238 | if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4ac | |
239 | && (dev.bDeviceClass == USB_CLASS_PER_INTERFACE | |
240 | || dev.bDeviceClass == USB_CLASS_VENDOR_SPEC)) | |
241 | return testdev_ffs_ifnum(fd); | |
242 | ||
243 | return -1; | |
2201d6b1 DB |
244 | } |
245 | ||
5bc9661c | 246 | static int find_testdev(const char *name, const struct stat *sb, int flag) |
2201d6b1 | 247 | { |
5bc9661c MN |
248 | FILE *fd; |
249 | int ifnum; | |
250 | struct testdev *entry; | |
251 | ||
252 | (void)sb; /* unused */ | |
2201d6b1 DB |
253 | |
254 | if (flag != FTW_F) | |
255 | return 0; | |
2201d6b1 | 256 | |
5bc9661c MN |
257 | fd = fopen(name, "rb"); |
258 | if (!fd) { | |
259 | perror(name); | |
2201d6b1 DB |
260 | return 0; |
261 | } | |
2201d6b1 | 262 | |
5bc9661c MN |
263 | ifnum = testdev_ifnum(fd); |
264 | fclose(fd); | |
265 | if (ifnum < 0) | |
266 | return 0; | |
2201d6b1 | 267 | |
5bc9661c MN |
268 | entry = calloc(1, sizeof *entry); |
269 | if (!entry) | |
270 | goto nomem; | |
2201d6b1 | 271 | |
5bc9661c MN |
272 | entry->name = strdup(name); |
273 | if (!entry->name) { | |
274 | free(entry); | |
275 | nomem: | |
276 | perror("malloc"); | |
277 | return 0; | |
2201d6b1 DB |
278 | } |
279 | ||
5bc9661c MN |
280 | entry->ifnum = ifnum; |
281 | ||
9742aecd | 282 | /* FIXME update USBDEVFS_CONNECTINFO so it tells about high speed etc */ |
5bc9661c MN |
283 | |
284 | fprintf(stderr, "%s speed\t%s\t%u\n", | |
285 | speed(entry->speed), entry->name, entry->ifnum); | |
286 | ||
287 | entry->next = testdevs; | |
288 | testdevs = entry; | |
2201d6b1 DB |
289 | return 0; |
290 | } | |
291 | ||
292 | static int | |
293 | usbdev_ioctl (int fd, int ifno, unsigned request, void *param) | |
294 | { | |
295 | struct usbdevfs_ioctl wrapper; | |
296 | ||
297 | wrapper.ifno = ifno; | |
298 | wrapper.ioctl_code = request; | |
299 | wrapper.data = param; | |
300 | ||
301 | return ioctl (fd, USBDEVFS_IOCTL, &wrapper); | |
302 | } | |
303 | ||
304 | static void *handle_testdev (void *arg) | |
305 | { | |
306 | struct testdev *dev = arg; | |
307 | int fd, i; | |
308 | int status; | |
309 | ||
310 | if ((fd = open (dev->name, O_RDWR)) < 0) { | |
311 | perror ("can't open dev file r/w"); | |
312 | return 0; | |
313 | } | |
314 | ||
315 | restart: | |
316 | for (i = 0; i < TEST_CASES; i++) { | |
317 | if (dev->test != -1 && dev->test != i) | |
318 | continue; | |
319 | dev->param.test_num = i; | |
320 | ||
321 | status = usbdev_ioctl (fd, dev->ifnum, | |
322 | USBTEST_REQUEST, &dev->param); | |
323 | if (status < 0 && errno == EOPNOTSUPP) | |
324 | continue; | |
325 | ||
326 | /* FIXME need a "syslog it" option for background testing */ | |
327 | ||
328 | /* NOTE: each thread emits complete lines; no fragments! */ | |
329 | if (status < 0) { | |
330 | char buf [80]; | |
331 | int err = errno; | |
332 | ||
333 | if (strerror_r (errno, buf, sizeof buf)) { | |
334 | snprintf (buf, sizeof buf, "error %d", err); | |
335 | errno = err; | |
336 | } | |
337 | printf ("%s test %d --> %d (%s)\n", | |
338 | dev->name, i, errno, buf); | |
339 | } else | |
340 | printf ("%s test %d, %4d.%.06d secs\n", dev->name, i, | |
341 | (int) dev->param.duration.tv_sec, | |
342 | (int) dev->param.duration.tv_usec); | |
343 | ||
344 | fflush (stdout); | |
345 | } | |
346 | if (dev->forever) | |
347 | goto restart; | |
348 | ||
349 | close (fd); | |
350 | return arg; | |
351 | } | |
352 | ||
9742aecd | 353 | static const char *usb_dir_find(void) |
5bc9661c | 354 | { |
f6fe916e | 355 | static char udev_usb_path[] = "/dev/bus/usb"; |
5bc9661c | 356 | |
f6fe916e DC |
357 | if (access(udev_usb_path, F_OK) == 0) |
358 | return udev_usb_path; | |
359 | ||
5bc9661c MN |
360 | return NULL; |
361 | } | |
362 | ||
363 | static int parse_num(unsigned *num, const char *str) | |
364 | { | |
365 | unsigned long val; | |
366 | char *end; | |
367 | ||
368 | errno = 0; | |
369 | val = strtoul(str, &end, 0); | |
370 | if (errno || *end || val > UINT_MAX) | |
371 | return -1; | |
372 | *num = val; | |
373 | return 0; | |
374 | } | |
375 | ||
2201d6b1 DB |
376 | int main (int argc, char **argv) |
377 | { | |
5bc9661c | 378 | |
2201d6b1 DB |
379 | int c; |
380 | struct testdev *entry; | |
381 | char *device; | |
9742aecd | 382 | const char *usb_dir = NULL; |
2201d6b1 DB |
383 | int all = 0, forever = 0, not = 0; |
384 | int test = -1 /* all */; | |
385 | struct usbtest_param param; | |
386 | ||
387 | /* pick defaults that works with all speeds, without short packets. | |
388 | * | |
389 | * Best per-frame data rates: | |
a7ea58f3 FB |
390 | * super speed,bulk 1024 * 16 * 8 = 131072 |
391 | * interrupt 1024 * 3 * 8 = 24576 | |
392 | * high speed, bulk 512 * 13 * 8 = 53248 | |
393 | * interrupt 1024 * 3 * 8 = 24576 | |
394 | * full speed, bulk/intr 64 * 19 = 1216 | |
395 | * interrupt 64 * 1 = 64 | |
396 | * low speed, interrupt 8 * 1 = 8 | |
2201d6b1 DB |
397 | */ |
398 | param.iterations = 1000; | |
9e44d194 | 399 | param.length = 1024; |
a7ea58f3 | 400 | param.vary = 1024; |
2201d6b1 DB |
401 | param.sglen = 32; |
402 | ||
403 | /* for easy use when hotplugging */ | |
404 | device = getenv ("DEVICE"); | |
405 | ||
7e54e978 | 406 | while ((c = getopt (argc, argv, "D:aA:c:g:hlns:t:v:")) != EOF) |
2201d6b1 DB |
407 | switch (c) { |
408 | case 'D': /* device, if only one */ | |
409 | device = optarg; | |
410 | continue; | |
9742aecd SS |
411 | case 'A': /* use all devices with specified USB dir */ |
412 | usb_dir = optarg; | |
5bc9661c | 413 | /* FALL THROUGH */ |
2201d6b1 | 414 | case 'a': /* use all devices */ |
5bc9661c | 415 | device = NULL; |
2201d6b1 DB |
416 | all = 1; |
417 | continue; | |
418 | case 'c': /* count iterations */ | |
5bc9661c | 419 | if (parse_num(¶m.iterations, optarg)) |
2201d6b1 DB |
420 | goto usage; |
421 | continue; | |
422 | case 'g': /* scatter/gather entries */ | |
5bc9661c | 423 | if (parse_num(¶m.sglen, optarg)) |
2201d6b1 DB |
424 | goto usage; |
425 | continue; | |
426 | case 'l': /* loop forever */ | |
427 | forever = 1; | |
428 | continue; | |
429 | case 'n': /* no test running! */ | |
430 | not = 1; | |
431 | continue; | |
432 | case 's': /* size of packet */ | |
5bc9661c | 433 | if (parse_num(¶m.length, optarg)) |
2201d6b1 DB |
434 | goto usage; |
435 | continue; | |
436 | case 't': /* run just one test */ | |
437 | test = atoi (optarg); | |
438 | if (test < 0) | |
439 | goto usage; | |
440 | continue; | |
441 | case 'v': /* vary packet size by ... */ | |
5bc9661c | 442 | if (parse_num(¶m.vary, optarg)) |
2201d6b1 DB |
443 | goto usage; |
444 | continue; | |
445 | case '?': | |
446 | case 'h': | |
447 | default: | |
448 | usage: | |
7e54e978 DC |
449 | fprintf (stderr, |
450 | "usage: %s [options]\n" | |
451 | "Options:\n" | |
452 | "\t-D dev only test specific device\n" | |
9742aecd | 453 | "\t-A usb-dir\n" |
7e54e978 DC |
454 | "\t-a test all recognized devices\n" |
455 | "\t-l loop forever(for stress test)\n" | |
456 | "\t-t testnum only run specified case\n" | |
457 | "\t-n no test running, show devices to be tested\n" | |
458 | "Case arguments:\n" | |
0f286379 | 459 | "\t-c iterations default 1000\n" |
9e44d194 | 460 | "\t-s transfer length default 1024\n" |
0f286379 | 461 | "\t-g sglen default 32\n" |
a7ea58f3 | 462 | "\t-v vary default 1024\n", |
7e54e978 | 463 | argv[0]); |
2201d6b1 DB |
464 | return 1; |
465 | } | |
466 | if (optind != argc) | |
467 | goto usage; | |
468 | if (!all && !device) { | |
469 | fprintf (stderr, "must specify '-a' or '-D dev', " | |
8a424bf4 | 470 | "or DEVICE=/dev/bus/usb/BBB/DDD in env\n"); |
2201d6b1 DB |
471 | goto usage; |
472 | } | |
473 | ||
9742aecd SS |
474 | /* Find usb device subdirectory */ |
475 | if (!usb_dir) { | |
476 | usb_dir = usb_dir_find(); | |
477 | if (!usb_dir) { | |
478 | fputs ("USB device files are missing\n", stderr); | |
5bc9661c MN |
479 | return -1; |
480 | } | |
2201d6b1 DB |
481 | } |
482 | ||
483 | /* collect and list the test devices */ | |
9742aecd SS |
484 | if (ftw (usb_dir, find_testdev, 3) != 0) { |
485 | fputs ("ftw failed; are USB device files missing?\n", stderr); | |
2201d6b1 DB |
486 | return -1; |
487 | } | |
488 | ||
489 | /* quit, run single test, or create test threads */ | |
490 | if (!testdevs && !device) { | |
491 | fputs ("no test devices recognized\n", stderr); | |
492 | return -1; | |
493 | } | |
494 | if (not) | |
495 | return 0; | |
496 | if (testdevs && testdevs->next == 0 && !device) | |
497 | device = testdevs->name; | |
498 | for (entry = testdevs; entry; entry = entry->next) { | |
499 | int status; | |
500 | ||
501 | entry->param = param; | |
502 | entry->forever = forever; | |
503 | entry->test = test; | |
504 | ||
505 | if (device) { | |
506 | if (strcmp (entry->name, device)) | |
507 | continue; | |
508 | return handle_testdev (entry) != entry; | |
509 | } | |
510 | status = pthread_create (&entry->thread, 0, handle_testdev, entry); | |
2c449e38 | 511 | if (status) |
2201d6b1 | 512 | perror ("pthread_create"); |
2201d6b1 DB |
513 | } |
514 | if (device) { | |
515 | struct testdev dev; | |
516 | ||
517 | /* kernel can recognize test devices we don't */ | |
518 | fprintf (stderr, "%s: %s may see only control tests\n", | |
519 | argv [0], device); | |
520 | ||
521 | memset (&dev, 0, sizeof dev); | |
522 | dev.name = device; | |
523 | dev.param = param; | |
524 | dev.forever = forever; | |
525 | dev.test = test; | |
526 | return handle_testdev (&dev) != &dev; | |
527 | } | |
528 | ||
529 | /* wait for tests to complete */ | |
530 | for (entry = testdevs; entry; entry = entry->next) { | |
531 | void *retval; | |
532 | ||
533 | if (pthread_join (entry->thread, &retval)) | |
534 | perror ("pthread_join"); | |
535 | /* testing errors discarded! */ | |
536 | } | |
537 | ||
538 | return 0; | |
539 | } |