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