drivers/usb/storage/usb.c

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