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