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