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