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