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