?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Automatic merge of rsync://rsync.kernel.org/pub/scm/linux/kernel/git/gregkh/driver...
[linux-2.6/verdex.git] / drivers / usb / misc / usbtest.c
blob3104f28f6aa8d130206cacdaf7999cbf63e48f1f
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 ch9 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,
608 "get config --> %d (%d)\n", retval,
609 expected);
610 return (retval < 0) ? retval : -EDOM;
611 }
612 }
613
614 /* there's always [9.4.3] a device descriptor [9.6.1] */
615 retval = usb_get_descriptor (udev, USB_DT_DEVICE, 0,
616 dev->buf, sizeof udev->descriptor);
617 if (retval != sizeof udev->descriptor) {
618 dev_dbg (&iface->dev, "dev descriptor --> %d\n", retval);
619 return (retval < 0) ? retval : -EDOM;
620 }
621
622 /* there's always [9.4.3] at least one config descriptor [9.6.3] */
623 for (i = 0; i < udev->descriptor.bNumConfigurations; i++) {
624 retval = usb_get_descriptor (udev, USB_DT_CONFIG, i,
625 dev->buf, TBUF_SIZE);
626 if (!is_good_config (dev->buf, retval)) {
627 dev_dbg (&iface->dev,
628 "config [%d] descriptor --> %d\n",
629 i, retval);
630 return (retval < 0) ? retval : -EDOM;
631 }
632
633 // FIXME cross-checking udev->config[i] to make sure usbcore
634 // parsed it right (etc) would be good testing paranoia
635 }
636
637 /* and sometimes [9.2.6.6] speed dependent descriptors */
638 if (le16_to_cpu(udev->descriptor.bcdUSB) == 0x0200) {
639 struct usb_qualifier_descriptor *d = NULL;
640
641 /* device qualifier [9.6.2] */
642 retval = usb_get_descriptor (udev,
643 USB_DT_DEVICE_QUALIFIER, 0, dev->buf,
644 sizeof (struct usb_qualifier_descriptor));
645 if (retval == -EPIPE) {
646 if (udev->speed == USB_SPEED_HIGH) {
647 dev_dbg (&iface->dev,
648 "hs dev qualifier --> %d\n",
649 retval);
650 return (retval < 0) ? retval : -EDOM;
651 }
652 /* usb2.0 but not high-speed capable; fine */
653 } else if (retval != sizeof (struct usb_qualifier_descriptor)) {
654 dev_dbg (&iface->dev, "dev qualifier --> %d\n", retval);
655 return (retval < 0) ? retval : -EDOM;
656 } else
657 d = (struct usb_qualifier_descriptor *) dev->buf;
658
659 /* might not have [9.6.2] any other-speed configs [9.6.4] */
660 if (d) {
661 unsigned max = d->bNumConfigurations;
662 for (i = 0; i < max; i++) {
663 retval = usb_get_descriptor (udev,
664 USB_DT_OTHER_SPEED_CONFIG, i,
665 dev->buf, TBUF_SIZE);
666 if (!is_good_config (dev->buf, retval)) {
667 dev_dbg (&iface->dev,
668 "other speed config --> %d\n",
669 retval);
670 return (retval < 0) ? retval : -EDOM;
671 }
672 }
673 }
674 }
675 // FIXME fetch strings from at least the device descriptor
676
677 /* [9.4.5] get_status always works */
678 retval = usb_get_status (udev, USB_RECIP_DEVICE, 0, dev->buf);
679 if (retval != 2) {
680 dev_dbg (&iface->dev, "get dev status --> %d\n", retval);
681 return (retval < 0) ? retval : -EDOM;
682 }
683
684 // FIXME configuration.bmAttributes says if we could try to set/clear
685 // the device's remote wakeup feature ... if we can, test that here
686
687 retval = usb_get_status (udev, USB_RECIP_INTERFACE,
688 iface->altsetting [0].desc.bInterfaceNumber, dev->buf);
689 if (retval != 2) {
690 dev_dbg (&iface->dev, "get interface status --> %d\n", retval);
691 return (retval < 0) ? retval : -EDOM;
692 }
693 // FIXME get status for each endpoint in the interface
694
695 return 0;
696 }
697
698 /*-------------------------------------------------------------------------*/
699
700 /* use ch9 requests to test whether:
701 * (a) queues work for control, keeping N subtests queued and
702 * active (auto-resubmit) for M loops through the queue.
703 * (b) protocol stalls (control-only) will autorecover.
704 * it's not like bulk/intr; no halt clearing.
705 * (c) short control reads are reported and handled.
706 * (d) queues are always processed in-order
707 */
708
709 struct ctrl_ctx {
710 spinlock_t lock;
711 struct usbtest_dev *dev;
712 struct completion complete;
713 unsigned count;
714 unsigned pending;
715 int status;
716 struct urb **urb;
717 struct usbtest_param *param;
718 int last;
719 };
720
721 #define NUM_SUBCASES 15 /* how many test subcases here? */
722
723 struct subcase {
724 struct usb_ctrlrequest setup;
725 int number;
726 int expected;
727 };
728
729 static void ctrl_complete (struct urb *urb, struct pt_regs *regs)
730 {
731 struct ctrl_ctx *ctx = urb->context;
732 struct usb_ctrlrequest *reqp;
733 struct subcase *subcase;
734 int status = urb->status;
735
736 reqp = (struct usb_ctrlrequest *)urb->setup_packet;
737 subcase = container_of (reqp, struct subcase, setup);
738
739 spin_lock (&ctx->lock);
740 ctx->count--;
741 ctx->pending--;
742
743 /* queue must transfer and complete in fifo order, unless
744 * usb_unlink_urb() is used to unlink something not at the
745 * physical queue head (not tested).
746 */
747 if (subcase->number > 0) {
748 if ((subcase->number - ctx->last) != 1) {
749 dbg ("subcase %d completed out of order, last %d",
750 subcase->number, ctx->last);
751 status = -EDOM;
752 ctx->last = subcase->number;
753 goto error;
754 }
755 }
756 ctx->last = subcase->number;
757
758 /* succeed or fault in only one way? */
759 if (status == subcase->expected)
760 status = 0;
761
762 /* async unlink for cleanup? */
763 else if (status != -ECONNRESET) {
764
765 /* some faults are allowed, not required */
766 if (subcase->expected > 0 && (
767 ((urb->status == -subcase->expected /* happened */
768 || urb->status == 0)))) /* didn't */
769 status = 0;
770 /* sometimes more than one fault is allowed */
771 else if (subcase->number == 12 && status == -EPIPE)
772 status = 0;
773 else
774 dbg ("subtest %d error, status %d",
775 subcase->number, status);
776 }
777
778 /* unexpected status codes mean errors; ideally, in hardware */
779 if (status) {
780 error:
781 if (ctx->status == 0) {
782 int i;
783
784 ctx->status = status;
785 info ("control queue %02x.%02x, err %d, %d left",
786 reqp->bRequestType, reqp->bRequest,
787 status, ctx->count);
788
789 /* FIXME this "unlink everything" exit route should
790 * be a separate test case.
791 */
792
793 /* unlink whatever's still pending */
794 for (i = 1; i < ctx->param->sglen; i++) {
795 struct urb *u = ctx->urb [
796 (i + subcase->number) % ctx->param->sglen];
797
798 if (u == urb || !u->dev)
799 continue;
800 status = usb_unlink_urb (u);
801 switch (status) {
802 case -EINPROGRESS:
803 case -EBUSY:
804 case -EIDRM:
805 continue;
806 default:
807 dbg ("urb unlink --> %d", status);
808 }
809 }
810 status = ctx->status;
811 }
812 }
813
814 /* resubmit if we need to, else mark this as done */
815 if ((status == 0) && (ctx->pending < ctx->count)) {
816 if ((status = usb_submit_urb (urb, SLAB_ATOMIC)) != 0) {
817 dbg ("can't resubmit ctrl %02x.%02x, err %d",
818 reqp->bRequestType, reqp->bRequest, status);
819 urb->dev = NULL;
820 } else
821 ctx->pending++;
822 } else
823 urb->dev = NULL;
824
825 /* signal completion when nothing's queued */
826 if (ctx->pending == 0)
827 complete (&ctx->complete);
828 spin_unlock (&ctx->lock);
829 }
830
831 static int
832 test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
833 {
834 struct usb_device *udev = testdev_to_usbdev (dev);
835 struct urb **urb;
836 struct ctrl_ctx context;
837 int i;
838
839 spin_lock_init (&context.lock);
840 context.dev = dev;
841 init_completion (&context.complete);
842 context.count = param->sglen * param->iterations;
843 context.pending = 0;
844 context.status = -ENOMEM;
845 context.param = param;
846 context.last = -1;
847
848 /* allocate and init the urbs we'll queue.
849 * as with bulk/intr sglists, sglen is the queue depth; it also
850 * controls which subtests run (more tests than sglen) or rerun.
851 */
852 urb = kmalloc (param->sglen * sizeof (struct urb *), SLAB_KERNEL);
853 if (!urb)
854 return -ENOMEM;
855 memset (urb, 0, param->sglen * sizeof (struct urb *));
856 for (i = 0; i < param->sglen; i++) {
857 int pipe = usb_rcvctrlpipe (udev, 0);
858 unsigned len;
859 struct urb *u;
860 struct usb_ctrlrequest req;
861 struct subcase *reqp;
862 int expected = 0;
863
864 /* requests here are mostly expected to succeed on any
865 * device, but some are chosen to trigger protocol stalls
866 * or short reads.
867 */
868 memset (&req, 0, sizeof req);
869 req.bRequest = USB_REQ_GET_DESCRIPTOR;
870 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
871
872 switch (i % NUM_SUBCASES) {
873 case 0: // get device descriptor
874 req.wValue = cpu_to_le16 (USB_DT_DEVICE << 8);
875 len = sizeof (struct usb_device_descriptor);
876 break;
877 case 1: // get first config descriptor (only)
878 req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
879 len = sizeof (struct usb_config_descriptor);
880 break;
881 case 2: // get altsetting (OFTEN STALLS)
882 req.bRequest = USB_REQ_GET_INTERFACE;
883 req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
884 // index = 0 means first interface
885 len = 1;
886 expected = EPIPE;
887 break;
888 case 3: // get interface status
889 req.bRequest = USB_REQ_GET_STATUS;
890 req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
891 // interface 0
892 len = 2;
893 break;
894 case 4: // get device status
895 req.bRequest = USB_REQ_GET_STATUS;
896 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
897 len = 2;
898 break;
899 case 5: // get device qualifier (MAY STALL)
900 req.wValue = cpu_to_le16 (USB_DT_DEVICE_QUALIFIER << 8);
901 len = sizeof (struct usb_qualifier_descriptor);
902 if (udev->speed != USB_SPEED_HIGH)
903 expected = EPIPE;
904 break;
905 case 6: // get first config descriptor, plus interface
906 req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
907 len = sizeof (struct usb_config_descriptor);
908 len += sizeof (struct usb_interface_descriptor);
909 break;
910 case 7: // get interface descriptor (ALWAYS STALLS)
911 req.wValue = cpu_to_le16 (USB_DT_INTERFACE << 8);
912 // interface == 0
913 len = sizeof (struct usb_interface_descriptor);
914 expected = EPIPE;
915 break;
916 // NOTE: two consecutive stalls in the queue here.
917 // that tests fault recovery a bit more aggressively.
918 case 8: // clear endpoint halt (USUALLY STALLS)
919 req.bRequest = USB_REQ_CLEAR_FEATURE;
920 req.bRequestType = USB_RECIP_ENDPOINT;
921 // wValue 0 == ep halt
922 // wIndex 0 == ep0 (shouldn't halt!)
923 len = 0;
924 pipe = usb_sndctrlpipe (udev, 0);
925 expected = EPIPE;
926 break;
927 case 9: // get endpoint status
928 req.bRequest = USB_REQ_GET_STATUS;
929 req.bRequestType = USB_DIR_IN|USB_RECIP_ENDPOINT;
930 // endpoint 0
931 len = 2;
932 break;
933 case 10: // trigger short read (EREMOTEIO)
934 req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
935 len = 1024;
936 expected = -EREMOTEIO;
937 break;
938 // NOTE: two consecutive _different_ faults in the queue.
939 case 11: // get endpoint descriptor (ALWAYS STALLS)
940 req.wValue = cpu_to_le16 (USB_DT_ENDPOINT << 8);
941 // endpoint == 0
942 len = sizeof (struct usb_interface_descriptor);
943 expected = EPIPE;
944 break;
945 // NOTE: sometimes even a third fault in the queue!
946 case 12: // get string 0 descriptor (MAY STALL)
947 req.wValue = cpu_to_le16 (USB_DT_STRING << 8);
948 // string == 0, for language IDs
949 len = sizeof (struct usb_interface_descriptor);
950 // may succeed when > 4 languages
951 expected = EREMOTEIO; // or EPIPE, if no strings
952 break;
953 case 13: // short read, resembling case 10
954 req.wValue = cpu_to_le16 ((USB_DT_CONFIG << 8) | 0);
955 // last data packet "should" be DATA1, not DATA0
956 len = 1024 - udev->descriptor.bMaxPacketSize0;
957 expected = -EREMOTEIO;
958 break;
959 case 14: // short read; try to fill the last packet
960 req.wValue = cpu_to_le16 ((USB_DT_DEVICE << 8) | 0);
961 // device descriptor size == 18 bytes
962 len = udev->descriptor.bMaxPacketSize0;
963 switch (len) {
964 case 8: len = 24; break;
965 case 16: len = 32; break;
966 }
967 expected = -EREMOTEIO;
968 break;
969 default:
970 err ("bogus number of ctrl queue testcases!");
971 context.status = -EINVAL;
972 goto cleanup;
973 }
974 req.wLength = cpu_to_le16 (len);
975 urb [i] = u = simple_alloc_urb (udev, pipe, len);
976 if (!u)
977 goto cleanup;
978
979 reqp = usb_buffer_alloc (udev, sizeof *reqp, SLAB_KERNEL,
980 &u->setup_dma);
981 if (!reqp)
982 goto cleanup;
983 reqp->setup = req;
984 reqp->number = i % NUM_SUBCASES;
985 reqp->expected = expected;
986 u->setup_packet = (char *) &reqp->setup;
987
988 u->context = &context;
989 u->complete = ctrl_complete;
990 u->transfer_flags |= URB_ASYNC_UNLINK;
991 }
992
993 /* queue the urbs */
994 context.urb = urb;
995 spin_lock_irq (&context.lock);
996 for (i = 0; i < param->sglen; i++) {
997 context.status = usb_submit_urb (urb [i], SLAB_ATOMIC);
998 if (context.status != 0) {
999 dbg ("can't submit urb[%d], status %d",
1000 i, context.status);
1001 context.count = context.pending;
1002 break;
1003 }
1004 context.pending++;
1005 }
1006 spin_unlock_irq (&context.lock);
1007
1008 /* FIXME set timer and time out; provide a disconnect hook */
1009
1010 /* wait for the last one to complete */
1011 if (context.pending > 0)
1012 wait_for_completion (&context.complete);
1013
1014 cleanup:
1015 for (i = 0; i < param->sglen; i++) {
1016 if (!urb [i])
1017 continue;
1018 urb [i]->dev = udev;
1019 if (urb [i]->setup_packet)
1020 usb_buffer_free (udev, sizeof (struct usb_ctrlrequest),
1021 urb [i]->setup_packet,
1022 urb [i]->setup_dma);
1023 simple_free_urb (urb [i]);
1024 }
1025 kfree (urb);
1026 return context.status;
1027 }
1028 #undef NUM_SUBCASES
1029
1030
1031 /*-------------------------------------------------------------------------*/
1032
1033 static void unlink1_callback (struct urb *urb, struct pt_regs *regs)
1034 {
1035 int status = urb->status;
1036
1037 // we "know" -EPIPE (stall) never happens
1038 if (!status)
1039 status = usb_submit_urb (urb, SLAB_ATOMIC);
1040 if (status) {
1041 urb->status = status;
1042 complete ((struct completion *) urb->context);
1043 }
1044 }
1045
1046 static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async)
1047 {
1048 struct urb *urb;
1049 struct completion completion;
1050 int retval = 0;
1051
1052 init_completion (&completion);
1053 urb = simple_alloc_urb (testdev_to_usbdev (dev), pipe, size);
1054 if (!urb)
1055 return -ENOMEM;
1056 urb->transfer_flags |= URB_ASYNC_UNLINK;
1057 urb->context = &completion;
1058 urb->complete = unlink1_callback;
1059
1060 /* keep the endpoint busy. there are lots of hc/hcd-internal
1061 * states, and testing should get to all of them over time.
1062 *
1063 * FIXME want additional tests for when endpoint is STALLing
1064 * due to errors, or is just NAKing requests.
1065 */
1066 if ((retval = usb_submit_urb (urb, SLAB_KERNEL)) != 0) {
1067 dev_dbg (&dev->intf->dev, "submit fail %d\n", retval);
1068 return retval;
1069 }
1070
1071 /* unlinking that should always work. variable delay tests more
1072 * hcd states and code paths, even with little other system load.
1073 */
1074 msleep (jiffies % (2 * INTERRUPT_RATE));
1075 if (async) {
1076 retry:
1077 retval = usb_unlink_urb (urb);
1078 if (retval == -EBUSY || retval == -EIDRM) {
1079 /* we can't unlink urbs while they're completing.
1080 * or if they've completed, and we haven't resubmitted.
1081 * "normal" drivers would prevent resubmission, but
1082 * since we're testing unlink paths, we can't.
1083 */
1084 dev_dbg (&dev->intf->dev, "unlink retry\n");
1085 goto retry;
1086 }
1087 } else
1088 usb_kill_urb (urb);
1089 if (!(retval == 0 || retval == -EINPROGRESS)) {
1090 dev_dbg (&dev->intf->dev, "unlink fail %d\n", retval);
1091 return retval;
1092 }
1093
1094 wait_for_completion (&completion);
1095 retval = urb->status;
1096 simple_free_urb (urb);
1097
1098 if (async)
1099 return (retval == -ECONNRESET) ? 0 : retval - 1000;
1100 else
1101 return (retval == -ENOENT || retval == -EPERM) ?
1102 0 : retval - 2000;
1103 }
1104
1105 static int unlink_simple (struct usbtest_dev *dev, int pipe, int len)
1106 {
1107 int retval = 0;
1108
1109 /* test sync and async paths */
1110 retval = unlink1 (dev, pipe, len, 1);
1111 if (!retval)
1112 retval = unlink1 (dev, pipe, len, 0);
1113 return retval;
1114 }
1115
1116 /*-------------------------------------------------------------------------*/
1117
1118 static int verify_not_halted (int ep, struct urb *urb)
1119 {
1120 int retval;
1121 u16 status;
1122
1123 /* shouldn't look or act halted */
1124 retval = usb_get_status (urb->dev, USB_RECIP_ENDPOINT, ep, &status);
1125 if (retval < 0) {
1126 dbg ("ep %02x couldn't get no-halt status, %d", ep, retval);
1127 return retval;
1128 }
1129 if (status != 0) {
1130 dbg ("ep %02x bogus status: %04x != 0", ep, status);
1131 return -EINVAL;
1132 }
1133 retval = simple_io (urb, 1, 0, 0, __FUNCTION__);
1134 if (retval != 0)
1135 return -EINVAL;
1136 return 0;
1137 }
1138
1139 static int verify_halted (int ep, struct urb *urb)
1140 {
1141 int retval;
1142 u16 status;
1143
1144 /* should look and act halted */
1145 retval = usb_get_status (urb->dev, USB_RECIP_ENDPOINT, ep, &status);
1146 if (retval < 0) {
1147 dbg ("ep %02x couldn't get halt status, %d", ep, retval);
1148 return retval;
1149 }
1150 if (status != 1) {
1151 dbg ("ep %02x bogus status: %04x != 1", ep, status);
1152 return -EINVAL;
1153 }
1154 retval = simple_io (urb, 1, 0, -EPIPE, __FUNCTION__);
1155 if (retval != -EPIPE)
1156 return -EINVAL;
1157 retval = simple_io (urb, 1, 0, -EPIPE, "verify_still_halted");
1158 if (retval != -EPIPE)
1159 return -EINVAL;
1160 return 0;
1161 }
1162
1163 static int test_halt (int ep, struct urb *urb)
1164 {
1165 int retval;
1166
1167 /* shouldn't look or act halted now */
1168 retval = verify_not_halted (ep, urb);
1169 if (retval < 0)
1170 return retval;
1171
1172 /* set halt (protocol test only), verify it worked */
1173 retval = usb_control_msg (urb->dev, usb_sndctrlpipe (urb->dev, 0),
1174 USB_REQ_SET_FEATURE, USB_RECIP_ENDPOINT,
1175 USB_ENDPOINT_HALT, ep,
1176 NULL, 0, USB_CTRL_SET_TIMEOUT);
1177 if (retval < 0) {
1178 dbg ("ep %02x couldn't set halt, %d", ep, retval);
1179 return retval;
1180 }
1181 retval = verify_halted (ep, urb);
1182 if (retval < 0)
1183 return retval;
1184
1185 /* clear halt (tests API + protocol), verify it worked */
1186 retval = usb_clear_halt (urb->dev, urb->pipe);
1187 if (retval < 0) {
1188 dbg ("ep %02x couldn't clear halt, %d", ep, retval);
1189 return retval;
1190 }
1191 retval = verify_not_halted (ep, urb);
1192 if (retval < 0)
1193 return retval;
1194
1195 /* NOTE: could also verify SET_INTERFACE clear halts ... */
1196
1197 return 0;
1198 }
1199
1200 static int halt_simple (struct usbtest_dev *dev)
1201 {
1202 int ep;
1203 int retval = 0;
1204 struct urb *urb;
1205
1206 urb = simple_alloc_urb (testdev_to_usbdev (dev), 0, 512);
1207 if (urb == NULL)
1208 return -ENOMEM;
1209
1210 if (dev->in_pipe) {
1211 ep = usb_pipeendpoint (dev->in_pipe) | USB_DIR_IN;
1212 urb->pipe = dev->in_pipe;
1213 retval = test_halt (ep, urb);
1214 if (retval < 0)
1215 goto done;
1216 }
1217
1218 if (dev->out_pipe) {
1219 ep = usb_pipeendpoint (dev->out_pipe);
1220 urb->pipe = dev->out_pipe;
1221 retval = test_halt (ep, urb);
1222 }
1223 done:
1224 simple_free_urb (urb);
1225 return retval;
1226 }
1227
1228 /*-------------------------------------------------------------------------*/
1229
1230 /* Control OUT tests use the vendor control requests from Intel's
1231 * USB 2.0 compliance test device: write a buffer, read it back.
1232 *
1233 * Intel's spec only _requires_ that it work for one packet, which
1234 * is pretty weak. Some HCDs place limits here; most devices will
1235 * need to be able to handle more than one OUT data packet. We'll
1236 * try whatever we're told to try.
1237 */
1238 static int ctrl_out (struct usbtest_dev *dev,
1239 unsigned count, unsigned length, unsigned vary)
1240 {
1241 unsigned i, j, len, retval;
1242 u8 *buf;
1243 char *what = "?";
1244 struct usb_device *udev;
1245
1246 if (length > 0xffff || vary >= length)
1247 return -EINVAL;
1248
1249 buf = kmalloc(length, SLAB_KERNEL);
1250 if (!buf)
1251 return -ENOMEM;
1252
1253 udev = testdev_to_usbdev (dev);
1254 len = length;
1255 retval = 0;
1256
1257 /* NOTE: hardware might well act differently if we pushed it
1258 * with lots back-to-back queued requests.
1259 */
1260 for (i = 0; i < count; i++) {
1261 /* write patterned data */
1262 for (j = 0; j < len; j++)
1263 buf [j] = i + j;
1264 retval = usb_control_msg (udev, usb_sndctrlpipe (udev,0),
1265 0x5b, USB_DIR_OUT|USB_TYPE_VENDOR,
1266 0, 0, buf, len, USB_CTRL_SET_TIMEOUT);
1267 if (retval != len) {
1268 what = "write";
1269 break;
1270 }
1271
1272 /* read it back -- assuming nothing intervened!! */
1273 retval = usb_control_msg (udev, usb_rcvctrlpipe (udev,0),
1274 0x5c, USB_DIR_IN|USB_TYPE_VENDOR,
1275 0, 0, buf, len, USB_CTRL_GET_TIMEOUT);
1276 if (retval != len) {
1277 what = "read";
1278 break;
1279 }
1280
1281 /* fail if we can't verify */
1282 for (j = 0; j < len; j++) {
1283 if (buf [j] != (u8) (i + j)) {
1284 INFO (dev, "ctrl_out, byte %d is %d not %d\n",
1285 j, buf [j], (u8) i + j);
1286 retval = -EBADMSG;
1287 break;
1288 }
1289 }
1290 if (retval < 0) {
1291 what = "verify";
1292 break;
1293 }
1294
1295 len += vary;
1296 if (len > length)
1297 len = 0;
1298 }
1299
1300 if (retval < 0)
1301 INFO (dev, "ctrl_out %s failed, code %d, count %d\n",
1302 what, retval, i);
1303
1304 kfree (buf);
1305 return retval;
1306 }
1307
1308 /*-------------------------------------------------------------------------*/
1309
1310 /* ISO tests ... mimics common usage
1311 * - buffer length is split into N packets (mostly maxpacket sized)
1312 * - multi-buffers according to sglen
1313 */
1314
1315 struct iso_context {
1316 unsigned count;
1317 unsigned pending;
1318 spinlock_t lock;
1319 struct completion done;
1320 unsigned long errors;
1321 struct usbtest_dev *dev;
1322 };
1323
1324 static void iso_callback (struct urb *urb, struct pt_regs *regs)
1325 {
1326 struct iso_context *ctx = urb->context;
1327
1328 spin_lock(&ctx->lock);
1329 ctx->count--;
1330
1331 if (urb->error_count > 0)
1332 ctx->errors += urb->error_count;
1333
1334 if (urb->status == 0 && ctx->count > (ctx->pending - 1)) {
1335 int status = usb_submit_urb (urb, GFP_ATOMIC);
1336 switch (status) {
1337 case 0:
1338 goto done;
1339 default:
1340 dev_dbg (&ctx->dev->intf->dev,
1341 "iso resubmit err %d\n",
1342 status);
1343 /* FALLTHROUGH */
1344 case -ENODEV: /* disconnected */
1345 break;
1346 }
1347 }
1348 simple_free_urb (urb);
1349
1350 ctx->pending--;
1351 if (ctx->pending == 0) {
1352 if (ctx->errors)
1353 dev_dbg (&ctx->dev->intf->dev,
1354 "iso test, %lu errors\n",
1355 ctx->errors);
1356 complete (&ctx->done);
1357 }
1358 done:
1359 spin_unlock(&ctx->lock);
1360 }
1361
1362 static struct urb *iso_alloc_urb (
1363 struct usb_device *udev,
1364 int pipe,
1365 struct usb_endpoint_descriptor *desc,
1366 long bytes
1367 )
1368 {
1369 struct urb *urb;
1370 unsigned i, maxp, packets;
1371
1372 if (bytes < 0 || !desc)
1373 return NULL;
1374 maxp = 0x7ff & le16_to_cpu(desc->wMaxPacketSize);
1375 maxp *= 1 + (0x3 & (le16_to_cpu(desc->wMaxPacketSize) >> 11));
1376 packets = (bytes + maxp - 1) / maxp;
1377
1378 urb = usb_alloc_urb (packets, SLAB_KERNEL);
1379 if (!urb)
1380 return urb;
1381 urb->dev = udev;
1382 urb->pipe = pipe;
1383
1384 urb->number_of_packets = packets;
1385 urb->transfer_buffer_length = bytes;
1386 urb->transfer_buffer = usb_buffer_alloc (udev, bytes, SLAB_KERNEL,
1387 &urb->transfer_dma);
1388 if (!urb->transfer_buffer) {
1389 usb_free_urb (urb);
1390 return NULL;
1391 }
1392 memset (urb->transfer_buffer, 0, bytes);
1393 for (i = 0; i < packets; i++) {
1394 /* here, only the last packet will be short */
1395 urb->iso_frame_desc[i].length = min ((unsigned) bytes, maxp);
1396 bytes -= urb->iso_frame_desc[i].length;
1397
1398 urb->iso_frame_desc[i].offset = maxp * i;
1399 }
1400
1401 urb->complete = iso_callback;
1402 // urb->context = SET BY CALLER
1403 urb->interval = 1 << (desc->bInterval - 1);
1404 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1405 return urb;
1406 }
1407
1408 static int
1409 test_iso_queue (struct usbtest_dev *dev, struct usbtest_param *param,
1410 int pipe, struct usb_endpoint_descriptor *desc)
1411 {
1412 struct iso_context context;
1413 struct usb_device *udev;
1414 unsigned i;
1415 unsigned long packets = 0;
1416 int status;
1417 struct urb *urbs[10]; /* FIXME no limit */
1418
1419 if (param->sglen > 10)
1420 return -EDOM;
1421
1422 context.count = param->iterations * param->sglen;
1423 context.pending = param->sglen;
1424 context.errors = 0;
1425 context.dev = dev;
1426 init_completion (&context.done);
1427 spin_lock_init (&context.lock);
1428
1429 memset (urbs, 0, sizeof urbs);
1430 udev = testdev_to_usbdev (dev);
1431 dev_dbg (&dev->intf->dev,
1432 "... iso period %d %sframes, wMaxPacket %04x\n",
1433 1 << (desc->bInterval - 1),
1434 (udev->speed == USB_SPEED_HIGH) ? "micro" : "",
1435 le16_to_cpu(desc->wMaxPacketSize));
1436
1437 for (i = 0; i < param->sglen; i++) {
1438 urbs [i] = iso_alloc_urb (udev, pipe, desc,
1439 param->length);
1440 if (!urbs [i]) {
1441 status = -ENOMEM;
1442 goto fail;
1443 }
1444 packets += urbs[i]->number_of_packets;
1445 urbs [i]->context = &context;
1446 }
1447 packets *= param->iterations;
1448 dev_dbg (&dev->intf->dev,
1449 "... total %lu msec (%lu packets)\n",
1450 (packets * (1 << (desc->bInterval - 1)))
1451 / ((udev->speed == USB_SPEED_HIGH) ? 8 : 1),
1452 packets);
1453
1454 spin_lock_irq (&context.lock);
1455 for (i = 0; i < param->sglen; i++) {
1456 status = usb_submit_urb (urbs [i], SLAB_ATOMIC);
1457 if (status < 0) {
1458 ERROR (dev, "submit iso[%d], error %d\n", i, status);
1459 if (i == 0) {
1460 spin_unlock_irq (&context.lock);
1461 goto fail;
1462 }
1463
1464 simple_free_urb (urbs [i]);
1465 context.pending--;
1466 }
1467 }
1468 spin_unlock_irq (&context.lock);
1469
1470 wait_for_completion (&context.done);
1471 return 0;
1472
1473 fail:
1474 for (i = 0; i < param->sglen; i++) {
1475 if (urbs [i])
1476 simple_free_urb (urbs [i]);
1477 }
1478 return status;
1479 }
1480
1481 /*-------------------------------------------------------------------------*/
1482
1483 /* We only have this one interface to user space, through usbfs.
1484 * User mode code can scan usbfs to find N different devices (maybe on
1485 * different busses) to use when testing, and allocate one thread per
1486 * test. So discovery is simplified, and we have no device naming issues.
1487 *
1488 * Don't use these only as stress/load tests. Use them along with with
1489 * other USB bus activity: plugging, unplugging, mousing, mp3 playback,
1490 * video capture, and so on. Run different tests at different times, in
1491 * different sequences. Nothing here should interact with other devices,
1492 * except indirectly by consuming USB bandwidth and CPU resources for test
1493 * threads and request completion. But the only way to know that for sure
1494 * is to test when HC queues are in use by many devices.
1495 */
1496
1497 static int
1498 usbtest_ioctl (struct usb_interface *intf, unsigned int code, void *buf)
1499 {
1500 struct usbtest_dev *dev = usb_get_intfdata (intf);
1501 struct usb_device *udev = testdev_to_usbdev (dev);
1502 struct usbtest_param *param = buf;
1503 int retval = -EOPNOTSUPP;
1504 struct urb *urb;
1505 struct scatterlist *sg;
1506 struct usb_sg_request req;
1507 struct timeval start;
1508 unsigned i;
1509
1510 // FIXME USBDEVFS_CONNECTINFO doesn't say how fast the device is.
1511
1512 if (code != USBTEST_REQUEST)
1513 return -EOPNOTSUPP;
1514
1515 if (param->iterations <= 0 || param->length < 0
1516 || param->sglen < 0 || param->vary < 0)
1517 return -EINVAL;
1518
1519 if (down_interruptible (&dev->sem))
1520 return -ERESTARTSYS;
1521
1522 /* some devices, like ez-usb default devices, need a non-default
1523 * altsetting to have any active endpoints. some tests change
1524 * altsettings; force a default so most tests don't need to check.
1525 */
1526 if (dev->info->alt >= 0) {
1527 int res;
1528
1529 if (intf->altsetting->desc.bInterfaceNumber) {
1530 up (&dev->sem);
1531 return -ENODEV;
1532 }
1533 res = set_altsetting (dev, dev->info->alt);
1534 if (res) {
1535 dev_err (&intf->dev,
1536 "set altsetting to %d failed, %d\n",
1537 dev->info->alt, res);
1538 up (&dev->sem);
1539 return res;
1540 }
1541 }
1542
1543 /*
1544 * Just a bunch of test cases that every HCD is expected to handle.
1545 *
1546 * Some may need specific firmware, though it'd be good to have
1547 * one firmware image to handle all the test cases.
1548 *
1549 * FIXME add more tests! cancel requests, verify the data, control
1550 * queueing, concurrent read+write threads, and so on.
1551 */
1552 do_gettimeofday (&start);
1553 switch (param->test_num) {
1554
1555 case 0:
1556 dev_dbg (&intf->dev, "TEST 0: NOP\n");
1557 retval = 0;
1558 break;
1559
1560 /* Simple non-queued bulk I/O tests */
1561 case 1:
1562 if (dev->out_pipe == 0)
1563 break;
1564 dev_dbg (&intf->dev,
1565 "TEST 1: write %d bytes %u times\n",
1566 param->length, param->iterations);
1567 urb = simple_alloc_urb (udev, dev->out_pipe, param->length);
1568 if (!urb) {
1569 retval = -ENOMEM;
1570 break;
1571 }
1572 // FIRMWARE: bulk sink (maybe accepts short writes)
1573 retval = simple_io (urb, param->iterations, 0, 0, "test1");
1574 simple_free_urb (urb);
1575 break;
1576 case 2:
1577 if (dev->in_pipe == 0)
1578 break;
1579 dev_dbg (&intf->dev,
1580 "TEST 2: read %d bytes %u times\n",
1581 param->length, param->iterations);
1582 urb = simple_alloc_urb (udev, dev->in_pipe, param->length);
1583 if (!urb) {
1584 retval = -ENOMEM;
1585 break;
1586 }
1587 // FIRMWARE: bulk source (maybe generates short writes)
1588 retval = simple_io (urb, param->iterations, 0, 0, "test2");
1589 simple_free_urb (urb);
1590 break;
1591 case 3:
1592 if (dev->out_pipe == 0 || param->vary == 0)
1593 break;
1594 dev_dbg (&intf->dev,
1595 "TEST 3: write/%d 0..%d bytes %u times\n",
1596 param->vary, param->length, param->iterations);
1597 urb = simple_alloc_urb (udev, dev->out_pipe, param->length);
1598 if (!urb) {
1599 retval = -ENOMEM;
1600 break;
1601 }
1602 // FIRMWARE: bulk sink (maybe accepts short writes)
1603 retval = simple_io (urb, param->iterations, param->vary,
1604 0, "test3");
1605 simple_free_urb (urb);
1606 break;
1607 case 4:
1608 if (dev->in_pipe == 0 || param->vary == 0)
1609 break;
1610 dev_dbg (&intf->dev,
1611 "TEST 4: read/%d 0..%d bytes %u times\n",
1612 param->vary, param->length, param->iterations);
1613 urb = simple_alloc_urb (udev, dev->in_pipe, param->length);
1614 if (!urb) {
1615 retval = -ENOMEM;
1616 break;
1617 }
1618 // FIRMWARE: bulk source (maybe generates short writes)
1619 retval = simple_io (urb, param->iterations, param->vary,
1620 0, "test4");
1621 simple_free_urb (urb);
1622 break;
1623
1624 /* Queued bulk I/O tests */
1625 case 5:
1626 if (dev->out_pipe == 0 || param->sglen == 0)
1627 break;
1628 dev_dbg (&intf->dev,
1629 "TEST 5: write %d sglists %d entries of %d bytes\n",
1630 param->iterations,
1631 param->sglen, param->length);
1632 sg = alloc_sglist (param->sglen, param->length, 0);
1633 if (!sg) {
1634 retval = -ENOMEM;
1635 break;
1636 }
1637 // FIRMWARE: bulk sink (maybe accepts short writes)
1638 retval = perform_sglist (udev, param->iterations, dev->out_pipe,
1639 &req, sg, param->sglen);
1640 free_sglist (sg, param->sglen);
1641 break;
1642
1643 case 6:
1644 if (dev->in_pipe == 0 || param->sglen == 0)
1645 break;
1646 dev_dbg (&intf->dev,
1647 "TEST 6: read %d sglists %d entries of %d bytes\n",
1648 param->iterations,
1649 param->sglen, param->length);
1650 sg = alloc_sglist (param->sglen, param->length, 0);
1651 if (!sg) {
1652 retval = -ENOMEM;
1653 break;
1654 }
1655 // FIRMWARE: bulk source (maybe generates short writes)
1656 retval = perform_sglist (udev, param->iterations, dev->in_pipe,
1657 &req, sg, param->sglen);
1658 free_sglist (sg, param->sglen);
1659 break;
1660 case 7:
1661 if (dev->out_pipe == 0 || param->sglen == 0 || param->vary == 0)
1662 break;
1663 dev_dbg (&intf->dev,
1664 "TEST 7: write/%d %d sglists %d entries 0..%d bytes\n",
1665 param->vary, param->iterations,
1666 param->sglen, param->length);
1667 sg = alloc_sglist (param->sglen, param->length, param->vary);
1668 if (!sg) {
1669 retval = -ENOMEM;
1670 break;
1671 }
1672 // FIRMWARE: bulk sink (maybe accepts short writes)
1673 retval = perform_sglist (udev, param->iterations, dev->out_pipe,
1674 &req, sg, param->sglen);
1675 free_sglist (sg, param->sglen);
1676 break;
1677 case 8:
1678 if (dev->in_pipe == 0 || param->sglen == 0 || param->vary == 0)
1679 break;
1680 dev_dbg (&intf->dev,
1681 "TEST 8: read/%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 source (maybe generates short writes)
1690 retval = perform_sglist (udev, param->iterations, dev->in_pipe,
1691 &req, sg, param->sglen);
1692 free_sglist (sg, param->sglen);
1693 break;
1694
1695 /* non-queued sanity tests for control (chapter 9 subset) */
1696 case 9:
1697 retval = 0;
1698 dev_dbg (&intf->dev,
1699 "TEST 9: ch9 (subset) control tests, %d times\n",
1700 param->iterations);
1701 for (i = param->iterations; retval == 0 && i--; /* NOP */)
1702 retval = ch9_postconfig (dev);
1703 if (retval)
1704 dbg ("ch9 subset failed, iterations left %d", i);
1705 break;
1706
1707 /* queued control messaging */
1708 case 10:
1709 if (param->sglen == 0)
1710 break;
1711 retval = 0;
1712 dev_dbg (&intf->dev,
1713 "TEST 10: queue %d control calls, %d times\n",
1714 param->sglen,
1715 param->iterations);
1716 retval = test_ctrl_queue (dev, param);
1717 break;
1718
1719 /* simple non-queued unlinks (ring with one urb) */
1720 case 11:
1721 if (dev->in_pipe == 0 || !param->length)
1722 break;
1723 retval = 0;
1724 dev_dbg (&intf->dev, "TEST 11: unlink %d reads of %d\n",
1725 param->iterations, param->length);
1726 for (i = param->iterations; retval == 0 && i--; /* NOP */)
1727 retval = unlink_simple (dev, dev->in_pipe,
1728 param->length);
1729 if (retval)
1730 dev_dbg (&intf->dev, "unlink reads failed %d, "
1731 "iterations left %d\n", retval, i);
1732 break;
1733 case 12:
1734 if (dev->out_pipe == 0 || !param->length)
1735 break;
1736 retval = 0;
1737 dev_dbg (&intf->dev, "TEST 12: unlink %d writes of %d\n",
1738 param->iterations, param->length);
1739 for (i = param->iterations; retval == 0 && i--; /* NOP */)
1740 retval = unlink_simple (dev, dev->out_pipe,
1741 param->length);
1742 if (retval)
1743 dev_dbg (&intf->dev, "unlink writes failed %d, "
1744 "iterations left %d\n", retval, i);
1745 break;
1746
1747 /* ep halt tests */
1748 case 13:
1749 if (dev->out_pipe == 0 && dev->in_pipe == 0)
1750 break;
1751 retval = 0;
1752 dev_dbg (&intf->dev, "TEST 13: set/clear %d halts\n",
1753 param->iterations);
1754 for (i = param->iterations; retval == 0 && i--; /* NOP */)
1755 retval = halt_simple (dev);
1756
1757 if (retval)
1758 DBG (dev, "halts failed, iterations left %d\n", i);
1759 break;
1760
1761 /* control write tests */
1762 case 14:
1763 if (!dev->info->ctrl_out)
1764 break;
1765 dev_dbg (&intf->dev, "TEST 14: %d ep0out, 0..%d vary %d\n",
1766 param->iterations, param->length, param->vary);
1767 retval = ctrl_out (dev, param->iterations,
1768 param->length, param->vary);
1769 break;
1770
1771 /* iso write tests */
1772 case 15:
1773 if (dev->out_iso_pipe == 0 || param->sglen == 0)
1774 break;
1775 dev_dbg (&intf->dev,
1776 "TEST 15: write %d iso, %d entries of %d bytes\n",
1777 param->iterations,
1778 param->sglen, param->length);
1779 // FIRMWARE: iso sink
1780 retval = test_iso_queue (dev, param,
1781 dev->out_iso_pipe, dev->iso_out);
1782 break;
1783
1784 /* iso read tests */
1785 case 16:
1786 if (dev->in_iso_pipe == 0 || param->sglen == 0)
1787 break;
1788 dev_dbg (&intf->dev,
1789 "TEST 16: read %d iso, %d entries of %d bytes\n",
1790 param->iterations,
1791 param->sglen, param->length);
1792 // FIRMWARE: iso source
1793 retval = test_iso_queue (dev, param,
1794 dev->in_iso_pipe, dev->iso_in);
1795 break;
1796
1797 // FIXME unlink from queue (ring with N urbs)
1798
1799 // FIXME scatterlist cancel (needs helper thread)
1800
1801 }
1802 do_gettimeofday (&param->duration);
1803 param->duration.tv_sec -= start.tv_sec;
1804 param->duration.tv_usec -= start.tv_usec;
1805 if (param->duration.tv_usec < 0) {
1806 param->duration.tv_usec += 1000 * 1000;
1807 param->duration.tv_sec -= 1;
1808 }
1809 up (&dev->sem);
1810 return retval;
1811 }
1812
1813 /*-------------------------------------------------------------------------*/
1814
1815 static unsigned force_interrupt = 0;
1816 module_param (force_interrupt, uint, 0);
1817 MODULE_PARM_DESC (force_interrupt, "0 = test default; else interrupt");
1818
1819 #ifdef GENERIC
1820 static unsigned short vendor;
1821 module_param(vendor, ushort, 0);
1822 MODULE_PARM_DESC (vendor, "vendor code (from usb-if)");
1823
1824 static unsigned short product;
1825 module_param(product, ushort, 0);
1826 MODULE_PARM_DESC (product, "product code (from vendor)");
1827 #endif
1828
1829 static int
1830 usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
1831 {
1832 struct usb_device *udev;
1833 struct usbtest_dev *dev;
1834 struct usbtest_info *info;
1835 char *rtest, *wtest;
1836 char *irtest, *iwtest;
1837
1838 udev = interface_to_usbdev (intf);
1839
1840 #ifdef GENERIC
1841 /* specify devices by module parameters? */
1842 if (id->match_flags == 0) {
1843 /* vendor match required, product match optional */
1844 if (!vendor || le16_to_cpu(udev->descriptor.idVendor) != (u16)vendor)
1845 return -ENODEV;
1846 if (product && le16_to_cpu(udev->descriptor.idProduct) != (u16)product)
1847 return -ENODEV;
1848 dbg ("matched module params, vend=0x%04x prod=0x%04x",
1849 le16_to_cpu(udev->descriptor.idVendor),
1850 le16_to_cpu(udev->descriptor.idProduct));
1851 }
1852 #endif
1853
1854 dev = kmalloc (sizeof *dev, SLAB_KERNEL);
1855 if (!dev)
1856 return -ENOMEM;
1857 memset (dev, 0, sizeof *dev);
1858 info = (struct usbtest_info *) id->driver_info;
1859 dev->info = info;
1860 init_MUTEX (&dev->sem);
1861
1862 dev->intf = intf;
1863
1864 /* cacheline-aligned scratch for i/o */
1865 if ((dev->buf = kmalloc (TBUF_SIZE, SLAB_KERNEL)) == NULL) {
1866 kfree (dev);
1867 return -ENOMEM;
1868 }
1869
1870 /* NOTE this doesn't yet test the handful of difference that are
1871 * visible with high speed interrupts: bigger maxpacket (1K) and
1872 * "high bandwidth" modes (up to 3 packets/uframe).
1873 */
1874 rtest = wtest = "";
1875 irtest = iwtest = "";
1876 if (force_interrupt || udev->speed == USB_SPEED_LOW) {
1877 if (info->ep_in) {
1878 dev->in_pipe = usb_rcvintpipe (udev, info->ep_in);
1879 rtest = " intr-in";
1880 }
1881 if (info->ep_out) {
1882 dev->out_pipe = usb_sndintpipe (udev, info->ep_out);
1883 wtest = " intr-out";
1884 }
1885 } else {
1886 if (info->autoconf) {
1887 int status;
1888
1889 status = get_endpoints (dev, intf);
1890 if (status < 0) {
1891 dbg ("couldn't get endpoints, %d\n", status);
1892 return status;
1893 }
1894 /* may find bulk or ISO pipes */
1895 } else {
1896 if (info->ep_in)
1897 dev->in_pipe = usb_rcvbulkpipe (udev,
1898 info->ep_in);
1899 if (info->ep_out)
1900 dev->out_pipe = usb_sndbulkpipe (udev,
1901 info->ep_out);
1902 }
1903 if (dev->in_pipe)
1904 rtest = " bulk-in";
1905 if (dev->out_pipe)
1906 wtest = " bulk-out";
1907 if (dev->in_iso_pipe)
1908 irtest = " iso-in";
1909 if (dev->out_iso_pipe)
1910 iwtest = " iso-out";
1911 }
1912
1913 usb_set_intfdata (intf, dev);
1914 dev_info (&intf->dev, "%s\n", info->name);
1915 dev_info (&intf->dev, "%s speed {control%s%s%s%s%s} tests%s\n",
1916 ({ char *tmp;
1917 switch (udev->speed) {
1918 case USB_SPEED_LOW: tmp = "low"; break;
1919 case USB_SPEED_FULL: tmp = "full"; break;
1920 case USB_SPEED_HIGH: tmp = "high"; break;
1921 default: tmp = "unknown"; break;
1922 }; tmp; }),
1923 info->ctrl_out ? " in/out" : "",
1924 rtest, wtest,
1925 irtest, iwtest,
1926 info->alt >= 0 ? " (+alt)" : "");
1927 return 0;
1928 }
1929
1930 static void usbtest_disconnect (struct usb_interface *intf)
1931 {
1932 struct usbtest_dev *dev = usb_get_intfdata (intf);
1933
1934 down (&dev->sem);
1935
1936 usb_set_intfdata (intf, NULL);
1937 dev_dbg (&intf->dev, "disconnect\n");
1938 kfree (dev);
1939 }
1940
1941 /* Basic testing only needs a device that can source or sink bulk traffic.
1942 * Any device can test control transfers (default with GENERIC binding).
1943 *
1944 * Several entries work with the default EP0 implementation that's built
1945 * into EZ-USB chips. There's a default vendor ID which can be overridden
1946 * by (very) small config EEPROMS, but otherwise all these devices act
1947 * identically until firmware is loaded: only EP0 works. It turns out
1948 * to be easy to make other endpoints work, without modifying that EP0
1949 * behavior. For now, we expect that kind of firmware.
1950 */
1951
1952 /* an21xx or fx versions of ez-usb */
1953 static struct usbtest_info ez1_info = {
1954 .name = "EZ-USB device",
1955 .ep_in = 2,
1956 .ep_out = 2,
1957 .alt = 1,
1958 };
1959
1960 /* fx2 version of ez-usb */
1961 static struct usbtest_info ez2_info = {
1962 .name = "FX2 device",
1963 .ep_in = 6,
1964 .ep_out = 2,
1965 .alt = 1,
1966 };
1967
1968 /* ezusb family device with dedicated usb test firmware,
1969 */
1970 static struct usbtest_info fw_info = {
1971 .name = "usb test device",
1972 .ep_in = 2,
1973 .ep_out = 2,
1974 .alt = 1,
1975 .autoconf = 1, // iso and ctrl_out need autoconf
1976 .ctrl_out = 1,
1977 .iso = 1, // iso_ep's are #8 in/out
1978 };
1979
1980 /* peripheral running Linux and 'zero.c' test firmware, or
1981 * its user-mode cousin. different versions of this use
1982 * different hardware with the same vendor/product codes.
1983 * host side MUST rely on the endpoint descriptors.
1984 */
1985 static struct usbtest_info gz_info = {
1986 .name = "Linux gadget zero",
1987 .autoconf = 1,
1988 .ctrl_out = 1,
1989 .alt = 0,
1990 };
1991
1992 static struct usbtest_info um_info = {
1993 .name = "Linux user mode test driver",
1994 .autoconf = 1,
1995 .alt = -1,
1996 };
1997
1998 static struct usbtest_info um2_info = {
1999 .name = "Linux user mode ISO test driver",
2000 .autoconf = 1,
2001 .iso = 1,
2002 .alt = -1,
2003 };
2004
2005 #ifdef IBOT2
2006 /* this is a nice source of high speed bulk data;
2007 * uses an FX2, with firmware provided in the device
2008 */
2009 static struct usbtest_info ibot2_info = {
2010 .name = "iBOT2 webcam",
2011 .ep_in = 2,
2012 .alt = -1,
2013 };
2014 #endif
2015
2016 #ifdef GENERIC
2017 /* we can use any device to test control traffic */
2018 static struct usbtest_info generic_info = {
2019 .name = "Generic USB device",
2020 .alt = -1,
2021 };
2022 #endif
2023
2024 // FIXME remove this
2025 static struct usbtest_info hact_info = {
2026 .name = "FX2/hact",
2027 //.ep_in = 6,
2028 .ep_out = 2,
2029 .alt = -1,
2030 };
2031
2032
2033 static struct usb_device_id id_table [] = {
2034
2035 { USB_DEVICE (0x0547, 0x1002),
2036 .driver_info = (unsigned long) &hact_info,
2037 },
2038
2039 /*-------------------------------------------------------------*/
2040
2041 /* EZ-USB devices which download firmware to replace (or in our
2042 * case augment) the default device implementation.
2043 */
2044
2045 /* generic EZ-USB FX controller */
2046 { USB_DEVICE (0x0547, 0x2235),
2047 .driver_info = (unsigned long) &ez1_info,
2048 },
2049
2050 /* CY3671 development board with EZ-USB FX */
2051 { USB_DEVICE (0x0547, 0x0080),
2052 .driver_info = (unsigned long) &ez1_info,
2053 },
2054
2055 /* generic EZ-USB FX2 controller (or development board) */
2056 { USB_DEVICE (0x04b4, 0x8613),
2057 .driver_info = (unsigned long) &ez2_info,
2058 },
2059
2060 /* re-enumerated usb test device firmware */
2061 { USB_DEVICE (0xfff0, 0xfff0),
2062 .driver_info = (unsigned long) &fw_info,
2063 },
2064
2065 /* "Gadget Zero" firmware runs under Linux */
2066 { USB_DEVICE (0x0525, 0xa4a0),
2067 .driver_info = (unsigned long) &gz_info,
2068 },
2069
2070 /* so does a user-mode variant */
2071 { USB_DEVICE (0x0525, 0xa4a4),
2072 .driver_info = (unsigned long) &um_info,
2073 },
2074
2075 /* ... and a user-mode variant that talks iso */
2076 { USB_DEVICE (0x0525, 0xa4a3),
2077 .driver_info = (unsigned long) &um2_info,
2078 },
2079
2080 #ifdef KEYSPAN_19Qi
2081 /* Keyspan 19qi uses an21xx (original EZ-USB) */
2082 // this does not coexist with the real Keyspan 19qi driver!
2083 { USB_DEVICE (0x06cd, 0x010b),
2084 .driver_info = (unsigned long) &ez1_info,
2085 },
2086 #endif
2087
2088 /*-------------------------------------------------------------*/
2089
2090 #ifdef IBOT2
2091 /* iBOT2 makes a nice source of high speed bulk-in data */
2092 // this does not coexist with a real iBOT2 driver!
2093 { USB_DEVICE (0x0b62, 0x0059),
2094 .driver_info = (unsigned long) &ibot2_info,
2095 },
2096 #endif
2097
2098 /*-------------------------------------------------------------*/
2099
2100 #ifdef GENERIC
2101 /* module params can specify devices to use for control tests */
2102 { .driver_info = (unsigned long) &generic_info, },
2103 #endif
2104
2105 /*-------------------------------------------------------------*/
2106
2107 { }
2108 };
2109 MODULE_DEVICE_TABLE (usb, id_table);
2110
2111 static struct usb_driver usbtest_driver = {
2112 .owner = THIS_MODULE,
2113 .name = "usbtest",
2114 .id_table = id_table,
2115 .probe = usbtest_probe,
2116 .ioctl = usbtest_ioctl,
2117 .disconnect = usbtest_disconnect,
2118 };
2119
2120 /*-------------------------------------------------------------------------*/
2121
2122 static int __init usbtest_init (void)
2123 {
2124 #ifdef GENERIC
2125 if (vendor)
2126 dbg ("params: vend=0x%04x prod=0x%04x", vendor, product);
2127 #endif
2128 return usb_register (&usbtest_driver);
2129 }
2130 module_init (usbtest_init);
2131
2132 static void __exit usbtest_exit (void)
2133 {
2134 usb_deregister (&usbtest_driver);
2135 }
2136 module_exit (usbtest_exit);
2137
2138 MODULE_DESCRIPTION ("USB Core/HCD Testing Driver");
2139 MODULE_LICENSE ("GPL");
2140
Verdex Pro support