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