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