drivers/usb/storage/usb.c

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