blob: 9dcb68f04f03025265f3747e6f7bf072ab1b8958 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#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>
David Hardeman378f0582005-09-17 17:55:31 +10008#include <linux/scatterlist.h>
Matthias Kaehlcke1cfab022007-12-13 16:15:33 -08009#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
11#include <linux/usb.h>
12
13
14/*-------------------------------------------------------------------------*/
15
Martin Fuzzeyfabbf212010-10-01 00:20:42 +020016/* FIXME make these public somewhere; usbdevfs.h? */
Linus Torvalds1da177e2005-04-16 15:20:36 -070017struct usbtest_param {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +020018 /* inputs */
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 unsigned test_num; /* 0..(TEST_CASES-1) */
20 unsigned iterations;
21 unsigned length;
22 unsigned vary;
23 unsigned sglen;
24
Martin Fuzzeyfabbf212010-10-01 00:20:42 +020025 /* outputs */
Linus Torvalds1da177e2005-04-16 15:20:36 -070026 struct timeval duration;
27};
28#define USBTEST_REQUEST _IOWR('U', 100, struct usbtest_param)
29
30/*-------------------------------------------------------------------------*/
31
32#define GENERIC /* let probe() bind using module params */
33
34/* Some devices that can be used for testing will have "real" drivers.
35 * Entries for those need to be enabled here by hand, after disabling
36 * that "real" driver.
37 */
38//#define IBOT2 /* grab iBOT2 webcams */
39//#define KEYSPAN_19Qi /* grab un-renumerated serial adapter */
40
41/*-------------------------------------------------------------------------*/
42
43struct usbtest_info {
44 const char *name;
45 u8 ep_in; /* bulk/intr source */
46 u8 ep_out; /* bulk/intr sink */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +020047 unsigned autoconf:1;
48 unsigned ctrl_out:1;
49 unsigned iso:1; /* try iso in/out */
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 int alt;
51};
52
53/* this is accessed only through usbfs ioctl calls.
54 * one ioctl to issue a test ... one lock per device.
55 * tests create other threads if they need them.
56 * urbs and buffers are allocated dynamically,
57 * and data generated deterministically.
58 */
59struct usbtest_dev {
60 struct usb_interface *intf;
61 struct usbtest_info *info;
62 int in_pipe;
63 int out_pipe;
64 int in_iso_pipe;
65 int out_iso_pipe;
66 struct usb_endpoint_descriptor *iso_in, *iso_out;
Matthias Kaehlcke1cfab022007-12-13 16:15:33 -080067 struct mutex lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
69#define TBUF_SIZE 256
70 u8 *buf;
71};
72
Martin Fuzzeyfabbf212010-10-01 00:20:42 +020073static struct usb_device *testdev_to_usbdev(struct usbtest_dev *test)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074{
Martin Fuzzeyfabbf212010-10-01 00:20:42 +020075 return interface_to_usbdev(test->intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076}
77
78/* set up all urbs so they can be used with either bulk or interrupt */
79#define INTERRUPT_RATE 1 /* msec/transfer */
80
David Brownell28ffd792008-04-25 18:51:10 -070081#define ERROR(tdev, fmt, args...) \
82 dev_err(&(tdev)->intf->dev , fmt , ## args)
Arjan van de Venb6c63932008-07-25 01:45:52 -070083#define WARNING(tdev, fmt, args...) \
David Brownell28ffd792008-04-25 18:51:10 -070084 dev_warn(&(tdev)->intf->dev , fmt , ## args)
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Martin Fuzzey084fb202011-01-16 19:17:11 +010086#define GUARD_BYTE 0xA5
87
Linus Torvalds1da177e2005-04-16 15:20:36 -070088/*-------------------------------------------------------------------------*/
89
90static int
Martin Fuzzeyfabbf212010-10-01 00:20:42 +020091get_endpoints(struct usbtest_dev *dev, struct usb_interface *intf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092{
93 int tmp;
94 struct usb_host_interface *alt;
95 struct usb_host_endpoint *in, *out;
96 struct usb_host_endpoint *iso_in, *iso_out;
97 struct usb_device *udev;
98
99 for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
100 unsigned ep;
101
102 in = out = NULL;
103 iso_in = iso_out = NULL;
104 alt = intf->altsetting + tmp;
105
106 /* take the first altsetting with in-bulk + out-bulk;
Justin P. Mattock70f23fd2011-05-10 10:16:21 +0200107 * ignore other endpoints and altsettings.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 */
109 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
110 struct usb_host_endpoint *e;
111
112 e = alt->endpoint + ep;
113 switch (e->desc.bmAttributes) {
114 case USB_ENDPOINT_XFER_BULK:
115 break;
116 case USB_ENDPOINT_XFER_ISOC:
117 if (dev->info->iso)
118 goto try_iso;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200119 /* FALLTHROUGH */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 default:
121 continue;
122 }
Luiz Fernando N. Capitulino4d823dd2006-10-26 13:03:02 -0300123 if (usb_endpoint_dir_in(&e->desc)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 if (!in)
125 in = e;
126 } else {
127 if (!out)
128 out = e;
129 }
130 continue;
131try_iso:
Luiz Fernando N. Capitulino4d823dd2006-10-26 13:03:02 -0300132 if (usb_endpoint_dir_in(&e->desc)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 if (!iso_in)
134 iso_in = e;
135 } else {
136 if (!iso_out)
137 iso_out = e;
138 }
139 }
Ming Lei951fd8e2010-08-02 22:09:17 +0800140 if ((in && out) || iso_in || iso_out)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 goto found;
142 }
143 return -EINVAL;
144
145found:
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200146 udev = testdev_to_usbdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 if (alt->desc.bAlternateSetting != 0) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200148 tmp = usb_set_interface(udev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 alt->desc.bInterfaceNumber,
150 alt->desc.bAlternateSetting);
151 if (tmp < 0)
152 return tmp;
153 }
154
155 if (in) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200156 dev->in_pipe = usb_rcvbulkpipe(udev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200158 dev->out_pipe = usb_sndbulkpipe(udev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
160 }
161 if (iso_in) {
162 dev->iso_in = &iso_in->desc;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200163 dev->in_iso_pipe = usb_rcvisocpipe(udev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 iso_in->desc.bEndpointAddress
165 & USB_ENDPOINT_NUMBER_MASK);
Ming Lei951fd8e2010-08-02 22:09:17 +0800166 }
167
168 if (iso_out) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 dev->iso_out = &iso_out->desc;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200170 dev->out_iso_pipe = usb_sndisocpipe(udev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 iso_out->desc.bEndpointAddress
172 & USB_ENDPOINT_NUMBER_MASK);
173 }
174 return 0;
175}
176
177/*-------------------------------------------------------------------------*/
178
179/* Support for testing basic non-queued I/O streams.
180 *
181 * These just package urbs as requests that can be easily canceled.
182 * Each urb's data buffer is dynamically allocated; callers can fill
183 * them with non-zero test data (or test for it) when appropriate.
184 */
185
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200186static void simple_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187{
Ming Leicdc97792008-02-24 18:41:47 +0800188 complete(urb->context);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189}
190
Martin Fuzzey084fb202011-01-16 19:17:11 +0100191static struct urb *usbtest_alloc_urb(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 struct usb_device *udev,
193 int pipe,
Martin Fuzzey084fb202011-01-16 19:17:11 +0100194 unsigned long bytes,
195 unsigned transfer_flags,
196 unsigned offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197{
198 struct urb *urb;
199
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200200 urb = usb_alloc_urb(0, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 if (!urb)
202 return urb;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200203 usb_fill_bulk_urb(urb, udev, pipe, NULL, bytes, simple_callback, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 urb->interval = (udev->speed == USB_SPEED_HIGH)
205 ? (INTERRUPT_RATE << 3)
206 : INTERRUPT_RATE;
Martin Fuzzey084fb202011-01-16 19:17:11 +0100207 urb->transfer_flags = transfer_flags;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200208 if (usb_pipein(pipe))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 urb->transfer_flags |= URB_SHORT_NOT_OK;
Martin Fuzzey084fb202011-01-16 19:17:11 +0100210
211 if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
212 urb->transfer_buffer = usb_alloc_coherent(udev, bytes + offset,
213 GFP_KERNEL, &urb->transfer_dma);
214 else
215 urb->transfer_buffer = kmalloc(bytes + offset, GFP_KERNEL);
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 if (!urb->transfer_buffer) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200218 usb_free_urb(urb);
Martin Fuzzey084fb202011-01-16 19:17:11 +0100219 return NULL;
220 }
221
222 /* To test unaligned transfers add an offset and fill the
223 unused memory with a guard value */
224 if (offset) {
225 memset(urb->transfer_buffer, GUARD_BYTE, offset);
226 urb->transfer_buffer += offset;
227 if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
228 urb->transfer_dma += offset;
229 }
230
231 /* For inbound transfers use guard byte so that test fails if
232 data not correctly copied */
233 memset(urb->transfer_buffer,
234 usb_pipein(urb->pipe) ? GUARD_BYTE : 0,
235 bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 return urb;
237}
238
Martin Fuzzey084fb202011-01-16 19:17:11 +0100239static struct urb *simple_alloc_urb(
240 struct usb_device *udev,
241 int pipe,
242 unsigned long bytes)
243{
244 return usbtest_alloc_urb(udev, pipe, bytes, URB_NO_TRANSFER_DMA_MAP, 0);
245}
246
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200247static unsigned pattern;
Vikram Pandita7f4e9852009-11-09 21:24:32 -0600248static unsigned mod_pattern;
249module_param_named(pattern, mod_pattern, uint, S_IRUGO | S_IWUSR);
250MODULE_PARM_DESC(mod_pattern, "i/o pattern (0 == zeroes)");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200252static inline void simple_fill_buf(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
254 unsigned i;
255 u8 *buf = urb->transfer_buffer;
256 unsigned len = urb->transfer_buffer_length;
257
258 switch (pattern) {
259 default:
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200260 /* FALLTHROUGH */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 case 0:
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200262 memset(buf, 0, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 break;
264 case 1: /* mod63 */
265 for (i = 0; i < len; i++)
266 *buf++ = (u8) (i % 63);
267 break;
268 }
269}
270
Greg Dietsche304b0b52011-05-08 22:51:43 -0500271static inline unsigned long buffer_offset(void *buf)
Martin Fuzzey084fb202011-01-16 19:17:11 +0100272{
Greg Dietsche304b0b52011-05-08 22:51:43 -0500273 return (unsigned long)buf & (ARCH_KMALLOC_MINALIGN - 1);
Martin Fuzzey084fb202011-01-16 19:17:11 +0100274}
275
276static int check_guard_bytes(struct usbtest_dev *tdev, struct urb *urb)
277{
278 u8 *buf = urb->transfer_buffer;
279 u8 *guard = buf - buffer_offset(buf);
280 unsigned i;
281
282 for (i = 0; guard < buf; i++, guard++) {
283 if (*guard != GUARD_BYTE) {
284 ERROR(tdev, "guard byte[%d] %d (not %d)\n",
285 i, *guard, GUARD_BYTE);
286 return -EINVAL;
287 }
288 }
289 return 0;
290}
291
292static int simple_check_buf(struct usbtest_dev *tdev, struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293{
294 unsigned i;
295 u8 expected;
296 u8 *buf = urb->transfer_buffer;
297 unsigned len = urb->actual_length;
298
Martin Fuzzey084fb202011-01-16 19:17:11 +0100299 int ret = check_guard_bytes(tdev, urb);
300 if (ret)
301 return ret;
302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 for (i = 0; i < len; i++, buf++) {
304 switch (pattern) {
305 /* all-zeroes has no synchronization issues */
306 case 0:
307 expected = 0;
308 break;
309 /* mod63 stays in sync with short-terminated transfers,
310 * or otherwise when host and gadget agree on how large
311 * each usb transfer request should be. resync is done
312 * with set_interface or set_config.
313 */
314 case 1: /* mod63 */
315 expected = i % 63;
316 break;
317 /* always fail unsupported patterns */
318 default:
319 expected = !*buf;
320 break;
321 }
322 if (*buf == expected)
323 continue;
David Brownell28ffd792008-04-25 18:51:10 -0700324 ERROR(tdev, "buf[%d] = %d (not %d)\n", i, *buf, expected);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 return -EINVAL;
326 }
327 return 0;
328}
329
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200330static void simple_free_urb(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331{
Greg Dietsche304b0b52011-05-08 22:51:43 -0500332 unsigned long offset = buffer_offset(urb->transfer_buffer);
Martin Fuzzey084fb202011-01-16 19:17:11 +0100333
334 if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
335 usb_free_coherent(
336 urb->dev,
337 urb->transfer_buffer_length + offset,
338 urb->transfer_buffer - offset,
339 urb->transfer_dma - offset);
340 else
341 kfree(urb->transfer_buffer - offset);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200342 usb_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343}
344
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200345static int simple_io(
David Brownell28ffd792008-04-25 18:51:10 -0700346 struct usbtest_dev *tdev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 struct urb *urb,
348 int iterations,
349 int vary,
350 int expected,
351 const char *label
352)
353{
354 struct usb_device *udev = urb->dev;
355 int max = urb->transfer_buffer_length;
356 struct completion completion;
357 int retval = 0;
358
359 urb->context = &completion;
360 while (retval == 0 && iterations-- > 0) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200361 init_completion(&completion);
Sebastian Andrzej Siewior7c79d092011-08-23 10:44:54 +0200362 if (usb_pipeout(urb->pipe)) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200363 simple_fill_buf(urb);
Sebastian Andrzej Siewior7c79d092011-08-23 10:44:54 +0200364 urb->transfer_flags |= URB_ZERO_PACKET;
365 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200366 retval = usb_submit_urb(urb, GFP_KERNEL);
367 if (retval != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 break;
369
370 /* NOTE: no timeouts; can't be broken out of by interrupt */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200371 wait_for_completion(&completion);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 retval = urb->status;
373 urb->dev = udev;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200374 if (retval == 0 && usb_pipein(urb->pipe))
David Brownell28ffd792008-04-25 18:51:10 -0700375 retval = simple_check_buf(tdev, urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
377 if (vary) {
378 int len = urb->transfer_buffer_length;
379
380 len += vary;
381 len %= max;
382 if (len == 0)
383 len = (vary < max) ? vary : max;
384 urb->transfer_buffer_length = len;
385 }
386
387 /* FIXME if endpoint halted, clear halt (and log) */
388 }
389 urb->transfer_buffer_length = max;
390
391 if (expected != retval)
David Brownell28ffd792008-04-25 18:51:10 -0700392 dev_err(&udev->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 "%s failed, iterations left %d, status %d (not %d)\n",
394 label, iterations, retval, expected);
395 return retval;
396}
397
398
399/*-------------------------------------------------------------------------*/
400
401/* We use scatterlist primitives to test queued I/O.
402 * Yes, this also tests the scatterlist primitives.
403 */
404
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200405static void free_sglist(struct scatterlist *sg, int nents)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
407 unsigned i;
David Brownell28ffd792008-04-25 18:51:10 -0700408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 if (!sg)
410 return;
411 for (i = 0; i < nents; i++) {
Jens Axboe45711f12007-10-22 21:19:53 +0200412 if (!sg_page(&sg[i]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 continue;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200414 kfree(sg_virt(&sg[i]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200416 kfree(sg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417}
418
419static struct scatterlist *
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200420alloc_sglist(int nents, int max, int vary)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421{
422 struct scatterlist *sg;
423 unsigned i;
424 unsigned size = max;
425
Xi Wang8bde9a62012-04-09 15:48:45 -0400426 sg = kmalloc_array(nents, sizeof *sg, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 if (!sg)
428 return NULL;
Alan Stern4756feb2008-03-27 10:15:22 -0400429 sg_init_table(sg, nents);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431 for (i = 0; i < nents; i++) {
432 char *buf;
David Brownell8b524902006-04-02 10:20:15 -0800433 unsigned j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200435 buf = kzalloc(size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 if (!buf) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200437 free_sglist(sg, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 return NULL;
439 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440
441 /* kmalloc pages are always physically contiguous! */
Alan Stern4756feb2008-03-27 10:15:22 -0400442 sg_set_buf(&sg[i], buf, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
David Brownell8b524902006-04-02 10:20:15 -0800444 switch (pattern) {
445 case 0:
446 /* already zeroed */
447 break;
448 case 1:
449 for (j = 0; j < size; j++)
450 *buf++ = (u8) (j % 63);
451 break;
452 }
453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 if (vary) {
455 size += vary;
456 size %= max;
457 if (size == 0)
458 size = (vary < max) ? vary : max;
459 }
460 }
461
462 return sg;
463}
464
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200465static int perform_sglist(
David Brownell28ffd792008-04-25 18:51:10 -0700466 struct usbtest_dev *tdev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 unsigned iterations,
468 int pipe,
469 struct usb_sg_request *req,
470 struct scatterlist *sg,
471 int nents
472)
473{
David Brownell28ffd792008-04-25 18:51:10 -0700474 struct usb_device *udev = testdev_to_usbdev(tdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 int retval = 0;
476
477 while (retval == 0 && iterations-- > 0) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200478 retval = usb_sg_init(req, udev, pipe,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 (udev->speed == USB_SPEED_HIGH)
480 ? (INTERRUPT_RATE << 3)
481 : INTERRUPT_RATE,
Christoph Lametere94b1762006-12-06 20:33:17 -0800482 sg, nents, 0, GFP_KERNEL);
David Brownell28ffd792008-04-25 18:51:10 -0700483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 if (retval)
485 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200486 usb_sg_wait(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 retval = req->status;
488
David Brownell8b524902006-04-02 10:20:15 -0800489 /* FIXME check resulting data pattern */
490
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 /* FIXME if endpoint halted, clear halt (and log) */
492 }
493
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200494 /* FIXME for unlink or fault handling tests, don't report
495 * failure if retval is as we expected ...
496 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 if (retval)
David Brownell28ffd792008-04-25 18:51:10 -0700498 ERROR(tdev, "perform_sglist failed, "
499 "iterations left %d, status %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 iterations, retval);
501 return retval;
502}
503
504
505/*-------------------------------------------------------------------------*/
506
507/* unqueued control message testing
508 *
509 * there's a nice set of device functional requirements in chapter 9 of the
510 * usb 2.0 spec, which we can apply to ANY device, even ones that don't use
511 * special test firmware.
512 *
513 * we know the device is configured (or suspended) by the time it's visible
514 * through usbfs. we can't change that, so we won't test enumeration (which
515 * worked 'well enough' to get here, this time), power management (ditto),
516 * or remote wakeup (which needs human interaction).
517 */
518
519static unsigned realworld = 1;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200520module_param(realworld, uint, 0);
521MODULE_PARM_DESC(realworld, "clear to demand stricter spec compliance");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200523static int get_altsetting(struct usbtest_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524{
525 struct usb_interface *iface = dev->intf;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200526 struct usb_device *udev = interface_to_usbdev(iface);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 int retval;
528
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200529 retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 USB_REQ_GET_INTERFACE, USB_DIR_IN|USB_RECIP_INTERFACE,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200531 0, iface->altsetting[0].desc.bInterfaceNumber,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 dev->buf, 1, USB_CTRL_GET_TIMEOUT);
533 switch (retval) {
534 case 1:
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200535 return dev->buf[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 case 0:
537 retval = -ERANGE;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200538 /* FALLTHROUGH */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 default:
540 return retval;
541 }
542}
543
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200544static int set_altsetting(struct usbtest_dev *dev, int alternate)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545{
546 struct usb_interface *iface = dev->intf;
547 struct usb_device *udev;
548
549 if (alternate < 0 || alternate >= 256)
550 return -EINVAL;
551
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200552 udev = interface_to_usbdev(iface);
553 return usb_set_interface(udev,
554 iface->altsetting[0].desc.bInterfaceNumber,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 alternate);
556}
557
David Brownell28ffd792008-04-25 18:51:10 -0700558static int is_good_config(struct usbtest_dev *tdev, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559{
560 struct usb_config_descriptor *config;
David Brownell28ffd792008-04-25 18:51:10 -0700561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 if (len < sizeof *config)
563 return 0;
David Brownell28ffd792008-04-25 18:51:10 -0700564 config = (struct usb_config_descriptor *) tdev->buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
566 switch (config->bDescriptorType) {
567 case USB_DT_CONFIG:
568 case USB_DT_OTHER_SPEED_CONFIG:
569 if (config->bLength != 9) {
David Brownell28ffd792008-04-25 18:51:10 -0700570 ERROR(tdev, "bogus config descriptor length\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 return 0;
572 }
573 /* this bit 'must be 1' but often isn't */
574 if (!realworld && !(config->bmAttributes & 0x80)) {
David Brownell28ffd792008-04-25 18:51:10 -0700575 ERROR(tdev, "high bit of config attributes not set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 return 0;
577 }
578 if (config->bmAttributes & 0x1f) { /* reserved == 0 */
David Brownell28ffd792008-04-25 18:51:10 -0700579 ERROR(tdev, "reserved config bits set\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 return 0;
581 }
582 break;
583 default:
584 return 0;
585 }
586
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200587 if (le16_to_cpu(config->wTotalLength) == len) /* read it all */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 return 1;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200589 if (le16_to_cpu(config->wTotalLength) >= TBUF_SIZE) /* max partial read */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 return 1;
David Brownell28ffd792008-04-25 18:51:10 -0700591 ERROR(tdev, "bogus config descriptor read size\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 return 0;
593}
594
595/* sanity test for standard requests working with usb_control_mesg() and some
596 * of the utility functions which use it.
597 *
598 * this doesn't test how endpoint halts behave or data toggles get set, since
599 * we won't do I/O to bulk/interrupt endpoints here (which is how to change
600 * halt or toggle). toggle testing is impractical without support from hcds.
601 *
602 * this avoids failing devices linux would normally work with, by not testing
603 * config/altsetting operations for devices that only support their defaults.
604 * such devices rarely support those needless operations.
605 *
606 * NOTE that since this is a sanity test, it's not examining boundary cases
607 * to see if usbcore, hcd, and device all behave right. such testing would
608 * involve varied read sizes and other operation sequences.
609 */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200610static int ch9_postconfig(struct usbtest_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611{
612 struct usb_interface *iface = dev->intf;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200613 struct usb_device *udev = interface_to_usbdev(iface);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 int i, alt, retval;
615
616 /* [9.2.3] if there's more than one altsetting, we need to be able to
617 * set and get each one. mostly trusts the descriptors from usbcore.
618 */
619 for (i = 0; i < iface->num_altsetting; i++) {
620
621 /* 9.2.3 constrains the range here */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200622 alt = iface->altsetting[i].desc.bAlternateSetting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 if (alt < 0 || alt >= iface->num_altsetting) {
David Brownell28ffd792008-04-25 18:51:10 -0700624 dev_err(&iface->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 "invalid alt [%d].bAltSetting = %d\n",
626 i, alt);
627 }
628
629 /* [real world] get/set unimplemented if there's only one */
630 if (realworld && iface->num_altsetting == 1)
631 continue;
632
633 /* [9.4.10] set_interface */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200634 retval = set_altsetting(dev, alt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 if (retval) {
David Brownell28ffd792008-04-25 18:51:10 -0700636 dev_err(&iface->dev, "can't set_interface = %d, %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 alt, retval);
638 return retval;
639 }
640
641 /* [9.4.4] get_interface always works */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200642 retval = get_altsetting(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 if (retval != alt) {
David Brownell28ffd792008-04-25 18:51:10 -0700644 dev_err(&iface->dev, "get alt should be %d, was %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 alt, retval);
646 return (retval < 0) ? retval : -EDOM;
647 }
648
649 }
650
651 /* [real world] get_config unimplemented if there's only one */
652 if (!realworld || udev->descriptor.bNumConfigurations != 1) {
653 int expected = udev->actconfig->desc.bConfigurationValue;
654
655 /* [9.4.2] get_configuration always works
656 * ... although some cheap devices (like one TI Hub I've got)
657 * won't return config descriptors except before set_config.
658 */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200659 retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 USB_REQ_GET_CONFIGURATION,
661 USB_DIR_IN | USB_RECIP_DEVICE,
662 0, 0, dev->buf, 1, USB_CTRL_GET_TIMEOUT);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200663 if (retval != 1 || dev->buf[0] != expected) {
David Brownell28ffd792008-04-25 18:51:10 -0700664 dev_err(&iface->dev, "get config --> %d %d (1 %d)\n",
David Brownellff7c79e2005-04-22 13:17:00 -0700665 retval, dev->buf[0], expected);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 return (retval < 0) ? retval : -EDOM;
667 }
668 }
669
670 /* there's always [9.4.3] a device descriptor [9.6.1] */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200671 retval = usb_get_descriptor(udev, USB_DT_DEVICE, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 dev->buf, sizeof udev->descriptor);
673 if (retval != sizeof udev->descriptor) {
David Brownell28ffd792008-04-25 18:51:10 -0700674 dev_err(&iface->dev, "dev descriptor --> %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 return (retval < 0) ? retval : -EDOM;
676 }
677
678 /* there's always [9.4.3] at least one config descriptor [9.6.3] */
679 for (i = 0; i < udev->descriptor.bNumConfigurations; i++) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200680 retval = usb_get_descriptor(udev, USB_DT_CONFIG, i,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 dev->buf, TBUF_SIZE);
David Brownell28ffd792008-04-25 18:51:10 -0700682 if (!is_good_config(dev, retval)) {
683 dev_err(&iface->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 "config [%d] descriptor --> %d\n",
685 i, retval);
686 return (retval < 0) ? retval : -EDOM;
687 }
688
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200689 /* FIXME cross-checking udev->config[i] to make sure usbcore
690 * parsed it right (etc) would be good testing paranoia
691 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 }
693
694 /* and sometimes [9.2.6.6] speed dependent descriptors */
695 if (le16_to_cpu(udev->descriptor.bcdUSB) == 0x0200) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200696 struct usb_qualifier_descriptor *d = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
698 /* device qualifier [9.6.2] */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200699 retval = usb_get_descriptor(udev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 USB_DT_DEVICE_QUALIFIER, 0, dev->buf,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200701 sizeof(struct usb_qualifier_descriptor));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 if (retval == -EPIPE) {
703 if (udev->speed == USB_SPEED_HIGH) {
David Brownell28ffd792008-04-25 18:51:10 -0700704 dev_err(&iface->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 "hs dev qualifier --> %d\n",
706 retval);
707 return (retval < 0) ? retval : -EDOM;
708 }
709 /* usb2.0 but not high-speed capable; fine */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200710 } else if (retval != sizeof(struct usb_qualifier_descriptor)) {
David Brownell28ffd792008-04-25 18:51:10 -0700711 dev_err(&iface->dev, "dev qualifier --> %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 return (retval < 0) ? retval : -EDOM;
713 } else
714 d = (struct usb_qualifier_descriptor *) dev->buf;
715
716 /* might not have [9.6.2] any other-speed configs [9.6.4] */
717 if (d) {
718 unsigned max = d->bNumConfigurations;
719 for (i = 0; i < max; i++) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200720 retval = usb_get_descriptor(udev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 USB_DT_OTHER_SPEED_CONFIG, i,
722 dev->buf, TBUF_SIZE);
David Brownell28ffd792008-04-25 18:51:10 -0700723 if (!is_good_config(dev, retval)) {
724 dev_err(&iface->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 "other speed config --> %d\n",
726 retval);
727 return (retval < 0) ? retval : -EDOM;
728 }
729 }
730 }
731 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200732 /* FIXME fetch strings from at least the device descriptor */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
734 /* [9.4.5] get_status always works */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200735 retval = usb_get_status(udev, USB_RECIP_DEVICE, 0, dev->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 if (retval != 2) {
David Brownell28ffd792008-04-25 18:51:10 -0700737 dev_err(&iface->dev, "get dev status --> %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 return (retval < 0) ? retval : -EDOM;
739 }
740
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200741 /* FIXME configuration.bmAttributes says if we could try to set/clear
742 * the device's remote wakeup feature ... if we can, test that here
743 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200745 retval = usb_get_status(udev, USB_RECIP_INTERFACE,
746 iface->altsetting[0].desc.bInterfaceNumber, dev->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 if (retval != 2) {
David Brownell28ffd792008-04-25 18:51:10 -0700748 dev_err(&iface->dev, "get interface status --> %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 return (retval < 0) ? retval : -EDOM;
750 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200751 /* FIXME get status for each endpoint in the interface */
David Brownell28ffd792008-04-25 18:51:10 -0700752
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 return 0;
754}
755
756/*-------------------------------------------------------------------------*/
757
758/* use ch9 requests to test whether:
759 * (a) queues work for control, keeping N subtests queued and
760 * active (auto-resubmit) for M loops through the queue.
761 * (b) protocol stalls (control-only) will autorecover.
762 * it's not like bulk/intr; no halt clearing.
763 * (c) short control reads are reported and handled.
764 * (d) queues are always processed in-order
765 */
766
767struct ctrl_ctx {
768 spinlock_t lock;
769 struct usbtest_dev *dev;
770 struct completion complete;
771 unsigned count;
772 unsigned pending;
773 int status;
774 struct urb **urb;
775 struct usbtest_param *param;
776 int last;
777};
778
779#define NUM_SUBCASES 15 /* how many test subcases here? */
780
781struct subcase {
782 struct usb_ctrlrequest setup;
783 int number;
784 int expected;
785};
786
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200787static void ctrl_complete(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788{
789 struct ctrl_ctx *ctx = urb->context;
790 struct usb_ctrlrequest *reqp;
791 struct subcase *subcase;
792 int status = urb->status;
793
794 reqp = (struct usb_ctrlrequest *)urb->setup_packet;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200795 subcase = container_of(reqp, struct subcase, setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200797 spin_lock(&ctx->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 ctx->count--;
799 ctx->pending--;
800
801 /* queue must transfer and complete in fifo order, unless
802 * usb_unlink_urb() is used to unlink something not at the
803 * physical queue head (not tested).
804 */
805 if (subcase->number > 0) {
806 if ((subcase->number - ctx->last) != 1) {
David Brownell28ffd792008-04-25 18:51:10 -0700807 ERROR(ctx->dev,
808 "subcase %d completed out of order, last %d\n",
809 subcase->number, ctx->last);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 status = -EDOM;
811 ctx->last = subcase->number;
812 goto error;
813 }
814 }
815 ctx->last = subcase->number;
816
817 /* succeed or fault in only one way? */
818 if (status == subcase->expected)
819 status = 0;
820
821 /* async unlink for cleanup? */
822 else if (status != -ECONNRESET) {
823
824 /* some faults are allowed, not required */
825 if (subcase->expected > 0 && (
Greg Kroah-Hartman59d99782007-07-18 10:58:02 -0700826 ((status == -subcase->expected /* happened */
827 || status == 0)))) /* didn't */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 status = 0;
829 /* sometimes more than one fault is allowed */
830 else if (subcase->number == 12 && status == -EPIPE)
831 status = 0;
832 else
David Brownell28ffd792008-04-25 18:51:10 -0700833 ERROR(ctx->dev, "subtest %d error, status %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 subcase->number, status);
835 }
836
837 /* unexpected status codes mean errors; ideally, in hardware */
838 if (status) {
839error:
840 if (ctx->status == 0) {
841 int i;
842
843 ctx->status = status;
David Brownell28ffd792008-04-25 18:51:10 -0700844 ERROR(ctx->dev, "control queue %02x.%02x, err %d, "
845 "%d left, subcase %d, len %d/%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 reqp->bRequestType, reqp->bRequest,
David Brownell28ffd792008-04-25 18:51:10 -0700847 status, ctx->count, subcase->number,
848 urb->actual_length,
849 urb->transfer_buffer_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
851 /* FIXME this "unlink everything" exit route should
852 * be a separate test case.
853 */
854
855 /* unlink whatever's still pending */
856 for (i = 1; i < ctx->param->sglen; i++) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200857 struct urb *u = ctx->urb[
858 (i + subcase->number)
859 % ctx->param->sglen];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
861 if (u == urb || !u->dev)
862 continue;
Franck Bui-Huucaa2a122006-05-15 19:23:53 +0200863 spin_unlock(&ctx->lock);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200864 status = usb_unlink_urb(u);
Franck Bui-Huucaa2a122006-05-15 19:23:53 +0200865 spin_lock(&ctx->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 switch (status) {
867 case -EINPROGRESS:
868 case -EBUSY:
869 case -EIDRM:
870 continue;
871 default:
David Brownell28ffd792008-04-25 18:51:10 -0700872 ERROR(ctx->dev, "urb unlink --> %d\n",
873 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 }
875 }
876 status = ctx->status;
877 }
878 }
879
880 /* resubmit if we need to, else mark this as done */
881 if ((status == 0) && (ctx->pending < ctx->count)) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200882 status = usb_submit_urb(urb, GFP_ATOMIC);
883 if (status != 0) {
David Brownell28ffd792008-04-25 18:51:10 -0700884 ERROR(ctx->dev,
885 "can't resubmit ctrl %02x.%02x, err %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 reqp->bRequestType, reqp->bRequest, status);
887 urb->dev = NULL;
888 } else
889 ctx->pending++;
890 } else
891 urb->dev = NULL;
David Brownell28ffd792008-04-25 18:51:10 -0700892
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 /* signal completion when nothing's queued */
894 if (ctx->pending == 0)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200895 complete(&ctx->complete);
896 spin_unlock(&ctx->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897}
898
899static int
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200900test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param *param)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901{
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200902 struct usb_device *udev = testdev_to_usbdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 struct urb **urb;
904 struct ctrl_ctx context;
905 int i;
906
Xi Wange65cdfa2012-04-09 15:48:55 -0400907 if (param->sglen == 0 || param->iterations > UINT_MAX / param->sglen)
908 return -EOPNOTSUPP;
909
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200910 spin_lock_init(&context.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 context.dev = dev;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200912 init_completion(&context.complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 context.count = param->sglen * param->iterations;
914 context.pending = 0;
915 context.status = -ENOMEM;
916 context.param = param;
917 context.last = -1;
918
919 /* allocate and init the urbs we'll queue.
920 * as with bulk/intr sglists, sglen is the queue depth; it also
921 * controls which subtests run (more tests than sglen) or rerun.
922 */
Christoph Lametere94b1762006-12-06 20:33:17 -0800923 urb = kcalloc(param->sglen, sizeof(struct urb *), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 if (!urb)
925 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 for (i = 0; i < param->sglen; i++) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200927 int pipe = usb_rcvctrlpipe(udev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 unsigned len;
929 struct urb *u;
930 struct usb_ctrlrequest req;
931 struct subcase *reqp;
Marcin Slusarz6def7552008-05-12 20:17:25 +0200932
933 /* sign of this variable means:
934 * -: tested code must return this (negative) error code
935 * +: tested code may return this (negative too) error code
936 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 int expected = 0;
938
939 /* requests here are mostly expected to succeed on any
940 * device, but some are chosen to trigger protocol stalls
941 * or short reads.
942 */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200943 memset(&req, 0, sizeof req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 req.bRequest = USB_REQ_GET_DESCRIPTOR;
945 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
946
947 switch (i % NUM_SUBCASES) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200948 case 0: /* get device descriptor */
949 req.wValue = cpu_to_le16(USB_DT_DEVICE << 8);
950 len = sizeof(struct usb_device_descriptor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200952 case 1: /* get first config descriptor (only) */
953 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
954 len = sizeof(struct usb_config_descriptor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200956 case 2: /* get altsetting (OFTEN STALLS) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 req.bRequest = USB_REQ_GET_INTERFACE;
958 req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200959 /* index = 0 means first interface */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 len = 1;
961 expected = EPIPE;
962 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200963 case 3: /* get interface status */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 req.bRequest = USB_REQ_GET_STATUS;
965 req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200966 /* interface 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 len = 2;
968 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200969 case 4: /* get device status */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 req.bRequest = USB_REQ_GET_STATUS;
971 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
972 len = 2;
973 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200974 case 5: /* get device qualifier (MAY STALL) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 req.wValue = cpu_to_le16 (USB_DT_DEVICE_QUALIFIER << 8);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200976 len = sizeof(struct usb_qualifier_descriptor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 if (udev->speed != USB_SPEED_HIGH)
978 expected = EPIPE;
979 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200980 case 6: /* get first config descriptor, plus interface */
981 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
982 len = sizeof(struct usb_config_descriptor);
983 len += sizeof(struct usb_interface_descriptor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200985 case 7: /* get interface descriptor (ALWAYS STALLS) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 req.wValue = cpu_to_le16 (USB_DT_INTERFACE << 8);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200987 /* interface == 0 */
988 len = sizeof(struct usb_interface_descriptor);
David Brownell28ffd792008-04-25 18:51:10 -0700989 expected = -EPIPE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200991 /* NOTE: two consecutive stalls in the queue here.
992 * that tests fault recovery a bit more aggressively. */
993 case 8: /* clear endpoint halt (MAY STALL) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 req.bRequest = USB_REQ_CLEAR_FEATURE;
995 req.bRequestType = USB_RECIP_ENDPOINT;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200996 /* wValue 0 == ep halt */
997 /* wIndex 0 == ep0 (shouldn't halt!) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 len = 0;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +0200999 pipe = usb_sndctrlpipe(udev, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 expected = EPIPE;
1001 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001002 case 9: /* get endpoint status */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 req.bRequest = USB_REQ_GET_STATUS;
1004 req.bRequestType = USB_DIR_IN|USB_RECIP_ENDPOINT;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001005 /* endpoint 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 len = 2;
1007 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001008 case 10: /* trigger short read (EREMOTEIO) */
1009 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 len = 1024;
1011 expected = -EREMOTEIO;
1012 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001013 /* NOTE: two consecutive _different_ faults in the queue. */
1014 case 11: /* get endpoint descriptor (ALWAYS STALLS) */
1015 req.wValue = cpu_to_le16(USB_DT_ENDPOINT << 8);
1016 /* endpoint == 0 */
1017 len = sizeof(struct usb_interface_descriptor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 expected = EPIPE;
1019 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001020 /* NOTE: sometimes even a third fault in the queue! */
1021 case 12: /* get string 0 descriptor (MAY STALL) */
1022 req.wValue = cpu_to_le16(USB_DT_STRING << 8);
1023 /* string == 0, for language IDs */
1024 len = sizeof(struct usb_interface_descriptor);
1025 /* may succeed when > 4 languages */
1026 expected = EREMOTEIO; /* or EPIPE, if no strings */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001028 case 13: /* short read, resembling case 10 */
1029 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0);
1030 /* last data packet "should" be DATA1, not DATA0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 len = 1024 - udev->descriptor.bMaxPacketSize0;
1032 expected = -EREMOTEIO;
1033 break;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001034 case 14: /* short read; try to fill the last packet */
1035 req.wValue = cpu_to_le16((USB_DT_DEVICE << 8) | 0);
David Brownell28ffd792008-04-25 18:51:10 -07001036 /* device descriptor size == 18 bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 len = udev->descriptor.bMaxPacketSize0;
Sebastian Andrzej Siewior67e7d642011-04-14 16:17:21 +02001038 if (udev->speed == USB_SPEED_SUPER)
1039 len = 512;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 switch (len) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001041 case 8:
1042 len = 24;
1043 break;
1044 case 16:
1045 len = 32;
1046 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 }
1048 expected = -EREMOTEIO;
1049 break;
1050 default:
David Brownell28ffd792008-04-25 18:51:10 -07001051 ERROR(dev, "bogus number of ctrl queue testcases!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 context.status = -EINVAL;
1053 goto cleanup;
1054 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001055 req.wLength = cpu_to_le16(len);
1056 urb[i] = u = simple_alloc_urb(udev, pipe, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 if (!u)
1058 goto cleanup;
1059
Alan Stern0ede76f2010-03-05 15:10:17 -05001060 reqp = kmalloc(sizeof *reqp, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 if (!reqp)
1062 goto cleanup;
1063 reqp->setup = req;
1064 reqp->number = i % NUM_SUBCASES;
1065 reqp->expected = expected;
1066 u->setup_packet = (char *) &reqp->setup;
1067
1068 u->context = &context;
1069 u->complete = ctrl_complete;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 }
1071
1072 /* queue the urbs */
1073 context.urb = urb;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001074 spin_lock_irq(&context.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 for (i = 0; i < param->sglen; i++) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001076 context.status = usb_submit_urb(urb[i], GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 if (context.status != 0) {
David Brownell28ffd792008-04-25 18:51:10 -07001078 ERROR(dev, "can't submit urb[%d], status %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 i, context.status);
1080 context.count = context.pending;
1081 break;
1082 }
1083 context.pending++;
1084 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001085 spin_unlock_irq(&context.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086
1087 /* FIXME set timer and time out; provide a disconnect hook */
1088
1089 /* wait for the last one to complete */
1090 if (context.pending > 0)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001091 wait_for_completion(&context.complete);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
1093cleanup:
1094 for (i = 0; i < param->sglen; i++) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001095 if (!urb[i])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 continue;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001097 urb[i]->dev = udev;
Alan Stern0ede76f2010-03-05 15:10:17 -05001098 kfree(urb[i]->setup_packet);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001099 simple_free_urb(urb[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001101 kfree(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 return context.status;
1103}
1104#undef NUM_SUBCASES
1105
1106
1107/*-------------------------------------------------------------------------*/
1108
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001109static void unlink1_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110{
1111 int status = urb->status;
1112
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001113 /* we "know" -EPIPE (stall) never happens */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 if (!status)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001115 status = usb_submit_urb(urb, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 if (status) {
1117 urb->status = status;
Ming Leicdc97792008-02-24 18:41:47 +08001118 complete(urb->context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 }
1120}
1121
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001122static int unlink1(struct usbtest_dev *dev, int pipe, int size, int async)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123{
1124 struct urb *urb;
1125 struct completion completion;
1126 int retval = 0;
1127
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001128 init_completion(&completion);
1129 urb = simple_alloc_urb(testdev_to_usbdev(dev), pipe, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 if (!urb)
1131 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 urb->context = &completion;
1133 urb->complete = unlink1_callback;
1134
1135 /* keep the endpoint busy. there are lots of hc/hcd-internal
1136 * states, and testing should get to all of them over time.
1137 *
1138 * FIXME want additional tests for when endpoint is STALLing
1139 * due to errors, or is just NAKing requests.
1140 */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001141 retval = usb_submit_urb(urb, GFP_KERNEL);
1142 if (retval != 0) {
David Brownell28ffd792008-04-25 18:51:10 -07001143 dev_err(&dev->intf->dev, "submit fail %d\n", retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 return retval;
1145 }
1146
1147 /* unlinking that should always work. variable delay tests more
1148 * hcd states and code paths, even with little other system load.
1149 */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001150 msleep(jiffies % (2 * INTERRUPT_RATE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 if (async) {
Martin Fuzzey3b6c0232009-06-04 23:20:38 +02001152 while (!completion_done(&completion)) {
1153 retval = usb_unlink_urb(urb);
1154
1155 switch (retval) {
1156 case -EBUSY:
1157 case -EIDRM:
1158 /* we can't unlink urbs while they're completing
1159 * or if they've completed, and we haven't
1160 * resubmitted. "normal" drivers would prevent
1161 * resubmission, but since we're testing unlink
1162 * paths, we can't.
1163 */
1164 ERROR(dev, "unlink retry\n");
1165 continue;
1166 case 0:
1167 case -EINPROGRESS:
1168 break;
1169
1170 default:
1171 dev_err(&dev->intf->dev,
1172 "unlink fail %d\n", retval);
1173 return retval;
1174 }
1175
1176 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 }
1178 } else
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001179 usb_kill_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001181 wait_for_completion(&completion);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 retval = urb->status;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001183 simple_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
1185 if (async)
1186 return (retval == -ECONNRESET) ? 0 : retval - 1000;
1187 else
1188 return (retval == -ENOENT || retval == -EPERM) ?
1189 0 : retval - 2000;
1190}
1191
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001192static int unlink_simple(struct usbtest_dev *dev, int pipe, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193{
1194 int retval = 0;
1195
1196 /* test sync and async paths */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001197 retval = unlink1(dev, pipe, len, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 if (!retval)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001199 retval = unlink1(dev, pipe, len, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 return retval;
1201}
1202
1203/*-------------------------------------------------------------------------*/
1204
Alan Stern869410f2011-04-14 11:21:04 -04001205struct queued_ctx {
1206 struct completion complete;
1207 atomic_t pending;
1208 unsigned num;
1209 int status;
1210 struct urb **urbs;
1211};
1212
1213static void unlink_queued_callback(struct urb *urb)
1214{
1215 int status = urb->status;
1216 struct queued_ctx *ctx = urb->context;
1217
1218 if (ctx->status)
1219 goto done;
1220 if (urb == ctx->urbs[ctx->num - 4] || urb == ctx->urbs[ctx->num - 2]) {
1221 if (status == -ECONNRESET)
1222 goto done;
1223 /* What error should we report if the URB completed normally? */
1224 }
1225 if (status != 0)
1226 ctx->status = status;
1227
1228 done:
1229 if (atomic_dec_and_test(&ctx->pending))
1230 complete(&ctx->complete);
1231}
1232
1233static int unlink_queued(struct usbtest_dev *dev, int pipe, unsigned num,
1234 unsigned size)
1235{
1236 struct queued_ctx ctx;
1237 struct usb_device *udev = testdev_to_usbdev(dev);
1238 void *buf;
1239 dma_addr_t buf_dma;
1240 int i;
1241 int retval = -ENOMEM;
1242
1243 init_completion(&ctx.complete);
1244 atomic_set(&ctx.pending, 1); /* One more than the actual value */
1245 ctx.num = num;
1246 ctx.status = 0;
1247
1248 buf = usb_alloc_coherent(udev, size, GFP_KERNEL, &buf_dma);
1249 if (!buf)
1250 return retval;
1251 memset(buf, 0, size);
1252
1253 /* Allocate and init the urbs we'll queue */
1254 ctx.urbs = kcalloc(num, sizeof(struct urb *), GFP_KERNEL);
1255 if (!ctx.urbs)
1256 goto free_buf;
1257 for (i = 0; i < num; i++) {
1258 ctx.urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
1259 if (!ctx.urbs[i])
1260 goto free_urbs;
1261 usb_fill_bulk_urb(ctx.urbs[i], udev, pipe, buf, size,
1262 unlink_queued_callback, &ctx);
1263 ctx.urbs[i]->transfer_dma = buf_dma;
1264 ctx.urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1265 }
1266
1267 /* Submit all the URBs and then unlink URBs num - 4 and num - 2. */
1268 for (i = 0; i < num; i++) {
1269 atomic_inc(&ctx.pending);
1270 retval = usb_submit_urb(ctx.urbs[i], GFP_KERNEL);
1271 if (retval != 0) {
1272 dev_err(&dev->intf->dev, "submit urbs[%d] fail %d\n",
1273 i, retval);
1274 atomic_dec(&ctx.pending);
1275 ctx.status = retval;
1276 break;
1277 }
1278 }
1279 if (i == num) {
1280 usb_unlink_urb(ctx.urbs[num - 4]);
1281 usb_unlink_urb(ctx.urbs[num - 2]);
1282 } else {
1283 while (--i >= 0)
1284 usb_unlink_urb(ctx.urbs[i]);
1285 }
1286
1287 if (atomic_dec_and_test(&ctx.pending)) /* The extra count */
1288 complete(&ctx.complete);
1289 wait_for_completion(&ctx.complete);
1290 retval = ctx.status;
1291
1292 free_urbs:
1293 for (i = 0; i < num; i++)
1294 usb_free_urb(ctx.urbs[i]);
1295 kfree(ctx.urbs);
1296 free_buf:
1297 usb_free_coherent(udev, size, buf, buf_dma);
1298 return retval;
1299}
1300
1301/*-------------------------------------------------------------------------*/
1302
David Brownell28ffd792008-04-25 18:51:10 -07001303static int verify_not_halted(struct usbtest_dev *tdev, int ep, struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304{
1305 int retval;
1306 u16 status;
1307
1308 /* shouldn't look or act halted */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001309 retval = usb_get_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 if (retval < 0) {
David Brownell28ffd792008-04-25 18:51:10 -07001311 ERROR(tdev, "ep %02x couldn't get no-halt status, %d\n",
1312 ep, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 return retval;
1314 }
1315 if (status != 0) {
David Brownell28ffd792008-04-25 18:51:10 -07001316 ERROR(tdev, "ep %02x bogus status: %04x != 0\n", ep, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 return -EINVAL;
1318 }
David Brownell28ffd792008-04-25 18:51:10 -07001319 retval = simple_io(tdev, urb, 1, 0, 0, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 if (retval != 0)
1321 return -EINVAL;
1322 return 0;
1323}
1324
David Brownell28ffd792008-04-25 18:51:10 -07001325static int verify_halted(struct usbtest_dev *tdev, int ep, struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326{
1327 int retval;
1328 u16 status;
1329
1330 /* should look and act halted */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001331 retval = usb_get_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 if (retval < 0) {
David Brownell28ffd792008-04-25 18:51:10 -07001333 ERROR(tdev, "ep %02x couldn't get halt status, %d\n",
1334 ep, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 return retval;
1336 }
Jan Andersson6ce45602008-01-08 16:39:49 +01001337 le16_to_cpus(&status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 if (status != 1) {
David Brownell28ffd792008-04-25 18:51:10 -07001339 ERROR(tdev, "ep %02x bogus status: %04x != 1\n", ep, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 return -EINVAL;
1341 }
David Brownell28ffd792008-04-25 18:51:10 -07001342 retval = simple_io(tdev, urb, 1, 0, -EPIPE, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 if (retval != -EPIPE)
1344 return -EINVAL;
David Brownell28ffd792008-04-25 18:51:10 -07001345 retval = simple_io(tdev, urb, 1, 0, -EPIPE, "verify_still_halted");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 if (retval != -EPIPE)
1347 return -EINVAL;
1348 return 0;
1349}
1350
David Brownell28ffd792008-04-25 18:51:10 -07001351static int test_halt(struct usbtest_dev *tdev, int ep, struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352{
1353 int retval;
1354
1355 /* shouldn't look or act halted now */
David Brownell28ffd792008-04-25 18:51:10 -07001356 retval = verify_not_halted(tdev, ep, urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 if (retval < 0)
1358 return retval;
1359
1360 /* set halt (protocol test only), verify it worked */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001361 retval = usb_control_msg(urb->dev, usb_sndctrlpipe(urb->dev, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 USB_REQ_SET_FEATURE, USB_RECIP_ENDPOINT,
1363 USB_ENDPOINT_HALT, ep,
1364 NULL, 0, USB_CTRL_SET_TIMEOUT);
1365 if (retval < 0) {
David Brownell28ffd792008-04-25 18:51:10 -07001366 ERROR(tdev, "ep %02x couldn't set halt, %d\n", ep, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 return retval;
1368 }
David Brownell28ffd792008-04-25 18:51:10 -07001369 retval = verify_halted(tdev, ep, urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 if (retval < 0)
1371 return retval;
1372
1373 /* clear halt (tests API + protocol), verify it worked */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001374 retval = usb_clear_halt(urb->dev, urb->pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 if (retval < 0) {
David Brownell28ffd792008-04-25 18:51:10 -07001376 ERROR(tdev, "ep %02x couldn't clear halt, %d\n", ep, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 return retval;
1378 }
David Brownell28ffd792008-04-25 18:51:10 -07001379 retval = verify_not_halted(tdev, ep, urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 if (retval < 0)
1381 return retval;
1382
1383 /* NOTE: could also verify SET_INTERFACE clear halts ... */
1384
1385 return 0;
1386}
1387
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001388static int halt_simple(struct usbtest_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389{
1390 int ep;
1391 int retval = 0;
1392 struct urb *urb;
1393
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001394 urb = simple_alloc_urb(testdev_to_usbdev(dev), 0, 512);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 if (urb == NULL)
1396 return -ENOMEM;
1397
1398 if (dev->in_pipe) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001399 ep = usb_pipeendpoint(dev->in_pipe) | USB_DIR_IN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 urb->pipe = dev->in_pipe;
David Brownell28ffd792008-04-25 18:51:10 -07001401 retval = test_halt(dev, ep, urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 if (retval < 0)
1403 goto done;
1404 }
1405
1406 if (dev->out_pipe) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001407 ep = usb_pipeendpoint(dev->out_pipe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 urb->pipe = dev->out_pipe;
David Brownell28ffd792008-04-25 18:51:10 -07001409 retval = test_halt(dev, ep, urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 }
1411done:
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001412 simple_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 return retval;
1414}
1415
1416/*-------------------------------------------------------------------------*/
1417
1418/* Control OUT tests use the vendor control requests from Intel's
1419 * USB 2.0 compliance test device: write a buffer, read it back.
1420 *
1421 * Intel's spec only _requires_ that it work for one packet, which
1422 * is pretty weak. Some HCDs place limits here; most devices will
1423 * need to be able to handle more than one OUT data packet. We'll
1424 * try whatever we're told to try.
1425 */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001426static int ctrl_out(struct usbtest_dev *dev,
Martin Fuzzey084fb202011-01-16 19:17:11 +01001427 unsigned count, unsigned length, unsigned vary, unsigned offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428{
Orjan Fribergf54fa842006-08-08 23:31:40 -07001429 unsigned i, j, len;
1430 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 u8 *buf;
1432 char *what = "?";
1433 struct usb_device *udev;
Orjan Fribergf54fa842006-08-08 23:31:40 -07001434
David Brownellff7c79e2005-04-22 13:17:00 -07001435 if (length < 1 || length > 0xffff || vary >= length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 return -EINVAL;
1437
Martin Fuzzey084fb202011-01-16 19:17:11 +01001438 buf = kmalloc(length + offset, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 if (!buf)
1440 return -ENOMEM;
1441
Martin Fuzzey084fb202011-01-16 19:17:11 +01001442 buf += offset;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001443 udev = testdev_to_usbdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 len = length;
1445 retval = 0;
1446
1447 /* NOTE: hardware might well act differently if we pushed it
1448 * with lots back-to-back queued requests.
1449 */
1450 for (i = 0; i < count; i++) {
1451 /* write patterned data */
1452 for (j = 0; j < len; j++)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001453 buf[j] = i + j;
1454 retval = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 0x5b, USB_DIR_OUT|USB_TYPE_VENDOR,
1456 0, 0, buf, len, USB_CTRL_SET_TIMEOUT);
1457 if (retval != len) {
1458 what = "write";
David Brownellff7c79e2005-04-22 13:17:00 -07001459 if (retval >= 0) {
David Brownell28ffd792008-04-25 18:51:10 -07001460 ERROR(dev, "ctrl_out, wlen %d (expected %d)\n",
David Brownellff7c79e2005-04-22 13:17:00 -07001461 retval, len);
1462 retval = -EBADMSG;
1463 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 break;
1465 }
1466
1467 /* read it back -- assuming nothing intervened!! */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001468 retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 0x5c, USB_DIR_IN|USB_TYPE_VENDOR,
1470 0, 0, buf, len, USB_CTRL_GET_TIMEOUT);
1471 if (retval != len) {
1472 what = "read";
David Brownellff7c79e2005-04-22 13:17:00 -07001473 if (retval >= 0) {
David Brownell28ffd792008-04-25 18:51:10 -07001474 ERROR(dev, "ctrl_out, rlen %d (expected %d)\n",
David Brownellff7c79e2005-04-22 13:17:00 -07001475 retval, len);
1476 retval = -EBADMSG;
1477 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 break;
1479 }
1480
1481 /* fail if we can't verify */
1482 for (j = 0; j < len; j++) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001483 if (buf[j] != (u8) (i + j)) {
David Brownell28ffd792008-04-25 18:51:10 -07001484 ERROR(dev, "ctrl_out, byte %d is %d not %d\n",
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001485 j, buf[j], (u8) i + j);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 retval = -EBADMSG;
1487 break;
1488 }
1489 }
1490 if (retval < 0) {
1491 what = "verify";
1492 break;
1493 }
1494
1495 len += vary;
David Brownellff7c79e2005-04-22 13:17:00 -07001496
1497 /* [real world] the "zero bytes IN" case isn't really used.
Joe Perchesdc0d5c12007-12-17 11:40:18 -08001498 * hardware can easily trip up in this weird case, since its
David Brownellff7c79e2005-04-22 13:17:00 -07001499 * status stage is IN, not OUT like other ep0in transfers.
1500 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 if (len > length)
David Brownellff7c79e2005-04-22 13:17:00 -07001502 len = realworld ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 }
1504
1505 if (retval < 0)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001506 ERROR(dev, "ctrl_out %s failed, code %d, count %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 what, retval, i);
1508
Martin Fuzzey084fb202011-01-16 19:17:11 +01001509 kfree(buf - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 return retval;
1511}
1512
1513/*-------------------------------------------------------------------------*/
1514
1515/* ISO tests ... mimics common usage
1516 * - buffer length is split into N packets (mostly maxpacket sized)
1517 * - multi-buffers according to sglen
1518 */
1519
1520struct iso_context {
1521 unsigned count;
1522 unsigned pending;
1523 spinlock_t lock;
1524 struct completion done;
Alan Stern9da21502006-05-22 16:47:13 -04001525 int submit_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 unsigned long errors;
Alan Stern9da21502006-05-22 16:47:13 -04001527 unsigned long packet_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 struct usbtest_dev *dev;
1529};
1530
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001531static void iso_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532{
1533 struct iso_context *ctx = urb->context;
1534
1535 spin_lock(&ctx->lock);
1536 ctx->count--;
1537
Alan Stern9da21502006-05-22 16:47:13 -04001538 ctx->packet_count += urb->number_of_packets;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 if (urb->error_count > 0)
1540 ctx->errors += urb->error_count;
Alan Stern9da21502006-05-22 16:47:13 -04001541 else if (urb->status != 0)
1542 ctx->errors += urb->number_of_packets;
Martin Fuzzey40aed522010-10-01 00:20:48 +02001543 else if (urb->actual_length != urb->transfer_buffer_length)
1544 ctx->errors++;
Martin Fuzzey084fb202011-01-16 19:17:11 +01001545 else if (check_guard_bytes(ctx->dev, urb) != 0)
1546 ctx->errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547
Alan Stern9da21502006-05-22 16:47:13 -04001548 if (urb->status == 0 && ctx->count > (ctx->pending - 1)
1549 && !ctx->submit_error) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001550 int status = usb_submit_urb(urb, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 switch (status) {
1552 case 0:
1553 goto done;
1554 default:
David Brownell28ffd792008-04-25 18:51:10 -07001555 dev_err(&ctx->dev->intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 "iso resubmit err %d\n",
1557 status);
1558 /* FALLTHROUGH */
1559 case -ENODEV: /* disconnected */
Alan Stern9da21502006-05-22 16:47:13 -04001560 case -ESHUTDOWN: /* endpoint disabled */
1561 ctx->submit_error = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 break;
1563 }
1564 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565
1566 ctx->pending--;
1567 if (ctx->pending == 0) {
1568 if (ctx->errors)
David Brownell28ffd792008-04-25 18:51:10 -07001569 dev_err(&ctx->dev->intf->dev,
Alan Stern9da21502006-05-22 16:47:13 -04001570 "iso test, %lu errors out of %lu\n",
1571 ctx->errors, ctx->packet_count);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001572 complete(&ctx->done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 }
1574done:
1575 spin_unlock(&ctx->lock);
1576}
1577
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001578static struct urb *iso_alloc_urb(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 struct usb_device *udev,
1580 int pipe,
1581 struct usb_endpoint_descriptor *desc,
Martin Fuzzey084fb202011-01-16 19:17:11 +01001582 long bytes,
1583 unsigned offset
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584)
1585{
1586 struct urb *urb;
1587 unsigned i, maxp, packets;
1588
1589 if (bytes < 0 || !desc)
1590 return NULL;
Kuninori Morimoto29cc8892011-08-23 03:12:03 -07001591 maxp = 0x7ff & usb_endpoint_maxp(desc);
1592 maxp *= 1 + (0x3 & (usb_endpoint_maxp(desc) >> 11));
Julia Lawalldfa5ec72008-03-04 15:25:11 -08001593 packets = DIV_ROUND_UP(bytes, maxp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001595 urb = usb_alloc_urb(packets, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 if (!urb)
1597 return urb;
1598 urb->dev = udev;
1599 urb->pipe = pipe;
1600
1601 urb->number_of_packets = packets;
1602 urb->transfer_buffer_length = bytes;
Martin Fuzzey084fb202011-01-16 19:17:11 +01001603 urb->transfer_buffer = usb_alloc_coherent(udev, bytes + offset,
1604 GFP_KERNEL,
1605 &urb->transfer_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 if (!urb->transfer_buffer) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001607 usb_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 return NULL;
1609 }
Martin Fuzzey084fb202011-01-16 19:17:11 +01001610 if (offset) {
1611 memset(urb->transfer_buffer, GUARD_BYTE, offset);
1612 urb->transfer_buffer += offset;
1613 urb->transfer_dma += offset;
1614 }
1615 /* For inbound transfers use guard byte so that test fails if
1616 data not correctly copied */
1617 memset(urb->transfer_buffer,
1618 usb_pipein(urb->pipe) ? GUARD_BYTE : 0,
1619 bytes);
1620
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 for (i = 0; i < packets; i++) {
1622 /* here, only the last packet will be short */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001623 urb->iso_frame_desc[i].length = min((unsigned) bytes, maxp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 bytes -= urb->iso_frame_desc[i].length;
1625
1626 urb->iso_frame_desc[i].offset = maxp * i;
1627 }
1628
1629 urb->complete = iso_callback;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001630 /* urb->context = SET BY CALLER */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 urb->interval = 1 << (desc->bInterval - 1);
1632 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1633 return urb;
1634}
1635
1636static int
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001637test_iso_queue(struct usbtest_dev *dev, struct usbtest_param *param,
Martin Fuzzey084fb202011-01-16 19:17:11 +01001638 int pipe, struct usb_endpoint_descriptor *desc, unsigned offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639{
1640 struct iso_context context;
1641 struct usb_device *udev;
1642 unsigned i;
1643 unsigned long packets = 0;
Alan Stern9da21502006-05-22 16:47:13 -04001644 int status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 struct urb *urbs[10]; /* FIXME no limit */
1646
1647 if (param->sglen > 10)
1648 return -EDOM;
1649
Alan Stern9da21502006-05-22 16:47:13 -04001650 memset(&context, 0, sizeof context);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 context.count = param->iterations * param->sglen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 context.dev = dev;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001653 init_completion(&context.done);
1654 spin_lock_init(&context.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001656 memset(urbs, 0, sizeof urbs);
1657 udev = testdev_to_usbdev(dev);
David Brownell28ffd792008-04-25 18:51:10 -07001658 dev_info(&dev->intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 "... iso period %d %sframes, wMaxPacket %04x\n",
1660 1 << (desc->bInterval - 1),
1661 (udev->speed == USB_SPEED_HIGH) ? "micro" : "",
Kuninori Morimoto29cc8892011-08-23 03:12:03 -07001662 usb_endpoint_maxp(desc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
1664 for (i = 0; i < param->sglen; i++) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001665 urbs[i] = iso_alloc_urb(udev, pipe, desc,
Martin Fuzzey084fb202011-01-16 19:17:11 +01001666 param->length, offset);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001667 if (!urbs[i]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 status = -ENOMEM;
1669 goto fail;
1670 }
1671 packets += urbs[i]->number_of_packets;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001672 urbs[i]->context = &context;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 }
1674 packets *= param->iterations;
David Brownell28ffd792008-04-25 18:51:10 -07001675 dev_info(&dev->intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 "... total %lu msec (%lu packets)\n",
1677 (packets * (1 << (desc->bInterval - 1)))
1678 / ((udev->speed == USB_SPEED_HIGH) ? 8 : 1),
1679 packets);
1680
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001681 spin_lock_irq(&context.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 for (i = 0; i < param->sglen; i++) {
Alan Stern9da21502006-05-22 16:47:13 -04001683 ++context.pending;
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001684 status = usb_submit_urb(urbs[i], GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 if (status < 0) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001686 ERROR(dev, "submit iso[%d], error %d\n", i, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 if (i == 0) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001688 spin_unlock_irq(&context.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 goto fail;
1690 }
1691
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001692 simple_free_urb(urbs[i]);
Ming Leie10e1be2010-08-02 22:09:01 +08001693 urbs[i] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 context.pending--;
Alan Stern9da21502006-05-22 16:47:13 -04001695 context.submit_error = 1;
1696 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 }
1698 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001699 spin_unlock_irq(&context.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001701 wait_for_completion(&context.done);
Alan Stern9da21502006-05-22 16:47:13 -04001702
Ming Leie10e1be2010-08-02 22:09:01 +08001703 for (i = 0; i < param->sglen; i++) {
1704 if (urbs[i])
1705 simple_free_urb(urbs[i]);
1706 }
Alan Stern9da21502006-05-22 16:47:13 -04001707 /*
1708 * Isochronous transfers are expected to fail sometimes. As an
1709 * arbitrary limit, we will report an error if any submissions
1710 * fail or if the transfer failure rate is > 10%.
1711 */
1712 if (status != 0)
1713 ;
1714 else if (context.submit_error)
1715 status = -EACCES;
1716 else if (context.errors > context.packet_count / 10)
1717 status = -EIO;
1718 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719
1720fail:
1721 for (i = 0; i < param->sglen; i++) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001722 if (urbs[i])
1723 simple_free_urb(urbs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 }
1725 return status;
1726}
1727
Martin Fuzzey084fb202011-01-16 19:17:11 +01001728static int test_unaligned_bulk(
1729 struct usbtest_dev *tdev,
1730 int pipe,
1731 unsigned length,
1732 int iterations,
1733 unsigned transfer_flags,
1734 const char *label)
1735{
1736 int retval;
1737 struct urb *urb = usbtest_alloc_urb(
1738 testdev_to_usbdev(tdev), pipe, length, transfer_flags, 1);
1739
1740 if (!urb)
1741 return -ENOMEM;
1742
1743 retval = simple_io(tdev, urb, iterations, 0, 0, label);
1744 simple_free_urb(urb);
1745 return retval;
1746}
1747
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748/*-------------------------------------------------------------------------*/
1749
1750/* We only have this one interface to user space, through usbfs.
1751 * User mode code can scan usbfs to find N different devices (maybe on
1752 * different busses) to use when testing, and allocate one thread per
1753 * test. So discovery is simplified, and we have no device naming issues.
1754 *
1755 * Don't use these only as stress/load tests. Use them along with with
1756 * other USB bus activity: plugging, unplugging, mousing, mp3 playback,
1757 * video capture, and so on. Run different tests at different times, in
1758 * different sequences. Nothing here should interact with other devices,
1759 * except indirectly by consuming USB bandwidth and CPU resources for test
1760 * threads and request completion. But the only way to know that for sure
1761 * is to test when HC queues are in use by many devices.
David Brownell28ffd792008-04-25 18:51:10 -07001762 *
1763 * WARNING: Because usbfs grabs udev->dev.sem before calling this ioctl(),
1764 * it locks out usbcore in certain code paths. Notably, if you disconnect
1765 * the device-under-test, khubd will wait block forever waiting for the
1766 * ioctl to complete ... so that usb_disconnect() can abort the pending
1767 * urbs and then call usbtest_disconnect(). To abort a test, you're best
1768 * off just killing the userspace task and waiting for it to exit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 */
1770
1771static int
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001772usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773{
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001774 struct usbtest_dev *dev = usb_get_intfdata(intf);
1775 struct usb_device *udev = testdev_to_usbdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 struct usbtest_param *param = buf;
1777 int retval = -EOPNOTSUPP;
1778 struct urb *urb;
1779 struct scatterlist *sg;
1780 struct usb_sg_request req;
1781 struct timeval start;
1782 unsigned i;
1783
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001784 /* FIXME USBDEVFS_CONNECTINFO doesn't say how fast the device is. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785
Vikram Pandita7f4e9852009-11-09 21:24:32 -06001786 pattern = mod_pattern;
1787
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 if (code != USBTEST_REQUEST)
1789 return -EOPNOTSUPP;
1790
roel kluin8aafdf62008-10-21 00:36:44 -04001791 if (param->iterations <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 return -EINVAL;
1793
Matthias Kaehlcke1cfab022007-12-13 16:15:33 -08001794 if (mutex_lock_interruptible(&dev->lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 return -ERESTARTSYS;
1796
Alan Stern70a1c9e2008-03-06 17:00:58 -05001797 /* FIXME: What if a system sleep starts while a test is running? */
David Brownellff7c79e2005-04-22 13:17:00 -07001798
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 /* some devices, like ez-usb default devices, need a non-default
1800 * altsetting to have any active endpoints. some tests change
1801 * altsettings; force a default so most tests don't need to check.
1802 */
1803 if (dev->info->alt >= 0) {
David Brownell28ffd792008-04-25 18:51:10 -07001804 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805
1806 if (intf->altsetting->desc.bInterfaceNumber) {
Matthias Kaehlcke1cfab022007-12-13 16:15:33 -08001807 mutex_unlock(&dev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 return -ENODEV;
1809 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001810 res = set_altsetting(dev, dev->info->alt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 if (res) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001812 dev_err(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 "set altsetting to %d failed, %d\n",
1814 dev->info->alt, res);
Matthias Kaehlcke1cfab022007-12-13 16:15:33 -08001815 mutex_unlock(&dev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 return res;
1817 }
1818 }
1819
1820 /*
1821 * Just a bunch of test cases that every HCD is expected to handle.
1822 *
1823 * Some may need specific firmware, though it'd be good to have
1824 * one firmware image to handle all the test cases.
1825 *
1826 * FIXME add more tests! cancel requests, verify the data, control
1827 * queueing, concurrent read+write threads, and so on.
1828 */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001829 do_gettimeofday(&start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 switch (param->test_num) {
1831
1832 case 0:
David Brownell28ffd792008-04-25 18:51:10 -07001833 dev_info(&intf->dev, "TEST 0: NOP\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 retval = 0;
1835 break;
1836
1837 /* Simple non-queued bulk I/O tests */
1838 case 1:
1839 if (dev->out_pipe == 0)
1840 break;
David Brownell28ffd792008-04-25 18:51:10 -07001841 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 "TEST 1: write %d bytes %u times\n",
1843 param->length, param->iterations);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001844 urb = simple_alloc_urb(udev, dev->out_pipe, param->length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 if (!urb) {
1846 retval = -ENOMEM;
1847 break;
1848 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001849 /* FIRMWARE: bulk sink (maybe accepts short writes) */
David Brownell28ffd792008-04-25 18:51:10 -07001850 retval = simple_io(dev, urb, param->iterations, 0, 0, "test1");
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001851 simple_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 break;
1853 case 2:
1854 if (dev->in_pipe == 0)
1855 break;
David Brownell28ffd792008-04-25 18:51:10 -07001856 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 "TEST 2: read %d bytes %u times\n",
1858 param->length, param->iterations);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001859 urb = simple_alloc_urb(udev, dev->in_pipe, param->length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 if (!urb) {
1861 retval = -ENOMEM;
1862 break;
1863 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001864 /* FIRMWARE: bulk source (maybe generates short writes) */
David Brownell28ffd792008-04-25 18:51:10 -07001865 retval = simple_io(dev, urb, param->iterations, 0, 0, "test2");
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001866 simple_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 break;
1868 case 3:
1869 if (dev->out_pipe == 0 || param->vary == 0)
1870 break;
David Brownell28ffd792008-04-25 18:51:10 -07001871 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 "TEST 3: write/%d 0..%d bytes %u times\n",
1873 param->vary, param->length, param->iterations);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001874 urb = simple_alloc_urb(udev, dev->out_pipe, param->length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 if (!urb) {
1876 retval = -ENOMEM;
1877 break;
1878 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001879 /* FIRMWARE: bulk sink (maybe accepts short writes) */
David Brownell28ffd792008-04-25 18:51:10 -07001880 retval = simple_io(dev, urb, param->iterations, param->vary,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 0, "test3");
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001882 simple_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 break;
1884 case 4:
1885 if (dev->in_pipe == 0 || param->vary == 0)
1886 break;
David Brownell28ffd792008-04-25 18:51:10 -07001887 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 "TEST 4: read/%d 0..%d bytes %u times\n",
1889 param->vary, param->length, param->iterations);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001890 urb = simple_alloc_urb(udev, dev->in_pipe, param->length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 if (!urb) {
1892 retval = -ENOMEM;
1893 break;
1894 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001895 /* FIRMWARE: bulk source (maybe generates short writes) */
David Brownell28ffd792008-04-25 18:51:10 -07001896 retval = simple_io(dev, urb, param->iterations, param->vary,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 0, "test4");
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001898 simple_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 break;
1900
1901 /* Queued bulk I/O tests */
1902 case 5:
1903 if (dev->out_pipe == 0 || param->sglen == 0)
1904 break;
David Brownell28ffd792008-04-25 18:51:10 -07001905 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 "TEST 5: write %d sglists %d entries of %d bytes\n",
1907 param->iterations,
1908 param->sglen, param->length);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001909 sg = alloc_sglist(param->sglen, param->length, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 if (!sg) {
1911 retval = -ENOMEM;
1912 break;
1913 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001914 /* FIRMWARE: bulk sink (maybe accepts short writes) */
David Brownell28ffd792008-04-25 18:51:10 -07001915 retval = perform_sglist(dev, param->iterations, dev->out_pipe,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 &req, sg, param->sglen);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001917 free_sglist(sg, param->sglen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 break;
1919
1920 case 6:
1921 if (dev->in_pipe == 0 || param->sglen == 0)
1922 break;
David Brownell28ffd792008-04-25 18:51:10 -07001923 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 "TEST 6: read %d sglists %d entries of %d bytes\n",
1925 param->iterations,
1926 param->sglen, param->length);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001927 sg = alloc_sglist(param->sglen, param->length, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 if (!sg) {
1929 retval = -ENOMEM;
1930 break;
1931 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001932 /* FIRMWARE: bulk source (maybe generates short writes) */
David Brownell28ffd792008-04-25 18:51:10 -07001933 retval = perform_sglist(dev, param->iterations, dev->in_pipe,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 &req, sg, param->sglen);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001935 free_sglist(sg, param->sglen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 break;
1937 case 7:
1938 if (dev->out_pipe == 0 || param->sglen == 0 || param->vary == 0)
1939 break;
David Brownell28ffd792008-04-25 18:51:10 -07001940 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 "TEST 7: write/%d %d sglists %d entries 0..%d bytes\n",
1942 param->vary, param->iterations,
1943 param->sglen, param->length);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001944 sg = alloc_sglist(param->sglen, param->length, param->vary);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 if (!sg) {
1946 retval = -ENOMEM;
1947 break;
1948 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001949 /* FIRMWARE: bulk sink (maybe accepts short writes) */
David Brownell28ffd792008-04-25 18:51:10 -07001950 retval = perform_sglist(dev, param->iterations, dev->out_pipe,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 &req, sg, param->sglen);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001952 free_sglist(sg, param->sglen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 break;
1954 case 8:
1955 if (dev->in_pipe == 0 || param->sglen == 0 || param->vary == 0)
1956 break;
David Brownell28ffd792008-04-25 18:51:10 -07001957 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 "TEST 8: read/%d %d sglists %d entries 0..%d bytes\n",
1959 param->vary, param->iterations,
1960 param->sglen, param->length);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001961 sg = alloc_sglist(param->sglen, param->length, param->vary);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962 if (!sg) {
1963 retval = -ENOMEM;
1964 break;
1965 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001966 /* FIRMWARE: bulk source (maybe generates short writes) */
David Brownell28ffd792008-04-25 18:51:10 -07001967 retval = perform_sglist(dev, param->iterations, dev->in_pipe,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 &req, sg, param->sglen);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001969 free_sglist(sg, param->sglen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 break;
1971
1972 /* non-queued sanity tests for control (chapter 9 subset) */
1973 case 9:
1974 retval = 0;
David Brownell28ffd792008-04-25 18:51:10 -07001975 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 "TEST 9: ch9 (subset) control tests, %d times\n",
1977 param->iterations);
1978 for (i = param->iterations; retval == 0 && i--; /* NOP */)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001979 retval = ch9_postconfig(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980 if (retval)
David Brownell28ffd792008-04-25 18:51:10 -07001981 dev_err(&intf->dev, "ch9 subset failed, "
1982 "iterations left %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 break;
1984
1985 /* queued control messaging */
1986 case 10:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 retval = 0;
David Brownell28ffd792008-04-25 18:51:10 -07001988 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 "TEST 10: queue %d control calls, %d times\n",
1990 param->sglen,
1991 param->iterations);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02001992 retval = test_ctrl_queue(dev, param);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 break;
1994
1995 /* simple non-queued unlinks (ring with one urb) */
1996 case 11:
1997 if (dev->in_pipe == 0 || !param->length)
1998 break;
1999 retval = 0;
David Brownell28ffd792008-04-25 18:51:10 -07002000 dev_info(&intf->dev, "TEST 11: unlink %d reads of %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 param->iterations, param->length);
2002 for (i = param->iterations; retval == 0 && i--; /* NOP */)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002003 retval = unlink_simple(dev, dev->in_pipe,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 param->length);
2005 if (retval)
David Brownell28ffd792008-04-25 18:51:10 -07002006 dev_err(&intf->dev, "unlink reads failed %d, "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 "iterations left %d\n", retval, i);
2008 break;
2009 case 12:
2010 if (dev->out_pipe == 0 || !param->length)
2011 break;
2012 retval = 0;
David Brownell28ffd792008-04-25 18:51:10 -07002013 dev_info(&intf->dev, "TEST 12: unlink %d writes of %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 param->iterations, param->length);
2015 for (i = param->iterations; retval == 0 && i--; /* NOP */)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002016 retval = unlink_simple(dev, dev->out_pipe,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 param->length);
2018 if (retval)
David Brownell28ffd792008-04-25 18:51:10 -07002019 dev_err(&intf->dev, "unlink writes failed %d, "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 "iterations left %d\n", retval, i);
2021 break;
2022
2023 /* ep halt tests */
2024 case 13:
2025 if (dev->out_pipe == 0 && dev->in_pipe == 0)
2026 break;
2027 retval = 0;
David Brownell28ffd792008-04-25 18:51:10 -07002028 dev_info(&intf->dev, "TEST 13: set/clear %d halts\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 param->iterations);
2030 for (i = param->iterations; retval == 0 && i--; /* NOP */)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002031 retval = halt_simple(dev);
David Brownell28ffd792008-04-25 18:51:10 -07002032
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 if (retval)
David Brownell28ffd792008-04-25 18:51:10 -07002034 ERROR(dev, "halts failed, iterations left %d\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 break;
2036
2037 /* control write tests */
2038 case 14:
2039 if (!dev->info->ctrl_out)
2040 break;
David Brownell28ffd792008-04-25 18:51:10 -07002041 dev_info(&intf->dev, "TEST 14: %d ep0out, %d..%d vary %d\n",
David Brownellff7c79e2005-04-22 13:17:00 -07002042 param->iterations,
2043 realworld ? 1 : 0, param->length,
2044 param->vary);
David Brownell28ffd792008-04-25 18:51:10 -07002045 retval = ctrl_out(dev, param->iterations,
Martin Fuzzey084fb202011-01-16 19:17:11 +01002046 param->length, param->vary, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 break;
2048
2049 /* iso write tests */
2050 case 15:
2051 if (dev->out_iso_pipe == 0 || param->sglen == 0)
2052 break;
David Brownell28ffd792008-04-25 18:51:10 -07002053 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 "TEST 15: write %d iso, %d entries of %d bytes\n",
2055 param->iterations,
2056 param->sglen, param->length);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002057 /* FIRMWARE: iso sink */
2058 retval = test_iso_queue(dev, param,
Martin Fuzzey084fb202011-01-16 19:17:11 +01002059 dev->out_iso_pipe, dev->iso_out, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 break;
2061
2062 /* iso read tests */
2063 case 16:
2064 if (dev->in_iso_pipe == 0 || param->sglen == 0)
2065 break;
David Brownell28ffd792008-04-25 18:51:10 -07002066 dev_info(&intf->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 "TEST 16: read %d iso, %d entries of %d bytes\n",
2068 param->iterations,
2069 param->sglen, param->length);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002070 /* FIRMWARE: iso source */
2071 retval = test_iso_queue(dev, param,
Martin Fuzzey084fb202011-01-16 19:17:11 +01002072 dev->in_iso_pipe, dev->iso_in, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 break;
2074
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002075 /* FIXME scatterlist cancel (needs helper thread) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076
Martin Fuzzey084fb202011-01-16 19:17:11 +01002077 /* Tests for bulk I/O using DMA mapping by core and odd address */
2078 case 17:
2079 if (dev->out_pipe == 0)
2080 break;
2081 dev_info(&intf->dev,
2082 "TEST 17: write odd addr %d bytes %u times core map\n",
2083 param->length, param->iterations);
2084
2085 retval = test_unaligned_bulk(
2086 dev, dev->out_pipe,
2087 param->length, param->iterations,
2088 0, "test17");
2089 break;
2090
2091 case 18:
2092 if (dev->in_pipe == 0)
2093 break;
2094 dev_info(&intf->dev,
2095 "TEST 18: read odd addr %d bytes %u times core map\n",
2096 param->length, param->iterations);
2097
2098 retval = test_unaligned_bulk(
2099 dev, dev->in_pipe,
2100 param->length, param->iterations,
2101 0, "test18");
2102 break;
2103
2104 /* Tests for bulk I/O using premapped coherent buffer and odd address */
2105 case 19:
2106 if (dev->out_pipe == 0)
2107 break;
2108 dev_info(&intf->dev,
2109 "TEST 19: write odd addr %d bytes %u times premapped\n",
2110 param->length, param->iterations);
2111
2112 retval = test_unaligned_bulk(
2113 dev, dev->out_pipe,
2114 param->length, param->iterations,
2115 URB_NO_TRANSFER_DMA_MAP, "test19");
2116 break;
2117
2118 case 20:
2119 if (dev->in_pipe == 0)
2120 break;
2121 dev_info(&intf->dev,
2122 "TEST 20: read odd addr %d bytes %u times premapped\n",
2123 param->length, param->iterations);
2124
2125 retval = test_unaligned_bulk(
2126 dev, dev->in_pipe,
2127 param->length, param->iterations,
2128 URB_NO_TRANSFER_DMA_MAP, "test20");
2129 break;
2130
2131 /* control write tests with unaligned buffer */
2132 case 21:
2133 if (!dev->info->ctrl_out)
2134 break;
2135 dev_info(&intf->dev,
2136 "TEST 21: %d ep0out odd addr, %d..%d vary %d\n",
2137 param->iterations,
2138 realworld ? 1 : 0, param->length,
2139 param->vary);
2140 retval = ctrl_out(dev, param->iterations,
2141 param->length, param->vary, 1);
2142 break;
2143
2144 /* unaligned iso tests */
2145 case 22:
2146 if (dev->out_iso_pipe == 0 || param->sglen == 0)
2147 break;
2148 dev_info(&intf->dev,
2149 "TEST 22: write %d iso odd, %d entries of %d bytes\n",
2150 param->iterations,
2151 param->sglen, param->length);
2152 retval = test_iso_queue(dev, param,
2153 dev->out_iso_pipe, dev->iso_out, 1);
2154 break;
2155
2156 case 23:
2157 if (dev->in_iso_pipe == 0 || param->sglen == 0)
2158 break;
2159 dev_info(&intf->dev,
2160 "TEST 23: read %d iso odd, %d entries of %d bytes\n",
2161 param->iterations,
2162 param->sglen, param->length);
2163 retval = test_iso_queue(dev, param,
2164 dev->in_iso_pipe, dev->iso_in, 1);
2165 break;
2166
Alan Stern869410f2011-04-14 11:21:04 -04002167 /* unlink URBs from a bulk-OUT queue */
2168 case 24:
2169 if (dev->out_pipe == 0 || !param->length || param->sglen < 4)
2170 break;
2171 retval = 0;
2172 dev_info(&intf->dev, "TEST 17: unlink from %d queues of "
2173 "%d %d-byte writes\n",
2174 param->iterations, param->sglen, param->length);
2175 for (i = param->iterations; retval == 0 && i > 0; --i) {
2176 retval = unlink_queued(dev, dev->out_pipe,
2177 param->sglen, param->length);
2178 if (retval) {
2179 dev_err(&intf->dev,
2180 "unlink queued writes failed %d, "
2181 "iterations left %d\n", retval, i);
2182 break;
2183 }
2184 }
2185 break;
2186
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 }
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002188 do_gettimeofday(&param->duration);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 param->duration.tv_sec -= start.tv_sec;
2190 param->duration.tv_usec -= start.tv_usec;
2191 if (param->duration.tv_usec < 0) {
2192 param->duration.tv_usec += 1000 * 1000;
2193 param->duration.tv_sec -= 1;
2194 }
Matthias Kaehlcke1cfab022007-12-13 16:15:33 -08002195 mutex_unlock(&dev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196 return retval;
2197}
2198
2199/*-------------------------------------------------------------------------*/
2200
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002201static unsigned force_interrupt;
2202module_param(force_interrupt, uint, 0);
2203MODULE_PARM_DESC(force_interrupt, "0 = test default; else interrupt");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204
2205#ifdef GENERIC
2206static unsigned short vendor;
2207module_param(vendor, ushort, 0);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002208MODULE_PARM_DESC(vendor, "vendor code (from usb-if)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209
2210static unsigned short product;
2211module_param(product, ushort, 0);
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002212MODULE_PARM_DESC(product, "product code (from vendor)");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213#endif
2214
2215static int
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002216usbtest_probe(struct usb_interface *intf, const struct usb_device_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217{
2218 struct usb_device *udev;
2219 struct usbtest_dev *dev;
2220 struct usbtest_info *info;
2221 char *rtest, *wtest;
2222 char *irtest, *iwtest;
2223
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002224 udev = interface_to_usbdev(intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225
2226#ifdef GENERIC
2227 /* specify devices by module parameters? */
2228 if (id->match_flags == 0) {
2229 /* vendor match required, product match optional */
2230 if (!vendor || le16_to_cpu(udev->descriptor.idVendor) != (u16)vendor)
2231 return -ENODEV;
2232 if (product && le16_to_cpu(udev->descriptor.idProduct) != (u16)product)
2233 return -ENODEV;
David Brownell28ffd792008-04-25 18:51:10 -07002234 dev_info(&intf->dev, "matched module params, "
2235 "vend=0x%04x prod=0x%04x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 le16_to_cpu(udev->descriptor.idVendor),
2237 le16_to_cpu(udev->descriptor.idProduct));
2238 }
2239#endif
2240
Christoph Lametere94b1762006-12-06 20:33:17 -08002241 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 if (!dev)
2243 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 info = (struct usbtest_info *) id->driver_info;
2245 dev->info = info;
Matthias Kaehlcke1cfab022007-12-13 16:15:33 -08002246 mutex_init(&dev->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247
2248 dev->intf = intf;
2249
2250 /* cacheline-aligned scratch for i/o */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002251 dev->buf = kmalloc(TBUF_SIZE, GFP_KERNEL);
2252 if (dev->buf == NULL) {
2253 kfree(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254 return -ENOMEM;
2255 }
2256
2257 /* NOTE this doesn't yet test the handful of difference that are
2258 * visible with high speed interrupts: bigger maxpacket (1K) and
2259 * "high bandwidth" modes (up to 3 packets/uframe).
2260 */
2261 rtest = wtest = "";
2262 irtest = iwtest = "";
2263 if (force_interrupt || udev->speed == USB_SPEED_LOW) {
2264 if (info->ep_in) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002265 dev->in_pipe = usb_rcvintpipe(udev, info->ep_in);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 rtest = " intr-in";
2267 }
2268 if (info->ep_out) {
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002269 dev->out_pipe = usb_sndintpipe(udev, info->ep_out);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 wtest = " intr-out";
2271 }
2272 } else {
2273 if (info->autoconf) {
2274 int status;
2275
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002276 status = get_endpoints(dev, intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277 if (status < 0) {
Arjan van de Venb6c63932008-07-25 01:45:52 -07002278 WARNING(dev, "couldn't get endpoints, %d\n",
David Brownell28ffd792008-04-25 18:51:10 -07002279 status);
Julia Lawallf4a728d2012-03-25 21:08:32 +02002280 kfree(dev->buf);
2281 kfree(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 return status;
2283 }
2284 /* may find bulk or ISO pipes */
2285 } else {
2286 if (info->ep_in)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002287 dev->in_pipe = usb_rcvbulkpipe(udev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288 info->ep_in);
2289 if (info->ep_out)
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002290 dev->out_pipe = usb_sndbulkpipe(udev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 info->ep_out);
2292 }
2293 if (dev->in_pipe)
2294 rtest = " bulk-in";
2295 if (dev->out_pipe)
2296 wtest = " bulk-out";
2297 if (dev->in_iso_pipe)
2298 irtest = " iso-in";
2299 if (dev->out_iso_pipe)
2300 iwtest = " iso-out";
2301 }
2302
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002303 usb_set_intfdata(intf, dev);
2304 dev_info(&intf->dev, "%s\n", info->name);
Michal Nazarewicze538dfd2011-08-30 17:11:19 +02002305 dev_info(&intf->dev, "%s {control%s%s%s%s%s} tests%s\n",
2306 usb_speed_string(udev->speed),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 info->ctrl_out ? " in/out" : "",
2308 rtest, wtest,
2309 irtest, iwtest,
2310 info->alt >= 0 ? " (+alt)" : "");
2311 return 0;
2312}
2313
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002314static int usbtest_suspend(struct usb_interface *intf, pm_message_t message)
David Brownellff7c79e2005-04-22 13:17:00 -07002315{
David Brownellff7c79e2005-04-22 13:17:00 -07002316 return 0;
2317}
2318
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002319static int usbtest_resume(struct usb_interface *intf)
David Brownellff7c79e2005-04-22 13:17:00 -07002320{
David Brownellff7c79e2005-04-22 13:17:00 -07002321 return 0;
2322}
2323
2324
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002325static void usbtest_disconnect(struct usb_interface *intf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326{
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002327 struct usbtest_dev *dev = usb_get_intfdata(intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002329 usb_set_intfdata(intf, NULL);
2330 dev_dbg(&intf->dev, "disconnect\n");
2331 kfree(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332}
2333
2334/* Basic testing only needs a device that can source or sink bulk traffic.
2335 * Any device can test control transfers (default with GENERIC binding).
2336 *
2337 * Several entries work with the default EP0 implementation that's built
2338 * into EZ-USB chips. There's a default vendor ID which can be overridden
2339 * by (very) small config EEPROMS, but otherwise all these devices act
2340 * identically until firmware is loaded: only EP0 works. It turns out
2341 * to be easy to make other endpoints work, without modifying that EP0
2342 * behavior. For now, we expect that kind of firmware.
2343 */
2344
2345/* an21xx or fx versions of ez-usb */
2346static struct usbtest_info ez1_info = {
2347 .name = "EZ-USB device",
2348 .ep_in = 2,
2349 .ep_out = 2,
2350 .alt = 1,
2351};
2352
2353/* fx2 version of ez-usb */
2354static struct usbtest_info ez2_info = {
2355 .name = "FX2 device",
2356 .ep_in = 6,
2357 .ep_out = 2,
2358 .alt = 1,
2359};
2360
2361/* ezusb family device with dedicated usb test firmware,
2362 */
2363static struct usbtest_info fw_info = {
2364 .name = "usb test device",
2365 .ep_in = 2,
2366 .ep_out = 2,
2367 .alt = 1,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002368 .autoconf = 1, /* iso and ctrl_out need autoconf */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 .ctrl_out = 1,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002370 .iso = 1, /* iso_ep's are #8 in/out */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371};
2372
2373/* peripheral running Linux and 'zero.c' test firmware, or
2374 * its user-mode cousin. different versions of this use
2375 * different hardware with the same vendor/product codes.
2376 * host side MUST rely on the endpoint descriptors.
2377 */
2378static struct usbtest_info gz_info = {
2379 .name = "Linux gadget zero",
2380 .autoconf = 1,
2381 .ctrl_out = 1,
2382 .alt = 0,
2383};
2384
2385static struct usbtest_info um_info = {
2386 .name = "Linux user mode test driver",
2387 .autoconf = 1,
2388 .alt = -1,
2389};
2390
2391static struct usbtest_info um2_info = {
2392 .name = "Linux user mode ISO test driver",
2393 .autoconf = 1,
2394 .iso = 1,
2395 .alt = -1,
2396};
2397
2398#ifdef IBOT2
2399/* this is a nice source of high speed bulk data;
2400 * uses an FX2, with firmware provided in the device
2401 */
2402static struct usbtest_info ibot2_info = {
2403 .name = "iBOT2 webcam",
2404 .ep_in = 2,
2405 .alt = -1,
2406};
2407#endif
2408
2409#ifdef GENERIC
2410/* we can use any device to test control traffic */
2411static struct usbtest_info generic_info = {
2412 .name = "Generic USB device",
2413 .alt = -1,
2414};
2415#endif
2416
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417
Németh Márton33b9e162010-01-10 15:34:45 +01002418static const struct usb_device_id id_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002419
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 /*-------------------------------------------------------------*/
2421
2422 /* EZ-USB devices which download firmware to replace (or in our
2423 * case augment) the default device implementation.
2424 */
2425
2426 /* generic EZ-USB FX controller */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002427 { USB_DEVICE(0x0547, 0x2235),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428 .driver_info = (unsigned long) &ez1_info,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002429 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430
2431 /* CY3671 development board with EZ-USB FX */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002432 { USB_DEVICE(0x0547, 0x0080),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 .driver_info = (unsigned long) &ez1_info,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002434 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435
2436 /* generic EZ-USB FX2 controller (or development board) */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002437 { USB_DEVICE(0x04b4, 0x8613),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 .driver_info = (unsigned long) &ez2_info,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002439 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440
2441 /* re-enumerated usb test device firmware */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002442 { USB_DEVICE(0xfff0, 0xfff0),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 .driver_info = (unsigned long) &fw_info,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002444 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445
2446 /* "Gadget Zero" firmware runs under Linux */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002447 { USB_DEVICE(0x0525, 0xa4a0),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448 .driver_info = (unsigned long) &gz_info,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002449 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450
2451 /* so does a user-mode variant */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002452 { USB_DEVICE(0x0525, 0xa4a4),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 .driver_info = (unsigned long) &um_info,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002454 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455
2456 /* ... and a user-mode variant that talks iso */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002457 { USB_DEVICE(0x0525, 0xa4a3),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 .driver_info = (unsigned long) &um2_info,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002459 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460
2461#ifdef KEYSPAN_19Qi
2462 /* Keyspan 19qi uses an21xx (original EZ-USB) */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002463 /* this does not coexist with the real Keyspan 19qi driver! */
2464 { USB_DEVICE(0x06cd, 0x010b),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 .driver_info = (unsigned long) &ez1_info,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002466 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467#endif
2468
2469 /*-------------------------------------------------------------*/
2470
2471#ifdef IBOT2
2472 /* iBOT2 makes a nice source of high speed bulk-in data */
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002473 /* this does not coexist with a real iBOT2 driver! */
2474 { USB_DEVICE(0x0b62, 0x0059),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 .driver_info = (unsigned long) &ibot2_info,
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002476 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477#endif
2478
2479 /*-------------------------------------------------------------*/
2480
2481#ifdef GENERIC
2482 /* module params can specify devices to use for control tests */
2483 { .driver_info = (unsigned long) &generic_info, },
2484#endif
2485
2486 /*-------------------------------------------------------------*/
2487
2488 { }
2489};
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002490MODULE_DEVICE_TABLE(usb, id_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491
2492static struct usb_driver usbtest_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 .name = "usbtest",
2494 .id_table = id_table,
2495 .probe = usbtest_probe,
Andi Kleenc532b292010-06-01 23:04:41 +02002496 .unlocked_ioctl = usbtest_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497 .disconnect = usbtest_disconnect,
David Brownellff7c79e2005-04-22 13:17:00 -07002498 .suspend = usbtest_suspend,
2499 .resume = usbtest_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500};
2501
2502/*-------------------------------------------------------------------------*/
2503
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002504static int __init usbtest_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505{
2506#ifdef GENERIC
2507 if (vendor)
David Brownell28ffd792008-04-25 18:51:10 -07002508 pr_debug("params: vend=0x%04x prod=0x%04x\n", vendor, product);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509#endif
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002510 return usb_register(&usbtest_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511}
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002512module_init(usbtest_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002514static void __exit usbtest_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515{
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002516 usb_deregister(&usbtest_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517}
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002518module_exit(usbtest_exit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002519
Martin Fuzzeyfabbf212010-10-01 00:20:42 +02002520MODULE_DESCRIPTION("USB Core/HCD Testing Driver");
2521MODULE_LICENSE("GPL");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522