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