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