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