drivers/usb/storage/usb.c

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