1 /* Driver for USB Mass Storage compliant devices
3 * Current development and maintenance by:
4 * (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
6 * Developed with the assistance of:
7 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
8 * (c) 2003 Alan Stern (stern@rowland.harvard.edu)
11 * (c) 1999 Michael Gee (michael@linuxspecific.com)
13 * usb_device_id support by Adam J. Richter (adam@yggdrasil.com):
14 * (c) 2000 Yggdrasil Computing, Inc.
16 * This driver is based on the 'USB Mass Storage Class' document. This
17 * describes in detail the protocol used to communicate with such
18 * devices. Clearly, the designers had SCSI and ATAPI commands in
19 * mind when they created this document. The commands are all very
20 * similar to commands in the SCSI-II and ATAPI specifications.
22 * It is important to note that in a number of cases this class
23 * exhibits class-specific exemptions from the USB specification.
24 * Notably the usage of NAK, STALL and ACK differs from the norm, in
25 * that they are used to communicate wait, failed and OK on commands.
27 * Also, for certain devices, the interrupt endpoint is used to convey
28 * status of a command.
30 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
31 * information about this driver.
33 * This program is free software; you can redistribute it and/or modify it
34 * under the terms of the GNU General Public License as published by the
35 * Free Software Foundation; either version 2, or (at your option) any
38 * This program is distributed in the hope that it will be useful, but
39 * WITHOUT ANY WARRANTY; without even the implied warranty of
40 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41 * General Public License for more details.
43 * You should have received a copy of the GNU General Public License along
44 * with this program; if not, write to the Free Software Foundation, Inc.,
45 * 675 Mass Ave, Cambridge, MA 02139, USA.
48 #include <linux/sched.h>
49 #include <linux/errno.h>
50 #include <linux/freezer.h>
51 #include <linux/module.h>
52 #include <linux/init.h>
53 #include <linux/slab.h>
54 #include <linux/kthread.h>
55 #include <linux/mutex.h>
56 #include <linux/utsname.h>
58 #include <scsi/scsi.h>
59 #include <scsi/scsi_cmnd.h>
60 #include <scsi/scsi_device.h>
64 #include "transport.h"
67 #include "initializers.h"
69 #ifdef CONFIG_USB_STORAGE_USBAT
70 #include "shuttle_usbat.h"
72 #ifdef CONFIG_USB_STORAGE_SDDR09
75 #ifdef CONFIG_USB_STORAGE_SDDR55
78 #ifdef CONFIG_USB_STORAGE_FREECOM
81 #ifdef CONFIG_USB_STORAGE_ISD200
84 #ifdef CONFIG_USB_STORAGE_DATAFAB
87 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
90 #ifdef CONFIG_USB_STORAGE_ONETOUCH
93 #ifdef CONFIG_USB_STORAGE_ALAUDA
96 #ifdef CONFIG_USB_STORAGE_KARMA
99 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
100 #include "cypress_atacb.h"
102 #include "sierra_ms.h"
103 #include "option_ms.h"
105 /* Some informational data */
106 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
107 MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
108 MODULE_LICENSE("GPL");
110 static unsigned int delay_use = 5;
111 module_param(delay_use, uint, S_IRUGO | S_IWUSR);
112 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
115 module_param(quirks, charp, S_IRUGO);
116 MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
118 struct quirks_entry {
122 static struct quirks_entry *quirks_list, *quirks_end;
126 * The entries in this table correspond, line for line,
127 * with the entries of us_unusual_dev_list[].
129 #ifndef CONFIG_USB_LIBUSUAL
131 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
132 vendorName, productName,useProtocol, useTransport, \
133 initFunction, flags) \
134 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \
135 .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
137 #define COMPLIANT_DEV UNUSUAL_DEV
139 #define USUAL_DEV(useProto, useTrans, useType) \
140 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
141 .driver_info = (USB_US_TYPE_STOR<<24) }
143 static struct usb_device_id storage_usb_ids [] = {
145 # include "unusual_devs.h"
149 /* Terminating entry */
153 MODULE_DEVICE_TABLE (usb, storage_usb_ids);
154 #endif /* CONFIG_USB_LIBUSUAL */
156 /* This is the list of devices we recognize, along with their flag data */
158 /* The vendor name should be kept at eight characters or less, and
159 * the product name should be kept at 16 characters or less. If a device
160 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
161 * normally generated by a device thorugh the INQUIRY response will be
162 * taken from this list, and this is the reason for the above size
163 * restriction. However, if the flag is not present, then you
164 * are free to use as many characters as you like.
167 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
168 vendor_name, product_name, use_protocol, use_transport, \
169 init_function, Flags) \
171 .vendorName = vendor_name, \
172 .productName = product_name, \
173 .useProtocol = use_protocol, \
174 .useTransport = use_transport, \
175 .initFunction = init_function, \
178 #define COMPLIANT_DEV UNUSUAL_DEV
180 #define USUAL_DEV(use_protocol, use_transport, use_type) \
182 .useProtocol = use_protocol, \
183 .useTransport = use_transport, \
186 static struct us_unusual_dev us_unusual_dev_list[] = {
187 # include "unusual_devs.h"
189 # undef COMPLIANT_DEV
192 /* Terminating entry */
197 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
199 static int storage_suspend(struct usb_interface *iface, pm_message_t message)
201 struct us_data *us = usb_get_intfdata(iface);
203 /* Wait until no command is running */
204 mutex_lock(&us->dev_mutex);
206 US_DEBUGP("%s\n", __func__);
207 if (us->suspend_resume_hook)
208 (us->suspend_resume_hook)(us, US_SUSPEND);
210 /* When runtime PM is working, we'll set a flag to indicate
211 * whether we should autoresume when a SCSI request arrives. */
213 mutex_unlock(&us->dev_mutex);
217 static int storage_resume(struct usb_interface *iface)
219 struct us_data *us = usb_get_intfdata(iface);
221 mutex_lock(&us->dev_mutex);
223 US_DEBUGP("%s\n", __func__);
224 if (us->suspend_resume_hook)
225 (us->suspend_resume_hook)(us, US_RESUME);
227 mutex_unlock(&us->dev_mutex);
231 static int storage_reset_resume(struct usb_interface *iface)
233 struct us_data *us = usb_get_intfdata(iface);
235 US_DEBUGP("%s\n", __func__);
237 /* Report the reset to the SCSI core */
238 usb_stor_report_bus_reset(us);
240 /* FIXME: Notify the subdrivers that they need to reinitialize
245 #endif /* CONFIG_PM */
248 * The next two routines get called just before and just after
249 * a USB port reset, whether from this driver or a different one.
252 static int storage_pre_reset(struct usb_interface *iface)
254 struct us_data *us = usb_get_intfdata(iface);
256 US_DEBUGP("%s\n", __func__);
258 /* Make sure no command runs during the reset */
259 mutex_lock(&us->dev_mutex);
263 static int storage_post_reset(struct usb_interface *iface)
265 struct us_data *us = usb_get_intfdata(iface);
267 US_DEBUGP("%s\n", __func__);
269 /* Report the reset to the SCSI core */
270 usb_stor_report_bus_reset(us);
272 /* FIXME: Notify the subdrivers that they need to reinitialize
275 mutex_unlock(&us->dev_mutex);
280 * fill_inquiry_response takes an unsigned char array (which must
281 * be at least 36 characters) and populates the vendor name,
282 * product name, and revision fields. Then the array is copied
283 * into the SCSI command's response buffer (oddly enough
284 * called request_buffer). data_len contains the length of the
285 * data array, which again must be at least 36.
288 void fill_inquiry_response(struct us_data *us, unsigned char *data,
289 unsigned int data_len)
291 if (data_len<36) // You lose.
294 if(data[0]&0x20) { /* USB device currently not connected. Return
295 peripheral qualifier 001b ("...however, the
296 physical device is not currently connected
297 to this logical unit") and leave vendor and
298 product identification empty. ("If the target
299 does store some of the INQUIRY data on the
300 device, it may return zeros or ASCII spaces
301 (20h) in those fields until the data is
302 available from the device."). */
305 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
306 memcpy(data+8, us->unusual_dev->vendorName,
307 strlen(us->unusual_dev->vendorName) > 8 ? 8 :
308 strlen(us->unusual_dev->vendorName));
309 memcpy(data+16, us->unusual_dev->productName,
310 strlen(us->unusual_dev->productName) > 16 ? 16 :
311 strlen(us->unusual_dev->productName));
312 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F);
313 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F);
314 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F);
315 data[35] = 0x30 + ((bcdDevice) & 0x0F);
318 usb_stor_set_xfer_buf(data, data_len, us->srb);
321 static int usb_stor_control_thread(void * __us)
323 struct us_data *us = (struct us_data *)__us;
324 struct Scsi_Host *host = us_to_host(us);
327 US_DEBUGP("*** thread sleeping.\n");
328 if (wait_for_completion_interruptible(&us->cmnd_ready))
331 US_DEBUGP("*** thread awakened.\n");
333 /* lock the device pointers */
334 mutex_lock(&(us->dev_mutex));
336 /* lock access to the state */
339 /* When we are called with no command pending, we're done */
340 if (us->srb == NULL) {
342 mutex_unlock(&us->dev_mutex);
343 US_DEBUGP("-- exiting\n");
347 /* has the command timed out *already* ? */
348 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
349 us->srb->result = DID_ABORT << 16;
355 /* reject the command if the direction indicator
358 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
359 US_DEBUGP("UNKNOWN data direction\n");
360 us->srb->result = DID_ERROR << 16;
363 /* reject if target != 0 or if LUN is higher than
364 * the maximum known LUN
366 else if (us->srb->device->id &&
367 !(us->fflags & US_FL_SCM_MULT_TARG)) {
368 US_DEBUGP("Bad target number (%d:%d)\n",
369 us->srb->device->id, us->srb->device->lun);
370 us->srb->result = DID_BAD_TARGET << 16;
373 else if (us->srb->device->lun > us->max_lun) {
374 US_DEBUGP("Bad LUN (%d:%d)\n",
375 us->srb->device->id, us->srb->device->lun);
376 us->srb->result = DID_BAD_TARGET << 16;
379 /* Handle those devices which need us to fake
380 * their inquiry data */
381 else if ((us->srb->cmnd[0] == INQUIRY) &&
382 (us->fflags & US_FL_FIX_INQUIRY)) {
383 unsigned char data_ptr[36] = {
384 0x00, 0x80, 0x02, 0x02,
385 0x1F, 0x00, 0x00, 0x00};
387 US_DEBUGP("Faking INQUIRY command\n");
388 fill_inquiry_response(us, data_ptr, 36);
389 us->srb->result = SAM_STAT_GOOD;
392 /* we've got a command, let's do it! */
394 US_DEBUG(usb_stor_show_command(us->srb));
395 us->proto_handler(us->srb, us);
398 /* lock access to the state */
401 /* indicate that the command is done */
402 if (us->srb->result != DID_ABORT << 16) {
403 US_DEBUGP("scsi cmd done, result=0x%x\n",
405 us->srb->scsi_done(us->srb);
408 US_DEBUGP("scsi command aborted\n");
411 /* If an abort request was received we need to signal that
412 * the abort has finished. The proper test for this is
413 * the TIMED_OUT flag, not srb->result == DID_ABORT, because
414 * the timeout might have occurred after the command had
415 * already completed with a different result code. */
416 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
417 complete(&(us->notify));
419 /* Allow USB transfers to resume */
420 clear_bit(US_FLIDX_ABORTING, &us->dflags);
421 clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
424 /* finished working on this command */
428 /* unlock the device pointers */
429 mutex_unlock(&us->dev_mutex);
432 /* Wait until we are told to stop */
434 set_current_state(TASK_INTERRUPTIBLE);
435 if (kthread_should_stop())
439 __set_current_state(TASK_RUNNING);
443 /***********************************************************************
444 * Device probing and disconnecting
445 ***********************************************************************/
447 /* Associate our private data with the USB device */
448 static int associate_dev(struct us_data *us, struct usb_interface *intf)
450 US_DEBUGP("-- %s\n", __func__);
452 /* Fill in the device-related fields */
453 us->pusb_dev = interface_to_usbdev(intf);
454 us->pusb_intf = intf;
455 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
456 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n",
457 le16_to_cpu(us->pusb_dev->descriptor.idVendor),
458 le16_to_cpu(us->pusb_dev->descriptor.idProduct),
459 le16_to_cpu(us->pusb_dev->descriptor.bcdDevice));
460 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n",
461 intf->cur_altsetting->desc.bInterfaceSubClass,
462 intf->cur_altsetting->desc.bInterfaceProtocol);
464 /* Store our private data in the interface */
465 usb_set_intfdata(intf, us);
467 /* Allocate the device-related DMA-mapped buffers */
468 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr),
469 GFP_KERNEL, &us->cr_dma);
471 US_DEBUGP("usb_ctrlrequest allocation failed\n");
475 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE,
476 GFP_KERNEL, &us->iobuf_dma);
478 US_DEBUGP("I/O buffer allocation failed\n");
484 /* Adjust device flags based on the "quirks=" module parameter */
485 static void adjust_quirks(struct us_data *us)
488 struct quirks_entry *q;
489 unsigned int mask = (US_FL_FIX_CAPACITY | US_FL_IGNORE_DEVICE |
490 US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
491 US_FL_IGNORE_RESIDUE | US_FL_SINGLE_LUN |
494 vid = le16_to_cpu(us->pusb_dev->descriptor.idVendor);
495 pid = le16_to_cpu(us->pusb_dev->descriptor.idProduct);
497 for (q = quirks_list; q != quirks_end; ++q) {
498 if (q->vid == vid && q->pid == pid) {
499 us->fflags = (us->fflags & ~mask) | q->fflags;
500 dev_info(&us->pusb_intf->dev, "Quirks match for "
501 "vid %04x pid %04x: %x\n",
502 vid, pid, q->fflags);
508 /* Find an unusual_dev descriptor (always succeeds in the current code) */
509 static struct us_unusual_dev *find_unusual(const struct usb_device_id *id)
511 const int id_index = id - storage_usb_ids;
512 return &us_unusual_dev_list[id_index];
515 /* Get the unusual_devs entries and the string descriptors */
516 static int get_device_info(struct us_data *us, const struct usb_device_id *id)
518 struct usb_device *dev = us->pusb_dev;
519 struct usb_interface_descriptor *idesc =
520 &us->pusb_intf->cur_altsetting->desc;
521 struct us_unusual_dev *unusual_dev = find_unusual(id);
523 /* Store the entries */
524 us->unusual_dev = unusual_dev;
525 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ?
526 idesc->bInterfaceSubClass :
527 unusual_dev->useProtocol;
528 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ?
529 idesc->bInterfaceProtocol :
530 unusual_dev->useTransport;
531 us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
534 if (us->fflags & US_FL_IGNORE_DEVICE) {
535 printk(KERN_INFO USB_STORAGE "device ignored\n");
540 * This flag is only needed when we're in high-speed, so let's
541 * disable it if we're in full-speed
543 if (dev->speed != USB_SPEED_HIGH)
544 us->fflags &= ~US_FL_GO_SLOW;
546 /* Log a message if a non-generic unusual_dev entry contains an
547 * unnecessary subclass or protocol override. This may stimulate
548 * reports from users that will help us remove unneeded entries
549 * from the unusual_devs.h table.
551 if (id->idVendor || id->idProduct) {
552 static const char *msgs[3] = {
553 "an unneeded SubClass entry",
554 "an unneeded Protocol entry",
555 "unneeded SubClass and Protocol entries"};
556 struct usb_device_descriptor *ddesc = &dev->descriptor;
559 if (unusual_dev->useProtocol != US_SC_DEVICE &&
560 us->subclass == idesc->bInterfaceSubClass)
562 if (unusual_dev->useTransport != US_PR_DEVICE &&
563 us->protocol == idesc->bInterfaceProtocol)
565 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
566 printk(KERN_NOTICE USB_STORAGE "This device "
567 "(%04x,%04x,%04x S %02x P %02x)"
568 " has %s in unusual_devs.h (kernel"
570 " Please send a copy of this message to "
571 "<linux-usb@vger.kernel.org> and "
572 "<usb-storage@lists.one-eyed-alien.net>\n",
573 le16_to_cpu(ddesc->idVendor),
574 le16_to_cpu(ddesc->idProduct),
575 le16_to_cpu(ddesc->bcdDevice),
576 idesc->bInterfaceSubClass,
577 idesc->bInterfaceProtocol,
585 /* Get the transport settings */
586 static int get_transport(struct us_data *us)
588 switch (us->protocol) {
590 us->transport_name = "Control/Bulk";
591 us->transport = usb_stor_CB_transport;
592 us->transport_reset = usb_stor_CB_reset;
597 us->transport_name = "Control/Bulk/Interrupt";
598 us->transport = usb_stor_CB_transport;
599 us->transport_reset = usb_stor_CB_reset;
604 us->transport_name = "Bulk";
605 us->transport = usb_stor_Bulk_transport;
606 us->transport_reset = usb_stor_Bulk_reset;
609 #ifdef CONFIG_USB_STORAGE_USBAT
611 us->transport_name = "Shuttle USBAT";
612 us->transport = usbat_transport;
613 us->transport_reset = usb_stor_CB_reset;
618 #ifdef CONFIG_USB_STORAGE_SDDR09
619 case US_PR_EUSB_SDDR09:
620 us->transport_name = "EUSB/SDDR09";
621 us->transport = sddr09_transport;
622 us->transport_reset = usb_stor_CB_reset;
627 #ifdef CONFIG_USB_STORAGE_SDDR55
629 us->transport_name = "SDDR55";
630 us->transport = sddr55_transport;
631 us->transport_reset = sddr55_reset;
636 #ifdef CONFIG_USB_STORAGE_DPCM
638 us->transport_name = "Control/Bulk-EUSB/SDDR09";
639 us->transport = dpcm_transport;
640 us->transport_reset = usb_stor_CB_reset;
645 #ifdef CONFIG_USB_STORAGE_FREECOM
647 us->transport_name = "Freecom";
648 us->transport = freecom_transport;
649 us->transport_reset = usb_stor_freecom_reset;
654 #ifdef CONFIG_USB_STORAGE_DATAFAB
656 us->transport_name = "Datafab Bulk-Only";
657 us->transport = datafab_transport;
658 us->transport_reset = usb_stor_Bulk_reset;
663 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
665 us->transport_name = "Lexar Jumpshot Control/Bulk";
666 us->transport = jumpshot_transport;
667 us->transport_reset = usb_stor_Bulk_reset;
672 #ifdef CONFIG_USB_STORAGE_ALAUDA
674 us->transport_name = "Alauda Control/Bulk";
675 us->transport = alauda_transport;
676 us->transport_reset = usb_stor_Bulk_reset;
681 #ifdef CONFIG_USB_STORAGE_KARMA
683 us->transport_name = "Rio Karma/Bulk";
684 us->transport = rio_karma_transport;
685 us->transport_reset = usb_stor_Bulk_reset;
692 US_DEBUGP("Transport: %s\n", us->transport_name);
694 /* fix for single-lun devices */
695 if (us->fflags & US_FL_SINGLE_LUN)
700 /* Get the protocol settings */
701 static int get_protocol(struct us_data *us)
703 switch (us->subclass) {
705 us->protocol_name = "Reduced Block Commands (RBC)";
706 us->proto_handler = usb_stor_transparent_scsi_command;
710 us->protocol_name = "8020i";
711 us->proto_handler = usb_stor_pad12_command;
716 us->protocol_name = "QIC-157";
717 us->proto_handler = usb_stor_pad12_command;
722 us->protocol_name = "8070i";
723 us->proto_handler = usb_stor_pad12_command;
728 us->protocol_name = "Transparent SCSI";
729 us->proto_handler = usb_stor_transparent_scsi_command;
733 us->protocol_name = "Uniform Floppy Interface (UFI)";
734 us->proto_handler = usb_stor_ufi_command;
737 #ifdef CONFIG_USB_STORAGE_ISD200
739 us->protocol_name = "ISD200 ATA/ATAPI";
740 us->proto_handler = isd200_ata_command;
744 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
745 case US_SC_CYP_ATACB:
746 us->protocol_name = "Transparent SCSI with Cypress ATACB";
747 us->proto_handler = cypress_atacb_passthrough;
754 US_DEBUGP("Protocol: %s\n", us->protocol_name);
758 /* Get the pipe settings */
759 static int get_pipes(struct us_data *us)
761 struct usb_host_interface *altsetting =
762 us->pusb_intf->cur_altsetting;
764 struct usb_endpoint_descriptor *ep;
765 struct usb_endpoint_descriptor *ep_in = NULL;
766 struct usb_endpoint_descriptor *ep_out = NULL;
767 struct usb_endpoint_descriptor *ep_int = NULL;
770 * Find the first endpoint of each type we need.
771 * We are expecting a minimum of 2 endpoints - in and out (bulk).
772 * An optional interrupt-in is OK (necessary for CBI protocol).
773 * We will ignore any others.
775 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
776 ep = &altsetting->endpoint[i].desc;
778 if (usb_endpoint_xfer_bulk(ep)) {
779 if (usb_endpoint_dir_in(ep)) {
788 else if (usb_endpoint_is_int_in(ep)) {
794 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) {
795 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
799 /* Calculate and store the pipe values */
800 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
801 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
802 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
803 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
804 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
805 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
807 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
808 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
809 us->ep_bInterval = ep_int->bInterval;
814 /* Initialize all the dynamic resources we need */
815 static int usb_stor_acquire_resources(struct us_data *us)
818 struct task_struct *th;
820 us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
821 if (!us->current_urb) {
822 US_DEBUGP("URB allocation failed\n");
826 /* Just before we start our control thread, initialize
827 * the device if it needs initialization */
828 if (us->unusual_dev->initFunction) {
829 p = us->unusual_dev->initFunction(us);
834 /* Start up our control thread */
835 th = kthread_run(usb_stor_control_thread, us, "usb-storage");
837 printk(KERN_WARNING USB_STORAGE
838 "Unable to start control thread\n");
846 /* Release all our dynamic resources */
847 static void usb_stor_release_resources(struct us_data *us)
849 US_DEBUGP("-- %s\n", __func__);
851 /* Tell the control thread to exit. The SCSI host must
852 * already have been removed and the DISCONNECTING flag set
853 * so that we won't accept any more commands.
855 US_DEBUGP("-- sending exit command to thread\n");
856 complete(&us->cmnd_ready);
858 kthread_stop(us->ctl_thread);
860 /* Call the destructor routine, if it exists */
861 if (us->extra_destructor) {
862 US_DEBUGP("-- calling extra_destructor()\n");
863 us->extra_destructor(us->extra);
866 /* Free the extra data and the URB */
868 usb_free_urb(us->current_urb);
871 /* Dissociate from the USB device */
872 static void dissociate_dev(struct us_data *us)
874 US_DEBUGP("-- %s\n", __func__);
876 /* Free the device-related DMA-mapped buffers */
878 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr,
881 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf,
884 /* Remove our private data from the interface */
885 usb_set_intfdata(us->pusb_intf, NULL);
888 /* First stage of disconnect processing: stop SCSI scanning,
889 * remove the host, and stop accepting new commands
891 static void quiesce_and_remove_host(struct us_data *us)
893 struct Scsi_Host *host = us_to_host(us);
895 /* If the device is really gone, cut short reset delays */
896 if (us->pusb_dev->state == USB_STATE_NOTATTACHED)
897 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
899 /* Prevent SCSI-scanning (if it hasn't started yet)
900 * and wait for the SCSI-scanning thread to stop.
902 set_bit(US_FLIDX_DONT_SCAN, &us->dflags);
903 wake_up(&us->delay_wait);
904 wait_for_completion(&us->scanning_done);
906 /* Removing the host will perform an orderly shutdown: caches
907 * synchronized, disks spun down, etc.
909 scsi_remove_host(host);
911 /* Prevent any new commands from being accepted and cut short
915 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
917 wake_up(&us->delay_wait);
920 /* Second stage of disconnect processing: deallocate all resources */
921 static void release_everything(struct us_data *us)
923 usb_stor_release_resources(us);
926 /* Drop our reference to the host; the SCSI core will free it
927 * (and "us" along with it) when the refcount becomes 0. */
928 scsi_host_put(us_to_host(us));
931 /* Thread to carry out delayed SCSI-device scanning */
932 static int usb_stor_scan_thread(void * __us)
934 struct us_data *us = (struct us_data *)__us;
937 "usb-storage: device found at %d\n", us->pusb_dev->devnum);
940 /* Wait for the timeout to expire or for a disconnect */
942 printk(KERN_DEBUG "usb-storage: waiting for device "
943 "to settle before scanning\n");
944 wait_event_freezable_timeout(us->delay_wait,
945 test_bit(US_FLIDX_DONT_SCAN, &us->dflags),
949 /* If the device is still connected, perform the scanning */
950 if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) {
952 /* For bulk-only devices, determine the max LUN value */
953 if (us->protocol == US_PR_BULK &&
954 !(us->fflags & US_FL_SINGLE_LUN)) {
955 mutex_lock(&us->dev_mutex);
956 us->max_lun = usb_stor_Bulk_max_lun(us);
957 mutex_unlock(&us->dev_mutex);
959 scsi_scan_host(us_to_host(us));
960 printk(KERN_DEBUG "usb-storage: device scan complete\n");
962 /* Should we unbind if no devices were detected? */
965 complete_and_exit(&us->scanning_done, 0);
969 /* Probe to see if we can drive a newly-connected USB device */
970 static int storage_probe(struct usb_interface *intf,
971 const struct usb_device_id *id)
973 struct Scsi_Host *host;
976 struct task_struct *th;
978 if (usb_usual_check_type(id, USB_US_TYPE_STOR))
981 US_DEBUGP("USB Mass Storage device detected\n");
984 * Ask the SCSI layer to allocate a host structure, with extra
985 * space at the end for our private us_data structure.
987 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
989 printk(KERN_WARNING USB_STORAGE
990 "Unable to allocate the scsi host\n");
995 * Allow 16-byte CDBs and thus > 2TB
997 host->max_cmd_len = 16;
998 us = host_to_us(host);
999 memset(us, 0, sizeof(struct us_data));
1000 mutex_init(&(us->dev_mutex));
1001 init_completion(&us->cmnd_ready);
1002 init_completion(&(us->notify));
1003 init_waitqueue_head(&us->delay_wait);
1004 init_completion(&us->scanning_done);
1006 /* Associate the us_data structure with the USB device */
1007 result = associate_dev(us, intf);
1012 * Get the unusual_devs entries and the descriptors
1014 * id_index is calculated in the declaration to be the index number
1015 * of the match from the usb_device_id table, so we can find the
1016 * corresponding entry in the private table.
1018 result = get_device_info(us, id);
1022 /* Get the transport, protocol, and pipe settings */
1023 result = get_transport(us);
1026 result = get_protocol(us);
1029 result = get_pipes(us);
1033 /* Acquire all the other resources and add the host */
1034 result = usb_stor_acquire_resources(us);
1037 result = scsi_add_host(host, &intf->dev);
1039 printk(KERN_WARNING USB_STORAGE
1040 "Unable to add the scsi host\n");
1044 /* Start up the thread for delayed SCSI-device scanning */
1045 th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan");
1047 printk(KERN_WARNING USB_STORAGE
1048 "Unable to start the device-scanning thread\n");
1049 complete(&us->scanning_done);
1050 quiesce_and_remove_host(us);
1051 result = PTR_ERR(th);
1055 wake_up_process(th);
1059 /* We come here if there are any problems */
1061 US_DEBUGP("storage_probe() failed\n");
1062 release_everything(us);
1066 /* Handle a disconnect event from the USB core */
1067 static void storage_disconnect(struct usb_interface *intf)
1069 struct us_data *us = usb_get_intfdata(intf);
1071 US_DEBUGP("storage_disconnect() called\n");
1072 quiesce_and_remove_host(us);
1073 release_everything(us);
1076 /***********************************************************************
1077 * Initialization and registration
1078 ***********************************************************************/
1080 static struct usb_driver usb_storage_driver = {
1081 .name = "usb-storage",
1082 .probe = storage_probe,
1083 .disconnect = storage_disconnect,
1085 .suspend = storage_suspend,
1086 .resume = storage_resume,
1087 .reset_resume = storage_reset_resume,
1089 .pre_reset = storage_pre_reset,
1090 .post_reset = storage_post_reset,
1091 .id_table = storage_usb_ids,
1095 /* Works only for digits and letters, but small and fast */
1096 #define TOLOWER(x) ((x) | 0x20)
1098 static void __init parse_quirks(void)
1106 /* Count the ':' characters to get 2 * the number of entries */
1108 for (p = quirks; *p; ++p) {
1114 return; /* Don't allocate 0 bytes */
1116 quirks_list = kmalloc(n * sizeof(*quirks_list), GFP_KERNEL);
1121 quirks_end = quirks_list;
1122 for (i = 0; i < n && *p; ++i) {
1125 /* Each entry consists of VID:PID:flags */
1126 quirks_end->vid = simple_strtoul(p, &p, 16);
1129 quirks_end->pid = simple_strtoul(p+1, &p, 16);
1133 while (*++p && *p != ',') {
1134 switch (TOLOWER(*p)) {
1136 f |= US_FL_FIX_CAPACITY;
1139 f |= US_FL_IGNORE_DEVICE;
1142 f |= US_FL_NOT_LOCKABLE;
1145 f |= US_FL_MAX_SECTORS_64;
1148 f |= US_FL_IGNORE_RESIDUE;
1151 f |= US_FL_SINGLE_LUN;
1154 f |= US_FL_NO_WP_DETECT;
1156 /* Ignore unrecognized flag characters */
1159 quirks_end->fflags = f;
1163 /* Entries are separated by commas */
1168 } /* for (i = 0; ...) */
1171 static int __init usb_stor_init(void)
1175 printk(KERN_INFO "Initializing USB Mass Storage driver...\n");
1178 /* register the driver, return usb_register return code if error */
1179 retval = usb_register(&usb_storage_driver);
1181 printk(KERN_INFO "USB Mass Storage support registered.\n");
1182 usb_usual_set_present(USB_US_TYPE_STOR);
1187 static void __exit usb_stor_exit(void)
1189 US_DEBUGP("usb_stor_exit() called\n");
1191 /* Deregister the driver
1192 * This will cause disconnect() to be called for each
1195 US_DEBUGP("-- calling usb_deregister()\n");
1196 usb_deregister(&usb_storage_driver) ;
1198 usb_usual_clear_present(USB_US_TYPE_STOR);
1201 module_init(usb_stor_init);
1202 module_exit(usb_stor_exit);