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