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