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 | US_FL_WRITE_CACHE);
 477
 478         p = quirks;
 479         while (*p) {
 480                 /* Each entry consists of VID:PID:flags */
 481                 if (vid == simple_strtoul(p, &p, 16) &&
 482                                 *p == ':' &&
 483                                 pid == simple_strtoul(p+1, &p, 16) &&
 484                                 *p == ':')
 485                         break;
 486
 487                 /* Move forward to the next entry */
 488                 while (*p) {
 489                         if (*p++ == ',')
 490                                 break;
 491                 }
 492         }
 493         if (!*p)        /* No match */
 494                 return;
 495
 496         /* Collect the flags */
 497         while (*++p && *p != ',') {
 498                 switch (TOLOWER(*p)) {
 499                 case 'a':
 500                         f |= US_FL_SANE_SENSE;
 501                         break;
 502                 case 'b':
 503                         f |= US_FL_BAD_SENSE;
 504                         break;
 505                 case 'c':
 506                         f |= US_FL_FIX_CAPACITY;
 507                         break;
 508                 case 'd':
 509                         f |= US_FL_NO_READ_DISC_INFO;
 510                         break;
 511                 case 'e':
 512                         f |= US_FL_NO_READ_CAPACITY_16;
 513                         break;
 514                 case 'h':
 515                         f |= US_FL_CAPACITY_HEURISTICS;
 516                         break;
 517                 case 'i':
 518                         f |= US_FL_IGNORE_DEVICE;
 519                         break;
 520                 case 'l':
 521                         f |= US_FL_NOT_LOCKABLE;
 522                         break;
 523                 case 'm':
 524                         f |= US_FL_MAX_SECTORS_64;
 525                         break;
 526                 case 'n':
 527                         f |= US_FL_INITIAL_READ10;
 528                         break;
 529                 case 'o':
 530                         f |= US_FL_CAPACITY_OK;
 531                         break;
 532                 case 'p':
 533                         f |= US_FL_WRITE_CACHE;
 534                         break;
 535                 case 'r':
 536                         f |= US_FL_IGNORE_RESIDUE;
 537                         break;
 538                 case 's':
 539                         f |= US_FL_SINGLE_LUN;
 540                         break;
 541                 case 'w':
 542                         f |= US_FL_NO_WP_DETECT;
 543                         break;
 544                 /* Ignore unrecognized flag characters */
 545                 }
 546         }
 547         us->fflags = (us->fflags & ~mask) | f;
 548 }
 549
 550 /* Get the unusual_devs entries and the string descriptors */
 551 static int get_device_info(struct us_data *us, const struct usb_device_id *id,
 552                 struct us_unusual_dev *unusual_dev)
 553 {
 554         struct usb_device *dev = us->pusb_dev;
 555         struct usb_interface_descriptor *idesc =
 556                 &us->pusb_intf->cur_altsetting->desc;
 557         struct device *pdev = &us->pusb_intf->dev;
 558
 559         /* Store the entries */
 560         us->unusual_dev = unusual_dev;
 561         us->subclass = (unusual_dev->useProtocol == USB_SC_DEVICE) ?
 562                         idesc->bInterfaceSubClass :
 563                         unusual_dev->useProtocol;
 564         us->protocol = (unusual_dev->useTransport == USB_PR_DEVICE) ?
 565                         idesc->bInterfaceProtocol :
 566                         unusual_dev->useTransport;
 567         us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
 568         adjust_quirks(us);
 569
 570         if (us->fflags & US_FL_IGNORE_DEVICE) {
 571                 dev_info(pdev, "device ignored\n");
 572                 return -ENODEV;
 573         }
 574
 575         /*
 576          * This flag is only needed when we're in high-speed, so let's
 577          * disable it if we're in full-speed
 578          */
 579         if (dev->speed != USB_SPEED_HIGH)
 580                 us->fflags &= ~US_FL_GO_SLOW;
 581
 582         if (us->fflags)
 583                 dev_info(pdev, "Quirks match for vid %04x pid %04x: %lx\n",
 584                                 le16_to_cpu(dev->descriptor.idVendor),
 585                                 le16_to_cpu(dev->descriptor.idProduct),
 586                                 us->fflags);
 587
 588         /* Log a message if a non-generic unusual_dev entry contains an
 589          * unnecessary subclass or protocol override.  This may stimulate
 590          * reports from users that will help us remove unneeded entries
 591          * from the unusual_devs.h table.
 592          */
 593         if (id->idVendor || id->idProduct) {
 594                 static const char *msgs[3] = {
 595                         "an unneeded SubClass entry",
 596                         "an unneeded Protocol entry",
 597                         "unneeded SubClass and Protocol entries"};
 598                 struct usb_device_descriptor *ddesc = &dev->descriptor;
 599                 int msg = -1;
 600
 601                 if (unusual_dev->useProtocol != USB_SC_DEVICE &&
 602                         us->subclass == idesc->bInterfaceSubClass)
 603                         msg += 1;
 604                 if (unusual_dev->useTransport != USB_PR_DEVICE &&
 605                         us->protocol == idesc->bInterfaceProtocol)
 606                         msg += 2;
 607                 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
 608                         dev_notice(pdev, "This device "
 609                                         "(%04x,%04x,%04x S %02x P %02x)"
 610                                         " has %s in unusual_devs.h (kernel"
 611                                         " %s)\n"
 612                                         "   Please send a copy of this message to "
 613                                         "<linux-usb@vger.kernel.org> and "
 614                                         "<usb-storage@lists.one-eyed-alien.net>\n",
 615                                         le16_to_cpu(ddesc->idVendor),
 616                                         le16_to_cpu(ddesc->idProduct),
 617                                         le16_to_cpu(ddesc->bcdDevice),
 618                                         idesc->bInterfaceSubClass,
 619                                         idesc->bInterfaceProtocol,
 620                                         msgs[msg],
 621                                         utsname()->release);
 622         }
 623
 624         return 0;
 625 }
 626
 627 /* Get the transport settings */
 628 static void get_transport(struct us_data *us)
 629 {
 630         switch (us->protocol) {
 631         case USB_PR_CB:
 632                 us->transport_name = "Control/Bulk";
 633                 us->transport = usb_stor_CB_transport;
 634                 us->transport_reset = usb_stor_CB_reset;
 635                 us->max_lun = 7;
 636                 break;
 637
 638         case USB_PR_CBI:
 639                 us->transport_name = "Control/Bulk/Interrupt";
 640                 us->transport = usb_stor_CB_transport;
 641                 us->transport_reset = usb_stor_CB_reset;
 642                 us->max_lun = 7;
 643                 break;
 644
 645         case USB_PR_BULK:
 646                 us->transport_name = "Bulk";
 647                 us->transport = usb_stor_Bulk_transport;
 648                 us->transport_reset = usb_stor_Bulk_reset;
 649                 break;
 650         }
 651 }
 652
 653 /* Get the protocol settings */
 654 static void get_protocol(struct us_data *us)
 655 {
 656         switch (us->subclass) {
 657         case USB_SC_RBC:
 658                 us->protocol_name = "Reduced Block Commands (RBC)";
 659                 us->proto_handler = usb_stor_transparent_scsi_command;
 660                 break;
 661
 662         case USB_SC_8020:
 663                 us->protocol_name = "8020i";
 664                 us->proto_handler = usb_stor_pad12_command;
 665                 us->max_lun = 0;
 666                 break;
 667
 668         case USB_SC_QIC:
 669                 us->protocol_name = "QIC-157";
 670                 us->proto_handler = usb_stor_pad12_command;
 671                 us->max_lun = 0;
 672                 break;
 673
 674         case USB_SC_8070:
 675                 us->protocol_name = "8070i";
 676                 us->proto_handler = usb_stor_pad12_command;
 677                 us->max_lun = 0;
 678                 break;
 679
 680         case USB_SC_SCSI:
 681                 us->protocol_name = "Transparent SCSI";
 682                 us->proto_handler = usb_stor_transparent_scsi_command;
 683                 break;
 684
 685         case USB_SC_UFI:
 686                 us->protocol_name = "Uniform Floppy Interface (UFI)";
 687                 us->proto_handler = usb_stor_ufi_command;
 688                 break;
 689         }
 690 }
 691
 692 /* Get the pipe settings */
 693 static int get_pipes(struct us_data *us)
 694 {
 695         struct usb_host_interface *altsetting =
 696                 us->pusb_intf->cur_altsetting;
 697         int i;
 698         struct usb_endpoint_descriptor *ep;
 699         struct usb_endpoint_descriptor *ep_in = NULL;
 700         struct usb_endpoint_descriptor *ep_out = NULL;
 701         struct usb_endpoint_descriptor *ep_int = NULL;
 702
 703         /*
 704          * Find the first endpoint of each type we need.
 705          * We are expecting a minimum of 2 endpoints - in and out (bulk).
 706          * An optional interrupt-in is OK (necessary for CBI protocol).
 707          * We will ignore any others.
 708          */
 709         for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
 710                 ep = &altsetting->endpoint[i].desc;
 711
 712                 if (usb_endpoint_xfer_bulk(ep)) {
 713                         if (usb_endpoint_dir_in(ep)) {
 714                                 if (!ep_in)
 715                                         ep_in = ep;
 716                         } else {
 717                                 if (!ep_out)
 718                                         ep_out = ep;
 719                         }
 720                 }
 721
 722                 else if (usb_endpoint_is_int_in(ep)) {
 723                         if (!ep_int)
 724                                 ep_int = ep;
 725                 }
 726         }
 727
 728         if (!ep_in || !ep_out || (us->protocol == USB_PR_CBI && !ep_int)) {
 729                 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
 730                 return -EIO;
 731         }
 732
 733         /* Calculate and store the pipe values */
 734         us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
 735         us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
 736         us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
 737                 usb_endpoint_num(ep_out));
 738         us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
 739                 usb_endpoint_num(ep_in));
 740         if (ep_int) {
 741                 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
 742                         usb_endpoint_num(ep_int));
 743                 us->ep_bInterval = ep_int->bInterval;
 744         }
 745         return 0;
 746 }
 747
 748 /* Initialize all the dynamic resources we need */
 749 static int usb_stor_acquire_resources(struct us_data *us)
 750 {
 751         int p;
 752         struct task_struct *th;
 753
 754         us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
 755         if (!us->current_urb) {
 756                 US_DEBUGP("URB allocation failed\n");
 757                 return -ENOMEM;
 758         }
 759
 760         /* Just before we start our control thread, initialize
 761          * the device if it needs initialization */
 762         if (us->unusual_dev->initFunction) {
 763                 p = us->unusual_dev->initFunction(us);
 764                 if (p)
 765                         return p;
 766         }
 767
 768         /* Start up our control thread */
 769         th = kthread_run(usb_stor_control_thread, us, "usb-storage");
 770         if (IS_ERR(th)) {
 771                 dev_warn(&us->pusb_intf->dev,
 772                                 "Unable to start control thread\n");
 773                 return PTR_ERR(th);
 774         }
 775         us->ctl_thread = th;
 776
 777         return 0;
 778 }
 779
 780 /* Release all our dynamic resources */
 781 static void usb_stor_release_resources(struct us_data *us)
 782 {
 783         US_DEBUGP("-- %s\n", __func__);
 784
 785         /* Tell the control thread to exit.  The SCSI host must
 786          * already have been removed and the DISCONNECTING flag set
 787          * so that we won't accept any more commands.
 788          */
 789         US_DEBUGP("-- sending exit command to thread\n");
 790         complete(&us->cmnd_ready);
 791         if (us->ctl_thread)
 792                 kthread_stop(us->ctl_thread);
 793
 794         /* Call the destructor routine, if it exists */
 795         if (us->extra_destructor) {
 796                 US_DEBUGP("-- calling extra_destructor()\n");
 797                 us->extra_destructor(us->extra);
 798         }
 799
 800         /* Free the extra data and the URB */
 801         kfree(us->extra);
 802         usb_free_urb(us->current_urb);
 803 }
 804
 805 /* Dissociate from the USB device */
 806 static void dissociate_dev(struct us_data *us)
 807 {
 808         US_DEBUGP("-- %s\n", __func__);
 809
 810         /* Free the buffers */
 811         kfree(us->cr);
 812         usb_free_coherent(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma);
 813
 814         /* Remove our private data from the interface */
 815         usb_set_intfdata(us->pusb_intf, NULL);
 816 }
 817
 818 /* First stage of disconnect processing: stop SCSI scanning,
 819  * remove the host, and stop accepting new commands
 820  */
 821 static void quiesce_and_remove_host(struct us_data *us)
 822 {
 823         struct Scsi_Host *host = us_to_host(us);
 824
 825         /* If the device is really gone, cut short reset delays */
 826         if (us->pusb_dev->state == USB_STATE_NOTATTACHED) {
 827                 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
 828                 wake_up(&us->delay_wait);
 829         }
 830
 831         /* Prevent SCSI scanning (if it hasn't started yet)
 832          * or wait for the SCSI-scanning routine to stop.
 833          */
 834         cancel_delayed_work_sync(&us->scan_dwork);
 835
 836         /* Balance autopm calls if scanning was cancelled */
 837         if (test_bit(US_FLIDX_SCAN_PENDING, &us->dflags))
 838                 usb_autopm_put_interface_no_suspend(us->pusb_intf);
 839
 840         /* Removing the host will perform an orderly shutdown: caches
 841          * synchronized, disks spun down, etc.
 842          */
 843         scsi_remove_host(host);
 844
 845         /* Prevent any new commands from being accepted and cut short
 846          * reset delays.
 847          */
 848         scsi_lock(host);
 849         set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
 850         scsi_unlock(host);
 851         wake_up(&us->delay_wait);
 852 }
 853
 854 /* Second stage of disconnect processing: deallocate all resources */
 855 static void release_everything(struct us_data *us)
 856 {
 857         usb_stor_release_resources(us);
 858         dissociate_dev(us);
 859
 860         /* Drop our reference to the host; the SCSI core will free it
 861          * (and "us" along with it) when the refcount becomes 0. */
 862         scsi_host_put(us_to_host(us));
 863 }
 864
 865 /* Delayed-work routine to carry out SCSI-device scanning */
 866 static void usb_stor_scan_dwork(struct work_struct *work)
 867 {
 868         struct us_data *us = container_of(work, struct us_data,
 869                         scan_dwork.work);
 870         struct device *dev = &us->pusb_intf->dev;
 871
 872         dev_dbg(dev, "starting scan\n");
 873
 874         /* For bulk-only devices, determine the max LUN value */
 875         if (us->protocol == USB_PR_BULK && !(us->fflags & US_FL_SINGLE_LUN)) {
 876                 mutex_lock(&us->dev_mutex);
 877                 us->max_lun = usb_stor_Bulk_max_lun(us);
 878                 mutex_unlock(&us->dev_mutex);
 879         }
 880         scsi_scan_host(us_to_host(us));
 881         dev_dbg(dev, "scan complete\n");
 882
 883         /* Should we unbind if no devices were detected? */
 884
 885         usb_autopm_put_interface(us->pusb_intf);
 886         clear_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
 887 }
 888
 889 static unsigned int usb_stor_sg_tablesize(struct usb_interface *intf)
 890 {
 891         struct usb_device *usb_dev = interface_to_usbdev(intf);
 892
 893         if (usb_dev->bus->sg_tablesize) {
 894                 return usb_dev->bus->sg_tablesize;
 895         }
 896         return SG_ALL;
 897 }
 898
 899 /* First part of general USB mass-storage probing */
 900 int usb_stor_probe1(struct us_data **pus,
 901                 struct usb_interface *intf,
 902                 const struct usb_device_id *id,
 903                 struct us_unusual_dev *unusual_dev)
 904 {
 905         struct Scsi_Host *host;
 906         struct us_data *us;
 907         int result;
 908
 909         US_DEBUGP("USB Mass Storage device detected\n");
 910
 911         /*
 912          * Ask the SCSI layer to allocate a host structure, with extra
 913          * space at the end for our private us_data structure.
 914          */
 915         host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
 916         if (!host) {
 917                 dev_warn(&intf->dev,
 918                                 "Unable to allocate the scsi host\n");
 919                 return -ENOMEM;
 920         }
 921
 922         /*
 923          * Allow 16-byte CDBs and thus > 2TB
 924          */
 925         host->max_cmd_len = 16;
 926         host->sg_tablesize = usb_stor_sg_tablesize(intf);
 927         *pus = us = host_to_us(host);
 928         memset(us, 0, sizeof(struct us_data));
 929         mutex_init(&(us->dev_mutex));
 930         us_set_lock_class(&us->dev_mutex, intf);
 931         init_completion(&us->cmnd_ready);
 932         init_completion(&(us->notify));
 933         init_waitqueue_head(&us->delay_wait);
 934         INIT_DELAYED_WORK(&us->scan_dwork, usb_stor_scan_dwork);
 935
 936         /* Associate the us_data structure with the USB device */
 937         result = associate_dev(us, intf);
 938         if (result)
 939                 goto BadDevice;
 940
 941         /* Get the unusual_devs entries and the descriptors */
 942         result = get_device_info(us, id, unusual_dev);
 943         if (result)
 944                 goto BadDevice;
 945
 946         /* Get standard transport and protocol settings */
 947         get_transport(us);
 948         get_protocol(us);
 949
 950         /* Give the caller a chance to fill in specialized transport
 951          * or protocol settings.
 952          */
 953         return 0;
 954
 955 BadDevice:
 956         US_DEBUGP("storage_probe() failed\n");
 957         release_everything(us);
 958         return result;
 959 }
 960 EXPORT_SYMBOL_GPL(usb_stor_probe1);
 961
 962 /* Second part of general USB mass-storage probing */
 963 int usb_stor_probe2(struct us_data *us)
 964 {
 965         int result;
 966         struct device *dev = &us->pusb_intf->dev;
 967
 968         /* Make sure the transport and protocol have both been set */
 969         if (!us->transport || !us->proto_handler) {
 970                 result = -ENXIO;
 971                 goto BadDevice;
 972         }
 973         US_DEBUGP("Transport: %s\n", us->transport_name);
 974         US_DEBUGP("Protocol: %s\n", us->protocol_name);
 975
 976         /* fix for single-lun devices */
 977         if (us->fflags & US_FL_SINGLE_LUN)
 978                 us->max_lun = 0;
 979
 980         /* Find the endpoints and calculate pipe values */
 981         result = get_pipes(us);
 982         if (result)
 983                 goto BadDevice;
 984
 985         /*
 986          * If the device returns invalid data for the first READ(10)
 987          * command, indicate the command should be retried.
 988          */
 989         if (us->fflags & US_FL_INITIAL_READ10)
 990                 set_bit(US_FLIDX_REDO_READ10, &us->dflags);
 991
 992         /* Acquire all the other resources and add the host */
 993         result = usb_stor_acquire_resources(us);
 994         if (result)
 995                 goto BadDevice;
 996         snprintf(us->scsi_name, sizeof(us->scsi_name), "usb-storage %s",
 997                                         dev_name(&us->pusb_intf->dev));
 998         result = scsi_add_host(us_to_host(us), dev);
 999         if (result) {
1000                 dev_warn(dev,
1001                                 "Unable to add the scsi host\n");
1002                 goto BadDevice;
1003         }
1004
1005         /* Submit the delayed_work for SCSI-device scanning */
1006         usb_autopm_get_interface_no_resume(us->pusb_intf);
1007         set_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
1008
1009         if (delay_use > 0)
1010                 dev_dbg(dev, "waiting for device to settle before scanning\n");
1011         queue_delayed_work(system_freezable_wq, &us->scan_dwork,
1012                         delay_use * HZ);
1013         return 0;
1014
1015         /* We come here if there are any problems */
1016 BadDevice:
1017         US_DEBUGP("storage_probe() failed\n");
1018         release_everything(us);
1019         return result;
1020 }
1021 EXPORT_SYMBOL_GPL(usb_stor_probe2);
1022
1023 /* Handle a USB mass-storage disconnect */
1024 void usb_stor_disconnect(struct usb_interface *intf)
1025 {
1026         struct us_data *us = usb_get_intfdata(intf);
1027
1028         US_DEBUGP("storage_disconnect() called\n");
1029         quiesce_and_remove_host(us);
1030         release_everything(us);
1031 }
1032 EXPORT_SYMBOL_GPL(usb_stor_disconnect);
1033
1034 /* The main probe routine for standard devices */
1035 static int storage_probe(struct usb_interface *intf,
1036                          const struct usb_device_id *id)
1037 {
1038         struct us_unusual_dev *unusual_dev;
1039         struct us_data *us;
1040         int result;
1041         int size;
1042
1043         /*
1044          * If libusual is configured, let it decide whether a standard
1045          * device should be handled by usb-storage or by ub.
1046          * If the device isn't standard (is handled by a subdriver
1047          * module) then don't accept it.
1048          */
1049         if (usb_usual_check_type(id, USB_US_TYPE_STOR) ||
1050                         usb_usual_ignore_device(intf))
1051                 return -ENXIO;
1052
1053         /*
1054          * Call the general probe procedures.
1055          *
1056          * The unusual_dev_list array is parallel to the usb_storage_usb_ids
1057          * table, so we use the index of the id entry to find the
1058          * corresponding unusual_devs entry.
1059          */
1060
1061         size = ARRAY_SIZE(us_unusual_dev_list);
1062         if (id >= usb_storage_usb_ids && id < usb_storage_usb_ids + size) {
1063                 unusual_dev = (id - usb_storage_usb_ids) + us_unusual_dev_list;
1064         } else {
1065                 unusual_dev = &for_dynamic_ids;
1066
1067                 US_DEBUGP("%s %s 0x%04x 0x%04x\n", "Use Bulk-Only transport",
1068                         "with the Transparent SCSI protocol for dynamic id:",
1069                         id->idVendor, id->idProduct);
1070         }
1071
1072         result = usb_stor_probe1(&us, intf, id, unusual_dev);
1073         if (result)
1074                 return result;
1075
1076         /* No special transport or protocol settings in the main module */
1077
1078         result = usb_stor_probe2(us);
1079         return result;
1080 }
1081
1082 /***********************************************************************
1083  * Initialization and registration
1084  ***********************************************************************/
1085
1086 static struct usb_driver usb_storage_driver = {
1087         .name =         "usb-storage",
1088         .probe =        storage_probe,
1089         .disconnect =   usb_stor_disconnect,
1090         .suspend =      usb_stor_suspend,
1091         .resume =       usb_stor_resume,
1092         .reset_resume = usb_stor_reset_resume,
1093         .pre_reset =    usb_stor_pre_reset,
1094         .post_reset =   usb_stor_post_reset,
1095         .id_table =     usb_storage_usb_ids,
1096         .supports_autosuspend = 1,
1097         .soft_unbind =  1,
1098 };
1099
1100 static int __init usb_stor_init(void)
1101 {
1102         int retval;
1103
1104         pr_info("Initializing USB Mass Storage driver...\n");
1105
1106         /* register the driver, return usb_register return code if error */
1107         retval = usb_register(&usb_storage_driver);
1108         if (retval == 0) {
1109                 pr_info("USB Mass Storage support registered.\n");
1110                 usb_usual_set_present(USB_US_TYPE_STOR);
1111         }
1112         return retval;
1113 }
1114
1115 static void __exit usb_stor_exit(void)
1116 {
1117         US_DEBUGP("usb_stor_exit() called\n");
1118
1119         /* Deregister the driver
1120          * This will cause disconnect() to be called for each
1121          * attached unit
1122          */
1123         US_DEBUGP("-- calling usb_deregister()\n");
1124         usb_deregister(&usb_storage_driver) ;
1125
1126         usb_usual_clear_present(USB_US_TYPE_STOR);
1127 }
1128
1129 module_init(usb_stor_init);
1130 module_exit(usb_stor_exit);