git.oblomov.eu Git - linux-2.6/blob - drivers/usb/storage/usb.c

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