tools/tools/usbtest/usb_control_ep_test.c

   1 /* $FreeBSD: head/tools/tools/usbtest/usb_control_ep_test.c 254241 2013-08-12 09:15:33Z hselasky $ */
   2 /*-
   3  * Copyright (c) 2007-2010 Hans Petter Selasky. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <stdio.h>
  28 #include <stdint.h>
  29 #include <stdlib.h>
  30 #include <err.h>
  31 #include <string.h>
  32 #include <errno.h>
  33 #include <unistd.h>
  34
  35 #include <sys/sysctl.h>
  36 #include <sys/time.h>
  37
  38 #include <libusb20.h>
  39 #include <libusb20_desc.h>
  40
  41 #include <bus/u4b/usb_endian.h>
  42 #include <bus/u4b/usb.h>
  43 #include <bus/u4b/usb_cdc.h>
  44
  45 #include "usbtest.h"
  46
  47 static void
  48 set_ctrl_ep_fail(int bus, int dev, int ds_fail, int ss_fail)
  49 {
  50         int error;
  51
  52         error = sysctlbyname("hw.usb.ctrl_bus_fail", NULL, NULL,
  53             &bus, sizeof(bus));
  54         if (error != 0)
  55                 goto emissing;
  56
  57         error = sysctlbyname("hw.usb.ctrl_dev_fail", NULL, NULL,
  58             &dev, sizeof(dev));
  59         if (error != 0)
  60                 goto emissing;
  61
  62         error = sysctlbyname("hw.usb.ctrl_ds_fail", NULL, NULL,
  63             &ds_fail, sizeof(ds_fail));
  64         if (error != 0)
  65                 goto emissing;
  66
  67         error = sysctlbyname("hw.usb.ctrl_ss_fail", NULL, NULL,
  68             &ss_fail, sizeof(ss_fail));
  69         if (error != 0)
  70                 goto emissing;
  71         return;
  72
  73 emissing:
  74         printf("Cannot set USB sysctl, missing USB_REQ_DEBUG option?\n");
  75 }
  76
  77 void
  78 usb_control_ep_error_test(uint16_t vid, uint16_t pid)
  79 {
  80         struct LIBUSB20_CONTROL_SETUP_DECODED req;
  81         struct libusb20_device *pdev;
  82         uint8_t buffer[256];
  83         int error;
  84         int fail = 0;
  85         int bus;
  86         int dev;
  87         int cfg;
  88
  89         pdev = find_usb_device(vid, pid);
  90         if (pdev == NULL) {
  91                 printf("USB device not found\n");
  92                 return;
  93         }
  94         error = libusb20_dev_open(pdev, 0);
  95         if (error) {
  96                 printf("Could not open USB device\n");
  97                 libusb20_dev_free(pdev);
  98                 return;
  99         }
 100
 101         bus = libusb20_dev_get_bus_number(pdev);
 102         dev = libusb20_dev_get_address(pdev);
 103
 104         for (cfg = 0; cfg != 255; cfg++) {
 105
 106                 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &req);
 107                 req.bmRequestType = 0x80; /* read */
 108                 req.bRequest = 0x06; /* descriptor */
 109                 req.wValue = 0x0200 | cfg; /* config descriptor */
 110                 req.wIndex = 0;
 111                 req.wLength = 255;
 112
 113                 printf("Test #%d.1/3 ...\n", cfg);
 114
 115                 set_ctrl_ep_fail(-1,-1,0,0);
 116
 117                 error = libusb20_dev_request_sync(pdev, &req, buffer,
 118                     NULL, 1000, 0);
 119                 if (error != 0) {
 120                         printf("Last configuration index is: %d\n", cfg - 1);
 121                         break;
 122                 }
 123
 124                 printf("Test #%d.2/3 ...\n", cfg);
 125
 126                 set_ctrl_ep_fail(bus,dev,1,1);
 127
 128                 error = libusb20_dev_request_sync(pdev, &req, buffer,
 129                     NULL, 1000, 0);
 130
 131                 set_ctrl_ep_fail(-1,-1,0,0);
 132
 133                 error = libusb20_dev_request_sync(pdev, &req, buffer,
 134                     NULL, 1000, 0);
 135                 if (error != 0) {
 136                         printf("Cannot fetch descriptor (unexpected)\n");
 137                         fail++;
 138                 }
 139
 140                 printf("Test #%d.3/3 ...\n", cfg);
 141
 142                 set_ctrl_ep_fail(bus,dev,0,1);
 143
 144                 error = libusb20_dev_request_sync(pdev, &req, buffer,
 145                     NULL, 1000, 0);
 146
 147                 set_ctrl_ep_fail(-1,-1,0,0);
 148
 149                 error = libusb20_dev_request_sync(pdev, &req, buffer,
 150                     NULL, 1000, 0);
 151                 if (error != 0) {
 152                         printf("Cannot fetch descriptor (unexpected)\n");
 153                         fail++;
 154                 }
 155         }
 156
 157         libusb20_dev_close(pdev);
 158         libusb20_dev_free(pdev);
 159
 160         printf("Test completed detecting %d failures\nDone\n\n", fail);
 161 }
 162
 163 void
 164 usb_get_string_desc_test(uint16_t vid, uint16_t pid)
 165 {
 166         struct libusb20_device *pdev;
 167         uint32_t x;
 168         uint32_t y;
 169         uint32_t valid;
 170         uint8_t *buf;
 171         int error;
 172
 173         pdev = find_usb_device(vid, pid);
 174         if (pdev == NULL) {
 175                 printf("USB device not found\n");
 176                 return;
 177         }
 178         error = libusb20_dev_open(pdev, 0);
 179         if (error) {
 180                 printf("Could not open USB device\n");
 181                 libusb20_dev_free(pdev);
 182                 return;
 183         }
 184         buf = malloc(256);
 185         if (buf == NULL) {
 186                 printf("Cannot allocate memory\n");
 187                 libusb20_dev_free(pdev);
 188                 return;
 189         }
 190         valid = 0;
 191
 192         printf("Starting string descriptor test for "
 193             "VID=0x%04x PID=0x%04x\n", vid, pid);
 194
 195         for (x = 0; x != 256; x++) {
 196
 197                 if (libusb20_dev_check_connected(pdev) != 0) {
 198                         printf("Device disconnected\n");
 199                         break;
 200                 }
 201                 printf("%d .. ", (int)x);
 202
 203                 fflush(stdout);
 204
 205                 error = libusb20_dev_req_string_simple_sync(pdev, x, buf, 255);
 206
 207                 if (error == 0) {
 208                         printf("\nINDEX=%d, STRING='%s' (Default language)\n", (int)x, buf);
 209                         fflush(stdout);
 210                 } else {
 211                         continue;
 212                 }
 213
 214                 valid = 0;
 215
 216                 for (y = 0; y != 65536; y++) {
 217
 218                         if (libusb20_dev_check_connected(pdev) != 0) {
 219                                 printf("Device disconnected\n");
 220                                 break;
 221                         }
 222                         error = libusb20_dev_req_string_sync(pdev, x, y, buf, 256);
 223                         if (error == 0)
 224                                 valid++;
 225                 }
 226
 227                 printf("String at INDEX=%d responds to %d "
 228                     "languages\n", (int)x, (int)valid);
 229         }
 230
 231         printf("\nDone\n");
 232
 233         free(buf);
 234
 235         libusb20_dev_free(pdev);
 236 }
 237
 238 void
 239 usb_port_reset_test(uint16_t vid, uint16_t pid, uint32_t duration)
 240 {
 241         struct timeval sub_tv;
 242         struct timeval ref_tv;
 243         struct timeval res_tv;
 244
 245         struct libusb20_device *pdev;
 246
 247         int error;
 248         int iter;
 249         int errcnt;
 250
 251         time_t last_sec;
 252
 253         /* sysctl() - no set config */
 254
 255         pdev = find_usb_device(vid, pid);
 256         if (pdev == NULL) {
 257                 printf("USB device not found\n");
 258                 return;
 259         }
 260         error = libusb20_dev_open(pdev, 0);
 261         if (error) {
 262                 libusb20_dev_free(pdev);
 263                 printf("Could not open USB device\n");
 264                 return;
 265         }
 266         iter = 0;
 267
 268         errcnt = 0;
 269
 270         gettimeofday(&ref_tv, 0);
 271
 272         last_sec = ref_tv.tv_sec;
 273
 274         while (1) {
 275
 276                 gettimeofday(&sub_tv, 0);
 277
 278                 if (last_sec != sub_tv.tv_sec) {
 279
 280                         printf("STATUS: ID=%u, ERR=%u\n",
 281                             (int)iter, (int)errcnt);
 282
 283                         fflush(stdout);
 284
 285                         last_sec = sub_tv.tv_sec;
 286                 }
 287                 timersub(&sub_tv, &ref_tv, &res_tv);
 288
 289                 if ((res_tv.tv_sec < 0) || (res_tv.tv_sec >= (int)duration))
 290                         break;
 291
 292                 if (libusb20_dev_reset(pdev)) {
 293                         errcnt++;
 294                         usleep(50000);
 295                 }
 296                 if (libusb20_dev_check_connected(pdev) != 0) {
 297                         printf("Device disconnected\n");
 298                         break;
 299                 }
 300                 iter++;
 301         }
 302
 303         libusb20_dev_reset(pdev);
 304
 305         libusb20_dev_free(pdev);
 306 }
 307
 308 void
 309 usb_set_config_test(uint16_t vid, uint16_t pid, uint32_t duration)
 310 {
 311         struct libusb20_device *pdev;
 312         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
 313         int x;
 314         int error;
 315         int failed;
 316         int exp;
 317
 318         pdev = find_usb_device(vid, pid);
 319         if (pdev == NULL) {
 320                 printf("USB device not found\n");
 321                 return;
 322         }
 323         error = libusb20_dev_open(pdev, 0);
 324         if (error) {
 325                 printf("Could not open USB device\n");
 326                 libusb20_dev_free(pdev);
 327                 return;
 328         }
 329         failed = 0;
 330
 331         printf("Starting set config test for "
 332             "VID=0x%04x PID=0x%04x\n", vid, pid);
 333
 334         for (x = 255; x > -1; x--) {
 335
 336                 error = libusb20_dev_set_config_index(pdev, x);
 337                 if (error == 0) {
 338                         if (x == 255) {
 339                                 printf("Unconfiguring USB device "
 340                                     "was successful\n");
 341                         } else {
 342                                 printf("Setting configuration %d "
 343                                     "was successful\n", x);
 344                         }
 345                 } else {
 346                         failed++;
 347                 }
 348         }
 349
 350         ddesc = libusb20_dev_get_device_desc(pdev);
 351         if (ddesc != NULL)
 352                 exp = ddesc->bNumConfigurations + 1;
 353         else
 354                 exp = 1;
 355
 356         printf("\n\n"
 357             "Set configuration summary\n"
 358             "Valid count:  %d/%d %s\n"
 359             "Failed count: %d\n",
 360             256 - failed, exp,
 361             (exp == (256 - failed)) ? "(expected)" : "(unexpected)",
 362             failed);
 363
 364         libusb20_dev_free(pdev);
 365 }
 366
 367 void
 368 usb_get_descriptor_test(uint16_t vid, uint16_t pid, uint32_t duration)
 369 {
 370         struct libusb20_device *pdev;
 371
 372         pdev = find_usb_device(vid, pid);
 373         if (pdev == NULL) {
 374                 printf("USB device not found\n");
 375                 return;
 376         }
 377         libusb20_dev_free(pdev);
 378 }
 379
 380 void
 381 usb_suspend_resume_test(uint16_t vid, uint16_t pid, uint32_t duration)
 382 {
 383         struct timeval sub_tv;
 384         struct timeval ref_tv;
 385         struct timeval res_tv;
 386
 387         struct libusb20_device *pdev;
 388
 389         time_t last_sec;
 390
 391         int iter;
 392         int error;
 393         int ptimo;
 394         int errcnt;
 395         int power_old;
 396
 397         ptimo = 1;                      /* second(s) */
 398
 399         error = sysctlbyname("hw.usb.power_timeout", NULL, NULL,
 400             &ptimo, sizeof(ptimo));
 401
 402         if (error != 0) {
 403                 printf("WARNING: Could not set power "
 404                     "timeout to 1 (error=%d) \n", errno);
 405         }
 406         pdev = find_usb_device(vid, pid);
 407         if (pdev == NULL) {
 408                 printf("USB device not found\n");
 409                 return;
 410         }
 411         error = libusb20_dev_open(pdev, 0);
 412         if (error) {
 413                 printf("Could not open USB device\n");
 414                 libusb20_dev_free(pdev);
 415                 return;
 416         }
 417         power_old = libusb20_dev_get_power_mode(pdev);
 418
 419         printf("Starting suspend and resume "
 420             "test for VID=0x%04x PID=0x%04x\n", vid, pid);
 421
 422         iter = 0;
 423         errcnt = 0;
 424
 425         gettimeofday(&ref_tv, 0);
 426
 427         last_sec = ref_tv.tv_sec;
 428
 429         while (1) {
 430
 431                 if (libusb20_dev_check_connected(pdev) != 0) {
 432                         printf("Device disconnected\n");
 433                         break;
 434                 }
 435                 gettimeofday(&sub_tv, 0);
 436
 437                 if (last_sec != sub_tv.tv_sec) {
 438
 439                         printf("STATUS: ID=%u, ERR=%u\n",
 440                             (int)iter, (int)errcnt);
 441
 442                         fflush(stdout);
 443
 444                         last_sec = sub_tv.tv_sec;
 445                 }
 446                 timersub(&sub_tv, &ref_tv, &res_tv);
 447
 448                 if ((res_tv.tv_sec < 0) || (res_tv.tv_sec >= (int)duration))
 449                         break;
 450
 451                 error = libusb20_dev_set_power_mode(pdev, (iter & 1) ?
 452                     LIBUSB20_POWER_ON : LIBUSB20_POWER_SAVE);
 453
 454                 if (error)
 455                         errcnt++;
 456
 457                 /* wait before switching power mode */
 458                 usleep(4100000 +
 459                     (((uint32_t)usb_ts_rand_noise()) % 2000000U));
 460
 461                 iter++;
 462         }
 463
 464         /* restore default power mode */
 465         libusb20_dev_set_power_mode(pdev, power_old);
 466
 467         libusb20_dev_free(pdev);
 468 }
 469
 470 void
 471 usb_set_and_clear_stall_test(uint16_t vid, uint16_t pid)
 472 {
 473         struct libusb20_device *pdev;
 474         struct libusb20_transfer *pxfer;
 475
 476         int iter;
 477         int error;
 478         int errcnt;
 479         int ep;
 480
 481         pdev = find_usb_device(vid, pid);
 482         if (pdev == NULL) {
 483                 printf("USB device not found\n");
 484                 return;
 485         }
 486         error = libusb20_dev_open(pdev, 1);
 487         if (error) {
 488                 printf("Could not open USB device\n");
 489                 libusb20_dev_free(pdev);
 490                 return;
 491         }
 492         printf("Starting set and clear stall test "
 493             "for VID=0x%04x PID=0x%04x\n", vid, pid);
 494
 495         iter = 0;
 496         errcnt = 0;
 497
 498         for (ep = 2; ep != 32; ep++) {
 499
 500                 struct LIBUSB20_CONTROL_SETUP_DECODED setup_set_stall;
 501                 struct LIBUSB20_CONTROL_SETUP_DECODED setup_get_status;
 502
 503                 uint8_t epno = ((ep / 2) | ((ep & 1) << 7));
 504                 uint8_t buf[1];
 505
 506                 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &setup_set_stall);
 507                 setup_set_stall.bmRequestType = 0x02;   /* write endpoint */
 508                 setup_set_stall.bRequest = 0x03;        /* set feature */
 509                 setup_set_stall.wValue = 0x00;  /* UF_ENDPOINT_HALT */
 510                 setup_set_stall.wIndex = epno;
 511                 setup_set_stall.wLength = 0;
 512
 513                 LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &setup_get_status);
 514                 setup_get_status.bmRequestType = 0x82;  /* read endpoint */
 515                 setup_get_status.bRequest = 0x00;       /* get status */
 516                 setup_get_status.wValue = 0x00;
 517                 setup_get_status.wIndex = epno;
 518                 setup_get_status.wLength = 1;
 519
 520                 if (libusb20_dev_check_connected(pdev) != 0) {
 521                         printf("Device disconnected\n");
 522                         break;
 523                 }
 524                 pxfer = libusb20_tr_get_pointer(pdev, 0);
 525
 526                 error = libusb20_tr_open(pxfer, 1, 1, epno);
 527
 528                 if (error != 0) {
 529                         printf("Endpoint 0x%02x does not exist "
 530                             "in current setting. (%s, ignored)\n",
 531                             epno, libusb20_strerror(error));
 532                         continue;
 533                 }
 534                 printf("Stalling endpoint 0x%02x\n", epno);
 535
 536                 /* set stall */
 537                 error = libusb20_dev_request_sync(pdev,
 538                     &setup_set_stall, NULL, NULL, 250, 0);
 539
 540                 if (error != 0) {
 541                         printf("Endpoint 0x%02x does not allow "
 542                             "setting of stall. (%s)\n",
 543                             epno, libusb20_strerror(error));
 544                         errcnt++;
 545                 }
 546                 /* get EP status */
 547                 buf[0] = 0;
 548                 error = libusb20_dev_request_sync(pdev,
 549                     &setup_get_status, buf, NULL, 250, 0);
 550
 551                 if (error != 0) {
 552                         printf("Endpoint 0x%02x does not allow "
 553                             "reading status. (%s)\n",
 554                             epno, libusb20_strerror(error));
 555                         errcnt++;
 556                 } else {
 557                         if (!(buf[0] & 1)) {
 558                                 printf("Endpoint 0x%02x status is "
 559                                     "not set to stalled\n", epno);
 560                                 errcnt++;
 561                         }
 562                 }
 563
 564                 buf[0] = 0;
 565                 error = libusb20_tr_bulk_intr_sync(pxfer, buf, 1, NULL, 250);
 566                 if (error != LIBUSB20_TRANSFER_STALL) {
 567                         printf("Endpoint 0x%02x does not appear to "
 568                             "have stalled. Missing stall PID!\n", epno);
 569                         errcnt++;
 570                 }
 571                 printf("Unstalling endpoint 0x%02x\n", epno);
 572
 573                 libusb20_tr_clear_stall_sync(pxfer);
 574
 575                 /* get EP status */
 576                 buf[0] = 0;
 577                 error = libusb20_dev_request_sync(pdev,
 578                     &setup_get_status, buf, NULL, 250, 0);
 579
 580                 if (error != 0) {
 581                         printf("Endpoint 0x%02x does not allow "
 582                             "reading status. (%s)\n",
 583                             epno, libusb20_strerror(error));
 584                         errcnt++;
 585                 } else {
 586                         if (buf[0] & 1) {
 587                                 printf("Endpoint 0x%02x status is "
 588                                     "still stalled\n", epno);
 589                                 errcnt++;
 590                         }
 591                 }
 592
 593                 libusb20_tr_close(pxfer);
 594                 iter++;
 595         }
 596
 597         libusb20_dev_free(pdev);
 598
 599         printf("\n"
 600             "Test summary\n"
 601             "============\n"
 602             "Endpoints tested: %d\n"
 603             "Errors: %d\n", iter, errcnt);
 604 }
 605
 606 void
 607 usb_set_alt_interface_test(uint16_t vid, uint16_t pid)
 608 {
 609         struct libusb20_device *pdev;
 610         struct libusb20_config *config;
 611
 612         int iter;
 613         int error;
 614         int errcnt;
 615         int n;
 616         int m;
 617
 618         pdev = find_usb_device(vid, pid);
 619         if (pdev == NULL) {
 620                 printf("USB device not found\n");
 621                 return;
 622         }
 623         printf("Starting set alternate setting test "
 624             "for VID=0x%04x PID=0x%04x\n", vid, pid);
 625
 626         config = libusb20_dev_alloc_config(pdev,
 627             libusb20_dev_get_config_index(pdev));
 628         if (config == NULL) {
 629                 printf("Could not get configuration descriptor\n");
 630                 libusb20_dev_free(pdev);
 631                 return;
 632         }
 633         iter = 0;
 634         errcnt = 0;
 635
 636         for (n = 0; n != config->num_interface; n++) {
 637                 /* detach kernel driver */
 638                 libusb20_dev_detach_kernel_driver(pdev, n);
 639
 640                 error = libusb20_dev_open(pdev, 0);
 641                 if (error)
 642                         printf("ERROR could not open device\n");
 643
 644                 /* Try the alternate settings */
 645                 for (m = 0; m != config->interface[n].num_altsetting; m++) {
 646
 647                         iter++;
 648
 649                         if (libusb20_dev_set_alt_index(pdev, n, m + 1)) {
 650                                 printf("ERROR on interface %d alt %d\n", n, m + 1);
 651                                 errcnt++;
 652                         }
 653                 }
 654
 655                 /* Restore to default */
 656
 657                 iter++;
 658
 659                 if (libusb20_dev_set_alt_index(pdev, n, 0)) {
 660                         printf("ERROR on interface %d alt %d\n", n, 0);
 661                         errcnt++;
 662                 }
 663                 libusb20_dev_close(pdev);
 664         }
 665
 666         libusb20_dev_free(pdev);
 667
 668         printf("\n"
 669             "Test summary\n"
 670             "============\n"
 671             "Interfaces tested: %d\n"
 672             "Errors: %d\n", iter, errcnt);
 673 }