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