tools/tools/usbtest/usb_msc_test.c

   1 /* $FreeBSD: head/tools/tools/usbtest/usb_msc_test.c 260587 2014-01-13 13:27:00Z hselasky $ */
   2 /*-
   3  * Copyright (c) 2007-2012 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
  43 #include "usbtest.h"
  44
  45 #include "usb_msc_test.h"
  46
  47 /* Command Block Wrapper */
  48 typedef struct {
  49         uDWord  dCBWSignature;
  50 #define CBWSIGNATURE    0x43425355
  51         uDWord  dCBWTag;
  52         uDWord  dCBWDataTransferLength;
  53         uByte   bCBWFlags;
  54 #define CBWFLAGS_OUT    0x00
  55 #define CBWFLAGS_IN     0x80
  56         uByte   bCBWLUN;
  57         uByte   bCDBLength;
  58 #define CBWCDBLENGTH    16
  59         uByte   CBWCDB[CBWCDBLENGTH];
  60 } umass_bbb_cbw_t;
  61
  62 #define UMASS_BBB_CBW_SIZE      31
  63
  64 /* Command Status Wrapper */
  65 typedef struct {
  66         uDWord  dCSWSignature;
  67 #define CSWSIGNATURE    0x53425355
  68 #define CSWSIGNATURE_IMAGINATION_DBX1   0x43425355
  69 #define CSWSIGNATURE_OLYMPUS_C1 0x55425355
  70         uDWord  dCSWTag;
  71         uDWord  dCSWDataResidue;
  72         uByte   bCSWStatus;
  73 #define CSWSTATUS_GOOD  0x0
  74 #define CSWSTATUS_FAILED        0x1
  75 #define CSWSTATUS_PHASE 0x2
  76 } umass_bbb_csw_t;
  77
  78 #define UMASS_BBB_CSW_SIZE      13
  79
  80 #define SC_READ_6                       0x08
  81 #define SC_READ_10                      0x28
  82 #define SC_READ_12                      0xa8
  83 #define SC_WRITE_6                      0x0a
  84 #define SC_WRITE_10                     0x2a
  85 #define SC_WRITE_12                     0xaa
  86
  87 static struct stats {
  88         uint64_t xfer_error;
  89         uint64_t xfer_success;
  90         uint64_t xfer_reset;
  91         uint64_t xfer_rx_bytes;
  92         uint64_t xfer_tx_bytes;
  93         uint64_t data_error;
  94 }       stats;
  95
  96 static uint32_t xfer_current_id;
  97 static uint32_t xfer_wrapper_sig;
  98 static uint32_t block_size = 512;
  99
 100 static struct libusb20_transfer *xfer_in;
 101 static struct libusb20_transfer *xfer_out;
 102 static struct libusb20_device *usb_pdev;
 103 static uint8_t usb_iface;
 104 static int sense_recurse;
 105
 106 /*
 107  * SCSI commands sniffed off the wire - LUN maybe needs to be
 108  * adjusted!  Refer to "bus/u4b/storage/ustorage_fs.c" for more
 109  * information.
 110  */
 111 static uint8_t mode_sense_6[0x6] = {0x1a, 0, 0x3f, 0, 0x0c};
 112 static uint8_t read_capacity[0xA] = {0x25,};
 113 static uint8_t request_sense[0xC] = {0x03, 0, 0, 0, 0x12};
 114 static uint8_t test_unit_ready[0x6] = {0};
 115 static uint8_t mode_page_inquiry[0x6] = {0x12, 1, 0x80, 0, 0xff, 0};
 116 static uint8_t request_invalid[0xC] = {0xEA, 0, 0, 0, 0};
 117 static uint8_t prevent_removal[0x6] = {0x1E, 0, 0, 0, 1};
 118 static uint8_t read_toc[0xA] = {0x43, 0x02, 0, 0, 0, 0xAA, 0, 0x0C};
 119
 120 #define TIMEOUT_FILTER(x) (x)
 121
 122 static void usb_request_sense(uint8_t lun);
 123
 124 static void
 125 do_msc_reset(uint8_t lun)
 126 {
 127         struct LIBUSB20_CONTROL_SETUP_DECODED setup;
 128
 129         LIBUSB20_INIT(LIBUSB20_CONTROL_SETUP, &setup);
 130
 131         setup.bmRequestType = LIBUSB20_REQUEST_TYPE_CLASS |
 132             LIBUSB20_RECIPIENT_INTERFACE;
 133         setup.bRequest = 0xFF;          /* BBB reset */
 134         setup.wValue = 0;
 135         setup.wIndex = usb_iface;
 136         setup.wLength = 0;
 137
 138         if (libusb20_dev_request_sync(usb_pdev, &setup, NULL, NULL, 5000, 0)) {
 139                 printf("ERROR: %s\n", __FUNCTION__);
 140                 stats.xfer_error++;
 141         }
 142         libusb20_tr_clear_stall_sync(xfer_in);
 143         libusb20_tr_clear_stall_sync(xfer_out);
 144
 145         stats.xfer_reset++;
 146
 147         usb_request_sense(lun);
 148 }
 149
 150 static uint8_t
 151 do_msc_cmd(uint8_t *pcmd, uint8_t cmdlen, void *pdata, uint32_t datalen,
 152     uint8_t isread, uint8_t isshort, uint8_t lun, uint8_t flags)
 153 {
 154         umass_bbb_cbw_t cbw;
 155         umass_bbb_csw_t csw;
 156         struct libusb20_transfer *xfer_io;
 157         uint32_t actlen;
 158         uint32_t timeout;
 159         int error;
 160
 161         memset(&cbw, 0, sizeof(cbw));
 162
 163         USETDW(cbw.dCBWSignature, xfer_wrapper_sig);
 164         USETDW(cbw.dCBWTag, xfer_current_id);
 165         xfer_current_id++;
 166         USETDW(cbw.dCBWDataTransferLength, datalen);
 167         cbw.bCBWFlags = (isread ? CBWFLAGS_IN : CBWFLAGS_OUT);
 168         cbw.bCBWLUN = lun;
 169         cbw.bCDBLength = cmdlen;
 170         bcopy(pcmd, cbw.CBWCDB, cmdlen);
 171
 172         actlen = 0;
 173
 174         timeout = ((datalen + 299999) / 300000) * 1000;
 175         timeout += 5000;
 176
 177         if ((error = libusb20_tr_bulk_intr_sync(xfer_out,
 178             &cbw, sizeof(cbw), &actlen, TIMEOUT_FILTER(1000)))) {
 179                 printf("ERROR: CBW reception: %d\n", error);
 180                 do_msc_reset(lun);
 181                 return (1);
 182         }
 183         if (actlen != sizeof(cbw)) {
 184                 printf("ERROR: CBW length: %d != %d\n",
 185                     actlen, (int)sizeof(cbw));
 186                 do_msc_reset(lun);
 187                 return (1);
 188         }
 189         if (flags & 1)
 190                 datalen /= 2;
 191
 192         if (datalen != 0) {
 193                 xfer_io = isread ? xfer_in : xfer_out;
 194
 195                 if ((error = libusb20_tr_bulk_intr_sync(xfer_io,
 196                     pdata, datalen, &actlen, TIMEOUT_FILTER(timeout)))) {
 197                         printf("ERROR: Data transfer: %d\n", error);
 198                         do_msc_reset(lun);
 199                         return (1);
 200                 }
 201                 if ((actlen != datalen) && (!isshort)) {
 202                         printf("ERROR: Short data: %d of %d bytes\n",
 203                             actlen, datalen);
 204                         do_msc_reset(lun);
 205                         return (1);
 206                 }
 207         }
 208         actlen = 0;
 209         timeout = 8;
 210
 211         do {
 212                 error = libusb20_tr_bulk_intr_sync(xfer_in, &csw,
 213                     sizeof(csw), &actlen, TIMEOUT_FILTER(1000));
 214                 if (error) {
 215                         if (error == LIBUSB20_TRANSFER_TIMED_OUT) {
 216                                 printf("TIMEOUT: Trying to get CSW again. "
 217                                     "%d tries left.\n", timeout);
 218                         } else {
 219                                 break;
 220                         }
 221                 } else {
 222                         break;
 223                 }
 224         } while (--timeout);
 225
 226         if (error) {
 227                 libusb20_tr_clear_stall_sync(xfer_in);
 228                 error = libusb20_tr_bulk_intr_sync(xfer_in, &csw,
 229                     sizeof(csw), &actlen, TIMEOUT_FILTER(1000));
 230                 if (error) {
 231                         libusb20_tr_clear_stall_sync(xfer_in);
 232                         printf("ERROR: Could not read CSW: Stalled or "
 233                             "timeout (%d).\n", error);
 234                         do_msc_reset(lun);
 235                         return (1);
 236                 }
 237         }
 238         if (UGETDW(csw.dCSWSignature) != CSWSIGNATURE) {
 239                 printf("ERROR: Wrong CSW signature\n");
 240                 do_msc_reset(lun);
 241                 return (1);
 242         }
 243         if (actlen != sizeof(csw)) {
 244                 printf("ERROR: Wrong CSW length: %d != %d\n",
 245                     actlen, (int)sizeof(csw));
 246                 do_msc_reset(lun);
 247                 return (1);
 248         }
 249         if (csw.bCSWStatus != 0) {
 250                 printf("ERROR: CSW status: %d\n", (int)csw.bCSWStatus);
 251                 return (1);
 252         } else {
 253                 stats.xfer_success++;
 254                 return (0);
 255         }
 256 }
 257
 258 static void
 259 do_msc_shorter_cmd(uint8_t lun)
 260 {
 261         uint8_t buffer[sizeof(umass_bbb_cbw_t)];
 262         int actlen;
 263         int error;
 264         int x;
 265
 266         memset(buffer, 0, sizeof(buffer));
 267
 268         for (x = 0; x != (sizeof(buffer) - 1); x++) {
 269                 error = libusb20_tr_bulk_intr_sync(xfer_out,
 270                     buffer, x, &actlen, 250);
 271
 272                 printf("Sent short %d of %d bytes wrapper block, "
 273                     "status = %d\n", x, (int)(sizeof(buffer) - 1),
 274                     error);
 275
 276                 do_msc_reset(lun);
 277
 278                 if (error != 0) {
 279                         printf("ERROR: Too short command wrapper "
 280                             "was not accepted\n");
 281                         stats.xfer_error++;
 282                         break;
 283                 }
 284         }
 285 }
 286
 287 static uint8_t
 288 do_read_10(uint32_t lba, uint32_t len, void *buf, uint8_t lun)
 289 {
 290         static uint8_t cmd[10];
 291         uint8_t retval;
 292
 293         cmd[0] = SC_READ_10;
 294
 295         len /= block_size;
 296
 297         cmd[2] = lba >> 24;
 298         cmd[3] = lba >> 16;
 299         cmd[4] = lba >> 8;
 300         cmd[5] = lba >> 0;
 301
 302         cmd[7] = len >> 8;
 303         cmd[8] = len;
 304
 305         retval = do_msc_cmd(cmd, 10, buf, len * block_size, 1, 0, lun, 0);
 306
 307         if (retval) {
 308                 printf("ERROR: %s\n", __FUNCTION__);
 309                 stats.xfer_error++;
 310         }
 311         return (retval);
 312 }
 313
 314 static uint8_t
 315 do_write_10(uint32_t lba, uint32_t len, void *buf, uint8_t lun)
 316 {
 317         static uint8_t cmd[10];
 318         uint8_t retval;
 319         uint8_t abort;
 320
 321         cmd[0] = SC_WRITE_10;
 322
 323         abort = len & 1;
 324
 325         len /= block_size;
 326
 327         cmd[2] = lba >> 24;
 328         cmd[3] = lba >> 16;
 329         cmd[4] = lba >> 8;
 330         cmd[5] = lba >> 0;
 331
 332         cmd[7] = len >> 8;
 333         cmd[8] = len;
 334
 335         retval = do_msc_cmd(cmd, 10, buf, (len * block_size), 0, 0, lun, abort);
 336
 337         if (retval) {
 338                 printf("ERROR: %s\n", __FUNCTION__);
 339                 stats.xfer_error++;
 340         }
 341         return (retval);
 342 }
 343
 344 static void
 345 do_io_test(struct usb_msc_params *p, uint8_t lun, uint32_t lba_max,
 346     uint8_t *buffer, uint8_t *reference)
 347 {
 348         uint32_t io_offset;
 349         uint32_t io_size;
 350         uint32_t temp;
 351         uint8_t do_read;
 352         uint8_t retval;
 353
 354         switch (p->io_mode) {
 355         case USB_MSC_IO_MODE_WRITE_ONLY:
 356                 do_read = 0;
 357                 break;
 358         case USB_MSC_IO_MODE_READ_WRITE:
 359                 do_read = (usb_ts_rand_noise() & 1);
 360                 break;
 361         default:
 362                 do_read = 1;
 363                 break;
 364         }
 365
 366         switch (p->io_offset) {
 367         case USB_MSC_IO_OFF_RANDOM:
 368                 io_offset = usb_ts_rand_noise();
 369                 break;
 370         default:
 371                 io_offset = 0;
 372                 break;
 373         }
 374
 375         switch (p->io_delay) {
 376         case USB_MSC_IO_DELAY_RANDOM_10MS:
 377                 usleep(((uint32_t)usb_ts_rand_noise()) % 10000U);
 378                 break;
 379         case USB_MSC_IO_DELAY_RANDOM_100MS:
 380                 usleep(((uint32_t)usb_ts_rand_noise()) % 100000U);
 381                 break;
 382         case USB_MSC_IO_DELAY_FIXED_10MS:
 383                 usleep(10000);
 384                 break;
 385         case USB_MSC_IO_DELAY_FIXED_100MS:
 386                 usleep(100000);
 387                 break;
 388         default:
 389                 break;
 390         }
 391
 392         switch (p->io_size) {
 393         case USB_MSC_IO_SIZE_RANDOM:
 394                 io_size = ((uint32_t)usb_ts_rand_noise()) & 65535U;
 395                 break;
 396         case USB_MSC_IO_SIZE_INCREASING:
 397                 io_size = (xfer_current_id & 65535U);
 398                 break;
 399         case USB_MSC_IO_SIZE_FIXED_1BLK:
 400                 io_size = 1;
 401                 break;
 402         case USB_MSC_IO_SIZE_FIXED_2BLK:
 403                 io_size = 2;
 404                 break;
 405         case USB_MSC_IO_SIZE_FIXED_4BLK:
 406                 io_size = 4;
 407                 break;
 408         case USB_MSC_IO_SIZE_FIXED_8BLK:
 409                 io_size = 8;
 410                 break;
 411         case USB_MSC_IO_SIZE_FIXED_16BLK:
 412                 io_size = 16;
 413                 break;
 414         case USB_MSC_IO_SIZE_FIXED_32BLK:
 415                 io_size = 32;
 416                 break;
 417         case USB_MSC_IO_SIZE_FIXED_64BLK:
 418                 io_size = 64;
 419                 break;
 420         case USB_MSC_IO_SIZE_FIXED_128BLK:
 421                 io_size = 128;
 422                 break;
 423         case USB_MSC_IO_SIZE_FIXED_256BLK:
 424                 io_size = 256;
 425                 break;
 426         case USB_MSC_IO_SIZE_FIXED_512BLK:
 427                 io_size = 512;
 428                 break;
 429         case USB_MSC_IO_SIZE_FIXED_1024BLK:
 430                 io_size = 1024;
 431                 break;
 432         default:
 433                 io_size = 1;
 434                 break;
 435         }
 436
 437         if (io_size == 0)
 438                 io_size = 1;
 439
 440         io_offset %= lba_max;
 441
 442         temp = (lba_max - io_offset);
 443
 444         if (io_size > temp)
 445                 io_size = temp;
 446
 447         if (do_read) {
 448                 retval = do_read_10(io_offset, io_size * block_size,
 449                     buffer + (io_offset * block_size), lun);
 450
 451                 if (retval == 0) {
 452                         if (bcmp(buffer + (io_offset * block_size),
 453                             reference + (io_offset * block_size),
 454                             io_size * block_size)) {
 455                                 printf("ERROR: Data comparison failure\n");
 456                                 stats.data_error++;
 457                                 retval = 1;
 458                         }
 459                 }
 460                 stats.xfer_rx_bytes += (io_size * block_size);
 461
 462         } else {
 463
 464                 retval = do_write_10(io_offset, io_size * block_size,
 465                     reference + (io_offset * block_size), lun);
 466
 467                 stats.xfer_tx_bytes += (io_size * block_size);
 468         }
 469
 470         if ((stats.xfer_error + stats.data_error +
 471             stats.xfer_reset) >= p->max_errors) {
 472                 printf("Maximum number of errors exceeded\n");
 473                 p->done = 1;
 474         }
 475 }
 476
 477 static void
 478 usb_request_sense(uint8_t lun)
 479 {
 480         uint8_t dummy_buf[255];
 481
 482         if (sense_recurse)
 483                 return;
 484
 485         sense_recurse++;
 486
 487         do_msc_cmd(request_sense, sizeof(request_sense),
 488             dummy_buf, 255, 1, 1, lun, 0);
 489
 490         sense_recurse--;
 491 }
 492
 493 static void
 494 usb_msc_test(struct usb_msc_params *p)
 495 {
 496         struct stats last_stat;
 497         struct timeval sub_tv;
 498         struct timeval ref_tv;
 499         struct timeval res_tv;
 500         uint8_t *buffer = NULL;
 501         uint8_t *reference = NULL;
 502         uint32_t dummy_buf[65536 / 4];
 503         uint32_t lba_max;
 504         uint32_t x;
 505         uint32_t y;
 506         uint32_t capacity_lba;
 507         uint32_t capacity_bs;
 508         time_t last_sec;
 509         uint8_t lun;
 510         int tries;
 511
 512         memset(&last_stat, 0, sizeof(last_stat));
 513
 514         switch (p->io_lun) {
 515         case USB_MSC_IO_LUN_0:
 516                 lun = 0;
 517                 break;
 518         case USB_MSC_IO_LUN_1:
 519                 lun = 1;
 520                 break;
 521         case USB_MSC_IO_LUN_2:
 522                 lun = 2;
 523                 break;
 524         case USB_MSC_IO_LUN_3:
 525                 lun = 3;
 526                 break;
 527         default:
 528                 lun = 0;
 529                 break;
 530         }
 531
 532         p->done = 0;
 533
 534         sense_recurse = p->try_sense_on_error ? 0 : 1;
 535
 536         printf("Resetting device ...\n");
 537
 538         do_msc_reset(lun);
 539
 540         printf("Testing SCSI commands ...\n");
 541
 542         if (p->try_all_lun) {
 543                 printf("Requesting sense from LUN 0..255 ... ");
 544                 for (x = y = 0; x != 256; x++) {
 545                         if (do_msc_cmd(mode_sense_6, sizeof(mode_sense_6),
 546                             dummy_buf, 255, 1, 1, x, 0))
 547                                 y++;
 548
 549                         if (libusb20_dev_check_connected(usb_pdev) != 0) {
 550                                 printf(" disconnect ");
 551                                 break;
 552                         }
 553                 }
 554                 printf("Passed=%d, Failed=%d\n", 256 - y, y);
 555         }
 556         do_msc_cmd(mode_sense_6, sizeof(mode_sense_6),
 557             dummy_buf, 255, 1, 1, lun, 0);
 558         do_msc_cmd(request_sense, sizeof(request_sense),
 559             dummy_buf, 255, 1, 1, lun, 0);
 560
 561         for (tries = 0; tries != 4; tries++) {
 562
 563                 memset(dummy_buf, 0, sizeof(dummy_buf));
 564
 565                 if (do_msc_cmd(read_capacity, sizeof(read_capacity),
 566                     dummy_buf, 255, 1, 1, lun, 0) != 0) {
 567                         printf("Cannot read disk capacity (%u / 4)\n", tries);
 568                         if (tries == 3)
 569                                 return;
 570                         usleep(50000);
 571                         continue;
 572                 } else {
 573                         break;
 574                 }
 575         }
 576
 577         capacity_lba = be32toh(dummy_buf[0]);
 578         capacity_bs = be32toh(dummy_buf[1]);
 579
 580         printf("Disk reports a capacity of LBA=%u and BS=%u\n",
 581             capacity_lba, capacity_bs);
 582
 583         block_size = capacity_bs;
 584
 585         if (capacity_bs > 65535) {
 586                 printf("Blocksize is too big\n");
 587                 return;
 588         }
 589         if (capacity_bs < 1) {
 590                 printf("Blocksize is too small\n");
 591                 return;
 592         }
 593         if (capacity_bs != 512)
 594                 printf("INFO: Blocksize is not 512 bytes\n");
 595
 596         if (p->try_shorter_wrapper_block) {
 597                 printf("Trying too short command wrapper:\n");
 598                 do_msc_shorter_cmd(lun);
 599         }
 600
 601         if (p->try_invalid_scsi_command) {
 602                 int status;
 603
 604                 for (tries = 0; tries != 4; tries++) {
 605
 606                         printf("Trying invalid SCSI command: ");
 607
 608                         status = do_msc_cmd(request_invalid,
 609                             sizeof(request_invalid), dummy_buf,
 610                             255, 1, 1, lun, 0);
 611
 612                         printf("Result%s as expected\n", status ? "" : " NOT");
 613
 614                         usleep(50000);
 615                 }
 616         }
 617         if (p->try_invalid_wrapper_block) {
 618                 int status;
 619
 620                 for (tries = 0; tries != 4; tries++) {
 621
 622                         printf("Trying invalid USB wrapper block signature: ");
 623
 624                         xfer_wrapper_sig = 0x55663322;
 625
 626                         status = do_msc_cmd(read_capacity,
 627                             sizeof(read_capacity), dummy_buf,
 628                             255, 1, 1, lun, 0);
 629
 630                         printf("Result%s as expected\n", status ? "" : " NOT");
 631
 632                         xfer_wrapper_sig = CBWSIGNATURE;
 633
 634                         usleep(50000);
 635                 }
 636         }
 637         do_msc_cmd(request_sense, sizeof(request_sense), dummy_buf, 255, 1, 1, lun, 0);
 638         do_msc_cmd(read_capacity, sizeof(read_capacity), dummy_buf, 255, 1, 1, lun, 0);
 639         do_msc_cmd(request_sense, sizeof(request_sense), dummy_buf, 255, 1, 1, lun, 0);
 640         do_msc_cmd(test_unit_ready, sizeof(test_unit_ready), 0, 0, 1, 1, lun, 0);
 641         do_msc_cmd(test_unit_ready, sizeof(test_unit_ready), 0, 0, 1, 1, lun, 0);
 642         do_msc_cmd(request_sense, sizeof(request_sense), dummy_buf, 255, 1, 1, lun, 0);
 643         do_msc_cmd(test_unit_ready, sizeof(test_unit_ready), 0, 0, 1, 1, lun, 0);
 644         do_msc_cmd(request_sense, sizeof(request_sense), dummy_buf, 255, 1, 1, lun, 0);
 645         do_msc_cmd(test_unit_ready, sizeof(test_unit_ready), 0, 0, 1, 1, lun, 0);
 646         do_msc_cmd(test_unit_ready, sizeof(test_unit_ready), 0, 0, 1, 1, lun, 0);
 647         do_msc_cmd(test_unit_ready, sizeof(test_unit_ready), 0, 0, 1, 1, lun, 0);
 648         do_msc_cmd(request_sense, sizeof(request_sense), dummy_buf, 255, 1, 1, lun, 0);
 649         do_msc_cmd(test_unit_ready, sizeof(test_unit_ready), 0, 0, 1, 1, lun, 0);
 650         do_msc_cmd(read_capacity, sizeof(read_capacity), dummy_buf, 255, 1, 1, lun, 0);
 651         do_msc_cmd(mode_page_inquiry, sizeof(mode_page_inquiry), dummy_buf, 255, 1, 1, lun, 0);
 652         do_msc_cmd(mode_page_inquiry, sizeof(mode_page_inquiry), dummy_buf, 255, 1, 1, lun, 0);
 653
 654         if (do_msc_cmd(prevent_removal, sizeof(prevent_removal),
 655             0, 0, 1, 1, lun, 0)) {
 656                 printf("INFO: Prevent medium removal failed\n");
 657         }
 658         if (do_msc_cmd(read_toc, sizeof(read_toc),
 659             dummy_buf, 255, 1, 1, lun, 0)) {
 660                 printf("INFO: Read Table Of Content failed\n");
 661         }
 662         if (p->try_last_lba) {
 663
 664                 for (y = 0, x = (1UL << 31); x; x >>= 1) {
 665                         if (do_read_10(x | y, block_size, dummy_buf, lun) == 0)
 666                                 y |= x;
 667                 }
 668
 669                 printf("Highest readable LBA: %u (%s), "
 670                     "Capacity is %u MBytes\n", y,
 671                     (capacity_lba != y) ? "WRONG" : "OK",
 672                     (int)((((uint64_t)(y) * (uint64_t)block_size) +
 673                     (uint64_t)block_size) / 1000000ULL));
 674         } else {
 675
 676                 y = capacity_lba;
 677
 678                 printf("Highest readable LBA: %u (not "
 679                     "verified), Capacity is %u MBytes\n", y,
 680                     (int)((((uint64_t)(y) * (uint64_t)block_size) +
 681                     (uint64_t)block_size) / 1000000ULL));
 682         }
 683
 684         if (y != 0xFFFFFFFFU)
 685                 y++;
 686
 687         lba_max = y;
 688
 689         switch (p->io_area) {
 690         case USB_MSC_IO_AREA_1MB:
 691                 lba_max = 1024;
 692                 break;
 693         case USB_MSC_IO_AREA_16MB:
 694                 lba_max = 1024 * 16;
 695                 break;
 696         case USB_MSC_IO_AREA_256MB:
 697                 lba_max = 1024 * 256;
 698                 break;
 699         case USB_MSC_IO_AREA_COMPLETE:
 700         default:
 701                 break;
 702         }
 703
 704         if (lba_max > 65535)
 705                 lba_max = 65535;
 706
 707         printf("Highest testable LBA: %u\n", (int)lba_max);
 708
 709         buffer = malloc(block_size * lba_max);
 710         if (buffer == NULL) {
 711                 printf("ERROR: Could not allocate memory\n");
 712                 goto fail;
 713         }
 714         reference = malloc(block_size * lba_max);
 715         if (reference == NULL) {
 716                 printf("ERROR: Could not allocate memory\n");
 717                 goto fail;
 718         }
 719 retry_read_init:
 720
 721         printf("Setting up initial data pattern, "
 722             "LBA limit = %u ... ", lba_max);
 723
 724         switch (p->io_mode) {
 725         case USB_MSC_IO_MODE_WRITE_ONCE_READ_ONLY:
 726         case USB_MSC_IO_MODE_WRITE_ONLY:
 727         case USB_MSC_IO_MODE_READ_WRITE:
 728
 729                 switch (p->io_pattern) {
 730                 case USB_MSC_IO_PATTERN_FIXED:
 731                         for (x = 0; x != (block_size * lba_max); x += 8) {
 732                                 reference[x + 0] = x >> 24;
 733                                 reference[x + 1] = x >> 16;
 734                                 reference[x + 2] = x >> 8;
 735                                 reference[x + 3] = x >> 0;
 736                                 reference[x + 4] = 0xFF;
 737                                 reference[x + 5] = 0x00;
 738                                 reference[x + 6] = 0xFF;
 739                                 reference[x + 7] = 0x00;
 740                         }
 741                         if (do_write_10(0, lba_max * block_size,
 742                             reference, lun)) {
 743                                 printf("FAILED\n");
 744                                 lba_max /= 2;
 745                                 if (lba_max)
 746                                         goto retry_read_init;
 747                                 goto fail;
 748                         }
 749                         printf("SUCCESS\n");
 750                         break;
 751                 case USB_MSC_IO_PATTERN_RANDOM:
 752                         for (x = 0; x != (block_size * lba_max); x++) {
 753                                 reference[x] = usb_ts_rand_noise() % 255U;
 754                         }
 755                         if (do_write_10(0, lba_max * block_size,
 756                             reference, lun)) {
 757                                 printf("FAILED\n");
 758                                 lba_max /= 2;
 759                                 if (lba_max)
 760                                         goto retry_read_init;
 761                                 goto fail;
 762                         }
 763                         printf("SUCCESS\n");
 764                         break;
 765                 default:
 766                         if (do_read_10(0, lba_max * block_size,
 767                             reference, lun)) {
 768                                 printf("FAILED\n");
 769                                 lba_max /= 2;
 770                                 if (lba_max)
 771                                         goto retry_read_init;
 772                                 goto fail;
 773                         }
 774                         printf("SUCCESS\n");
 775                         break;
 776                 }
 777                 break;
 778
 779         default:
 780                 if (do_read_10(0, lba_max * block_size, reference, lun)) {
 781                         printf("FAILED\n");
 782                         lba_max /= 2;
 783                         if (lba_max)
 784                                 goto retry_read_init;
 785                         goto fail;
 786                 }
 787                 printf("SUCCESS\n");
 788                 break;
 789         }
 790
 791
 792         if (p->try_abort_data_write) {
 793                 if (do_write_10(0, (2 * block_size) | 1, reference, lun))
 794                         printf("Aborted data write failed (OK)!\n");
 795                 else
 796                         printf("Aborted data write did not fail (ERROR)!\n");
 797
 798                 if (do_read_10(0, (2 * block_size), reference, lun))
 799                         printf("Post-aborted data read failed (ERROR)\n");
 800                 else
 801                         printf("Post-aborted data read success (OK)!\n");
 802         }
 803         printf("Starting test ...\n");
 804
 805         gettimeofday(&ref_tv, 0);
 806
 807         last_sec = ref_tv.tv_sec;
 808
 809         printf("\n");
 810
 811         while (1) {
 812
 813                 gettimeofday(&sub_tv, 0);
 814
 815                 if (last_sec != sub_tv.tv_sec) {
 816
 817                         printf("STATUS: ID=%u, RX=%u bytes/sec, "
 818                             "TX=%u bytes/sec, ERR=%u, RST=%u, DERR=%u\n",
 819                             (int)xfer_current_id,
 820                             (int)(stats.xfer_rx_bytes -
 821                             last_stat.xfer_rx_bytes),
 822                             (int)(stats.xfer_tx_bytes -
 823                             last_stat.xfer_tx_bytes),
 824                             (int)(stats.xfer_error),
 825                             (int)(stats.xfer_reset),
 826                             (int)(stats.data_error));
 827
 828                         fflush(stdout);
 829
 830                         last_sec = sub_tv.tv_sec;
 831                         last_stat = stats;
 832                 }
 833                 timersub(&sub_tv, &ref_tv, &res_tv);
 834
 835                 if ((res_tv.tv_sec < 0) || (res_tv.tv_sec >= (int)p->duration))
 836                         break;
 837
 838                 do_io_test(p, lun, lba_max, buffer, reference);
 839
 840                 if (libusb20_dev_check_connected(usb_pdev) != 0) {
 841                         printf("Device disconnected\n");
 842                         break;
 843                 }
 844                 if (p->done) {
 845                         printf("Maximum number of errors exceeded\n");
 846                         break;
 847                 }
 848         }
 849
 850         printf("\nTest done!\n");
 851
 852 fail:
 853         if (buffer)
 854                 free(buffer);
 855         if (reference)
 856                 free(reference);
 857 }
 858
 859 void
 860 show_host_device_selection(uint8_t level, uint16_t *pvid, uint16_t *ppid)
 861 {
 862         struct libusb20_backend *pbe;
 863         struct libusb20_device *pdev;
 864         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
 865
 866         uint16_t vid[USB_DEVICES_MAX];
 867         uint16_t pid[USB_DEVICES_MAX];
 868
 869         int index;
 870         int sel;
 871
 872         const char *ptr;
 873
 874 top:
 875         pbe = libusb20_be_alloc_default();
 876         pdev = NULL;
 877         index = 0;
 878
 879         printf("\n[] Select USB device:\n");
 880
 881         while ((pdev = libusb20_be_device_foreach(pbe, pdev))) {
 882
 883                 if (libusb20_dev_get_mode(pdev) != LIBUSB20_MODE_HOST)
 884                         continue;
 885
 886                 if (index < USB_DEVICES_MAX) {
 887                         ddesc = libusb20_dev_get_device_desc(pdev);
 888                         ptr = libusb20_dev_get_desc(pdev);
 889                         printf("%s%d) %s\n", indent[level], index, ptr);
 890                         vid[index] = ddesc->idVendor;
 891                         pid[index] = ddesc->idProduct;
 892                         index++;
 893                 } else {
 894                         break;
 895                 }
 896         }
 897
 898         printf("%sr) Refresh device list\n", indent[level]);
 899         printf("%sx) Return to previous menu\n", indent[level]);
 900
 901         /* release data */
 902         libusb20_be_free(pbe);
 903
 904         sel = get_integer();
 905
 906         if (sel == -2)
 907                 goto top;
 908
 909         if ((sel < 0) || (sel >= index)) {
 910                 *pvid = 0;
 911                 *ppid = 0;
 912                 return;
 913         }
 914         *pvid = vid[sel];
 915         *ppid = pid[sel];
 916 }
 917
 918 struct libusb20_device *
 919 find_usb_device(uint16_t vid, uint16_t pid)
 920 {
 921         struct libusb20_backend *pbe = libusb20_be_alloc_default();
 922         struct libusb20_device *pdev = NULL;
 923         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
 924
 925         while ((pdev = libusb20_be_device_foreach(pbe, pdev))) {
 926
 927                 if (libusb20_dev_get_mode(pdev) != LIBUSB20_MODE_HOST)
 928                         continue;
 929
 930                 ddesc = libusb20_dev_get_device_desc(pdev);
 931
 932                 if ((vid == ddesc->idVendor) &&
 933                     (pid == ddesc->idProduct)) {
 934                         libusb20_be_dequeue_device(pbe, pdev);
 935                         break;
 936                 }
 937         }
 938
 939         /* release data */
 940         libusb20_be_free(pbe);
 941
 942         return (pdev);
 943 }
 944
 945 void
 946 find_usb_endpoints(struct libusb20_device *pdev, uint8_t class,
 947     uint8_t subclass, uint8_t protocol, uint8_t alt_setting,
 948     uint8_t *pif, uint8_t *in_ep, uint8_t *out_ep, uint8_t next_if)
 949 {
 950         struct libusb20_config *pcfg;
 951         struct libusb20_interface *iface;
 952         struct libusb20_endpoint *ep;
 953         uint8_t x;
 954         uint8_t y;
 955         uint8_t z;
 956
 957         *in_ep = 0;
 958         *out_ep = 0;
 959         *pif = 0;
 960
 961         pcfg = libusb20_dev_alloc_config(pdev,
 962             libusb20_dev_get_config_index(pdev));
 963
 964         if (pcfg == NULL)
 965                 return;
 966
 967         for (x = 0; x != pcfg->num_interface; x++) {
 968
 969                 y = alt_setting;
 970
 971                 iface = (pcfg->interface + x);
 972
 973                 if ((iface->desc.bInterfaceClass == class) &&
 974                     (iface->desc.bInterfaceSubClass == subclass ||
 975                     subclass == 255) &&
 976                     (iface->desc.bInterfaceProtocol == protocol ||
 977                     protocol == 255)) {
 978
 979                         if (next_if) {
 980                                 x++;
 981                                 if (x == pcfg->num_interface)
 982                                         break;
 983                                 iface = (pcfg->interface + x);
 984                         }
 985                         *pif = x;
 986
 987                         for (z = 0; z != iface->num_endpoints; z++) {
 988                                 ep = iface->endpoints + z;
 989
 990                                 /* BULK only */
 991                                 if ((ep->desc.bmAttributes & 3) != 2)
 992                                         continue;
 993
 994                                 if (ep->desc.bEndpointAddress & 0x80)
 995                                         *in_ep = ep->desc.bEndpointAddress;
 996                                 else
 997                                         *out_ep = ep->desc.bEndpointAddress;
 998                         }
 999                         break;
1000                 }
1001         }
1002
1003         free(pcfg);
1004 }
1005
1006 static void
1007 exec_host_msc_test(struct usb_msc_params *p, uint16_t vid, uint16_t pid)
1008 {
1009         struct libusb20_device *pdev;
1010
1011         uint8_t in_ep;
1012         uint8_t out_ep;
1013         uint8_t iface;
1014
1015         int error;
1016
1017         memset(&stats, 0, sizeof(stats));
1018
1019         xfer_current_id = 0;
1020         xfer_wrapper_sig = CBWSIGNATURE;
1021
1022         pdev = find_usb_device(vid, pid);
1023         if (pdev == NULL) {
1024                 printf("USB device not found\n");
1025                 return;
1026         }
1027         find_usb_endpoints(pdev, 8, 6, 0x50, 0, &iface, &in_ep, &out_ep, 0);
1028
1029         if ((in_ep == 0) || (out_ep == 0)) {
1030                 printf("Could not find USB endpoints\n");
1031                 libusb20_dev_free(pdev);
1032                 return;
1033         }
1034         printf("Attaching to: %s @ iface %d\n",
1035             libusb20_dev_get_desc(pdev), iface);
1036
1037         if (libusb20_dev_open(pdev, 2)) {
1038                 printf("Could not open USB device\n");
1039                 libusb20_dev_free(pdev);
1040                 return;
1041         }
1042         if (libusb20_dev_detach_kernel_driver(pdev, iface)) {
1043                 printf("WARNING: Could not detach kernel driver\n");
1044         }
1045         xfer_in = libusb20_tr_get_pointer(pdev, 0);
1046         error = libusb20_tr_open(xfer_in, 65536, 1, in_ep);
1047         if (error) {
1048                 printf("Could not open USB endpoint %d\n", in_ep);
1049                 libusb20_dev_free(pdev);
1050                 return;
1051         }
1052         xfer_out = libusb20_tr_get_pointer(pdev, 1);
1053         error = libusb20_tr_open(xfer_out, 65536, 1, out_ep);
1054         if (error) {
1055                 printf("Could not open USB endpoint %d\n", out_ep);
1056                 libusb20_dev_free(pdev);
1057                 return;
1058         }
1059         usb_pdev = pdev;
1060         usb_iface = iface;
1061
1062         usb_msc_test(p);
1063
1064         libusb20_dev_free(pdev);
1065 }
1066
1067 static void
1068 set_defaults(struct usb_msc_params *p)
1069 {
1070         memset(p, 0, sizeof(*p));
1071
1072         p->duration = 60;               /* seconds */
1073         p->try_invalid_scsi_command = 1;
1074         p->try_invalid_wrapper_block = 1;
1075         p->try_last_lba = 1;
1076         p->max_errors = -1;
1077 }
1078
1079 static const char *
1080 get_io_mode(const struct usb_msc_params *p)
1081 {
1082         ;                               /* indent fix */
1083         switch (p->io_mode) {
1084         case USB_MSC_IO_MODE_READ_ONLY:
1085                 return ("Read Only");
1086         case USB_MSC_IO_MODE_WRITE_ONCE_READ_ONLY:
1087                 return ("Write Once, Read Only");
1088         case USB_MSC_IO_MODE_WRITE_ONLY:
1089                 return ("Write Only");
1090         case USB_MSC_IO_MODE_READ_WRITE:
1091                 return ("Read and Write");
1092         default:
1093                 return ("Unknown");
1094         }
1095 }
1096
1097 static const char *
1098 get_io_pattern(const struct usb_msc_params *p)
1099 {
1100         ;                               /* indent fix */
1101         switch (p->io_pattern) {
1102         case USB_MSC_IO_PATTERN_FIXED:
1103                 return ("Fixed");
1104         case USB_MSC_IO_PATTERN_RANDOM:
1105                 return ("Random");
1106         case USB_MSC_IO_PATTERN_PRESERVE:
1107                 return ("Preserve");
1108         default:
1109                 return ("Unknown");
1110         }
1111 }
1112
1113 static const char *
1114 get_io_size(const struct usb_msc_params *p)
1115 {
1116         ;                               /* indent fix */
1117         switch (p->io_size) {
1118         case USB_MSC_IO_SIZE_RANDOM:
1119                 return ("Random");
1120         case USB_MSC_IO_SIZE_INCREASING:
1121                 return ("Increasing");
1122         case USB_MSC_IO_SIZE_FIXED_1BLK:
1123                 return ("Single block");
1124         case USB_MSC_IO_SIZE_FIXED_2BLK:
1125                 return ("2 blocks");
1126         case USB_MSC_IO_SIZE_FIXED_4BLK:
1127                 return ("4 blocks");
1128         case USB_MSC_IO_SIZE_FIXED_8BLK:
1129                 return ("8 blocks");
1130         case USB_MSC_IO_SIZE_FIXED_16BLK:
1131                 return ("16 blocks");
1132         case USB_MSC_IO_SIZE_FIXED_32BLK:
1133                 return ("32 blocks");
1134         case USB_MSC_IO_SIZE_FIXED_64BLK:
1135                 return ("64 blocks");
1136         case USB_MSC_IO_SIZE_FIXED_128BLK:
1137                 return ("128 blocks");
1138         case USB_MSC_IO_SIZE_FIXED_256BLK:
1139                 return ("256 blocks");
1140         case USB_MSC_IO_SIZE_FIXED_512BLK:
1141                 return ("512 blocks");
1142         case USB_MSC_IO_SIZE_FIXED_1024BLK:
1143                 return ("1024 blocks");
1144         default:
1145                 return ("Unknown");
1146         }
1147 }
1148
1149 static const char *
1150 get_io_delay(const struct usb_msc_params *p)
1151 {
1152         ;                               /* indent fix */
1153         switch (p->io_delay) {
1154         case USB_MSC_IO_DELAY_NONE:
1155                 return ("None");
1156         case USB_MSC_IO_DELAY_RANDOM_10MS:
1157                 return ("Random 10ms");
1158         case USB_MSC_IO_DELAY_RANDOM_100MS:
1159                 return ("Random 100ms");
1160         case USB_MSC_IO_DELAY_FIXED_10MS:
1161                 return ("Fixed 10ms");
1162         case USB_MSC_IO_DELAY_FIXED_100MS:
1163                 return ("Fixed 100ms");
1164         default:
1165                 return ("Unknown");
1166         }
1167 }
1168
1169 static const char *
1170 get_io_offset(const struct usb_msc_params *p)
1171 {
1172         ;                               /* indent fix */
1173         switch (p->io_offset) {
1174         case USB_MSC_IO_OFF_START_OF_DISK:
1175                 return ("Start Of Disk");
1176         case USB_MSC_IO_OFF_RANDOM:
1177                 return ("Random Offset");
1178         default:
1179                 return ("Unknown");
1180         }
1181 }
1182
1183 static const char *
1184 get_io_area(const struct usb_msc_params *p)
1185 {
1186         ;                               /* indent fix */
1187         switch (p->io_area) {
1188         case USB_MSC_IO_AREA_COMPLETE:
1189                 return ("Complete Disk");
1190         case USB_MSC_IO_AREA_1MB:
1191                 return ("First MegaByte");
1192         case USB_MSC_IO_AREA_16MB:
1193                 return ("First 16 MegaBytes");
1194         case USB_MSC_IO_AREA_256MB:
1195                 return ("First 256 MegaBytes");
1196         default:
1197                 return ("Unknown");
1198         }
1199 }
1200
1201 void
1202 show_host_msc_test(uint8_t level, uint16_t vid,
1203     uint16_t pid, uint32_t duration)
1204 {
1205         struct usb_msc_params params;
1206         uint8_t retval;
1207
1208         set_defaults(&params);
1209
1210         params.duration = duration;
1211
1212         while (1) {
1213
1214                 retval = usb_ts_show_menu(level,
1215                     "Mass Storage Test Parameters",
1216                     " 1) Toggle I/O mode: <%s>\n"
1217                     " 2) Toggle I/O size: <%s>\n"
1218                     " 3) Toggle I/O delay: <%s>\n"
1219                     " 4) Toggle I/O offset: <%s>\n"
1220                     " 5) Toggle I/O area: <%s>\n"
1221                     " 6) Toggle I/O pattern: <%s>\n"
1222                     " 7) Toggle try invalid SCSI command: <%s>\n"
1223                     " 8) Toggle try invalid wrapper block: <%s>\n"
1224                     " 9) Toggle try invalid MaxPacketSize: <%s>\n"
1225                     "10) Toggle try last Logical Block Address: <%s>\n"
1226                     "11) Toggle I/O lun: <%d>\n"
1227                     "12) Set maximum number of errors: <%d>\n"
1228                     "13) Set test duration: <%d> seconds\n"
1229                     "14) Toggle try aborted write transfer: <%s>\n"
1230                     "15) Toggle request sense on error: <%s>\n"
1231                     "16) Toggle try all LUN: <%s>\n"
1232                     "17) Toggle try too short wrapper block: <%s>\n"
1233                     "20) Reset parameters\n"
1234                     "30) Start test (VID=0x%04x, PID=0x%04x)\n"
1235                     "40) Select another device\n"
1236                     " x) Return to previous menu \n",
1237                     get_io_mode(&params),
1238                     get_io_size(&params),
1239                     get_io_delay(&params),
1240                     get_io_offset(&params),
1241                     get_io_area(&params),
1242                     get_io_pattern(&params),
1243                     (params.try_invalid_scsi_command ? "YES" : "NO"),
1244                     (params.try_invalid_wrapper_block ? "YES" : "NO"),
1245                     (params.try_invalid_max_packet_size ? "YES" : "NO"),
1246                     (params.try_last_lba ? "YES" : "NO"),
1247                     params.io_lun,
1248                     (int)params.max_errors,
1249                     (int)params.duration,
1250                     (params.try_abort_data_write ? "YES" : "NO"),
1251                     (params.try_sense_on_error ? "YES" : "NO"),
1252                     (params.try_all_lun ? "YES" : "NO"),
1253                     (params.try_shorter_wrapper_block ? "YES" : "NO"),
1254                     vid, pid);
1255                 switch (retval) {
1256                 case 0:
1257                         break;
1258                 case 1:
1259                         params.io_mode++;
1260                         params.io_mode %= USB_MSC_IO_MODE_MAX;
1261                         break;
1262                 case 2:
1263                         params.io_size++;
1264                         params.io_size %= USB_MSC_IO_SIZE_MAX;
1265                         break;
1266                 case 3:
1267                         params.io_delay++;
1268                         params.io_delay %= USB_MSC_IO_DELAY_MAX;
1269                         break;
1270                 case 4:
1271                         params.io_offset++;
1272                         params.io_offset %= USB_MSC_IO_OFF_MAX;
1273                         break;
1274                 case 5:
1275                         params.io_area++;
1276                         params.io_area %= USB_MSC_IO_AREA_MAX;
1277                         break;
1278                 case 6:
1279                         params.io_pattern++;
1280                         params.io_pattern %= USB_MSC_IO_PATTERN_MAX;
1281                         break;
1282                 case 7:
1283                         params.try_invalid_scsi_command ^= 1;
1284                         break;
1285                 case 8:
1286                         params.try_invalid_wrapper_block ^= 1;
1287                         break;
1288                 case 9:
1289                         params.try_invalid_max_packet_size ^= 1;
1290                         break;
1291                 case 10:
1292                         params.try_last_lba ^= 1;
1293                         break;
1294                 case 11:
1295                         params.io_lun++;
1296                         params.io_lun %= USB_MSC_IO_LUN_MAX;
1297                         break;
1298                 case 12:
1299                         params.max_errors = get_integer();
1300                         break;
1301                 case 13:
1302                         params.duration = get_integer();
1303                         break;
1304                 case 14:
1305                         params.try_abort_data_write ^= 1;
1306                         break;
1307                 case 15:
1308                         params.try_sense_on_error ^= 1;
1309                         break;
1310                 case 16:
1311                         params.try_all_lun ^= 1;
1312                         break;
1313                 case 17:
1314                         params.try_shorter_wrapper_block ^= 1;
1315                         break;
1316                 case 20:
1317                         set_defaults(&params);
1318                         break;
1319                 case 30:
1320                         exec_host_msc_test(&params, vid, pid);
1321                         break;
1322                 case 40:
1323                         show_host_device_selection(level + 1, &vid, &pid);
1324                         break;
1325                 default:
1326                         return;
1327                 }
1328         }
1329 }