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