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