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-2009 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_SDDR55
75 #ifdef CONFIG_USB_STORAGE_FREECOM
78 #ifdef CONFIG_USB_STORAGE_ISD200
81 #ifdef CONFIG_USB_STORAGE_DATAFAB
84 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
87 #ifdef CONFIG_USB_STORAGE_ONETOUCH
90 #ifdef CONFIG_USB_STORAGE_ALAUDA
93 #ifdef CONFIG_USB_STORAGE_KARMA
96 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
97 #include "cypress_atacb.h"
99 #include "sierra_ms.h"
100 #include "option_ms.h"
102 /* Some informational data */
103 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
104 MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
105 MODULE_LICENSE("GPL");
107 static unsigned int delay_use
= 5;
108 module_param(delay_use
, uint
, S_IRUGO
| S_IWUSR
);
109 MODULE_PARM_DESC(delay_use
, "seconds to delay before using a new device");
111 static char quirks
[128];
112 module_param_string(quirks
, quirks
, sizeof(quirks
), S_IRUGO
| S_IWUSR
);
113 MODULE_PARM_DESC(quirks
, "supplemental list of device IDs and their quirks");
117 * The entries in this table correspond, line for line,
118 * with the entries in usb_storage_usb_ids[], defined in usual-tables.c.
121 /* The vendor name should be kept at eight characters or less, and
122 * the product name should be kept at 16 characters or less. If a device
123 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
124 * normally generated by a device thorugh the INQUIRY response will be
125 * taken from this list, and this is the reason for the above size
126 * restriction. However, if the flag is not present, then you
127 * are free to use as many characters as you like.
130 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
131 vendor_name, product_name, use_protocol, use_transport, \
132 init_function, Flags) \
134 .vendorName = vendor_name, \
135 .productName = product_name, \
136 .useProtocol = use_protocol, \
137 .useTransport = use_transport, \
138 .initFunction = init_function, \
141 #define COMPLIANT_DEV UNUSUAL_DEV
143 #define USUAL_DEV(use_protocol, use_transport, use_type) \
145 .useProtocol = use_protocol, \
146 .useTransport = use_transport, \
149 static struct us_unusual_dev us_unusual_dev_list
[] = {
150 # include "unusual_devs.h"
151 { } /* Terminating entry */
159 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
161 int usb_stor_suspend(struct usb_interface
*iface
, pm_message_t message
)
163 struct us_data
*us
= usb_get_intfdata(iface
);
165 /* Wait until no command is running */
166 mutex_lock(&us
->dev_mutex
);
168 US_DEBUGP("%s\n", __func__
);
169 if (us
->suspend_resume_hook
)
170 (us
->suspend_resume_hook
)(us
, US_SUSPEND
);
172 /* When runtime PM is working, we'll set a flag to indicate
173 * whether we should autoresume when a SCSI request arrives. */
175 mutex_unlock(&us
->dev_mutex
);
178 EXPORT_SYMBOL_GPL(usb_stor_suspend
);
180 int usb_stor_resume(struct usb_interface
*iface
)
182 struct us_data
*us
= usb_get_intfdata(iface
);
184 mutex_lock(&us
->dev_mutex
);
186 US_DEBUGP("%s\n", __func__
);
187 if (us
->suspend_resume_hook
)
188 (us
->suspend_resume_hook
)(us
, US_RESUME
);
190 mutex_unlock(&us
->dev_mutex
);
193 EXPORT_SYMBOL_GPL(usb_stor_resume
);
195 int usb_stor_reset_resume(struct usb_interface
*iface
)
197 struct us_data
*us
= usb_get_intfdata(iface
);
199 US_DEBUGP("%s\n", __func__
);
201 /* Report the reset to the SCSI core */
202 usb_stor_report_bus_reset(us
);
204 /* FIXME: Notify the subdrivers that they need to reinitialize
208 EXPORT_SYMBOL_GPL(usb_stor_reset_resume
);
210 #endif /* CONFIG_PM */
213 * The next two routines get called just before and just after
214 * a USB port reset, whether from this driver or a different one.
217 int usb_stor_pre_reset(struct usb_interface
*iface
)
219 struct us_data
*us
= usb_get_intfdata(iface
);
221 US_DEBUGP("%s\n", __func__
);
223 /* Make sure no command runs during the reset */
224 mutex_lock(&us
->dev_mutex
);
227 EXPORT_SYMBOL_GPL(usb_stor_pre_reset
);
229 int usb_stor_post_reset(struct usb_interface
*iface
)
231 struct us_data
*us
= usb_get_intfdata(iface
);
233 US_DEBUGP("%s\n", __func__
);
235 /* Report the reset to the SCSI core */
236 usb_stor_report_bus_reset(us
);
238 /* FIXME: Notify the subdrivers that they need to reinitialize
241 mutex_unlock(&us
->dev_mutex
);
244 EXPORT_SYMBOL_GPL(usb_stor_post_reset
);
247 * fill_inquiry_response takes an unsigned char array (which must
248 * be at least 36 characters) and populates the vendor name,
249 * product name, and revision fields. Then the array is copied
250 * into the SCSI command's response buffer (oddly enough
251 * called request_buffer). data_len contains the length of the
252 * data array, which again must be at least 36.
255 void fill_inquiry_response(struct us_data
*us
, unsigned char *data
,
256 unsigned int data_len
)
258 if (data_len
<36) // You lose.
261 if(data
[0]&0x20) { /* USB device currently not connected. Return
262 peripheral qualifier 001b ("...however, the
263 physical device is not currently connected
264 to this logical unit") and leave vendor and
265 product identification empty. ("If the target
266 does store some of the INQUIRY data on the
267 device, it may return zeros or ASCII spaces
268 (20h) in those fields until the data is
269 available from the device."). */
272 u16 bcdDevice
= le16_to_cpu(us
->pusb_dev
->descriptor
.bcdDevice
);
273 memcpy(data
+8, us
->unusual_dev
->vendorName
,
274 strlen(us
->unusual_dev
->vendorName
) > 8 ? 8 :
275 strlen(us
->unusual_dev
->vendorName
));
276 memcpy(data
+16, us
->unusual_dev
->productName
,
277 strlen(us
->unusual_dev
->productName
) > 16 ? 16 :
278 strlen(us
->unusual_dev
->productName
));
279 data
[32] = 0x30 + ((bcdDevice
>>12) & 0x0F);
280 data
[33] = 0x30 + ((bcdDevice
>>8) & 0x0F);
281 data
[34] = 0x30 + ((bcdDevice
>>4) & 0x0F);
282 data
[35] = 0x30 + ((bcdDevice
) & 0x0F);
285 usb_stor_set_xfer_buf(data
, data_len
, us
->srb
);
287 EXPORT_SYMBOL_GPL(fill_inquiry_response
);
289 static int usb_stor_control_thread(void * __us
)
291 struct us_data
*us
= (struct us_data
*)__us
;
292 struct Scsi_Host
*host
= us_to_host(us
);
295 US_DEBUGP("*** thread sleeping.\n");
296 if (wait_for_completion_interruptible(&us
->cmnd_ready
))
299 US_DEBUGP("*** thread awakened.\n");
301 /* lock the device pointers */
302 mutex_lock(&(us
->dev_mutex
));
304 /* lock access to the state */
307 /* When we are called with no command pending, we're done */
308 if (us
->srb
== NULL
) {
310 mutex_unlock(&us
->dev_mutex
);
311 US_DEBUGP("-- exiting\n");
315 /* has the command timed out *already* ? */
316 if (test_bit(US_FLIDX_TIMED_OUT
, &us
->dflags
)) {
317 us
->srb
->result
= DID_ABORT
<< 16;
323 /* reject the command if the direction indicator
326 if (us
->srb
->sc_data_direction
== DMA_BIDIRECTIONAL
) {
327 US_DEBUGP("UNKNOWN data direction\n");
328 us
->srb
->result
= DID_ERROR
<< 16;
331 /* reject if target != 0 or if LUN is higher than
332 * the maximum known LUN
334 else if (us
->srb
->device
->id
&&
335 !(us
->fflags
& US_FL_SCM_MULT_TARG
)) {
336 US_DEBUGP("Bad target number (%d:%d)\n",
337 us
->srb
->device
->id
, us
->srb
->device
->lun
);
338 us
->srb
->result
= DID_BAD_TARGET
<< 16;
341 else if (us
->srb
->device
->lun
> us
->max_lun
) {
342 US_DEBUGP("Bad LUN (%d:%d)\n",
343 us
->srb
->device
->id
, us
->srb
->device
->lun
);
344 us
->srb
->result
= DID_BAD_TARGET
<< 16;
347 /* Handle those devices which need us to fake
348 * their inquiry data */
349 else if ((us
->srb
->cmnd
[0] == INQUIRY
) &&
350 (us
->fflags
& US_FL_FIX_INQUIRY
)) {
351 unsigned char data_ptr
[36] = {
352 0x00, 0x80, 0x02, 0x02,
353 0x1F, 0x00, 0x00, 0x00};
355 US_DEBUGP("Faking INQUIRY command\n");
356 fill_inquiry_response(us
, data_ptr
, 36);
357 us
->srb
->result
= SAM_STAT_GOOD
;
360 /* we've got a command, let's do it! */
362 US_DEBUG(usb_stor_show_command(us
->srb
));
363 us
->proto_handler(us
->srb
, us
);
366 /* lock access to the state */
369 /* indicate that the command is done */
370 if (us
->srb
->result
!= DID_ABORT
<< 16) {
371 US_DEBUGP("scsi cmd done, result=0x%x\n",
373 us
->srb
->scsi_done(us
->srb
);
376 US_DEBUGP("scsi command aborted\n");
379 /* If an abort request was received we need to signal that
380 * the abort has finished. The proper test for this is
381 * the TIMED_OUT flag, not srb->result == DID_ABORT, because
382 * the timeout might have occurred after the command had
383 * already completed with a different result code. */
384 if (test_bit(US_FLIDX_TIMED_OUT
, &us
->dflags
)) {
385 complete(&(us
->notify
));
387 /* Allow USB transfers to resume */
388 clear_bit(US_FLIDX_ABORTING
, &us
->dflags
);
389 clear_bit(US_FLIDX_TIMED_OUT
, &us
->dflags
);
392 /* finished working on this command */
396 /* unlock the device pointers */
397 mutex_unlock(&us
->dev_mutex
);
400 /* Wait until we are told to stop */
402 set_current_state(TASK_INTERRUPTIBLE
);
403 if (kthread_should_stop())
407 __set_current_state(TASK_RUNNING
);
411 /***********************************************************************
412 * Device probing and disconnecting
413 ***********************************************************************/
415 /* Associate our private data with the USB device */
416 static int associate_dev(struct us_data
*us
, struct usb_interface
*intf
)
418 US_DEBUGP("-- %s\n", __func__
);
420 /* Fill in the device-related fields */
421 us
->pusb_dev
= interface_to_usbdev(intf
);
422 us
->pusb_intf
= intf
;
423 us
->ifnum
= intf
->cur_altsetting
->desc
.bInterfaceNumber
;
424 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n",
425 le16_to_cpu(us
->pusb_dev
->descriptor
.idVendor
),
426 le16_to_cpu(us
->pusb_dev
->descriptor
.idProduct
),
427 le16_to_cpu(us
->pusb_dev
->descriptor
.bcdDevice
));
428 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n",
429 intf
->cur_altsetting
->desc
.bInterfaceSubClass
,
430 intf
->cur_altsetting
->desc
.bInterfaceProtocol
);
432 /* Store our private data in the interface */
433 usb_set_intfdata(intf
, us
);
435 /* Allocate the device-related DMA-mapped buffers */
436 us
->cr
= usb_buffer_alloc(us
->pusb_dev
, sizeof(*us
->cr
),
437 GFP_KERNEL
, &us
->cr_dma
);
439 US_DEBUGP("usb_ctrlrequest allocation failed\n");
443 us
->iobuf
= usb_buffer_alloc(us
->pusb_dev
, US_IOBUF_SIZE
,
444 GFP_KERNEL
, &us
->iobuf_dma
);
446 US_DEBUGP("I/O buffer allocation failed\n");
452 /* Works only for digits and letters, but small and fast */
453 #define TOLOWER(x) ((x) | 0x20)
455 /* Adjust device flags based on the "quirks=" module parameter */
456 static void adjust_quirks(struct us_data
*us
)
459 u16 vid
= le16_to_cpu(us
->pusb_dev
->descriptor
.idVendor
);
460 u16 pid
= le16_to_cpu(us
->pusb_dev
->descriptor
.idProduct
);
462 unsigned int mask
= (US_FL_SANE_SENSE
| US_FL_FIX_CAPACITY
|
463 US_FL_CAPACITY_HEURISTICS
| US_FL_IGNORE_DEVICE
|
464 US_FL_NOT_LOCKABLE
| US_FL_MAX_SECTORS_64
|
465 US_FL_CAPACITY_OK
| US_FL_IGNORE_RESIDUE
|
466 US_FL_SINGLE_LUN
| US_FL_NO_WP_DETECT
);
470 /* Each entry consists of VID:PID:flags */
471 if (vid
== simple_strtoul(p
, &p
, 16) &&
473 pid
== simple_strtoul(p
+1, &p
, 16) &&
477 /* Move forward to the next entry */
483 if (!*p
) /* No match */
486 /* Collect the flags */
487 while (*++p
&& *p
!= ',') {
488 switch (TOLOWER(*p
)) {
490 f
|= US_FL_SANE_SENSE
;
493 f
|= US_FL_FIX_CAPACITY
;
496 f
|= US_FL_CAPACITY_HEURISTICS
;
499 f
|= US_FL_IGNORE_DEVICE
;
502 f
|= US_FL_NOT_LOCKABLE
;
505 f
|= US_FL_MAX_SECTORS_64
;
508 f
|= US_FL_CAPACITY_OK
;
511 f
|= US_FL_IGNORE_RESIDUE
;
514 f
|= US_FL_SINGLE_LUN
;
517 f
|= US_FL_NO_WP_DETECT
;
519 /* Ignore unrecognized flag characters */
522 us
->fflags
= (us
->fflags
& ~mask
) | f
;
523 dev_info(&us
->pusb_intf
->dev
, "Quirks match for "
524 "vid %04x pid %04x: %x\n",
528 /* Get the unusual_devs entries and the string descriptors */
529 static int get_device_info(struct us_data
*us
, const struct usb_device_id
*id
,
530 struct us_unusual_dev
*unusual_dev
)
532 struct usb_device
*dev
= us
->pusb_dev
;
533 struct usb_interface_descriptor
*idesc
=
534 &us
->pusb_intf
->cur_altsetting
->desc
;
536 /* Store the entries */
537 us
->unusual_dev
= unusual_dev
;
538 us
->subclass
= (unusual_dev
->useProtocol
== US_SC_DEVICE
) ?
539 idesc
->bInterfaceSubClass
:
540 unusual_dev
->useProtocol
;
541 us
->protocol
= (unusual_dev
->useTransport
== US_PR_DEVICE
) ?
542 idesc
->bInterfaceProtocol
:
543 unusual_dev
->useTransport
;
544 us
->fflags
= USB_US_ORIG_FLAGS(id
->driver_info
);
547 if (us
->fflags
& US_FL_IGNORE_DEVICE
) {
548 printk(KERN_INFO USB_STORAGE
"device ignored\n");
553 * This flag is only needed when we're in high-speed, so let's
554 * disable it if we're in full-speed
556 if (dev
->speed
!= USB_SPEED_HIGH
)
557 us
->fflags
&= ~US_FL_GO_SLOW
;
559 /* Log a message if a non-generic unusual_dev entry contains an
560 * unnecessary subclass or protocol override. This may stimulate
561 * reports from users that will help us remove unneeded entries
562 * from the unusual_devs.h table.
564 if (id
->idVendor
|| id
->idProduct
) {
565 static const char *msgs
[3] = {
566 "an unneeded SubClass entry",
567 "an unneeded Protocol entry",
568 "unneeded SubClass and Protocol entries"};
569 struct usb_device_descriptor
*ddesc
= &dev
->descriptor
;
572 if (unusual_dev
->useProtocol
!= US_SC_DEVICE
&&
573 us
->subclass
== idesc
->bInterfaceSubClass
)
575 if (unusual_dev
->useTransport
!= US_PR_DEVICE
&&
576 us
->protocol
== idesc
->bInterfaceProtocol
)
578 if (msg
>= 0 && !(us
->fflags
& US_FL_NEED_OVERRIDE
))
579 printk(KERN_NOTICE USB_STORAGE
"This device "
580 "(%04x,%04x,%04x S %02x P %02x)"
581 " has %s in unusual_devs.h (kernel"
583 " Please send a copy of this message to "
584 "<linux-usb@vger.kernel.org> and "
585 "<usb-storage@lists.one-eyed-alien.net>\n",
586 le16_to_cpu(ddesc
->idVendor
),
587 le16_to_cpu(ddesc
->idProduct
),
588 le16_to_cpu(ddesc
->bcdDevice
),
589 idesc
->bInterfaceSubClass
,
590 idesc
->bInterfaceProtocol
,
598 /* Get the transport settings */
599 static void get_transport(struct us_data
*us
)
601 switch (us
->protocol
) {
603 us
->transport_name
= "Control/Bulk";
604 us
->transport
= usb_stor_CB_transport
;
605 us
->transport_reset
= usb_stor_CB_reset
;
610 us
->transport_name
= "Control/Bulk/Interrupt";
611 us
->transport
= usb_stor_CB_transport
;
612 us
->transport_reset
= usb_stor_CB_reset
;
617 us
->transport_name
= "Bulk";
618 us
->transport
= usb_stor_Bulk_transport
;
619 us
->transport_reset
= usb_stor_Bulk_reset
;
622 #ifdef CONFIG_USB_STORAGE_USBAT
624 us
->transport_name
= "Shuttle USBAT";
625 us
->transport
= usbat_transport
;
626 us
->transport_reset
= usb_stor_CB_reset
;
631 #ifdef CONFIG_USB_STORAGE_SDDR55
633 us
->transport_name
= "SDDR55";
634 us
->transport
= sddr55_transport
;
635 us
->transport_reset
= sddr55_reset
;
640 #ifdef CONFIG_USB_STORAGE_FREECOM
642 us
->transport_name
= "Freecom";
643 us
->transport
= freecom_transport
;
644 us
->transport_reset
= usb_stor_freecom_reset
;
649 #ifdef CONFIG_USB_STORAGE_DATAFAB
651 us
->transport_name
= "Datafab Bulk-Only";
652 us
->transport
= datafab_transport
;
653 us
->transport_reset
= usb_stor_Bulk_reset
;
658 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
660 us
->transport_name
= "Lexar Jumpshot Control/Bulk";
661 us
->transport
= jumpshot_transport
;
662 us
->transport_reset
= usb_stor_Bulk_reset
;
667 #ifdef CONFIG_USB_STORAGE_ALAUDA
669 us
->transport_name
= "Alauda Control/Bulk";
670 us
->transport
= alauda_transport
;
671 us
->transport_reset
= usb_stor_Bulk_reset
;
676 #ifdef CONFIG_USB_STORAGE_KARMA
678 us
->transport_name
= "Rio Karma/Bulk";
679 us
->transport
= rio_karma_transport
;
680 us
->transport_reset
= usb_stor_Bulk_reset
;
687 /* Get the protocol settings */
688 static void get_protocol(struct us_data
*us
)
690 switch (us
->subclass
) {
692 us
->protocol_name
= "Reduced Block Commands (RBC)";
693 us
->proto_handler
= usb_stor_transparent_scsi_command
;
697 us
->protocol_name
= "8020i";
698 us
->proto_handler
= usb_stor_pad12_command
;
703 us
->protocol_name
= "QIC-157";
704 us
->proto_handler
= usb_stor_pad12_command
;
709 us
->protocol_name
= "8070i";
710 us
->proto_handler
= usb_stor_pad12_command
;
715 us
->protocol_name
= "Transparent SCSI";
716 us
->proto_handler
= usb_stor_transparent_scsi_command
;
720 us
->protocol_name
= "Uniform Floppy Interface (UFI)";
721 us
->proto_handler
= usb_stor_ufi_command
;
724 #ifdef CONFIG_USB_STORAGE_ISD200
726 us
->protocol_name
= "ISD200 ATA/ATAPI";
727 us
->proto_handler
= isd200_ata_command
;
731 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
732 case US_SC_CYP_ATACB
:
733 us
->protocol_name
= "Transparent SCSI with Cypress ATACB";
734 us
->proto_handler
= cypress_atacb_passthrough
;
741 /* Get the pipe settings */
742 static int get_pipes(struct us_data
*us
)
744 struct usb_host_interface
*altsetting
=
745 us
->pusb_intf
->cur_altsetting
;
747 struct usb_endpoint_descriptor
*ep
;
748 struct usb_endpoint_descriptor
*ep_in
= NULL
;
749 struct usb_endpoint_descriptor
*ep_out
= NULL
;
750 struct usb_endpoint_descriptor
*ep_int
= NULL
;
753 * Find the first endpoint of each type we need.
754 * We are expecting a minimum of 2 endpoints - in and out (bulk).
755 * An optional interrupt-in is OK (necessary for CBI protocol).
756 * We will ignore any others.
758 for (i
= 0; i
< altsetting
->desc
.bNumEndpoints
; i
++) {
759 ep
= &altsetting
->endpoint
[i
].desc
;
761 if (usb_endpoint_xfer_bulk(ep
)) {
762 if (usb_endpoint_dir_in(ep
)) {
771 else if (usb_endpoint_is_int_in(ep
)) {
777 if (!ep_in
|| !ep_out
|| (us
->protocol
== US_PR_CBI
&& !ep_int
)) {
778 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
782 /* Calculate and store the pipe values */
783 us
->send_ctrl_pipe
= usb_sndctrlpipe(us
->pusb_dev
, 0);
784 us
->recv_ctrl_pipe
= usb_rcvctrlpipe(us
->pusb_dev
, 0);
785 us
->send_bulk_pipe
= usb_sndbulkpipe(us
->pusb_dev
,
786 usb_endpoint_num(ep_out
));
787 us
->recv_bulk_pipe
= usb_rcvbulkpipe(us
->pusb_dev
,
788 usb_endpoint_num(ep_in
));
790 us
->recv_intr_pipe
= usb_rcvintpipe(us
->pusb_dev
,
791 usb_endpoint_num(ep_int
));
792 us
->ep_bInterval
= ep_int
->bInterval
;
797 /* Initialize all the dynamic resources we need */
798 static int usb_stor_acquire_resources(struct us_data
*us
)
801 struct task_struct
*th
;
803 us
->current_urb
= usb_alloc_urb(0, GFP_KERNEL
);
804 if (!us
->current_urb
) {
805 US_DEBUGP("URB allocation failed\n");
809 /* Just before we start our control thread, initialize
810 * the device if it needs initialization */
811 if (us
->unusual_dev
->initFunction
) {
812 p
= us
->unusual_dev
->initFunction(us
);
817 /* Start up our control thread */
818 th
= kthread_run(usb_stor_control_thread
, us
, "usb-storage");
820 printk(KERN_WARNING USB_STORAGE
821 "Unable to start control thread\n");
829 /* Release all our dynamic resources */
830 static void usb_stor_release_resources(struct us_data
*us
)
832 US_DEBUGP("-- %s\n", __func__
);
834 /* Tell the control thread to exit. The SCSI host must
835 * already have been removed and the DISCONNECTING flag set
836 * so that we won't accept any more commands.
838 US_DEBUGP("-- sending exit command to thread\n");
839 complete(&us
->cmnd_ready
);
841 kthread_stop(us
->ctl_thread
);
843 /* Call the destructor routine, if it exists */
844 if (us
->extra_destructor
) {
845 US_DEBUGP("-- calling extra_destructor()\n");
846 us
->extra_destructor(us
->extra
);
849 /* Free the extra data and the URB */
851 usb_free_urb(us
->current_urb
);
854 /* Dissociate from the USB device */
855 static void dissociate_dev(struct us_data
*us
)
857 US_DEBUGP("-- %s\n", __func__
);
859 /* Free the device-related DMA-mapped buffers */
861 usb_buffer_free(us
->pusb_dev
, sizeof(*us
->cr
), us
->cr
,
864 usb_buffer_free(us
->pusb_dev
, US_IOBUF_SIZE
, us
->iobuf
,
867 /* Remove our private data from the interface */
868 usb_set_intfdata(us
->pusb_intf
, NULL
);
871 /* First stage of disconnect processing: stop SCSI scanning,
872 * remove the host, and stop accepting new commands
874 static void quiesce_and_remove_host(struct us_data
*us
)
876 struct Scsi_Host
*host
= us_to_host(us
);
878 /* If the device is really gone, cut short reset delays */
879 if (us
->pusb_dev
->state
== USB_STATE_NOTATTACHED
)
880 set_bit(US_FLIDX_DISCONNECTING
, &us
->dflags
);
882 /* Prevent SCSI-scanning (if it hasn't started yet)
883 * and wait for the SCSI-scanning thread to stop.
885 set_bit(US_FLIDX_DONT_SCAN
, &us
->dflags
);
886 wake_up(&us
->delay_wait
);
887 wait_for_completion(&us
->scanning_done
);
889 /* Removing the host will perform an orderly shutdown: caches
890 * synchronized, disks spun down, etc.
892 scsi_remove_host(host
);
894 /* Prevent any new commands from being accepted and cut short
898 set_bit(US_FLIDX_DISCONNECTING
, &us
->dflags
);
900 wake_up(&us
->delay_wait
);
903 /* Second stage of disconnect processing: deallocate all resources */
904 static void release_everything(struct us_data
*us
)
906 usb_stor_release_resources(us
);
909 /* Drop our reference to the host; the SCSI core will free it
910 * (and "us" along with it) when the refcount becomes 0. */
911 scsi_host_put(us_to_host(us
));
914 /* Thread to carry out delayed SCSI-device scanning */
915 static int usb_stor_scan_thread(void * __us
)
917 struct us_data
*us
= (struct us_data
*)__us
;
920 "usb-storage: device found at %d\n", us
->pusb_dev
->devnum
);
923 /* Wait for the timeout to expire or for a disconnect */
925 printk(KERN_DEBUG
"usb-storage: waiting for device "
926 "to settle before scanning\n");
927 wait_event_freezable_timeout(us
->delay_wait
,
928 test_bit(US_FLIDX_DONT_SCAN
, &us
->dflags
),
932 /* If the device is still connected, perform the scanning */
933 if (!test_bit(US_FLIDX_DONT_SCAN
, &us
->dflags
)) {
935 /* For bulk-only devices, determine the max LUN value */
936 if (us
->protocol
== US_PR_BULK
&&
937 !(us
->fflags
& US_FL_SINGLE_LUN
)) {
938 mutex_lock(&us
->dev_mutex
);
939 us
->max_lun
= usb_stor_Bulk_max_lun(us
);
940 mutex_unlock(&us
->dev_mutex
);
942 scsi_scan_host(us_to_host(us
));
943 printk(KERN_DEBUG
"usb-storage: device scan complete\n");
945 /* Should we unbind if no devices were detected? */
948 complete_and_exit(&us
->scanning_done
, 0);
952 /* First part of general USB mass-storage probing */
953 int usb_stor_probe1(struct us_data
**pus
,
954 struct usb_interface
*intf
,
955 const struct usb_device_id
*id
,
956 struct us_unusual_dev
*unusual_dev
)
958 struct Scsi_Host
*host
;
962 US_DEBUGP("USB Mass Storage device detected\n");
965 * Ask the SCSI layer to allocate a host structure, with extra
966 * space at the end for our private us_data structure.
968 host
= scsi_host_alloc(&usb_stor_host_template
, sizeof(*us
));
970 printk(KERN_WARNING USB_STORAGE
971 "Unable to allocate the scsi host\n");
976 * Allow 16-byte CDBs and thus > 2TB
978 host
->max_cmd_len
= 16;
979 *pus
= us
= host_to_us(host
);
980 memset(us
, 0, sizeof(struct us_data
));
981 mutex_init(&(us
->dev_mutex
));
982 init_completion(&us
->cmnd_ready
);
983 init_completion(&(us
->notify
));
984 init_waitqueue_head(&us
->delay_wait
);
985 init_completion(&us
->scanning_done
);
987 /* Associate the us_data structure with the USB device */
988 result
= associate_dev(us
, intf
);
992 /* Get the unusual_devs entries and the descriptors */
993 result
= get_device_info(us
, id
, unusual_dev
);
997 /* Get standard transport and protocol settings */
1001 /* Give the caller a chance to fill in specialized transport
1002 * or protocol settings.
1007 US_DEBUGP("storage_probe() failed\n");
1008 release_everything(us
);
1011 EXPORT_SYMBOL_GPL(usb_stor_probe1
);
1013 /* Second part of general USB mass-storage probing */
1014 int usb_stor_probe2(struct us_data
*us
)
1016 struct task_struct
*th
;
1019 /* Make sure the transport and protocol have both been set */
1020 if (!us
->transport
|| !us
->proto_handler
) {
1024 US_DEBUGP("Transport: %s\n", us
->transport_name
);
1025 US_DEBUGP("Protocol: %s\n", us
->protocol_name
);
1027 /* fix for single-lun devices */
1028 if (us
->fflags
& US_FL_SINGLE_LUN
)
1031 /* Find the endpoints and calculate pipe values */
1032 result
= get_pipes(us
);
1036 /* Acquire all the other resources and add the host */
1037 result
= usb_stor_acquire_resources(us
);
1040 result
= scsi_add_host(us_to_host(us
), &us
->pusb_intf
->dev
);
1042 printk(KERN_WARNING USB_STORAGE
1043 "Unable to add the scsi host\n");
1047 /* Start up the thread for delayed SCSI-device scanning */
1048 th
= kthread_create(usb_stor_scan_thread
, us
, "usb-stor-scan");
1050 printk(KERN_WARNING USB_STORAGE
1051 "Unable to start the device-scanning thread\n");
1052 complete(&us
->scanning_done
);
1053 quiesce_and_remove_host(us
);
1054 result
= PTR_ERR(th
);
1058 wake_up_process(th
);
1062 /* We come here if there are any problems */
1064 US_DEBUGP("storage_probe() failed\n");
1065 release_everything(us
);
1068 EXPORT_SYMBOL_GPL(usb_stor_probe2
);
1070 /* Handle a USB mass-storage disconnect */
1071 void usb_stor_disconnect(struct usb_interface
*intf
)
1073 struct us_data
*us
= usb_get_intfdata(intf
);
1075 US_DEBUGP("storage_disconnect() called\n");
1076 quiesce_and_remove_host(us
);
1077 release_everything(us
);
1079 EXPORT_SYMBOL_GPL(usb_stor_disconnect
);
1081 /* The main probe routine for standard devices */
1082 static int storage_probe(struct usb_interface
*intf
,
1083 const struct usb_device_id
*id
)
1089 * If libusual is configured, let it decide whether a standard
1090 * device should be handled by usb-storage or by ub.
1091 * If the device isn't standard (is handled by a subdriver
1092 * module) then don't accept it.
1094 if (usb_usual_check_type(id
, USB_US_TYPE_STOR
) ||
1095 usb_usual_ignore_device(intf
))
1099 * Call the general probe procedures.
1101 * The unusual_dev_list array is parallel to the usb_storage_usb_ids
1102 * table, so we use the index of the id entry to find the
1103 * corresponding unusual_devs entry.
1105 result
= usb_stor_probe1(&us
, intf
, id
,
1106 (id
- usb_storage_usb_ids
) + us_unusual_dev_list
);
1110 /* No special transport or protocol settings in the main module */
1112 result
= usb_stor_probe2(us
);
1116 /***********************************************************************
1117 * Initialization and registration
1118 ***********************************************************************/
1120 static struct usb_driver usb_storage_driver
= {
1121 .name
= "usb-storage",
1122 .probe
= storage_probe
,
1123 .disconnect
= usb_stor_disconnect
,
1124 .suspend
= usb_stor_suspend
,
1125 .resume
= usb_stor_resume
,
1126 .reset_resume
= usb_stor_reset_resume
,
1127 .pre_reset
= usb_stor_pre_reset
,
1128 .post_reset
= usb_stor_post_reset
,
1129 .id_table
= usb_storage_usb_ids
,
1133 static int __init
usb_stor_init(void)
1137 printk(KERN_INFO
"Initializing USB Mass Storage driver...\n");
1139 /* register the driver, return usb_register return code if error */
1140 retval
= usb_register(&usb_storage_driver
);
1142 printk(KERN_INFO
"USB Mass Storage support registered.\n");
1143 usb_usual_set_present(USB_US_TYPE_STOR
);
1148 static void __exit
usb_stor_exit(void)
1150 US_DEBUGP("usb_stor_exit() called\n");
1152 /* Deregister the driver
1153 * This will cause disconnect() to be called for each
1156 US_DEBUGP("-- calling usb_deregister()\n");
1157 usb_deregister(&usb_storage_driver
) ;
1159 usb_usual_clear_present(USB_US_TYPE_STOR
);
1162 module_init(usb_stor_init
);
1163 module_exit(usb_stor_exit
);