LCOV - code coverage report
Current view: top level - lkbce/drivers/usb/storage - usb.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 346 442 78.3 %
Date: 2017-01-25 Functions: 20 23 87.0 %

          Line data    Source code
       1             : /* Driver for USB Mass Storage compliant devices
       2             :  *
       3             :  * Current development and maintenance by:
       4             :  *   (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
       5             :  *
       6             :  * Developed with the assistance of:
       7             :  *   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
       8             :  *   (c) 2003-2009 Alan Stern (stern@rowland.harvard.edu)
       9             :  *
      10             :  * Initial work by:
      11             :  *   (c) 1999 Michael Gee (michael@linuxspecific.com)
      12             :  *
      13             :  * usb_device_id support by Adam J. Richter (adam@yggdrasil.com):
      14             :  *   (c) 2000 Yggdrasil Computing, Inc.
      15             :  *
      16             :  * This driver is based on the 'USB Mass Storage Class' document. This
      17             :  * describes in detail the protocol used to communicate with such
      18             :  * devices.  Clearly, the designers had SCSI and ATAPI commands in
      19             :  * mind when they created this document.  The commands are all very
      20             :  * similar to commands in the SCSI-II and ATAPI specifications.
      21             :  *
      22             :  * It is important to note that in a number of cases this class
      23             :  * exhibits class-specific exemptions from the USB specification.
      24             :  * Notably the usage of NAK, STALL and ACK differs from the norm, in
      25             :  * that they are used to communicate wait, failed and OK on commands.
      26             :  *
      27             :  * Also, for certain devices, the interrupt endpoint is used to convey
      28             :  * status of a command.
      29             :  *
      30             :  * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
      31             :  * information about this driver.
      32             :  *
      33             :  * This program is free software; you can redistribute it and/or modify it
      34             :  * under the terms of the GNU General Public License as published by the
      35             :  * Free Software Foundation; either version 2, or (at your option) any
      36             :  * later version.
      37             :  *
      38             :  * This program is distributed in the hope that it will be useful, but
      39             :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      40             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      41             :  * General Public License for more details.
      42             :  *
      43             :  * You should have received a copy of the GNU General Public License along
      44             :  * with this program; if not, write to the Free Software Foundation, Inc.,
      45             :  * 675 Mass Ave, Cambridge, MA 02139, USA.
      46             :  */
      47             : 
      48             : #ifdef CONFIG_USB_STORAGE_DEBUG
      49             : #define DEBUG
      50             : #endif
      51             : 
      52             : #include <linux/sched.h>
      53             : #include <linux/errno.h>
      54             : #include <linux/freezer.h>
      55             : #include <linux/module.h>
      56             : #include <linux/init.h>
      57             : #include <linux/slab.h>
      58             : #include <linux/kthread.h>
      59             : #include <linux/mutex.h>
      60             : #include <linux/utsname.h>
      61             : 
      62             : #include <scsi/scsi.h>
      63             : #include <scsi/scsi_cmnd.h>
      64             : #include <scsi/scsi_device.h>
      65             : 
      66             : #include "usb.h"
      67             : #include "scsiglue.h"
      68             : #include "transport.h"
      69             : #include "protocol.h"
      70             : #include "debug.h"
      71             : #include "initializers.h"
      72             : 
      73             : #include "sierra_ms.h"
      74             : #include "option_ms.h"
      75             : 
      76             : /* Some informational data */
      77             : MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
      78             : MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
      79             : MODULE_LICENSE("GPL");
      80             : 
      81           1 : static unsigned int delay_use = 5;
      82             : module_param(delay_use, uint, S_IRUGO | S_IWUSR);
      83             : MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
      84             : 
      85           1 : static char quirks[128];
      86             : module_param_string(quirks, quirks, sizeof(quirks), S_IRUGO | S_IWUSR);
      87             : MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
      88             : 
      89             : 
      90             : /*
      91             :  * The entries in this table correspond, line for line,
      92             :  * with the entries in usb_storage_usb_ids[], defined in usual-tables.c.
      93             :  */
      94             : 
      95             : /* The vendor name should be kept at eight characters or less, and
      96             :  * the product name should be kept at 16 characters or less. If a device
      97             :  * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
      98             :  * normally generated by a device thorugh the INQUIRY response will be
      99             :  * taken from this list, and this is the reason for the above size
     100             :  * restriction. However, if the flag is not present, then you
     101             :  * are free to use as many characters as you like.
     102             :  */
     103             : 
     104             : #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
     105             :                     vendor_name, product_name, use_protocol, use_transport, \
     106             :                     init_function, Flags) \
     107             : { \
     108             :         .vendorName = vendor_name,      \
     109             :         .productName = product_name,    \
     110             :         .useProtocol = use_protocol,    \
     111             :         .useTransport = use_transport,  \
     112             :         .initFunction = init_function,  \
     113             : }
     114             : 
     115             : #define COMPLIANT_DEV   UNUSUAL_DEV
     116             : 
     117             : #define USUAL_DEV(use_protocol, use_transport, use_type) \
     118             : { \
     119             :         .useProtocol = use_protocol,    \
     120             :         .useTransport = use_transport,  \
     121             : }
     122             : 
     123           1 : static struct us_unusual_dev us_unusual_dev_list[] = {
     124             : #       include "unusual_devs.h" 
     125             :         { }             /* Terminating entry */
     126             : };
     127             : 
     128             : #undef UNUSUAL_DEV
     129             : #undef COMPLIANT_DEV
     130             : #undef USUAL_DEV
     131             : 
     132             : 
     133             : #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
     134             : 
     135             : int usb_stor_suspend(struct usb_interface *iface, pm_message_t message)
     136             : {
     137             :         struct us_data *us = usb_get_intfdata(iface);
     138             : 
     139             :         /* Wait until no command is running */
     140             :         mutex_lock(&us->dev_mutex);
     141             : 
     142             :         US_DEBUGP("%s\n", __func__);
     143             :         if (us->suspend_resume_hook)
     144             :                 (us->suspend_resume_hook)(us, US_SUSPEND);
     145             : 
     146             :         /* When runtime PM is working, we'll set a flag to indicate
     147             :          * whether we should autoresume when a SCSI request arrives. */
     148             : 
     149             :         mutex_unlock(&us->dev_mutex);
     150             :         return 0;
     151             : }
     152             : EXPORT_SYMBOL_GPL(usb_stor_suspend);
     153             : 
     154             : int usb_stor_resume(struct usb_interface *iface)
     155             : {
     156             :         struct us_data *us = usb_get_intfdata(iface);
     157             : 
     158             :         mutex_lock(&us->dev_mutex);
     159             : 
     160             :         US_DEBUGP("%s\n", __func__);
     161             :         if (us->suspend_resume_hook)
     162             :                 (us->suspend_resume_hook)(us, US_RESUME);
     163             : 
     164             :         mutex_unlock(&us->dev_mutex);
     165             :         return 0;
     166             : }
     167             : EXPORT_SYMBOL_GPL(usb_stor_resume);
     168             : 
     169             : int usb_stor_reset_resume(struct usb_interface *iface)
     170             : {
     171             :         struct us_data *us = usb_get_intfdata(iface);
     172             : 
     173             :         US_DEBUGP("%s\n", __func__);
     174             : 
     175             :         /* Report the reset to the SCSI core */
     176             :         usb_stor_report_bus_reset(us);
     177             : 
     178             :         /* FIXME: Notify the subdrivers that they need to reinitialize
     179             :          * the device */
     180             :         return 0;
     181             : }
     182             : EXPORT_SYMBOL_GPL(usb_stor_reset_resume);
     183             : 
     184             : #endif /* CONFIG_PM */
     185             : 
     186             : /*
     187             :  * The next two routines get called just before and just after
     188             :  * a USB port reset, whether from this driver or a different one.
     189             :  */
     190             : 
     191             : int usb_stor_pre_reset(struct usb_interface *iface)
     192             : {
     193           4 :         struct us_data *us = usb_get_intfdata(iface);
     194           1 : 
     195             :         US_DEBUGP("%s\n", __func__);
     196             : 
     197             :         /* Make sure no command runs during the reset */
     198           1 :         mutex_lock(&us->dev_mutex);
     199           1 :         return 0;
     200             : }
     201             : EXPORT_SYMBOL_GPL(usb_stor_pre_reset);
     202             : 
     203             : int usb_stor_post_reset(struct usb_interface *iface)
     204             : {
     205           4 :         struct us_data *us = usb_get_intfdata(iface);
     206           1 : 
     207             :         US_DEBUGP("%s\n", __func__);
     208             : 
     209             :         /* Report the reset to the SCSI core */
     210           2 :         usb_stor_report_bus_reset(us);
     211             : 
     212             :         /* FIXME: Notify the subdrivers that they need to reinitialize
     213             :          * the device */
     214             : 
     215           1 :         mutex_unlock(&us->dev_mutex);
     216           1 :         return 0;
     217             : }
     218             : EXPORT_SYMBOL_GPL(usb_stor_post_reset);
     219             : 
     220             : /*
     221             :  * fill_inquiry_response takes an unsigned char array (which must
     222             :  * be at least 36 characters) and populates the vendor name,
     223             :  * product name, and revision fields. Then the array is copied
     224             :  * into the SCSI command's response buffer (oddly enough
     225             :  * called request_buffer). data_len contains the length of the
     226             :  * data array, which again must be at least 36.
     227             :  */
     228             : 
     229             : void fill_inquiry_response(struct us_data *us, unsigned char *data,
     230             :                 unsigned int data_len)
     231           0 : {
     232           0 :         if (data_len<36) // You lose.
     233           0 :                 return;
     234           0 : 
     235           0 :         memset(data+8, ' ', 28);
     236           0 :         if(data[0]&0x20) { /* USB device currently not connected. Return
     237           0 :                               peripheral qualifier 001b ("...however, the
     238           0 :                               physical device is not currently connected
     239             :                               to this logical unit") and leave vendor and
     240             :                               product identification empty. ("If the target
     241             :                               does store some of the INQUIRY data on the
     242             :                               device, it may return zeros or ASCII spaces 
     243             :                               (20h) in those fields until the data is
     244             :                               available from the device."). */
     245             :         } else {
     246           0 :                 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
     247             :                 int n;
     248             : 
     249           0 :                 n = strlen(us->unusual_dev->vendorName);
     250           0 :                 memcpy(data+8, us->unusual_dev->vendorName, min(8, n));
     251           0 :                 n = strlen(us->unusual_dev->productName);
     252           0 :                 memcpy(data+16, us->unusual_dev->productName, min(16, n));
     253             : 
     254           0 :                 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F);
     255           0 :                 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F);
     256           0 :                 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F);
     257           0 :                 data[35] = 0x30 + ((bcdDevice) & 0x0F);
     258             :         }
     259             : 
     260           0 :         usb_stor_set_xfer_buf(data, data_len, us->srb);
     261           0 : }
     262             : EXPORT_SYMBOL_GPL(fill_inquiry_response);
     263             : 
     264             : static int usb_stor_control_thread(void * __us)
     265             : {
     266           0 :         struct us_data *us = (struct us_data *)__us;
     267           0 :         struct Scsi_Host *host = us_to_host(us);
     268           0 : 
     269           0 :         for(;;) {
     270           0 :                 US_DEBUGP("*** thread sleeping.\n");
     271           0 :                 if (wait_for_completion_interruptible(&us->cmnd_ready))
     272           0 :                         break;
     273           0 : 
     274           0 :                 US_DEBUGP("*** thread awakened.\n");
     275           0 : 
     276           0 :                 /* lock the device pointers */
     277           0 :                 mutex_lock(&(us->dev_mutex));
     278           0 : 
     279           0 :                 /* lock access to the state */
     280           0 :                 scsi_lock(host);
     281             : 
     282             :                 /* When we are called with no command pending, we're done */
     283           0 :                 if (us->srb == NULL) {
     284           0 :                         scsi_unlock(host);
     285           0 :                         mutex_unlock(&us->dev_mutex);
     286             :                         US_DEBUGP("-- exiting\n");
     287           0 :                         break;
     288             :                 }
     289             : 
     290             :                 /* has the command timed out *already* ? */
     291           0 :                 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
     292           0 :                         us->srb->result = DID_ABORT << 16;
     293           0 :                         goto SkipForAbort;
     294             :                 }
     295             : 
     296           0 :                 scsi_unlock(host);
     297             : 
     298             :                 /* reject the command if the direction indicator 
     299             :                  * is UNKNOWN
     300             :                  */
     301           0 :                 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
     302             :                         US_DEBUGP("UNKNOWN data direction\n");
     303           0 :                         us->srb->result = DID_ERROR << 16;
     304             :                 }
     305             : 
     306             :                 /* reject if target != 0 or if LUN is higher than
     307             :                  * the maximum known LUN
     308             :                  */
     309           0 :                 else if (us->srb->device->id && 
     310             :                                 !(us->fflags & US_FL_SCM_MULT_TARG)) {
     311             :                         US_DEBUGP("Bad target number (%d:%d)\n",
     312             :                                   us->srb->device->id, us->srb->device->lun);
     313           0 :                         us->srb->result = DID_BAD_TARGET << 16;
     314             :                 }
     315             : 
     316           0 :                 else if (us->srb->device->lun > us->max_lun) {
     317             :                         US_DEBUGP("Bad LUN (%d:%d)\n",
     318             :                                   us->srb->device->id, us->srb->device->lun);
     319           0 :                         us->srb->result = DID_BAD_TARGET << 16;
     320             :                 }
     321             : 
     322             :                 /* Handle those devices which need us to fake 
     323             :                  * their inquiry data */
     324           0 :                 else if ((us->srb->cmnd[0] == INQUIRY) &&
     325             :                             (us->fflags & US_FL_FIX_INQUIRY)) {
     326           0 :                         unsigned char data_ptr[36] = {
     327           0 :                             0x00, 0x80, 0x02, 0x02,
     328           0 :                             0x1F, 0x00, 0x00, 0x00};
     329             : 
     330             :                         US_DEBUGP("Faking INQUIRY command\n");
     331           0 :                         fill_inquiry_response(us, data_ptr, 36);
     332           0 :                         us->srb->result = SAM_STAT_GOOD;
     333             :                 }
     334             : 
     335             :                 /* we've got a command, let's do it! */
     336             :                 else {
     337             :                         US_DEBUG(usb_stor_show_command(us->srb));
     338           0 :                         us->proto_handler(us->srb, us);
     339             :                 }
     340             : 
     341             :                 /* lock access to the state */
     342           0 :                 scsi_lock(host);
     343             : 
     344             :                 /* indicate that the command is done */
     345           0 :                 if (us->srb->result != DID_ABORT << 16) {
     346             :                         US_DEBUGP("scsi cmd done, result=0x%x\n", 
     347             :                                    us->srb->result);
     348           0 :                         us->srb->scsi_done(us->srb);
     349             :                 } else {
     350             : SkipForAbort:
     351           0 :                         US_DEBUGP("scsi command aborted\n");
     352             :                 }
     353             : 
     354             :                 /* If an abort request was received we need to signal that
     355             :                  * the abort has finished.  The proper test for this is
     356             :                  * the TIMED_OUT flag, not srb->result == DID_ABORT, because
     357             :                  * the timeout might have occurred after the command had
     358             :                  * already completed with a different result code. */
     359           0 :                 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
     360           0 :                         complete(&(us->notify));
     361             : 
     362             :                         /* Allow USB transfers to resume */
     363           0 :                         clear_bit(US_FLIDX_ABORTING, &us->dflags);
     364           0 :                         clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
     365             :                 }
     366             : 
     367             :                 /* finished working on this command */
     368           0 :                 us->srb = NULL;
     369           0 :                 scsi_unlock(host);
     370             : 
     371             :                 /* unlock the device pointers */
     372           0 :                 mutex_unlock(&us->dev_mutex);
     373           0 :         } /* for (;;) */
     374           0 : 
     375           0 :         /* Wait until we are told to stop */
     376             :         for (;;) {
     377           0 :                 set_current_state(TASK_INTERRUPTIBLE);
     378           0 :                 if (kthread_should_stop())
     379           0 :                         break;
     380           0 :                 schedule();
     381           0 :         }
     382           0 :         __set_current_state(TASK_RUNNING);
     383           0 :         return 0;
     384             : }       
     385             : 
     386             : /***********************************************************************
     387             :  * Device probing and disconnecting
     388             :  ***********************************************************************/
     389             : 
     390             : /* Associate our private data with the USB device */
     391             : static int associate_dev(struct us_data *us, struct usb_interface *intf)
     392             : {
     393           1 :         US_DEBUGP("-- %s\n", __func__);
     394           1 : 
     395           1 :         /* Fill in the device-related fields */
     396           2 :         us->pusb_dev = interface_to_usbdev(intf);
     397           1 :         us->pusb_intf = intf;
     398           1 :         us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
     399             :         US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n",
     400             :                         le16_to_cpu(us->pusb_dev->descriptor.idVendor),
     401             :                         le16_to_cpu(us->pusb_dev->descriptor.idProduct),
     402             :                         le16_to_cpu(us->pusb_dev->descriptor.bcdDevice));
     403             :         US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n",
     404             :                         intf->cur_altsetting->desc.bInterfaceSubClass,
     405             :                         intf->cur_altsetting->desc.bInterfaceProtocol);
     406             : 
     407             :         /* Store our private data in the interface */
     408           2 :         usb_set_intfdata(intf, us);
     409             : 
     410             :         /* Allocate the device-related DMA-mapped buffers */
     411           2 :         us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr),
     412             :                         GFP_KERNEL, &us->cr_dma);
     413           3 :         if (!us->cr) {
     414             :                 US_DEBUGP("usb_ctrlrequest allocation failed\n");
     415           1 :                 return -ENOMEM;
     416             :         }
     417             : 
     418           2 :         us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE,
     419             :                         GFP_KERNEL, &us->iobuf_dma);
     420           3 :         if (!us->iobuf) {
     421             :                 US_DEBUGP("I/O buffer allocation failed\n");
     422           1 :                 return -ENOMEM;
     423             :         }
     424           1 :         return 0;
     425             : }
     426             : 
     427             : /* Works only for digits and letters, but small and fast */
     428             : #define TOLOWER(x) ((x) | 0x20)
     429             : 
     430             : /* Adjust device flags based on the "quirks=" module parameter */
     431             : static void adjust_quirks(struct us_data *us)
     432             : {
     433           1 :         char *p;
     434           2 :         u16 vid = le16_to_cpu(us->pusb_dev->descriptor.idVendor);
     435           2 :         u16 pid = le16_to_cpu(us->pusb_dev->descriptor.idProduct);
     436           2 :         unsigned f = 0;
     437           2 :         unsigned int mask = (US_FL_SANE_SENSE | US_FL_BAD_SENSE |
     438           1 :                         US_FL_FIX_CAPACITY |
     439           1 :                         US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE |
     440           1 :                         US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
     441           1 :                         US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
     442           1 :                         US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT);
     443             : 
     444           1 :         p = quirks;
     445           3 :         while (*p) {
     446           1 :                 /* Each entry consists of VID:PID:flags */
     447          11 :                 if (vid == simple_strtoul(p, &p, 16) &&
     448             :                                 *p == ':' &&
     449             :                                 pid == simple_strtoul(p+1, &p, 16) &&
     450             :                                 *p == ':')
     451           2 :                         break;
     452             : 
     453             :                 /* Move forward to the next entry */
     454           3 :                 while (*p) {
     455           5 :                         if (*p++ == ',')
     456           2 :                                 break;
     457             :                 }
     458             :         }
     459           2 :         if (!*p)        /* No match */
     460           3 :                 return;
     461           1 : 
     462             :         /* Collect the flags */
     463           6 :         while (*++p && *p != ',') {
     464           2 :                 switch (TOLOWER(*p)) {
     465           5 :                 case 'a':
     466           1 :                         f |= US_FL_SANE_SENSE;
     467           1 :                         break;
     468           4 :                 case 'b':
     469           1 :                         f |= US_FL_BAD_SENSE;
     470           1 :                         break;
     471           4 :                 case 'c':
     472           1 :                         f |= US_FL_FIX_CAPACITY;
     473           1 :                         break;
     474           4 :                 case 'h':
     475           1 :                         f |= US_FL_CAPACITY_HEURISTICS;
     476           1 :                         break;
     477           4 :                 case 'i':
     478           1 :                         f |= US_FL_IGNORE_DEVICE;
     479           1 :                         break;
     480           4 :                 case 'l':
     481           1 :                         f |= US_FL_NOT_LOCKABLE;
     482           1 :                         break;
     483           4 :                 case 'm':
     484           1 :                         f |= US_FL_MAX_SECTORS_64;
     485           1 :                         break;
     486           4 :                 case 'o':
     487           1 :                         f |= US_FL_CAPACITY_OK;
     488           1 :                         break;
     489           4 :                 case 'r':
     490           1 :                         f |= US_FL_IGNORE_RESIDUE;
     491           1 :                         break;
     492           4 :                 case 's':
     493           1 :                         f |= US_FL_SINGLE_LUN;
     494           1 :                         break;
     495           4 :                 case 'w':
     496           1 :                         f |= US_FL_NO_WP_DETECT;
     497           1 :                         break;
     498           1 :                 /* Ignore unrecognized flag characters */
     499             :                 }
     500           1 :         }
     501           2 :         us->fflags = (us->fflags & ~mask) | f;
     502           4 :         dev_info(&us->pusb_intf->dev, "Quirks match for "
     503           1 :                         "vid %04x pid %04x: %x\n",
     504             :                         vid, pid, f);
     505             : }
     506             : 
     507             : /* Get the unusual_devs entries and the string descriptors */
     508             : static int get_device_info(struct us_data *us, const struct usb_device_id *id,
     509             :                 struct us_unusual_dev *unusual_dev)
     510             : {
     511           2 :         struct usb_device *dev = us->pusb_dev;
     512           2 :         struct usb_interface_descriptor *idesc =
     513           1 :                 &us->pusb_intf->cur_altsetting->desc;
     514           1 : 
     515           1 :         /* Store the entries */
     516           2 :         us->unusual_dev = unusual_dev;
     517           7 :         us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ?
     518             :                         idesc->bInterfaceSubClass :
     519             :                         unusual_dev->useProtocol;
     520           7 :         us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ?
     521             :                         idesc->bInterfaceProtocol :
     522             :                         unusual_dev->useTransport;
     523           2 :         us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
     524           3 :         adjust_quirks(us);
     525             : 
     526           2 :         if (us->fflags & US_FL_IGNORE_DEVICE) {
     527           1 :                 printk(KERN_INFO USB_STORAGE "device ignored\n");
     528           1 :                 return -ENODEV;
     529             :         }
     530             : 
     531             :         /*
     532             :          * This flag is only needed when we're in high-speed, so let's
     533             :          * disable it if we're in full-speed
     534             :          */
     535           3 :         if (dev->speed != USB_SPEED_HIGH)
     536           1 :                 us->fflags &= ~US_FL_GO_SLOW;
     537             : 
     538             :         /* Log a message if a non-generic unusual_dev entry contains an
     539             :          * unnecessary subclass or protocol override.  This may stimulate
     540             :          * reports from users that will help us remove unneeded entries
     541             :          * from the unusual_devs.h table.
     542             :          */
     543           2 :         if (id->idVendor || id->idProduct) {
     544           3 :                 static const char *msgs[3] = {
     545             :                         "an unneeded SubClass entry",
     546             :                         "an unneeded Protocol entry",
     547             :                         "unneeded SubClass and Protocol entries"};
     548           1 :                 struct usb_device_descriptor *ddesc = &dev->descriptor;
     549           1 :                 int msg = -1;
     550             : 
     551           7 :                 if (unusual_dev->useProtocol != US_SC_DEVICE &&
     552             :                         us->subclass == idesc->bInterfaceSubClass)
     553           1 :                         msg += 1;
     554           7 :                 if (unusual_dev->useTransport != US_PR_DEVICE &&
     555             :                         us->protocol == idesc->bInterfaceProtocol)
     556           1 :                         msg += 2;
     557           4 :                 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
     558           8 :                         printk(KERN_NOTICE USB_STORAGE "This device "
     559             :                                 "(%04x,%04x,%04x S %02x P %02x)"
     560             :                                 " has %s in unusual_devs.h (kernel"
     561             :                                 " %s)\n"
     562             :                                 "   Please send a copy of this message to "
     563             :                                 "<linux-usb@vger.kernel.org> and "
     564             :                                 "<usb-storage@lists.one-eyed-alien.net>\n",
     565             :                                 le16_to_cpu(ddesc->idVendor),
     566             :                                 le16_to_cpu(ddesc->idProduct),
     567             :                                 le16_to_cpu(ddesc->bcdDevice),
     568             :                                 idesc->bInterfaceSubClass,
     569             :                                 idesc->bInterfaceProtocol,
     570             :                                 msgs[msg],
     571             :                                 utsname()->release);
     572             :         }
     573             : 
     574           2 :         return 0;
     575             : }
     576             : 
     577             : /* Get the transport settings */
     578             : static void get_transport(struct us_data *us)
     579             : {
     580           1 :         switch (us->protocol) {
     581           5 :         case US_PR_CB:
     582           1 :                 us->transport_name = "Control/Bulk";
     583           1 :                 us->transport = usb_stor_CB_transport;
     584           1 :                 us->transport_reset = usb_stor_CB_reset;
     585           1 :                 us->max_lun = 7;
     586           1 :                 break;
     587           1 : 
     588           4 :         case US_PR_CBI:
     589           1 :                 us->transport_name = "Control/Bulk/Interrupt";
     590           1 :                 us->transport = usb_stor_CB_transport;
     591           1 :                 us->transport_reset = usb_stor_CB_reset;
     592           1 :                 us->max_lun = 7;
     593           1 :                 break;
     594           1 : 
     595           4 :         case US_PR_BULK:
     596           1 :                 us->transport_name = "Bulk";
     597           1 :                 us->transport = usb_stor_Bulk_transport;
     598           1 :                 us->transport_reset = usb_stor_Bulk_reset;
     599           1 :                 break;
     600           1 :         }
     601             : }
     602           2 : 
     603             : /* Get the protocol settings */
     604             : static void get_protocol(struct us_data *us)
     605             : {
     606           1 :         switch (us->subclass) {
     607           5 :         case US_SC_RBC:
     608           1 :                 us->protocol_name = "Reduced Block Commands (RBC)";
     609           1 :                 us->proto_handler = usb_stor_transparent_scsi_command;
     610           1 :                 break;
     611           1 : 
     612           4 :         case US_SC_8020:
     613           1 :                 us->protocol_name = "8020i";
     614           1 :                 us->proto_handler = usb_stor_pad12_command;
     615           1 :                 us->max_lun = 0;
     616           1 :                 break;
     617           1 : 
     618           4 :         case US_SC_QIC:
     619           1 :                 us->protocol_name = "QIC-157";
     620           1 :                 us->proto_handler = usb_stor_pad12_command;
     621           1 :                 us->max_lun = 0;
     622           1 :                 break;
     623           1 : 
     624           4 :         case US_SC_8070:
     625           1 :                 us->protocol_name = "8070i";
     626           1 :                 us->proto_handler = usb_stor_pad12_command;
     627           1 :                 us->max_lun = 0;
     628           1 :                 break;
     629           1 : 
     630           4 :         case US_SC_SCSI:
     631           1 :                 us->protocol_name = "Transparent SCSI";
     632           1 :                 us->proto_handler = usb_stor_transparent_scsi_command;
     633           1 :                 break;
     634           1 : 
     635           4 :         case US_SC_UFI:
     636           1 :                 us->protocol_name = "Uniform Floppy Interface (UFI)";
     637           1 :                 us->proto_handler = usb_stor_ufi_command;
     638           1 :                 break;
     639           1 :         }
     640             : }
     641           2 : 
     642             : /* Get the pipe settings */
     643             : static int get_pipes(struct us_data *us)
     644             : {
     645           2 :         struct usb_host_interface *altsetting =
     646           1 :                 us->pusb_intf->cur_altsetting;
     647           1 :         int i;
     648           1 :         struct usb_endpoint_descriptor *ep;
     649           2 :         struct usb_endpoint_descriptor *ep_in = NULL;
     650           2 :         struct usb_endpoint_descriptor *ep_out = NULL;
     651           2 :         struct usb_endpoint_descriptor *ep_int = NULL;
     652           1 : 
     653           1 :         /*
     654           1 :          * Find the first endpoint of each type we need.
     655           1 :          * We are expecting a minimum of 2 endpoints - in and out (bulk).
     656           1 :          * An optional interrupt-in is OK (necessary for CBI protocol).
     657           1 :          * We will ignore any others.
     658           1 :          */
     659           7 :         for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
     660           5 :                 ep = &altsetting->endpoint[i].desc;
     661           2 : 
     662           4 :                 if (usb_endpoint_xfer_bulk(ep)) {
     663           4 :                         if (usb_endpoint_dir_in(ep)) {
     664           2 :                                 if (!ep_in)
     665           1 :                                         ep_in = ep;
     666             :                         } else {
     667           2 :                                 if (!ep_out)
     668           1 :                                         ep_out = ep;
     669             :                         }
     670             :                 }
     671             : 
     672           5 :                 else if (usb_endpoint_is_int_in(ep)) {
     673           2 :                         if (!ep_int)
     674           1 :                                 ep_int = ep;
     675             :                 }
     676             :         }
     677             : 
     678           9 :         if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) {
     679             :                 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
     680           1 :                 return -EIO;
     681             :         }
     682             : 
     683             :         /* Calculate and store the pipe values */
     684           3 :         us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
     685           3 :         us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
     686           5 :         us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
     687             :                 usb_endpoint_num(ep_out));
     688           5 :         us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, 
     689             :                 usb_endpoint_num(ep_in));
     690           2 :         if (ep_int) {
     691           5 :                 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
     692             :                         usb_endpoint_num(ep_int));
     693           1 :                 us->ep_bInterval = ep_int->bInterval;
     694             :         }
     695           2 :         return 0;
     696             : }
     697             : 
     698             : /* Initialize all the dynamic resources we need */
     699             : static int usb_stor_acquire_resources(struct us_data *us)
     700             : {
     701           1 :         int p;
     702           1 :         struct task_struct *th;
     703           1 : 
     704           2 :         us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
     705           4 :         if (!us->current_urb) {
     706           1 :                 US_DEBUGP("URB allocation failed\n");
     707           2 :                 return -ENOMEM;
     708             :         }
     709             : 
     710             :         /* Just before we start our control thread, initialize
     711             :          * the device if it needs initialization */
     712           3 :         if (us->unusual_dev->initFunction) {
     713          10 :                 p = us->unusual_dev->initFunction(us);
     714           2 :                 if (p)
     715           1 :                         return p;
     716             :         }
     717             : 
     718             :         /* Start up our control thread */
     719           8 :         th = kthread_run(usb_stor_control_thread, us, "usb-storage");
     720           4 :         if (IS_ERR(th)) {
     721           1 :                 printk(KERN_WARNING USB_STORAGE 
     722             :                        "Unable to start control thread\n");
     723           3 :                 return PTR_ERR(th);
     724             :         }
     725           1 :         us->ctl_thread = th;
     726             : 
     727           1 :         return 0;
     728             : }
     729             : 
     730             : /* Release all our dynamic resources */
     731             : static void usb_stor_release_resources(struct us_data *us)
     732             : {
     733             :         US_DEBUGP("-- %s\n", __func__);
     734             : 
     735             :         /* Tell the control thread to exit.  The SCSI host must
     736             :          * already have been removed and the DISCONNECTING flag set
     737             :          * so that we won't accept any more commands.
     738             :          */
     739             :         US_DEBUGP("-- sending exit command to thread\n");
     740          11 :         complete(&us->cmnd_ready);
     741          33 :         if (us->ctl_thread)
     742          11 :                 kthread_stop(us->ctl_thread);
     743             : 
     744             :         /* Call the destructor routine, if it exists */
     745          33 :         if (us->extra_destructor) {
     746             :                 US_DEBUGP("-- calling extra_destructor()\n");
     747          33 :                 us->extra_destructor(us->extra);
     748             :         }
     749             : 
     750             :         /* Free the extra data and the URB */
     751          22 :         kfree(us->extra);
     752          11 :         usb_free_urb(us->current_urb);
     753          11 : }
     754             : 
     755             : /* Dissociate from the USB device */
     756             : static void dissociate_dev(struct us_data *us)
     757             : {
     758             :         US_DEBUGP("-- %s\n", __func__);
     759             : 
     760             :         /* Free the device-related DMA-mapped buffers */
     761          33 :         if (us->cr)
     762          22 :                 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr,
     763             :                                 us->cr_dma);
     764          33 :         if (us->iobuf)
     765          22 :                 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf,
     766             :                                 us->iobuf_dma);
     767             : 
     768             :         /* Remove our private data from the interface */
     769          22 :         usb_set_intfdata(us->pusb_intf, NULL);
     770          11 : }
     771             : 
     772             : /* First stage of disconnect processing: stop SCSI scanning,
     773             :  * remove the host, and stop accepting new commands
     774             :  */
     775             : static void quiesce_and_remove_host(struct us_data *us)
     776             : {
     777          20 :         struct Scsi_Host *host = us_to_host(us);
     778           5 : 
     779             :         /* If the device is really gone, cut short reset delays */
     780          15 :         if (us->pusb_dev->state == USB_STATE_NOTATTACHED)
     781          10 :                 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
     782             : 
     783             :         /* Prevent SCSI-scanning (if it hasn't started yet)
     784             :          * and wait for the SCSI-scanning thread to stop.
     785             :          */
     786          20 :         set_bit(US_FLIDX_DONT_SCAN, &us->dflags);
     787           5 :         wake_up(&us->delay_wait);
     788           5 :         wait_for_completion(&us->scanning_done);
     789             : 
     790             :         /* Removing the host will perform an orderly shutdown: caches
     791             :          * synchronized, disks spun down, etc.
     792             :          */
     793          10 :         scsi_remove_host(host);
     794             : 
     795             :         /* Prevent any new commands from being accepted and cut short
     796             :          * reset delays.
     797             :          */
     798          10 :         scsi_lock(host);
     799          10 :         set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
     800          10 :         scsi_unlock(host);
     801           5 :         wake_up(&us->delay_wait);
     802           5 : }
     803             : 
     804             : /* Second stage of disconnect processing: deallocate all resources */
     805             : static void release_everything(struct us_data *us)
     806             : {
     807          33 :         usb_stor_release_resources(us);
     808          22 :         dissociate_dev(us);
     809             : 
     810             :         /* Drop our reference to the host; the SCSI core will free it
     811             :          * (and "us" along with it) when the refcount becomes 0. */
     812          33 :         scsi_host_put(us_to_host(us));
     813          11 : }
     814             : 
     815             : /* Thread to carry out delayed SCSI-device scanning */
     816             : static int usb_stor_scan_thread(void * __us)
     817             : {
     818           0 :         struct us_data *us = (struct us_data *)__us;
     819           0 : 
     820           0 :         dev_dbg(&us->pusb_intf->dev, "device found\n");
     821           0 : 
     822           0 :         set_freezable();
     823           0 :         /* Wait for the timeout to expire or for a disconnect */
     824           0 :         if (delay_use > 0) {
     825           0 :                 dev_dbg(&us->pusb_intf->dev, "waiting for device to settle "
     826           0 :                                 "before scanning\n");
     827           0 :                 wait_event_freezable_timeout(us->delay_wait,
     828           0 :                                 test_bit(US_FLIDX_DONT_SCAN, &us->dflags),
     829           0 :                                 delay_use * HZ);
     830             :         }
     831             : 
     832             :         /* If the device is still connected, perform the scanning */
     833           0 :         if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) {
     834             : 
     835             :                 /* For bulk-only devices, determine the max LUN value */
     836           0 :                 if (us->protocol == US_PR_BULK &&
     837             :                                 !(us->fflags & US_FL_SINGLE_LUN)) {
     838           0 :                         mutex_lock(&us->dev_mutex);
     839           0 :                         us->max_lun = usb_stor_Bulk_max_lun(us);
     840           0 :                         mutex_unlock(&us->dev_mutex);
     841             :                 }
     842           0 :                 scsi_scan_host(us_to_host(us));
     843             :                 dev_dbg(&us->pusb_intf->dev, "scan complete\n");
     844             : 
     845             :                 /* Should we unbind if no devices were detected? */
     846             :         }
     847             : 
     848           0 :         complete_and_exit(&us->scanning_done, 0);
     849           0 : }
     850             : 
     851             : static unsigned int usb_stor_sg_tablesize(struct usb_interface *intf)
     852             : {
     853           3 :         struct usb_device *usb_dev = interface_to_usbdev(intf);
     854           1 : 
     855           2 :         if (usb_dev->bus->sg_tablesize) {
     856           1 :                 return usb_dev->bus->sg_tablesize;
     857             :         }
     858           1 :         return SG_ALL;
     859             : }
     860             : 
     861             : /* First part of general USB mass-storage probing */
     862             : int usb_stor_probe1(struct us_data **pus,
     863             :                 struct usb_interface *intf,
     864             :                 const struct usb_device_id *id,
     865           1 :                 struct us_unusual_dev *unusual_dev)
     866           1 : {
     867           1 :         struct Scsi_Host *host;
     868           1 :         struct us_data *us;
     869           1 :         int result;
     870           1 : 
     871             :         US_DEBUGP("USB Mass Storage device detected\n");
     872             : 
     873             :         /*
     874             :          * Ask the SCSI layer to allocate a host structure, with extra
     875             :          * space at the end for our private us_data structure.
     876             :          */
     877           2 :         host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
     878           2 :         if (!host) {
     879           1 :                 printk(KERN_WARNING USB_STORAGE
     880             :                         "Unable to allocate the scsi host\n");
     881           1 :                 return -ENOMEM;
     882             :         }
     883             : 
     884             :         /*
     885             :          * Allow 16-byte CDBs and thus > 2TB
     886             :          */
     887           1 :         host->max_cmd_len = 16;
     888           3 :         host->sg_tablesize = usb_stor_sg_tablesize(intf);
     889           3 :         *pus = us = host_to_us(host);
     890           1 :         memset(us, 0, sizeof(struct us_data));
     891           1 :         mutex_init(&(us->dev_mutex));
     892           2 :         init_completion(&us->cmnd_ready);
     893           2 :         init_completion(&(us->notify));
     894           1 :         init_waitqueue_head(&us->delay_wait);
     895           2 :         init_completion(&us->scanning_done);
     896             : 
     897             :         /* Associate the us_data structure with the USB device */
     898           2 :         result = associate_dev(us, intf);
     899           2 :         if (result)
     900           1 :                 goto BadDevice;
     901             : 
     902             :         /* Get the unusual_devs entries and the descriptors */
     903           3 :         result = get_device_info(us, id, unusual_dev);
     904           2 :         if (result)
     905           1 :                 goto BadDevice;
     906             : 
     907             :         /* Get standard transport and protocol settings */
     908           2 :         get_transport(us);
     909           2 :         get_protocol(us);
     910             : 
     911             :         /* Give the caller a chance to fill in specialized transport
     912             :          * or protocol settings.
     913             :          */
     914           1 :         return 0;
     915           2 : 
     916             : BadDevice:
     917             :         US_DEBUGP("storage_probe() failed\n");
     918           4 :         release_everything(us);
     919           1 :         return result;
     920             : }
     921             : EXPORT_SYMBOL_GPL(usb_stor_probe1);
     922             : 
     923             : /* Second part of general USB mass-storage probing */
     924             : int usb_stor_probe2(struct us_data *us)
     925             : {
     926           1 :         struct task_struct *th;
     927           1 :         int result;
     928           1 : 
     929           1 :         /* Make sure the transport and protocol have both been set */
     930           7 :         if (!us->transport || !us->proto_handler) {
     931           2 :                 result = -ENXIO;
     932           1 :                 goto BadDevice;
     933             :         }
     934             :         US_DEBUGP("Transport: %s\n", us->transport_name);
     935             :         US_DEBUGP("Protocol: %s\n", us->protocol_name);
     936             : 
     937             :         /* fix for single-lun devices */
     938           3 :         if (us->fflags & US_FL_SINGLE_LUN)
     939           1 :                 us->max_lun = 0;
     940             : 
     941             :         /* Find the endpoints and calculate pipe values */
     942           4 :         result = get_pipes(us);
     943           2 :         if (result)
     944           1 :                 goto BadDevice;
     945             : 
     946             :         /* Acquire all the other resources and add the host */
     947           4 :         result = usb_stor_acquire_resources(us);
     948           2 :         if (result)
     949           1 :                 goto BadDevice;
     950           3 :         snprintf(us->scsi_name, sizeof(us->scsi_name), "usb-storage %s",
     951             :                                         dev_name(&us->pusb_intf->dev));
     952           4 :         result = scsi_add_host(us_to_host(us), &us->pusb_intf->dev);
     953           2 :         if (result) {
     954           1 :                 printk(KERN_WARNING USB_STORAGE
     955             :                         "Unable to add the scsi host\n");
     956           1 :                 goto BadDevice;
     957             :         }
     958             : 
     959             :         /* Start up the thread for delayed SCSI-device scanning */
     960           1 :         th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan");
     961           4 :         if (IS_ERR(th)) {
     962           1 :                 printk(KERN_WARNING USB_STORAGE 
     963             :                        "Unable to start the device-scanning thread\n");
     964           1 :                 complete(&us->scanning_done);
     965           2 :                 quiesce_and_remove_host(us);
     966           3 :                 result = PTR_ERR(th);
     967           1 :                 goto BadDevice;
     968             :         }
     969             : 
     970           1 :         wake_up_process(th);
     971             : 
     972           1 :         return 0;
     973           5 : 
     974             :         /* We come here if there are any problems */
     975             : BadDevice:
     976             :         US_DEBUGP("storage_probe() failed\n");
     977          10 :         release_everything(us);
     978           1 :         return result;
     979             : }
     980             : EXPORT_SYMBOL_GPL(usb_stor_probe2);
     981             : 
     982             : /* Handle a USB mass-storage disconnect */
     983             : void usb_stor_disconnect(struct usb_interface *intf)
     984             : {
     985          16 :         struct us_data *us = usb_get_intfdata(intf);
     986           4 : 
     987             :         US_DEBUGP("storage_disconnect() called\n");
     988           8 :         quiesce_and_remove_host(us);
     989           8 :         release_everything(us);
     990           4 : }
     991             : EXPORT_SYMBOL_GPL(usb_stor_disconnect);
     992             : 
     993             : /* The main probe routine for standard devices */
     994             : static int storage_probe(struct usb_interface *intf,
     995             :                          const struct usb_device_id *id)
     996           1 : {
     997           1 :         struct us_data *us;
     998           1 :         int result;
     999             : 
    1000             :         /*
    1001             :          * If libusual is configured, let it decide whether a standard
    1002             :          * device should be handled by usb-storage or by ub.
    1003             :          * If the device isn't standard (is handled by a subdriver
    1004             :          * module) then don't accept it.
    1005             :          */
    1006           4 :         if (usb_usual_check_type(id, USB_US_TYPE_STOR) ||
    1007             :                         usb_usual_ignore_device(intf))
    1008           1 :                 return -ENXIO;
    1009             : 
    1010             :         /*
    1011             :          * Call the general probe procedures.
    1012             :          *
    1013             :          * The unusual_dev_list array is parallel to the usb_storage_usb_ids
    1014             :          * table, so we use the index of the id entry to find the
    1015             :          * corresponding unusual_devs entry.
    1016             :          */
    1017           4 :         result = usb_stor_probe1(&us, intf, id,
    1018             :                         (id - usb_storage_usb_ids) + us_unusual_dev_list);
    1019           2 :         if (result)
    1020           1 :                 return result;
    1021             : 
    1022             :         /* No special transport or protocol settings in the main module */
    1023             : 
    1024           3 :         result = usb_stor_probe2(us);
    1025           1 :         return result;
    1026             : }
    1027             : 
    1028             : /***********************************************************************
    1029             :  * Initialization and registration
    1030             :  ***********************************************************************/
    1031             : 
    1032           1 : static struct usb_driver usb_storage_driver = {
    1033             :         .name =         "usb-storage",
    1034             :         .probe =        storage_probe,
    1035             :         .disconnect =   usb_stor_disconnect,
    1036             :         .suspend =      usb_stor_suspend,
    1037             :         .resume =       usb_stor_resume,
    1038             :         .reset_resume = usb_stor_reset_resume,
    1039             :         .pre_reset =    usb_stor_pre_reset,
    1040             :         .post_reset =   usb_stor_post_reset,
    1041             :         .id_table =     usb_storage_usb_ids,
    1042             :         .soft_unbind =  1,
    1043             : };
    1044             : 
    1045             : static int __init usb_stor_init(void)
    1046             : {
    1047           1 :         int retval;
    1048             : 
    1049           1 :         printk(KERN_INFO "Initializing USB Mass Storage driver...\n");
    1050             : 
    1051             :         /* register the driver, return usb_register return code if error */
    1052           2 :         retval = usb_register(&usb_storage_driver);
    1053           2 :         if (retval == 0) {
    1054           1 :                 printk(KERN_INFO "USB Mass Storage support registered.\n");
    1055             :                 usb_usual_set_present(USB_US_TYPE_STOR);
    1056             :         }
    1057           1 :         return retval;
    1058             : }
    1059             : 
    1060             : static void __exit usb_stor_exit(void)
    1061             : {
    1062             :         US_DEBUGP("usb_stor_exit() called\n");
    1063             : 
    1064             :         /* Deregister the driver
    1065             :          * This will cause disconnect() to be called for each
    1066             :          * attached unit
    1067             :          */
    1068             :         US_DEBUGP("-- calling usb_deregister()\n");
    1069           4 :         usb_deregister(&usb_storage_driver) ;
    1070           2 : 
    1071             :         usb_usual_clear_present(USB_US_TYPE_STOR);
    1072             : }
    1073             : 
    1074             : module_init(usb_stor_init);
    1075             : module_exit(usb_stor_exit);

Generated by: LCOV version 1.10