drivers/usb/storage/scsiglue.c

   1 /*
   2  * Driver for USB Mass Storage compliant devices
   3  * SCSI layer glue code
   4  *
   5  * Current development and maintenance by:
   6  *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
   7  *
   8  * Developed with the assistance of:
   9  *   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
  10  *   (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov)
  11  *
  12  * Initial work by:
  13  *   (c) 1999 Michael Gee (michael@linuxspecific.com)
  14  *
  15  * This driver is based on the 'USB Mass Storage Class' document. This
  16  * describes in detail the protocol used to communicate with such
  17  * devices.  Clearly, the designers had SCSI and ATAPI commands in
  18  * mind when they created this document.  The commands are all very
  19  * similar to commands in the SCSI-II and ATAPI specifications.
  20  *
  21  * It is important to note that in a number of cases this class
  22  * exhibits class-specific exemptions from the USB specification.
  23  * Notably the usage of NAK, STALL and ACK differs from the norm, in
  24  * that they are used to communicate wait, failed and OK on commands.
  25  *
  26  * Also, for certain devices, the interrupt endpoint is used to convey
  27  * status of a command.
  28  *
  29  * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
  30  * information about this driver.
  31  *
  32  * This program is free software; you can redistribute it and/or modify it
  33  * under the terms of the GNU General Public License as published by the
  34  * Free Software Foundation; either version 2, or (at your option) any
  35  * later version.
  36  *
  37  * This program is distributed in the hope that it will be useful, but
  38  * WITHOUT ANY WARRANTY; without even the implied warranty of
  39  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  40  * General Public License for more details.
  41  *
  42  * You should have received a copy of the GNU General Public License along
  43  * with this program; if not, write to the Free Software Foundation, Inc.,
  44  * 675 Mass Ave, Cambridge, MA 02139, USA.
  45  */
  46
  47 #include <linux/module.h>
  48 #include <linux/mutex.h>
  49
  50 #include <scsi/scsi.h>
  51 #include <scsi/scsi_cmnd.h>
  52 #include <scsi/scsi_devinfo.h>
  53 #include <scsi/scsi_device.h>
  54 #include <scsi/scsi_eh.h>
  55
  56 #include "usb.h"
  57 #include "scsiglue.h"
  58 #include "debug.h"
  59 #include "transport.h"
  60 #include "protocol.h"
  61
  62 /*
  63  * Vendor IDs for companies that seem to include the READ CAPACITY bug
  64  * in all their devices
  65  */
  66 #define VENDOR_ID_NOKIA         0x0421
  67 #define VENDOR_ID_NIKON         0x04b0
  68 #define VENDOR_ID_PENTAX        0x0a17
  69 #define VENDOR_ID_MOTOROLA      0x22b8
  70
  71 /***********************************************************************
  72  * Host functions
  73  ***********************************************************************/
  74
  75 static const char* host_info(struct Scsi_Host *host)
  76 {
  77         struct us_data *us = host_to_us(host);
  78         return us->scsi_name;
  79 }
  80
  81 static int slave_alloc (struct scsi_device *sdev)
  82 {
  83         struct us_data *us = host_to_us(sdev->host);
  84
  85         /*
  86          * Set the INQUIRY transfer length to 36.  We don't use any of
  87          * the extra data and many devices choke if asked for more or
  88          * less than 36 bytes.
  89          */
  90         sdev->inquiry_len = 36;
  91
  92         /*
  93          * Some host controllers may have alignment requirements.
  94          * We'll play it safe by requiring 512-byte alignment always.
  95          */
  96         blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
  97
  98         /* Tell the SCSI layer if we know there is more than one LUN */
  99         if (us->protocol == USB_PR_BULK && us->max_lun > 0)
 100                 sdev->sdev_bflags |= BLIST_FORCELUN;
 101
 102         return 0;
 103 }
 104
 105 static int slave_configure(struct scsi_device *sdev)
 106 {
 107         struct us_data *us = host_to_us(sdev->host);
 108
 109         /*
 110          * Many devices have trouble transferring more than 32KB at a time,
 111          * while others have trouble with more than 64K. At this time we
 112          * are limiting both to 32K (64 sectores).
 113          */
 114         if (us->fflags & (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) {
 115                 unsigned int max_sectors = 64;
 116
 117                 if (us->fflags & US_FL_MAX_SECTORS_MIN)
 118                         max_sectors = PAGE_SIZE >> 9;
 119                 if (queue_max_hw_sectors(sdev->request_queue) > max_sectors)
 120                         blk_queue_max_hw_sectors(sdev->request_queue,
 121                                               max_sectors);
 122         } else if (sdev->type == TYPE_TAPE) {
 123                 /*
 124                  * Tapes need much higher max_sector limits, so just
 125                  * raise it to the maximum possible (4 GB / 512) and
 126                  * let the queue segment size sort out the real limit.
 127                  */
 128                 blk_queue_max_hw_sectors(sdev->request_queue, 0x7FFFFF);
 129         } else if (us->pusb_dev->speed >= USB_SPEED_SUPER) {
 130                 /*
 131                  * USB3 devices will be limited to 2048 sectors. This gives us
 132                  * better throughput on most devices.
 133                  */
 134                 blk_queue_max_hw_sectors(sdev->request_queue, 2048);
 135         }
 136
 137         /*
 138          * Some USB host controllers can't do DMA; they have to use PIO.
 139          * They indicate this by setting their dma_mask to NULL.  For
 140          * such controllers we need to make sure the block layer sets
 141          * up bounce buffers in addressable memory.
 142          */
 143         if (!us->pusb_dev->bus->controller->dma_mask)
 144                 blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_HIGH);
 145
 146         /*
 147          * We can't put these settings in slave_alloc() because that gets
 148          * called before the device type is known.  Consequently these
 149          * settings can't be overridden via the scsi devinfo mechanism.
 150          */
 151         if (sdev->type == TYPE_DISK) {
 152
 153                 /*
 154                  * Some vendors seem to put the READ CAPACITY bug into
 155                  * all their devices -- primarily makers of cell phones
 156                  * and digital cameras.  Since these devices always use
 157                  * flash media and can be expected to have an even number
 158                  * of sectors, we will always enable the CAPACITY_HEURISTICS
 159                  * flag unless told otherwise.
 160                  */
 161                 switch (le16_to_cpu(us->pusb_dev->descriptor.idVendor)) {
 162                 case VENDOR_ID_NOKIA:
 163                 case VENDOR_ID_NIKON:
 164                 case VENDOR_ID_PENTAX:
 165                 case VENDOR_ID_MOTOROLA:
 166                         if (!(us->fflags & (US_FL_FIX_CAPACITY |
 167                                         US_FL_CAPACITY_OK)))
 168                                 us->fflags |= US_FL_CAPACITY_HEURISTICS;
 169                         break;
 170                 }
 171
 172                 /*
 173                  * Disk-type devices use MODE SENSE(6) if the protocol
 174                  * (SubClass) is Transparent SCSI, otherwise they use
 175                  * MODE SENSE(10).
 176                  */
 177                 if (us->subclass != USB_SC_SCSI && us->subclass != USB_SC_CYP_ATACB)
 178                         sdev->use_10_for_ms = 1;
 179
 180                 /*
 181                  *Many disks only accept MODE SENSE transfer lengths of
 182                  * 192 bytes (that's what Windows uses).
 183                  */
 184                 sdev->use_192_bytes_for_3f = 1;
 185
 186                 /*
 187                  * Some devices don't like MODE SENSE with page=0x3f,
 188                  * which is the command used for checking if a device
 189                  * is write-protected.  Now that we tell the sd driver
 190                  * to do a 192-byte transfer with this command the
 191                  * majority of devices work fine, but a few still can't
 192                  * handle it.  The sd driver will simply assume those
 193                  * devices are write-enabled.
 194                  */
 195                 if (us->fflags & US_FL_NO_WP_DETECT)
 196                         sdev->skip_ms_page_3f = 1;
 197
 198                 /*
 199                  * A number of devices have problems with MODE SENSE for
 200                  * page x08, so we will skip it.
 201                  */
 202                 sdev->skip_ms_page_8 = 1;
 203
 204                 /* Some devices don't handle VPD pages correctly */
 205                 sdev->skip_vpd_pages = 1;
 206
 207                 /* Do not attempt to use REPORT SUPPORTED OPERATION CODES */
 208                 sdev->no_report_opcodes = 1;
 209
 210                 /* Do not attempt to use WRITE SAME */
 211                 sdev->no_write_same = 1;
 212
 213                 /*
 214                  * Some disks return the total number of blocks in response
 215                  * to READ CAPACITY rather than the highest block number.
 216                  * If this device makes that mistake, tell the sd driver.
 217                  */
 218                 if (us->fflags & US_FL_FIX_CAPACITY)
 219                         sdev->fix_capacity = 1;
 220
 221                 /*
 222                  * A few disks have two indistinguishable version, one of
 223                  * which reports the correct capacity and the other does not.
 224                  * The sd driver has to guess which is the case.
 225                  */
 226                 if (us->fflags & US_FL_CAPACITY_HEURISTICS)
 227                         sdev->guess_capacity = 1;
 228
 229                 /* Some devices cannot handle READ_CAPACITY_16 */
 230                 if (us->fflags & US_FL_NO_READ_CAPACITY_16)
 231                         sdev->no_read_capacity_16 = 1;
 232
 233                 /*
 234                  * Many devices do not respond properly to READ_CAPACITY_16.
 235                  * Tell the SCSI layer to try READ_CAPACITY_10 first.
 236                  * However some USB 3.0 drive enclosures return capacity
 237                  * modulo 2TB. Those must use READ_CAPACITY_16
 238                  */
 239                 if (!(us->fflags & US_FL_NEEDS_CAP16))
 240                         sdev->try_rc_10_first = 1;
 241
 242                 /*
 243                  * assume SPC3 or latter devices support sense size > 18
 244                  * unless US_FL_BAD_SENSE quirk is specified.
 245                  */
 246                 if (sdev->scsi_level > SCSI_SPC_2 &&
 247                     !(us->fflags & US_FL_BAD_SENSE))
 248                         us->fflags |= US_FL_SANE_SENSE;
 249
 250                 /*
 251                  * USB-IDE bridges tend to report SK = 0x04 (Non-recoverable
 252                  * Hardware Error) when any low-level error occurs,
 253                  * recoverable or not.  Setting this flag tells the SCSI
 254                  * midlayer to retry such commands, which frequently will
 255                  * succeed and fix the error.  The worst this can lead to
 256                  * is an occasional series of retries that will all fail.
 257                  */
 258                 sdev->retry_hwerror = 1;
 259
 260                 /*
 261                  * USB disks should allow restart.  Some drives spin down
 262                  * automatically, requiring a START-STOP UNIT command.
 263                  */
 264                 sdev->allow_restart = 1;
 265
 266                 /*
 267                  * Some USB cardreaders have trouble reading an sdcard's last
 268                  * sector in a larger then 1 sector read, since the performance
 269                  * impact is negligible we set this flag for all USB disks
 270                  */
 271                 sdev->last_sector_bug = 1;
 272
 273                 /*
 274                  * Enable last-sector hacks for single-target devices using
 275                  * the Bulk-only transport, unless we already know the
 276                  * capacity will be decremented or is correct.
 277                  */
 278                 if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK |
 279                                         US_FL_SCM_MULT_TARG)) &&
 280                                 us->protocol == USB_PR_BULK)
 281                         us->use_last_sector_hacks = 1;
 282
 283                 /* Check if write cache default on flag is set or not */
 284                 if (us->fflags & US_FL_WRITE_CACHE)
 285                         sdev->wce_default_on = 1;
 286
 287                 /* A few buggy USB-ATA bridges don't understand FUA */
 288                 if (us->fflags & US_FL_BROKEN_FUA)
 289                         sdev->broken_fua = 1;
 290
 291                 /* Some even totally fail to indicate a cache */
 292                 if (us->fflags & US_FL_ALWAYS_SYNC) {
 293                         /* don't read caching information */
 294                         sdev->skip_ms_page_8 = 1;
 295                         sdev->skip_ms_page_3f = 1;
 296                         /* assume sync is needed */
 297                         sdev->wce_default_on = 1;
 298                 }
 299         } else {
 300
 301                 /*
 302                  * Non-disk-type devices don't need to blacklist any pages
 303                  * or to force 192-byte transfer lengths for MODE SENSE.
 304                  * But they do need to use MODE SENSE(10).
 305                  */
 306                 sdev->use_10_for_ms = 1;
 307
 308                 /* Some (fake) usb cdrom devices don't like READ_DISC_INFO */
 309                 if (us->fflags & US_FL_NO_READ_DISC_INFO)
 310                         sdev->no_read_disc_info = 1;
 311         }
 312
 313         /*
 314          * The CB and CBI transports have no way to pass LUN values
 315          * other than the bits in the second byte of a CDB.  But those
 316          * bits don't get set to the LUN value if the device reports
 317          * scsi_level == 0 (UNKNOWN).  Hence such devices must necessarily
 318          * be single-LUN.
 319          */
 320         if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_CBI) &&
 321                         sdev->scsi_level == SCSI_UNKNOWN)
 322                 us->max_lun = 0;
 323
 324         /*
 325          * Some devices choke when they receive a PREVENT-ALLOW MEDIUM
 326          * REMOVAL command, so suppress those commands.
 327          */
 328         if (us->fflags & US_FL_NOT_LOCKABLE)
 329                 sdev->lockable = 0;
 330
 331         /*
 332          * this is to satisfy the compiler, tho I don't think the
 333          * return code is ever checked anywhere.
 334          */
 335         return 0;
 336 }
 337
 338 static int target_alloc(struct scsi_target *starget)
 339 {
 340         struct us_data *us = host_to_us(dev_to_shost(starget->dev.parent));
 341
 342         /*
 343          * Some USB drives don't support REPORT LUNS, even though they
 344          * report a SCSI revision level above 2.  Tell the SCSI layer
 345          * not to issue that command; it will perform a normal sequential
 346          * scan instead.
 347          */
 348         starget->no_report_luns = 1;
 349
 350         /*
 351          * The UFI spec treats the Peripheral Qualifier bits in an
 352          * INQUIRY result as reserved and requires devices to set them
 353          * to 0.  However the SCSI spec requires these bits to be set
 354          * to 3 to indicate when a LUN is not present.
 355          *
 356          * Let the scanning code know if this target merely sets
 357          * Peripheral Device Type to 0x1f to indicate no LUN.
 358          */
 359         if (us->subclass == USB_SC_UFI)
 360                 starget->pdt_1f_for_no_lun = 1;
 361
 362         return 0;
 363 }
 364
 365 /* queue a command */
 366 /* This is always called with scsi_lock(host) held */
 367 static int queuecommand_lck(struct scsi_cmnd *srb,
 368                         void (*done)(struct scsi_cmnd *))
 369 {
 370         struct us_data *us = host_to_us(srb->device->host);
 371
 372         /* check for state-transition errors */
 373         if (us->srb != NULL) {
 374                 printk(KERN_ERR USB_STORAGE "Error in %s: us->srb = %p\n",
 375                         __func__, us->srb);
 376                 return SCSI_MLQUEUE_HOST_BUSY;
 377         }
 378
 379         /* fail the command if we are disconnecting */
 380         if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
 381                 usb_stor_dbg(us, "Fail command during disconnect\n");
 382                 srb->result = DID_NO_CONNECT << 16;
 383                 done(srb);
 384                 return 0;
 385         }
 386
 387         if ((us->fflags & US_FL_NO_ATA_1X) &&
 388                         (srb->cmnd[0] == ATA_12 || srb->cmnd[0] == ATA_16)) {
 389                 memcpy(srb->sense_buffer, usb_stor_sense_invalidCDB,
 390                        sizeof(usb_stor_sense_invalidCDB));
 391                 srb->result = SAM_STAT_CHECK_CONDITION;
 392                 done(srb);
 393                 return 0;
 394         }
 395
 396         /* enqueue the command and wake up the control thread */
 397         srb->scsi_done = done;
 398         us->srb = srb;
 399         complete(&us->cmnd_ready);
 400
 401         return 0;
 402 }
 403
 404 static DEF_SCSI_QCMD(queuecommand)
 405
 406 /***********************************************************************
 407  * Error handling functions
 408  ***********************************************************************/
 409
 410 /* Command timeout and abort */
 411 static int command_abort(struct scsi_cmnd *srb)
 412 {
 413         struct us_data *us = host_to_us(srb->device->host);
 414
 415         usb_stor_dbg(us, "%s called\n", __func__);
 416
 417         /*
 418          * us->srb together with the TIMED_OUT, RESETTING, and ABORTING
 419          * bits are protected by the host lock.
 420          */
 421         scsi_lock(us_to_host(us));
 422
 423         /* Is this command still active? */
 424         if (us->srb != srb) {
 425                 scsi_unlock(us_to_host(us));
 426                 usb_stor_dbg(us, "-- nothing to abort\n");
 427                 return FAILED;
 428         }
 429
 430         /*
 431          * Set the TIMED_OUT bit.  Also set the ABORTING bit, but only if
 432          * a device reset isn't already in progress (to avoid interfering
 433          * with the reset).  Note that we must retain the host lock while
 434          * calling usb_stor_stop_transport(); otherwise it might interfere
 435          * with an auto-reset that begins as soon as we release the lock.
 436          */
 437         set_bit(US_FLIDX_TIMED_OUT, &us->dflags);
 438         if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) {
 439                 set_bit(US_FLIDX_ABORTING, &us->dflags);
 440                 usb_stor_stop_transport(us);
 441         }
 442         scsi_unlock(us_to_host(us));
 443
 444         /* Wait for the aborted command to finish */
 445         wait_for_completion(&us->notify);
 446         return SUCCESS;
 447 }
 448
 449 /*
 450  * This invokes the transport reset mechanism to reset the state of the
 451  * device
 452  */
 453 static int device_reset(struct scsi_cmnd *srb)
 454 {
 455         struct us_data *us = host_to_us(srb->device->host);
 456         int result;
 457
 458         usb_stor_dbg(us, "%s called\n", __func__);
 459
 460         /* lock the device pointers and do the reset */
 461         mutex_lock(&(us->dev_mutex));
 462         result = us->transport_reset(us);
 463         mutex_unlock(&us->dev_mutex);
 464
 465         return result < 0 ? FAILED : SUCCESS;
 466 }
 467
 468 /* Simulate a SCSI bus reset by resetting the device's USB port. */
 469 static int bus_reset(struct scsi_cmnd *srb)
 470 {
 471         struct us_data *us = host_to_us(srb->device->host);
 472         int result;
 473
 474         usb_stor_dbg(us, "%s called\n", __func__);
 475
 476         result = usb_stor_port_reset(us);
 477         return result < 0 ? FAILED : SUCCESS;
 478 }
 479
 480 /*
 481  * Report a driver-initiated device reset to the SCSI layer.
 482  * Calling this for a SCSI-initiated reset is unnecessary but harmless.
 483  * The caller must own the SCSI host lock.
 484  */
 485 void usb_stor_report_device_reset(struct us_data *us)
 486 {
 487         int i;
 488         struct Scsi_Host *host = us_to_host(us);
 489
 490         scsi_report_device_reset(host, 0, 0);
 491         if (us->fflags & US_FL_SCM_MULT_TARG) {
 492                 for (i = 1; i < host->max_id; ++i)
 493                         scsi_report_device_reset(host, 0, i);
 494         }
 495 }
 496
 497 /*
 498  * Report a driver-initiated bus reset to the SCSI layer.
 499  * Calling this for a SCSI-initiated reset is unnecessary but harmless.
 500  * The caller must not own the SCSI host lock.
 501  */
 502 void usb_stor_report_bus_reset(struct us_data *us)
 503 {
 504         struct Scsi_Host *host = us_to_host(us);
 505
 506         scsi_lock(host);
 507         scsi_report_bus_reset(host, 0);
 508         scsi_unlock(host);
 509 }
 510
 511 /***********************************************************************
 512  * /proc/scsi/ functions
 513  ***********************************************************************/
 514
 515 static int write_info(struct Scsi_Host *host, char *buffer, int length)
 516 {
 517         /* if someone is sending us data, just throw it away */
 518         return length;
 519 }
 520
 521 static int show_info (struct seq_file *m, struct Scsi_Host *host)
 522 {
 523         struct us_data *us = host_to_us(host);
 524         const char *string;
 525
 526         /* print the controller name */
 527         seq_printf(m, "   Host scsi%d: usb-storage\n", host->host_no);
 528
 529         /* print product, vendor, and serial number strings */
 530         if (us->pusb_dev->manufacturer)
 531                 string = us->pusb_dev->manufacturer;
 532         else if (us->unusual_dev->vendorName)
 533                 string = us->unusual_dev->vendorName;
 534         else
 535                 string = "Unknown";
 536         seq_printf(m, "       Vendor: %s\n", string);
 537         if (us->pusb_dev->product)
 538                 string = us->pusb_dev->product;
 539         else if (us->unusual_dev->productName)
 540                 string = us->unusual_dev->productName;
 541         else
 542                 string = "Unknown";
 543         seq_printf(m, "      Product: %s\n", string);
 544         if (us->pusb_dev->serial)
 545                 string = us->pusb_dev->serial;
 546         else
 547                 string = "None";
 548         seq_printf(m, "Serial Number: %s\n", string);
 549
 550         /* show the protocol and transport */
 551         seq_printf(m, "     Protocol: %s\n", us->protocol_name);
 552         seq_printf(m, "    Transport: %s\n", us->transport_name);
 553
 554         /* show the device flags */
 555         seq_printf(m, "       Quirks:");
 556
 557 #define US_FLAG(name, value) \
 558         if (us->fflags & value) seq_printf(m, " " #name);
 559 US_DO_ALL_FLAGS
 560 #undef US_FLAG
 561         seq_putc(m, '\n');
 562         return 0;
 563 }
 564
 565 /***********************************************************************
 566  * Sysfs interface
 567  ***********************************************************************/
 568
 569 /* Output routine for the sysfs max_sectors file */
 570 static ssize_t max_sectors_show(struct device *dev, struct device_attribute *attr, char *buf)
 571 {
 572         struct scsi_device *sdev = to_scsi_device(dev);
 573
 574         return sprintf(buf, "%u\n", queue_max_hw_sectors(sdev->request_queue));
 575 }
 576
 577 /* Input routine for the sysfs max_sectors file */
 578 static ssize_t max_sectors_store(struct device *dev, struct device_attribute *attr, const char *buf,
 579                 size_t count)
 580 {
 581         struct scsi_device *sdev = to_scsi_device(dev);
 582         unsigned short ms;
 583
 584         if (sscanf(buf, "%hu", &ms) > 0) {
 585                 blk_queue_max_hw_sectors(sdev->request_queue, ms);
 586                 return count;
 587         }
 588         return -EINVAL;
 589 }
 590 static DEVICE_ATTR_RW(max_sectors);
 591
 592 static struct device_attribute *sysfs_device_attr_list[] = {
 593         &dev_attr_max_sectors,
 594         NULL,
 595 };
 596
 597 /*
 598  * this defines our host template, with which we'll allocate hosts
 599  */
 600
 601 static const struct scsi_host_template usb_stor_host_template = {
 602         /* basic userland interface stuff */
 603         .name =                         "usb-storage",
 604         .proc_name =                    "usb-storage",
 605         .show_info =                    show_info,
 606         .write_info =                   write_info,
 607         .info =                         host_info,
 608
 609         /* command interface -- queued only */
 610         .queuecommand =                 queuecommand,
 611
 612         /* error and abort handlers */
 613         .eh_abort_handler =             command_abort,
 614         .eh_device_reset_handler =      device_reset,
 615         .eh_bus_reset_handler =         bus_reset,
 616
 617         /* queue commands only, only one command per LUN */
 618         .can_queue =                    1,
 619
 620         /* unknown initiator id */
 621         .this_id =                      -1,
 622
 623         .slave_alloc =                  slave_alloc,
 624         .slave_configure =              slave_configure,
 625         .target_alloc =                 target_alloc,
 626
 627         /* lots of sg segments can be handled */
 628         .sg_tablesize =                 SG_MAX_SEGMENTS,
 629
 630
 631         /*
 632          * Limit the total size of a transfer to 120 KB.
 633          *
 634          * Some devices are known to choke with anything larger. It seems like
 635          * the problem stems from the fact that original IDE controllers had
 636          * only an 8-bit register to hold the number of sectors in one transfer
 637          * and even those couldn't handle a full 256 sectors.
 638          *
 639          * Because we want to make sure we interoperate with as many devices as
 640          * possible, we will maintain a 240 sector transfer size limit for USB
 641          * Mass Storage devices.
 642          *
 643          * Tests show that other operating have similar limits with Microsoft
 644          * Windows 7 limiting transfers to 128 sectors for both USB2 and USB3
 645          * and Apple Mac OS X 10.11 limiting transfers to 256 sectors for USB2
 646          * and 2048 for USB3 devices.
 647          */
 648         .max_sectors =                  240,
 649
 650         /*
 651          * merge commands... this seems to help performance, but
 652          * periodically someone should test to see which setting is more
 653          * optimal.
 654          */
 655         .use_clustering =               1,
 656
 657         /* emulated HBA */
 658         .emulated =                     1,
 659
 660         /* we do our own delay after a device or bus reset */
 661         .skip_settle_delay =            1,
 662
 663         /* sysfs device attributes */
 664         .sdev_attrs =                   sysfs_device_attr_list,
 665
 666         /* module management */
 667         .module =                       THIS_MODULE
 668 };
 669
 670 void usb_stor_host_template_init(struct scsi_host_template *sht,
 671                                  const char *name, struct module *owner)
 672 {
 673         *sht = usb_stor_host_template;
 674         sht->name = name;
 675         sht->proc_name = name;
 676         sht->module = owner;
 677 }
 678 EXPORT_SYMBOL_GPL(usb_stor_host_template_init);
 679
 680 /* To Report "Illegal Request: Invalid Field in CDB */
 681 unsigned char usb_stor_sense_invalidCDB[18] = {
 682         [0]     = 0x70,                     /* current error */
 683         [2]     = ILLEGAL_REQUEST,          /* Illegal Request = 0x05 */
 684         [7]     = 0x0a,                     /* additional length */
 685         [12]    = 0x24                      /* Invalid Field in CDB */
 686 };
 687 EXPORT_SYMBOL_GPL(usb_stor_sense_invalidCDB);