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