?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/mm: Add TLB purge to free pmd/pte page interfaces
[linux/fpc-iii.git] / drivers / usb / misc / usbtest.c
blobe31f72b3a22c5eea7b8b290f330a098505579880
1 #include <linux/kernel.h>
2 #include <linux/errno.h>
3 #include <linux/init.h>
4 #include <linux/slab.h>
5 #include <linux/mm.h>
6 #include <linux/module.h>
7 #include <linux/moduleparam.h>
8 #include <linux/scatterlist.h>
9 #include <linux/mutex.h>
10 #include <linux/timer.h>
11 #include <linux/usb.h>
12
13 #define SIMPLE_IO_TIMEOUT 10000 /* in milliseconds */
14
15 /*-------------------------------------------------------------------------*/
16
17 static int override_alt = -1;
18 module_param_named(alt, override_alt, int, 0644);
19 MODULE_PARM_DESC(alt, ">= 0 to override altsetting selection");
20 static void complicated_callback(struct urb *urb);
21
22 /*-------------------------------------------------------------------------*/
23
24 /* FIXME make these public somewhere; usbdevfs.h? */
25
26 /* Parameter for usbtest driver. */
27 struct usbtest_param_32 {
28 /* inputs */
29 __u32 test_num; /* 0..(TEST_CASES-1) */
30 __u32 iterations;
31 __u32 length;
32 __u32 vary;
33 __u32 sglen;
34
35 /* outputs */
36 __s32 duration_sec;
37 __s32 duration_usec;
38 };
39
40 /*
41 * Compat parameter to the usbtest driver.
42 * This supports older user space binaries compiled with 64 bit compiler.
43 */
44 struct usbtest_param_64 {
45 /* inputs */
46 __u32 test_num; /* 0..(TEST_CASES-1) */
47 __u32 iterations;
48 __u32 length;
49 __u32 vary;
50 __u32 sglen;
51
52 /* outputs */
53 __s64 duration_sec;
54 __s64 duration_usec;
55 };
56
57 /* IOCTL interface to the driver. */
58 #define USBTEST_REQUEST_32 _IOWR('U', 100, struct usbtest_param_32)
59 /* COMPAT IOCTL interface to the driver. */
60 #define USBTEST_REQUEST_64 _IOWR('U', 100, struct usbtest_param_64)
61
62 /*-------------------------------------------------------------------------*/
63
64 #define GENERIC /* let probe() bind using module params */
65
66 /* Some devices that can be used for testing will have "real" drivers.
67 * Entries for those need to be enabled here by hand, after disabling
68 * that "real" driver.
69 */
70 //#define IBOT2 /* grab iBOT2 webcams */
71 //#define KEYSPAN_19Qi /* grab un-renumerated serial adapter */
72
73 /*-------------------------------------------------------------------------*/
74
75 struct usbtest_info {
76 const char *name;
77 u8 ep_in; /* bulk/intr source */
78 u8 ep_out; /* bulk/intr sink */
79 unsigned autoconf:1;
80 unsigned ctrl_out:1;
81 unsigned iso:1; /* try iso in/out */
82 unsigned intr:1; /* try interrupt in/out */
83 int alt;
84 };
85
86 /* this is accessed only through usbfs ioctl calls.
87 * one ioctl to issue a test ... one lock per device.
88 * tests create other threads if they need them.
89 * urbs and buffers are allocated dynamically,
90 * and data generated deterministically.
91 */
92 struct usbtest_dev {
93 struct usb_interface *intf;
94 struct usbtest_info *info;
95 int in_pipe;
96 int out_pipe;
97 int in_iso_pipe;
98 int out_iso_pipe;
99 int in_int_pipe;
100 int out_int_pipe;
101 struct usb_endpoint_descriptor *iso_in, *iso_out;
102 struct usb_endpoint_descriptor *int_in, *int_out;
103 struct mutex lock;
104
105 #define TBUF_SIZE 256
106 u8 *buf;
107 };
108
109 static struct usb_device *testdev_to_usbdev(struct usbtest_dev *test)
110 {
111 return interface_to_usbdev(test->intf);
112 }
113
114 /* set up all urbs so they can be used with either bulk or interrupt */
115 #define INTERRUPT_RATE 1 /* msec/transfer */
116
117 #define ERROR(tdev, fmt, args...) \
118 dev_err(&(tdev)->intf->dev , fmt , ## args)
119 #define WARNING(tdev, fmt, args...) \
120 dev_warn(&(tdev)->intf->dev , fmt , ## args)
121
122 #define GUARD_BYTE 0xA5
123 #define MAX_SGLEN 128
124
125 /*-------------------------------------------------------------------------*/
126
127 static int
128 get_endpoints(struct usbtest_dev *dev, struct usb_interface *intf)
129 {
130 int tmp;
131 struct usb_host_interface *alt;
132 struct usb_host_endpoint *in, *out;
133 struct usb_host_endpoint *iso_in, *iso_out;
134 struct usb_host_endpoint *int_in, *int_out;
135 struct usb_device *udev;
136
137 for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
138 unsigned ep;
139
140 in = out = NULL;
141 iso_in = iso_out = NULL;
142 int_in = int_out = NULL;
143 alt = intf->altsetting + tmp;
144
145 if (override_alt >= 0 &&
146 override_alt != alt->desc.bAlternateSetting)
147 continue;
148
149 /* take the first altsetting with in-bulk + out-bulk;
150 * ignore other endpoints and altsettings.
151 */
152 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
153 struct usb_host_endpoint *e;
154
155 e = alt->endpoint + ep;
156 switch (usb_endpoint_type(&e->desc)) {
157 case USB_ENDPOINT_XFER_BULK:
158 break;
159 case USB_ENDPOINT_XFER_INT:
160 if (dev->info->intr)
161 goto try_intr;
162 continue;
163 case USB_ENDPOINT_XFER_ISOC:
164 if (dev->info->iso)
165 goto try_iso;
166 /* FALLTHROUGH */
167 default:
168 continue;
169 }
170 if (usb_endpoint_dir_in(&e->desc)) {
171 if (!in)
172 in = e;
173 } else {
174 if (!out)
175 out = e;
176 }
177 continue;
178 try_intr:
179 if (usb_endpoint_dir_in(&e->desc)) {
180 if (!int_in)
181 int_in = e;
182 } else {
183 if (!int_out)
184 int_out = e;
185 }
186 continue;
187 try_iso:
188 if (usb_endpoint_dir_in(&e->desc)) {
189 if (!iso_in)
190 iso_in = e;
191 } else {
192 if (!iso_out)
193 iso_out = e;
194 }
195 }
196 if ((in && out) || iso_in || iso_out || int_in || int_out)
197 goto found;
198 }
199 return -EINVAL;
200
201 found:
202 udev = testdev_to_usbdev(dev);
203 dev->info->alt = alt->desc.bAlternateSetting;
204 if (alt->desc.bAlternateSetting != 0) {
205 tmp = usb_set_interface(udev,
206 alt->desc.bInterfaceNumber,
207 alt->desc.bAlternateSetting);
208 if (tmp < 0)
209 return tmp;
210 }
211
212 if (in)
213 dev->in_pipe = usb_rcvbulkpipe(udev,
214 in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
215 if (out)
216 dev->out_pipe = usb_sndbulkpipe(udev,
217 out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
218
219 if (iso_in) {
220 dev->iso_in = &iso_in->desc;
221 dev->in_iso_pipe = usb_rcvisocpipe(udev,
222 iso_in->desc.bEndpointAddress
223 & USB_ENDPOINT_NUMBER_MASK);
224 }
225
226 if (iso_out) {
227 dev->iso_out = &iso_out->desc;
228 dev->out_iso_pipe = usb_sndisocpipe(udev,
229 iso_out->desc.bEndpointAddress
230 & USB_ENDPOINT_NUMBER_MASK);
231 }
232
233 if (int_in) {
234 dev->int_in = &int_in->desc;
235 dev->in_int_pipe = usb_rcvintpipe(udev,
236 int_in->desc.bEndpointAddress
237 & USB_ENDPOINT_NUMBER_MASK);
238 }
239
240 if (int_out) {
241 dev->int_out = &int_out->desc;
242 dev->out_int_pipe = usb_sndintpipe(udev,
243 int_out->desc.bEndpointAddress
244 & USB_ENDPOINT_NUMBER_MASK);
245 }
246 return 0;
247 }
248
249 /*-------------------------------------------------------------------------*/
250
251 /* Support for testing basic non-queued I/O streams.
252 *
253 * These just package urbs as requests that can be easily canceled.
254 * Each urb's data buffer is dynamically allocated; callers can fill
255 * them with non-zero test data (or test for it) when appropriate.
256 */
257
258 static void simple_callback(struct urb *urb)
259 {
260 complete(urb->context);
261 }
262
263 static struct urb *usbtest_alloc_urb(
264 struct usb_device *udev,
265 int pipe,
266 unsigned long bytes,
267 unsigned transfer_flags,
268 unsigned offset,
269 u8 bInterval,
270 usb_complete_t complete_fn)
271 {
272 struct urb *urb;
273
274 urb = usb_alloc_urb(0, GFP_KERNEL);
275 if (!urb)
276 return urb;
277
278 if (bInterval)
279 usb_fill_int_urb(urb, udev, pipe, NULL, bytes, complete_fn,
280 NULL, bInterval);
281 else
282 usb_fill_bulk_urb(urb, udev, pipe, NULL, bytes, complete_fn,
283 NULL);
284
285 urb->interval = (udev->speed == USB_SPEED_HIGH)
286 ? (INTERRUPT_RATE << 3)
287 : INTERRUPT_RATE;
288 urb->transfer_flags = transfer_flags;
289 if (usb_pipein(pipe))
290 urb->transfer_flags |= URB_SHORT_NOT_OK;
291
292 if ((bytes + offset) == 0)
293 return urb;
294
295 if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
296 urb->transfer_buffer = usb_alloc_coherent(udev, bytes + offset,
297 GFP_KERNEL, &urb->transfer_dma);
298 else
299 urb->transfer_buffer = kmalloc(bytes + offset, GFP_KERNEL);
300
301 if (!urb->transfer_buffer) {
302 usb_free_urb(urb);
303 return NULL;
304 }
305
306 /* To test unaligned transfers add an offset and fill the
307 unused memory with a guard value */
308 if (offset) {
309 memset(urb->transfer_buffer, GUARD_BYTE, offset);
310 urb->transfer_buffer += offset;
311 if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
312 urb->transfer_dma += offset;
313 }
314
315 /* For inbound transfers use guard byte so that test fails if
316 data not correctly copied */
317 memset(urb->transfer_buffer,
318 usb_pipein(urb->pipe) ? GUARD_BYTE : 0,
319 bytes);
320 return urb;
321 }
322
323 static struct urb *simple_alloc_urb(
324 struct usb_device *udev,
325 int pipe,
326 unsigned long bytes,
327 u8 bInterval)
328 {
329 return usbtest_alloc_urb(udev, pipe, bytes, URB_NO_TRANSFER_DMA_MAP, 0,
330 bInterval, simple_callback);
331 }
332
333 static struct urb *complicated_alloc_urb(
334 struct usb_device *udev,
335 int pipe,
336 unsigned long bytes,
337 u8 bInterval)
338 {
339 return usbtest_alloc_urb(udev, pipe, bytes, URB_NO_TRANSFER_DMA_MAP, 0,
340 bInterval, complicated_callback);
341 }
342
343 static unsigned pattern;
344 static unsigned mod_pattern;
345 module_param_named(pattern, mod_pattern, uint, S_IRUGO | S_IWUSR);
346 MODULE_PARM_DESC(mod_pattern, "i/o pattern (0 == zeroes)");
347
348 static unsigned get_maxpacket(struct usb_device *udev, int pipe)
349 {
350 struct usb_host_endpoint *ep;
351
352 ep = usb_pipe_endpoint(udev, pipe);
353 return le16_to_cpup(&ep->desc.wMaxPacketSize);
354 }
355
356 static void simple_fill_buf(struct urb *urb)
357 {
358 unsigned i;
359 u8 *buf = urb->transfer_buffer;
360 unsigned len = urb->transfer_buffer_length;
361 unsigned maxpacket;
362
363 switch (pattern) {
364 default:
365 /* FALLTHROUGH */
366 case 0:
367 memset(buf, 0, len);
368 break;
369 case 1: /* mod63 */
370 maxpacket = get_maxpacket(urb->dev, urb->pipe);
371 for (i = 0; i < len; i++)
372 *buf++ = (u8) ((i % maxpacket) % 63);
373 break;
374 }
375 }
376
377 static inline unsigned long buffer_offset(void *buf)
378 {
379 return (unsigned long)buf & (ARCH_KMALLOC_MINALIGN - 1);
380 }
381
382 static int check_guard_bytes(struct usbtest_dev *tdev, struct urb *urb)
383 {
384 u8 *buf = urb->transfer_buffer;
385 u8 *guard = buf - buffer_offset(buf);
386 unsigned i;
387
388 for (i = 0; guard < buf; i++, guard++) {
389 if (*guard != GUARD_BYTE) {
390 ERROR(tdev, "guard byte[%d] %d (not %d)\n",
391 i, *guard, GUARD_BYTE);
392 return -EINVAL;
393 }
394 }
395 return 0;
396 }
397
398 static int simple_check_buf(struct usbtest_dev *tdev, struct urb *urb)
399 {
400 unsigned i;
401 u8 expected;
402 u8 *buf = urb->transfer_buffer;
403 unsigned len = urb->actual_length;
404 unsigned maxpacket = get_maxpacket(urb->dev, urb->pipe);
405
406 int ret = check_guard_bytes(tdev, urb);
407 if (ret)
408 return ret;
409
410 for (i = 0; i < len; i++, buf++) {
411 switch (pattern) {
412 /* all-zeroes has no synchronization issues */
413 case 0:
414 expected = 0;
415 break;
416 /* mod63 stays in sync with short-terminated transfers,
417 * or otherwise when host and gadget agree on how large
418 * each usb transfer request should be. resync is done
419 * with set_interface or set_config.
420 */
421 case 1: /* mod63 */
422 expected = (i % maxpacket) % 63;
423 break;
424 /* always fail unsupported patterns */
425 default:
426 expected = !*buf;
427 break;
428 }
429 if (*buf == expected)
430 continue;
431 ERROR(tdev, "buf[%d] = %d (not %d)\n", i, *buf, expected);
432 return -EINVAL;
433 }
434 return 0;
435 }
436
437 static void simple_free_urb(struct urb *urb)
438 {
439 unsigned long offset = buffer_offset(urb->transfer_buffer);
440
441 if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
442 usb_free_coherent(
443 urb->dev,
444 urb->transfer_buffer_length + offset,
445 urb->transfer_buffer - offset,
446 urb->transfer_dma - offset);
447 else
448 kfree(urb->transfer_buffer - offset);
449 usb_free_urb(urb);
450 }
451
452 static int simple_io(
453 struct usbtest_dev *tdev,
454 struct urb *urb,
455 int iterations,
456 int vary,
457 int expected,
458 const char *label
459 )
460 {
461 struct usb_device *udev = urb->dev;
462 int max = urb->transfer_buffer_length;
463 struct completion completion;
464 int retval = 0;
465 unsigned long expire;
466
467 urb->context = &completion;
468 while (retval == 0 && iterations-- > 0) {
469 init_completion(&completion);
470 if (usb_pipeout(urb->pipe)) {
471 simple_fill_buf(urb);
472 urb->transfer_flags |= URB_ZERO_PACKET;
473 }
474 retval = usb_submit_urb(urb, GFP_KERNEL);
475 if (retval != 0)
476 break;
477
478 expire = msecs_to_jiffies(SIMPLE_IO_TIMEOUT);
479 if (!wait_for_completion_timeout(&completion, expire)) {
480 usb_kill_urb(urb);
481 retval = (urb->status == -ENOENT ?
482 -ETIMEDOUT : urb->status);
483 } else {
484 retval = urb->status;
485 }
486
487 urb->dev = udev;
488 if (retval == 0 && usb_pipein(urb->pipe))
489 retval = simple_check_buf(tdev, urb);
490
491 if (vary) {
492 int len = urb->transfer_buffer_length;
493
494 len += vary;
495 len %= max;
496 if (len == 0)
497 len = (vary < max) ? vary : max;
498 urb->transfer_buffer_length = len;
499 }
500
501 /* FIXME if endpoint halted, clear halt (and log) */
502 }
503 urb->transfer_buffer_length = max;
504
505 if (expected != retval)
506 dev_err(&udev->dev,
507 "%s failed, iterations left %d, status %d (not %d)\n",
508 label, iterations, retval, expected);
509 return retval;
510 }
511
512
513 /*-------------------------------------------------------------------------*/
514
515 /* We use scatterlist primitives to test queued I/O.
516 * Yes, this also tests the scatterlist primitives.
517 */
518
519 static void free_sglist(struct scatterlist *sg, int nents)
520 {
521 unsigned i;
522
523 if (!sg)
524 return;
525 for (i = 0; i < nents; i++) {
526 if (!sg_page(&sg[i]))
527 continue;
528 kfree(sg_virt(&sg[i]));
529 }
530 kfree(sg);
531 }
532
533 static struct scatterlist *
534 alloc_sglist(int nents, int max, int vary, struct usbtest_dev *dev, int pipe)
535 {
536 struct scatterlist *sg;
537 unsigned int n_size = 0;
538 unsigned i;
539 unsigned size = max;
540 unsigned maxpacket =
541 get_maxpacket(interface_to_usbdev(dev->intf), pipe);
542
543 if (max == 0)
544 return NULL;
545
546 sg = kmalloc_array(nents, sizeof(*sg), GFP_KERNEL);
547 if (!sg)
548 return NULL;
549 sg_init_table(sg, nents);
550
551 for (i = 0; i < nents; i++) {
552 char *buf;
553 unsigned j;
554
555 buf = kzalloc(size, GFP_KERNEL);
556 if (!buf) {
557 free_sglist(sg, i);
558 return NULL;
559 }
560
561 /* kmalloc pages are always physically contiguous! */
562 sg_set_buf(&sg[i], buf, size);
563
564 switch (pattern) {
565 case 0:
566 /* already zeroed */
567 break;
568 case 1:
569 for (j = 0; j < size; j++)
570 *buf++ = (u8) (((j + n_size) % maxpacket) % 63);
571 n_size += size;
572 break;
573 }
574
575 if (vary) {
576 size += vary;
577 size %= max;
578 if (size == 0)
579 size = (vary < max) ? vary : max;
580 }
581 }
582
583 return sg;
584 }
585
586 static void sg_timeout(unsigned long _req)
587 {
588 struct usb_sg_request *req = (struct usb_sg_request *) _req;
589
590 usb_sg_cancel(req);
591 }
592
593 static int perform_sglist(
594 struct usbtest_dev *tdev,
595 unsigned iterations,
596 int pipe,
597 struct usb_sg_request *req,
598 struct scatterlist *sg,
599 int nents
600 )
601 {
602 struct usb_device *udev = testdev_to_usbdev(tdev);
603 int retval = 0;
604 struct timer_list sg_timer;
605
606 setup_timer_on_stack(&sg_timer, sg_timeout, (unsigned long) req);
607
608 while (retval == 0 && iterations-- > 0) {
609 retval = usb_sg_init(req, udev, pipe,
610 (udev->speed == USB_SPEED_HIGH)
611 ? (INTERRUPT_RATE << 3)
612 : INTERRUPT_RATE,
613 sg, nents, 0, GFP_KERNEL);
614
615 if (retval)
616 break;
617 mod_timer(&sg_timer, jiffies +
618 msecs_to_jiffies(SIMPLE_IO_TIMEOUT));
619 usb_sg_wait(req);
620 if (!del_timer_sync(&sg_timer))
621 retval = -ETIMEDOUT;
622 else
623 retval = req->status;
624
625 /* FIXME check resulting data pattern */
626
627 /* FIXME if endpoint halted, clear halt (and log) */
628 }
629
630 /* FIXME for unlink or fault handling tests, don't report
631 * failure if retval is as we expected ...
632 */
633 if (retval)
634 ERROR(tdev, "perform_sglist failed, "
635 "iterations left %d, status %d\n",
636 iterations, retval);
637 return retval;
638 }
639
640
641 /*-------------------------------------------------------------------------*/
642
643 /* unqueued control message testing
644 *
645 * there's a nice set of device functional requirements in chapter 9 of the
646 * usb 2.0 spec, which we can apply to ANY device, even ones that don't use
647 * special test firmware.
648 *
649 * we know the device is configured (or suspended) by the time it's visible
650 * through usbfs. we can't change that, so we won't test enumeration (which
651 * worked 'well enough' to get here, this time), power management (ditto),
652 * or remote wakeup (which needs human interaction).
653 */
654
655 static unsigned realworld = 1;
656 module_param(realworld, uint, 0);
657 MODULE_PARM_DESC(realworld, "clear to demand stricter spec compliance");
658
659 static int get_altsetting(struct usbtest_dev *dev)
660 {
661 struct usb_interface *iface = dev->intf;
662 struct usb_device *udev = interface_to_usbdev(iface);
663 int retval;
664
665 retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
666 USB_REQ_GET_INTERFACE, USB_DIR_IN|USB_RECIP_INTERFACE,
667 0, iface->altsetting[0].desc.bInterfaceNumber,
668 dev->buf, 1, USB_CTRL_GET_TIMEOUT);
669 switch (retval) {
670 case 1:
671 return dev->buf[0];
672 case 0:
673 retval = -ERANGE;
674 /* FALLTHROUGH */
675 default:
676 return retval;
677 }
678 }
679
680 static int set_altsetting(struct usbtest_dev *dev, int alternate)
681 {
682 struct usb_interface *iface = dev->intf;
683 struct usb_device *udev;
684
685 if (alternate < 0 || alternate >= 256)
686 return -EINVAL;
687
688 udev = interface_to_usbdev(iface);
689 return usb_set_interface(udev,
690 iface->altsetting[0].desc.bInterfaceNumber,
691 alternate);
692 }
693
694 static int is_good_config(struct usbtest_dev *tdev, int len)
695 {
696 struct usb_config_descriptor *config;
697
698 if (len < sizeof(*config))
699 return 0;
700 config = (struct usb_config_descriptor *) tdev->buf;
701
702 switch (config->bDescriptorType) {
703 case USB_DT_CONFIG:
704 case USB_DT_OTHER_SPEED_CONFIG:
705 if (config->bLength != 9) {
706 ERROR(tdev, "bogus config descriptor length\n");
707 return 0;
708 }
709 /* this bit 'must be 1' but often isn't */
710 if (!realworld && !(config->bmAttributes & 0x80)) {
711 ERROR(tdev, "high bit of config attributes not set\n");
712 return 0;
713 }
714 if (config->bmAttributes & 0x1f) { /* reserved == 0 */
715 ERROR(tdev, "reserved config bits set\n");
716 return 0;
717 }
718 break;
719 default:
720 return 0;
721 }
722
723 if (le16_to_cpu(config->wTotalLength) == len) /* read it all */
724 return 1;
725 if (le16_to_cpu(config->wTotalLength) >= TBUF_SIZE) /* max partial read */
726 return 1;
727 ERROR(tdev, "bogus config descriptor read size\n");
728 return 0;
729 }
730
731 static int is_good_ext(struct usbtest_dev *tdev, u8 *buf)
732 {
733 struct usb_ext_cap_descriptor *ext;
734 u32 attr;
735
736 ext = (struct usb_ext_cap_descriptor *) buf;
737
738 if (ext->bLength != USB_DT_USB_EXT_CAP_SIZE) {
739 ERROR(tdev, "bogus usb 2.0 extension descriptor length\n");
740 return 0;
741 }
742
743 attr = le32_to_cpu(ext->bmAttributes);
744 /* bits[1:15] is used and others are reserved */
745 if (attr & ~0xfffe) { /* reserved == 0 */
746 ERROR(tdev, "reserved bits set\n");
747 return 0;
748 }
749
750 return 1;
751 }
752
753 static int is_good_ss_cap(struct usbtest_dev *tdev, u8 *buf)
754 {
755 struct usb_ss_cap_descriptor *ss;
756
757 ss = (struct usb_ss_cap_descriptor *) buf;
758
759 if (ss->bLength != USB_DT_USB_SS_CAP_SIZE) {
760 ERROR(tdev, "bogus superspeed device capability descriptor length\n");
761 return 0;
762 }
763
764 /*
765 * only bit[1] of bmAttributes is used for LTM and others are
766 * reserved
767 */
768 if (ss->bmAttributes & ~0x02) { /* reserved == 0 */
769 ERROR(tdev, "reserved bits set in bmAttributes\n");
770 return 0;
771 }
772
773 /* bits[0:3] of wSpeedSupported is used and others are reserved */
774 if (le16_to_cpu(ss->wSpeedSupported) & ~0x0f) { /* reserved == 0 */
775 ERROR(tdev, "reserved bits set in wSpeedSupported\n");
776 return 0;
777 }
778
779 return 1;
780 }
781
782 static int is_good_con_id(struct usbtest_dev *tdev, u8 *buf)
783 {
784 struct usb_ss_container_id_descriptor *con_id;
785
786 con_id = (struct usb_ss_container_id_descriptor *) buf;
787
788 if (con_id->bLength != USB_DT_USB_SS_CONTN_ID_SIZE) {
789 ERROR(tdev, "bogus container id descriptor length\n");
790 return 0;
791 }
792
793 if (con_id->bReserved) { /* reserved == 0 */
794 ERROR(tdev, "reserved bits set\n");
795 return 0;
796 }
797
798 return 1;
799 }
800
801 /* sanity test for standard requests working with usb_control_mesg() and some
802 * of the utility functions which use it.
803 *
804 * this doesn't test how endpoint halts behave or data toggles get set, since
805 * we won't do I/O to bulk/interrupt endpoints here (which is how to change
806 * halt or toggle). toggle testing is impractical without support from hcds.
807 *
808 * this avoids failing devices linux would normally work with, by not testing
809 * config/altsetting operations for devices that only support their defaults.
810 * such devices rarely support those needless operations.
811 *
812 * NOTE that since this is a sanity test, it's not examining boundary cases
813 * to see if usbcore, hcd, and device all behave right. such testing would
814 * involve varied read sizes and other operation sequences.
815 */
816 static int ch9_postconfig(struct usbtest_dev *dev)
817 {
818 struct usb_interface *iface = dev->intf;
819 struct usb_device *udev = interface_to_usbdev(iface);
820 int i, alt, retval;
821
822 /* [9.2.3] if there's more than one altsetting, we need to be able to
823 * set and get each one. mostly trusts the descriptors from usbcore.
824 */
825 for (i = 0; i < iface->num_altsetting; i++) {
826
827 /* 9.2.3 constrains the range here */
828 alt = iface->altsetting[i].desc.bAlternateSetting;
829 if (alt < 0 || alt >= iface->num_altsetting) {
830 dev_err(&iface->dev,
831 "invalid alt [%d].bAltSetting = %d\n",
832 i, alt);
833 }
834
835 /* [real world] get/set unimplemented if there's only one */
836 if (realworld && iface->num_altsetting == 1)
837 continue;
838
839 /* [9.4.10] set_interface */
840 retval = set_altsetting(dev, alt);
841 if (retval) {
842 dev_err(&iface->dev, "can't set_interface = %d, %d\n",
843 alt, retval);
844 return retval;
845 }
846
847 /* [9.4.4] get_interface always works */
848 retval = get_altsetting(dev);
849 if (retval != alt) {
850 dev_err(&iface->dev, "get alt should be %d, was %d\n",
851 alt, retval);
852 return (retval < 0) ? retval : -EDOM;
853 }
854
855 }
856
857 /* [real world] get_config unimplemented if there's only one */
858 if (!realworld || udev->descriptor.bNumConfigurations != 1) {
859 int expected = udev->actconfig->desc.bConfigurationValue;
860
861 /* [9.4.2] get_configuration always works
862 * ... although some cheap devices (like one TI Hub I've got)
863 * won't return config descriptors except before set_config.
864 */
865 retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
866 USB_REQ_GET_CONFIGURATION,
867 USB_DIR_IN | USB_RECIP_DEVICE,
868 0, 0, dev->buf, 1, USB_CTRL_GET_TIMEOUT);
869 if (retval != 1 || dev->buf[0] != expected) {
870 dev_err(&iface->dev, "get config --> %d %d (1 %d)\n",
871 retval, dev->buf[0], expected);
872 return (retval < 0) ? retval : -EDOM;
873 }
874 }
875
876 /* there's always [9.4.3] a device descriptor [9.6.1] */
877 retval = usb_get_descriptor(udev, USB_DT_DEVICE, 0,
878 dev->buf, sizeof(udev->descriptor));
879 if (retval != sizeof(udev->descriptor)) {
880 dev_err(&iface->dev, "dev descriptor --> %d\n", retval);
881 return (retval < 0) ? retval : -EDOM;
882 }
883
884 /*
885 * there's always [9.4.3] a bos device descriptor [9.6.2] in USB
886 * 3.0 spec
887 */
888 if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0210) {
889 struct usb_bos_descriptor *bos = NULL;
890 struct usb_dev_cap_header *header = NULL;
891 unsigned total, num, length;
892 u8 *buf;
893
894 retval = usb_get_descriptor(udev, USB_DT_BOS, 0, dev->buf,
895 sizeof(*udev->bos->desc));
896 if (retval != sizeof(*udev->bos->desc)) {
897 dev_err(&iface->dev, "bos descriptor --> %d\n", retval);
898 return (retval < 0) ? retval : -EDOM;
899 }
900
901 bos = (struct usb_bos_descriptor *)dev->buf;
902 total = le16_to_cpu(bos->wTotalLength);
903 num = bos->bNumDeviceCaps;
904
905 if (total > TBUF_SIZE)
906 total = TBUF_SIZE;
907
908 /*
909 * get generic device-level capability descriptors [9.6.2]
910 * in USB 3.0 spec
911 */
912 retval = usb_get_descriptor(udev, USB_DT_BOS, 0, dev->buf,
913 total);
914 if (retval != total) {
915 dev_err(&iface->dev, "bos descriptor set --> %d\n",
916 retval);
917 return (retval < 0) ? retval : -EDOM;
918 }
919
920 length = sizeof(*udev->bos->desc);
921 buf = dev->buf;
922 for (i = 0; i < num; i++) {
923 buf += length;
924 if (buf + sizeof(struct usb_dev_cap_header) >
925 dev->buf + total)
926 break;
927
928 header = (struct usb_dev_cap_header *)buf;
929 length = header->bLength;
930
931 if (header->bDescriptorType !=
932 USB_DT_DEVICE_CAPABILITY) {
933 dev_warn(&udev->dev, "not device capability descriptor, skip\n");
934 continue;
935 }
936
937 switch (header->bDevCapabilityType) {
938 case USB_CAP_TYPE_EXT:
939 if (buf + USB_DT_USB_EXT_CAP_SIZE >
940 dev->buf + total ||
941 !is_good_ext(dev, buf)) {
942 dev_err(&iface->dev, "bogus usb 2.0 extension descriptor\n");
943 return -EDOM;
944 }
945 break;
946 case USB_SS_CAP_TYPE:
947 if (buf + USB_DT_USB_SS_CAP_SIZE >
948 dev->buf + total ||
949 !is_good_ss_cap(dev, buf)) {
950 dev_err(&iface->dev, "bogus superspeed device capability descriptor\n");
951 return -EDOM;
952 }
953 break;
954 case CONTAINER_ID_TYPE:
955 if (buf + USB_DT_USB_SS_CONTN_ID_SIZE >
956 dev->buf + total ||
957 !is_good_con_id(dev, buf)) {
958 dev_err(&iface->dev, "bogus container id descriptor\n");
959 return -EDOM;
960 }
961 break;
962 default:
963 break;
964 }
965 }
966 }
967
968 /* there's always [9.4.3] at least one config descriptor [9.6.3] */
969 for (i = 0; i < udev->descriptor.bNumConfigurations; i++) {
970 retval = usb_get_descriptor(udev, USB_DT_CONFIG, i,
971 dev->buf, TBUF_SIZE);
972 if (!is_good_config(dev, retval)) {
973 dev_err(&iface->dev,
974 "config [%d] descriptor --> %d\n",
975 i, retval);
976 return (retval < 0) ? retval : -EDOM;
977 }
978
979 /* FIXME cross-checking udev->config[i] to make sure usbcore
980 * parsed it right (etc) would be good testing paranoia
981 */
982 }
983
984 /* and sometimes [9.2.6.6] speed dependent descriptors */
985 if (le16_to_cpu(udev->descriptor.bcdUSB) == 0x0200) {
986 struct usb_qualifier_descriptor *d = NULL;
987
988 /* device qualifier [9.6.2] */
989 retval = usb_get_descriptor(udev,
990 USB_DT_DEVICE_QUALIFIER, 0, dev->buf,
991 sizeof(struct usb_qualifier_descriptor));
992 if (retval == -EPIPE) {
993 if (udev->speed == USB_SPEED_HIGH) {
994 dev_err(&iface->dev,
995 "hs dev qualifier --> %d\n",
996 retval);
997 return (retval < 0) ? retval : -EDOM;
998 }
999 /* usb2.0 but not high-speed capable; fine */
1000 } else if (retval != sizeof(struct usb_qualifier_descriptor)) {
1001 dev_err(&iface->dev, "dev qualifier --> %d\n", retval);
1002 return (retval < 0) ? retval : -EDOM;
1003 } else
1004 d = (struct usb_qualifier_descriptor *) dev->buf;
1005
1006 /* might not have [9.6.2] any other-speed configs [9.6.4] */
1007 if (d) {
1008 unsigned max = d->bNumConfigurations;
1009 for (i = 0; i < max; i++) {
1010 retval = usb_get_descriptor(udev,
1011 USB_DT_OTHER_SPEED_CONFIG, i,
1012 dev->buf, TBUF_SIZE);
1013 if (!is_good_config(dev, retval)) {
1014 dev_err(&iface->dev,
1015 "other speed config --> %d\n",
1016 retval);
1017 return (retval < 0) ? retval : -EDOM;
1018 }
1019 }
1020 }
1021 }
1022 /* FIXME fetch strings from at least the device descriptor */
1023
1024 /* [9.4.5] get_status always works */
1025 retval = usb_get_status(udev, USB_RECIP_DEVICE, 0, dev->buf);
1026 if (retval) {
1027 dev_err(&iface->dev, "get dev status --> %d\n", retval);
1028 return retval;
1029 }
1030
1031 /* FIXME configuration.bmAttributes says if we could try to set/clear
1032 * the device's remote wakeup feature ... if we can, test that here
1033 */
1034
1035 retval = usb_get_status(udev, USB_RECIP_INTERFACE,
1036 iface->altsetting[0].desc.bInterfaceNumber, dev->buf);
1037 if (retval) {
1038 dev_err(&iface->dev, "get interface status --> %d\n", retval);
1039 return retval;
1040 }
1041 /* FIXME get status for each endpoint in the interface */
1042
1043 return 0;
1044 }
1045
1046 /*-------------------------------------------------------------------------*/
1047
1048 /* use ch9 requests to test whether:
1049 * (a) queues work for control, keeping N subtests queued and
1050 * active (auto-resubmit) for M loops through the queue.
1051 * (b) protocol stalls (control-only) will autorecover.
1052 * it's not like bulk/intr; no halt clearing.
1053 * (c) short control reads are reported and handled.
1054 * (d) queues are always processed in-order
1055 */
1056
1057 struct ctrl_ctx {
1058 spinlock_t lock;
1059 struct usbtest_dev *dev;
1060 struct completion complete;
1061 unsigned count;
1062 unsigned pending;
1063 int status;
1064 struct urb **urb;
1065 struct usbtest_param_32 *param;
1066 int last;
1067 };
1068
1069 #define NUM_SUBCASES 16 /* how many test subcases here? */
1070
1071 struct subcase {
1072 struct usb_ctrlrequest setup;
1073 int number;
1074 int expected;
1075 };
1076
1077 static void ctrl_complete(struct urb *urb)
1078 {
1079 struct ctrl_ctx *ctx = urb->context;
1080 struct usb_ctrlrequest *reqp;
1081 struct subcase *subcase;
1082 int status = urb->status;
1083
1084 reqp = (struct usb_ctrlrequest *)urb->setup_packet;
1085 subcase = container_of(reqp, struct subcase, setup);
1086
1087 spin_lock(&ctx->lock);
1088 ctx->count--;
1089 ctx->pending--;
1090
1091 /* queue must transfer and complete in fifo order, unless
1092 * usb_unlink_urb() is used to unlink something not at the
1093 * physical queue head (not tested).
1094 */
1095 if (subcase->number > 0) {
1096 if ((subcase->number - ctx->last) != 1) {
1097 ERROR(ctx->dev,
1098 "subcase %d completed out of order, last %d\n",
1099 subcase->number, ctx->last);
1100 status = -EDOM;
1101 ctx->last = subcase->number;
1102 goto error;
1103 }
1104 }
1105 ctx->last = subcase->number;
1106
1107 /* succeed or fault in only one way? */
1108 if (status == subcase->expected)
1109 status = 0;
1110
1111 /* async unlink for cleanup? */
1112 else if (status != -ECONNRESET) {
1113
1114 /* some faults are allowed, not required */
1115 if (subcase->expected > 0 && (
1116 ((status == -subcase->expected /* happened */
1117 || status == 0)))) /* didn't */
1118 status = 0;
1119 /* sometimes more than one fault is allowed */
1120 else if (subcase->number == 12 && status == -EPIPE)
1121 status = 0;
1122 else
1123 ERROR(ctx->dev, "subtest %d error, status %d\n",
1124 subcase->number, status);
1125 }
1126
1127 /* unexpected status codes mean errors; ideally, in hardware */
1128 if (status) {
1129 error:
1130 if (ctx->status == 0) {
1131 int i;
1132
1133 ctx->status = status;
1134 ERROR(ctx->dev, "control queue %02x.%02x, err %d, "
1135 "%d left, subcase %d, len %d/%d\n",
1136 reqp->bRequestType, reqp->bRequest,
1137 status, ctx->count, subcase->number,
1138 urb->actual_length,
1139 urb->transfer_buffer_length);
1140
1141 /* FIXME this "unlink everything" exit route should
1142 * be a separate test case.
1143 */
1144
1145 /* unlink whatever's still pending */
1146 for (i = 1; i < ctx->param->sglen; i++) {
1147 struct urb *u = ctx->urb[
1148 (i + subcase->number)
1149 % ctx->param->sglen];
1150
1151 if (u == urb || !u->dev)
1152 continue;
1153 spin_unlock(&ctx->lock);
1154 status = usb_unlink_urb(u);
1155 spin_lock(&ctx->lock);
1156 switch (status) {
1157 case -EINPROGRESS:
1158 case -EBUSY:
1159 case -EIDRM:
1160 continue;
1161 default:
1162 ERROR(ctx->dev, "urb unlink --> %d\n",
1163 status);
1164 }
1165 }
1166 status = ctx->status;
1167 }
1168 }
1169
1170 /* resubmit if we need to, else mark this as done */
1171 if ((status == 0) && (ctx->pending < ctx->count)) {
1172 status = usb_submit_urb(urb, GFP_ATOMIC);
1173 if (status != 0) {
1174 ERROR(ctx->dev,
1175 "can't resubmit ctrl %02x.%02x, err %d\n",
1176 reqp->bRequestType, reqp->bRequest, status);
1177 urb->dev = NULL;
1178 } else
1179 ctx->pending++;
1180 } else
1181 urb->dev = NULL;
1182
1183 /* signal completion when nothing's queued */
1184 if (ctx->pending == 0)
1185 complete(&ctx->complete);
1186 spin_unlock(&ctx->lock);
1187 }
1188
1189 static int
1190 test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param_32 *param)
1191 {
1192 struct usb_device *udev = testdev_to_usbdev(dev);
1193 struct urb **urb;
1194 struct ctrl_ctx context;
1195 int i;
1196
1197 if (param->sglen == 0 || param->iterations > UINT_MAX / param->sglen)
1198 return -EOPNOTSUPP;
1199
1200 spin_lock_init(&context.lock);
1201 context.dev = dev;
1202 init_completion(&context.complete);
1203 context.count = param->sglen * param->iterations;
1204 context.pending = 0;
1205 context.status = -ENOMEM;
1206 context.param = param;
1207 context.last = -1;
1208
1209 /* allocate and init the urbs we'll queue.
1210 * as with bulk/intr sglists, sglen is the queue depth; it also
1211 * controls which subtests run (more tests than sglen) or rerun.
1212 */
1213 urb = kcalloc(param->sglen, sizeof(struct urb *), GFP_KERNEL);
1214 if (!urb)
1215 return -ENOMEM;
1216 for (i = 0; i < param->sglen; i++) {
1217 int pipe = usb_rcvctrlpipe(udev, 0);
1218 unsigned len;
1219 struct urb *u;
1220 struct usb_ctrlrequest req;
1221 struct subcase *reqp;
1222
1223 /* sign of this variable means:
1224 * -: tested code must return this (negative) error code
1225 * +: tested code may return this (negative too) error code
1226 */
1227 int expected = 0;
1228
1229 /* requests here are mostly expected to succeed on any
1230 * device, but some are chosen to trigger protocol stalls
1231 * or short reads.
1232 */
1233 memset(&req, 0, sizeof(req));
1234 req.bRequest = USB_REQ_GET_DESCRIPTOR;
1235 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
1236
1237 switch (i % NUM_SUBCASES) {
1238 case 0: /* get device descriptor */
1239 req.wValue = cpu_to_le16(USB_DT_DEVICE << 8);
1240 len = sizeof(struct usb_device_descriptor);
1241 break;
1242 case 1: /* get first config descriptor (only) */
1243 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
1244 len = sizeof(struct usb_config_descriptor);
1245 break;
1246 case 2: /* get altsetting (OFTEN STALLS) */
1247 req.bRequest = USB_REQ_GET_INTERFACE;
1248 req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
1249 /* index = 0 means first interface */
1250 len = 1;
1251 expected = EPIPE;
1252 break;
1253 case 3: /* get interface status */
1254 req.bRequest = USB_REQ_GET_STATUS;
1255 req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
1256 /* interface 0 */
1257 len = 2;
1258 break;
1259 case 4: /* get device status */
1260 req.bRequest = USB_REQ_GET_STATUS;
1261 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
1262 len = 2;
1263 break;
1264 case 5: /* get device qualifier (MAY STALL) */
1265 req.wValue = cpu_to_le16 (USB_DT_DEVICE_QUALIFIER << 8);
1266 len = sizeof(struct usb_qualifier_descriptor);
1267 if (udev->speed != USB_SPEED_HIGH)
1268 expected = EPIPE;
1269 break;
1270 case 6: /* get first config descriptor, plus interface */
1271 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
1272 len = sizeof(struct usb_config_descriptor);
1273 len += sizeof(struct usb_interface_descriptor);
1274 break;
1275 case 7: /* get interface descriptor (ALWAYS STALLS) */
1276 req.wValue = cpu_to_le16 (USB_DT_INTERFACE << 8);
1277 /* interface == 0 */
1278 len = sizeof(struct usb_interface_descriptor);
1279 expected = -EPIPE;
1280 break;
1281 /* NOTE: two consecutive stalls in the queue here.
1282 * that tests fault recovery a bit more aggressively. */
1283 case 8: /* clear endpoint halt (MAY STALL) */
1284 req.bRequest = USB_REQ_CLEAR_FEATURE;
1285 req.bRequestType = USB_RECIP_ENDPOINT;
1286 /* wValue 0 == ep halt */
1287 /* wIndex 0 == ep0 (shouldn't halt!) */
1288 len = 0;
1289 pipe = usb_sndctrlpipe(udev, 0);
1290 expected = EPIPE;
1291 break;
1292 case 9: /* get endpoint status */
1293 req.bRequest = USB_REQ_GET_STATUS;
1294 req.bRequestType = USB_DIR_IN|USB_RECIP_ENDPOINT;
1295 /* endpoint 0 */
1296 len = 2;
1297 break;
1298 case 10: /* trigger short read (EREMOTEIO) */
1299 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
1300 len = 1024;
1301 expected = -EREMOTEIO;
1302 break;
1303 /* NOTE: two consecutive _different_ faults in the queue. */
1304 case 11: /* get endpoint descriptor (ALWAYS STALLS) */
1305 req.wValue = cpu_to_le16(USB_DT_ENDPOINT << 8);
1306 /* endpoint == 0 */
1307 len = sizeof(struct usb_interface_descriptor);
1308 expected = EPIPE;
1309 break;
1310 /* NOTE: sometimes even a third fault in the queue! */
1311 case 12: /* get string 0 descriptor (MAY STALL) */
1312 req.wValue = cpu_to_le16(USB_DT_STRING << 8);
1313 /* string == 0, for language IDs */
1314 len = sizeof(struct usb_interface_descriptor);
1315 /* may succeed when > 4 languages */
1316 expected = EREMOTEIO; /* or EPIPE, if no strings */
1317 break;
1318 case 13: /* short read, resembling case 10 */
1319 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
1320 /* last data packet "should" be DATA1, not DATA0 */
1321 if (udev->speed == USB_SPEED_SUPER)
1322 len = 1024 - 512;
1323 else
1324 len = 1024 - udev->descriptor.bMaxPacketSize0;
1325 expected = -EREMOTEIO;
1326 break;
1327 case 14: /* short read; try to fill the last packet */
1328 req.wValue = cpu_to_le16((USB_DT_DEVICE << 8) | 0);
1329 /* device descriptor size == 18 bytes */
1330 len = udev->descriptor.bMaxPacketSize0;
1331 if (udev->speed == USB_SPEED_SUPER)
1332 len = 512;
1333 switch (len) {
1334 case 8:
1335 len = 24;
1336 break;
1337 case 16:
1338 len = 32;
1339 break;
1340 }
1341 expected = -EREMOTEIO;
1342 break;
1343 case 15:
1344 req.wValue = cpu_to_le16(USB_DT_BOS << 8);
1345 if (udev->bos)
1346 len = le16_to_cpu(udev->bos->desc->wTotalLength);
1347 else
1348 len = sizeof(struct usb_bos_descriptor);
1349 if (le16_to_cpu(udev->descriptor.bcdUSB) < 0x0201)
1350 expected = -EPIPE;
1351 break;
1352 default:
1353 ERROR(dev, "bogus number of ctrl queue testcases!\n");
1354 context.status = -EINVAL;
1355 goto cleanup;
1356 }
1357 req.wLength = cpu_to_le16(len);
1358 urb[i] = u = simple_alloc_urb(udev, pipe, len, 0);
1359 if (!u)
1360 goto cleanup;
1361
1362 reqp = kmalloc(sizeof(*reqp), GFP_KERNEL);
1363 if (!reqp)
1364 goto cleanup;
1365 reqp->setup = req;
1366 reqp->number = i % NUM_SUBCASES;
1367 reqp->expected = expected;
1368 u->setup_packet = (char *) &reqp->setup;
1369
1370 u->context = &context;
1371 u->complete = ctrl_complete;
1372 }
1373
1374 /* queue the urbs */
1375 context.urb = urb;
1376 spin_lock_irq(&context.lock);
1377 for (i = 0; i < param->sglen; i++) {
1378 context.status = usb_submit_urb(urb[i], GFP_ATOMIC);
1379 if (context.status != 0) {
1380 ERROR(dev, "can't submit urb[%d], status %d\n",
1381 i, context.status);
1382 context.count = context.pending;
1383 break;
1384 }
1385 context.pending++;
1386 }
1387 spin_unlock_irq(&context.lock);
1388
1389 /* FIXME set timer and time out; provide a disconnect hook */
1390
1391 /* wait for the last one to complete */
1392 if (context.pending > 0)
1393 wait_for_completion(&context.complete);
1394
1395 cleanup:
1396 for (i = 0; i < param->sglen; i++) {
1397 if (!urb[i])
1398 continue;
1399 urb[i]->dev = udev;
1400 kfree(urb[i]->setup_packet);
1401 simple_free_urb(urb[i]);
1402 }
1403 kfree(urb);
1404 return context.status;
1405 }
1406 #undef NUM_SUBCASES
1407
1408
1409 /*-------------------------------------------------------------------------*/
1410
1411 static void unlink1_callback(struct urb *urb)
1412 {
1413 int status = urb->status;
1414
1415 /* we "know" -EPIPE (stall) never happens */
1416 if (!status)
1417 status = usb_submit_urb(urb, GFP_ATOMIC);
1418 if (status) {
1419 urb->status = status;
1420 complete(urb->context);
1421 }
1422 }
1423
1424 static int unlink1(struct usbtest_dev *dev, int pipe, int size, int async)
1425 {
1426 struct urb *urb;
1427 struct completion completion;
1428 int retval = 0;
1429
1430 init_completion(&completion);
1431 urb = simple_alloc_urb(testdev_to_usbdev(dev), pipe, size, 0);
1432 if (!urb)
1433 return -ENOMEM;
1434 urb->context = &completion;
1435 urb->complete = unlink1_callback;
1436
1437 if (usb_pipeout(urb->pipe)) {
1438 simple_fill_buf(urb);
1439 urb->transfer_flags |= URB_ZERO_PACKET;
1440 }
1441
1442 /* keep the endpoint busy. there are lots of hc/hcd-internal
1443 * states, and testing should get to all of them over time.
1444 *
1445 * FIXME want additional tests for when endpoint is STALLing
1446 * due to errors, or is just NAKing requests.
1447 */
1448 retval = usb_submit_urb(urb, GFP_KERNEL);
1449 if (retval != 0) {
1450 dev_err(&dev->intf->dev, "submit fail %d\n", retval);
1451 return retval;
1452 }
1453
1454 /* unlinking that should always work. variable delay tests more
1455 * hcd states and code paths, even with little other system load.
1456 */
1457 msleep(jiffies % (2 * INTERRUPT_RATE));
1458 if (async) {
1459 while (!completion_done(&completion)) {
1460 retval = usb_unlink_urb(urb);
1461
1462 if (retval == 0 && usb_pipein(urb->pipe))
1463 retval = simple_check_buf(dev, urb);
1464
1465 switch (retval) {
1466 case -EBUSY:
1467 case -EIDRM:
1468 /* we can't unlink urbs while they're completing
1469 * or if they've completed, and we haven't
1470 * resubmitted. "normal" drivers would prevent
1471 * resubmission, but since we're testing unlink
1472 * paths, we can't.
1473 */
1474 ERROR(dev, "unlink retry\n");
1475 continue;
1476 case 0:
1477 case -EINPROGRESS:
1478 break;
1479
1480 default:
1481 dev_err(&dev->intf->dev,
1482 "unlink fail %d\n", retval);
1483 return retval;
1484 }
1485
1486 break;
1487 }
1488 } else
1489 usb_kill_urb(urb);
1490
1491 wait_for_completion(&completion);
1492 retval = urb->status;
1493 simple_free_urb(urb);
1494
1495 if (async)
1496 return (retval == -ECONNRESET) ? 0 : retval - 1000;
1497 else
1498 return (retval == -ENOENT || retval == -EPERM) ?
1499 0 : retval - 2000;
1500 }
1501
1502 static int unlink_simple(struct usbtest_dev *dev, int pipe, int len)
1503 {
1504 int retval = 0;
1505
1506 /* test sync and async paths */
1507 retval = unlink1(dev, pipe, len, 1);
1508 if (!retval)
1509 retval = unlink1(dev, pipe, len, 0);
1510 return retval;
1511 }
1512
1513 /*-------------------------------------------------------------------------*/
1514
1515 struct queued_ctx {
1516 struct completion complete;
1517 atomic_t pending;
1518 unsigned num;
1519 int status;
1520 struct urb **urbs;
1521 };
1522
1523 static void unlink_queued_callback(struct urb *urb)
1524 {
1525 int status = urb->status;
1526 struct queued_ctx *ctx = urb->context;
1527
1528 if (ctx->status)
1529 goto done;
1530 if (urb == ctx->urbs[ctx->num - 4] || urb == ctx->urbs[ctx->num - 2]) {
1531 if (status == -ECONNRESET)
1532 goto done;
1533 /* What error should we report if the URB completed normally? */
1534 }
1535 if (status != 0)
1536 ctx->status = status;
1537
1538 done:
1539 if (atomic_dec_and_test(&ctx->pending))
1540 complete(&ctx->complete);
1541 }
1542
1543 static int unlink_queued(struct usbtest_dev *dev, int pipe, unsigned num,
1544 unsigned size)
1545 {
1546 struct queued_ctx ctx;
1547 struct usb_device *udev = testdev_to_usbdev(dev);
1548 void *buf;
1549 dma_addr_t buf_dma;
1550 int i;
1551 int retval = -ENOMEM;
1552
1553 init_completion(&ctx.complete);
1554 atomic_set(&ctx.pending, 1); /* One more than the actual value */
1555 ctx.num = num;
1556 ctx.status = 0;
1557
1558 buf = usb_alloc_coherent(udev, size, GFP_KERNEL, &buf_dma);
1559 if (!buf)
1560 return retval;
1561 memset(buf, 0, size);
1562
1563 /* Allocate and init the urbs we'll queue */
1564 ctx.urbs = kcalloc(num, sizeof(struct urb *), GFP_KERNEL);
1565 if (!ctx.urbs)
1566 goto free_buf;
1567 for (i = 0; i < num; i++) {
1568 ctx.urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
1569 if (!ctx.urbs[i])
1570 goto free_urbs;
1571 usb_fill_bulk_urb(ctx.urbs[i], udev, pipe, buf, size,
1572 unlink_queued_callback, &ctx);
1573 ctx.urbs[i]->transfer_dma = buf_dma;
1574 ctx.urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1575
1576 if (usb_pipeout(ctx.urbs[i]->pipe)) {
1577 simple_fill_buf(ctx.urbs[i]);
1578 ctx.urbs[i]->transfer_flags |= URB_ZERO_PACKET;
1579 }
1580 }
1581
1582 /* Submit all the URBs and then unlink URBs num - 4 and num - 2. */
1583 for (i = 0; i < num; i++) {
1584 atomic_inc(&ctx.pending);
1585 retval = usb_submit_urb(ctx.urbs[i], GFP_KERNEL);
1586 if (retval != 0) {
1587 dev_err(&dev->intf->dev, "submit urbs[%d] fail %d\n",
1588 i, retval);
1589 atomic_dec(&ctx.pending);
1590 ctx.status = retval;
1591 break;
1592 }
1593 }
1594 if (i == num) {
1595 usb_unlink_urb(ctx.urbs[num - 4]);
1596 usb_unlink_urb(ctx.urbs[num - 2]);
1597 } else {
1598 while (--i >= 0)
1599 usb_unlink_urb(ctx.urbs[i]);
1600 }
1601
1602 if (atomic_dec_and_test(&ctx.pending)) /* The extra count */
1603 complete(&ctx.complete);
1604 wait_for_completion(&ctx.complete);
1605 retval = ctx.status;
1606
1607 free_urbs:
1608 for (i = 0; i < num; i++)
1609 usb_free_urb(ctx.urbs[i]);
1610 kfree(ctx.urbs);
1611 free_buf:
1612 usb_free_coherent(udev, size, buf, buf_dma);
1613 return retval;
1614 }
1615
1616 /*-------------------------------------------------------------------------*/
1617
1618 static int verify_not_halted(struct usbtest_dev *tdev, int ep, struct urb *urb)
1619 {
1620 int retval;
1621 u16 status;
1622
1623 /* shouldn't look or act halted */
1624 retval = usb_get_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
1625 if (retval < 0) {
1626 ERROR(tdev, "ep %02x couldn't get no-halt status, %d\n",
1627 ep, retval);
1628 return retval;
1629 }
1630 if (status != 0) {
1631 ERROR(tdev, "ep %02x bogus status: %04x != 0\n", ep, status);
1632 return -EINVAL;
1633 }
1634 retval = simple_io(tdev, urb, 1, 0, 0, __func__);
1635 if (retval != 0)
1636 return -EINVAL;
1637 return 0;
1638 }
1639
1640 static int verify_halted(struct usbtest_dev *tdev, int ep, struct urb *urb)
1641 {
1642 int retval;
1643 u16 status;
1644
1645 /* should look and act halted */
1646 retval = usb_get_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
1647 if (retval < 0) {
1648 ERROR(tdev, "ep %02x couldn't get halt status, %d\n",
1649 ep, retval);
1650 return retval;
1651 }
1652 if (status != 1) {
1653 ERROR(tdev, "ep %02x bogus status: %04x != 1\n", ep, status);
1654 return -EINVAL;
1655 }
1656 retval = simple_io(tdev, urb, 1, 0, -EPIPE, __func__);
1657 if (retval != -EPIPE)
1658 return -EINVAL;
1659 retval = simple_io(tdev, urb, 1, 0, -EPIPE, "verify_still_halted");
1660 if (retval != -EPIPE)
1661 return -EINVAL;
1662 return 0;
1663 }
1664
1665 static int test_halt(struct usbtest_dev *tdev, int ep, struct urb *urb)
1666 {
1667 int retval;
1668
1669 /* shouldn't look or act halted now */
1670 retval = verify_not_halted(tdev, ep, urb);
1671 if (retval < 0)
1672 return retval;
1673
1674 /* set halt (protocol test only), verify it worked */
1675 retval = usb_control_msg(urb->dev, usb_sndctrlpipe(urb->dev, 0),
1676 USB_REQ_SET_FEATURE, USB_RECIP_ENDPOINT,
1677 USB_ENDPOINT_HALT, ep,
1678 NULL, 0, USB_CTRL_SET_TIMEOUT);
1679 if (retval < 0) {
1680 ERROR(tdev, "ep %02x couldn't set halt, %d\n", ep, retval);
1681 return retval;
1682 }
1683 retval = verify_halted(tdev, ep, urb);
1684 if (retval < 0) {
1685 int ret;
1686
1687 /* clear halt anyways, else further tests will fail */
1688 ret = usb_clear_halt(urb->dev, urb->pipe);
1689 if (ret)
1690 ERROR(tdev, "ep %02x couldn't clear halt, %d\n",
1691 ep, ret);
1692
1693 return retval;
1694 }
1695
1696 /* clear halt (tests API + protocol), verify it worked */
1697 retval = usb_clear_halt(urb->dev, urb->pipe);
1698 if (retval < 0) {
1699 ERROR(tdev, "ep %02x couldn't clear halt, %d\n", ep, retval);
1700 return retval;
1701 }
1702 retval = verify_not_halted(tdev, ep, urb);
1703 if (retval < 0)
1704 return retval;
1705
1706 /* NOTE: could also verify SET_INTERFACE clear halts ... */
1707
1708 return 0;
1709 }
1710
1711 static int halt_simple(struct usbtest_dev *dev)
1712 {
1713 int ep;
1714 int retval = 0;
1715 struct urb *urb;
1716 struct usb_device *udev = testdev_to_usbdev(dev);
1717
1718 if (udev->speed == USB_SPEED_SUPER)
1719 urb = simple_alloc_urb(udev, 0, 1024, 0);
1720 else
1721 urb = simple_alloc_urb(udev, 0, 512, 0);
1722 if (urb == NULL)
1723 return -ENOMEM;
1724
1725 if (dev->in_pipe) {
1726 ep = usb_pipeendpoint(dev->in_pipe) | USB_DIR_IN;
1727 urb->pipe = dev->in_pipe;
1728 retval = test_halt(dev, ep, urb);
1729 if (retval < 0)
1730 goto done;
1731 }
1732
1733 if (dev->out_pipe) {
1734 ep = usb_pipeendpoint(dev->out_pipe);
1735 urb->pipe = dev->out_pipe;
1736 retval = test_halt(dev, ep, urb);
1737 }
1738 done:
1739 simple_free_urb(urb);
1740 return retval;
1741 }
1742
1743 /*-------------------------------------------------------------------------*/
1744
1745 /* Control OUT tests use the vendor control requests from Intel's
1746 * USB 2.0 compliance test device: write a buffer, read it back.
1747 *
1748 * Intel's spec only _requires_ that it work for one packet, which
1749 * is pretty weak. Some HCDs place limits here; most devices will
1750 * need to be able to handle more than one OUT data packet. We'll
1751 * try whatever we're told to try.
1752 */
1753 static int ctrl_out(struct usbtest_dev *dev,
1754 unsigned count, unsigned length, unsigned vary, unsigned offset)
1755 {
1756 unsigned i, j, len;
1757 int retval;
1758 u8 *buf;
1759 char *what = "?";
1760 struct usb_device *udev;
1761
1762 if (length < 1 || length > 0xffff || vary >= length)
1763 return -EINVAL;
1764
1765 buf = kmalloc(length + offset, GFP_KERNEL);
1766 if (!buf)
1767 return -ENOMEM;
1768
1769 buf += offset;
1770 udev = testdev_to_usbdev(dev);
1771 len = length;
1772 retval = 0;
1773
1774 /* NOTE: hardware might well act differently if we pushed it
1775 * with lots back-to-back queued requests.
1776 */
1777 for (i = 0; i < count; i++) {
1778 /* write patterned data */
1779 for (j = 0; j < len; j++)
1780 buf[j] = (u8)(i + j);
1781 retval = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
1782 0x5b, USB_DIR_OUT|USB_TYPE_VENDOR,
1783 0, 0, buf, len, USB_CTRL_SET_TIMEOUT);
1784 if (retval != len) {
1785 what = "write";
1786 if (retval >= 0) {
1787 ERROR(dev, "ctrl_out, wlen %d (expected %d)\n",
1788 retval, len);
1789 retval = -EBADMSG;
1790 }
1791 break;
1792 }
1793
1794 /* read it back -- assuming nothing intervened!! */
1795 retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
1796 0x5c, USB_DIR_IN|USB_TYPE_VENDOR,
1797 0, 0, buf, len, USB_CTRL_GET_TIMEOUT);
1798 if (retval != len) {
1799 what = "read";
1800 if (retval >= 0) {
1801 ERROR(dev, "ctrl_out, rlen %d (expected %d)\n",
1802 retval, len);
1803 retval = -EBADMSG;
1804 }
1805 break;
1806 }
1807
1808 /* fail if we can't verify */
1809 for (j = 0; j < len; j++) {
1810 if (buf[j] != (u8)(i + j)) {
1811 ERROR(dev, "ctrl_out, byte %d is %d not %d\n",
1812 j, buf[j], (u8)(i + j));
1813 retval = -EBADMSG;
1814 break;
1815 }
1816 }
1817 if (retval < 0) {
1818 what = "verify";
1819 break;
1820 }
1821
1822 len += vary;
1823
1824 /* [real world] the "zero bytes IN" case isn't really used.
1825 * hardware can easily trip up in this weird case, since its
1826 * status stage is IN, not OUT like other ep0in transfers.
1827 */
1828 if (len > length)
1829 len = realworld ? 1 : 0;
1830 }
1831
1832 if (retval < 0)
1833 ERROR(dev, "ctrl_out %s failed, code %d, count %d\n",
1834 what, retval, i);
1835
1836 kfree(buf - offset);
1837 return retval;
1838 }
1839
1840 /*-------------------------------------------------------------------------*/
1841
1842 /* ISO/BULK tests ... mimics common usage
1843 * - buffer length is split into N packets (mostly maxpacket sized)
1844 * - multi-buffers according to sglen
1845 */
1846
1847 struct transfer_context {
1848 unsigned count;
1849 unsigned pending;
1850 spinlock_t lock;
1851 struct completion done;
1852 int submit_error;
1853 unsigned long errors;
1854 unsigned long packet_count;
1855 struct usbtest_dev *dev;
1856 bool is_iso;
1857 };
1858
1859 static void complicated_callback(struct urb *urb)
1860 {
1861 struct transfer_context *ctx = urb->context;
1862
1863 spin_lock(&ctx->lock);
1864 ctx->count--;
1865
1866 ctx->packet_count += urb->number_of_packets;
1867 if (urb->error_count > 0)
1868 ctx->errors += urb->error_count;
1869 else if (urb->status != 0)
1870 ctx->errors += (ctx->is_iso ? urb->number_of_packets : 1);
1871 else if (urb->actual_length != urb->transfer_buffer_length)
1872 ctx->errors++;
1873 else if (check_guard_bytes(ctx->dev, urb) != 0)
1874 ctx->errors++;
1875
1876 if (urb->status == 0 && ctx->count > (ctx->pending - 1)
1877 && !ctx->submit_error) {
1878 int status = usb_submit_urb(urb, GFP_ATOMIC);
1879 switch (status) {
1880 case 0:
1881 goto done;
1882 default:
1883 dev_err(&ctx->dev->intf->dev,
1884 "resubmit err %d\n",
1885 status);
1886 /* FALLTHROUGH */
1887 case -ENODEV: /* disconnected */
1888 case -ESHUTDOWN: /* endpoint disabled */
1889 ctx->submit_error = 1;
1890 break;
1891 }
1892 }
1893
1894 ctx->pending--;
1895 if (ctx->pending == 0) {
1896 if (ctx->errors)
1897 dev_err(&ctx->dev->intf->dev,
1898 "during the test, %lu errors out of %lu\n",
1899 ctx->errors, ctx->packet_count);
1900 complete(&ctx->done);
1901 }
1902 done:
1903 spin_unlock(&ctx->lock);
1904 }
1905
1906 static struct urb *iso_alloc_urb(
1907 struct usb_device *udev,
1908 int pipe,
1909 struct usb_endpoint_descriptor *desc,
1910 long bytes,
1911 unsigned offset
1912 )
1913 {
1914 struct urb *urb;
1915 unsigned i, maxp, packets;
1916
1917 if (bytes < 0 || !desc)
1918 return NULL;
1919 maxp = 0x7ff & usb_endpoint_maxp(desc);
1920 maxp *= 1 + (0x3 & (usb_endpoint_maxp(desc) >> 11));
1921 packets = DIV_ROUND_UP(bytes, maxp);
1922
1923 urb = usb_alloc_urb(packets, GFP_KERNEL);
1924 if (!urb)
1925 return urb;
1926 urb->dev = udev;
1927 urb->pipe = pipe;
1928
1929 urb->number_of_packets = packets;
1930 urb->transfer_buffer_length = bytes;
1931 urb->transfer_buffer = usb_alloc_coherent(udev, bytes + offset,
1932 GFP_KERNEL,
1933 &urb->transfer_dma);
1934 if (!urb->transfer_buffer) {
1935 usb_free_urb(urb);
1936 return NULL;
1937 }
1938 if (offset) {
1939 memset(urb->transfer_buffer, GUARD_BYTE, offset);
1940 urb->transfer_buffer += offset;
1941 urb->transfer_dma += offset;
1942 }
1943 /* For inbound transfers use guard byte so that test fails if
1944 data not correctly copied */
1945 memset(urb->transfer_buffer,
1946 usb_pipein(urb->pipe) ? GUARD_BYTE : 0,
1947 bytes);
1948
1949 for (i = 0; i < packets; i++) {
1950 /* here, only the last packet will be short */
1951 urb->iso_frame_desc[i].length = min((unsigned) bytes, maxp);
1952 bytes -= urb->iso_frame_desc[i].length;
1953
1954 urb->iso_frame_desc[i].offset = maxp * i;
1955 }
1956
1957 urb->complete = complicated_callback;
1958 /* urb->context = SET BY CALLER */
1959 urb->interval = 1 << (desc->bInterval - 1);
1960 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1961 return urb;
1962 }
1963
1964 static int
1965 test_queue(struct usbtest_dev *dev, struct usbtest_param_32 *param,
1966 int pipe, struct usb_endpoint_descriptor *desc, unsigned offset)
1967 {
1968 struct transfer_context context;
1969 struct usb_device *udev;
1970 unsigned i;
1971 unsigned long packets = 0;
1972 int status = 0;
1973 struct urb *urbs[param->sglen];
1974
1975 memset(&context, 0, sizeof(context));
1976 context.count = param->iterations * param->sglen;
1977 context.dev = dev;
1978 context.is_iso = !!desc;
1979 init_completion(&context.done);
1980 spin_lock_init(&context.lock);
1981
1982 udev = testdev_to_usbdev(dev);
1983
1984 for (i = 0; i < param->sglen; i++) {
1985 if (context.is_iso)
1986 urbs[i] = iso_alloc_urb(udev, pipe, desc,
1987 param->length, offset);
1988 else
1989 urbs[i] = complicated_alloc_urb(udev, pipe,
1990 param->length, 0);
1991
1992 if (!urbs[i]) {
1993 status = -ENOMEM;
1994 goto fail;
1995 }
1996 packets += urbs[i]->number_of_packets;
1997 urbs[i]->context = &context;
1998 }
1999 packets *= param->iterations;
2000
2001 if (context.is_iso) {
2002 dev_info(&dev->intf->dev,
2003 "iso period %d %sframes, wMaxPacket %d, transactions: %d\n",
2004 1 << (desc->bInterval - 1),
2005 (udev->speed == USB_SPEED_HIGH) ? "micro" : "",
2006 usb_endpoint_maxp(desc) & 0x7ff,
2007 1 + (0x3 & (usb_endpoint_maxp(desc) >> 11)));
2008
2009 dev_info(&dev->intf->dev,
2010 "total %lu msec (%lu packets)\n",
2011 (packets * (1 << (desc->bInterval - 1)))
2012 / ((udev->speed == USB_SPEED_HIGH) ? 8 : 1),
2013 packets);
2014 }
2015
2016 spin_lock_irq(&context.lock);
2017 for (i = 0; i < param->sglen; i++) {
2018 ++context.pending;
2019 status = usb_submit_urb(urbs[i], GFP_ATOMIC);
2020 if (status < 0) {
2021 ERROR(dev, "submit iso[%d], error %d\n", i, status);
2022 if (i == 0) {
2023 spin_unlock_irq(&context.lock);
2024 goto fail;
2025 }
2026
2027 simple_free_urb(urbs[i]);
2028 urbs[i] = NULL;
2029 context.pending--;
2030 context.submit_error = 1;
2031 break;
2032 }
2033 }
2034 spin_unlock_irq(&context.lock);
2035
2036 wait_for_completion(&context.done);
2037
2038 for (i = 0; i < param->sglen; i++) {
2039 if (urbs[i])
2040 simple_free_urb(urbs[i]);
2041 }
2042 /*
2043 * Isochronous transfers are expected to fail sometimes. As an
2044 * arbitrary limit, we will report an error if any submissions
2045 * fail or if the transfer failure rate is > 10%.
2046 */
2047 if (status != 0)
2048 ;
2049 else if (context.submit_error)
2050 status = -EACCES;
2051 else if (context.errors >
2052 (context.is_iso ? context.packet_count / 10 : 0))
2053 status = -EIO;
2054 return status;
2055
2056 fail:
2057 for (i = 0; i < param->sglen; i++) {
2058 if (urbs[i])
2059 simple_free_urb(urbs[i]);
2060 }
2061 return status;
2062 }
2063
2064 static int test_unaligned_bulk(
2065 struct usbtest_dev *tdev,
2066 int pipe,
2067 unsigned length,
2068 int iterations,
2069 unsigned transfer_flags,
2070 const char *label)
2071 {
2072 int retval;
2073 struct urb *urb = usbtest_alloc_urb(testdev_to_usbdev(tdev),
2074 pipe, length, transfer_flags, 1, 0, simple_callback);
2075
2076 if (!urb)
2077 return -ENOMEM;
2078
2079 retval = simple_io(tdev, urb, iterations, 0, 0, label);
2080 simple_free_urb(urb);
2081 return retval;
2082 }
2083
2084 /* Run tests. */
2085 static int
2086 usbtest_do_ioctl(struct usb_interface *intf, struct usbtest_param_32 *param)
2087 {
2088 struct usbtest_dev *dev = usb_get_intfdata(intf);
2089 struct usb_device *udev = testdev_to_usbdev(dev);
2090 struct urb *urb;
2091 struct scatterlist *sg;
2092 struct usb_sg_request req;
2093 unsigned i;
2094 int retval = -EOPNOTSUPP;
2095
2096 if (param->iterations <= 0)
2097 return -EINVAL;
2098 /*
2099 * Just a bunch of test cases that every HCD is expected to handle.
2100 *
2101 * Some may need specific firmware, though it'd be good to have
2102 * one firmware image to handle all the test cases.
2103 *
2104 * FIXME add more tests! cancel requests, verify the data, control
2105 * queueing, concurrent read+write threads, and so on.
2106 */
2107 switch (param->test_num) {
2108
2109 case 0:
2110 dev_info(&intf->dev, "TEST 0: NOP\n");
2111 retval = 0;
2112 break;
2113
2114 /* Simple non-queued bulk I/O tests */
2115 case 1:
2116 if (dev->out_pipe == 0)
2117 break;
2118 dev_info(&intf->dev,
2119 "TEST 1: write %d bytes %u times\n",
2120 param->length, param->iterations);
2121 urb = simple_alloc_urb(udev, dev->out_pipe, param->length, 0);
2122 if (!urb) {
2123 retval = -ENOMEM;
2124 break;
2125 }
2126 /* FIRMWARE: bulk sink (maybe accepts short writes) */
2127 retval = simple_io(dev, urb, param->iterations, 0, 0, "test1");
2128 simple_free_urb(urb);
2129 break;
2130 case 2:
2131 if (dev->in_pipe == 0)
2132 break;
2133 dev_info(&intf->dev,
2134 "TEST 2: read %d bytes %u times\n",
2135 param->length, param->iterations);
2136 urb = simple_alloc_urb(udev, dev->in_pipe, param->length, 0);
2137 if (!urb) {
2138 retval = -ENOMEM;
2139 break;
2140 }
2141 /* FIRMWARE: bulk source (maybe generates short writes) */
2142 retval = simple_io(dev, urb, param->iterations, 0, 0, "test2");
2143 simple_free_urb(urb);
2144 break;
2145 case 3:
2146 if (dev->out_pipe == 0 || param->vary == 0)
2147 break;
2148 dev_info(&intf->dev,
2149 "TEST 3: write/%d 0..%d bytes %u times\n",
2150 param->vary, param->length, param->iterations);
2151 urb = simple_alloc_urb(udev, dev->out_pipe, param->length, 0);
2152 if (!urb) {
2153 retval = -ENOMEM;
2154 break;
2155 }
2156 /* FIRMWARE: bulk sink (maybe accepts short writes) */
2157 retval = simple_io(dev, urb, param->iterations, param->vary,
2158 0, "test3");
2159 simple_free_urb(urb);
2160 break;
2161 case 4:
2162 if (dev->in_pipe == 0 || param->vary == 0)
2163 break;
2164 dev_info(&intf->dev,
2165 "TEST 4: read/%d 0..%d bytes %u times\n",
2166 param->vary, param->length, param->iterations);
2167 urb = simple_alloc_urb(udev, dev->in_pipe, param->length, 0);
2168 if (!urb) {
2169 retval = -ENOMEM;
2170 break;
2171 }
2172 /* FIRMWARE: bulk source (maybe generates short writes) */
2173 retval = simple_io(dev, urb, param->iterations, param->vary,
2174 0, "test4");
2175 simple_free_urb(urb);
2176 break;
2177
2178 /* Queued bulk I/O tests */
2179 case 5:
2180 if (dev->out_pipe == 0 || param->sglen == 0)
2181 break;
2182 dev_info(&intf->dev,
2183 "TEST 5: write %d sglists %d entries of %d bytes\n",
2184 param->iterations,
2185 param->sglen, param->length);
2186 sg = alloc_sglist(param->sglen, param->length,
2187 0, dev, dev->out_pipe);
2188 if (!sg) {
2189 retval = -ENOMEM;
2190 break;
2191 }
2192 /* FIRMWARE: bulk sink (maybe accepts short writes) */
2193 retval = perform_sglist(dev, param->iterations, dev->out_pipe,
2194 &req, sg, param->sglen);
2195 free_sglist(sg, param->sglen);
2196 break;
2197
2198 case 6:
2199 if (dev->in_pipe == 0 || param->sglen == 0)
2200 break;
2201 dev_info(&intf->dev,
2202 "TEST 6: read %d sglists %d entries of %d bytes\n",
2203 param->iterations,
2204 param->sglen, param->length);
2205 sg = alloc_sglist(param->sglen, param->length,
2206 0, dev, dev->in_pipe);
2207 if (!sg) {
2208 retval = -ENOMEM;
2209 break;
2210 }
2211 /* FIRMWARE: bulk source (maybe generates short writes) */
2212 retval = perform_sglist(dev, param->iterations, dev->in_pipe,
2213 &req, sg, param->sglen);
2214 free_sglist(sg, param->sglen);
2215 break;
2216 case 7:
2217 if (dev->out_pipe == 0 || param->sglen == 0 || param->vary == 0)
2218 break;
2219 dev_info(&intf->dev,
2220 "TEST 7: write/%d %d sglists %d entries 0..%d bytes\n",
2221 param->vary, param->iterations,
2222 param->sglen, param->length);
2223 sg = alloc_sglist(param->sglen, param->length,
2224 param->vary, dev, dev->out_pipe);
2225 if (!sg) {
2226 retval = -ENOMEM;
2227 break;
2228 }
2229 /* FIRMWARE: bulk sink (maybe accepts short writes) */
2230 retval = perform_sglist(dev, param->iterations, dev->out_pipe,
2231 &req, sg, param->sglen);
2232 free_sglist(sg, param->sglen);
2233 break;
2234 case 8:
2235 if (dev->in_pipe == 0 || param->sglen == 0 || param->vary == 0)
2236 break;
2237 dev_info(&intf->dev,
2238 "TEST 8: read/%d %d sglists %d entries 0..%d bytes\n",
2239 param->vary, param->iterations,
2240 param->sglen, param->length);
2241 sg = alloc_sglist(param->sglen, param->length,
2242 param->vary, dev, dev->in_pipe);
2243 if (!sg) {
2244 retval = -ENOMEM;
2245 break;
2246 }
2247 /* FIRMWARE: bulk source (maybe generates short writes) */
2248 retval = perform_sglist(dev, param->iterations, dev->in_pipe,
2249 &req, sg, param->sglen);
2250 free_sglist(sg, param->sglen);
2251 break;
2252
2253 /* non-queued sanity tests for control (chapter 9 subset) */
2254 case 9:
2255 retval = 0;
2256 dev_info(&intf->dev,
2257 "TEST 9: ch9 (subset) control tests, %d times\n",
2258 param->iterations);
2259 for (i = param->iterations; retval == 0 && i--; /* NOP */)
2260 retval = ch9_postconfig(dev);
2261 if (retval)
2262 dev_err(&intf->dev, "ch9 subset failed, "
2263 "iterations left %d\n", i);
2264 break;
2265
2266 /* queued control messaging */
2267 case 10:
2268 retval = 0;
2269 dev_info(&intf->dev,
2270 "TEST 10: queue %d control calls, %d times\n",
2271 param->sglen,
2272 param->iterations);
2273 retval = test_ctrl_queue(dev, param);
2274 break;
2275
2276 /* simple non-queued unlinks (ring with one urb) */
2277 case 11:
2278 if (dev->in_pipe == 0 || !param->length)
2279 break;
2280 retval = 0;
2281 dev_info(&intf->dev, "TEST 11: unlink %d reads of %d\n",
2282 param->iterations, param->length);
2283 for (i = param->iterations; retval == 0 && i--; /* NOP */)
2284 retval = unlink_simple(dev, dev->in_pipe,
2285 param->length);
2286 if (retval)
2287 dev_err(&intf->dev, "unlink reads failed %d, "
2288 "iterations left %d\n", retval, i);
2289 break;
2290 case 12:
2291 if (dev->out_pipe == 0 || !param->length)
2292 break;
2293 retval = 0;
2294 dev_info(&intf->dev, "TEST 12: unlink %d writes of %d\n",
2295 param->iterations, param->length);
2296 for (i = param->iterations; retval == 0 && i--; /* NOP */)
2297 retval = unlink_simple(dev, dev->out_pipe,
2298 param->length);
2299 if (retval)
2300 dev_err(&intf->dev, "unlink writes failed %d, "
2301 "iterations left %d\n", retval, i);
2302 break;
2303
2304 /* ep halt tests */
2305 case 13:
2306 if (dev->out_pipe == 0 && dev->in_pipe == 0)
2307 break;
2308 retval = 0;
2309 dev_info(&intf->dev, "TEST 13: set/clear %d halts\n",
2310 param->iterations);
2311 for (i = param->iterations; retval == 0 && i--; /* NOP */)
2312 retval = halt_simple(dev);
2313
2314 if (retval)
2315 ERROR(dev, "halts failed, iterations left %d\n", i);
2316 break;
2317
2318 /* control write tests */
2319 case 14:
2320 if (!dev->info->ctrl_out)
2321 break;
2322 dev_info(&intf->dev, "TEST 14: %d ep0out, %d..%d vary %d\n",
2323 param->iterations,
2324 realworld ? 1 : 0, param->length,
2325 param->vary);
2326 retval = ctrl_out(dev, param->iterations,
2327 param->length, param->vary, 0);
2328 break;
2329
2330 /* iso write tests */
2331 case 15:
2332 if (dev->out_iso_pipe == 0 || param->sglen == 0)
2333 break;
2334 dev_info(&intf->dev,
2335 "TEST 15: write %d iso, %d entries of %d bytes\n",
2336 param->iterations,
2337 param->sglen, param->length);
2338 /* FIRMWARE: iso sink */
2339 retval = test_queue(dev, param,
2340 dev->out_iso_pipe, dev->iso_out, 0);
2341 break;
2342
2343 /* iso read tests */
2344 case 16:
2345 if (dev->in_iso_pipe == 0 || param->sglen == 0)
2346 break;
2347 dev_info(&intf->dev,
2348 "TEST 16: read %d iso, %d entries of %d bytes\n",
2349 param->iterations,
2350 param->sglen, param->length);
2351 /* FIRMWARE: iso source */
2352 retval = test_queue(dev, param,
2353 dev->in_iso_pipe, dev->iso_in, 0);
2354 break;
2355
2356 /* FIXME scatterlist cancel (needs helper thread) */
2357
2358 /* Tests for bulk I/O using DMA mapping by core and odd address */
2359 case 17:
2360 if (dev->out_pipe == 0)
2361 break;
2362 dev_info(&intf->dev,
2363 "TEST 17: write odd addr %d bytes %u times core map\n",
2364 param->length, param->iterations);
2365
2366 retval = test_unaligned_bulk(
2367 dev, dev->out_pipe,
2368 param->length, param->iterations,
2369 0, "test17");
2370 break;
2371
2372 case 18:
2373 if (dev->in_pipe == 0)
2374 break;
2375 dev_info(&intf->dev,
2376 "TEST 18: read odd addr %d bytes %u times core map\n",
2377 param->length, param->iterations);
2378
2379 retval = test_unaligned_bulk(
2380 dev, dev->in_pipe,
2381 param->length, param->iterations,
2382 0, "test18");
2383 break;
2384
2385 /* Tests for bulk I/O using premapped coherent buffer and odd address */
2386 case 19:
2387 if (dev->out_pipe == 0)
2388 break;
2389 dev_info(&intf->dev,
2390 "TEST 19: write odd addr %d bytes %u times premapped\n",
2391 param->length, param->iterations);
2392
2393 retval = test_unaligned_bulk(
2394 dev, dev->out_pipe,
2395 param->length, param->iterations,
2396 URB_NO_TRANSFER_DMA_MAP, "test19");
2397 break;
2398
2399 case 20:
2400 if (dev->in_pipe == 0)
2401 break;
2402 dev_info(&intf->dev,
2403 "TEST 20: read odd addr %d bytes %u times premapped\n",
2404 param->length, param->iterations);
2405
2406 retval = test_unaligned_bulk(
2407 dev, dev->in_pipe,
2408 param->length, param->iterations,
2409 URB_NO_TRANSFER_DMA_MAP, "test20");
2410 break;
2411
2412 /* control write tests with unaligned buffer */
2413 case 21:
2414 if (!dev->info->ctrl_out)
2415 break;
2416 dev_info(&intf->dev,
2417 "TEST 21: %d ep0out odd addr, %d..%d vary %d\n",
2418 param->iterations,
2419 realworld ? 1 : 0, param->length,
2420 param->vary);
2421 retval = ctrl_out(dev, param->iterations,
2422 param->length, param->vary, 1);
2423 break;
2424
2425 /* unaligned iso tests */
2426 case 22:
2427 if (dev->out_iso_pipe == 0 || param->sglen == 0)
2428 break;
2429 dev_info(&intf->dev,
2430 "TEST 22: write %d iso odd, %d entries of %d bytes\n",
2431 param->iterations,
2432 param->sglen, param->length);
2433 retval = test_queue(dev, param,
2434 dev->out_iso_pipe, dev->iso_out, 1);
2435 break;
2436
2437 case 23:
2438 if (dev->in_iso_pipe == 0 || param->sglen == 0)
2439 break;
2440 dev_info(&intf->dev,
2441 "TEST 23: read %d iso odd, %d entries of %d bytes\n",
2442 param->iterations,
2443 param->sglen, param->length);
2444 retval = test_queue(dev, param,
2445 dev->in_iso_pipe, dev->iso_in, 1);
2446 break;
2447
2448 /* unlink URBs from a bulk-OUT queue */
2449 case 24:
2450 if (dev->out_pipe == 0 || !param->length || param->sglen < 4)
2451 break;
2452 retval = 0;
2453 dev_info(&intf->dev, "TEST 24: unlink from %d queues of "
2454 "%d %d-byte writes\n",
2455 param->iterations, param->sglen, param->length);
2456 for (i = param->iterations; retval == 0 && i > 0; --i) {
2457 retval = unlink_queued(dev, dev->out_pipe,
2458 param->sglen, param->length);
2459 if (retval) {
2460 dev_err(&intf->dev,
2461 "unlink queued writes failed %d, "
2462 "iterations left %d\n", retval, i);
2463 break;
2464 }
2465 }
2466 break;
2467
2468 /* Simple non-queued interrupt I/O tests */
2469 case 25:
2470 if (dev->out_int_pipe == 0)
2471 break;
2472 dev_info(&intf->dev,
2473 "TEST 25: write %d bytes %u times\n",
2474 param->length, param->iterations);
2475 urb = simple_alloc_urb(udev, dev->out_int_pipe, param->length,
2476 dev->int_out->bInterval);
2477 if (!urb) {
2478 retval = -ENOMEM;
2479 break;
2480 }
2481 /* FIRMWARE: interrupt sink (maybe accepts short writes) */
2482 retval = simple_io(dev, urb, param->iterations, 0, 0, "test25");
2483 simple_free_urb(urb);
2484 break;
2485 case 26:
2486 if (dev->in_int_pipe == 0)
2487 break;
2488 dev_info(&intf->dev,
2489 "TEST 26: read %d bytes %u times\n",
2490 param->length, param->iterations);
2491 urb = simple_alloc_urb(udev, dev->in_int_pipe, param->length,
2492 dev->int_in->bInterval);
2493 if (!urb) {
2494 retval = -ENOMEM;
2495 break;
2496 }
2497 /* FIRMWARE: interrupt source (maybe generates short writes) */
2498 retval = simple_io(dev, urb, param->iterations, 0, 0, "test26");
2499 simple_free_urb(urb);
2500 break;
2501 case 27:
2502 /* We do performance test, so ignore data compare */
2503 if (dev->out_pipe == 0 || param->sglen == 0 || pattern != 0)
2504 break;
2505 dev_info(&intf->dev,
2506 "TEST 27: bulk write %dMbytes\n", (param->iterations *
2507 param->sglen * param->length) / (1024 * 1024));
2508 retval = test_queue(dev, param,
2509 dev->out_pipe, NULL, 0);
2510 break;
2511 case 28:
2512 if (dev->in_pipe == 0 || param->sglen == 0 || pattern != 0)
2513 break;
2514 dev_info(&intf->dev,
2515 "TEST 28: bulk read %dMbytes\n", (param->iterations *
2516 param->sglen * param->length) / (1024 * 1024));
2517 retval = test_queue(dev, param,
2518 dev->in_pipe, NULL, 0);
2519 break;
2520 }
2521 return retval;
2522 }
2523
2524 /*-------------------------------------------------------------------------*/
2525
2526 /* We only have this one interface to user space, through usbfs.
2527 * User mode code can scan usbfs to find N different devices (maybe on
2528 * different busses) to use when testing, and allocate one thread per
2529 * test. So discovery is simplified, and we have no device naming issues.
2530 *
2531 * Don't use these only as stress/load tests. Use them along with with
2532 * other USB bus activity: plugging, unplugging, mousing, mp3 playback,
2533 * video capture, and so on. Run different tests at different times, in
2534 * different sequences. Nothing here should interact with other devices,
2535 * except indirectly by consuming USB bandwidth and CPU resources for test
2536 * threads and request completion. But the only way to know that for sure
2537 * is to test when HC queues are in use by many devices.
2538 *
2539 * WARNING: Because usbfs grabs udev->dev.sem before calling this ioctl(),
2540 * it locks out usbcore in certain code paths. Notably, if you disconnect
2541 * the device-under-test, hub_wq will wait block forever waiting for the
2542 * ioctl to complete ... so that usb_disconnect() can abort the pending
2543 * urbs and then call usbtest_disconnect(). To abort a test, you're best
2544 * off just killing the userspace task and waiting for it to exit.
2545 */
2546
2547 static int
2548 usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
2549 {
2550
2551 struct usbtest_dev *dev = usb_get_intfdata(intf);
2552 struct usbtest_param_64 *param_64 = buf;
2553 struct usbtest_param_32 temp;
2554 struct usbtest_param_32 *param_32 = buf;
2555 struct timespec64 start;
2556 struct timespec64 end;
2557 struct timespec64 duration;
2558 int retval = -EOPNOTSUPP;
2559
2560 /* FIXME USBDEVFS_CONNECTINFO doesn't say how fast the device is. */
2561
2562 pattern = mod_pattern;
2563
2564 if (mutex_lock_interruptible(&dev->lock))
2565 return -ERESTARTSYS;
2566
2567 /* FIXME: What if a system sleep starts while a test is running? */
2568
2569 /* some devices, like ez-usb default devices, need a non-default
2570 * altsetting to have any active endpoints. some tests change
2571 * altsettings; force a default so most tests don't need to check.
2572 */
2573 if (dev->info->alt >= 0) {
2574 if (intf->altsetting->desc.bInterfaceNumber) {
2575 retval = -ENODEV;
2576 goto free_mutex;
2577 }
2578 retval = set_altsetting(dev, dev->info->alt);
2579 if (retval) {
2580 dev_err(&intf->dev,
2581 "set altsetting to %d failed, %d\n",
2582 dev->info->alt, retval);
2583 goto free_mutex;
2584 }
2585 }
2586
2587 switch (code) {
2588 case USBTEST_REQUEST_64:
2589 temp.test_num = param_64->test_num;
2590 temp.iterations = param_64->iterations;
2591 temp.length = param_64->length;
2592 temp.sglen = param_64->sglen;
2593 temp.vary = param_64->vary;
2594 param_32 = &temp;
2595 break;
2596
2597 case USBTEST_REQUEST_32:
2598 break;
2599
2600 default:
2601 retval = -EOPNOTSUPP;
2602 goto free_mutex;
2603 }
2604
2605 ktime_get_ts64(&start);
2606
2607 retval = usbtest_do_ioctl(intf, param_32);
2608 if (retval < 0)
2609 goto free_mutex;
2610
2611 ktime_get_ts64(&end);
2612
2613 duration = timespec64_sub(end, start);
2614
2615 temp.duration_sec = duration.tv_sec;
2616 temp.duration_usec = duration.tv_nsec/NSEC_PER_USEC;
2617
2618 switch (code) {
2619 case USBTEST_REQUEST_32:
2620 param_32->duration_sec = temp.duration_sec;
2621 param_32->duration_usec = temp.duration_usec;
2622 break;
2623
2624 case USBTEST_REQUEST_64:
2625 param_64->duration_sec = temp.duration_sec;
2626 param_64->duration_usec = temp.duration_usec;
2627 break;
2628 }
2629
2630 free_mutex:
2631 mutex_unlock(&dev->lock);
2632 return retval;
2633 }
2634
2635 /*-------------------------------------------------------------------------*/
2636
2637 static unsigned force_interrupt;
2638 module_param(force_interrupt, uint, 0);
2639 MODULE_PARM_DESC(force_interrupt, "0 = test default; else interrupt");
2640
2641 #ifdef GENERIC
2642 static unsigned short vendor;
2643 module_param(vendor, ushort, 0);
2644 MODULE_PARM_DESC(vendor, "vendor code (from usb-if)");
2645
2646 static unsigned short product;
2647 module_param(product, ushort, 0);
2648 MODULE_PARM_DESC(product, "product code (from vendor)");
2649 #endif
2650
2651 static int
2652 usbtest_probe(struct usb_interface *intf, const struct usb_device_id *id)
2653 {
2654 struct usb_device *udev;
2655 struct usbtest_dev *dev;
2656 struct usbtest_info *info;
2657 char *rtest, *wtest;
2658 char *irtest, *iwtest;
2659 char *intrtest, *intwtest;
2660
2661 udev = interface_to_usbdev(intf);
2662
2663 #ifdef GENERIC
2664 /* specify devices by module parameters? */
2665 if (id->match_flags == 0) {
2666 /* vendor match required, product match optional */
2667 if (!vendor || le16_to_cpu(udev->descriptor.idVendor) != (u16)vendor)
2668 return -ENODEV;
2669 if (product && le16_to_cpu(udev->descriptor.idProduct) != (u16)product)
2670 return -ENODEV;
2671 dev_info(&intf->dev, "matched module params, "
2672 "vend=0x%04x prod=0x%04x\n",
2673 le16_to_cpu(udev->descriptor.idVendor),
2674 le16_to_cpu(udev->descriptor.idProduct));
2675 }
2676 #endif
2677
2678 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
2679 if (!dev)
2680 return -ENOMEM;
2681 info = (struct usbtest_info *) id->driver_info;
2682 dev->info = info;
2683 mutex_init(&dev->lock);
2684
2685 dev->intf = intf;
2686
2687 /* cacheline-aligned scratch for i/o */
2688 dev->buf = kmalloc(TBUF_SIZE, GFP_KERNEL);
2689 if (dev->buf == NULL) {
2690 kfree(dev);
2691 return -ENOMEM;
2692 }
2693
2694 /* NOTE this doesn't yet test the handful of difference that are
2695 * visible with high speed interrupts: bigger maxpacket (1K) and
2696 * "high bandwidth" modes (up to 3 packets/uframe).
2697 */
2698 rtest = wtest = "";
2699 irtest = iwtest = "";
2700 intrtest = intwtest = "";
2701 if (force_interrupt || udev->speed == USB_SPEED_LOW) {
2702 if (info->ep_in) {
2703 dev->in_pipe = usb_rcvintpipe(udev, info->ep_in);
2704 rtest = " intr-in";
2705 }
2706 if (info->ep_out) {
2707 dev->out_pipe = usb_sndintpipe(udev, info->ep_out);
2708 wtest = " intr-out";
2709 }
2710 } else {
2711 if (override_alt >= 0 || info->autoconf) {
2712 int status;
2713
2714 status = get_endpoints(dev, intf);
2715 if (status < 0) {
2716 WARNING(dev, "couldn't get endpoints, %d\n",
2717 status);
2718 kfree(dev->buf);
2719 kfree(dev);
2720 return status;
2721 }
2722 /* may find bulk or ISO pipes */
2723 } else {
2724 if (info->ep_in)
2725 dev->in_pipe = usb_rcvbulkpipe(udev,
2726 info->ep_in);
2727 if (info->ep_out)
2728 dev->out_pipe = usb_sndbulkpipe(udev,
2729 info->ep_out);
2730 }
2731 if (dev->in_pipe)
2732 rtest = " bulk-in";
2733 if (dev->out_pipe)
2734 wtest = " bulk-out";
2735 if (dev->in_iso_pipe)
2736 irtest = " iso-in";
2737 if (dev->out_iso_pipe)
2738 iwtest = " iso-out";
2739 if (dev->in_int_pipe)
2740 intrtest = " int-in";
2741 if (dev->out_int_pipe)
2742 intwtest = " int-out";
2743 }
2744
2745 usb_set_intfdata(intf, dev);
2746 dev_info(&intf->dev, "%s\n", info->name);
2747 dev_info(&intf->dev, "%s {control%s%s%s%s%s%s%s} tests%s\n",
2748 usb_speed_string(udev->speed),
2749 info->ctrl_out ? " in/out" : "",
2750 rtest, wtest,
2751 irtest, iwtest,
2752 intrtest, intwtest,
2753 info->alt >= 0 ? " (+alt)" : "");
2754 return 0;
2755 }
2756
2757 static int usbtest_suspend(struct usb_interface *intf, pm_message_t message)
2758 {
2759 return 0;
2760 }
2761
2762 static int usbtest_resume(struct usb_interface *intf)
2763 {
2764 return 0;
2765 }
2766
2767
2768 static void usbtest_disconnect(struct usb_interface *intf)
2769 {
2770 struct usbtest_dev *dev = usb_get_intfdata(intf);
2771
2772 usb_set_intfdata(intf, NULL);
2773 dev_dbg(&intf->dev, "disconnect\n");
2774 kfree(dev);
2775 }
2776
2777 /* Basic testing only needs a device that can source or sink bulk traffic.
2778 * Any device can test control transfers (default with GENERIC binding).
2779 *
2780 * Several entries work with the default EP0 implementation that's built
2781 * into EZ-USB chips. There's a default vendor ID which can be overridden
2782 * by (very) small config EEPROMS, but otherwise all these devices act
2783 * identically until firmware is loaded: only EP0 works. It turns out
2784 * to be easy to make other endpoints work, without modifying that EP0
2785 * behavior. For now, we expect that kind of firmware.
2786 */
2787
2788 /* an21xx or fx versions of ez-usb */
2789 static struct usbtest_info ez1_info = {
2790 .name = "EZ-USB device",
2791 .ep_in = 2,
2792 .ep_out = 2,
2793 .alt = 1,
2794 };
2795
2796 /* fx2 version of ez-usb */
2797 static struct usbtest_info ez2_info = {
2798 .name = "FX2 device",
2799 .ep_in = 6,
2800 .ep_out = 2,
2801 .alt = 1,
2802 };
2803
2804 /* ezusb family device with dedicated usb test firmware,
2805 */
2806 static struct usbtest_info fw_info = {
2807 .name = "usb test device",
2808 .ep_in = 2,
2809 .ep_out = 2,
2810 .alt = 1,
2811 .autoconf = 1, /* iso and ctrl_out need autoconf */
2812 .ctrl_out = 1,
2813 .iso = 1, /* iso_ep's are #8 in/out */
2814 };
2815
2816 /* peripheral running Linux and 'zero.c' test firmware, or
2817 * its user-mode cousin. different versions of this use
2818 * different hardware with the same vendor/product codes.
2819 * host side MUST rely on the endpoint descriptors.
2820 */
2821 static struct usbtest_info gz_info = {
2822 .name = "Linux gadget zero",
2823 .autoconf = 1,
2824 .ctrl_out = 1,
2825 .iso = 1,
2826 .intr = 1,
2827 .alt = 0,
2828 };
2829
2830 static struct usbtest_info um_info = {
2831 .name = "Linux user mode test driver",
2832 .autoconf = 1,
2833 .alt = -1,
2834 };
2835
2836 static struct usbtest_info um2_info = {
2837 .name = "Linux user mode ISO test driver",
2838 .autoconf = 1,
2839 .iso = 1,
2840 .alt = -1,
2841 };
2842
2843 #ifdef IBOT2
2844 /* this is a nice source of high speed bulk data;
2845 * uses an FX2, with firmware provided in the device
2846 */
2847 static struct usbtest_info ibot2_info = {
2848 .name = "iBOT2 webcam",
2849 .ep_in = 2,
2850 .alt = -1,
2851 };
2852 #endif
2853
2854 #ifdef GENERIC
2855 /* we can use any device to test control traffic */
2856 static struct usbtest_info generic_info = {
2857 .name = "Generic USB device",
2858 .alt = -1,
2859 };
2860 #endif
2861
2862
2863 static const struct usb_device_id id_table[] = {
2864
2865 /*-------------------------------------------------------------*/
2866
2867 /* EZ-USB devices which download firmware to replace (or in our
2868 * case augment) the default device implementation.
2869 */
2870
2871 /* generic EZ-USB FX controller */
2872 { USB_DEVICE(0x0547, 0x2235),
2873 .driver_info = (unsigned long) &ez1_info,
2874 },
2875
2876 /* CY3671 development board with EZ-USB FX */
2877 { USB_DEVICE(0x0547, 0x0080),
2878 .driver_info = (unsigned long) &ez1_info,
2879 },
2880
2881 /* generic EZ-USB FX2 controller (or development board) */
2882 { USB_DEVICE(0x04b4, 0x8613),
2883 .driver_info = (unsigned long) &ez2_info,
2884 },
2885
2886 /* re-enumerated usb test device firmware */
2887 { USB_DEVICE(0xfff0, 0xfff0),
2888 .driver_info = (unsigned long) &fw_info,
2889 },
2890
2891 /* "Gadget Zero" firmware runs under Linux */
2892 { USB_DEVICE(0x0525, 0xa4a0),
2893 .driver_info = (unsigned long) &gz_info,
2894 },
2895
2896 /* so does a user-mode variant */
2897 { USB_DEVICE(0x0525, 0xa4a4),
2898 .driver_info = (unsigned long) &um_info,
2899 },
2900
2901 /* ... and a user-mode variant that talks iso */
2902 { USB_DEVICE(0x0525, 0xa4a3),
2903 .driver_info = (unsigned long) &um2_info,
2904 },
2905
2906 #ifdef KEYSPAN_19Qi
2907 /* Keyspan 19qi uses an21xx (original EZ-USB) */
2908 /* this does not coexist with the real Keyspan 19qi driver! */
2909 { USB_DEVICE(0x06cd, 0x010b),
2910 .driver_info = (unsigned long) &ez1_info,
2911 },
2912 #endif
2913
2914 /*-------------------------------------------------------------*/
2915
2916 #ifdef IBOT2
2917 /* iBOT2 makes a nice source of high speed bulk-in data */
2918 /* this does not coexist with a real iBOT2 driver! */
2919 { USB_DEVICE(0x0b62, 0x0059),
2920 .driver_info = (unsigned long) &ibot2_info,
2921 },
2922 #endif
2923
2924 /*-------------------------------------------------------------*/
2925
2926 #ifdef GENERIC
2927 /* module params can specify devices to use for control tests */
2928 { .driver_info = (unsigned long) &generic_info, },
2929 #endif
2930
2931 /*-------------------------------------------------------------*/
2932
2933 { }
2934 };
2935 MODULE_DEVICE_TABLE(usb, id_table);
2936
2937 static struct usb_driver usbtest_driver = {
2938 .name = "usbtest",
2939 .id_table = id_table,
2940 .probe = usbtest_probe,
2941 .unlocked_ioctl = usbtest_ioctl,
2942 .disconnect = usbtest_disconnect,
2943 .suspend = usbtest_suspend,
2944 .resume = usbtest_resume,
2945 };
2946
2947 /*-------------------------------------------------------------------------*/
2948
2949 static int __init usbtest_init(void)
2950 {
2951 #ifdef GENERIC
2952 if (vendor)
2953 pr_debug("params: vend=0x%04x prod=0x%04x\n", vendor, product);
2954 #endif
2955 return usb_register(&usbtest_driver);
2956 }
2957 module_init(usbtest_init);
2958
2959 static void __exit usbtest_exit(void)
2960 {
2961 usb_deregister(&usbtest_driver);
2962 }
2963 module_exit(usbtest_exit);
2964
2965 MODULE_DESCRIPTION("USB Core/HCD Testing Driver");
2966 MODULE_LICENSE("GPL");
2967
Linux with added FPC-III support