1130407Sdfr// SPDX-License-Identifier: GPL-2.0 2130407Sdfr#include <linux/kernel.h> 3130407Sdfr#include <linux/errno.h> 4130407Sdfr#include <linux/init.h> 5130407Sdfr#include <linux/slab.h> 6130407Sdfr#include <linux/mm.h> 7130407Sdfr#include <linux/module.h> 8130407Sdfr#include <linux/moduleparam.h> 9130407Sdfr#include <linux/scatterlist.h> 10130407Sdfr#include <linux/mutex.h> 11130407Sdfr#include <linux/timer.h> 12130407Sdfr#include <linux/usb.h> 13130407Sdfr 14130407Sdfr#define SIMPLE_IO_TIMEOUT 10000 /* in milliseconds */ 15130407Sdfr 16130407Sdfr/*-------------------------------------------------------------------------*/ 17130407Sdfr 18130407Sdfrstatic int override_alt = -1; 19130407Sdfrmodule_param_named(alt, override_alt, int, 0644); 20130407SdfrMODULE_PARM_DESC(alt, ">= 0 to override altsetting selection"); 21130407Sdfrstatic void complicated_callback(struct urb *urb); 22130407Sdfr 23130407Sdfr/*-------------------------------------------------------------------------*/ 24130407Sdfr 25130407Sdfr/* FIXME make these public somewhere; usbdevfs.h? */ 26130407Sdfr 27130407Sdfr/* Parameter for usbtest driver. */ 28130407Sdfrstruct usbtest_param_32 { 29130407Sdfr /* inputs */ 30130407Sdfr __u32 test_num; /* 0..(TEST_CASES-1) */ 31130407Sdfr __u32 iterations; 32130407Sdfr __u32 length; 33130407Sdfr __u32 vary; 34130407Sdfr __u32 sglen; 35130407Sdfr 36130407Sdfr /* outputs */ 37130407Sdfr __s32 duration_sec; 38130407Sdfr __s32 duration_usec; 39130407Sdfr}; 40130407Sdfr 41130407Sdfr/* 42130407Sdfr * Compat parameter to the usbtest driver. 43130407Sdfr * This supports older user space binaries compiled with 64 bit compiler. 44130407Sdfr */ 45130407Sdfrstruct usbtest_param_64 { 46130407Sdfr /* inputs */ 47130407Sdfr __u32 test_num; /* 0..(TEST_CASES-1) */ 48130407Sdfr __u32 iterations; 49130407Sdfr __u32 length; 50130407Sdfr __u32 vary; 51130407Sdfr __u32 sglen; 52130407Sdfr 53130407Sdfr /* outputs */ 54130407Sdfr __s64 duration_sec; 55130407Sdfr __s64 duration_usec; 56130407Sdfr}; 57130407Sdfr 58130407Sdfr/* IOCTL interface to the driver. */ 59130407Sdfr#define USBTEST_REQUEST_32 _IOWR('U', 100, struct usbtest_param_32) 60130407Sdfr/* COMPAT IOCTL interface to the driver. */ 61130407Sdfr#define USBTEST_REQUEST_64 _IOWR('U', 100, struct usbtest_param_64) 62130407Sdfr 63130407Sdfr/*-------------------------------------------------------------------------*/ 64130407Sdfr 65130411Sdfr#define GENERIC /* let probe() bind using module params */ 66130407Sdfr 67130407Sdfr/* Some devices that can be used for testing will have "real" drivers. 68130407Sdfr * Entries for those need to be enabled here by hand, after disabling 69130407Sdfr * that "real" driver. 70130407Sdfr */ 71130407Sdfr//#define IBOT2 /* grab iBOT2 webcams */ 72130407Sdfr//#define KEYSPAN_19Qi /* grab un-renumerated serial adapter */ 73130407Sdfr 74130407Sdfr/*-------------------------------------------------------------------------*/ 75130407Sdfr 76130407Sdfrstruct usbtest_info { 77130407Sdfr const char *name; 78130407Sdfr u8 ep_in; /* bulk/intr source */ 79130407Sdfr u8 ep_out; /* bulk/intr sink */ 80130407Sdfr unsigned autoconf:1; 81130407Sdfr unsigned ctrl_out:1; 82130407Sdfr unsigned iso:1; /* try iso in/out */ 83130407Sdfr unsigned intr:1; /* try interrupt in/out */ 84130407Sdfr int alt; 85130407Sdfr}; 86130407Sdfr 87130407Sdfr/* this is accessed only through usbfs ioctl calls. 88130407Sdfr * one ioctl to issue a test ... one lock per device. 89130407Sdfr * tests create other threads if they need them. 90130407Sdfr * urbs and buffers are allocated dynamically, 91130407Sdfr * and data generated deterministically. 92130407Sdfr */ 93130407Sdfrstruct usbtest_dev { 94130407Sdfr struct usb_interface *intf; 95130407Sdfr struct usbtest_info *info; 96130407Sdfr int in_pipe; 97130407Sdfr int out_pipe; 98130407Sdfr int in_iso_pipe; 99130407Sdfr int out_iso_pipe; 100130407Sdfr int in_int_pipe; 101130407Sdfr int out_int_pipe; 102130407Sdfr struct usb_endpoint_descriptor *iso_in, *iso_out; 103130407Sdfr struct usb_endpoint_descriptor *int_in, *int_out; 104130407Sdfr struct mutex lock; 105130407Sdfr 106130407Sdfr#define TBUF_SIZE 256 107130407Sdfr u8 *buf; 108130407Sdfr}; 109130407Sdfr 110130407Sdfrstatic struct usb_device *testdev_to_usbdev(struct usbtest_dev *test) 111130407Sdfr{ 112130407Sdfr return interface_to_usbdev(test->intf); 113130407Sdfr} 114130407Sdfr 115130407Sdfr/* set up all urbs so they can be used with either bulk or interrupt */ 116130407Sdfr#define INTERRUPT_RATE 1 /* msec/transfer */ 117130407Sdfr 118130407Sdfr#define ERROR(tdev, fmt, args...) \ 119130407Sdfr dev_err(&(tdev)->intf->dev , fmt , ## args) 120130407Sdfr#define WARNING(tdev, fmt, args...) \ 121130407Sdfr dev_warn(&(tdev)->intf->dev , fmt , ## args) 122130407Sdfr 123130407Sdfr#define GUARD_BYTE 0xA5 124130407Sdfr#define MAX_SGLEN 128 125130407Sdfr 126130407Sdfr/*-------------------------------------------------------------------------*/ 127130407Sdfr 128130407Sdfrstatic inline void endpoint_update(int edi, 129130407Sdfr struct usb_host_endpoint **in, 130130407Sdfr struct usb_host_endpoint **out, 131130407Sdfr struct usb_host_endpoint *e) 132130407Sdfr{ 133130407Sdfr if (edi) { 134130407Sdfr if (!*in) 135130407Sdfr *in = e; 136130407Sdfr } else { 137130407Sdfr if (!*out) 138130407Sdfr *out = e; 139130407Sdfr } 140130407Sdfr} 141130407Sdfr 142130407Sdfrstatic int 143130407Sdfrget_endpoints(struct usbtest_dev *dev, struct usb_interface *intf) 144130407Sdfr{ 145130407Sdfr int tmp; 146130407Sdfr struct usb_host_interface *alt; 147130407Sdfr struct usb_host_endpoint *in, *out; 148130407Sdfr struct usb_host_endpoint *iso_in, *iso_out; 149130407Sdfr struct usb_host_endpoint *int_in, *int_out; 150130407Sdfr struct usb_device *udev; 151130407Sdfr 152130407Sdfr for (tmp = 0; tmp < intf->num_altsetting; tmp++) { 153130407Sdfr unsigned ep; 154130407Sdfr 155130407Sdfr in = out = NULL; 156130407Sdfr iso_in = iso_out = NULL; 157130407Sdfr int_in = int_out = NULL; 158130407Sdfr alt = intf->altsetting + tmp; 159130407Sdfr 160130407Sdfr if (override_alt >= 0 && 161130407Sdfr override_alt != alt->desc.bAlternateSetting) 162130407Sdfr continue; 163130407Sdfr 164130407Sdfr /* take the first altsetting with in-bulk + out-bulk; 165130407Sdfr * ignore other endpoints and altsettings. 166130407Sdfr */ 167130407Sdfr for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) { 168130407Sdfr struct usb_host_endpoint *e; 169130407Sdfr int edi; 170130407Sdfr 171130407Sdfr e = alt->endpoint + ep; 172130407Sdfr edi = usb_endpoint_dir_in(&e->desc); 173130407Sdfr 174130407Sdfr switch (usb_endpoint_type(&e->desc)) { 175130407Sdfr case USB_ENDPOINT_XFER_BULK: 176130407Sdfr endpoint_update(edi, &in, &out, e); 177130407Sdfr continue; 178130407Sdfr case USB_ENDPOINT_XFER_INT: 179130407Sdfr if (dev->info->intr) 180130407Sdfr endpoint_update(edi, &int_in, &int_out, e); 181130407Sdfr continue; 182130407Sdfr case USB_ENDPOINT_XFER_ISOC: 183130407Sdfr if (dev->info->iso) 184130407Sdfr endpoint_update(edi, &iso_in, &iso_out, e); 185130407Sdfr fallthrough; 186130407Sdfr default: 187130407Sdfr continue; 188130407Sdfr } 189130407Sdfr } 190130407Sdfr if ((in && out) || iso_in || iso_out || int_in || int_out) 191130407Sdfr goto found; 192130407Sdfr } 193130407Sdfr return -EINVAL; 194130407Sdfr 195130407Sdfrfound: 196130407Sdfr udev = testdev_to_usbdev(dev); 197130407Sdfr dev->info->alt = alt->desc.bAlternateSetting; 198130407Sdfr if (alt->desc.bAlternateSetting != 0) { 199130407Sdfr tmp = usb_set_interface(udev, 200130407Sdfr alt->desc.bInterfaceNumber, 201130407Sdfr alt->desc.bAlternateSetting); 202130407Sdfr if (tmp < 0) 203130407Sdfr return tmp; 204130407Sdfr } 205130407Sdfr 206130407Sdfr if (in) 207130407Sdfr dev->in_pipe = usb_rcvbulkpipe(udev, 208130407Sdfr in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 209130407Sdfr if (out) 210130407Sdfr dev->out_pipe = usb_sndbulkpipe(udev, 211130407Sdfr out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 212130407Sdfr 213130407Sdfr if (iso_in) { 214130407Sdfr dev->iso_in = &iso_in->desc; 215130407Sdfr dev->in_iso_pipe = usb_rcvisocpipe(udev, 216130407Sdfr iso_in->desc.bEndpointAddress 217130407Sdfr & USB_ENDPOINT_NUMBER_MASK); 218130407Sdfr } 219130407Sdfr 220130407Sdfr if (iso_out) { 221130407Sdfr dev->iso_out = &iso_out->desc; 222130407Sdfr dev->out_iso_pipe = usb_sndisocpipe(udev, 223130407Sdfr iso_out->desc.bEndpointAddress 224130407Sdfr & USB_ENDPOINT_NUMBER_MASK); 225130407Sdfr } 226130407Sdfr 227130407Sdfr if (int_in) { 228130407Sdfr dev->int_in = &int_in->desc; 229130407Sdfr dev->in_int_pipe = usb_rcvintpipe(udev, 230130407Sdfr int_in->desc.bEndpointAddress 231130407Sdfr & USB_ENDPOINT_NUMBER_MASK); 232130407Sdfr } 233130407Sdfr 234130407Sdfr if (int_out) { 235130407Sdfr dev->int_out = &int_out->desc; 236130407Sdfr dev->out_int_pipe = usb_sndintpipe(udev, 237130407Sdfr int_out->desc.bEndpointAddress 238130407Sdfr & USB_ENDPOINT_NUMBER_MASK); 239130407Sdfr } 240130407Sdfr return 0; 241130407Sdfr} 242130407Sdfr 243130407Sdfr/*-------------------------------------------------------------------------*/ 244130407Sdfr 245130407Sdfr/* Support for testing basic non-queued I/O streams. 246130407Sdfr * 247130407Sdfr * These just package urbs as requests that can be easily canceled. 248130407Sdfr * Each urb's data buffer is dynamically allocated; callers can fill 249130407Sdfr * them with non-zero test data (or test for it) when appropriate. 250130407Sdfr */ 251130407Sdfr 252130407Sdfrstatic void simple_callback(struct urb *urb) 253130407Sdfr{ 254130407Sdfr complete(urb->context); 255130407Sdfr} 256130407Sdfr 257130407Sdfrstatic struct urb *usbtest_alloc_urb( 258130407Sdfr struct usb_device *udev, 259130407Sdfr int pipe, 260130407Sdfr unsigned long bytes, 261130407Sdfr unsigned transfer_flags, 262130407Sdfr unsigned offset, 263130407Sdfr u8 bInterval, 264130407Sdfr usb_complete_t complete_fn) 265130407Sdfr{ 266130407Sdfr struct urb *urb; 267130407Sdfr 268130407Sdfr urb = usb_alloc_urb(0, GFP_KERNEL); 269130407Sdfr if (!urb) 270130407Sdfr return urb; 271130407Sdfr 272130407Sdfr if (bInterval) 273130407Sdfr usb_fill_int_urb(urb, udev, pipe, NULL, bytes, complete_fn, 274130407Sdfr NULL, bInterval); 275130407Sdfr else 276130407Sdfr usb_fill_bulk_urb(urb, udev, pipe, NULL, bytes, complete_fn, 277130407Sdfr NULL); 278130407Sdfr 279130407Sdfr urb->interval = (udev->speed == USB_SPEED_HIGH) 280130407Sdfr ? (INTERRUPT_RATE << 3) 281130407Sdfr : INTERRUPT_RATE; 282130407Sdfr urb->transfer_flags = transfer_flags; 283130407Sdfr if (usb_pipein(pipe)) 284130407Sdfr urb->transfer_flags |= URB_SHORT_NOT_OK; 285130407Sdfr 286130407Sdfr if ((bytes + offset) == 0) 287130407Sdfr return urb; 288130407Sdfr 289130407Sdfr if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 290130407Sdfr urb->transfer_buffer = usb_alloc_coherent(udev, bytes + offset, 291130407Sdfr GFP_KERNEL, &urb->transfer_dma); 292130407Sdfr else 293130407Sdfr urb->transfer_buffer = kmalloc(bytes + offset, GFP_KERNEL); 294130407Sdfr 295130407Sdfr if (!urb->transfer_buffer) { 296130407Sdfr usb_free_urb(urb); 297130407Sdfr return NULL; 298130407Sdfr } 299130407Sdfr 300130407Sdfr /* To test unaligned transfers add an offset and fill the 301130407Sdfr unused memory with a guard value */ 302130407Sdfr if (offset) { 303130407Sdfr memset(urb->transfer_buffer, GUARD_BYTE, offset); 304130407Sdfr urb->transfer_buffer += offset; 305130407Sdfr if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 306130407Sdfr urb->transfer_dma += offset; 307130407Sdfr } 308130407Sdfr 309130407Sdfr /* For inbound transfers use guard byte so that test fails if 310130407Sdfr data not correctly copied */ 311130407Sdfr memset(urb->transfer_buffer, 312130407Sdfr usb_pipein(urb->pipe) ? GUARD_BYTE : 0, 313130407Sdfr bytes); 314130407Sdfr return urb; 315130407Sdfr} 316130407Sdfr 317130407Sdfrstatic struct urb *simple_alloc_urb( 318130407Sdfr struct usb_device *udev, 319130407Sdfr int pipe, 320130407Sdfr unsigned long bytes, 321130407Sdfr u8 bInterval) 322130407Sdfr{ 323130407Sdfr return usbtest_alloc_urb(udev, pipe, bytes, URB_NO_TRANSFER_DMA_MAP, 0, 324130407Sdfr bInterval, simple_callback); 325130407Sdfr} 326130407Sdfr 327130407Sdfrstatic struct urb *complicated_alloc_urb( 328130407Sdfr struct usb_device *udev, 329130407Sdfr int pipe, 330130407Sdfr unsigned long bytes, 331130407Sdfr u8 bInterval) 332130407Sdfr{ 333130407Sdfr return usbtest_alloc_urb(udev, pipe, bytes, URB_NO_TRANSFER_DMA_MAP, 0, 334130407Sdfr bInterval, complicated_callback); 335130407Sdfr} 336130407Sdfr 337130407Sdfrstatic unsigned pattern; 338130407Sdfrstatic unsigned mod_pattern; 339130407Sdfrmodule_param_named(pattern, mod_pattern, uint, S_IRUGO | S_IWUSR); 340130407SdfrMODULE_PARM_DESC(mod_pattern, "i/o pattern (0 == zeroes)"); 341130407Sdfr 342130407Sdfrstatic unsigned get_maxpacket(struct usb_device *udev, int pipe) 343130407Sdfr{ 344130407Sdfr struct usb_host_endpoint *ep; 345130407Sdfr 346130407Sdfr ep = usb_pipe_endpoint(udev, pipe); 347130407Sdfr return le16_to_cpup(&ep->desc.wMaxPacketSize); 348130407Sdfr} 349130407Sdfr 350130407Sdfrstatic int ss_isoc_get_packet_num(struct usb_device *udev, int pipe) 351130407Sdfr{ 352130407Sdfr struct usb_host_endpoint *ep = usb_pipe_endpoint(udev, pipe); 353130407Sdfr 354130407Sdfr return USB_SS_MULT(ep->ss_ep_comp.bmAttributes) 355130407Sdfr * (1 + ep->ss_ep_comp.bMaxBurst); 356130407Sdfr} 357130407Sdfr 358130407Sdfrstatic void simple_fill_buf(struct urb *urb) 359130407Sdfr{ 360130407Sdfr unsigned i; 361130407Sdfr u8 *buf = urb->transfer_buffer; 362130407Sdfr unsigned len = urb->transfer_buffer_length; 363130407Sdfr unsigned maxpacket; 364130407Sdfr 365130407Sdfr switch (pattern) { 366130407Sdfr default: 367130407Sdfr fallthrough; 368130407Sdfr case 0: 369130407Sdfr memset(buf, 0, len); 370130407Sdfr break; 371130407Sdfr case 1: /* mod63 */ 372130407Sdfr maxpacket = get_maxpacket(urb->dev, urb->pipe); 373130407Sdfr for (i = 0; i < len; i++) 374130407Sdfr *buf++ = (u8) ((i % maxpacket) % 63); 375130407Sdfr break; 376130407Sdfr } 377130407Sdfr} 378130407Sdfr 379130407Sdfrstatic inline unsigned long buffer_offset(void *buf) 380130407Sdfr{ 381130407Sdfr return (unsigned long)buf & (ARCH_KMALLOC_MINALIGN - 1); 382130407Sdfr} 383130407Sdfr 384130407Sdfrstatic int check_guard_bytes(struct usbtest_dev *tdev, struct urb *urb) 385130407Sdfr{ 386130407Sdfr u8 *buf = urb->transfer_buffer; 387130407Sdfr u8 *guard = buf - buffer_offset(buf); 388130407Sdfr unsigned i; 389130407Sdfr 390130407Sdfr for (i = 0; guard < buf; i++, guard++) { 391130407Sdfr if (*guard != GUARD_BYTE) { 392130407Sdfr ERROR(tdev, "guard byte[%d] %d (not %d)\n", 393130407Sdfr i, *guard, GUARD_BYTE); 394130407Sdfr return -EINVAL; 395130407Sdfr } 396130407Sdfr } 397130407Sdfr return 0; 398130407Sdfr} 399130407Sdfr 400130407Sdfrstatic int simple_check_buf(struct usbtest_dev *tdev, struct urb *urb) 401130407Sdfr{ 402130407Sdfr unsigned i; 403130407Sdfr u8 expected; 404130407Sdfr u8 *buf = urb->transfer_buffer; 405130407Sdfr unsigned len = urb->actual_length; 406130407Sdfr unsigned maxpacket = get_maxpacket(urb->dev, urb->pipe); 407130407Sdfr 408130407Sdfr int ret = check_guard_bytes(tdev, urb); 409130407Sdfr if (ret) 410130407Sdfr return ret; 411130407Sdfr 412130407Sdfr for (i = 0; i < len; i++, buf++) { 413130407Sdfr switch (pattern) { 414130407Sdfr /* all-zeroes has no synchronization issues */ 415130407Sdfr case 0: 416130407Sdfr expected = 0; 417130407Sdfr break; 418130407Sdfr /* mod63 stays in sync with short-terminated transfers, 419130407Sdfr * or otherwise when host and gadget agree on how large 420130407Sdfr * each usb transfer request should be. resync is done 421130407Sdfr * with set_interface or set_config. 422130407Sdfr */ 423130407Sdfr case 1: /* mod63 */ 424130407Sdfr expected = (i % maxpacket) % 63; 425130407Sdfr break; 426130407Sdfr /* always fail unsupported patterns */ 427130407Sdfr default: 428130407Sdfr expected = !*buf; 429130407Sdfr break; 430130407Sdfr } 431130407Sdfr if (*buf == expected) 432130407Sdfr continue; 433130407Sdfr ERROR(tdev, "buf[%d] = %d (not %d)\n", i, *buf, expected); 434130407Sdfr return -EINVAL; 435130407Sdfr } 436130407Sdfr return 0; 437130407Sdfr} 438130407Sdfr 439130407Sdfrstatic void simple_free_urb(struct urb *urb) 440130407Sdfr{ 441130407Sdfr unsigned long offset = buffer_offset(urb->transfer_buffer); 442130407Sdfr 443130407Sdfr if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 444130407Sdfr usb_free_coherent( 445130407Sdfr urb->dev, 446130407Sdfr urb->transfer_buffer_length + offset, 447130407Sdfr urb->transfer_buffer - offset, 448130407Sdfr urb->transfer_dma - offset); 449130407Sdfr else 450130407Sdfr kfree(urb->transfer_buffer - offset); 451130411Sdfr usb_free_urb(urb); 452130411Sdfr} 453130407Sdfr 454130411Sdfrstatic int simple_io( 455130411Sdfr struct usbtest_dev *tdev, 456130411Sdfr struct urb *urb, 457130411Sdfr int iterations, 458130411Sdfr int vary, 459130411Sdfr int expected, 460130411Sdfr const char *label 461130411Sdfr) 462130411Sdfr{ 463130411Sdfr struct usb_device *udev = urb->dev; 464130411Sdfr int max = urb->transfer_buffer_length; 465130411Sdfr struct completion completion; 466130411Sdfr int retval = 0; 467130411Sdfr unsigned long expire; 468130411Sdfr 469130411Sdfr urb->context = &completion; 470130411Sdfr while (retval == 0 && iterations-- > 0) { 471130411Sdfr init_completion(&completion); 472130411Sdfr if (usb_pipeout(urb->pipe)) { 473130407Sdfr simple_fill_buf(urb); 474130407Sdfr urb->transfer_flags |= URB_ZERO_PACKET; 475130407Sdfr } 476130407Sdfr retval = usb_submit_urb(urb, GFP_KERNEL); 477130407Sdfr if (retval != 0) 478130407Sdfr break; 479130407Sdfr 480130407Sdfr expire = msecs_to_jiffies(SIMPLE_IO_TIMEOUT); 481130407Sdfr if (!wait_for_completion_timeout(&completion, expire)) { 482130407Sdfr usb_kill_urb(urb); 483130407Sdfr retval = (urb->status == -ENOENT ? 484130407Sdfr -ETIMEDOUT : urb->status); 485130407Sdfr } else { 486130407Sdfr retval = urb->status; 487130407Sdfr } 488130407Sdfr 489130407Sdfr urb->dev = udev; 490130407Sdfr if (retval == 0 && usb_pipein(urb->pipe)) 491130407Sdfr retval = simple_check_buf(tdev, urb); 492130407Sdfr 493130407Sdfr if (vary) { 494130407Sdfr int len = urb->transfer_buffer_length; 495130407Sdfr 496130407Sdfr len += vary; 497130407Sdfr len %= max; 498130407Sdfr if (len == 0) 499130407Sdfr len = (vary < max) ? vary : max; 500130407Sdfr urb->transfer_buffer_length = len; 501130407Sdfr } 502130407Sdfr 503130407Sdfr /* FIXME if endpoint halted, clear halt (and log) */ 504130407Sdfr } 505130407Sdfr urb->transfer_buffer_length = max; 506130407Sdfr 507130407Sdfr if (expected != retval) 508130407Sdfr dev_err(&udev->dev, 509130407Sdfr "%s failed, iterations left %d, status %d (not %d)\n", 510130407Sdfr label, iterations, retval, expected); 511130407Sdfr return retval; 512130407Sdfr} 513130407Sdfr 514130407Sdfr 515130407Sdfr/*-------------------------------------------------------------------------*/ 516130407Sdfr 517130407Sdfr/* We use scatterlist primitives to test queued I/O. 518130407Sdfr * Yes, this also tests the scatterlist primitives. 519130407Sdfr */ 520130407Sdfr 521130407Sdfrstatic void free_sglist(struct scatterlist *sg, int nents) 522130407Sdfr{ 523130407Sdfr unsigned i; 524130407Sdfr 525130407Sdfr if (!sg) 526130407Sdfr return; 527130407Sdfr for (i = 0; i < nents; i++) { 528130407Sdfr if (!sg_page(&sg[i])) 529130407Sdfr continue; 530130407Sdfr kfree(sg_virt(&sg[i])); 531130407Sdfr } 532130407Sdfr kfree(sg); 533130407Sdfr} 534130407Sdfr 535130407Sdfrstatic struct scatterlist * 536130407Sdfralloc_sglist(int nents, int max, int vary, struct usbtest_dev *dev, int pipe) 537130407Sdfr{ 538130407Sdfr struct scatterlist *sg; 539130407Sdfr unsigned int n_size = 0; 540130407Sdfr unsigned i; 541130407Sdfr unsigned size = max; 542130407Sdfr unsigned maxpacket = 543130407Sdfr get_maxpacket(interface_to_usbdev(dev->intf), pipe); 544130407Sdfr 545130407Sdfr if (max == 0) 546130407Sdfr return NULL; 547130407Sdfr 548130407Sdfr sg = kmalloc_array(nents, sizeof(*sg), GFP_KERNEL); 549130407Sdfr if (!sg) 550130407Sdfr return NULL; 551130407Sdfr sg_init_table(sg, nents); 552130407Sdfr 553130407Sdfr for (i = 0; i < nents; i++) { 554130407Sdfr char *buf; 555130460Sdfr unsigned j; 556130407Sdfr 557130407Sdfr buf = kzalloc(size, GFP_KERNEL); 558130407Sdfr if (!buf) { 559130407Sdfr free_sglist(sg, i); 560130407Sdfr return NULL; 561130407Sdfr } 562130407Sdfr 563130407Sdfr /* kmalloc pages are always physically contiguous! */ 564130407Sdfr sg_set_buf(&sg[i], buf, size); 565130407Sdfr 566130407Sdfr switch (pattern) { 567130407Sdfr case 0: 568130407Sdfr /* already zeroed */ 569130407Sdfr break; 570130407Sdfr case 1: 571130407Sdfr for (j = 0; j < size; j++) 572130407Sdfr *buf++ = (u8) (((j + n_size) % maxpacket) % 63); 573130407Sdfr n_size += size; 574130407Sdfr break; 575130407Sdfr } 576130407Sdfr 577130407Sdfr if (vary) { 578130407Sdfr size += vary; 579130407Sdfr size %= max; 580130407Sdfr if (size == 0) 581130407Sdfr size = (vary < max) ? vary : max; 582130407Sdfr } 583130407Sdfr } 584130407Sdfr 585130407Sdfr return sg; 586130407Sdfr} 587130407Sdfr 588130407Sdfrstruct sg_timeout { 589130407Sdfr struct timer_list timer; 590130407Sdfr struct usb_sg_request *req; 591130407Sdfr}; 592130407Sdfr 593130407Sdfrstatic void sg_timeout(struct timer_list *t) 594130407Sdfr{ 595130407Sdfr struct sg_timeout *timeout = from_timer(timeout, t, timer); 596130407Sdfr 597130407Sdfr usb_sg_cancel(timeout->req); 598130407Sdfr} 599130407Sdfr 600130407Sdfrstatic int perform_sglist( 601130407Sdfr struct usbtest_dev *tdev, 602130407Sdfr unsigned iterations, 603130407Sdfr int pipe, 604130407Sdfr struct usb_sg_request *req, 605130407Sdfr struct scatterlist *sg, 606130407Sdfr int nents 607130407Sdfr) 608130407Sdfr{ 609130407Sdfr struct usb_device *udev = testdev_to_usbdev(tdev); 610130407Sdfr int retval = 0; 611130407Sdfr struct sg_timeout timeout = { 612130407Sdfr .req = req, 613130407Sdfr }; 614130407Sdfr 615130407Sdfr timer_setup_on_stack(&timeout.timer, sg_timeout, 0); 616130407Sdfr 617130407Sdfr while (retval == 0 && iterations-- > 0) { 618130407Sdfr retval = usb_sg_init(req, udev, pipe, 619130407Sdfr (udev->speed == USB_SPEED_HIGH) 620130407Sdfr ? (INTERRUPT_RATE << 3) 621130407Sdfr : INTERRUPT_RATE, 622130407Sdfr sg, nents, 0, GFP_KERNEL); 623130407Sdfr 624130407Sdfr if (retval) 625130407Sdfr break; 626130407Sdfr mod_timer(&timeout.timer, jiffies + 627130407Sdfr msecs_to_jiffies(SIMPLE_IO_TIMEOUT)); 628130407Sdfr usb_sg_wait(req); 629130407Sdfr if (!del_timer_sync(&timeout.timer)) 630130407Sdfr retval = -ETIMEDOUT; 631130407Sdfr else 632130407Sdfr retval = req->status; 633130407Sdfr destroy_timer_on_stack(&timeout.timer); 634130407Sdfr 635130407Sdfr /* FIXME check resulting data pattern */ 636130407Sdfr 637130407Sdfr /* FIXME if endpoint halted, clear halt (and log) */ 638130407Sdfr } 639130407Sdfr 640130407Sdfr /* FIXME for unlink or fault handling tests, don't report 641130407Sdfr * failure if retval is as we expected ... 642130407Sdfr */ 643130407Sdfr if (retval) 644130407Sdfr ERROR(tdev, "perform_sglist failed, " 645130407Sdfr "iterations left %d, status %d\n", 646130407Sdfr iterations, retval); 647130407Sdfr return retval; 648130407Sdfr} 649130407Sdfr 650130407Sdfr 651130407Sdfr/*-------------------------------------------------------------------------*/ 652130407Sdfr 653130407Sdfr/* unqueued control message testing 654130407Sdfr * 655130407Sdfr * there's a nice set of device functional requirements in chapter 9 of the 656130407Sdfr * usb 2.0 spec, which we can apply to ANY device, even ones that don't use 657130407Sdfr * special test firmware. 658130407Sdfr * 659130407Sdfr * we know the device is configured (or suspended) by the time it's visible 660130407Sdfr * through usbfs. we can't change that, so we won't test enumeration (which 661130407Sdfr * worked 'well enough' to get here, this time), power management (ditto), 662130407Sdfr * or remote wakeup (which needs human interaction). 663130407Sdfr */ 664130407Sdfr 665130407Sdfrstatic unsigned realworld = 1; 666130407Sdfrmodule_param(realworld, uint, 0); 667130407SdfrMODULE_PARM_DESC(realworld, "clear to demand stricter spec compliance"); 668130407Sdfr 669130407Sdfrstatic int get_altsetting(struct usbtest_dev *dev) 670130460Sdfr{ 671130460Sdfr struct usb_interface *iface = dev->intf; 672130460Sdfr struct usb_device *udev = interface_to_usbdev(iface); 673130460Sdfr int retval; 674130460Sdfr 675130460Sdfr retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 676130460Sdfr USB_REQ_GET_INTERFACE, USB_DIR_IN|USB_RECIP_INTERFACE, 677130460Sdfr 0, iface->altsetting[0].desc.bInterfaceNumber, 678130460Sdfr dev->buf, 1, USB_CTRL_GET_TIMEOUT); 679130460Sdfr switch (retval) { 680130460Sdfr case 1: 681130460Sdfr return dev->buf[0]; 682130407Sdfr case 0: 683130407Sdfr retval = -ERANGE; 684130407Sdfr fallthrough; 685130407Sdfr default: 686130407Sdfr return retval; 687130407Sdfr } 688130407Sdfr} 689130407Sdfr 690130407Sdfrstatic int set_altsetting(struct usbtest_dev *dev, int alternate) 691130407Sdfr{ 692130407Sdfr struct usb_interface *iface = dev->intf; 693130407Sdfr struct usb_device *udev; 694130407Sdfr 695130407Sdfr if (alternate < 0 || alternate >= 256) 696130407Sdfr return -EINVAL; 697130407Sdfr 698130407Sdfr udev = interface_to_usbdev(iface); 699130407Sdfr return usb_set_interface(udev, 700130407Sdfr iface->altsetting[0].desc.bInterfaceNumber, 701130407Sdfr alternate); 702130407Sdfr} 703130407Sdfr 704130407Sdfrstatic int is_good_config(struct usbtest_dev *tdev, int len) 705130407Sdfr{ 706130407Sdfr struct usb_config_descriptor *config; 707130407Sdfr 708130407Sdfr if (len < (int)sizeof(*config)) 709130407Sdfr return 0; 710130407Sdfr config = (struct usb_config_descriptor *) tdev->buf; 711130407Sdfr 712130407Sdfr switch (config->bDescriptorType) { 713130407Sdfr case USB_DT_CONFIG: 714130407Sdfr case USB_DT_OTHER_SPEED_CONFIG: 715130407Sdfr if (config->bLength != 9) { 716130407Sdfr ERROR(tdev, "bogus config descriptor length\n"); 717130407Sdfr return 0; 718130407Sdfr } 719130407Sdfr /* this bit 'must be 1' but often isn't */ 720130407Sdfr if (!realworld && !(config->bmAttributes & 0x80)) { 721130407Sdfr ERROR(tdev, "high bit of config attributes not set\n"); 722130407Sdfr return 0; 723130407Sdfr } 724130407Sdfr if (config->bmAttributes & 0x1f) { /* reserved == 0 */ 725130407Sdfr ERROR(tdev, "reserved config bits set\n"); 726130407Sdfr return 0; 727130407Sdfr } 728130407Sdfr break; 729130407Sdfr default: 730130407Sdfr return 0; 731130407Sdfr } 732130407Sdfr 733130407Sdfr if (le16_to_cpu(config->wTotalLength) == len) /* read it all */ 734130407Sdfr return 1; 735130407Sdfr if (le16_to_cpu(config->wTotalLength) >= TBUF_SIZE) /* max partial read */ 736130407Sdfr return 1; 737130407Sdfr ERROR(tdev, "bogus config descriptor read size\n"); 738130407Sdfr return 0; 739130407Sdfr} 740130407Sdfr 741130407Sdfrstatic int is_good_ext(struct usbtest_dev *tdev, u8 *buf) 742130407Sdfr{ 743130407Sdfr struct usb_ext_cap_descriptor *ext; 744130407Sdfr u32 attr; 745130407Sdfr 746130407Sdfr ext = (struct usb_ext_cap_descriptor *) buf; 747130407Sdfr 748130407Sdfr if (ext->bLength != USB_DT_USB_EXT_CAP_SIZE) { 749130407Sdfr ERROR(tdev, "bogus usb 2.0 extension descriptor length\n"); 750130407Sdfr return 0; 751130407Sdfr } 752130407Sdfr 753130407Sdfr attr = le32_to_cpu(ext->bmAttributes); 754130407Sdfr /* bits[1:15] is used and others are reserved */ 755130407Sdfr if (attr & ~0xfffe) { /* reserved == 0 */ 756130407Sdfr ERROR(tdev, "reserved bits set\n"); 757130407Sdfr return 0; 758130407Sdfr } 759130407Sdfr 760130407Sdfr return 1; 761130407Sdfr} 762130407Sdfr 763130407Sdfrstatic int is_good_ss_cap(struct usbtest_dev *tdev, u8 *buf) 764130407Sdfr{ 765130407Sdfr struct usb_ss_cap_descriptor *ss; 766130407Sdfr 767130407Sdfr ss = (struct usb_ss_cap_descriptor *) buf; 768130407Sdfr 769130407Sdfr if (ss->bLength != USB_DT_USB_SS_CAP_SIZE) { 770130407Sdfr ERROR(tdev, "bogus superspeed device capability descriptor length\n"); 771130407Sdfr return 0; 772130407Sdfr } 773130407Sdfr 774130407Sdfr /* 775130407Sdfr * only bit[1] of bmAttributes is used for LTM and others are 776130407Sdfr * reserved 777130407Sdfr */ 778130407Sdfr if (ss->bmAttributes & ~0x02) { /* reserved == 0 */ 779130407Sdfr ERROR(tdev, "reserved bits set in bmAttributes\n"); 780130407Sdfr return 0; 781130407Sdfr } 782130407Sdfr 783130407Sdfr /* bits[0:3] of wSpeedSupported is used and others are reserved */ 784130407Sdfr if (le16_to_cpu(ss->wSpeedSupported) & ~0x0f) { /* reserved == 0 */ 785130407Sdfr ERROR(tdev, "reserved bits set in wSpeedSupported\n"); 786130407Sdfr return 0; 787130407Sdfr } 788130407Sdfr 789130407Sdfr return 1; 790130407Sdfr} 791130407Sdfr 792130407Sdfrstatic int is_good_con_id(struct usbtest_dev *tdev, u8 *buf) 793130407Sdfr{ 794130407Sdfr struct usb_ss_container_id_descriptor *con_id; 795130407Sdfr 796130407Sdfr con_id = (struct usb_ss_container_id_descriptor *) buf; 797130407Sdfr 798130407Sdfr if (con_id->bLength != USB_DT_USB_SS_CONTN_ID_SIZE) { 799130407Sdfr ERROR(tdev, "bogus container id descriptor length\n"); 800130407Sdfr return 0; 801130407Sdfr } 802130407Sdfr 803130407Sdfr if (con_id->bReserved) { /* reserved == 0 */ 804130407Sdfr ERROR(tdev, "reserved bits set\n"); 805130407Sdfr return 0; 806130407Sdfr } 807130407Sdfr 808130407Sdfr return 1; 809130407Sdfr} 810130407Sdfr 811130407Sdfr/* sanity test for standard requests working with usb_control_mesg() and some 812130407Sdfr * of the utility functions which use it. 813130407Sdfr * 814130407Sdfr * this doesn't test how endpoint halts behave or data toggles get set, since 815130407Sdfr * we won't do I/O to bulk/interrupt endpoints here (which is how to change 816130407Sdfr * halt or toggle). toggle testing is impractical without support from hcds. 817130407Sdfr * 818130407Sdfr * this avoids failing devices linux would normally work with, by not testing 819130407Sdfr * config/altsetting operations for devices that only support their defaults. 820130407Sdfr * such devices rarely support those needless operations. 821130407Sdfr * 822130407Sdfr * NOTE that since this is a sanity test, it's not examining boundary cases 823130407Sdfr * to see if usbcore, hcd, and device all behave right. such testing would 824130407Sdfr * involve varied read sizes and other operation sequences. 825130407Sdfr */ 826130407Sdfrstatic int ch9_postconfig(struct usbtest_dev *dev) 827130407Sdfr{ 828130407Sdfr struct usb_interface *iface = dev->intf; 829130407Sdfr struct usb_device *udev = interface_to_usbdev(iface); 830130407Sdfr int i, alt, retval; 831130407Sdfr 832130407Sdfr /* [9.2.3] if there's more than one altsetting, we need to be able to 833130407Sdfr * set and get each one. mostly trusts the descriptors from usbcore. 834130407Sdfr */ 835130407Sdfr for (i = 0; i < iface->num_altsetting; i++) { 836130407Sdfr 837130407Sdfr /* 9.2.3 constrains the range here */ 838130407Sdfr alt = iface->altsetting[i].desc.bAlternateSetting; 839130407Sdfr if (alt < 0 || alt >= iface->num_altsetting) { 840130407Sdfr dev_err(&iface->dev, 841130407Sdfr "invalid alt [%d].bAltSetting = %d\n", 842130407Sdfr i, alt); 843130407Sdfr } 844130407Sdfr 845130407Sdfr /* [real world] get/set unimplemented if there's only one */ 846130407Sdfr if (realworld && iface->num_altsetting == 1) 847130407Sdfr continue; 848130407Sdfr 849130407Sdfr /* [9.4.10] set_interface */ 850130407Sdfr retval = set_altsetting(dev, alt); 851130407Sdfr if (retval) { 852130407Sdfr dev_err(&iface->dev, "can't set_interface = %d, %d\n", 853130407Sdfr alt, retval); 854130407Sdfr return retval; 855130407Sdfr } 856130407Sdfr 857130407Sdfr /* [9.4.4] get_interface always works */ 858130407Sdfr retval = get_altsetting(dev); 859130407Sdfr if (retval != alt) { 860130407Sdfr dev_err(&iface->dev, "get alt should be %d, was %d\n", 861130407Sdfr alt, retval); 862130407Sdfr return (retval < 0) ? retval : -EDOM; 863130407Sdfr } 864130407Sdfr 865130407Sdfr } 866130407Sdfr 867130407Sdfr /* [real world] get_config unimplemented if there's only one */ 868130407Sdfr if (!realworld || udev->descriptor.bNumConfigurations != 1) { 869130407Sdfr int expected = udev->actconfig->desc.bConfigurationValue; 870130407Sdfr 871130407Sdfr /* [9.4.2] get_configuration always works 872130407Sdfr * ... although some cheap devices (like one TI Hub I've got) 873130407Sdfr * won't return config descriptors except before set_config. 874130407Sdfr */ 875130407Sdfr retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 876130407Sdfr USB_REQ_GET_CONFIGURATION, 877130407Sdfr USB_DIR_IN | USB_RECIP_DEVICE, 878130407Sdfr 0, 0, dev->buf, 1, USB_CTRL_GET_TIMEOUT); 879130407Sdfr if (retval != 1 || dev->buf[0] != expected) { 880130407Sdfr dev_err(&iface->dev, "get config --> %d %d (1 %d)\n", 881130407Sdfr retval, dev->buf[0], expected); 882130407Sdfr return (retval < 0) ? retval : -EDOM; 883130407Sdfr } 884130407Sdfr } 885130407Sdfr 886130407Sdfr /* there's always [9.4.3] a device descriptor [9.6.1] */ 887130407Sdfr retval = usb_get_descriptor(udev, USB_DT_DEVICE, 0, 888130407Sdfr dev->buf, sizeof(udev->descriptor)); 889130407Sdfr if (retval != sizeof(udev->descriptor)) { 890130407Sdfr dev_err(&iface->dev, "dev descriptor --> %d\n", retval); 891130407Sdfr return (retval < 0) ? retval : -EDOM; 892130407Sdfr } 893130407Sdfr 894130407Sdfr /* 895130407Sdfr * there's always [9.4.3] a bos device descriptor [9.6.2] in USB 896130407Sdfr * 3.0 spec 897130407Sdfr */ 898130407Sdfr if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0210) { 899130407Sdfr struct usb_bos_descriptor *bos = NULL; 900130407Sdfr struct usb_dev_cap_header *header = NULL; 901130407Sdfr unsigned total, num, length; 902130407Sdfr u8 *buf; 903130407Sdfr 904130407Sdfr retval = usb_get_descriptor(udev, USB_DT_BOS, 0, dev->buf, 905130407Sdfr sizeof(*udev->bos->desc)); 906130407Sdfr if (retval != sizeof(*udev->bos->desc)) { 907130407Sdfr dev_err(&iface->dev, "bos descriptor --> %d\n", retval); 908130407Sdfr return (retval < 0) ? retval : -EDOM; 909130407Sdfr } 910130407Sdfr 911130407Sdfr bos = (struct usb_bos_descriptor *)dev->buf; 912130407Sdfr total = le16_to_cpu(bos->wTotalLength); 913130407Sdfr num = bos->bNumDeviceCaps; 914130407Sdfr 915130407Sdfr if (total > TBUF_SIZE) 916130407Sdfr total = TBUF_SIZE; 917130407Sdfr 918130407Sdfr /* 919130407Sdfr * get generic device-level capability descriptors [9.6.2] 920130407Sdfr * in USB 3.0 spec 921130407Sdfr */ 922130407Sdfr retval = usb_get_descriptor(udev, USB_DT_BOS, 0, dev->buf, 923130407Sdfr total); 924130407Sdfr if (retval != total) { 925130407Sdfr dev_err(&iface->dev, "bos descriptor set --> %d\n", 926130407Sdfr retval); 927130407Sdfr return (retval < 0) ? retval : -EDOM; 928130407Sdfr } 929130407Sdfr 930130407Sdfr length = sizeof(*udev->bos->desc); 931130407Sdfr buf = dev->buf; 932130407Sdfr for (i = 0; i < num; i++) { 933130407Sdfr buf += length; 934130407Sdfr if (buf + sizeof(struct usb_dev_cap_header) > 935130407Sdfr dev->buf + total) 936130407Sdfr break; 937130407Sdfr 938130407Sdfr header = (struct usb_dev_cap_header *)buf; 939130407Sdfr length = header->bLength; 940130407Sdfr 941130407Sdfr if (header->bDescriptorType != 942130407Sdfr USB_DT_DEVICE_CAPABILITY) { 943130407Sdfr dev_warn(&udev->dev, "not device capability descriptor, skip\n"); 944130407Sdfr continue; 945130407Sdfr } 946130407Sdfr 947130407Sdfr switch (header->bDevCapabilityType) { 948130407Sdfr case USB_CAP_TYPE_EXT: 949130407Sdfr if (buf + USB_DT_USB_EXT_CAP_SIZE > 950130407Sdfr dev->buf + total || 951130407Sdfr !is_good_ext(dev, buf)) { 952 dev_err(&iface->dev, "bogus usb 2.0 extension descriptor\n"); 953 return -EDOM; 954 } 955 break; 956 case USB_SS_CAP_TYPE: 957 if (buf + USB_DT_USB_SS_CAP_SIZE > 958 dev->buf + total || 959 !is_good_ss_cap(dev, buf)) { 960 dev_err(&iface->dev, "bogus superspeed device capability descriptor\n"); 961 return -EDOM; 962 } 963 break; 964 case CONTAINER_ID_TYPE: 965 if (buf + USB_DT_USB_SS_CONTN_ID_SIZE > 966 dev->buf + total || 967 !is_good_con_id(dev, buf)) { 968 dev_err(&iface->dev, "bogus container id descriptor\n"); 969 return -EDOM; 970 } 971 break; 972 default: 973 break; 974 } 975 } 976 } 977 978 /* there's always [9.4.3] at least one config descriptor [9.6.3] */ 979 for (i = 0; i < udev->descriptor.bNumConfigurations; i++) { 980 retval = usb_get_descriptor(udev, USB_DT_CONFIG, i, 981 dev->buf, TBUF_SIZE); 982 if (!is_good_config(dev, retval)) { 983 dev_err(&iface->dev, 984 "config [%d] descriptor --> %d\n", 985 i, retval); 986 return (retval < 0) ? retval : -EDOM; 987 } 988 989 /* FIXME cross-checking udev->config[i] to make sure usbcore 990 * parsed it right (etc) would be good testing paranoia 991 */ 992 } 993 994 /* and sometimes [9.2.6.6] speed dependent descriptors */ 995 if (le16_to_cpu(udev->descriptor.bcdUSB) == 0x0200) { 996 struct usb_qualifier_descriptor *d = NULL; 997 998 /* device qualifier [9.6.2] */ 999 retval = usb_get_descriptor(udev, 1000 USB_DT_DEVICE_QUALIFIER, 0, dev->buf, 1001 sizeof(struct usb_qualifier_descriptor)); 1002 if (retval == -EPIPE) { 1003 if (udev->speed == USB_SPEED_HIGH) { 1004 dev_err(&iface->dev, 1005 "hs dev qualifier --> %d\n", 1006 retval); 1007 return retval; 1008 } 1009 /* usb2.0 but not high-speed capable; fine */ 1010 } else if (retval != sizeof(struct usb_qualifier_descriptor)) { 1011 dev_err(&iface->dev, "dev qualifier --> %d\n", retval); 1012 return (retval < 0) ? retval : -EDOM; 1013 } else 1014 d = (struct usb_qualifier_descriptor *) dev->buf; 1015 1016 /* might not have [9.6.2] any other-speed configs [9.6.4] */ 1017 if (d) { 1018 unsigned max = d->bNumConfigurations; 1019 for (i = 0; i < max; i++) { 1020 retval = usb_get_descriptor(udev, 1021 USB_DT_OTHER_SPEED_CONFIG, i, 1022 dev->buf, TBUF_SIZE); 1023 if (!is_good_config(dev, retval)) { 1024 dev_err(&iface->dev, 1025 "other speed config --> %d\n", 1026 retval); 1027 return (retval < 0) ? retval : -EDOM; 1028 } 1029 } 1030 } 1031 } 1032 /* FIXME fetch strings from at least the device descriptor */ 1033 1034 /* [9.4.5] get_status always works */ 1035 retval = usb_get_std_status(udev, USB_RECIP_DEVICE, 0, dev->buf); 1036 if (retval) { 1037 dev_err(&iface->dev, "get dev status --> %d\n", retval); 1038 return retval; 1039 } 1040 1041 /* FIXME configuration.bmAttributes says if we could try to set/clear 1042 * the device's remote wakeup feature ... if we can, test that here 1043 */ 1044 1045 retval = usb_get_std_status(udev, USB_RECIP_INTERFACE, 1046 iface->altsetting[0].desc.bInterfaceNumber, dev->buf); 1047 if (retval) { 1048 dev_err(&iface->dev, "get interface status --> %d\n", retval); 1049 return retval; 1050 } 1051 /* FIXME get status for each endpoint in the interface */ 1052 1053 return 0; 1054} 1055 1056/*-------------------------------------------------------------------------*/ 1057 1058/* use ch9 requests to test whether: 1059 * (a) queues work for control, keeping N subtests queued and 1060 * active (auto-resubmit) for M loops through the queue. 1061 * (b) protocol stalls (control-only) will autorecover. 1062 * it's not like bulk/intr; no halt clearing. 1063 * (c) short control reads are reported and handled. 1064 * (d) queues are always processed in-order 1065 */ 1066 1067struct ctrl_ctx { 1068 spinlock_t lock; 1069 struct usbtest_dev *dev; 1070 struct completion complete; 1071 unsigned count; 1072 unsigned pending; 1073 int status; 1074 struct urb **urb; 1075 struct usbtest_param_32 *param; 1076 int last; 1077}; 1078 1079#define NUM_SUBCASES 16 /* how many test subcases here? */ 1080 1081struct subcase { 1082 struct usb_ctrlrequest setup; 1083 int number; 1084 int expected; 1085}; 1086 1087static void ctrl_complete(struct urb *urb) 1088{ 1089 struct ctrl_ctx *ctx = urb->context; 1090 struct usb_ctrlrequest *reqp; 1091 struct subcase *subcase; 1092 int status = urb->status; 1093 unsigned long flags; 1094 1095 reqp = (struct usb_ctrlrequest *)urb->setup_packet; 1096 subcase = container_of(reqp, struct subcase, setup); 1097 1098 spin_lock_irqsave(&ctx->lock, flags); 1099 ctx->count--; 1100 ctx->pending--; 1101 1102 /* queue must transfer and complete in fifo order, unless 1103 * usb_unlink_urb() is used to unlink something not at the 1104 * physical queue head (not tested). 1105 */ 1106 if (subcase->number > 0) { 1107 if ((subcase->number - ctx->last) != 1) { 1108 ERROR(ctx->dev, 1109 "subcase %d completed out of order, last %d\n", 1110 subcase->number, ctx->last); 1111 status = -EDOM; 1112 ctx->last = subcase->number; 1113 goto error; 1114 } 1115 } 1116 ctx->last = subcase->number; 1117 1118 /* succeed or fault in only one way? */ 1119 if (status == subcase->expected) 1120 status = 0; 1121 1122 /* async unlink for cleanup? */ 1123 else if (status != -ECONNRESET) { 1124 1125 /* some faults are allowed, not required */ 1126 if (subcase->expected > 0 && ( 1127 ((status == -subcase->expected /* happened */ 1128 || status == 0)))) /* didn't */ 1129 status = 0; 1130 /* sometimes more than one fault is allowed */ 1131 else if (subcase->number == 12 && status == -EPIPE) 1132 status = 0; 1133 else 1134 ERROR(ctx->dev, "subtest %d error, status %d\n", 1135 subcase->number, status); 1136 } 1137 1138 /* unexpected status codes mean errors; ideally, in hardware */ 1139 if (status) { 1140error: 1141 if (ctx->status == 0) { 1142 int i; 1143 1144 ctx->status = status; 1145 ERROR(ctx->dev, "control queue %02x.%02x, err %d, " 1146 "%d left, subcase %d, len %d/%d\n", 1147 reqp->bRequestType, reqp->bRequest, 1148 status, ctx->count, subcase->number, 1149 urb->actual_length, 1150 urb->transfer_buffer_length); 1151 1152 /* FIXME this "unlink everything" exit route should 1153 * be a separate test case. 1154 */ 1155 1156 /* unlink whatever's still pending */ 1157 for (i = 1; i < ctx->param->sglen; i++) { 1158 struct urb *u = ctx->urb[ 1159 (i + subcase->number) 1160 % ctx->param->sglen]; 1161 1162 if (u == urb || !u->dev) 1163 continue; 1164 spin_unlock(&ctx->lock); 1165 status = usb_unlink_urb(u); 1166 spin_lock(&ctx->lock); 1167 switch (status) { 1168 case -EINPROGRESS: 1169 case -EBUSY: 1170 case -EIDRM: 1171 continue; 1172 default: 1173 ERROR(ctx->dev, "urb unlink --> %d\n", 1174 status); 1175 } 1176 } 1177 status = ctx->status; 1178 } 1179 } 1180 1181 /* resubmit if we need to, else mark this as done */ 1182 if ((status == 0) && (ctx->pending < ctx->count)) { 1183 status = usb_submit_urb(urb, GFP_ATOMIC); 1184 if (status != 0) { 1185 ERROR(ctx->dev, 1186 "can't resubmit ctrl %02x.%02x, err %d\n", 1187 reqp->bRequestType, reqp->bRequest, status); 1188 urb->dev = NULL; 1189 } else 1190 ctx->pending++; 1191 } else 1192 urb->dev = NULL; 1193 1194 /* signal completion when nothing's queued */ 1195 if (ctx->pending == 0) 1196 complete(&ctx->complete); 1197 spin_unlock_irqrestore(&ctx->lock, flags); 1198} 1199 1200static int 1201test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param_32 *param) 1202{ 1203 struct usb_device *udev = testdev_to_usbdev(dev); 1204 struct urb **urb; 1205 struct ctrl_ctx context; 1206 int i; 1207 1208 if (param->sglen == 0 || param->iterations > UINT_MAX / param->sglen) 1209 return -EOPNOTSUPP; 1210 1211 spin_lock_init(&context.lock); 1212 context.dev = dev; 1213 init_completion(&context.complete); 1214 context.count = param->sglen * param->iterations; 1215 context.pending = 0; 1216 context.status = -ENOMEM; 1217 context.param = param; 1218 context.last = -1; 1219 1220 /* allocate and init the urbs we'll queue. 1221 * as with bulk/intr sglists, sglen is the queue depth; it also 1222 * controls which subtests run (more tests than sglen) or rerun. 1223 */ 1224 urb = kcalloc(param->sglen, sizeof(struct urb *), GFP_KERNEL); 1225 if (!urb) 1226 return -ENOMEM; 1227 for (i = 0; i < param->sglen; i++) { 1228 int pipe = usb_rcvctrlpipe(udev, 0); 1229 unsigned len; 1230 struct urb *u; 1231 struct usb_ctrlrequest req; 1232 struct subcase *reqp; 1233 1234 /* sign of this variable means: 1235 * -: tested code must return this (negative) error code 1236 * +: tested code may return this (negative too) error code 1237 */ 1238 int expected = 0; 1239 1240 /* requests here are mostly expected to succeed on any 1241 * device, but some are chosen to trigger protocol stalls 1242 * or short reads. 1243 */ 1244 memset(&req, 0, sizeof(req)); 1245 req.bRequest = USB_REQ_GET_DESCRIPTOR; 1246 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE; 1247 1248 switch (i % NUM_SUBCASES) { 1249 case 0: /* get device descriptor */ 1250 req.wValue = cpu_to_le16(USB_DT_DEVICE << 8); 1251 len = sizeof(struct usb_device_descriptor); 1252 break; 1253 case 1: /* get first config descriptor (only) */ 1254 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0); 1255 len = sizeof(struct usb_config_descriptor); 1256 break; 1257 case 2: /* get altsetting (OFTEN STALLS) */ 1258 req.bRequest = USB_REQ_GET_INTERFACE; 1259 req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE; 1260 /* index = 0 means first interface */ 1261 len = 1; 1262 expected = EPIPE; 1263 break; 1264 case 3: /* get interface status */ 1265 req.bRequest = USB_REQ_GET_STATUS; 1266 req.bRequestType = USB_DIR_IN|USB_RECIP_INTERFACE; 1267 /* interface 0 */ 1268 len = 2; 1269 break; 1270 case 4: /* get device status */ 1271 req.bRequest = USB_REQ_GET_STATUS; 1272 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE; 1273 len = 2; 1274 break; 1275 case 5: /* get device qualifier (MAY STALL) */ 1276 req.wValue = cpu_to_le16 (USB_DT_DEVICE_QUALIFIER << 8); 1277 len = sizeof(struct usb_qualifier_descriptor); 1278 if (udev->speed != USB_SPEED_HIGH) 1279 expected = EPIPE; 1280 break; 1281 case 6: /* get first config descriptor, plus interface */ 1282 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0); 1283 len = sizeof(struct usb_config_descriptor); 1284 len += sizeof(struct usb_interface_descriptor); 1285 break; 1286 case 7: /* get interface descriptor (ALWAYS STALLS) */ 1287 req.wValue = cpu_to_le16 (USB_DT_INTERFACE << 8); 1288 /* interface == 0 */ 1289 len = sizeof(struct usb_interface_descriptor); 1290 expected = -EPIPE; 1291 break; 1292 /* NOTE: two consecutive stalls in the queue here. 1293 * that tests fault recovery a bit more aggressively. */ 1294 case 8: /* clear endpoint halt (MAY STALL) */ 1295 req.bRequest = USB_REQ_CLEAR_FEATURE; 1296 req.bRequestType = USB_RECIP_ENDPOINT; 1297 /* wValue 0 == ep halt */ 1298 /* wIndex 0 == ep0 (shouldn't halt!) */ 1299 len = 0; 1300 pipe = usb_sndctrlpipe(udev, 0); 1301 expected = EPIPE; 1302 break; 1303 case 9: /* get endpoint status */ 1304 req.bRequest = USB_REQ_GET_STATUS; 1305 req.bRequestType = USB_DIR_IN|USB_RECIP_ENDPOINT; 1306 /* endpoint 0 */ 1307 len = 2; 1308 break; 1309 case 10: /* trigger short read (EREMOTEIO) */ 1310 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0); 1311 len = 1024; 1312 expected = -EREMOTEIO; 1313 break; 1314 /* NOTE: two consecutive _different_ faults in the queue. */ 1315 case 11: /* get endpoint descriptor (ALWAYS STALLS) */ 1316 req.wValue = cpu_to_le16(USB_DT_ENDPOINT << 8); 1317 /* endpoint == 0 */ 1318 len = sizeof(struct usb_interface_descriptor); 1319 expected = EPIPE; 1320 break; 1321 /* NOTE: sometimes even a third fault in the queue! */ 1322 case 12: /* get string 0 descriptor (MAY STALL) */ 1323 req.wValue = cpu_to_le16(USB_DT_STRING << 8); 1324 /* string == 0, for language IDs */ 1325 len = sizeof(struct usb_interface_descriptor); 1326 /* may succeed when > 4 languages */ 1327 expected = EREMOTEIO; /* or EPIPE, if no strings */ 1328 break; 1329 case 13: /* short read, resembling case 10 */ 1330 req.wValue = cpu_to_le16((USB_DT_CONFIG << 8) | 0); 1331 /* last data packet "should" be DATA1, not DATA0 */ 1332 if (udev->speed == USB_SPEED_SUPER) 1333 len = 1024 - 512; 1334 else 1335 len = 1024 - udev->descriptor.bMaxPacketSize0; 1336 expected = -EREMOTEIO; 1337 break; 1338 case 14: /* short read; try to fill the last packet */ 1339 req.wValue = cpu_to_le16((USB_DT_DEVICE << 8) | 0); 1340 /* device descriptor size == 18 bytes */ 1341 len = udev->descriptor.bMaxPacketSize0; 1342 if (udev->speed == USB_SPEED_SUPER) 1343 len = 512; 1344 switch (len) { 1345 case 8: 1346 len = 24; 1347 break; 1348 case 16: 1349 len = 32; 1350 break; 1351 } 1352 expected = -EREMOTEIO; 1353 break; 1354 case 15: 1355 req.wValue = cpu_to_le16(USB_DT_BOS << 8); 1356 if (udev->bos) 1357 len = le16_to_cpu(udev->bos->desc->wTotalLength); 1358 else 1359 len = sizeof(struct usb_bos_descriptor); 1360 if (le16_to_cpu(udev->descriptor.bcdUSB) < 0x0201) 1361 expected = -EPIPE; 1362 break; 1363 default: 1364 ERROR(dev, "bogus number of ctrl queue testcases!\n"); 1365 context.status = -EINVAL; 1366 goto cleanup; 1367 } 1368 req.wLength = cpu_to_le16(len); 1369 urb[i] = u = simple_alloc_urb(udev, pipe, len, 0); 1370 if (!u) 1371 goto cleanup; 1372 1373 reqp = kmalloc(sizeof(*reqp), GFP_KERNEL); 1374 if (!reqp) 1375 goto cleanup; 1376 reqp->setup = req; 1377 reqp->number = i % NUM_SUBCASES; 1378 reqp->expected = expected; 1379 u->setup_packet = (char *) &reqp->setup; 1380 1381 u->context = &context; 1382 u->complete = ctrl_complete; 1383 } 1384 1385 /* queue the urbs */ 1386 context.urb = urb; 1387 spin_lock_irq(&context.lock); 1388 for (i = 0; i < param->sglen; i++) { 1389 context.status = usb_submit_urb(urb[i], GFP_ATOMIC); 1390 if (context.status != 0) { 1391 ERROR(dev, "can't submit urb[%d], status %d\n", 1392 i, context.status); 1393 context.count = context.pending; 1394 break; 1395 } 1396 context.pending++; 1397 } 1398 spin_unlock_irq(&context.lock); 1399 1400 /* FIXME set timer and time out; provide a disconnect hook */ 1401 1402 /* wait for the last one to complete */ 1403 if (context.pending > 0) 1404 wait_for_completion(&context.complete); 1405 1406cleanup: 1407 for (i = 0; i < param->sglen; i++) { 1408 if (!urb[i]) 1409 continue; 1410 urb[i]->dev = udev; 1411 kfree(urb[i]->setup_packet); 1412 simple_free_urb(urb[i]); 1413 } 1414 kfree(urb); 1415 return context.status; 1416} 1417#undef NUM_SUBCASES 1418 1419 1420/*-------------------------------------------------------------------------*/ 1421 1422static void unlink1_callback(struct urb *urb) 1423{ 1424 int status = urb->status; 1425 1426 /* we "know" -EPIPE (stall) never happens */ 1427 if (!status) 1428 status = usb_submit_urb(urb, GFP_ATOMIC); 1429 if (status) { 1430 urb->status = status; 1431 complete(urb->context); 1432 } 1433} 1434 1435static int unlink1(struct usbtest_dev *dev, int pipe, int size, int async) 1436{ 1437 struct urb *urb; 1438 struct completion completion; 1439 int retval = 0; 1440 1441 init_completion(&completion); 1442 urb = simple_alloc_urb(testdev_to_usbdev(dev), pipe, size, 0); 1443 if (!urb) 1444 return -ENOMEM; 1445 urb->context = &completion; 1446 urb->complete = unlink1_callback; 1447 1448 if (usb_pipeout(urb->pipe)) { 1449 simple_fill_buf(urb); 1450 urb->transfer_flags |= URB_ZERO_PACKET; 1451 } 1452 1453 /* keep the endpoint busy. there are lots of hc/hcd-internal 1454 * states, and testing should get to all of them over time. 1455 * 1456 * FIXME want additional tests for when endpoint is STALLing 1457 * due to errors, or is just NAKing requests. 1458 */ 1459 retval = usb_submit_urb(urb, GFP_KERNEL); 1460 if (retval != 0) { 1461 dev_err(&dev->intf->dev, "submit fail %d\n", retval); 1462 return retval; 1463 } 1464 1465 /* unlinking that should always work. variable delay tests more 1466 * hcd states and code paths, even with little other system load. 1467 */ 1468 msleep(jiffies % (2 * INTERRUPT_RATE)); 1469 if (async) { 1470 while (!completion_done(&completion)) { 1471 retval = usb_unlink_urb(urb); 1472 1473 if (retval == 0 && usb_pipein(urb->pipe)) 1474 retval = simple_check_buf(dev, urb); 1475 1476 switch (retval) { 1477 case -EBUSY: 1478 case -EIDRM: 1479 /* we can't unlink urbs while they're completing 1480 * or if they've completed, and we haven't 1481 * resubmitted. "normal" drivers would prevent 1482 * resubmission, but since we're testing unlink 1483 * paths, we can't. 1484 */ 1485 ERROR(dev, "unlink retry\n"); 1486 continue; 1487 case 0: 1488 case -EINPROGRESS: 1489 break; 1490 1491 default: 1492 dev_err(&dev->intf->dev, 1493 "unlink fail %d\n", retval); 1494 return retval; 1495 } 1496 1497 break; 1498 } 1499 } else 1500 usb_kill_urb(urb); 1501 1502 wait_for_completion(&completion); 1503 retval = urb->status; 1504 simple_free_urb(urb); 1505 1506 if (async) 1507 return (retval == -ECONNRESET) ? 0 : retval - 1000; 1508 else 1509 return (retval == -ENOENT || retval == -EPERM) ? 1510 0 : retval - 2000; 1511} 1512 1513static int unlink_simple(struct usbtest_dev *dev, int pipe, int len) 1514{ 1515 int retval = 0; 1516 1517 /* test sync and async paths */ 1518 retval = unlink1(dev, pipe, len, 1); 1519 if (!retval) 1520 retval = unlink1(dev, pipe, len, 0); 1521 return retval; 1522} 1523 1524/*-------------------------------------------------------------------------*/ 1525 1526struct queued_ctx { 1527 struct completion complete; 1528 atomic_t pending; 1529 unsigned num; 1530 int status; 1531 struct urb **urbs; 1532}; 1533 1534static void unlink_queued_callback(struct urb *urb) 1535{ 1536 int status = urb->status; 1537 struct queued_ctx *ctx = urb->context; 1538 1539 if (ctx->status) 1540 goto done; 1541 if (urb == ctx->urbs[ctx->num - 4] || urb == ctx->urbs[ctx->num - 2]) { 1542 if (status == -ECONNRESET) 1543 goto done; 1544 /* What error should we report if the URB completed normally? */ 1545 } 1546 if (status != 0) 1547 ctx->status = status; 1548 1549 done: 1550 if (atomic_dec_and_test(&ctx->pending)) 1551 complete(&ctx->complete); 1552} 1553 1554static int unlink_queued(struct usbtest_dev *dev, int pipe, unsigned num, 1555 unsigned size) 1556{ 1557 struct queued_ctx ctx; 1558 struct usb_device *udev = testdev_to_usbdev(dev); 1559 void *buf; 1560 dma_addr_t buf_dma; 1561 int i; 1562 int retval = -ENOMEM; 1563 1564 init_completion(&ctx.complete); 1565 atomic_set(&ctx.pending, 1); /* One more than the actual value */ 1566 ctx.num = num; 1567 ctx.status = 0; 1568 1569 buf = usb_alloc_coherent(udev, size, GFP_KERNEL, &buf_dma); 1570 if (!buf) 1571 return retval; 1572 memset(buf, 0, size); 1573 1574 /* Allocate and init the urbs we'll queue */ 1575 ctx.urbs = kcalloc(num, sizeof(struct urb *), GFP_KERNEL); 1576 if (!ctx.urbs) 1577 goto free_buf; 1578 for (i = 0; i < num; i++) { 1579 ctx.urbs[i] = usb_alloc_urb(0, GFP_KERNEL); 1580 if (!ctx.urbs[i]) 1581 goto free_urbs; 1582 usb_fill_bulk_urb(ctx.urbs[i], udev, pipe, buf, size, 1583 unlink_queued_callback, &ctx); 1584 ctx.urbs[i]->transfer_dma = buf_dma; 1585 ctx.urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP; 1586 1587 if (usb_pipeout(ctx.urbs[i]->pipe)) { 1588 simple_fill_buf(ctx.urbs[i]); 1589 ctx.urbs[i]->transfer_flags |= URB_ZERO_PACKET; 1590 } 1591 } 1592 1593 /* Submit all the URBs and then unlink URBs num - 4 and num - 2. */ 1594 for (i = 0; i < num; i++) { 1595 atomic_inc(&ctx.pending); 1596 retval = usb_submit_urb(ctx.urbs[i], GFP_KERNEL); 1597 if (retval != 0) { 1598 dev_err(&dev->intf->dev, "submit urbs[%d] fail %d\n", 1599 i, retval); 1600 atomic_dec(&ctx.pending); 1601 ctx.status = retval; 1602 break; 1603 } 1604 } 1605 if (i == num) { 1606 usb_unlink_urb(ctx.urbs[num - 4]); 1607 usb_unlink_urb(ctx.urbs[num - 2]); 1608 } else { 1609 while (--i >= 0) 1610 usb_unlink_urb(ctx.urbs[i]); 1611 } 1612 1613 if (atomic_dec_and_test(&ctx.pending)) /* The extra count */ 1614 complete(&ctx.complete); 1615 wait_for_completion(&ctx.complete); 1616 retval = ctx.status; 1617 1618 free_urbs: 1619 for (i = 0; i < num; i++) 1620 usb_free_urb(ctx.urbs[i]); 1621 kfree(ctx.urbs); 1622 free_buf: 1623 usb_free_coherent(udev, size, buf, buf_dma); 1624 return retval; 1625} 1626 1627/*-------------------------------------------------------------------------*/ 1628 1629static int verify_not_halted(struct usbtest_dev *tdev, int ep, struct urb *urb) 1630{ 1631 int retval; 1632 u16 status; 1633 1634 /* shouldn't look or act halted */ 1635 retval = usb_get_std_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status); 1636 if (retval < 0) { 1637 ERROR(tdev, "ep %02x couldn't get no-halt status, %d\n", 1638 ep, retval); 1639 return retval; 1640 } 1641 if (status != 0) { 1642 ERROR(tdev, "ep %02x bogus status: %04x != 0\n", ep, status); 1643 return -EINVAL; 1644 } 1645 retval = simple_io(tdev, urb, 1, 0, 0, __func__); 1646 if (retval != 0) 1647 return -EINVAL; 1648 return 0; 1649} 1650 1651static int verify_halted(struct usbtest_dev *tdev, int ep, struct urb *urb) 1652{ 1653 int retval; 1654 u16 status; 1655 1656 /* should look and act halted */ 1657 retval = usb_get_std_status(urb->dev, USB_RECIP_ENDPOINT, ep, &status); 1658 if (retval < 0) { 1659 ERROR(tdev, "ep %02x couldn't get halt status, %d\n", 1660 ep, retval); 1661 return retval; 1662 } 1663 if (status != 1) { 1664 ERROR(tdev, "ep %02x bogus status: %04x != 1\n", ep, status); 1665 return -EINVAL; 1666 } 1667 retval = simple_io(tdev, urb, 1, 0, -EPIPE, __func__); 1668 if (retval != -EPIPE) 1669 return -EINVAL; 1670 retval = simple_io(tdev, urb, 1, 0, -EPIPE, "verify_still_halted"); 1671 if (retval != -EPIPE) 1672 return -EINVAL; 1673 return 0; 1674} 1675 1676static int test_halt(struct usbtest_dev *tdev, int ep, struct urb *urb) 1677{ 1678 int retval; 1679 1680 /* shouldn't look or act halted now */ 1681 retval = verify_not_halted(tdev, ep, urb); 1682 if (retval < 0) 1683 return retval; 1684 1685 /* set halt (protocol test only), verify it worked */ 1686 retval = usb_control_msg(urb->dev, usb_sndctrlpipe(urb->dev, 0), 1687 USB_REQ_SET_FEATURE, USB_RECIP_ENDPOINT, 1688 USB_ENDPOINT_HALT, ep, 1689 NULL, 0, USB_CTRL_SET_TIMEOUT); 1690 if (retval < 0) { 1691 ERROR(tdev, "ep %02x couldn't set halt, %d\n", ep, retval); 1692 return retval; 1693 } 1694 retval = verify_halted(tdev, ep, urb); 1695 if (retval < 0) { 1696 int ret; 1697 1698 /* clear halt anyways, else further tests will fail */ 1699 ret = usb_clear_halt(urb->dev, urb->pipe); 1700 if (ret) 1701 ERROR(tdev, "ep %02x couldn't clear halt, %d\n", 1702 ep, ret); 1703 1704 return retval; 1705 } 1706 1707 /* clear halt (tests API + protocol), verify it worked */ 1708 retval = usb_clear_halt(urb->dev, urb->pipe); 1709 if (retval < 0) { 1710 ERROR(tdev, "ep %02x couldn't clear halt, %d\n", ep, retval); 1711 return retval; 1712 } 1713 retval = verify_not_halted(tdev, ep, urb); 1714 if (retval < 0) 1715 return retval; 1716 1717 /* NOTE: could also verify SET_INTERFACE clear halts ... */ 1718 1719 return 0; 1720} 1721 1722static int test_toggle_sync(struct usbtest_dev *tdev, int ep, struct urb *urb) 1723{ 1724 int retval; 1725 1726 /* clear initial data toggle to DATA0 */ 1727 retval = usb_clear_halt(urb->dev, urb->pipe); 1728 if (retval < 0) { 1729 ERROR(tdev, "ep %02x couldn't clear halt, %d\n", ep, retval); 1730 return retval; 1731 } 1732 1733 /* transfer 3 data packets, should be DATA0, DATA1, DATA0 */ 1734 retval = simple_io(tdev, urb, 1, 0, 0, __func__); 1735 if (retval != 0) 1736 return -EINVAL; 1737 1738 /* clear halt resets device side data toggle, host should react to it */ 1739 retval = usb_clear_halt(urb->dev, urb->pipe); 1740 if (retval < 0) { 1741 ERROR(tdev, "ep %02x couldn't clear halt, %d\n", ep, retval); 1742 return retval; 1743 } 1744 1745 /* host should use DATA0 again after clear halt */ 1746 retval = simple_io(tdev, urb, 1, 0, 0, __func__); 1747 1748 return retval; 1749} 1750 1751static int halt_simple(struct usbtest_dev *dev) 1752{ 1753 int ep; 1754 int retval = 0; 1755 struct urb *urb; 1756 struct usb_device *udev = testdev_to_usbdev(dev); 1757 1758 if (udev->speed == USB_SPEED_SUPER) 1759 urb = simple_alloc_urb(udev, 0, 1024, 0); 1760 else 1761 urb = simple_alloc_urb(udev, 0, 512, 0); 1762 if (urb == NULL) 1763 return -ENOMEM; 1764 1765 if (dev->in_pipe) { 1766 ep = usb_pipeendpoint(dev->in_pipe) | USB_DIR_IN; 1767 urb->pipe = dev->in_pipe; 1768 retval = test_halt(dev, ep, urb); 1769 if (retval < 0) 1770 goto done; 1771 } 1772 1773 if (dev->out_pipe) { 1774 ep = usb_pipeendpoint(dev->out_pipe); 1775 urb->pipe = dev->out_pipe; 1776 retval = test_halt(dev, ep, urb); 1777 } 1778done: 1779 simple_free_urb(urb); 1780 return retval; 1781} 1782 1783static int toggle_sync_simple(struct usbtest_dev *dev) 1784{ 1785 int ep; 1786 int retval = 0; 1787 struct urb *urb; 1788 struct usb_device *udev = testdev_to_usbdev(dev); 1789 unsigned maxp = get_maxpacket(udev, dev->out_pipe); 1790 1791 /* 1792 * Create a URB that causes a transfer of uneven amount of data packets 1793 * This way the clear toggle has an impact on the data toggle sequence. 1794 * Use 2 maxpacket length packets and one zero packet. 1795 */ 1796 urb = simple_alloc_urb(udev, 0, 2 * maxp, 0); 1797 if (urb == NULL) 1798 return -ENOMEM; 1799 1800 urb->transfer_flags |= URB_ZERO_PACKET; 1801 1802 ep = usb_pipeendpoint(dev->out_pipe); 1803 urb->pipe = dev->out_pipe; 1804 retval = test_toggle_sync(dev, ep, urb); 1805 1806 simple_free_urb(urb); 1807 return retval; 1808} 1809 1810/*-------------------------------------------------------------------------*/ 1811 1812/* Control OUT tests use the vendor control requests from Intel's 1813 * USB 2.0 compliance test device: write a buffer, read it back. 1814 * 1815 * Intel's spec only _requires_ that it work for one packet, which 1816 * is pretty weak. Some HCDs place limits here; most devices will 1817 * need to be able to handle more than one OUT data packet. We'll 1818 * try whatever we're told to try. 1819 */ 1820static int ctrl_out(struct usbtest_dev *dev, 1821 unsigned count, unsigned length, unsigned vary, unsigned offset) 1822{ 1823 unsigned i, j, len; 1824 int retval; 1825 u8 *buf; 1826 char *what = "?"; 1827 struct usb_device *udev; 1828 1829 if (length < 1 || length > 0xffff || vary >= length) 1830 return -EINVAL; 1831 1832 buf = kmalloc(length + offset, GFP_KERNEL); 1833 if (!buf) 1834 return -ENOMEM; 1835 1836 buf += offset; 1837 udev = testdev_to_usbdev(dev); 1838 len = length; 1839 retval = 0; 1840 1841 /* NOTE: hardware might well act differently if we pushed it 1842 * with lots back-to-back queued requests. 1843 */ 1844 for (i = 0; i < count; i++) { 1845 /* write patterned data */ 1846 for (j = 0; j < len; j++) 1847 buf[j] = (u8)(i + j); 1848 retval = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 1849 0x5b, USB_DIR_OUT|USB_TYPE_VENDOR, 1850 0, 0, buf, len, USB_CTRL_SET_TIMEOUT); 1851 if (retval != len) { 1852 what = "write"; 1853 if (retval >= 0) { 1854 ERROR(dev, "ctrl_out, wlen %d (expected %d)\n", 1855 retval, len); 1856 retval = -EBADMSG; 1857 } 1858 break; 1859 } 1860 1861 /* read it back -- assuming nothing intervened!! */ 1862 retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 1863 0x5c, USB_DIR_IN|USB_TYPE_VENDOR, 1864 0, 0, buf, len, USB_CTRL_GET_TIMEOUT); 1865 if (retval != len) { 1866 what = "read"; 1867 if (retval >= 0) { 1868 ERROR(dev, "ctrl_out, rlen %d (expected %d)\n", 1869 retval, len); 1870 retval = -EBADMSG; 1871 } 1872 break; 1873 } 1874 1875 /* fail if we can't verify */ 1876 for (j = 0; j < len; j++) { 1877 if (buf[j] != (u8)(i + j)) { 1878 ERROR(dev, "ctrl_out, byte %d is %d not %d\n", 1879 j, buf[j], (u8)(i + j)); 1880 retval = -EBADMSG; 1881 break; 1882 } 1883 } 1884 if (retval < 0) { 1885 what = "verify"; 1886 break; 1887 } 1888 1889 len += vary; 1890 1891 /* [real world] the "zero bytes IN" case isn't really used. 1892 * hardware can easily trip up in this weird case, since its 1893 * status stage is IN, not OUT like other ep0in transfers. 1894 */ 1895 if (len > length) 1896 len = realworld ? 1 : 0; 1897 } 1898 1899 if (retval < 0) 1900 ERROR(dev, "ctrl_out %s failed, code %d, count %d\n", 1901 what, retval, i); 1902 1903 kfree(buf - offset); 1904 return retval; 1905} 1906 1907/*-------------------------------------------------------------------------*/ 1908 1909/* ISO/BULK tests ... mimics common usage 1910 * - buffer length is split into N packets (mostly maxpacket sized) 1911 * - multi-buffers according to sglen 1912 */ 1913 1914struct transfer_context { 1915 unsigned count; 1916 unsigned pending; 1917 spinlock_t lock; 1918 struct completion done; 1919 int submit_error; 1920 unsigned long errors; 1921 unsigned long packet_count; 1922 struct usbtest_dev *dev; 1923 bool is_iso; 1924}; 1925 1926static void complicated_callback(struct urb *urb) 1927{ 1928 struct transfer_context *ctx = urb->context; 1929 unsigned long flags; 1930 1931 spin_lock_irqsave(&ctx->lock, flags); 1932 ctx->count--; 1933 1934 ctx->packet_count += urb->number_of_packets; 1935 if (urb->error_count > 0) 1936 ctx->errors += urb->error_count; 1937 else if (urb->status != 0) 1938 ctx->errors += (ctx->is_iso ? urb->number_of_packets : 1); 1939 else if (urb->actual_length != urb->transfer_buffer_length) 1940 ctx->errors++; 1941 else if (check_guard_bytes(ctx->dev, urb) != 0) 1942 ctx->errors++; 1943 1944 if (urb->status == 0 && ctx->count > (ctx->pending - 1) 1945 && !ctx->submit_error) { 1946 int status = usb_submit_urb(urb, GFP_ATOMIC); 1947 switch (status) { 1948 case 0: 1949 goto done; 1950 default: 1951 dev_err(&ctx->dev->intf->dev, 1952 "resubmit err %d\n", 1953 status); 1954 fallthrough; 1955 case -ENODEV: /* disconnected */ 1956 case -ESHUTDOWN: /* endpoint disabled */ 1957 ctx->submit_error = 1; 1958 break; 1959 } 1960 } 1961 1962 ctx->pending--; 1963 if (ctx->pending == 0) { 1964 if (ctx->errors) 1965 dev_err(&ctx->dev->intf->dev, 1966 "during the test, %lu errors out of %lu\n", 1967 ctx->errors, ctx->packet_count); 1968 complete(&ctx->done); 1969 } 1970done: 1971 spin_unlock_irqrestore(&ctx->lock, flags); 1972} 1973 1974static struct urb *iso_alloc_urb( 1975 struct usb_device *udev, 1976 int pipe, 1977 struct usb_endpoint_descriptor *desc, 1978 long bytes, 1979 unsigned offset 1980) 1981{ 1982 struct urb *urb; 1983 unsigned i, maxp, packets; 1984 1985 if (bytes < 0 || !desc) 1986 return NULL; 1987 1988 maxp = usb_endpoint_maxp(desc); 1989 if (udev->speed >= USB_SPEED_SUPER) 1990 maxp *= ss_isoc_get_packet_num(udev, pipe); 1991 else 1992 maxp *= usb_endpoint_maxp_mult(desc); 1993 1994 packets = DIV_ROUND_UP(bytes, maxp); 1995 1996 urb = usb_alloc_urb(packets, GFP_KERNEL); 1997 if (!urb) 1998 return urb; 1999 urb->dev = udev; 2000 urb->pipe = pipe; 2001 2002 urb->number_of_packets = packets; 2003 urb->transfer_buffer_length = bytes; 2004 urb->transfer_buffer = usb_alloc_coherent(udev, bytes + offset, 2005 GFP_KERNEL, 2006 &urb->transfer_dma); 2007 if (!urb->transfer_buffer) { 2008 usb_free_urb(urb); 2009 return NULL; 2010 } 2011 if (offset) { 2012 memset(urb->transfer_buffer, GUARD_BYTE, offset); 2013 urb->transfer_buffer += offset; 2014 urb->transfer_dma += offset; 2015 } 2016 /* For inbound transfers use guard byte so that test fails if 2017 data not correctly copied */ 2018 memset(urb->transfer_buffer, 2019 usb_pipein(urb->pipe) ? GUARD_BYTE : 0, 2020 bytes); 2021 2022 for (i = 0; i < packets; i++) { 2023 /* here, only the last packet will be short */ 2024 urb->iso_frame_desc[i].length = min((unsigned) bytes, maxp); 2025 bytes -= urb->iso_frame_desc[i].length; 2026 2027 urb->iso_frame_desc[i].offset = maxp * i; 2028 } 2029 2030 urb->complete = complicated_callback; 2031 /* urb->context = SET BY CALLER */ 2032 urb->interval = 1 << (desc->bInterval - 1); 2033 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; 2034 return urb; 2035} 2036 2037static int 2038test_queue(struct usbtest_dev *dev, struct usbtest_param_32 *param, 2039 int pipe, struct usb_endpoint_descriptor *desc, unsigned offset) 2040{ 2041 struct transfer_context context; 2042 struct usb_device *udev; 2043 unsigned i; 2044 unsigned long packets = 0; 2045 int status = 0; 2046 struct urb **urbs; 2047 2048 if (!param->sglen || param->iterations > UINT_MAX / param->sglen) 2049 return -EINVAL; 2050 2051 if (param->sglen > MAX_SGLEN) 2052 return -EINVAL; 2053 2054 urbs = kcalloc(param->sglen, sizeof(*urbs), GFP_KERNEL); 2055 if (!urbs) 2056 return -ENOMEM; 2057 2058 memset(&context, 0, sizeof(context)); 2059 context.count = param->iterations * param->sglen; 2060 context.dev = dev; 2061 context.is_iso = !!desc; 2062 init_completion(&context.done); 2063 spin_lock_init(&context.lock); 2064 2065 udev = testdev_to_usbdev(dev); 2066 2067 for (i = 0; i < param->sglen; i++) { 2068 if (context.is_iso) 2069 urbs[i] = iso_alloc_urb(udev, pipe, desc, 2070 param->length, offset); 2071 else 2072 urbs[i] = complicated_alloc_urb(udev, pipe, 2073 param->length, 0); 2074 2075 if (!urbs[i]) { 2076 status = -ENOMEM; 2077 goto fail; 2078 } 2079 packets += urbs[i]->number_of_packets; 2080 urbs[i]->context = &context; 2081 } 2082 packets *= param->iterations; 2083 2084 if (context.is_iso) { 2085 int transaction_num; 2086 2087 if (udev->speed >= USB_SPEED_SUPER) 2088 transaction_num = ss_isoc_get_packet_num(udev, pipe); 2089 else 2090 transaction_num = usb_endpoint_maxp_mult(desc); 2091 2092 dev_info(&dev->intf->dev, 2093 "iso period %d %sframes, wMaxPacket %d, transactions: %d\n", 2094 1 << (desc->bInterval - 1), 2095 (udev->speed >= USB_SPEED_HIGH) ? "micro" : "", 2096 usb_endpoint_maxp(desc), 2097 transaction_num); 2098 2099 dev_info(&dev->intf->dev, 2100 "total %lu msec (%lu packets)\n", 2101 (packets * (1 << (desc->bInterval - 1))) 2102 / ((udev->speed >= USB_SPEED_HIGH) ? 8 : 1), 2103 packets); 2104 } 2105 2106 spin_lock_irq(&context.lock); 2107 for (i = 0; i < param->sglen; i++) { 2108 ++context.pending; 2109 status = usb_submit_urb(urbs[i], GFP_ATOMIC); 2110 if (status < 0) { 2111 ERROR(dev, "submit iso[%d], error %d\n", i, status); 2112 if (i == 0) { 2113 spin_unlock_irq(&context.lock); 2114 goto fail; 2115 } 2116 2117 simple_free_urb(urbs[i]); 2118 urbs[i] = NULL; 2119 context.pending--; 2120 context.submit_error = 1; 2121 break; 2122 } 2123 } 2124 spin_unlock_irq(&context.lock); 2125 2126 wait_for_completion(&context.done); 2127 2128 for (i = 0; i < param->sglen; i++) { 2129 if (urbs[i]) 2130 simple_free_urb(urbs[i]); 2131 } 2132 /* 2133 * Isochronous transfers are expected to fail sometimes. As an 2134 * arbitrary limit, we will report an error if any submissions 2135 * fail or if the transfer failure rate is > 10%. 2136 */ 2137 if (status != 0) 2138 ; 2139 else if (context.submit_error) 2140 status = -EACCES; 2141 else if (context.errors > 2142 (context.is_iso ? context.packet_count / 10 : 0)) 2143 status = -EIO; 2144 2145 kfree(urbs); 2146 return status; 2147 2148fail: 2149 for (i = 0; i < param->sglen; i++) { 2150 if (urbs[i]) 2151 simple_free_urb(urbs[i]); 2152 } 2153 2154 kfree(urbs); 2155 return status; 2156} 2157 2158static int test_unaligned_bulk( 2159 struct usbtest_dev *tdev, 2160 int pipe, 2161 unsigned length, 2162 int iterations, 2163 unsigned transfer_flags, 2164 const char *label) 2165{ 2166 int retval; 2167 struct urb *urb = usbtest_alloc_urb(testdev_to_usbdev(tdev), 2168 pipe, length, transfer_flags, 1, 0, simple_callback); 2169 2170 if (!urb) 2171 return -ENOMEM; 2172 2173 retval = simple_io(tdev, urb, iterations, 0, 0, label); 2174 simple_free_urb(urb); 2175 return retval; 2176} 2177 2178/* Run tests. */ 2179static int 2180usbtest_do_ioctl(struct usb_interface *intf, struct usbtest_param_32 *param) 2181{ 2182 struct usbtest_dev *dev = usb_get_intfdata(intf); 2183 struct usb_device *udev = testdev_to_usbdev(dev); 2184 struct urb *urb; 2185 struct scatterlist *sg; 2186 struct usb_sg_request req; 2187 unsigned i; 2188 int retval = -EOPNOTSUPP; 2189 2190 if (param->iterations <= 0) 2191 return -EINVAL; 2192 if (param->sglen > MAX_SGLEN) 2193 return -EINVAL; 2194 /* 2195 * Just a bunch of test cases that every HCD is expected to handle. 2196 * 2197 * Some may need specific firmware, though it'd be good to have 2198 * one firmware image to handle all the test cases. 2199 * 2200 * FIXME add more tests! cancel requests, verify the data, control 2201 * queueing, concurrent read+write threads, and so on. 2202 */ 2203 switch (param->test_num) { 2204 2205 case 0: 2206 dev_info(&intf->dev, "TEST 0: NOP\n"); 2207 retval = 0; 2208 break; 2209 2210 /* Simple non-queued bulk I/O tests */ 2211 case 1: 2212 if (dev->out_pipe == 0) 2213 break; 2214 dev_info(&intf->dev, 2215 "TEST 1: write %d bytes %u times\n", 2216 param->length, param->iterations); 2217 urb = simple_alloc_urb(udev, dev->out_pipe, param->length, 0); 2218 if (!urb) { 2219 retval = -ENOMEM; 2220 break; 2221 } 2222 /* FIRMWARE: bulk sink (maybe accepts short writes) */ 2223 retval = simple_io(dev, urb, param->iterations, 0, 0, "test1"); 2224 simple_free_urb(urb); 2225 break; 2226 case 2: 2227 if (dev->in_pipe == 0) 2228 break; 2229 dev_info(&intf->dev, 2230 "TEST 2: read %d bytes %u times\n", 2231 param->length, param->iterations); 2232 urb = simple_alloc_urb(udev, dev->in_pipe, param->length, 0); 2233 if (!urb) { 2234 retval = -ENOMEM; 2235 break; 2236 } 2237 /* FIRMWARE: bulk source (maybe generates short writes) */ 2238 retval = simple_io(dev, urb, param->iterations, 0, 0, "test2"); 2239 simple_free_urb(urb); 2240 break; 2241 case 3: 2242 if (dev->out_pipe == 0 || param->vary == 0) 2243 break; 2244 dev_info(&intf->dev, 2245 "TEST 3: write/%d 0..%d bytes %u times\n", 2246 param->vary, param->length, param->iterations); 2247 urb = simple_alloc_urb(udev, dev->out_pipe, param->length, 0); 2248 if (!urb) { 2249 retval = -ENOMEM; 2250 break; 2251 } 2252 /* FIRMWARE: bulk sink (maybe accepts short writes) */ 2253 retval = simple_io(dev, urb, param->iterations, param->vary, 2254 0, "test3"); 2255 simple_free_urb(urb); 2256 break; 2257 case 4: 2258 if (dev->in_pipe == 0 || param->vary == 0) 2259 break; 2260 dev_info(&intf->dev, 2261 "TEST 4: read/%d 0..%d bytes %u times\n", 2262 param->vary, param->length, param->iterations); 2263 urb = simple_alloc_urb(udev, dev->in_pipe, param->length, 0); 2264 if (!urb) { 2265 retval = -ENOMEM; 2266 break; 2267 } 2268 /* FIRMWARE: bulk source (maybe generates short writes) */ 2269 retval = simple_io(dev, urb, param->iterations, param->vary, 2270 0, "test4"); 2271 simple_free_urb(urb); 2272 break; 2273 2274 /* Queued bulk I/O tests */ 2275 case 5: 2276 if (dev->out_pipe == 0 || param->sglen == 0) 2277 break; 2278 dev_info(&intf->dev, 2279 "TEST 5: write %d sglists %d entries of %d bytes\n", 2280 param->iterations, 2281 param->sglen, param->length); 2282 sg = alloc_sglist(param->sglen, param->length, 2283 0, dev, dev->out_pipe); 2284 if (!sg) { 2285 retval = -ENOMEM; 2286 break; 2287 } 2288 /* FIRMWARE: bulk sink (maybe accepts short writes) */ 2289 retval = perform_sglist(dev, param->iterations, dev->out_pipe, 2290 &req, sg, param->sglen); 2291 free_sglist(sg, param->sglen); 2292 break; 2293 2294 case 6: 2295 if (dev->in_pipe == 0 || param->sglen == 0) 2296 break; 2297 dev_info(&intf->dev, 2298 "TEST 6: read %d sglists %d entries of %d bytes\n", 2299 param->iterations, 2300 param->sglen, param->length); 2301 sg = alloc_sglist(param->sglen, param->length, 2302 0, dev, dev->in_pipe); 2303 if (!sg) { 2304 retval = -ENOMEM; 2305 break; 2306 } 2307 /* FIRMWARE: bulk source (maybe generates short writes) */ 2308 retval = perform_sglist(dev, param->iterations, dev->in_pipe, 2309 &req, sg, param->sglen); 2310 free_sglist(sg, param->sglen); 2311 break; 2312 case 7: 2313 if (dev->out_pipe == 0 || param->sglen == 0 || param->vary == 0) 2314 break; 2315 dev_info(&intf->dev, 2316 "TEST 7: write/%d %d sglists %d entries 0..%d bytes\n", 2317 param->vary, param->iterations, 2318 param->sglen, param->length); 2319 sg = alloc_sglist(param->sglen, param->length, 2320 param->vary, dev, dev->out_pipe); 2321 if (!sg) { 2322 retval = -ENOMEM; 2323 break; 2324 } 2325 /* FIRMWARE: bulk sink (maybe accepts short writes) */ 2326 retval = perform_sglist(dev, param->iterations, dev->out_pipe, 2327 &req, sg, param->sglen); 2328 free_sglist(sg, param->sglen); 2329 break; 2330 case 8: 2331 if (dev->in_pipe == 0 || param->sglen == 0 || param->vary == 0) 2332 break; 2333 dev_info(&intf->dev, 2334 "TEST 8: read/%d %d sglists %d entries 0..%d bytes\n", 2335 param->vary, param->iterations, 2336 param->sglen, param->length); 2337 sg = alloc_sglist(param->sglen, param->length, 2338 param->vary, dev, dev->in_pipe); 2339 if (!sg) { 2340 retval = -ENOMEM; 2341 break; 2342 } 2343 /* FIRMWARE: bulk source (maybe generates short writes) */ 2344 retval = perform_sglist(dev, param->iterations, dev->in_pipe, 2345 &req, sg, param->sglen); 2346 free_sglist(sg, param->sglen); 2347 break; 2348 2349 /* non-queued sanity tests for control (chapter 9 subset) */ 2350 case 9: 2351 retval = 0; 2352 dev_info(&intf->dev, 2353 "TEST 9: ch9 (subset) control tests, %d times\n", 2354 param->iterations); 2355 for (i = param->iterations; retval == 0 && i--; /* NOP */) 2356 retval = ch9_postconfig(dev); 2357 if (retval) 2358 dev_err(&intf->dev, "ch9 subset failed, " 2359 "iterations left %d\n", i); 2360 break; 2361 2362 /* queued control messaging */ 2363 case 10: 2364 retval = 0; 2365 dev_info(&intf->dev, 2366 "TEST 10: queue %d control calls, %d times\n", 2367 param->sglen, 2368 param->iterations); 2369 retval = test_ctrl_queue(dev, param); 2370 break; 2371 2372 /* simple non-queued unlinks (ring with one urb) */ 2373 case 11: 2374 if (dev->in_pipe == 0 || !param->length) 2375 break; 2376 retval = 0; 2377 dev_info(&intf->dev, "TEST 11: unlink %d reads of %d\n", 2378 param->iterations, param->length); 2379 for (i = param->iterations; retval == 0 && i--; /* NOP */) 2380 retval = unlink_simple(dev, dev->in_pipe, 2381 param->length); 2382 if (retval) 2383 dev_err(&intf->dev, "unlink reads failed %d, " 2384 "iterations left %d\n", retval, i); 2385 break; 2386 case 12: 2387 if (dev->out_pipe == 0 || !param->length) 2388 break; 2389 retval = 0; 2390 dev_info(&intf->dev, "TEST 12: unlink %d writes of %d\n", 2391 param->iterations, param->length); 2392 for (i = param->iterations; retval == 0 && i--; /* NOP */) 2393 retval = unlink_simple(dev, dev->out_pipe, 2394 param->length); 2395 if (retval) 2396 dev_err(&intf->dev, "unlink writes failed %d, " 2397 "iterations left %d\n", retval, i); 2398 break; 2399 2400 /* ep halt tests */ 2401 case 13: 2402 if (dev->out_pipe == 0 && dev->in_pipe == 0) 2403 break; 2404 retval = 0; 2405 dev_info(&intf->dev, "TEST 13: set/clear %d halts\n", 2406 param->iterations); 2407 for (i = param->iterations; retval == 0 && i--; /* NOP */) 2408 retval = halt_simple(dev); 2409 2410 if (retval) 2411 ERROR(dev, "halts failed, iterations left %d\n", i); 2412 break; 2413 2414 /* control write tests */ 2415 case 14: 2416 if (!dev->info->ctrl_out) 2417 break; 2418 dev_info(&intf->dev, "TEST 14: %d ep0out, %d..%d vary %d\n", 2419 param->iterations, 2420 realworld ? 1 : 0, param->length, 2421 param->vary); 2422 retval = ctrl_out(dev, param->iterations, 2423 param->length, param->vary, 0); 2424 break; 2425 2426 /* iso write tests */ 2427 case 15: 2428 if (dev->out_iso_pipe == 0 || param->sglen == 0) 2429 break; 2430 dev_info(&intf->dev, 2431 "TEST 15: write %d iso, %d entries of %d bytes\n", 2432 param->iterations, 2433 param->sglen, param->length); 2434 /* FIRMWARE: iso sink */ 2435 retval = test_queue(dev, param, 2436 dev->out_iso_pipe, dev->iso_out, 0); 2437 break; 2438 2439 /* iso read tests */ 2440 case 16: 2441 if (dev->in_iso_pipe == 0 || param->sglen == 0) 2442 break; 2443 dev_info(&intf->dev, 2444 "TEST 16: read %d iso, %d entries of %d bytes\n", 2445 param->iterations, 2446 param->sglen, param->length); 2447 /* FIRMWARE: iso source */ 2448 retval = test_queue(dev, param, 2449 dev->in_iso_pipe, dev->iso_in, 0); 2450 break; 2451 2452 /* FIXME scatterlist cancel (needs helper thread) */ 2453 2454 /* Tests for bulk I/O using DMA mapping by core and odd address */ 2455 case 17: 2456 if (dev->out_pipe == 0) 2457 break; 2458 dev_info(&intf->dev, 2459 "TEST 17: write odd addr %d bytes %u times core map\n", 2460 param->length, param->iterations); 2461 2462 retval = test_unaligned_bulk( 2463 dev, dev->out_pipe, 2464 param->length, param->iterations, 2465 0, "test17"); 2466 break; 2467 2468 case 18: 2469 if (dev->in_pipe == 0) 2470 break; 2471 dev_info(&intf->dev, 2472 "TEST 18: read odd addr %d bytes %u times core map\n", 2473 param->length, param->iterations); 2474 2475 retval = test_unaligned_bulk( 2476 dev, dev->in_pipe, 2477 param->length, param->iterations, 2478 0, "test18"); 2479 break; 2480 2481 /* Tests for bulk I/O using premapped coherent buffer and odd address */ 2482 case 19: 2483 if (dev->out_pipe == 0) 2484 break; 2485 dev_info(&intf->dev, 2486 "TEST 19: write odd addr %d bytes %u times premapped\n", 2487 param->length, param->iterations); 2488 2489 retval = test_unaligned_bulk( 2490 dev, dev->out_pipe, 2491 param->length, param->iterations, 2492 URB_NO_TRANSFER_DMA_MAP, "test19"); 2493 break; 2494 2495 case 20: 2496 if (dev->in_pipe == 0) 2497 break; 2498 dev_info(&intf->dev, 2499 "TEST 20: read odd addr %d bytes %u times premapped\n", 2500 param->length, param->iterations); 2501 2502 retval = test_unaligned_bulk( 2503 dev, dev->in_pipe, 2504 param->length, param->iterations, 2505 URB_NO_TRANSFER_DMA_MAP, "test20"); 2506 break; 2507 2508 /* control write tests with unaligned buffer */ 2509 case 21: 2510 if (!dev->info->ctrl_out) 2511 break; 2512 dev_info(&intf->dev, 2513 "TEST 21: %d ep0out odd addr, %d..%d vary %d\n", 2514 param->iterations, 2515 realworld ? 1 : 0, param->length, 2516 param->vary); 2517 retval = ctrl_out(dev, param->iterations, 2518 param->length, param->vary, 1); 2519 break; 2520 2521 /* unaligned iso tests */ 2522 case 22: 2523 if (dev->out_iso_pipe == 0 || param->sglen == 0) 2524 break; 2525 dev_info(&intf->dev, 2526 "TEST 22: write %d iso odd, %d entries of %d bytes\n", 2527 param->iterations, 2528 param->sglen, param->length); 2529 retval = test_queue(dev, param, 2530 dev->out_iso_pipe, dev->iso_out, 1); 2531 break; 2532 2533 case 23: 2534 if (dev->in_iso_pipe == 0 || param->sglen == 0) 2535 break; 2536 dev_info(&intf->dev, 2537 "TEST 23: read %d iso odd, %d entries of %d bytes\n", 2538 param->iterations, 2539 param->sglen, param->length); 2540 retval = test_queue(dev, param, 2541 dev->in_iso_pipe, dev->iso_in, 1); 2542 break; 2543 2544 /* unlink URBs from a bulk-OUT queue */ 2545 case 24: 2546 if (dev->out_pipe == 0 || !param->length || param->sglen < 4) 2547 break; 2548 retval = 0; 2549 dev_info(&intf->dev, "TEST 24: unlink from %d queues of " 2550 "%d %d-byte writes\n", 2551 param->iterations, param->sglen, param->length); 2552 for (i = param->iterations; retval == 0 && i > 0; --i) { 2553 retval = unlink_queued(dev, dev->out_pipe, 2554 param->sglen, param->length); 2555 if (retval) { 2556 dev_err(&intf->dev, 2557 "unlink queued writes failed %d, " 2558 "iterations left %d\n", retval, i); 2559 break; 2560 } 2561 } 2562 break; 2563 2564 /* Simple non-queued interrupt I/O tests */ 2565 case 25: 2566 if (dev->out_int_pipe == 0) 2567 break; 2568 dev_info(&intf->dev, 2569 "TEST 25: write %d bytes %u times\n", 2570 param->length, param->iterations); 2571 urb = simple_alloc_urb(udev, dev->out_int_pipe, param->length, 2572 dev->int_out->bInterval); 2573 if (!urb) { 2574 retval = -ENOMEM; 2575 break; 2576 } 2577 /* FIRMWARE: interrupt sink (maybe accepts short writes) */ 2578 retval = simple_io(dev, urb, param->iterations, 0, 0, "test25"); 2579 simple_free_urb(urb); 2580 break; 2581 case 26: 2582 if (dev->in_int_pipe == 0) 2583 break; 2584 dev_info(&intf->dev, 2585 "TEST 26: read %d bytes %u times\n", 2586 param->length, param->iterations); 2587 urb = simple_alloc_urb(udev, dev->in_int_pipe, param->length, 2588 dev->int_in->bInterval); 2589 if (!urb) { 2590 retval = -ENOMEM; 2591 break; 2592 } 2593 /* FIRMWARE: interrupt source (maybe generates short writes) */ 2594 retval = simple_io(dev, urb, param->iterations, 0, 0, "test26"); 2595 simple_free_urb(urb); 2596 break; 2597 case 27: 2598 /* We do performance test, so ignore data compare */ 2599 if (dev->out_pipe == 0 || param->sglen == 0 || pattern != 0) 2600 break; 2601 dev_info(&intf->dev, 2602 "TEST 27: bulk write %dMbytes\n", (param->iterations * 2603 param->sglen * param->length) / (1024 * 1024)); 2604 retval = test_queue(dev, param, 2605 dev->out_pipe, NULL, 0); 2606 break; 2607 case 28: 2608 if (dev->in_pipe == 0 || param->sglen == 0 || pattern != 0) 2609 break; 2610 dev_info(&intf->dev, 2611 "TEST 28: bulk read %dMbytes\n", (param->iterations * 2612 param->sglen * param->length) / (1024 * 1024)); 2613 retval = test_queue(dev, param, 2614 dev->in_pipe, NULL, 0); 2615 break; 2616 /* Test data Toggle/seq_nr clear between bulk out transfers */ 2617 case 29: 2618 if (dev->out_pipe == 0) 2619 break; 2620 retval = 0; 2621 dev_info(&intf->dev, "TEST 29: Clear toggle between bulk writes %d times\n", 2622 param->iterations); 2623 for (i = param->iterations; retval == 0 && i > 0; --i) 2624 retval = toggle_sync_simple(dev); 2625 2626 if (retval) 2627 ERROR(dev, "toggle sync failed, iterations left %d\n", 2628 i); 2629 break; 2630 } 2631 return retval; 2632} 2633 2634/*-------------------------------------------------------------------------*/ 2635 2636/* We only have this one interface to user space, through usbfs. 2637 * User mode code can scan usbfs to find N different devices (maybe on 2638 * different busses) to use when testing, and allocate one thread per 2639 * test. So discovery is simplified, and we have no device naming issues. 2640 * 2641 * Don't use these only as stress/load tests. Use them along with 2642 * other USB bus activity: plugging, unplugging, mousing, mp3 playback, 2643 * video capture, and so on. Run different tests at different times, in 2644 * different sequences. Nothing here should interact with other devices, 2645 * except indirectly by consuming USB bandwidth and CPU resources for test 2646 * threads and request completion. But the only way to know that for sure 2647 * is to test when HC queues are in use by many devices. 2648 * 2649 * WARNING: Because usbfs grabs udev->dev.sem before calling this ioctl(), 2650 * it locks out usbcore in certain code paths. Notably, if you disconnect 2651 * the device-under-test, hub_wq will wait block forever waiting for the 2652 * ioctl to complete ... so that usb_disconnect() can abort the pending 2653 * urbs and then call usbtest_disconnect(). To abort a test, you're best 2654 * off just killing the userspace task and waiting for it to exit. 2655 */ 2656 2657static int 2658usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf) 2659{ 2660 2661 struct usbtest_dev *dev = usb_get_intfdata(intf); 2662 struct usbtest_param_64 *param_64 = buf; 2663 struct usbtest_param_32 temp; 2664 struct usbtest_param_32 *param_32 = buf; 2665 struct timespec64 start; 2666 struct timespec64 end; 2667 struct timespec64 duration; 2668 int retval = -EOPNOTSUPP; 2669 2670 /* FIXME USBDEVFS_CONNECTINFO doesn't say how fast the device is. */ 2671 2672 pattern = mod_pattern; 2673 2674 if (mutex_lock_interruptible(&dev->lock)) 2675 return -ERESTARTSYS; 2676 2677 /* FIXME: What if a system sleep starts while a test is running? */ 2678 2679 /* some devices, like ez-usb default devices, need a non-default 2680 * altsetting to have any active endpoints. some tests change 2681 * altsettings; force a default so most tests don't need to check. 2682 */ 2683 if (dev->info->alt >= 0) { 2684 if (intf->altsetting->desc.bInterfaceNumber) { 2685 retval = -ENODEV; 2686 goto free_mutex; 2687 } 2688 retval = set_altsetting(dev, dev->info->alt); 2689 if (retval) { 2690 dev_err(&intf->dev, 2691 "set altsetting to %d failed, %d\n", 2692 dev->info->alt, retval); 2693 goto free_mutex; 2694 } 2695 } 2696 2697 switch (code) { 2698 case USBTEST_REQUEST_64: 2699 temp.test_num = param_64->test_num; 2700 temp.iterations = param_64->iterations; 2701 temp.length = param_64->length; 2702 temp.sglen = param_64->sglen; 2703 temp.vary = param_64->vary; 2704 param_32 = &temp; 2705 break; 2706 2707 case USBTEST_REQUEST_32: 2708 break; 2709 2710 default: 2711 retval = -EOPNOTSUPP; 2712 goto free_mutex; 2713 } 2714 2715 ktime_get_ts64(&start); 2716 2717 retval = usbtest_do_ioctl(intf, param_32); 2718 if (retval < 0) 2719 goto free_mutex; 2720 2721 ktime_get_ts64(&end); 2722 2723 duration = timespec64_sub(end, start); 2724 2725 temp.duration_sec = duration.tv_sec; 2726 temp.duration_usec = duration.tv_nsec/NSEC_PER_USEC; 2727 2728 switch (code) { 2729 case USBTEST_REQUEST_32: 2730 param_32->duration_sec = temp.duration_sec; 2731 param_32->duration_usec = temp.duration_usec; 2732 break; 2733 2734 case USBTEST_REQUEST_64: 2735 param_64->duration_sec = temp.duration_sec; 2736 param_64->duration_usec = temp.duration_usec; 2737 break; 2738 } 2739 2740free_mutex: 2741 mutex_unlock(&dev->lock); 2742 return retval; 2743} 2744 2745/*-------------------------------------------------------------------------*/ 2746 2747static unsigned force_interrupt; 2748module_param(force_interrupt, uint, 0); 2749MODULE_PARM_DESC(force_interrupt, "0 = test default; else interrupt"); 2750 2751#ifdef GENERIC 2752static unsigned short vendor; 2753module_param(vendor, ushort, 0); 2754MODULE_PARM_DESC(vendor, "vendor code (from usb-if)"); 2755 2756static unsigned short product; 2757module_param(product, ushort, 0); 2758MODULE_PARM_DESC(product, "product code (from vendor)"); 2759#endif 2760 2761static int 2762usbtest_probe(struct usb_interface *intf, const struct usb_device_id *id) 2763{ 2764 struct usb_device *udev; 2765 struct usbtest_dev *dev; 2766 struct usbtest_info *info; 2767 char *rtest, *wtest; 2768 char *irtest, *iwtest; 2769 char *intrtest, *intwtest; 2770 2771 udev = interface_to_usbdev(intf); 2772 2773#ifdef GENERIC 2774 /* specify devices by module parameters? */ 2775 if (id->match_flags == 0) { 2776 /* vendor match required, product match optional */ 2777 if (!vendor || le16_to_cpu(udev->descriptor.idVendor) != (u16)vendor) 2778 return -ENODEV; 2779 if (product && le16_to_cpu(udev->descriptor.idProduct) != (u16)product) 2780 return -ENODEV; 2781 dev_info(&intf->dev, "matched module params, " 2782 "vend=0x%04x prod=0x%04x\n", 2783 le16_to_cpu(udev->descriptor.idVendor), 2784 le16_to_cpu(udev->descriptor.idProduct)); 2785 } 2786#endif 2787 2788 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 2789 if (!dev) 2790 return -ENOMEM; 2791 info = (struct usbtest_info *) id->driver_info; 2792 dev->info = info; 2793 mutex_init(&dev->lock); 2794 2795 dev->intf = intf; 2796 2797 /* cacheline-aligned scratch for i/o */ 2798 dev->buf = kmalloc(TBUF_SIZE, GFP_KERNEL); 2799 if (dev->buf == NULL) { 2800 kfree(dev); 2801 return -ENOMEM; 2802 } 2803 2804 /* NOTE this doesn't yet test the handful of difference that are 2805 * visible with high speed interrupts: bigger maxpacket (1K) and 2806 * "high bandwidth" modes (up to 3 packets/uframe). 2807 */ 2808 rtest = wtest = ""; 2809 irtest = iwtest = ""; 2810 intrtest = intwtest = ""; 2811 if (force_interrupt || udev->speed == USB_SPEED_LOW) { 2812 if (info->ep_in) { 2813 dev->in_pipe = usb_rcvintpipe(udev, info->ep_in); 2814 rtest = " intr-in"; 2815 } 2816 if (info->ep_out) { 2817 dev->out_pipe = usb_sndintpipe(udev, info->ep_out); 2818 wtest = " intr-out"; 2819 } 2820 } else { 2821 if (override_alt >= 0 || info->autoconf) { 2822 int status; 2823 2824 status = get_endpoints(dev, intf); 2825 if (status < 0) { 2826 WARNING(dev, "couldn't get endpoints, %d\n", 2827 status); 2828 kfree(dev->buf); 2829 kfree(dev); 2830 return status; 2831 } 2832 /* may find bulk or ISO pipes */ 2833 } else { 2834 if (info->ep_in) 2835 dev->in_pipe = usb_rcvbulkpipe(udev, 2836 info->ep_in); 2837 if (info->ep_out) 2838 dev->out_pipe = usb_sndbulkpipe(udev, 2839 info->ep_out); 2840 } 2841 if (dev->in_pipe) 2842 rtest = " bulk-in"; 2843 if (dev->out_pipe) 2844 wtest = " bulk-out"; 2845 if (dev->in_iso_pipe) 2846 irtest = " iso-in"; 2847 if (dev->out_iso_pipe) 2848 iwtest = " iso-out"; 2849 if (dev->in_int_pipe) 2850 intrtest = " int-in"; 2851 if (dev->out_int_pipe) 2852 intwtest = " int-out"; 2853 } 2854 2855 usb_set_intfdata(intf, dev); 2856 dev_info(&intf->dev, "%s\n", info->name); 2857 dev_info(&intf->dev, "%s {control%s%s%s%s%s%s%s} tests%s\n", 2858 usb_speed_string(udev->speed), 2859 info->ctrl_out ? " in/out" : "", 2860 rtest, wtest, 2861 irtest, iwtest, 2862 intrtest, intwtest, 2863 info->alt >= 0 ? " (+alt)" : ""); 2864 return 0; 2865} 2866 2867static int usbtest_suspend(struct usb_interface *intf, pm_message_t message) 2868{ 2869 return 0; 2870} 2871 2872static int usbtest_resume(struct usb_interface *intf) 2873{ 2874 return 0; 2875} 2876 2877 2878static void usbtest_disconnect(struct usb_interface *intf) 2879{ 2880 struct usbtest_dev *dev = usb_get_intfdata(intf); 2881 2882 usb_set_intfdata(intf, NULL); 2883 dev_dbg(&intf->dev, "disconnect\n"); 2884 kfree(dev->buf); 2885 kfree(dev); 2886} 2887 2888/* Basic testing only needs a device that can source or sink bulk traffic. 2889 * Any device can test control transfers (default with GENERIC binding). 2890 * 2891 * Several entries work with the default EP0 implementation that's built 2892 * into EZ-USB chips. There's a default vendor ID which can be overridden 2893 * by (very) small config EEPROMS, but otherwise all these devices act 2894 * identically until firmware is loaded: only EP0 works. It turns out 2895 * to be easy to make other endpoints work, without modifying that EP0 2896 * behavior. For now, we expect that kind of firmware. 2897 */ 2898 2899/* an21xx or fx versions of ez-usb */ 2900static struct usbtest_info ez1_info = { 2901 .name = "EZ-USB device", 2902 .ep_in = 2, 2903 .ep_out = 2, 2904 .alt = 1, 2905}; 2906 2907/* fx2 version of ez-usb */ 2908static struct usbtest_info ez2_info = { 2909 .name = "FX2 device", 2910 .ep_in = 6, 2911 .ep_out = 2, 2912 .alt = 1, 2913}; 2914 2915/* ezusb family device with dedicated usb test firmware, 2916 */ 2917static struct usbtest_info fw_info = { 2918 .name = "usb test device", 2919 .ep_in = 2, 2920 .ep_out = 2, 2921 .alt = 1, 2922 .autoconf = 1, /* iso and ctrl_out need autoconf */ 2923 .ctrl_out = 1, 2924 .iso = 1, /* iso_ep's are #8 in/out */ 2925}; 2926 2927/* peripheral running Linux and 'zero.c' test firmware, or 2928 * its user-mode cousin. different versions of this use 2929 * different hardware with the same vendor/product codes. 2930 * host side MUST rely on the endpoint descriptors. 2931 */ 2932static struct usbtest_info gz_info = { 2933 .name = "Linux gadget zero", 2934 .autoconf = 1, 2935 .ctrl_out = 1, 2936 .iso = 1, 2937 .intr = 1, 2938 .alt = 0, 2939}; 2940 2941static struct usbtest_info um_info = { 2942 .name = "Linux user mode test driver", 2943 .autoconf = 1, 2944 .alt = -1, 2945}; 2946 2947static struct usbtest_info um2_info = { 2948 .name = "Linux user mode ISO test driver", 2949 .autoconf = 1, 2950 .iso = 1, 2951 .alt = -1, 2952}; 2953 2954#ifdef IBOT2 2955/* this is a nice source of high speed bulk data; 2956 * uses an FX2, with firmware provided in the device 2957 */ 2958static struct usbtest_info ibot2_info = { 2959 .name = "iBOT2 webcam", 2960 .ep_in = 2, 2961 .alt = -1, 2962}; 2963#endif 2964 2965#ifdef GENERIC 2966/* we can use any device to test control traffic */ 2967static struct usbtest_info generic_info = { 2968 .name = "Generic USB device", 2969 .alt = -1, 2970}; 2971#endif 2972 2973 2974static const struct usb_device_id id_table[] = { 2975 2976 /*-------------------------------------------------------------*/ 2977 2978 /* EZ-USB devices which download firmware to replace (or in our 2979 * case augment) the default device implementation. 2980 */ 2981 2982 /* generic EZ-USB FX controller */ 2983 { USB_DEVICE(0x0547, 0x2235), 2984 .driver_info = (unsigned long) &ez1_info, 2985 }, 2986 2987 /* CY3671 development board with EZ-USB FX */ 2988 { USB_DEVICE(0x0547, 0x0080), 2989 .driver_info = (unsigned long) &ez1_info, 2990 }, 2991 2992 /* generic EZ-USB FX2 controller (or development board) */ 2993 { USB_DEVICE(0x04b4, 0x8613), 2994 .driver_info = (unsigned long) &ez2_info, 2995 }, 2996 2997 /* re-enumerated usb test device firmware */ 2998 { USB_DEVICE(0xfff0, 0xfff0), 2999 .driver_info = (unsigned long) &fw_info, 3000 }, 3001 3002 /* "Gadget Zero" firmware runs under Linux */ 3003 { USB_DEVICE(0x0525, 0xa4a0), 3004 .driver_info = (unsigned long) &gz_info, 3005 }, 3006 3007 /* so does a user-mode variant */ 3008 { USB_DEVICE(0x0525, 0xa4a4), 3009 .driver_info = (unsigned long) &um_info, 3010 }, 3011 3012 /* ... and a user-mode variant that talks iso */ 3013 { USB_DEVICE(0x0525, 0xa4a3), 3014 .driver_info = (unsigned long) &um2_info, 3015 }, 3016 3017#ifdef KEYSPAN_19Qi 3018 /* Keyspan 19qi uses an21xx (original EZ-USB) */ 3019 /* this does not coexist with the real Keyspan 19qi driver! */ 3020 { USB_DEVICE(0x06cd, 0x010b), 3021 .driver_info = (unsigned long) &ez1_info, 3022 }, 3023#endif 3024 3025 /*-------------------------------------------------------------*/ 3026 3027#ifdef IBOT2 3028 /* iBOT2 makes a nice source of high speed bulk-in data */ 3029 /* this does not coexist with a real iBOT2 driver! */ 3030 { USB_DEVICE(0x0b62, 0x0059), 3031 .driver_info = (unsigned long) &ibot2_info, 3032 }, 3033#endif 3034 3035 /*-------------------------------------------------------------*/ 3036 3037#ifdef GENERIC 3038 /* module params can specify devices to use for control tests */ 3039 { .driver_info = (unsigned long) &generic_info, }, 3040#endif 3041 3042 /*-------------------------------------------------------------*/ 3043 3044 { } 3045}; 3046MODULE_DEVICE_TABLE(usb, id_table); 3047 3048static struct usb_driver usbtest_driver = { 3049 .name = "usbtest", 3050 .id_table = id_table, 3051 .probe = usbtest_probe, 3052 .unlocked_ioctl = usbtest_ioctl, 3053 .disconnect = usbtest_disconnect, 3054 .suspend = usbtest_suspend, 3055 .resume = usbtest_resume, 3056}; 3057 3058/*-------------------------------------------------------------------------*/ 3059 3060static int __init usbtest_init(void) 3061{ 3062#ifdef GENERIC 3063 if (vendor) 3064 pr_debug("params: vend=0x%04x prod=0x%04x\n", vendor, product); 3065#endif 3066 return usb_register(&usbtest_driver); 3067} 3068module_init(usbtest_init); 3069 3070static void __exit usbtest_exit(void) 3071{ 3072 usb_deregister(&usbtest_driver); 3073} 3074module_exit(usbtest_exit); 3075 3076MODULE_DESCRIPTION("USB Core/HCD Testing Driver"); 3077MODULE_LICENSE("GPL"); 3078 3079