drivers/usb/storage/usb.c

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