?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[CONNECTOR]: async connector mode.
[linux-2.6/verdex.git] / drivers / usb / misc / usbtest.c
blob54799eb0bc600750dca99cc8b39224c2c28e62db
1 #include <linux/config.h>
2 #if !defined (DEBUG) && defined (CONFIG_USB_DEBUG)
3 # define DEBUG
4 #endif
5 #include <linux/kernel.h>
6 #include <linux/errno.h>
7 #include <linux/init.h>
8 #include <linux/slab.h>
9 #include <linux/mm.h>
10 #include <linux/module.h>
11 #include <linux/moduleparam.h>
12 #include <asm/scatterlist.h>
13
14 #include <linux/usb.h>
15
16
17 /*-------------------------------------------------------------------------*/
18
19 // FIXME make these public somewhere; usbdevfs.h?
20 //
21 struct usbtest_param {
22 // inputs
23 unsigned test_num; /* 0..(TEST_CASES-1) */
24 unsigned iterations;
25 unsigned length;
26 unsigned vary;
27 unsigned sglen;
28
29 // outputs
30 struct timeval duration;
31 };
32 #define USBTEST_REQUEST _IOWR('U', 100, struct usbtest_param)
33
34 /*-------------------------------------------------------------------------*/
35
36 #define GENERIC /* let probe() bind using module params */
37
38 /* Some devices that can be used for testing will have "real" drivers.
39 * Entries for those need to be enabled here by hand, after disabling
40 * that "real" driver.
41 */
42 //#define IBOT2 /* grab iBOT2 webcams */
43 //#define KEYSPAN_19Qi /* grab un-renumerated serial adapter */
44
45 /*-------------------------------------------------------------------------*/
46
47 struct usbtest_info {
48 const char *name;
49 u8 ep_in; /* bulk/intr source */
50 u8 ep_out; /* bulk/intr sink */
51 unsigned autoconf : 1;
52 unsigned ctrl_out : 1;
53 unsigned iso : 1; /* try iso in/out */
54 int alt;
55 };
56
57 /* this is accessed only through usbfs ioctl calls.
58 * one ioctl to issue a test ... one lock per device.
59 * tests create other threads if they need them.
60 * urbs and buffers are allocated dynamically,
61 * and data generated deterministically.
62 */
63 struct usbtest_dev {
64 struct usb_interface *intf;
65 struct usbtest_info *info;
66 int in_pipe;
67 int out_pipe;
68 int in_iso_pipe;
69 int out_iso_pipe;
70 struct usb_endpoint_descriptor *iso_in, *iso_out;
71 struct semaphore sem;
72
73 #define TBUF_SIZE 256
74 u8 *buf;
75 };
76
77 static struct usb_device *testdev_to_usbdev (struct usbtest_dev *test)
78 {
79 return interface_to_usbdev (test->intf);
80 }
81
82 /* set up all urbs so they can be used with either bulk or interrupt */
83 #define INTERRUPT_RATE 1 /* msec/transfer */
84
85 #define xprintk(tdev,level,fmt,args...) \
86 dev_printk(level , &(tdev)->intf->dev , fmt , ## args)
87
88 #ifdef DEBUG
89 #define DBG(dev,fmt,args...) \
90 xprintk(dev , KERN_DEBUG , fmt , ## args)
91 #else
92 #define DBG(dev,fmt,args...) \
93 do { } while (0)
94 #endif /* DEBUG */
95
96 #ifdef VERBOSE
97 #define VDBG DBG
98 #else
99 #define VDBG(dev,fmt,args...) \
100 do { } while (0)
101 #endif /* VERBOSE */
102
103 #define ERROR(dev,fmt,args...) \
104 xprintk(dev , KERN_ERR , fmt , ## args)
105 #define WARN(dev,fmt,args...) \
106 xprintk(dev , KERN_WARNING , fmt , ## args)
107 #define INFO(dev,fmt,args...) \
108 xprintk(dev , KERN_INFO , fmt , ## args)
109
110 /*-------------------------------------------------------------------------*/
111
112 static int
113 get_endpoints (struct usbtest_dev *dev, struct usb_interface *intf)
114 {
115 int tmp;
116 struct usb_host_interface *alt;
117 struct usb_host_endpoint *in, *out;
118 struct usb_host_endpoint *iso_in, *iso_out;
119 struct usb_device *udev;
120
121 for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
122 unsigned ep;
123
124 in = out = NULL;
125 iso_in = iso_out = NULL;
126 alt = intf->altsetting + tmp;
127
128 /* take the first altsetting with in-bulk + out-bulk;
129 * ignore other endpoints and altsetttings.
130 */
131 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
132 struct usb_host_endpoint *e;
133
134 e = alt->endpoint + ep;
135 switch (e->desc.bmAttributes) {
136 case USB_ENDPOINT_XFER_BULK:
137 break;
138 case USB_ENDPOINT_XFER_ISOC:
139 if (dev->info->iso)
140 goto try_iso;
141 // FALLTHROUGH
142 default:
143 continue;
144 }
145 if (e->desc.bEndpointAddress & USB_DIR_IN) {
146 if (!in)
147 in = e;
148 } else {
149 if (!out)
150 out = e;
151 }
152 continue;
153 try_iso:
154 if (e->desc.bEndpointAddress & USB_DIR_IN) {
155 if (!iso_in)
156 iso_in = e;
157 } else {
158 if (!iso_out)
159 iso_out = e;
160 }
161 }
162 if ((in && out) || (iso_in && iso_out))
163 goto found;
164 }
165 return -EINVAL;
166
167 found:
168 udev = testdev_to_usbdev (dev);
169 if (alt->desc.bAlternateSetting != 0) {
170 tmp = usb_set_interface (udev,
171 alt->desc.bInterfaceNumber,
172 alt->desc.bAlternateSetting);
173 if (tmp < 0)
174 return tmp;
175 }
176
177 if (in) {
178 dev->in_pipe = usb_rcvbulkpipe (udev,
179 in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
180 dev->out_pipe = usb_sndbulkpipe (udev,
181 out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
182 }
183 if (iso_in) {
184 dev->iso_in = &iso_in->desc;
185 dev->in_iso_pipe = usb_rcvisocpipe (udev,
186 iso_in->desc.bEndpointAddress
187 & USB_ENDPOINT_NUMBER_MASK);
188 dev->iso_out = &iso_out->desc;
189 dev->out_iso_pipe = usb_sndisocpipe (udev,
190 iso_out->desc.bEndpointAddress
191 & USB_ENDPOINT_NUMBER_MASK);
192 }
193 return 0;
194 }
195
196 /*-------------------------------------------------------------------------*/
197
198 /* Support for testing basic non-queued I/O streams.
199 *
200 * These just package urbs as requests that can be easily canceled.
201 * Each urb's data buffer is dynamically allocated; callers can fill
202 * them with non-zero test data (or test for it) when appropriate.
203 */
204
205 static void simple_callback (struct urb *urb, struct pt_regs *regs)
206 {
207 complete ((struct completion *) urb->context);
208 }
209
210 static struct urb *simple_alloc_urb (
211 struct usb_device *udev,
212 int pipe,
213 unsigned long bytes
214 )
215 {
216 struct urb *urb;
217
218 if (bytes < 0)
219 return NULL;
220 urb = usb_alloc_urb (0, SLAB_KERNEL);
221 if (!urb)
222 return urb;
223 usb_fill_bulk_urb (urb, udev, pipe, NULL, bytes, simple_callback, NULL);
224 urb->interval = (udev->speed == USB_SPEED_HIGH)
225 ? (INTERRUPT_RATE << 3)
226 : INTERRUPT_RATE;
227 urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
228 if (usb_pipein (pipe))
229 urb->transfer_flags |= URB_SHORT_NOT_OK;
230 urb->transfer_buffer = usb_buffer_alloc (udev, bytes, SLAB_KERNEL,
231 &urb->transfer_dma);
232 if (!urb->transfer_buffer) {
233 usb_free_urb (urb);
234 urb = NULL;
235 } else
236 memset (urb->transfer_buffer, 0, bytes);
237 return urb;
238 }
239
240 static unsigned pattern = 0;
241 module_param (pattern, uint, S_IRUGO);
242 // MODULE_PARM_DESC (pattern, "i/o pattern (0 == zeroes)");
243
244 static inline void simple_fill_buf (struct urb *urb)
245 {
246 unsigned i;
247 u8 *buf = urb->transfer_buffer;
248 unsigned len = urb->transfer_buffer_length;
249
250 switch (pattern) {
251 default:
252 // FALLTHROUGH
253 case 0:
254 memset (buf, 0, len);
255 break;
256 case 1: /* mod63 */
257 for (i = 0; i < len; i++)
258 *buf++ = (u8) (i % 63);
259 break;
260 }
261 }
262
263 static inline int simple_check_buf (struct urb *urb)
264 {
265 unsigned i;
266 u8 expected;
267 u8 *buf = urb->transfer_buffer;
268 unsigned len = urb->actual_length;
269
270 for (i = 0; i < len; i++, buf++) {
271 switch (pattern) {
272 /* all-zeroes has no synchronization issues */
273 case 0:
274 expected = 0;
275 break;
276 /* mod63 stays in sync with short-terminated transfers,
277 * or otherwise when host and gadget agree on how large
278 * each usb transfer request should be. resync is done
279 * with set_interface or set_config.
280 */
281 case 1: /* mod63 */
282 expected = i % 63;
283 break;
284 /* always fail unsupported patterns */
285 default:
286 expected = !*buf;
287 break;
288 }
289 if (*buf == expected)
290 continue;
291 dbg ("buf[%d] = %d (not %d)", i, *buf, expected);
292 return -EINVAL;
293 }
294 return 0;
295 }
296
297 static void simple_free_urb (struct urb *urb)
298 {
299 usb_buffer_free (urb->dev, urb->transfer_buffer_length,
300 urb->transfer_buffer, urb->transfer_dma);
301 usb_free_urb (urb);
302 }
303
304 static int simple_io (
305 struct urb *urb,
306 int iterations,
307 int vary,
308 int expected,
309 const char *label
310 )
311 {
312 struct usb_device *udev = urb->dev;
313 int max = urb->transfer_buffer_length;
314 struct completion completion;
315 int retval = 0;
316
317 urb->context = &completion;
318 while (retval == 0 && iterations-- > 0) {
319 init_completion (&completion);
320 if (usb_pipeout (urb->pipe))
321 simple_fill_buf (urb);
322 if ((retval = usb_submit_urb (urb, SLAB_KERNEL)) != 0)
323 break;
324
325 /* NOTE: no timeouts; can't be broken out of by interrupt */
326 wait_for_completion (&completion);
327 retval = urb->status;
328 urb->dev = udev;
329 if (retval == 0 && usb_pipein (urb->pipe))
330 retval = simple_check_buf (urb);
331
332 if (vary) {
333 int len = urb->transfer_buffer_length;
334
335 len += vary;
336 len %= max;
337 if (len == 0)
338 len = (vary < max) ? vary : max;
339 urb->transfer_buffer_length = len;
340 }
341
342 /* FIXME if endpoint halted, clear halt (and log) */
343 }
344 urb->transfer_buffer_length = max;
345
346 if (expected != retval)
347 dev_dbg (&udev->dev,
348 "%s failed, iterations left %d, status %d (not %d)\n",
349 label, iterations, retval, expected);
350 return retval;
351 }
352
353
354 /*-------------------------------------------------------------------------*/
355
356 /* We use scatterlist primitives to test queued I/O.
357 * Yes, this also tests the scatterlist primitives.
358 */
359
360 static void free_sglist (struct scatterlist *sg, int nents)
361 {
362 unsigned i;
363
364 if (!sg)
365 return;
366 for (i = 0; i < nents; i++) {
367 if (!sg [i].page)
368 continue;
369 kfree (page_address (sg [i].page) + sg [i].offset);
370 }
371 kfree (sg);
372 }
373
374 static struct scatterlist *
375 alloc_sglist (int nents, int max, int vary)
376 {
377 struct scatterlist *sg;
378 unsigned i;
379 unsigned size = max;
380
381 sg = kmalloc (nents * sizeof *sg, SLAB_KERNEL);
382 if (!sg)
383 return NULL;
384 memset (sg, 0, nents * sizeof *sg);
385
386 for (i = 0; i < nents; i++) {
387 char *buf;
388
389 buf = kmalloc (size, SLAB_KERNEL);
390 if (!buf) {
391 free_sglist (sg, i);
392 return NULL;
393 }
394 memset (buf, 0, size);
395
396 /* kmalloc pages are always physically contiguous! */
397 sg [i].page = virt_to_page (buf);
398 sg [i].offset = offset_in_page (buf);
399 sg [i].length = size;
400
401 if (vary) {
402 size += vary;
403 size %= max;
404 if (size == 0)
405 size = (vary < max) ? vary : max;
406 }
407 }
408
409 return sg;
410 }
411
412 static int perform_sglist (
413 struct usb_device *udev,
414 unsigned iterations,
415 int pipe,
416 struct usb_sg_request *req,
417 struct scatterlist *sg,
418 int nents
419 )
420 {
421 int retval = 0;
422
423 while (retval == 0 && iterations-- > 0) {
424 retval = usb_sg_init (req, udev, pipe,
425 (udev->speed == USB_SPEED_HIGH)
426 ? (INTERRUPT_RATE << 3)
427 : INTERRUPT_RATE,
428 sg, nents, 0, SLAB_KERNEL);
429
430 if (retval)
431 break;
432 usb_sg_wait (req);
433 retval = req->status;
434
435 /* FIXME if endpoint halted, clear halt (and log) */
436 }
437
438 // FIXME for unlink or fault handling tests, don't report
439 // failure if retval is as we expected ...
440
441 if (retval)
442 dbg ("perform_sglist failed, iterations left %d, status %d",
443 iterations, retval);
444 return retval;
445 }
446
447
448 /*-------------------------------------------------------------------------*/
449
450 /* unqueued control message testing
451 *
452 * there's a nice set of device functional requirements in chapter 9 of the
453 * usb 2.0 spec, which we can apply to ANY device, even ones that don't use
454 * special test firmware.
455 *
456 * we know the device is configured (or suspended) by the time it's visible
457 * through usbfs. we can't change that, so we won't test enumeration (which
458 * worked 'well enough' to get here, this time), power management (ditto),
459 * or remote wakeup (which needs human interaction).
460 */
461
462 static unsigned realworld = 1;
463 module_param (realworld, uint, 0);
464 MODULE_PARM_DESC (realworld, "clear to demand stricter spec compliance");
465
466 static int get_altsetting (struct usbtest_dev *dev)
467 {
468 struct usb_interface *iface = dev->intf;
469 struct usb_device *udev = interface_to_usbdev (iface);
470 int retval;
471
472 retval = usb_control_msg (udev, usb_rcvctrlpipe (udev, 0),
473 USB_REQ_GET_INTERFACE, USB_DIR_IN|USB_RECIP_INTERFACE,
474 0, iface->altsetting [0].desc.bInterfaceNumber,
475 dev->buf, 1, USB_CTRL_GET_TIMEOUT);
476 switch (retval) {
477 case 1:
478 return dev->buf [0];
479 case 0:
480 retval = -ERANGE;
481 // FALLTHROUGH
482 default:
483 return retval;
484 }
485 }
486
487 static int set_altsetting (struct usbtest_dev *dev, int alternate)
488 {
489 struct usb_interface *iface = dev->intf;
490 struct usb_device *udev;
491
492 if (alternate < 0 || alternate >= 256)
493 return -EINVAL;
494
495 udev = interface_to_usbdev (iface);
496 return usb_set_interface (udev,
497 iface->altsetting [0].desc.bInterfaceNumber,
498 alternate);
499 }
500
501 static int is_good_config (char *buf, int len)
502 {
503 struct usb_config_descriptor *config;
504
505 if (len < sizeof *config)
506 return 0;
507 config = (struct usb_config_descriptor *) buf;
508
509 switch (config->bDescriptorType) {
510 case USB_DT_CONFIG:
511 case USB_DT_OTHER_SPEED_CONFIG:
512 if (config->bLength != 9) {
513 dbg ("bogus config descriptor length");
514 return 0;
515 }
516 /* this bit 'must be 1' but often isn't */
517 if (!realworld && !(config->bmAttributes & 0x80)) {
518 dbg ("high bit of config attributes not set");
519 return 0;
520 }
521 if (config->bmAttributes & 0x1f) { /* reserved == 0 */
522 dbg ("reserved config bits set");
523 return 0;
524 }
525 break;
526 default:
527 return 0;
528 }
529
530 if (le16_to_cpu(config->wTotalLength) == len) /* read it all */
531 return 1;
532 if (le16_to_cpu(config->wTotalLength) >= TBUF_SIZE) /* max partial read */
533 return 1;
534 dbg ("bogus config descriptor read size");
535 return 0;
536 }
537
538 /* sanity test for standard requests working with usb_control_mesg() and some
539 * of the utility functions which use it.
540 *
541 * this doesn't test how endpoint halts behave or data toggles get set, since
542 * we won't do I/O to bulk/interrupt endpoints here (which is how to change
543 * halt or toggle). toggle testing is impractical without support from hcds.
544 *
545 * this avoids failing devices linux would normally work with, by not testing
546 * config/altsetting operations for devices that only support their defaults.
547 * such devices rarely support those needless operations.
548 *
549 * NOTE that since this is a sanity test, it's not examining boundary cases
550 * to see if usbcore, hcd, and device all behave right. such testing would
551 * involve varied read sizes and other operation sequences.
552 */
553 static int ch9_postconfig (struct usbtest_dev *dev)
554 {
555 struct usb_interface *iface = dev->intf;
556 struct usb_device *udev = interface_to_usbdev (iface);
557 int i, alt, retval;
558
559 /* [9.2.3] if there's more than one altsetting, we need to be able to
560 * set and get each one. mostly trusts the descriptors from usbcore.
561 */
562 for (i = 0; i < iface->num_altsetting; i++) {
563
564 /* 9.2.3 constrains the range here */
565 alt = iface->altsetting [i].desc.bAlternateSetting;
566 if (alt < 0 || alt >= iface->num_altsetting) {
567 dev_dbg (&iface->dev,
568 "invalid alt [%d].bAltSetting = %d\n",
569 i, alt);
570 }
571
572 /* [real world] get/set unimplemented if there's only one */
573 if (realworld && iface->num_altsetting == 1)
574 continue;
575
576 /* [9.4.10] set_interface */
577 retval = set_altsetting (dev, alt);
578 if (retval) {
579 dev_dbg (&iface->dev, "can't set_interface = %d, %d\n",
580 alt, retval);
581 return retval;
582 }
583
584 /* [9.4.4] get_interface always works */
585 retval = get_altsetting (dev);
586 if (retval != alt) {
587 dev_dbg (&iface->dev, "get alt should be %d, was %d\n",
588 alt, retval);
589 return (retval < 0) ? retval : -EDOM;
590 }
591
592 }
593
594 /* [real world] get_config unimplemented if there's only one */
595 if (!realworld || udev->descriptor.bNumConfigurations != 1) {
596 int expected = udev->actconfig->desc.bConfigurationValue;
597
598 /* [9.4.2] get_configuration always works
599 * ... although some cheap devices (like one TI Hub I've got)
600 * won't return config descriptors except before set_config.
601 */
602 retval = usb_control_msg (udev, usb_rcvctrlpipe (udev, 0),
603 USB_REQ_GET_CONFIGURATION,
604 USB_DIR_IN | USB_RECIP_DEVICE,
605 0, 0, dev->buf, 1, USB_CTRL_GET_TIMEOUT);
606 if (retval != 1 || dev->buf [0] != expected) {
607 dev_dbg (&iface->dev, "get config --> %d %d (1 %d)\n",
608 retval, dev->buf[0], expected);
609 return (retval < 0) ? retval : -EDOM;
610 }
611 }
612
613 /* there's always [9.4.3] a device descriptor [9.6.1] */
614 retval = usb_get_descriptor (udev, USB_DT_DEVICE, 0,
615 dev->buf, sizeof udev->descriptor);
616 if (retval != sizeof udev->descriptor) {
617 dev_dbg (&iface->dev, "dev descriptor --> %d\n", retval);
618 return (retval < 0) ? retval : -EDOM;
619 }
620
621 /* there's always [9.4.3] at least one config descriptor [9.6.3] */
622 for (i = 0; i < udev->descriptor.bNumConfigurations; i++) {
623 retval = usb_get_descriptor (udev, USB_DT_CONFIG, i,
624 dev->buf, TBUF_SIZE);
625 if (!is_good_config (dev->buf, retval)) {
626 dev_dbg (&iface->dev,
627 "config [%d] descriptor --> %d\n",
628 i, retval);
629 return (retval < 0) ? retval : -EDOM;
630 }
631
632 // FIXME cross-checking udev->config[i] to make sure usbcore
633 // parsed it right (etc) would be good testing paranoia
634 }
635
636 /* and sometimes [9.2.6.6] speed dependent descriptors */
637 if (le16_to_cpu(udev->descriptor.bcdUSB) == 0x0200) {
638 struct usb_qualifier_descriptor *d = NULL;
639
640 /* device qualifier [9.6.2] */
641 retval = usb_get_descriptor (udev,
642 USB_DT_DEVICE_QUALIFIER, 0, dev->buf,
643 sizeof (struct usb_qualifier_descriptor));
644 if (retval == -EPIPE) {
645 if (udev->speed == USB_SPEED_HIGH) {
646 dev_dbg (&iface->dev,
647 "hs dev qualifier --> %d\n",
648 retval);
649 return (retval < 0) ? retval : -EDOM;
650 }
651 /* usb2.0 but not high-speed capable; fine */
652 } else if (retval != sizeof (struct usb_qualifier_descriptor)) {
653 dev_dbg (&iface->dev, "dev qualifier --> %d\n", retval);
654 return (retval < 0) ? retval : -EDOM;
655 } else
656 d = (struct usb_qualifier_descriptor *) dev->buf;
657
658 /* might not have [9.6.2] any other-speed configs [9.6.4] */
659 if (d) {
660 unsigned max = d->bNumConfigurations;
661 for (i = 0; i < max; i++) {
662 retval = usb_get_descriptor (udev,
663 USB_DT_OTHER_SPEED_CONFIG, i,
664 dev->buf, TBUF_SIZE);
665 if (!is_good_config (dev->buf, retval)) {
666 dev_dbg (&iface->dev,
667 "other speed config --> %d\n",
668 retval);
669 return (retval < 0) ? retval : -EDOM;
670 }
671 }
672 }
673 }
674 // FIXME fetch strings from at least the device descriptor
675
676 /* [9.4.5] get_status always works */
677 retval = usb_get_status (udev, USB_RECIP_DEVICE, 0, dev->buf);
678 if (retval != 2) {
679 dev_dbg (&iface->dev, "get dev status --> %d\n", retval);
680 return (retval < 0) ? retval : -EDOM;
681 }
682
683 // FIXME configuration.bmAttributes says if we could try to set/clear
684 // the device's remote wakeup feature ... if we can, test that here
685
686 retval = usb_get_status (udev, USB_RECIP_INTERFACE,
687 iface->altsetting [0].desc.bInterfaceNumber, dev->buf);
688 if (retval != 2) {
689 dev_dbg (&iface->dev, "get interface status --> %d\n", retval);
690 return (retval < 0) ? retval : -EDOM;
691 }
692 // FIXME get status for each endpoint in the interface
693
694 return 0;
695 }
696
697 /*-------------------------------------------------------------------------*/
698
699 /* use ch9 requests to test whether:
700 * (a) queues work for control, keeping N subtests queued and
701 * active (auto-resubmit) for M loops through the queue.
702 * (b) protocol stalls (control-only) will autorecover.
703 * it's not like bulk/intr; no halt clearing.
704 * (c) short control reads are reported and handled.
705 * (d) queues are always processed in-order
706 */
707
708 struct ctrl_ctx {
709 spinlock_t lock;
710 struct usbtest_dev *dev;
711 struct completion complete;
712 unsigned count;
713 unsigned pending;
714 int status;
715 struct urb **urb;
716 struct usbtest_param *param;
717 int last;
718 };
719
720 #define NUM_SUBCASES 15 /* how many test subcases here? */
721
722 struct subcase {
723 struct usb_ctrlrequest setup;
724 int number;
725 int expected;
726 };
727
728 static void ctrl_complete (struct urb *urb, struct pt_regs *regs)
729 {
730 struct ctrl_ctx *ctx = urb->context;
731 struct usb_ctrlrequest *reqp;
732 struct subcase *subcase;
733 int status = urb->status;
734
735 reqp = (struct usb_ctrlrequest *)urb->setup_packet;
736 subcase = container_of (reqp, struct subcase, setup);
737
738 spin_lock (&ctx->lock);
739 ctx->count--;
740 ctx->pending--;
741
742 /* queue must transfer and complete in fifo order, unless
743 * usb_unlink_urb() is used to unlink something not at the
744 * physical queue head (not tested).
745 */
746 if (subcase->number > 0) {
747 if ((subcase->number - ctx->last) != 1) {
748 dbg ("subcase %d completed out of order, last %d",
749 subcase->number, ctx->last);
750 status = -EDOM;
751 ctx->last = subcase->number;
752 goto error;
753 }
754 }
755 ctx->last = subcase->number;
756
757 /* succeed or fault in only one way? */
758 if (status == subcase->expected)
759 status = 0;
760
761 /* async unlink for cleanup? */
762 else if (status != -ECONNRESET) {
763
764 /* some faults are allowed, not required */
765 if (subcase->expected > 0 && (
766 ((urb->status == -subcase->expected /* happened */
767 || urb->status == 0)))) /* didn't */
768 status = 0;
769 /* sometimes more than one fault is allowed */
770 else if (subcase->number == 12 && status == -EPIPE)
771 status = 0;
772 else
773 dbg ("subtest %d error, status %d",
774 subcase->number, status);
775 }
776
777 /* unexpected status codes mean errors; ideally, in hardware */
778 if (status) {
779 error:
780 if (ctx->status == 0) {
781 int i;
782
783 ctx->status = status;
784 info ("control queue %02x.%02x, err %d, %d left",
785 reqp->bRequestType, reqp->bRequest,
786 status, ctx->count);
787
788 /* FIXME this "unlink everything" exit route should
789 * be a separate test case.
790 */
791
792 /* unlink whatever's still pending */
793 for (i = 1; i < ctx->param->sglen; i++) {
794 struct urb *u = ctx->urb [
795 (i + subcase->number) % ctx->param->sglen];
796
797 if (u == urb || !u->dev)
798 continue;
799 status = usb_unlink_urb (u);
800 switch (status) {
801 case -EINPROGRESS:
802 case -EBUSY:
803 case -EIDRM:
804 continue;
805 default:
806 dbg ("urb unlink --> %d", status);
807 }
808 }
809 status = ctx->status;
810 }
811 }
812
813 /* resubmit if we need to, else mark this as done */
814 if ((status == 0) && (ctx->pending < ctx->count)) {
815 if ((status = usb_submit_urb (urb, SLAB_ATOMIC)) != 0) {
816 dbg ("can't resubmit ctrl %02x.%02x, err %d",
817 reqp->bRequestType, reqp->bRequest, status);
818 urb->dev = NULL;
819 } else
820 ctx->pending++;
821 } else
822 urb->dev = NULL;
823
824 /* signal completion when nothing's queued */
825 if (ctx->pending == 0)
826 complete (&ctx->complete);
827 spin_unlock (&ctx->lock);
828 }
829
830 static int
831 test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
832 {
833 struct usb_device *udev = testdev_to_usbdev (dev);
834 struct urb **urb;
835 struct ctrl_ctx context;
836 int i;
837
838 spin_lock_init (&context.lock);
839 context.dev = dev;
840 init_completion (&context.complete);
841 context.count = param->sglen * param->iterations;
842 context.pending = 0;
843 context.status = -ENOMEM;
844 context.param = param;
845 context.last = -1;
846
847 /* allocate and init the urbs we'll queue.
848 * as with bulk/intr sglists, sglen is the queue depth; it also
849 * controls which subtests run (more tests than sglen) or rerun.
850 */
851 urb = kmalloc (param->sglen * sizeof (struct urb *), SLAB_KERNEL);
852 if (!urb)
853 return -ENOMEM;
854 memset (urb, 0, param->sglen * sizeof (struct urb *));
855 for (i = 0; i < param->sglen; i++) {
856 int pipe = usb_rcvctrlpipe (udev, 0);
857 unsigned len;
858 struct urb *u;
859 struct usb_ctrlrequest req;
860 struct subcase *reqp;
861 int expected = 0;
862
863 /* requests here are mostly expected to succeed on any
864 * device, but some are chosen to trigger protocol stalls
865 * or short reads.
866 */
867 memset (&req, 0, sizeof req);
868 req.bRequest = USB_REQ_GET_DESCRIPTOR;
869 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
870
871 switch (i % NUM_SUBCASES) {
872 case 0: // get device descriptor
873 req.wValue = cpu_to_le16 (USB_DT_DEVICE << 8);
874 len = sizeof (struct usb_device_descriptor);
875 break;
876 case 1: // get first config descriptor (only)
877 req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
878 len = sizeof (struct usb_config_descriptor);
879 break;
880 case 2: // get altsetting (OFTEN STALLS)
881 req.bRequest = USB_REQ_GET_INTERFACE;
882 req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
883 // index = 0 means first interface
884 len = 1;
885 expected = EPIPE;
886 break;
887 case 3: // get interface status
888 req.bRequest = USB_REQ_GET_STATUS;
889 req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
890 // interface 0
891 len = 2;
892 break;
893 case 4: // get device status
894 req.bRequest = USB_REQ_GET_STATUS;
895 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
896 len = 2;
897 break;
898 case 5: // get device qualifier (MAY STALL)
899 req.wValue = cpu_to_le16 (USB_DT_DEVICE_QUALIFIER << 8);
900 len = sizeof (struct usb_qualifier_descriptor);
901 if (udev->speed != USB_SPEED_HIGH)
902 expected = EPIPE;
903 break;
904 case 6: // get first config descriptor, plus interface
905 req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
906 len = sizeof (struct usb_config_descriptor);
907 len += sizeof (struct usb_interface_descriptor);
908 break;
909 case 7: // get interface descriptor (ALWAYS STALLS)
910 req.wValue = cpu_to_le16 (USB_DT_INTERFACE << 8);
911 // interface == 0
912 len = sizeof (struct usb_interface_descriptor);
913 expected = EPIPE;
914 break;
915 // NOTE: two consecutive stalls in the queue here.
916 // that tests fault recovery a bit more aggressively.
917 case 8: // clear endpoint halt (USUALLY STALLS)
918 req.bRequest = USB_REQ_CLEAR_FEATURE;
919 req.bRequestType = USB_RECIP_ENDPOINT;
920 // wValue 0 == ep halt
921 // wIndex 0 == ep0 (shouldn't halt!)
922 len = 0;
923 pipe = usb_sndctrlpipe (udev, 0);
924 expected = EPIPE;
925 break;
926 case 9: // get endpoint status
927 req.bRequest = USB_REQ_GET_STATUS;
928 req.bRequestType = USB_DIR_IN|USB_RECIP_ENDPOINT;
929 // endpoint 0
930 len = 2;
931 break;
932 case 10: // trigger short read (EREMOTEIO)
933 req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
934 len = 1024;
935 expected = -EREMOTEIO;
936 break;
937 // NOTE: two consecutive _different_ faults in the queue.
938 case 11: // get endpoint descriptor (ALWAYS STALLS)
939 req.wValue = cpu_to_le16 (USB_DT_ENDPOINT << 8);
940 // endpoint == 0
941 len = sizeof (struct usb_interface_descriptor);
942 expected = EPIPE;
943 break;
944 // NOTE: sometimes even a third fault in the queue!
945 case 12: // get string 0 descriptor (MAY STALL)
946 req.wValue = cpu_to_le16 (USB_DT_STRING << 8);
947 // string == 0, for language IDs
948 len = sizeof (struct usb_interface_descriptor);
949 // may succeed when > 4 languages
950 expected = EREMOTEIO; // or EPIPE, if no strings
951 break;
952 case 13: // short read, resembling case 10
953 req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
954 // last data packet "should" be DATA1, not DATA0
955 len = 1024 - udev->descriptor.bMaxPacketSize0;
956 expected = -EREMOTEIO;
957 break;
958 case 14: // short read; try to fill the last packet
959 req.wValue = cpu_to_le16 ((USB_DT_DEVICE << 8) | 0);
960 // device descriptor size == 18 bytes
961 len = udev->descriptor.bMaxPacketSize0;
962 switch (len) {
963 case 8: len = 24; break;
964 case 16: len = 32; break;
965 }
966 expected = -EREMOTEIO;
967 break;
968 default:
969 err ("bogus number of ctrl queue testcases!");
970 context.status = -EINVAL;
971 goto cleanup;
972 }
973 req.wLength = cpu_to_le16 (len);
974 urb [i] = u = simple_alloc_urb (udev, pipe, len);
975 if (!u)
976 goto cleanup;
977
978 reqp = usb_buffer_alloc (udev, sizeof *reqp, SLAB_KERNEL,
979 &u->setup_dma);
980 if (!reqp)
981 goto cleanup;
982 reqp->setup = req;
983 reqp->number = i % NUM_SUBCASES;
984 reqp->expected = expected;
985 u->setup_packet = (char *) &reqp->setup;
986
987 u->context = &context;
988 u->complete = ctrl_complete;
989 }
990
991 /* queue the urbs */
992 context.urb = urb;
993 spin_lock_irq (&context.lock);
994 for (i = 0; i < param->sglen; i++) {
995 context.status = usb_submit_urb (urb [i], SLAB_ATOMIC);
996 if (context.status != 0) {
997 dbg ("can't submit urb[%d], status %d",
998 i, context.status);
999 context.count = context.pending;
1000 break;
1001 }
1002 context.pending++;
1003 }
1004 spin_unlock_irq (&context.lock);
1005
1006 /* FIXME set timer and time out; provide a disconnect hook */
1007
1008 /* wait for the last one to complete */
1009 if (context.pending > 0)
1010 wait_for_completion (&context.complete);
1011
1012 cleanup:
1013 for (i = 0; i < param->sglen; i++) {
1014 if (!urb [i])
1015 continue;
1016 urb [i]->dev = udev;
1017 if (urb [i]->setup_packet)
1018 usb_buffer_free (udev, sizeof (struct usb_ctrlrequest),
1019 urb [i]->setup_packet,
1020 urb [i]->setup_dma);
1021 simple_free_urb (urb [i]);
1022 }
1023 kfree (urb);
1024 return context.status;
1025 }
1026 #undef NUM_SUBCASES
1027
1028
1029 /*-------------------------------------------------------------------------*/
1030
1031 static void unlink1_callback (struct urb *urb, struct pt_regs *regs)
1032 {
1033 int status = urb->status;
1034
1035 // we "know" -EPIPE (stall) never happens
1036 if (!status)
1037 status = usb_submit_urb (urb, SLAB_ATOMIC);
1038 if (status) {
1039 urb->status = status;
1040 complete ((struct completion *) urb->context);
1041 }
1042 }
1043
1044 static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async)
1045 {
1046 struct urb *urb;
1047 struct completion completion;
1048 int retval = 0;
1049
1050 init_completion (&completion);
1051 urb = simple_alloc_urb (testdev_to_usbdev (dev), pipe, size);
1052 if (!urb)
1053 return -ENOMEM;
1054 urb->context = &completion;
1055 urb->complete = unlink1_callback;
1056
1057 /* keep the endpoint busy. there are lots of hc/hcd-internal
1058 * states, and testing should get to all of them over time.
1059 *
1060 * FIXME want additional tests for when endpoint is STALLing
1061 * due to errors, or is just NAKing requests.
1062 */
1063 if ((retval = usb_submit_urb (urb, SLAB_KERNEL)) != 0) {
1064 dev_dbg (&dev->intf->dev, "submit fail %d\n", retval);
1065 return retval;
1066 }
1067
1068 /* unlinking that should always work. variable delay tests more
1069 * hcd states and code paths, even with little other system load.
1070 */
1071 msleep (jiffies % (2 * INTERRUPT_RATE));
1072 if (async) {
1073 retry:
1074 retval = usb_unlink_urb (urb);
1075 if (retval == -EBUSY || retval == -EIDRM) {
1076 /* we can't unlink urbs while they're completing.
1077 * or if they've completed, and we haven't resubmitted.
1078 * "normal" drivers would prevent resubmission, but
1079 * since we're testing unlink paths, we can't.
1080 */
1081 dev_dbg (&dev->intf->dev, "unlink retry\n");
1082 goto retry;
1083 }
1084 } else
1085 usb_kill_urb (urb);
1086 if (!(retval == 0 || retval == -EINPROGRESS)) {
1087 dev_dbg (&dev->intf->dev, "unlink fail %d\n", retval);
1088 return retval;
1089 }
1090
1091 wait_for_completion (&completion);
1092 retval = urb->status;
1093 simple_free_urb (urb);
1094
1095 if (async)
1096 return (retval == -ECONNRESET) ? 0 : retval - 1000;
1097 else
1098 return (retval == -ENOENT || retval == -EPERM) ?
1099 0 : retval - 2000;
1100 }
1101
1102 static int unlink_simple (struct usbtest_dev *dev, int pipe, int len)
1103 {
1104 int retval = 0;
1105
1106 /* test sync and async paths */
1107 retval = unlink1 (dev, pipe, len, 1);
1108 if (!retval)
1109 retval = unlink1 (dev, pipe, len, 0);
1110 return retval;
1111 }
1112
1113 /*-------------------------------------------------------------------------*/
1114
1115 static int verify_not_halted (int ep, struct urb *urb)
1116 {
1117 int retval;
1118 u16 status;
1119
1120 /* shouldn't look or act halted */
1121 retval = usb_get_status (urb->dev, USB_RECIP_ENDPOINT, ep, &status);
1122 if (retval < 0) {
1123 dbg ("ep %02x couldn't get no-halt status, %d", ep, retval);
1124 return retval;
1125 }
1126 if (status != 0) {
1127 dbg ("ep %02x bogus status: %04x != 0", ep, status);
1128 return -EINVAL;
1129 }
1130 retval = simple_io (urb, 1, 0, 0, __FUNCTION__);
1131 if (retval != 0)
1132 return -EINVAL;
1133 return 0;
1134 }
1135
1136 static int verify_halted (int ep, struct urb *urb)
1137 {
1138 int retval;
1139 u16 status;
1140
1141 /* should look and act halted */
1142 retval = usb_get_status (urb->dev, USB_RECIP_ENDPOINT, ep, &status);
1143 if (retval < 0) {
1144 dbg ("ep %02x couldn't get halt status, %d", ep, retval);
1145 return retval;
1146 }
1147 if (status != 1) {
1148 dbg ("ep %02x bogus status: %04x != 1", ep, status);
1149 return -EINVAL;
1150 }
1151 retval = simple_io (urb, 1, 0, -EPIPE, __FUNCTION__);
1152 if (retval != -EPIPE)
1153 return -EINVAL;
1154 retval = simple_io (urb, 1, 0, -EPIPE, "verify_still_halted");
1155 if (retval != -EPIPE)
1156 return -EINVAL;
1157 return 0;
1158 }
1159
1160 static int test_halt (int ep, struct urb *urb)
1161 {
1162 int retval;
1163
1164 /* shouldn't look or act halted now */
1165 retval = verify_not_halted (ep, urb);
1166 if (retval < 0)
1167 return retval;
1168
1169 /* set halt (protocol test only), verify it worked */
1170 retval = usb_control_msg (urb->dev, usb_sndctrlpipe (urb->dev, 0),
1171 USB_REQ_SET_FEATURE, USB_RECIP_ENDPOINT,
1172 USB_ENDPOINT_HALT, ep,
1173 NULL, 0, USB_CTRL_SET_TIMEOUT);
1174 if (retval < 0) {
1175 dbg ("ep %02x couldn't set halt, %d", ep, retval);
1176 return retval;
1177 }
1178 retval = verify_halted (ep, urb);
1179 if (retval < 0)
1180 return retval;
1181
1182 /* clear halt (tests API + protocol), verify it worked */
1183 retval = usb_clear_halt (urb->dev, urb->pipe);
1184 if (retval < 0) {
1185 dbg ("ep %02x couldn't clear halt, %d", ep, retval);
1186 return retval;
1187 }
1188 retval = verify_not_halted (ep, urb);
1189 if (retval < 0)
1190 return retval;
1191
1192 /* NOTE: could also verify SET_INTERFACE clear halts ... */
1193
1194 return 0;
1195 }
1196
1197 static int halt_simple (struct usbtest_dev *dev)
1198 {
1199 int ep;
1200 int retval = 0;
1201 struct urb *urb;
1202
1203 urb = simple_alloc_urb (testdev_to_usbdev (dev), 0, 512);
1204 if (urb == NULL)
1205 return -ENOMEM;
1206
1207 if (dev->in_pipe) {
1208 ep = usb_pipeendpoint (dev->in_pipe) | USB_DIR_IN;
1209 urb->pipe = dev->in_pipe;
1210 retval = test_halt (ep, urb);
1211 if (retval < 0)
1212 goto done;
1213 }
1214
1215 if (dev->out_pipe) {
1216 ep = usb_pipeendpoint (dev->out_pipe);
1217 urb->pipe = dev->out_pipe;
1218 retval = test_halt (ep, urb);
1219 }
1220 done:
1221 simple_free_urb (urb);
1222 return retval;
1223 }
1224
1225 /*-------------------------------------------------------------------------*/
1226
1227 /* Control OUT tests use the vendor control requests from Intel's
1228 * USB 2.0 compliance test device: write a buffer, read it back.
1229 *
1230 * Intel's spec only _requires_ that it work for one packet, which
1231 * is pretty weak. Some HCDs place limits here; most devices will
1232 * need to be able to handle more than one OUT data packet. We'll
1233 * try whatever we're told to try.
1234 */
1235 static int ctrl_out (struct usbtest_dev *dev,
1236 unsigned count, unsigned length, unsigned vary)
1237 {
1238 unsigned i, j, len, retval;
1239 u8 *buf;
1240 char *what = "?";
1241 struct usb_device *udev;
1242
1243 if (length < 1 || length > 0xffff || vary >= length)
1244 return -EINVAL;
1245
1246 buf = kmalloc(length, SLAB_KERNEL);
1247 if (!buf)
1248 return -ENOMEM;
1249
1250 udev = testdev_to_usbdev (dev);
1251 len = length;
1252 retval = 0;
1253
1254 /* NOTE: hardware might well act differently if we pushed it
1255 * with lots back-to-back queued requests.
1256 */
1257 for (i = 0; i < count; i++) {
1258 /* write patterned data */
1259 for (j = 0; j < len; j++)
1260 buf [j] = i + j;
1261 retval = usb_control_msg (udev, usb_sndctrlpipe (udev,0),
1262 0x5b, USB_DIR_OUT|USB_TYPE_VENDOR,
1263 0, 0, buf, len, USB_CTRL_SET_TIMEOUT);
1264 if (retval != len) {
1265 what = "write";
1266 if (retval >= 0) {
1267 INFO(dev, "ctrl_out, wlen %d (expected %d)\n",
1268 retval, len);
1269 retval = -EBADMSG;
1270 }
1271 break;
1272 }
1273
1274 /* read it back -- assuming nothing intervened!! */
1275 retval = usb_control_msg (udev, usb_rcvctrlpipe (udev,0),
1276 0x5c, USB_DIR_IN|USB_TYPE_VENDOR,
1277 0, 0, buf, len, USB_CTRL_GET_TIMEOUT);
1278 if (retval != len) {
1279 what = "read";
1280 if (retval >= 0) {
1281 INFO(dev, "ctrl_out, rlen %d (expected %d)\n",
1282 retval, len);
1283 retval = -EBADMSG;
1284 }
1285 break;
1286 }
1287
1288 /* fail if we can't verify */
1289 for (j = 0; j < len; j++) {
1290 if (buf [j] != (u8) (i + j)) {
1291 INFO (dev, "ctrl_out, byte %d is %d not %d\n",
1292 j, buf [j], (u8) i + j);
1293 retval = -EBADMSG;
1294 break;
1295 }
1296 }
1297 if (retval < 0) {
1298 what = "verify";
1299 break;
1300 }
1301
1302 len += vary;
1303
1304 /* [real world] the "zero bytes IN" case isn't really used.
1305 * hardware can easily trip up in this wierd case, since its
1306 * status stage is IN, not OUT like other ep0in transfers.
1307 */
1308 if (len > length)
1309 len = realworld ? 1 : 0;
1310 }
1311
1312 if (retval < 0)
1313 INFO (dev, "ctrl_out %s failed, code %d, count %d\n",
1314 what, retval, i);
1315
1316 kfree (buf);
1317 return retval;
1318 }
1319
1320 /*-------------------------------------------------------------------------*/
1321
1322 /* ISO tests ... mimics common usage
1323 * - buffer length is split into N packets (mostly maxpacket sized)
1324 * - multi-buffers according to sglen
1325 */
1326
1327 struct iso_context {
1328 unsigned count;
1329 unsigned pending;
1330 spinlock_t lock;
1331 struct completion done;
1332 unsigned long errors;
1333 struct usbtest_dev *dev;
1334 };
1335
1336 static void iso_callback (struct urb *urb, struct pt_regs *regs)
1337 {
1338 struct iso_context *ctx = urb->context;
1339
1340 spin_lock(&ctx->lock);
1341 ctx->count--;
1342
1343 if (urb->error_count > 0)
1344 ctx->errors += urb->error_count;
1345
1346 if (urb->status == 0 && ctx->count > (ctx->pending - 1)) {
1347 int status = usb_submit_urb (urb, GFP_ATOMIC);
1348 switch (status) {
1349 case 0:
1350 goto done;
1351 default:
1352 dev_dbg (&ctx->dev->intf->dev,
1353 "iso resubmit err %d\n",
1354 status);
1355 /* FALLTHROUGH */
1356 case -ENODEV: /* disconnected */
1357 break;
1358 }
1359 }
1360 simple_free_urb (urb);
1361
1362 ctx->pending--;
1363 if (ctx->pending == 0) {
1364 if (ctx->errors)
1365 dev_dbg (&ctx->dev->intf->dev,
1366 "iso test, %lu errors\n",
1367 ctx->errors);
1368 complete (&ctx->done);
1369 }
1370 done:
1371 spin_unlock(&ctx->lock);
1372 }
1373
1374 static struct urb *iso_alloc_urb (
1375 struct usb_device *udev,
1376 int pipe,
1377 struct usb_endpoint_descriptor *desc,
1378 long bytes
1379 )
1380 {
1381 struct urb *urb;
1382 unsigned i, maxp, packets;
1383
1384 if (bytes < 0 || !desc)
1385 return NULL;
1386 maxp = 0x7ff & le16_to_cpu(desc->wMaxPacketSize);
1387 maxp *= 1 + (0x3 & (le16_to_cpu(desc->wMaxPacketSize) >> 11));
1388 packets = (bytes + maxp - 1) / maxp;
1389
1390 urb = usb_alloc_urb (packets, SLAB_KERNEL);
1391 if (!urb)
1392 return urb;
1393 urb->dev = udev;
1394 urb->pipe = pipe;
1395
1396 urb->number_of_packets = packets;
1397 urb->transfer_buffer_length = bytes;
1398 urb->transfer_buffer = usb_buffer_alloc (udev, bytes, SLAB_KERNEL,
1399 &urb->transfer_dma);
1400 if (!urb->transfer_buffer) {
1401 usb_free_urb (urb);
1402 return NULL;
1403 }
1404 memset (urb->transfer_buffer, 0, bytes);
1405 for (i = 0; i < packets; i++) {
1406 /* here, only the last packet will be short */
1407 urb->iso_frame_desc[i].length = min ((unsigned) bytes, maxp);
1408 bytes -= urb->iso_frame_desc[i].length;
1409
1410 urb->iso_frame_desc[i].offset = maxp * i;
1411 }
1412
1413 urb->complete = iso_callback;
1414 // urb->context = SET BY CALLER
1415 urb->interval = 1 << (desc->bInterval - 1);
1416 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1417 return urb;
1418 }
1419
1420 static int
1421 test_iso_queue (struct usbtest_dev *dev, struct usbtest_param *param,
1422 int pipe, struct usb_endpoint_descriptor *desc)
1423 {
1424 struct iso_context context;
1425 struct usb_device *udev;
1426 unsigned i;
1427 unsigned long packets = 0;
1428 int status;
1429 struct urb *urbs[10]; /* FIXME no limit */
1430
1431 if (param->sglen > 10)
1432 return -EDOM;
1433
1434 context.count = param->iterations * param->sglen;
1435 context.pending = param->sglen;
1436 context.errors = 0;
1437 context.dev = dev;
1438 init_completion (&context.done);
1439 spin_lock_init (&context.lock);
1440
1441 memset (urbs, 0, sizeof urbs);
1442 udev = testdev_to_usbdev (dev);
1443 dev_dbg (&dev->intf->dev,
1444 "... iso period %d %sframes, wMaxPacket %04x\n",
1445 1 << (desc->bInterval - 1),
1446 (udev->speed == USB_SPEED_HIGH) ? "micro" : "",
1447 le16_to_cpu(desc->wMaxPacketSize));
1448
1449 for (i = 0; i < param->sglen; i++) {
1450 urbs [i] = iso_alloc_urb (udev, pipe, desc,
1451 param->length);
1452 if (!urbs [i]) {
1453 status = -ENOMEM;
1454 goto fail;
1455 }
1456 packets += urbs[i]->number_of_packets;
1457 urbs [i]->context = &context;
1458 }
1459 packets *= param->iterations;
1460 dev_dbg (&dev->intf->dev,
1461 "... total %lu msec (%lu packets)\n",
1462 (packets * (1 << (desc->bInterval - 1)))
1463 / ((udev->speed == USB_SPEED_HIGH) ? 8 : 1),
1464 packets);
1465
1466 spin_lock_irq (&context.lock);
1467 for (i = 0; i < param->sglen; i++) {
1468 status = usb_submit_urb (urbs [i], SLAB_ATOMIC);
1469 if (status < 0) {
1470 ERROR (dev, "submit iso[%d], error %d\n", i, status);
1471 if (i == 0) {
1472 spin_unlock_irq (&context.lock);
1473 goto fail;
1474 }
1475
1476 simple_free_urb (urbs [i]);
1477 context.pending--;
1478 }
1479 }
1480 spin_unlock_irq (&context.lock);
1481
1482 wait_for_completion (&context.done);
1483 return 0;
1484
1485 fail:
1486 for (i = 0; i < param->sglen; i++) {
1487 if (urbs [i])
1488 simple_free_urb (urbs [i]);
1489 }
1490 return status;
1491 }
1492
1493 /*-------------------------------------------------------------------------*/
1494
1495 /* We only have this one interface to user space, through usbfs.
1496 * User mode code can scan usbfs to find N different devices (maybe on
1497 * different busses) to use when testing, and allocate one thread per
1498 * test. So discovery is simplified, and we have no device naming issues.
1499 *
1500 * Don't use these only as stress/load tests. Use them along with with
1501 * other USB bus activity: plugging, unplugging, mousing, mp3 playback,
1502 * video capture, and so on. Run different tests at different times, in
1503 * different sequences. Nothing here should interact with other devices,
1504 * except indirectly by consuming USB bandwidth and CPU resources for test
1505 * threads and request completion. But the only way to know that for sure
1506 * is to test when HC queues are in use by many devices.
1507 */
1508
1509 static int
1510 usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
1511 {
1512 struct usbtest_dev *dev = usb_get_intfdata (intf);
1513 struct usb_device *udev = testdev_to_usbdev (dev);
1514 struct usbtest_param *param = buf;
1515 int retval = -EOPNOTSUPP;
1516 struct urb *urb;
1517 struct scatterlist *sg;
1518 struct usb_sg_request req;
1519 struct timeval start;
1520 unsigned i;
1521
1522 // FIXME USBDEVFS_CONNECTINFO doesn't say how fast the device is.
1523
1524 if (code != USBTEST_REQUEST)
1525 return -EOPNOTSUPP;
1526
1527 if (param->iterations <= 0 || param->length < 0
1528 || param->sglen < 0 || param->vary < 0)
1529 return -EINVAL;
1530
1531 if (down_interruptible (&dev->sem))
1532 return -ERESTARTSYS;
1533
1534 if (intf->dev.power.power_state.event != PM_EVENT_ON) {
1535 up (&dev->sem);
1536 return -EHOSTUNREACH;
1537 }
1538
1539 /* some devices, like ez-usb default devices, need a non-default
1540 * altsetting to have any active endpoints. some tests change
1541 * altsettings; force a default so most tests don't need to check.
1542 */
1543 if (dev->info->alt >= 0) {
1544 int res;
1545
1546 if (intf->altsetting->desc.bInterfaceNumber) {
1547 up (&dev->sem);
1548 return -ENODEV;
1549 }
1550 res = set_altsetting (dev, dev->info->alt);
1551 if (res) {
1552 dev_err (&intf->dev,
1553 "set altsetting to %d failed, %d\n",
1554 dev->info->alt, res);
1555 up (&dev->sem);
1556 return res;
1557 }
1558 }
1559
1560 /*
1561 * Just a bunch of test cases that every HCD is expected to handle.
1562 *
1563 * Some may need specific firmware, though it'd be good to have
1564 * one firmware image to handle all the test cases.
1565 *
1566 * FIXME add more tests! cancel requests, verify the data, control
1567 * queueing, concurrent read+write threads, and so on.
1568 */
1569 do_gettimeofday (&start);
1570 switch (param->test_num) {
1571
1572 case 0:
1573 dev_dbg (&intf->dev, "TEST 0: NOP\n");
1574 retval = 0;
1575 break;
1576
1577 /* Simple non-queued bulk I/O tests */
1578 case 1:
1579 if (dev->out_pipe == 0)
1580 break;
1581 dev_dbg (&intf->dev,
1582 "TEST 1: write %d bytes %u times\n",
1583 param->length, param->iterations);
1584 urb = simple_alloc_urb (udev, dev->out_pipe, param->length);
1585 if (!urb) {
1586 retval = -ENOMEM;
1587 break;
1588 }
1589 // FIRMWARE: bulk sink (maybe accepts short writes)
1590 retval = simple_io (urb, param->iterations, 0, 0, "test1");
1591 simple_free_urb (urb);
1592 break;
1593 case 2:
1594 if (dev->in_pipe == 0)
1595 break;
1596 dev_dbg (&intf->dev,
1597 "TEST 2: read %d bytes %u times\n",
1598 param->length, param->iterations);
1599 urb = simple_alloc_urb (udev, dev->in_pipe, param->length);
1600 if (!urb) {
1601 retval = -ENOMEM;
1602 break;
1603 }
1604 // FIRMWARE: bulk source (maybe generates short writes)
1605 retval = simple_io (urb, param->iterations, 0, 0, "test2");
1606 simple_free_urb (urb);
1607 break;
1608 case 3:
1609 if (dev->out_pipe == 0 || param->vary == 0)
1610 break;
1611 dev_dbg (&intf->dev,
1612 "TEST 3: write/%d 0..%d bytes %u times\n",
1613 param->vary, param->length, param->iterations);
1614 urb = simple_alloc_urb (udev, dev->out_pipe, param->length);
1615 if (!urb) {
1616 retval = -ENOMEM;
1617 break;
1618 }
1619 // FIRMWARE: bulk sink (maybe accepts short writes)
1620 retval = simple_io (urb, param->iterations, param->vary,
1621 0, "test3");
1622 simple_free_urb (urb);
1623 break;
1624 case 4:
1625 if (dev->in_pipe == 0 || param->vary == 0)
1626 break;
1627 dev_dbg (&intf->dev,
1628 "TEST 4: read/%d 0..%d bytes %u times\n",
1629 param->vary, param->length, param->iterations);
1630 urb = simple_alloc_urb (udev, dev->in_pipe, param->length);
1631 if (!urb) {
1632 retval = -ENOMEM;
1633 break;
1634 }
1635 // FIRMWARE: bulk source (maybe generates short writes)
1636 retval = simple_io (urb, param->iterations, param->vary,
1637 0, "test4");
1638 simple_free_urb (urb);
1639 break;
1640
1641 /* Queued bulk I/O tests */
1642 case 5:
1643 if (dev->out_pipe == 0 || param->sglen == 0)
1644 break;
1645 dev_dbg (&intf->dev,
1646 "TEST 5: write %d sglists %d entries of %d bytes\n",
1647 param->iterations,
1648 param->sglen, param->length);
1649 sg = alloc_sglist (param->sglen, param->length, 0);
1650 if (!sg) {
1651 retval = -ENOMEM;
1652 break;
1653 }
1654 // FIRMWARE: bulk sink (maybe accepts short writes)
1655 retval = perform_sglist (udev, param->iterations, dev->out_pipe,
1656 &req, sg, param->sglen);
1657 free_sglist (sg, param->sglen);
1658 break;
1659
1660 case 6:
1661 if (dev->in_pipe == 0 || param->sglen == 0)
1662 break;
1663 dev_dbg (&intf->dev,
1664 "TEST 6: read %d sglists %d entries of %d bytes\n",
1665 param->iterations,
1666 param->sglen, param->length);
1667 sg = alloc_sglist (param->sglen, param->length, 0);
1668 if (!sg) {
1669 retval = -ENOMEM;
1670 break;
1671 }
1672 // FIRMWARE: bulk source (maybe generates short writes)
1673 retval = perform_sglist (udev, param->iterations, dev->in_pipe,
1674 &req, sg, param->sglen);
1675 free_sglist (sg, param->sglen);
1676 break;
1677 case 7:
1678 if (dev->out_pipe == 0 || param->sglen == 0 || param->vary == 0)
1679 break;
1680 dev_dbg (&intf->dev,
1681 "TEST 7: write/%d %d sglists %d entries 0..%d bytes\n",
1682 param->vary, param->iterations,
1683 param->sglen, param->length);
1684 sg = alloc_sglist (param->sglen, param->length, param->vary);
1685 if (!sg) {
1686 retval = -ENOMEM;
1687 break;
1688 }
1689 // FIRMWARE: bulk sink (maybe accepts short writes)
1690 retval = perform_sglist (udev, param->iterations, dev->out_pipe,
1691 &req, sg, param->sglen);
1692 free_sglist (sg, param->sglen);
1693 break;
1694 case 8:
1695 if (dev->in_pipe == 0 || param->sglen == 0 || param->vary == 0)
1696 break;
1697 dev_dbg (&intf->dev,
1698 "TEST 8: read/%d %d sglists %d entries 0..%d bytes\n",
1699 param->vary, param->iterations,
1700 param->sglen, param->length);
1701 sg = alloc_sglist (param->sglen, param->length, param->vary);
1702 if (!sg) {
1703 retval = -ENOMEM;
1704 break;
1705 }
1706 // FIRMWARE: bulk source (maybe generates short writes)
1707 retval = perform_sglist (udev, param->iterations, dev->in_pipe,
1708 &req, sg, param->sglen);
1709 free_sglist (sg, param->sglen);
1710 break;
1711
1712 /* non-queued sanity tests for control (chapter 9 subset) */
1713 case 9:
1714 retval = 0;
1715 dev_dbg (&intf->dev,
1716 "TEST 9: ch9 (subset) control tests, %d times\n",
1717 param->iterations);
1718 for (i = param->iterations; retval == 0 && i--; /* NOP */)
1719 retval = ch9_postconfig (dev);
1720 if (retval)
1721 dbg ("ch9 subset failed, iterations left %d", i);
1722 break;
1723
1724 /* queued control messaging */
1725 case 10:
1726 if (param->sglen == 0)
1727 break;
1728 retval = 0;
1729 dev_dbg (&intf->dev,
1730 "TEST 10: queue %d control calls, %d times\n",
1731 param->sglen,
1732 param->iterations);
1733 retval = test_ctrl_queue (dev, param);
1734 break;
1735
1736 /* simple non-queued unlinks (ring with one urb) */
1737 case 11:
1738 if (dev->in_pipe == 0 || !param->length)
1739 break;
1740 retval = 0;
1741 dev_dbg (&intf->dev, "TEST 11: unlink %d reads of %d\n",
1742 param->iterations, param->length);
1743 for (i = param->iterations; retval == 0 && i--; /* NOP */)
1744 retval = unlink_simple (dev, dev->in_pipe,
1745 param->length);
1746 if (retval)
1747 dev_dbg (&intf->dev, "unlink reads failed %d, "
1748 "iterations left %d\n", retval, i);
1749 break;
1750 case 12:
1751 if (dev->out_pipe == 0 || !param->length)
1752 break;
1753 retval = 0;
1754 dev_dbg (&intf->dev, "TEST 12: unlink %d writes of %d\n",
1755 param->iterations, param->length);
1756 for (i = param->iterations; retval == 0 && i--; /* NOP */)
1757 retval = unlink_simple (dev, dev->out_pipe,
1758 param->length);
1759 if (retval)
1760 dev_dbg (&intf->dev, "unlink writes failed %d, "
1761 "iterations left %d\n", retval, i);
1762 break;
1763
1764 /* ep halt tests */
1765 case 13:
1766 if (dev->out_pipe == 0 && dev->in_pipe == 0)
1767 break;
1768 retval = 0;
1769 dev_dbg (&intf->dev, "TEST 13: set/clear %d halts\n",
1770 param->iterations);
1771 for (i = param->iterations; retval == 0 && i--; /* NOP */)
1772 retval = halt_simple (dev);
1773
1774 if (retval)
1775 DBG (dev, "halts failed, iterations left %d\n", i);
1776 break;
1777
1778 /* control write tests */
1779 case 14:
1780 if (!dev->info->ctrl_out)
1781 break;
1782 dev_dbg (&intf->dev, "TEST 14: %d ep0out, %d..%d vary %d\n",
1783 param->iterations,
1784 realworld ? 1 : 0, param->length,
1785 param->vary);
1786 retval = ctrl_out (dev, param->iterations,
1787 param->length, param->vary);
1788 break;
1789
1790 /* iso write tests */
1791 case 15:
1792 if (dev->out_iso_pipe == 0 || param->sglen == 0)
1793 break;
1794 dev_dbg (&intf->dev,
1795 "TEST 15: write %d iso, %d entries of %d bytes\n",
1796 param->iterations,
1797 param->sglen, param->length);
1798 // FIRMWARE: iso sink
1799 retval = test_iso_queue (dev, param,
1800 dev->out_iso_pipe, dev->iso_out);
1801 break;
1802
1803 /* iso read tests */
1804 case 16:
1805 if (dev->in_iso_pipe == 0 || param->sglen == 0)
1806 break;
1807 dev_dbg (&intf->dev,
1808 "TEST 16: read %d iso, %d entries of %d bytes\n",
1809 param->iterations,
1810 param->sglen, param->length);
1811 // FIRMWARE: iso source
1812 retval = test_iso_queue (dev, param,
1813 dev->in_iso_pipe, dev->iso_in);
1814 break;
1815
1816 // FIXME unlink from queue (ring with N urbs)
1817
1818 // FIXME scatterlist cancel (needs helper thread)
1819
1820 }
1821 do_gettimeofday (&param->duration);
1822 param->duration.tv_sec -= start.tv_sec;
1823 param->duration.tv_usec -= start.tv_usec;
1824 if (param->duration.tv_usec < 0) {
1825 param->duration.tv_usec += 1000 * 1000;
1826 param->duration.tv_sec -= 1;
1827 }
1828 up (&dev->sem);
1829 return retval;
1830 }
1831
1832 /*-------------------------------------------------------------------------*/
1833
1834 static unsigned force_interrupt = 0;
1835 module_param (force_interrupt, uint, 0);
1836 MODULE_PARM_DESC (force_interrupt, "0 = test default; else interrupt");
1837
1838 #ifdef GENERIC
1839 static unsigned short vendor;
1840 module_param(vendor, ushort, 0);
1841 MODULE_PARM_DESC (vendor, "vendor code (from usb-if)");
1842
1843 static unsigned short product;
1844 module_param(product, ushort, 0);
1845 MODULE_PARM_DESC (product, "product code (from vendor)");
1846 #endif
1847
1848 static int
1849 usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
1850 {
1851 struct usb_device *udev;
1852 struct usbtest_dev *dev;
1853 struct usbtest_info *info;
1854 char *rtest, *wtest;
1855 char *irtest, *iwtest;
1856
1857 udev = interface_to_usbdev (intf);
1858
1859 #ifdef GENERIC
1860 /* specify devices by module parameters? */
1861 if (id->match_flags == 0) {
1862 /* vendor match required, product match optional */
1863 if (!vendor || le16_to_cpu(udev->descriptor.idVendor) != (u16)vendor)
1864 return -ENODEV;
1865 if (product && le16_to_cpu(udev->descriptor.idProduct) != (u16)product)
1866 return -ENODEV;
1867 dbg ("matched module params, vend=0x%04x prod=0x%04x",
1868 le16_to_cpu(udev->descriptor.idVendor),
1869 le16_to_cpu(udev->descriptor.idProduct));
1870 }
1871 #endif
1872
1873 dev = kmalloc (sizeof *dev, SLAB_KERNEL);
1874 if (!dev)
1875 return -ENOMEM;
1876 memset (dev, 0, sizeof *dev);
1877 info = (struct usbtest_info *) id->driver_info;
1878 dev->info = info;
1879 init_MUTEX (&dev->sem);
1880
1881 dev->intf = intf;
1882
1883 /* cacheline-aligned scratch for i/o */
1884 if ((dev->buf = kmalloc (TBUF_SIZE, SLAB_KERNEL)) == NULL) {
1885 kfree (dev);
1886 return -ENOMEM;
1887 }
1888
1889 /* NOTE this doesn't yet test the handful of difference that are
1890 * visible with high speed interrupts: bigger maxpacket (1K) and
1891 * "high bandwidth" modes (up to 3 packets/uframe).
1892 */
1893 rtest = wtest = "";
1894 irtest = iwtest = "";
1895 if (force_interrupt || udev->speed == USB_SPEED_LOW) {
1896 if (info->ep_in) {
1897 dev->in_pipe = usb_rcvintpipe (udev, info->ep_in);
1898 rtest = " intr-in";
1899 }
1900 if (info->ep_out) {
1901 dev->out_pipe = usb_sndintpipe (udev, info->ep_out);
1902 wtest = " intr-out";
1903 }
1904 } else {
1905 if (info->autoconf) {
1906 int status;
1907
1908 status = get_endpoints (dev, intf);
1909 if (status < 0) {
1910 dbg ("couldn't get endpoints, %d\n", status);
1911 return status;
1912 }
1913 /* may find bulk or ISO pipes */
1914 } else {
1915 if (info->ep_in)
1916 dev->in_pipe = usb_rcvbulkpipe (udev,
1917 info->ep_in);
1918 if (info->ep_out)
1919 dev->out_pipe = usb_sndbulkpipe (udev,
1920 info->ep_out);
1921 }
1922 if (dev->in_pipe)
1923 rtest = " bulk-in";
1924 if (dev->out_pipe)
1925 wtest = " bulk-out";
1926 if (dev->in_iso_pipe)
1927 irtest = " iso-in";
1928 if (dev->out_iso_pipe)
1929 iwtest = " iso-out";
1930 }
1931
1932 usb_set_intfdata (intf, dev);
1933 dev_info (&intf->dev, "%s\n", info->name);
1934 dev_info (&intf->dev, "%s speed {control%s%s%s%s%s} tests%s\n",
1935 ({ char *tmp;
1936 switch (udev->speed) {
1937 case USB_SPEED_LOW: tmp = "low"; break;
1938 case USB_SPEED_FULL: tmp = "full"; break;
1939 case USB_SPEED_HIGH: tmp = "high"; break;
1940 default: tmp = "unknown"; break;
1941 }; tmp; }),
1942 info->ctrl_out ? " in/out" : "",
1943 rtest, wtest,
1944 irtest, iwtest,
1945 info->alt >= 0 ? " (+alt)" : "");
1946 return 0;
1947 }
1948
1949 static int usbtest_suspend (struct usb_interface *intf, pm_message_t message)
1950 {
1951 struct usbtest_dev *dev = usb_get_intfdata (intf);
1952
1953 down (&dev->sem);
1954 intf->dev.power.power_state = PMSG_SUSPEND;
1955 up (&dev->sem);
1956 return 0;
1957 }
1958
1959 static int usbtest_resume (struct usb_interface *intf)
1960 {
1961 struct usbtest_dev *dev = usb_get_intfdata (intf);
1962
1963 down (&dev->sem);
1964 intf->dev.power.power_state = PMSG_ON;
1965 up (&dev->sem);
1966 return 0;
1967 }
1968
1969
1970 static void usbtest_disconnect (struct usb_interface *intf)
1971 {
1972 struct usbtest_dev *dev = usb_get_intfdata (intf);
1973
1974 down (&dev->sem);
1975
1976 usb_set_intfdata (intf, NULL);
1977 dev_dbg (&intf->dev, "disconnect\n");
1978 kfree (dev);
1979 }
1980
1981 /* Basic testing only needs a device that can source or sink bulk traffic.
1982 * Any device can test control transfers (default with GENERIC binding).
1983 *
1984 * Several entries work with the default EP0 implementation that's built
1985 * into EZ-USB chips. There's a default vendor ID which can be overridden
1986 * by (very) small config EEPROMS, but otherwise all these devices act
1987 * identically until firmware is loaded: only EP0 works. It turns out
1988 * to be easy to make other endpoints work, without modifying that EP0
1989 * behavior. For now, we expect that kind of firmware.
1990 */
1991
1992 /* an21xx or fx versions of ez-usb */
1993 static struct usbtest_info ez1_info = {
1994 .name = "EZ-USB device",
1995 .ep_in = 2,
1996 .ep_out = 2,
1997 .alt = 1,
1998 };
1999
2000 /* fx2 version of ez-usb */
2001 static struct usbtest_info ez2_info = {
2002 .name = "FX2 device",
2003 .ep_in = 6,
2004 .ep_out = 2,
2005 .alt = 1,
2006 };
2007
2008 /* ezusb family device with dedicated usb test firmware,
2009 */
2010 static struct usbtest_info fw_info = {
2011 .name = "usb test device",
2012 .ep_in = 2,
2013 .ep_out = 2,
2014 .alt = 1,
2015 .autoconf = 1, // iso and ctrl_out need autoconf
2016 .ctrl_out = 1,
2017 .iso = 1, // iso_ep's are #8 in/out
2018 };
2019
2020 /* peripheral running Linux and 'zero.c' test firmware, or
2021 * its user-mode cousin. different versions of this use
2022 * different hardware with the same vendor/product codes.
2023 * host side MUST rely on the endpoint descriptors.
2024 */
2025 static struct usbtest_info gz_info = {
2026 .name = "Linux gadget zero",
2027 .autoconf = 1,
2028 .ctrl_out = 1,
2029 .alt = 0,
2030 };
2031
2032 static struct usbtest_info um_info = {
2033 .name = "Linux user mode test driver",
2034 .autoconf = 1,
2035 .alt = -1,
2036 };
2037
2038 static struct usbtest_info um2_info = {
2039 .name = "Linux user mode ISO test driver",
2040 .autoconf = 1,
2041 .iso = 1,
2042 .alt = -1,
2043 };
2044
2045 #ifdef IBOT2
2046 /* this is a nice source of high speed bulk data;
2047 * uses an FX2, with firmware provided in the device
2048 */
2049 static struct usbtest_info ibot2_info = {
2050 .name = "iBOT2 webcam",
2051 .ep_in = 2,
2052 .alt = -1,
2053 };
2054 #endif
2055
2056 #ifdef GENERIC
2057 /* we can use any device to test control traffic */
2058 static struct usbtest_info generic_info = {
2059 .name = "Generic USB device",
2060 .alt = -1,
2061 };
2062 #endif
2063
2064 // FIXME remove this
2065 static struct usbtest_info hact_info = {
2066 .name = "FX2/hact",
2067 //.ep_in = 6,
2068 .ep_out = 2,
2069 .alt = -1,
2070 };
2071
2072
2073 static struct usb_device_id id_table [] = {
2074
2075 { USB_DEVICE (0x0547, 0x1002),
2076 .driver_info = (unsigned long) &hact_info,
2077 },
2078
2079 /*-------------------------------------------------------------*/
2080
2081 /* EZ-USB devices which download firmware to replace (or in our
2082 * case augment) the default device implementation.
2083 */
2084
2085 /* generic EZ-USB FX controller */
2086 { USB_DEVICE (0x0547, 0x2235),
2087 .driver_info = (unsigned long) &ez1_info,
2088 },
2089
2090 /* CY3671 development board with EZ-USB FX */
2091 { USB_DEVICE (0x0547, 0x0080),
2092 .driver_info = (unsigned long) &ez1_info,
2093 },
2094
2095 /* generic EZ-USB FX2 controller (or development board) */
2096 { USB_DEVICE (0x04b4, 0x8613),
2097 .driver_info = (unsigned long) &ez2_info,
2098 },
2099
2100 /* re-enumerated usb test device firmware */
2101 { USB_DEVICE (0xfff0, 0xfff0),
2102 .driver_info = (unsigned long) &fw_info,
2103 },
2104
2105 /* "Gadget Zero" firmware runs under Linux */
2106 { USB_DEVICE (0x0525, 0xa4a0),
2107 .driver_info = (unsigned long) &gz_info,
2108 },
2109
2110 /* so does a user-mode variant */
2111 { USB_DEVICE (0x0525, 0xa4a4),
2112 .driver_info = (unsigned long) &um_info,
2113 },
2114
2115 /* ... and a user-mode variant that talks iso */
2116 { USB_DEVICE (0x0525, 0xa4a3),
2117 .driver_info = (unsigned long) &um2_info,
2118 },
2119
2120 #ifdef KEYSPAN_19Qi
2121 /* Keyspan 19qi uses an21xx (original EZ-USB) */
2122 // this does not coexist with the real Keyspan 19qi driver!
2123 { USB_DEVICE (0x06cd, 0x010b),
2124 .driver_info = (unsigned long) &ez1_info,
2125 },
2126 #endif
2127
2128 /*-------------------------------------------------------------*/
2129
2130 #ifdef IBOT2
2131 /* iBOT2 makes a nice source of high speed bulk-in data */
2132 // this does not coexist with a real iBOT2 driver!
2133 { USB_DEVICE (0x0b62, 0x0059),
2134 .driver_info = (unsigned long) &ibot2_info,
2135 },
2136 #endif
2137
2138 /*-------------------------------------------------------------*/
2139
2140 #ifdef GENERIC
2141 /* module params can specify devices to use for control tests */
2142 { .driver_info = (unsigned long) &generic_info, },
2143 #endif
2144
2145 /*-------------------------------------------------------------*/
2146
2147 { }
2148 };
2149 MODULE_DEVICE_TABLE (usb, id_table);
2150
2151 static struct usb_driver usbtest_driver = {
2152 .owner = THIS_MODULE,
2153 .name = "usbtest",
2154 .id_table = id_table,
2155 .probe = usbtest_probe,
2156 .ioctl = usbtest_ioctl,
2157 .disconnect = usbtest_disconnect,
2158 .suspend = usbtest_suspend,
2159 .resume = usbtest_resume,
2160 };
2161
2162 /*-------------------------------------------------------------------------*/
2163
2164 static int __init usbtest_init (void)
2165 {
2166 #ifdef GENERIC
2167 if (vendor)
2168 dbg ("params: vend=0x%04x prod=0x%04x", vendor, product);
2169 #endif
2170 return usb_register (&usbtest_driver);
2171 }
2172 module_init (usbtest_init);
2173
2174 static void __exit usbtest_exit (void)
2175 {
2176 usb_deregister (&usbtest_driver);
2177 }
2178 module_exit (usbtest_exit);
2179
2180 MODULE_DESCRIPTION ("USB Core/HCD Testing Driver");
2181 MODULE_LICENSE ("GPL");
2182
Verdex Pro support