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