• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* $(CROSS_COMPILE)cc -Wall -Wextra -g -lpthread -o testusb testusb.c */
2 
3 /*
4  * Copyright (c) 2002 by David Brownell
5  * Copyright (c) 2010 by Samsung Electronics
6  * Author: Michal Nazarewicz <mina86@mina86.com>
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 
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 
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>
40 #include <limits.h>
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 
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 
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 
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 
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 
speed(enum usb_device_speed s)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 
testdev_ffs_ifnum(FILE * fd)141 static int testdev_ffs_ifnum(FILE *fd)
142 {
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 
testdev_ifnum(FILE * fd)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 
174 	/* FX2 with (tweaked) bulksrc firmware */
175 	if (dev.idVendor == 0x0547 && dev.idProduct == 0x1002)
176 		return 0;
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 */
191 	if (dev.idVendor == 0x0547 && dev.idProduct == 0x2235)
192 		return 0;
193 
194 	/* generic EZ-USB FX2 controller */
195 	if (dev.idVendor == 0x04b4 && dev.idProduct == 0x8613)
196 		return 0;
197 
198 	/* CY3671 development board with EZ-USB FX */
199 	if (dev.idVendor == 0x0547 && dev.idProduct == 0x0080)
200 		return 0;
201 
202 	/* Keyspan 19Qi uses an21xx (original EZ-USB) */
203 	if (dev.idVendor == 0x06cd && dev.idProduct == 0x010b)
204 		return 0;
205 
206 	/*----------------------------------------------------*/
207 
208 	/* "gadget zero", Linux-USB test software */
209 	if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a0)
210 		return 0;
211 
212 	/* user mode subset of that */
213 	if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a4)
214 		return testdev_ffs_ifnum(fd);
215 		/* return 0; */
216 
217 	/* iso version of usermode code */
218 	if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a3)
219 		return 0;
220 
221 	/* some GPL'd test firmware uses these IDs */
222 
223 	if (dev.idVendor == 0xfff0 && dev.idProduct == 0xfff0)
224 		return 0;
225 
226 	/*----------------------------------------------------*/
227 
228 	/* iBOT2 high speed webcam */
229 	if (dev.idVendor == 0x0b62 && dev.idProduct == 0x0059)
230 		return 0;
231 
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;
244 }
245 
find_testdev(const char * name,const struct stat * sb,int flag)246 static int find_testdev(const char *name, const struct stat *sb, int flag)
247 {
248 	FILE				*fd;
249 	int				ifnum;
250 	struct testdev			*entry;
251 
252 	(void)sb; /* unused */
253 
254 	if (flag != FTW_F)
255 		return 0;
256 
257 	fd = fopen(name, "rb");
258 	if (!fd) {
259 		perror(name);
260 		return 0;
261 	}
262 
263 	ifnum = testdev_ifnum(fd);
264 	fclose(fd);
265 	if (ifnum < 0)
266 		return 0;
267 
268 	entry = calloc(1, sizeof *entry);
269 	if (!entry)
270 		goto nomem;
271 
272 	entry->name = strdup(name);
273 	if (!entry->name) {
274 		free(entry);
275 nomem:
276 		perror("malloc");
277 		return 0;
278 	}
279 
280 	entry->ifnum = ifnum;
281 
282 	/* FIXME update USBDEVFS_CONNECTINFO so it tells about high speed etc */
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;
289 	return 0;
290 }
291 
292 static int
usbdev_ioctl(int fd,int ifno,unsigned request,void * param)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 
handle_testdev(void * arg)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 
usb_dir_find(void)353 static const char *usb_dir_find(void)
354 {
355 	static char udev_usb_path[] = "/dev/bus/usb";
356 
357 	if (access(udev_usb_path, F_OK) == 0)
358 		return udev_usb_path;
359 
360 	return NULL;
361 }
362 
parse_num(unsigned * num,const char * str)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 
main(int argc,char ** argv)376 int main (int argc, char **argv)
377 {
378 
379 	int			c;
380 	struct testdev		*entry;
381 	char			*device;
382 	const char		*usb_dir = NULL;
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:
390 	 *     high speed, bulk       512 * 13 * 8 = 53248
391 	 *                 interrupt 1024 *  3 * 8 = 24576
392 	 *     full speed, bulk/intr   64 * 19     =  1216
393 	 *                 interrupt   64 *  1     =    64
394 	 *      low speed, interrupt    8 *  1     =     8
395 	 */
396 	param.iterations = 1000;
397 	param.length = 1024;
398 	param.vary = 512;
399 	param.sglen = 32;
400 
401 	/* for easy use when hotplugging */
402 	device = getenv ("DEVICE");
403 
404 	while ((c = getopt (argc, argv, "D:aA:c:g:hlns:t:v:")) != EOF)
405 	switch (c) {
406 	case 'D':	/* device, if only one */
407 		device = optarg;
408 		continue;
409 	case 'A':	/* use all devices with specified USB dir */
410 		usb_dir = optarg;
411 		/* FALL THROUGH */
412 	case 'a':	/* use all devices */
413 		device = NULL;
414 		all = 1;
415 		continue;
416 	case 'c':	/* count iterations */
417 		if (parse_num(&param.iterations, optarg))
418 			goto usage;
419 		continue;
420 	case 'g':	/* scatter/gather entries */
421 		if (parse_num(&param.sglen, optarg))
422 			goto usage;
423 		continue;
424 	case 'l':	/* loop forever */
425 		forever = 1;
426 		continue;
427 	case 'n':	/* no test running! */
428 		not = 1;
429 		continue;
430 	case 's':	/* size of packet */
431 		if (parse_num(&param.length, optarg))
432 			goto usage;
433 		continue;
434 	case 't':	/* run just one test */
435 		test = atoi (optarg);
436 		if (test < 0)
437 			goto usage;
438 		continue;
439 	case 'v':	/* vary packet size by ... */
440 		if (parse_num(&param.vary, optarg))
441 			goto usage;
442 		continue;
443 	case '?':
444 	case 'h':
445 	default:
446 usage:
447 		fprintf (stderr,
448 			"usage: %s [options]\n"
449 			"Options:\n"
450 			"\t-D dev		only test specific device\n"
451 			"\t-A usb-dir\n"
452 			"\t-a		test all recognized devices\n"
453 			"\t-l		loop forever(for stress test)\n"
454 			"\t-t testnum	only run specified case\n"
455 			"\t-n		no test running, show devices to be tested\n"
456 			"Case arguments:\n"
457 			"\t-c iterations		default 1000\n"
458 			"\t-s transfer length	default 1024\n"
459 			"\t-g sglen		default 32\n"
460 			"\t-v vary			default 512\n",
461 			argv[0]);
462 		return 1;
463 	}
464 	if (optind != argc)
465 		goto usage;
466 	if (!all && !device) {
467 		fprintf (stderr, "must specify '-a' or '-D dev', "
468 			"or DEVICE=/dev/bus/usb/BBB/DDD in env\n");
469 		goto usage;
470 	}
471 
472 	/* Find usb device subdirectory */
473 	if (!usb_dir) {
474 		usb_dir = usb_dir_find();
475 		if (!usb_dir) {
476 			fputs ("USB device files are missing\n", stderr);
477 			return -1;
478 		}
479 	}
480 
481 	/* collect and list the test devices */
482 	if (ftw (usb_dir, find_testdev, 3) != 0) {
483 		fputs ("ftw failed; are USB device files missing?\n", stderr);
484 		return -1;
485 	}
486 
487 	/* quit, run single test, or create test threads */
488 	if (!testdevs && !device) {
489 		fputs ("no test devices recognized\n", stderr);
490 		return -1;
491 	}
492 	if (not)
493 		return 0;
494 	if (testdevs && testdevs->next == 0 && !device)
495 		device = testdevs->name;
496 	for (entry = testdevs; entry; entry = entry->next) {
497 		int	status;
498 
499 		entry->param = param;
500 		entry->forever = forever;
501 		entry->test = test;
502 
503 		if (device) {
504 			if (strcmp (entry->name, device))
505 				continue;
506 			return handle_testdev (entry) != entry;
507 		}
508 		status = pthread_create (&entry->thread, 0, handle_testdev, entry);
509 		if (status)
510 			perror ("pthread_create");
511 	}
512 	if (device) {
513 		struct testdev		dev;
514 
515 		/* kernel can recognize test devices we don't */
516 		fprintf (stderr, "%s: %s may see only control tests\n",
517 				argv [0], device);
518 
519 		memset (&dev, 0, sizeof dev);
520 		dev.name = device;
521 		dev.param = param;
522 		dev.forever = forever;
523 		dev.test = test;
524 		return handle_testdev (&dev) != &dev;
525 	}
526 
527 	/* wait for tests to complete */
528 	for (entry = testdevs; entry; entry = entry->next) {
529 		void	*retval;
530 
531 		if (pthread_join (entry->thread, &retval))
532 			perror ("pthread_join");
533 		/* testing errors discarded! */
534 	}
535 
536 	return 0;
537 }
538