1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* $(CROSS_COMPILE)cc -Wall -Wextra -g -lpthread -o testusb testusb.c */
5 * Copyright (c) 2002 by David Brownell
6 * Copyright (c) 2010 by Samsung Electronics
7 * Author: Michal Nazarewicz <mina86@mina86.com>
11 * This program issues ioctls to perform the tests implemented by the
12 * kernel driver. It can generate a variety of transfer patterns; you
13 * should make sure to test both regular streaming and mixes of
14 * transfer sizes (including short transfers).
16 * For more information on how this can be used and on USB testing
17 * refer to <URL:http://www.linux-usb.org/usbtest/>.
29 #include <sys/types.h>
33 #include <sys/ioctl.h>
34 #include <linux/usbdevice_fs.h>
36 /*-------------------------------------------------------------------------*/
40 // FIXME make these public somewhere; usbdevfs.h?
42 struct usbtest_param
{
44 unsigned test_num
; /* 0..(TEST_CASES-1) */
51 struct timeval duration
;
53 #define USBTEST_REQUEST _IOWR('U', 100, struct usbtest_param)
55 /*-------------------------------------------------------------------------*/
57 /* #include <linux/usb_ch9.h> */
59 #define USB_DT_DEVICE 0x01
60 #define USB_DT_INTERFACE 0x04
62 #define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */
63 #define USB_CLASS_VENDOR_SPEC 0xff
66 struct usb_device_descriptor
{
80 __u8 bNumConfigurations
;
81 } __attribute__ ((packed
));
83 struct usb_interface_descriptor
{
87 __u8 bInterfaceNumber
;
88 __u8 bAlternateSetting
;
91 __u8 bInterfaceSubClass
;
92 __u8 bInterfaceProtocol
;
94 } __attribute__ ((packed
));
96 enum usb_device_speed
{
97 USB_SPEED_UNKNOWN
= 0, /* enumerating */
98 USB_SPEED_LOW
, USB_SPEED_FULL
, /* usb 1.1 */
99 USB_SPEED_HIGH
/* usb 2.0 */
102 /*-------------------------------------------------------------------------*/
104 static char *speed (enum usb_device_speed s
)
107 case USB_SPEED_UNKNOWN
: return "unknown";
108 case USB_SPEED_LOW
: return "low";
109 case USB_SPEED_FULL
: return "full";
110 case USB_SPEED_HIGH
: return "high";
111 default: return "??";
116 struct testdev
*next
;
119 enum usb_device_speed speed
;
121 unsigned forever
: 1;
124 struct usbtest_param param
;
126 static struct testdev
*testdevs
;
128 static int testdev_ffs_ifnum(FILE *fd
)
132 struct usb_interface_descriptor intf
;
136 if (fread(u
.buf
, 1, 1, fd
) != 1)
138 if (fread(u
.buf
+ 1, (unsigned char)u
.buf
[0] - 1, 1, fd
) != 1)
141 if (u
.intf
.bLength
== sizeof u
.intf
142 && u
.intf
.bDescriptorType
== USB_DT_INTERFACE
143 && u
.intf
.bNumEndpoints
== 2
144 && u
.intf
.bInterfaceClass
== USB_CLASS_VENDOR_SPEC
145 && u
.intf
.bInterfaceSubClass
== 0
146 && u
.intf
.bInterfaceProtocol
== 0)
147 return (unsigned char)u
.intf
.bInterfaceNumber
;
151 static int testdev_ifnum(FILE *fd
)
153 struct usb_device_descriptor dev
;
155 if (fread(&dev
, sizeof dev
, 1, fd
) != 1)
158 if (dev
.bLength
!= sizeof dev
|| dev
.bDescriptorType
!= USB_DT_DEVICE
)
161 /* FX2 with (tweaked) bulksrc firmware */
162 if (dev
.idVendor
== 0x0547 && dev
.idProduct
== 0x1002)
165 /*----------------------------------------------------*/
167 /* devices that start up using the EZ-USB default device and
168 * which we can use after loading simple firmware. hotplug
169 * can fxload it, and then run this test driver.
171 * we return false positives in two cases:
172 * - the device has a "real" driver (maybe usb-serial) that
173 * renumerates. the device should vanish quickly.
174 * - the device doesn't have the test firmware installed.
177 /* generic EZ-USB FX controller */
178 if (dev
.idVendor
== 0x0547 && dev
.idProduct
== 0x2235)
181 /* generic EZ-USB FX2 controller */
182 if (dev
.idVendor
== 0x04b4 && dev
.idProduct
== 0x8613)
185 /* CY3671 development board with EZ-USB FX */
186 if (dev
.idVendor
== 0x0547 && dev
.idProduct
== 0x0080)
189 /* Keyspan 19Qi uses an21xx (original EZ-USB) */
190 if (dev
.idVendor
== 0x06cd && dev
.idProduct
== 0x010b)
193 /*----------------------------------------------------*/
195 /* "gadget zero", Linux-USB test software */
196 if (dev
.idVendor
== 0x0525 && dev
.idProduct
== 0xa4a0)
199 /* user mode subset of that */
200 if (dev
.idVendor
== 0x0525 && dev
.idProduct
== 0xa4a4)
201 return testdev_ffs_ifnum(fd
);
204 /* iso version of usermode code */
205 if (dev
.idVendor
== 0x0525 && dev
.idProduct
== 0xa4a3)
208 /* some GPL'd test firmware uses these IDs */
210 if (dev
.idVendor
== 0xfff0 && dev
.idProduct
== 0xfff0)
213 /*----------------------------------------------------*/
215 /* iBOT2 high speed webcam */
216 if (dev
.idVendor
== 0x0b62 && dev
.idProduct
== 0x0059)
219 /*----------------------------------------------------*/
221 /* the FunctionFS gadget can have the source/sink interface
222 * anywhere. We look for an interface descriptor that match
223 * what we expect. We ignore configuratiens thou. */
225 if (dev
.idVendor
== 0x0525 && dev
.idProduct
== 0xa4ac
226 && (dev
.bDeviceClass
== USB_CLASS_PER_INTERFACE
227 || dev
.bDeviceClass
== USB_CLASS_VENDOR_SPEC
))
228 return testdev_ffs_ifnum(fd
);
233 static int find_testdev(const char *name
, const struct stat
*sb
, int flag
)
237 struct testdev
*entry
;
239 (void)sb
; /* unused */
244 fd
= fopen(name
, "rb");
250 ifnum
= testdev_ifnum(fd
);
255 entry
= calloc(1, sizeof *entry
);
259 entry
->name
= strdup(name
);
267 entry
->ifnum
= ifnum
;
268 entry
->next
= testdevs
;
274 usbdev_ioctl (int fd
, int ifno
, unsigned request
, void *param
)
276 struct usbdevfs_ioctl wrapper
;
279 wrapper
.ioctl_code
= request
;
280 wrapper
.data
= param
;
282 return ioctl (fd
, USBDEVFS_IOCTL
, &wrapper
);
285 static void *handle_testdev (void *arg
)
287 struct testdev
*dev
= arg
;
291 if ((fd
= open (dev
->name
, O_RDWR
)) < 0) {
292 perror ("can't open dev file r/w");
296 status
= ioctl(fd
, USBDEVFS_GET_SPEED
, NULL
);
298 fprintf(stderr
, "USBDEVFS_GET_SPEED failed %d\n", status
);
301 fprintf(stderr
, "%s speed\t%s\t%u\n",
302 speed(dev
->speed
), dev
->name
, dev
->ifnum
);
305 for (i
= 0; i
< TEST_CASES
; i
++) {
306 if (dev
->test
!= -1 && dev
->test
!= i
)
308 dev
->param
.test_num
= i
;
310 status
= usbdev_ioctl (fd
, dev
->ifnum
,
311 USBTEST_REQUEST
, &dev
->param
);
312 if (status
< 0 && errno
== EOPNOTSUPP
)
315 /* FIXME need a "syslog it" option for background testing */
317 /* NOTE: each thread emits complete lines; no fragments! */
322 if (strerror_r (errno
, buf
, sizeof buf
)) {
323 snprintf (buf
, sizeof buf
, "error %d", err
);
326 printf ("%s test %d --> %d (%s)\n",
327 dev
->name
, i
, errno
, buf
);
329 printf ("%s test %d, %4d.%.06d secs\n", dev
->name
, i
,
330 (int) dev
->param
.duration
.tv_sec
,
331 (int) dev
->param
.duration
.tv_usec
);
342 static const char *usb_dir_find(void)
344 static char udev_usb_path
[] = "/dev/bus/usb";
346 if (access(udev_usb_path
, F_OK
) == 0)
347 return udev_usb_path
;
352 static int parse_num(unsigned *num
, const char *str
)
358 val
= strtoul(str
, &end
, 0);
359 if (errno
|| *end
|| val
> UINT_MAX
)
365 int main (int argc
, char **argv
)
369 struct testdev
*entry
;
371 const char *usb_dir
= NULL
;
372 int all
= 0, forever
= 0, not = 0;
373 int test
= -1 /* all */;
374 struct usbtest_param param
;
376 /* pick defaults that works with all speeds, without short packets.
378 * Best per-frame data rates:
379 * super speed,bulk 1024 * 16 * 8 = 131072
380 * interrupt 1024 * 3 * 8 = 24576
381 * high speed, bulk 512 * 13 * 8 = 53248
382 * interrupt 1024 * 3 * 8 = 24576
383 * full speed, bulk/intr 64 * 19 = 1216
384 * interrupt 64 * 1 = 64
385 * low speed, interrupt 8 * 1 = 8
387 param
.iterations
= 1000;
392 /* for easy use when hotplugging */
393 device
= getenv ("DEVICE");
395 while ((c
= getopt (argc
, argv
, "D:aA:c:g:hlns:t:v:")) != EOF
)
397 case 'D': /* device, if only one */
400 case 'A': /* use all devices with specified USB dir */
403 case 'a': /* use all devices */
407 case 'c': /* count iterations */
408 if (parse_num(¶m
.iterations
, optarg
))
411 case 'g': /* scatter/gather entries */
412 if (parse_num(¶m
.sglen
, optarg
))
415 case 'l': /* loop forever */
418 case 'n': /* no test running! */
421 case 's': /* size of packet */
422 if (parse_num(¶m
.length
, optarg
))
425 case 't': /* run just one test */
426 test
= atoi (optarg
);
430 case 'v': /* vary packet size by ... */
431 if (parse_num(¶m
.vary
, optarg
))
439 "usage: %s [options]\n"
441 "\t-D dev only test specific device\n"
443 "\t-a test all recognized devices\n"
444 "\t-l loop forever(for stress test)\n"
445 "\t-t testnum only run specified case\n"
446 "\t-n no test running, show devices to be tested\n"
448 "\t-c iterations default 1000\n"
449 "\t-s transfer length default 1024\n"
450 "\t-g sglen default 32\n"
451 "\t-v vary default 1024\n",
457 if (!all
&& !device
) {
458 fprintf (stderr
, "must specify '-a' or '-D dev', "
459 "or DEVICE=/dev/bus/usb/BBB/DDD in env\n");
463 /* Find usb device subdirectory */
465 usb_dir
= usb_dir_find();
467 fputs ("USB device files are missing\n", stderr
);
472 /* collect and list the test devices */
473 if (ftw (usb_dir
, find_testdev
, 3) != 0) {
474 fputs ("ftw failed; are USB device files missing?\n", stderr
);
478 /* quit, run single test, or create test threads */
479 if (!testdevs
&& !device
) {
480 fputs ("no test devices recognized\n", stderr
);
485 if (testdevs
&& testdevs
->next
== 0 && !device
)
486 device
= testdevs
->name
;
487 for (entry
= testdevs
; entry
; entry
= entry
->next
) {
490 entry
->param
= param
;
491 entry
->forever
= forever
;
495 if (strcmp (entry
->name
, device
))
497 return handle_testdev (entry
) != entry
;
499 status
= pthread_create (&entry
->thread
, 0, handle_testdev
, entry
);
501 perror ("pthread_create");
506 /* kernel can recognize test devices we don't */
507 fprintf (stderr
, "%s: %s may see only control tests\n",
510 memset (&dev
, 0, sizeof dev
);
513 dev
.forever
= forever
;
515 return handle_testdev (&dev
) != &dev
;
518 /* wait for tests to complete */
519 for (entry
= testdevs
; entry
; entry
= entry
->next
) {
522 if (pthread_join (entry
->thread
, &retval
))
523 perror ("pthread_join");
524 /* testing errors discarded! */