LCOV - code coverage report
Current view: top level - lkbce/drivers/usb/storage - scsiglue.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 168 177 94.9 %
Date: 2017-01-25 Functions: 11 12 91.7 %

          Line data    Source code
       1             : /* Driver for USB Mass Storage compliant devices
       2             :  * SCSI layer glue code
       3             :  *
       4             :  * Current development and maintenance by:
       5             :  *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
       6             :  *
       7             :  * Developed with the assistance of:
       8             :  *   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
       9             :  *   (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov)
      10             :  *
      11             :  * Initial work by:
      12             :  *   (c) 1999 Michael Gee (michael@linuxspecific.com)
      13             :  *
      14             :  * This driver is based on the 'USB Mass Storage Class' document. This
      15             :  * describes in detail the protocol used to communicate with such
      16             :  * devices.  Clearly, the designers had SCSI and ATAPI commands in
      17             :  * mind when they created this document.  The commands are all very
      18             :  * similar to commands in the SCSI-II and ATAPI specifications.
      19             :  *
      20             :  * It is important to note that in a number of cases this class
      21             :  * exhibits class-specific exemptions from the USB specification.
      22             :  * Notably the usage of NAK, STALL and ACK differs from the norm, in
      23             :  * that they are used to communicate wait, failed and OK on commands.
      24             :  *
      25             :  * Also, for certain devices, the interrupt endpoint is used to convey
      26             :  * status of a command.
      27             :  *
      28             :  * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
      29             :  * information about this driver.
      30             :  *
      31             :  * This program is free software; you can redistribute it and/or modify it
      32             :  * under the terms of the GNU General Public License as published by the
      33             :  * Free Software Foundation; either version 2, or (at your option) any
      34             :  * later version.
      35             :  *
      36             :  * This program is distributed in the hope that it will be useful, but
      37             :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      38             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      39             :  * General Public License for more details.
      40             :  *
      41             :  * You should have received a copy of the GNU General Public License along
      42             :  * with this program; if not, write to the Free Software Foundation, Inc.,
      43             :  * 675 Mass Ave, Cambridge, MA 02139, USA.
      44             :  */
      45             : 
      46             : #include <linux/slab.h>
      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             : /* Vendor IDs for companies that seem to include the READ CAPACITY bug
      63             :  * in all their devices
      64             :  */
      65             : #define VENDOR_ID_NOKIA         0x0421
      66             : #define VENDOR_ID_NIKON         0x04b0
      67             : #define VENDOR_ID_PENTAX        0x0a17
      68             : #define VENDOR_ID_MOTOROLA      0x22b8
      69             : 
      70             : /***********************************************************************
      71             :  * Host functions 
      72             :  ***********************************************************************/
      73             : 
      74             : static const char* host_info(struct Scsi_Host *host)
      75             : {
      76           4 :         struct us_data *us = host_to_us(host);
      77           2 :         return us->scsi_name;
      78             : }
      79             : 
      80             : static int slave_alloc (struct scsi_device *sdev)
      81             : {
      82           4 :         struct us_data *us = host_to_us(sdev->host);
      83           1 : 
      84             :         /*
      85             :          * Set the INQUIRY transfer length to 36.  We don't use any of
      86             :          * the extra data and many devices choke if asked for more or
      87             :          * less than 36 bytes.
      88             :          */
      89           1 :         sdev->inquiry_len = 36;
      90             : 
      91             :         /* USB has unusual DMA-alignment requirements: Although the
      92             :          * starting address of each scatter-gather element doesn't matter,
      93             :          * the length of each element except the last must be divisible
      94             :          * by the Bulk maxpacket value.  There's currently no way to
      95             :          * express this by block-layer constraints, so we'll cop out
      96             :          * and simply require addresses to be aligned at 512-byte
      97             :          * boundaries.  This is okay since most block I/O involves
      98             :          * hardware sectors that are multiples of 512 bytes in length,
      99             :          * and since host controllers up through USB 2.0 have maxpacket
     100             :          * values no larger than 512.
     101             :          *
     102             :          * But it doesn't suffice for Wireless USB, where Bulk maxpacket
     103             :          * values can be as large as 2048.  To make that work properly
     104             :          * will require changes to the block layer.
     105             :          */
     106           1 :         blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
     107             : 
     108             :         /*
     109             :          * The UFI spec treates the Peripheral Qualifier bits in an
     110             :          * INQUIRY result as reserved and requires devices to set them
     111             :          * to 0.  However the SCSI spec requires these bits to be set
     112             :          * to 3 to indicate when a LUN is not present.
     113             :          *
     114             :          * Let the scanning code know if this target merely sets
     115             :          * Peripheral Device Type to 0x1f to indicate no LUN.
     116             :          */
     117           3 :         if (us->subclass == US_SC_UFI)
     118           1 :                 sdev->sdev_target->pdt_1f_for_no_lun = 1;
     119             : 
     120           1 :         return 0;
     121             : }
     122             : 
     123             : static int slave_configure(struct scsi_device *sdev)
     124             : {
     125           4 :         struct us_data *us = host_to_us(sdev->host);
     126           1 : 
     127           1 :         /* Many devices have trouble transfering more than 32KB at a time,
     128           1 :          * while others have trouble with more than 64K. At this time we
     129           1 :          * are limiting both to 32K (64 sectores).
     130             :          */
     131           2 :         if (us->fflags & (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) {
     132           1 :                 unsigned int max_sectors = 64;
     133             : 
     134           2 :                 if (us->fflags & US_FL_MAX_SECTORS_MIN)
     135           1 :                         max_sectors = PAGE_CACHE_SIZE >> 9;
     136           4 :                 if (queue_max_sectors(sdev->request_queue) > max_sectors)
     137           1 :                         blk_queue_max_sectors(sdev->request_queue,
     138             :                                               max_sectors);
     139           3 :         } else if (sdev->type == TYPE_TAPE) {
     140             :                 /* Tapes need much higher max_sector limits, so just
     141             :                  * raise it to the maximum possible (4 GB / 512) and
     142             :                  * let the queue segment size sort out the real limit.
     143             :                  */
     144           1 :                 blk_queue_max_sectors(sdev->request_queue, 0x7FFFFF);
     145             :         }
     146             : 
     147             :         /* Some USB host controllers can't do DMA; they have to use PIO.
     148             :          * They indicate this by setting their dma_mask to NULL.  For
     149             :          * such controllers we need to make sure the block layer sets
     150             :          * up bounce buffers in addressable memory.
     151             :          */
     152           6 :         if (!us->pusb_dev->bus->controller->dma_mask)
     153           2 :                 blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_HIGH);
     154             : 
     155             :         /* We can't put these settings in slave_alloc() because that gets
     156             :          * called before the device type is known.  Consequently these
     157             :          * settings can't be overridden via the scsi devinfo mechanism. */
     158           6 :         if (sdev->type == TYPE_DISK) {
     159             : 
     160             :                 /* Some vendors seem to put the READ CAPACITY bug into
     161             :                  * all their devices -- primarily makers of cell phones
     162             :                  * and digital cameras.  Since these devices always use
     163             :                  * flash media and can be expected to have an even number
     164             :                  * of sectors, we will always enable the CAPACITY_HEURISTICS
     165             :                  * flag unless told otherwise. */
     166           2 :                 switch (le16_to_cpu(us->pusb_dev->descriptor.idVendor)) {
     167           8 :                 case VENDOR_ID_NOKIA:
     168           8 :                 case VENDOR_ID_NIKON:
     169           8 :                 case VENDOR_ID_PENTAX:
     170           8 :                 case VENDOR_ID_MOTOROLA:
     171           4 :                         if (!(us->fflags & (US_FL_FIX_CAPACITY |
     172             :                                         US_FL_CAPACITY_OK)))
     173           2 :                                 us->fflags |= US_FL_CAPACITY_HEURISTICS;
     174           2 :                         break;
     175           2 :                 }
     176             : 
     177           2 :                 /* Disk-type devices use MODE SENSE(6) if the protocol
     178             :                  * (SubClass) is Transparent SCSI, otherwise they use
     179             :                  * MODE SENSE(10). */
     180          12 :                 if (us->subclass != US_SC_SCSI && us->subclass != US_SC_CYP_ATACB)
     181           2 :                         sdev->use_10_for_ms = 1;
     182             : 
     183             :                 /* Many disks only accept MODE SENSE transfer lengths of
     184             :                  * 192 bytes (that's what Windows uses). */
     185           2 :                 sdev->use_192_bytes_for_3f = 1;
     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           4 :                 if (us->fflags & US_FL_NO_WP_DETECT)
     195           2 :                         sdev->skip_ms_page_3f = 1;
     196             : 
     197             :                 /* A number of devices have problems with MODE SENSE for
     198             :                  * page x08, so we will skip it. */
     199           2 :                 sdev->skip_ms_page_8 = 1;
     200             : 
     201             :                 /* Some disks return the total number of blocks in response
     202             :                  * to READ CAPACITY rather than the highest block number.
     203             :                  * If this device makes that mistake, tell the sd driver. */
     204           4 :                 if (us->fflags & US_FL_FIX_CAPACITY)
     205           2 :                         sdev->fix_capacity = 1;
     206             : 
     207             :                 /* A few disks have two indistinguishable version, one of
     208             :                  * which reports the correct capacity and the other does not.
     209             :                  * The sd driver has to guess which is the case. */
     210           4 :                 if (us->fflags & US_FL_CAPACITY_HEURISTICS)
     211           2 :                         sdev->guess_capacity = 1;
     212             : 
     213             :                 /* assume SPC3 or latter devices support sense size > 18 */
     214           6 :                 if (sdev->scsi_level > SCSI_SPC_2)
     215           2 :                         us->fflags |= US_FL_SANE_SENSE;
     216             : 
     217             :                 /* Some devices report a SCSI revision level above 2 but are
     218             :                  * unable to handle the REPORT LUNS command (for which
     219             :                  * support is mandatory at level 3).  Since we already have
     220             :                  * a Get-Max-LUN request, we won't lose much by setting the
     221             :                  * revision level down to 2.  The only devices that would be
     222             :                  * affected are those with sparse LUNs. */
     223           6 :                 if (sdev->scsi_level > SCSI_2)
     224           6 :                         sdev->sdev_target->scsi_level =
     225             :                                         sdev->scsi_level = SCSI_2;
     226             : 
     227             :                 /* USB-IDE bridges tend to report SK = 0x04 (Non-recoverable
     228             :                  * Hardware Error) when any low-level error occurs,
     229             :                  * recoverable or not.  Setting this flag tells the SCSI
     230             :                  * midlayer to retry such commands, which frequently will
     231             :                  * succeed and fix the error.  The worst this can lead to
     232             :                  * is an occasional series of retries that will all fail. */
     233           2 :                 sdev->retry_hwerror = 1;
     234             : 
     235             :                 /* USB disks should allow restart.  Some drives spin down
     236             :                  * automatically, requiring a START-STOP UNIT command. */
     237           2 :                 sdev->allow_restart = 1;
     238             : 
     239             :                 /* Some USB cardreaders have trouble reading an sdcard's last
     240             :                  * sector in a larger then 1 sector read, since the performance
     241             :                  * impact is negible we set this flag for all USB disks */
     242           2 :                 sdev->last_sector_bug = 1;
     243             : 
     244             :                 /* Enable last-sector hacks for single-target devices using
     245             :                  * the Bulk-only transport, unless we already know the
     246             :                  * capacity will be decremented or is correct. */
     247          10 :                 if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK |
     248             :                                         US_FL_SCM_MULT_TARG)) &&
     249             :                                 us->protocol == US_PR_BULK)
     250           2 :                         us->use_last_sector_hacks = 1;
     251             :         } else {
     252             : 
     253             :                 /* Non-disk-type devices don't need to blacklist any pages
     254             :                  * or to force 192-byte transfer lengths for MODE SENSE.
     255             :                  * But they do need to use MODE SENSE(10). */
     256           2 :                 sdev->use_10_for_ms = 1;
     257             :         }
     258             : 
     259             :         /* The CB and CBI transports have no way to pass LUN values
     260             :          * other than the bits in the second byte of a CDB.  But those
     261             :          * bits don't get set to the LUN value if the device reports
     262             :          * scsi_level == 0 (UNKNOWN).  Hence such devices must necessarily
     263             :          * be single-LUN.
     264             :          */
     265          12 :         if ((us->protocol == US_PR_CB || us->protocol == US_PR_CBI) &&
     266             :                         sdev->scsi_level == SCSI_UNKNOWN)
     267           2 :                 us->max_lun = 0;
     268             : 
     269             :         /* Some devices choke when they receive a PREVENT-ALLOW MEDIUM
     270             :          * REMOVAL command, so suppress those commands. */
     271           4 :         if (us->fflags & US_FL_NOT_LOCKABLE)
     272           2 :                 sdev->lockable = 0;
     273             : 
     274             :         /* this is to satisfy the compiler, tho I don't think the 
     275             :          * return code is ever checked anywhere. */
     276           2 :         return 0;
     277             : }
     278             : 
     279             : /* queue a command */
     280             : /* This is always called with scsi_lock(host) held */
     281             : static int queuecommand(struct scsi_cmnd *srb,
     282             :                         void (*done)(struct scsi_cmnd *))
     283           1 : {
     284           4 :         struct us_data *us = host_to_us(srb->device->host);
     285           1 : 
     286             :         US_DEBUGP("%s called\n", __func__);
     287             : 
     288             :         /* check for state-transition errors */
     289           3 :         if (us->srb != NULL) {
     290           1 :                 printk(KERN_ERR USB_STORAGE "Error in %s: us->srb = %p\n",
     291             :                         __func__, us->srb);
     292           1 :                 return SCSI_MLQUEUE_HOST_BUSY;
     293             :         }
     294             : 
     295             :         /* fail the command if we are disconnecting */
     296           4 :         if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
     297             :                 US_DEBUGP("Fail command during disconnect\n");
     298           1 :                 srb->result = DID_NO_CONNECT << 16;
     299           1 :                 done(srb);
     300           1 :                 return 0;
     301             :         }
     302             : 
     303             :         /* enqueue the command and wake up the control thread */
     304           1 :         srb->scsi_done = done;
     305           1 :         us->srb = srb;
     306           1 :         complete(&us->cmnd_ready);
     307             : 
     308           1 :         return 0;
     309             : }
     310             : 
     311             : /***********************************************************************
     312             :  * Error handling functions
     313             :  ***********************************************************************/
     314             : 
     315             : /* Command timeout and abort */
     316             : static int command_abort(struct scsi_cmnd *srb)
     317             : {
     318           4 :         struct us_data *us = host_to_us(srb->device->host);
     319           1 : 
     320           1 :         US_DEBUGP("%s called\n", __func__);
     321           1 : 
     322           1 :         /* us->srb together with the TIMED_OUT, RESETTING, and ABORTING
     323           1 :          * bits are protected by the host lock. */
     324           4 :         scsi_lock(us_to_host(us));
     325             : 
     326             :         /* Is this command still active? */
     327           3 :         if (us->srb != srb) {
     328           4 :                 scsi_unlock(us_to_host(us));
     329             :                 US_DEBUGP ("-- nothing to abort\n");
     330           1 :                 return FAILED;
     331             :         }
     332             : 
     333             :         /* Set the TIMED_OUT bit.  Also set the ABORTING bit, but only if
     334             :          * a device reset isn't already in progress (to avoid interfering
     335             :          * with the reset).  Note that we must retain the host lock while
     336             :          * calling usb_stor_stop_transport(); otherwise it might interfere
     337             :          * with an auto-reset that begins as soon as we release the lock. */
     338           2 :         set_bit(US_FLIDX_TIMED_OUT, &us->dflags);
     339           4 :         if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) {
     340           2 :                 set_bit(US_FLIDX_ABORTING, &us->dflags);
     341           2 :                 usb_stor_stop_transport(us);
     342             :         }
     343           6 :         scsi_unlock(us_to_host(us));
     344             : 
     345             :         /* Wait for the aborted command to finish */
     346           1 :         wait_for_completion(&us->notify);
     347           1 :         return SUCCESS;
     348             : }
     349             : 
     350             : /* This invokes the transport reset mechanism to reset the state of the
     351             :  * device */
     352             : static int device_reset(struct scsi_cmnd *srb)
     353             : {
     354           4 :         struct us_data *us = host_to_us(srb->device->host);
     355           1 :         int result;
     356           1 : 
     357             :         US_DEBUGP("%s called\n", __func__);
     358             : 
     359             :         /* lock the device pointers and do the reset */
     360           1 :         mutex_lock(&(us->dev_mutex));
     361          10 :         result = us->transport_reset(us);
     362           1 :         mutex_unlock(&us->dev_mutex);
     363             : 
     364           6 :         return result < 0 ? FAILED : SUCCESS;
     365             : }
     366             : 
     367             : /* Simulate a SCSI bus reset by resetting the device's USB port. */
     368             : static int bus_reset(struct scsi_cmnd *srb)
     369             : {
     370           4 :         struct us_data *us = host_to_us(srb->device->host);
     371           1 :         int result;
     372           1 : 
     373             :         US_DEBUGP("%s called\n", __func__);
     374           4 :         result = usb_stor_port_reset(us);
     375           6 :         return result < 0 ? FAILED : SUCCESS;
     376             : }
     377             : 
     378             : /* Report a driver-initiated device reset to the SCSI layer.
     379             :  * Calling this for a SCSI-initiated reset is unnecessary but harmless.
     380             :  * The caller must own the SCSI host lock. */
     381             : void usb_stor_report_device_reset(struct us_data *us)
     382             : {
     383           0 :         int i;
     384           0 :         struct Scsi_Host *host = us_to_host(us);
     385           0 : 
     386           0 :         scsi_report_device_reset(host, 0, 0);
     387           0 :         if (us->fflags & US_FL_SCM_MULT_TARG) {
     388           0 :                 for (i = 1; i < host->max_id; ++i)
     389           0 :                         scsi_report_device_reset(host, 0, i);
     390           0 :         }
     391             : }
     392             : 
     393             : /* Report a driver-initiated bus reset to the SCSI layer.
     394             :  * Calling this for a SCSI-initiated reset is unnecessary but harmless.
     395             :  * The caller must not own the SCSI host lock. */
     396           0 : void usb_stor_report_bus_reset(struct us_data *us)
     397             : {
     398           4 :         struct Scsi_Host *host = us_to_host(us);
     399           1 : 
     400           2 :         scsi_lock(host);
     401           1 :         scsi_report_bus_reset(host, 0);
     402           2 :         scsi_unlock(host);
     403           1 : }
     404             : 
     405             : /***********************************************************************
     406             :  * /proc/scsi/ functions
     407             :  ***********************************************************************/
     408             : 
     409             : /* we use this macro to help us write into the buffer */
     410             : #undef SPRINTF
     411             : #define SPRINTF(args...) \
     412             :         do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
     413             : 
     414             : static int proc_info (struct Scsi_Host *host, char *buffer,
     415             :                 char **start, off_t offset, int length, int inout)
     416             : {
     417           4 :         struct us_data *us = host_to_us(host);
     418           2 :         char *pos = buffer;
     419           1 :         const char *string;
     420           1 : 
     421           1 :         /* if someone is sending us data, just throw it away */
     422           3 :         if (inout)
     423           2 :                 return length;
     424           1 : 
     425           1 :         /* print the controller name */
     426           5 :         SPRINTF("   Host scsi%d: usb-storage\n", host->host_no);
     427           1 : 
     428           1 :         /* print product, vendor, and serial number strings */
     429           4 :         if (us->pusb_dev->manufacturer)
     430           3 :                 string = us->pusb_dev->manufacturer;
     431           4 :         else if (us->unusual_dev->vendorName)
     432           2 :                 string = us->unusual_dev->vendorName;
     433           1 :         else
     434           2 :                 string = "Unknown";
     435           5 :         SPRINTF("       Vendor: %s\n", string);
     436           4 :         if (us->pusb_dev->product)
     437           3 :                 string = us->pusb_dev->product;
     438           4 :         else if (us->unusual_dev->productName)
     439           2 :                 string = us->unusual_dev->productName;
     440           1 :         else
     441           2 :                 string = "Unknown";
     442           5 :         SPRINTF("      Product: %s\n", string);
     443           4 :         if (us->pusb_dev->serial)
     444           3 :                 string = us->pusb_dev->serial;
     445           1 :         else
     446           2 :                 string = "None";
     447           4 :         SPRINTF("Serial Number: %s\n", string);
     448             : 
     449             :         /* show the protocol and transport */
     450           4 :         SPRINTF("     Protocol: %s\n", us->protocol_name);
     451           4 :         SPRINTF("    Transport: %s\n", us->transport_name);
     452             : 
     453             :         /* show the device flags */
     454           2 :         if (pos < buffer + length) {
     455           2 :                 pos += sprintf(pos, "       Quirks:");
     456             : 
     457             : #define US_FLAG(name, value) \
     458             :         if (us->fflags & value) pos += sprintf(pos, " " #name);
     459          73 : US_DO_ALL_FLAGS
     460             : #undef US_FLAG
     461             : 
     462           3 :                 *(pos++) = '\n';
     463             :         }
     464             : 
     465             :         /*
     466             :          * Calculate start of next buffer, and return value.
     467             :          */
     468           1 :         *start = buffer + offset;
     469             : 
     470           2 :         if ((pos - buffer) < offset)
     471           1 :                 return (0);
     472           2 :         else if ((pos - buffer - offset) < length)
     473           1 :                 return (pos - buffer - offset);
     474             :         else
     475           1 :                 return (length);
     476             : }
     477             : 
     478             : /***********************************************************************
     479             :  * Sysfs interface
     480             :  ***********************************************************************/
     481             : 
     482             : /* Output routine for the sysfs max_sectors file */
     483             : static ssize_t show_max_sectors(struct device *dev, struct device_attribute *attr, char *buf)
     484             : {
     485           2 :         struct scsi_device *sdev = to_scsi_device(dev);
     486           1 : 
     487           5 :         return sprintf(buf, "%u\n", queue_max_sectors(sdev->request_queue));
     488           1 : }
     489           1 : 
     490             : /* Input routine for the sysfs max_sectors file */
     491             : static ssize_t store_max_sectors(struct device *dev, struct device_attribute *attr, const char *buf,
     492             :                 size_t count)
     493             : {
     494           3 :         struct scsi_device *sdev = to_scsi_device(dev);
     495           1 :         unsigned short ms;
     496           1 : 
     497           6 :         if (sscanf(buf, "%hu", &ms) > 0 && ms <= SCSI_DEFAULT_MAX_SECTORS) {
     498           2 :                 blk_queue_max_sectors(sdev->request_queue, ms);
     499           2 :                 return strlen(buf);
     500             :         }
     501           1 :         return -EINVAL; 
     502             : }
     503             : 
     504             : static DEVICE_ATTR(max_sectors, S_IRUGO | S_IWUSR, show_max_sectors,
     505           1 :                 store_max_sectors);
     506             : 
     507           1 : static struct device_attribute *sysfs_device_attr_list[] = {
     508             :                 &dev_attr_max_sectors,
     509             :                 NULL,
     510             :                 };
     511             : 
     512             : /*
     513             :  * this defines our host template, with which we'll allocate hosts
     514             :  */
     515             : 
     516           1 : struct scsi_host_template usb_stor_host_template = {
     517             :         /* basic userland interface stuff */
     518             :         .name =                         "usb-storage",
     519             :         .proc_name =                    "usb-storage",
     520             :         .proc_info =                    proc_info,
     521             :         .info =                         host_info,
     522             : 
     523             :         /* command interface -- queued only */
     524             :         .queuecommand =                 queuecommand,
     525             : 
     526             :         /* error and abort handlers */
     527             :         .eh_abort_handler =             command_abort,
     528             :         .eh_device_reset_handler =      device_reset,
     529             :         .eh_bus_reset_handler =         bus_reset,
     530             : 
     531             :         /* queue commands only, only one command per LUN */
     532             :         .can_queue =                    1,
     533             :         .cmd_per_lun =                  1,
     534             : 
     535             :         /* unknown initiator id */
     536             :         .this_id =                      -1,
     537             : 
     538             :         .slave_alloc =                  slave_alloc,
     539             :         .slave_configure =              slave_configure,
     540             : 
     541             :         /* lots of sg segments can be handled */
     542             :         .sg_tablesize =                 SG_ALL,
     543             : 
     544             :         /* limit the total size of a transfer to 120 KB */
     545             :         .max_sectors =                  240,
     546             : 
     547             :         /* merge commands... this seems to help performance, but
     548             :          * periodically someone should test to see which setting is more
     549             :          * optimal.
     550             :          */
     551             :         .use_clustering =               1,
     552             : 
     553             :         /* emulated HBA */
     554             :         .emulated =                     1,
     555             : 
     556             :         /* we do our own delay after a device or bus reset */
     557             :         .skip_settle_delay =            1,
     558             : 
     559             :         /* sysfs device attributes */
     560             :         .sdev_attrs =                   sysfs_device_attr_list,
     561             : 
     562             :         /* module management */
     563             :         .module =                       THIS_MODULE
     564             : };
     565             : 
     566             : /* To Report "Illegal Request: Invalid Field in CDB */
     567           1 : unsigned char usb_stor_sense_invalidCDB[18] = {
     568             :         [0]     = 0x70,                     /* current error */
     569             :         [2]     = ILLEGAL_REQUEST,          /* Illegal Request = 0x05 */
     570             :         [7]     = 0x0a,                     /* additional length */
     571             :         [12]    = 0x24                      /* Invalid Field in CDB */
     572             : };
     573             : EXPORT_SYMBOL_GPL(usb_stor_sense_invalidCDB);

Generated by: LCOV version 1.10