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