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