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