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