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
 478         us->sensebuf = kmalloc(US_SENSE_SIZE, GFP_KERNEL);
 479         if (!us->sensebuf) {
 480                 US_DEBUGP("Sense buffer allocation failed\n");
 481                 return -ENOMEM;
 482         }
 483         return 0;
 484 }
 485
 486 /* Adjust device flags based on the "quirks=" module parameter */
 487 static void adjust_quirks(struct us_data *us)
 488 {
 489         u16 vid, pid;
 490         struct quirks_entry *q;
 491         unsigned int mask = (US_FL_FIX_CAPACITY | US_FL_IGNORE_DEVICE |
 492                         US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
 493                         US_FL_IGNORE_RESIDUE | US_FL_SINGLE_LUN |
 494                         US_FL_NO_WP_DETECT);
 495
 496         vid = le16_to_cpu(us->pusb_dev->descriptor.idVendor);
 497         pid = le16_to_cpu(us->pusb_dev->descriptor.idProduct);
 498
 499         for (q = quirks_list; q != quirks_end; ++q) {
 500                 if (q->vid == vid && q->pid == pid) {
 501                         us->fflags = (us->fflags & ~mask) | q->fflags;
 502                         dev_info(&us->pusb_intf->dev, "Quirks match for "
 503                                         "vid %04x pid %04x: %x\n",
 504                                         vid, pid, q->fflags);
 505                         break;
 506                 }
 507         }
 508 }
 509
 510 /* Find an unusual_dev descriptor (always succeeds in the current code) */
 511 static struct us_unusual_dev *find_unusual(const struct usb_device_id *id)
 512 {
 513         const int id_index = id - storage_usb_ids;
 514         return &us_unusual_dev_list[id_index];
 515 }
 516
 517 /* Get the unusual_devs entries and the string descriptors */
 518 static int get_device_info(struct us_data *us, const struct usb_device_id *id)
 519 {
 520         struct usb_device *dev = us->pusb_dev;
 521         struct usb_interface_descriptor *idesc =
 522                 &us->pusb_intf->cur_altsetting->desc;
 523         struct us_unusual_dev *unusual_dev = find_unusual(id);
 524
 525         /* Store the entries */
 526         us->unusual_dev = unusual_dev;
 527         us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ?
 528                         idesc->bInterfaceSubClass :
 529                         unusual_dev->useProtocol;
 530         us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ?
 531                         idesc->bInterfaceProtocol :
 532                         unusual_dev->useTransport;
 533         us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
 534         adjust_quirks(us);
 535
 536         if (us->fflags & US_FL_IGNORE_DEVICE) {
 537                 printk(KERN_INFO USB_STORAGE "device ignored\n");
 538                 return -ENODEV;
 539         }
 540
 541         /*
 542          * This flag is only needed when we're in high-speed, so let's
 543          * disable it if we're in full-speed
 544          */
 545         if (dev->speed != USB_SPEED_HIGH)
 546                 us->fflags &= ~US_FL_GO_SLOW;
 547
 548         /* Log a message if a non-generic unusual_dev entry contains an
 549          * unnecessary subclass or protocol override.  This may stimulate
 550          * reports from users that will help us remove unneeded entries
 551          * from the unusual_devs.h table.
 552          */
 553         if (id->idVendor || id->idProduct) {
 554                 static const char *msgs[3] = {
 555                         "an unneeded SubClass entry",
 556                         "an unneeded Protocol entry",
 557                         "unneeded SubClass and Protocol entries"};
 558                 struct usb_device_descriptor *ddesc = &dev->descriptor;
 559                 int msg = -1;
 560
 561                 if (unusual_dev->useProtocol != US_SC_DEVICE &&
 562                         us->subclass == idesc->bInterfaceSubClass)
 563                         msg += 1;
 564                 if (unusual_dev->useTransport != US_PR_DEVICE &&
 565                         us->protocol == idesc->bInterfaceProtocol)
 566                         msg += 2;
 567                 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
 568                         printk(KERN_NOTICE USB_STORAGE "This device "
 569                                 "(%04x,%04x,%04x S %02x P %02x)"
 570                                 " has %s in unusual_devs.h (kernel"
 571                                 " %s)\n"
 572                                 "   Please send a copy of this message to "
 573                                 "<linux-usb@vger.kernel.org> and "
 574                                 "<usb-storage@lists.one-eyed-alien.net>\n",
 575                                 le16_to_cpu(ddesc->idVendor),
 576                                 le16_to_cpu(ddesc->idProduct),
 577                                 le16_to_cpu(ddesc->bcdDevice),
 578                                 idesc->bInterfaceSubClass,
 579                                 idesc->bInterfaceProtocol,
 580                                 msgs[msg],
 581                                 utsname()->release);
 582         }
 583
 584         return 0;
 585 }
 586
 587 /* Get the transport settings */
 588 static int get_transport(struct us_data *us)
 589 {
 590         switch (us->protocol) {
 591         case US_PR_CB:
 592                 us->transport_name = "Control/Bulk";
 593                 us->transport = usb_stor_CB_transport;
 594                 us->transport_reset = usb_stor_CB_reset;
 595                 us->max_lun = 7;
 596                 break;
 597
 598         case US_PR_CBI:
 599                 us->transport_name = "Control/Bulk/Interrupt";
 600                 us->transport = usb_stor_CBI_transport;
 601                 us->transport_reset = usb_stor_CB_reset;
 602                 us->max_lun = 7;
 603                 break;
 604
 605         case US_PR_BULK:
 606                 us->transport_name = "Bulk";
 607                 us->transport = usb_stor_Bulk_transport;
 608                 us->transport_reset = usb_stor_Bulk_reset;
 609                 break;
 610
 611 #ifdef CONFIG_USB_STORAGE_USBAT
 612         case US_PR_USBAT:
 613                 us->transport_name = "Shuttle USBAT";
 614                 us->transport = usbat_transport;
 615                 us->transport_reset = usb_stor_CB_reset;
 616                 us->max_lun = 1;
 617                 break;
 618 #endif
 619
 620 #ifdef CONFIG_USB_STORAGE_SDDR09
 621         case US_PR_EUSB_SDDR09:
 622                 us->transport_name = "EUSB/SDDR09";
 623                 us->transport = sddr09_transport;
 624                 us->transport_reset = usb_stor_CB_reset;
 625                 us->max_lun = 0;
 626                 break;
 627 #endif
 628
 629 #ifdef CONFIG_USB_STORAGE_SDDR55
 630         case US_PR_SDDR55:
 631                 us->transport_name = "SDDR55";
 632                 us->transport = sddr55_transport;
 633                 us->transport_reset = sddr55_reset;
 634                 us->max_lun = 0;
 635                 break;
 636 #endif
 637
 638 #ifdef CONFIG_USB_STORAGE_DPCM
 639         case US_PR_DPCM_USB:
 640                 us->transport_name = "Control/Bulk-EUSB/SDDR09";
 641                 us->transport = dpcm_transport;
 642                 us->transport_reset = usb_stor_CB_reset;
 643                 us->max_lun = 1;
 644                 break;
 645 #endif
 646
 647 #ifdef CONFIG_USB_STORAGE_FREECOM
 648         case US_PR_FREECOM:
 649                 us->transport_name = "Freecom";
 650                 us->transport = freecom_transport;
 651                 us->transport_reset = usb_stor_freecom_reset;
 652                 us->max_lun = 0;
 653                 break;
 654 #endif
 655
 656 #ifdef CONFIG_USB_STORAGE_DATAFAB
 657         case US_PR_DATAFAB:
 658                 us->transport_name  = "Datafab Bulk-Only";
 659                 us->transport = datafab_transport;
 660                 us->transport_reset = usb_stor_Bulk_reset;
 661                 us->max_lun = 1;
 662                 break;
 663 #endif
 664
 665 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
 666         case US_PR_JUMPSHOT:
 667                 us->transport_name  = "Lexar Jumpshot Control/Bulk";
 668                 us->transport = jumpshot_transport;
 669                 us->transport_reset = usb_stor_Bulk_reset;
 670                 us->max_lun = 1;
 671                 break;
 672 #endif
 673
 674 #ifdef CONFIG_USB_STORAGE_ALAUDA
 675         case US_PR_ALAUDA:
 676                 us->transport_name  = "Alauda Control/Bulk";
 677                 us->transport = alauda_transport;
 678                 us->transport_reset = usb_stor_Bulk_reset;
 679                 us->max_lun = 1;
 680                 break;
 681 #endif
 682
 683 #ifdef CONFIG_USB_STORAGE_KARMA
 684         case US_PR_KARMA:
 685                 us->transport_name = "Rio Karma/Bulk";
 686                 us->transport = rio_karma_transport;
 687                 us->transport_reset = usb_stor_Bulk_reset;
 688                 break;
 689 #endif
 690
 691         default:
 692                 return -EIO;
 693         }
 694         US_DEBUGP("Transport: %s\n", us->transport_name);
 695
 696         /* fix for single-lun devices */
 697         if (us->fflags & US_FL_SINGLE_LUN)
 698                 us->max_lun = 0;
 699         return 0;
 700 }
 701
 702 /* Get the protocol settings */
 703 static int get_protocol(struct us_data *us)
 704 {
 705         switch (us->subclass) {
 706         case US_SC_RBC:
 707                 us->protocol_name = "Reduced Block Commands (RBC)";
 708                 us->proto_handler = usb_stor_transparent_scsi_command;
 709                 break;
 710
 711         case US_SC_8020:
 712                 us->protocol_name = "8020i";
 713                 us->proto_handler = usb_stor_ATAPI_command;
 714                 us->max_lun = 0;
 715                 break;
 716
 717         case US_SC_QIC:
 718                 us->protocol_name = "QIC-157";
 719                 us->proto_handler = usb_stor_qic157_command;
 720                 us->max_lun = 0;
 721                 break;
 722
 723         case US_SC_8070:
 724                 us->protocol_name = "8070i";
 725                 us->proto_handler = usb_stor_ATAPI_command;
 726                 us->max_lun = 0;
 727                 break;
 728
 729         case US_SC_SCSI:
 730                 us->protocol_name = "Transparent SCSI";
 731                 us->proto_handler = usb_stor_transparent_scsi_command;
 732                 break;
 733
 734         case US_SC_UFI:
 735                 us->protocol_name = "Uniform Floppy Interface (UFI)";
 736                 us->proto_handler = usb_stor_ufi_command;
 737                 break;
 738
 739 #ifdef CONFIG_USB_STORAGE_ISD200
 740         case US_SC_ISD200:
 741                 us->protocol_name = "ISD200 ATA/ATAPI";
 742                 us->proto_handler = isd200_ata_command;
 743                 break;
 744 #endif
 745
 746 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
 747         case US_SC_CYP_ATACB:
 748                 us->protocol_name = "Transparent SCSI with Cypress ATACB";
 749                 us->proto_handler = cypress_atacb_passthrough;
 750                 break;
 751 #endif
 752
 753         default:
 754                 return -EIO;
 755         }
 756         US_DEBUGP("Protocol: %s\n", us->protocol_name);
 757         return 0;
 758 }
 759
 760 /* Get the pipe settings */
 761 static int get_pipes(struct us_data *us)
 762 {
 763         struct usb_host_interface *altsetting =
 764                 us->pusb_intf->cur_altsetting;
 765         int i;
 766         struct usb_endpoint_descriptor *ep;
 767         struct usb_endpoint_descriptor *ep_in = NULL;
 768         struct usb_endpoint_descriptor *ep_out = NULL;
 769         struct usb_endpoint_descriptor *ep_int = NULL;
 770
 771         /*
 772          * Find the first endpoint of each type we need.
 773          * We are expecting a minimum of 2 endpoints - in and out (bulk).
 774          * An optional interrupt-in is OK (necessary for CBI protocol).
 775          * We will ignore any others.
 776          */
 777         for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
 778                 ep = &altsetting->endpoint[i].desc;
 779
 780                 if (usb_endpoint_xfer_bulk(ep)) {
 781                         if (usb_endpoint_dir_in(ep)) {
 782                                 if (!ep_in)
 783                                         ep_in = ep;
 784                         } else {
 785                                 if (!ep_out)
 786                                         ep_out = ep;
 787                         }
 788                 }
 789
 790                 else if (usb_endpoint_is_int_in(ep)) {
 791                         if (!ep_int)
 792                                 ep_int = ep;
 793                 }
 794         }
 795
 796         if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) {
 797                 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
 798                 return -EIO;
 799         }
 800
 801         /* Calculate and store the pipe values */
 802         us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
 803         us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
 804         us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
 805                 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
 806         us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
 807                 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
 808         if (ep_int) {
 809                 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
 810                         ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
 811                 us->ep_bInterval = ep_int->bInterval;
 812         }
 813         return 0;
 814 }
 815
 816 /* Initialize all the dynamic resources we need */
 817 static int usb_stor_acquire_resources(struct us_data *us)
 818 {
 819         int p;
 820         struct task_struct *th;
 821
 822         us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
 823         if (!us->current_urb) {
 824                 US_DEBUGP("URB allocation failed\n");
 825                 return -ENOMEM;
 826         }
 827
 828         /* Just before we start our control thread, initialize
 829          * the device if it needs initialization */
 830         if (us->unusual_dev->initFunction) {
 831                 p = us->unusual_dev->initFunction(us);
 832                 if (p)
 833                         return p;
 834         }
 835
 836         /* Start up our control thread */
 837         th = kthread_run(usb_stor_control_thread, us, "usb-storage");
 838         if (IS_ERR(th)) {
 839                 printk(KERN_WARNING USB_STORAGE
 840                        "Unable to start control thread\n");
 841                 return PTR_ERR(th);
 842         }
 843         us->ctl_thread = th;
 844
 845         return 0;
 846 }
 847
 848 /* Release all our dynamic resources */
 849 static void usb_stor_release_resources(struct us_data *us)
 850 {
 851         US_DEBUGP("-- %s\n", __func__);
 852
 853         /* Tell the control thread to exit.  The SCSI host must
 854          * already have been removed and the DISCONNECTING flag set
 855          * so that we won't accept any more commands.
 856          */
 857         US_DEBUGP("-- sending exit command to thread\n");
 858         complete(&us->cmnd_ready);
 859         if (us->ctl_thread)
 860                 kthread_stop(us->ctl_thread);
 861
 862         /* Call the destructor routine, if it exists */
 863         if (us->extra_destructor) {
 864                 US_DEBUGP("-- calling extra_destructor()\n");
 865                 us->extra_destructor(us->extra);
 866         }
 867
 868         /* Free the extra data and the URB */
 869         kfree(us->extra);
 870         usb_free_urb(us->current_urb);
 871 }
 872
 873 /* Dissociate from the USB device */
 874 static void dissociate_dev(struct us_data *us)
 875 {
 876         US_DEBUGP("-- %s\n", __func__);
 877
 878         kfree(us->sensebuf);
 879
 880         /* Free the device-related DMA-mapped buffers */
 881         if (us->cr)
 882                 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr,
 883                                 us->cr_dma);
 884         if (us->iobuf)
 885                 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf,
 886                                 us->iobuf_dma);
 887
 888         /* Remove our private data from the interface */
 889         usb_set_intfdata(us->pusb_intf, NULL);
 890 }
 891
 892 /* First stage of disconnect processing: stop SCSI scanning,
 893  * remove the host, and stop accepting new commands
 894  */
 895 static void quiesce_and_remove_host(struct us_data *us)
 896 {
 897         struct Scsi_Host *host = us_to_host(us);
 898
 899         /* If the device is really gone, cut short reset delays */
 900         if (us->pusb_dev->state == USB_STATE_NOTATTACHED)
 901                 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
 902
 903         /* Prevent SCSI-scanning (if it hasn't started yet)
 904          * and wait for the SCSI-scanning thread to stop.
 905          */
 906         set_bit(US_FLIDX_DONT_SCAN, &us->dflags);
 907         wake_up(&us->delay_wait);
 908         wait_for_completion(&us->scanning_done);
 909
 910         /* Removing the host will perform an orderly shutdown: caches
 911          * synchronized, disks spun down, etc.
 912          */
 913         scsi_remove_host(host);
 914
 915         /* Prevent any new commands from being accepted and cut short
 916          * reset delays.
 917          */
 918         scsi_lock(host);
 919         set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
 920         scsi_unlock(host);
 921         wake_up(&us->delay_wait);
 922 }
 923
 924 /* Second stage of disconnect processing: deallocate all resources */
 925 static void release_everything(struct us_data *us)
 926 {
 927         usb_stor_release_resources(us);
 928         dissociate_dev(us);
 929
 930         /* Drop our reference to the host; the SCSI core will free it
 931          * (and "us" along with it) when the refcount becomes 0. */
 932         scsi_host_put(us_to_host(us));
 933 }
 934
 935 /* Thread to carry out delayed SCSI-device scanning */
 936 static int usb_stor_scan_thread(void * __us)
 937 {
 938         struct us_data *us = (struct us_data *)__us;
 939
 940         printk(KERN_DEBUG
 941                 "usb-storage: device found at %d\n", us->pusb_dev->devnum);
 942
 943         set_freezable();
 944         /* Wait for the timeout to expire or for a disconnect */
 945         if (delay_use > 0) {
 946                 printk(KERN_DEBUG "usb-storage: waiting for device "
 947                                 "to settle before scanning\n");
 948                 wait_event_freezable_timeout(us->delay_wait,
 949                                 test_bit(US_FLIDX_DONT_SCAN, &us->dflags),
 950                                 delay_use * HZ);
 951         }
 952
 953         /* If the device is still connected, perform the scanning */
 954         if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) {
 955
 956                 /* For bulk-only devices, determine the max LUN value */
 957                 if (us->protocol == US_PR_BULK &&
 958                                 !(us->fflags & US_FL_SINGLE_LUN)) {
 959                         mutex_lock(&us->dev_mutex);
 960                         us->max_lun = usb_stor_Bulk_max_lun(us);
 961                         mutex_unlock(&us->dev_mutex);
 962                 }
 963                 scsi_scan_host(us_to_host(us));
 964                 printk(KERN_DEBUG "usb-storage: device scan complete\n");
 965
 966                 /* Should we unbind if no devices were detected? */
 967         }
 968
 969         complete_and_exit(&us->scanning_done, 0);
 970 }
 971
 972
 973 /* Probe to see if we can drive a newly-connected USB device */
 974 static int storage_probe(struct usb_interface *intf,
 975                          const struct usb_device_id *id)
 976 {
 977         struct Scsi_Host *host;
 978         struct us_data *us;
 979         int result;
 980         struct task_struct *th;
 981
 982         if (usb_usual_check_type(id, USB_US_TYPE_STOR))
 983                 return -ENXIO;
 984
 985         US_DEBUGP("USB Mass Storage device detected\n");
 986
 987         /*
 988          * Ask the SCSI layer to allocate a host structure, with extra
 989          * space at the end for our private us_data structure.
 990          */
 991         host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
 992         if (!host) {
 993                 printk(KERN_WARNING USB_STORAGE
 994                         "Unable to allocate the scsi host\n");
 995                 return -ENOMEM;
 996         }
 997
 998         /*
 999          * Allow 16-byte CDBs and thus > 2TB
1000          */
1001         host->max_cmd_len = 16;
1002         us = host_to_us(host);
1003         memset(us, 0, sizeof(struct us_data));
1004         mutex_init(&(us->dev_mutex));
1005         init_completion(&us->cmnd_ready);
1006         init_completion(&(us->notify));
1007         init_waitqueue_head(&us->delay_wait);
1008         init_completion(&us->scanning_done);
1009
1010         /* Associate the us_data structure with the USB device */
1011         result = associate_dev(us, intf);
1012         if (result)
1013                 goto BadDevice;
1014
1015         /*
1016          * Get the unusual_devs entries and the descriptors
1017          *
1018          * id_index is calculated in the declaration to be the index number
1019          * of the match from the usb_device_id table, so we can find the
1020          * corresponding entry in the private table.
1021          */
1022         result = get_device_info(us, id);
1023         if (result)
1024                 goto BadDevice;
1025
1026         /* Get the transport, protocol, and pipe settings */
1027         result = get_transport(us);
1028         if (result)
1029                 goto BadDevice;
1030         result = get_protocol(us);
1031         if (result)
1032                 goto BadDevice;
1033         result = get_pipes(us);
1034         if (result)
1035                 goto BadDevice;
1036
1037         /* Acquire all the other resources and add the host */
1038         result = usb_stor_acquire_resources(us);
1039         if (result)
1040                 goto BadDevice;
1041         result = scsi_add_host(host, &intf->dev);
1042         if (result) {
1043                 printk(KERN_WARNING USB_STORAGE
1044                         "Unable to add the scsi host\n");
1045                 goto BadDevice;
1046         }
1047
1048         /* Start up the thread for delayed SCSI-device scanning */
1049         th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan");
1050         if (IS_ERR(th)) {
1051                 printk(KERN_WARNING USB_STORAGE
1052                        "Unable to start the device-scanning thread\n");
1053                 complete(&us->scanning_done);
1054                 quiesce_and_remove_host(us);
1055                 result = PTR_ERR(th);
1056                 goto BadDevice;
1057         }
1058
1059         wake_up_process(th);
1060
1061         return 0;
1062
1063         /* We come here if there are any problems */
1064 BadDevice:
1065         US_DEBUGP("storage_probe() failed\n");
1066         release_everything(us);
1067         return result;
1068 }
1069
1070 /* Handle a disconnect event from the USB core */
1071 static void storage_disconnect(struct usb_interface *intf)
1072 {
1073         struct us_data *us = usb_get_intfdata(intf);
1074
1075         US_DEBUGP("storage_disconnect() called\n");
1076         quiesce_and_remove_host(us);
1077         release_everything(us);
1078 }
1079
1080 /***********************************************************************
1081  * Initialization and registration
1082  ***********************************************************************/
1083
1084 static struct usb_driver usb_storage_driver = {
1085         .name =         "usb-storage",
1086         .probe =        storage_probe,
1087         .disconnect =   storage_disconnect,
1088 #ifdef CONFIG_PM
1089         .suspend =      storage_suspend,
1090         .resume =       storage_resume,
1091         .reset_resume = storage_reset_resume,
1092 #endif
1093         .pre_reset =    storage_pre_reset,
1094         .post_reset =   storage_post_reset,
1095         .id_table =     storage_usb_ids,
1096         .soft_unbind =  1,
1097 };
1098
1099 /* Works only for digits and letters, but small and fast */
1100 #define TOLOWER(x) ((x) | 0x20)
1101
1102 static void __init parse_quirks(void)
1103 {
1104         int n, i;
1105         char *p;
1106
1107         if (!quirks)
1108                 return;
1109
1110         /* Count the ':' characters to get 2 * the number of entries */
1111         n = 0;
1112         for (p = quirks; *p; ++p) {
1113                 if (*p == ':')
1114                         ++n;
1115         }
1116         n /= 2;
1117         if (n == 0)
1118                 return;         /* Don't allocate 0 bytes */
1119
1120         quirks_list = kmalloc(n * sizeof(*quirks_list), GFP_KERNEL);
1121         if (!quirks_list)
1122                 return;
1123
1124         p = quirks;
1125         quirks_end = quirks_list;
1126         for (i = 0; i < n && *p; ++i) {
1127                 unsigned f = 0;
1128
1129                 /* Each entry consists of VID:PID:flags */
1130                 quirks_end->vid = simple_strtoul(p, &p, 16);
1131                 if (*p != ':')
1132                         goto skip_to_next;
1133                 quirks_end->pid = simple_strtoul(p+1, &p, 16);
1134                 if (*p != ':')
1135                         goto skip_to_next;
1136
1137                 while (*++p && *p != ',') {
1138                         switch (TOLOWER(*p)) {
1139                         case 'c':
1140                                 f |= US_FL_FIX_CAPACITY;
1141                                 break;
1142                         case 'i':
1143                                 f |= US_FL_IGNORE_DEVICE;
1144                                 break;
1145                         case 'l':
1146                                 f |= US_FL_NOT_LOCKABLE;
1147                                 break;
1148                         case 'm':
1149                                 f |= US_FL_MAX_SECTORS_64;
1150                                 break;
1151                         case 'r':
1152                                 f |= US_FL_IGNORE_RESIDUE;
1153                                 break;
1154                         case 's':
1155                                 f |= US_FL_SINGLE_LUN;
1156                                 break;
1157                         case 'w':
1158                                 f |= US_FL_NO_WP_DETECT;
1159                                 break;
1160                         /* Ignore unrecognized flag characters */
1161                         }
1162                 }
1163                 quirks_end->fflags = f;
1164                 ++quirks_end;
1165
1166  skip_to_next:
1167                 /* Entries are separated by commas */
1168                 while (*p) {
1169                         if (*p++ == ',')
1170                                 break;
1171                 }
1172         } /* for (i = 0; ...) */
1173 }
1174
1175 static int __init usb_stor_init(void)
1176 {
1177         int retval;
1178
1179         printk(KERN_INFO "Initializing USB Mass Storage driver...\n");
1180         parse_quirks();
1181
1182         /* register the driver, return usb_register return code if error */
1183         retval = usb_register(&usb_storage_driver);
1184         if (retval == 0) {
1185                 printk(KERN_INFO "USB Mass Storage support registered.\n");
1186                 usb_usual_set_present(USB_US_TYPE_STOR);
1187         }
1188         return retval;
1189 }
1190
1191 static void __exit usb_stor_exit(void)
1192 {
1193         US_DEBUGP("usb_stor_exit() called\n");
1194
1195         /* Deregister the driver
1196          * This will cause disconnect() to be called for each
1197          * attached unit
1198          */
1199         US_DEBUGP("-- calling usb_deregister()\n");
1200         usb_deregister(&usb_storage_driver) ;
1201
1202         usb_usual_clear_present(USB_US_TYPE_STOR);
1203 }
1204
1205 module_init(usb_stor_init);
1206 module_exit(usb_stor_exit);