1 /* Driver for USB Mass Storage compliant devices
3 * $Id: usb.c,v 1.75 2002/04/22 03:39:43 mdharm Exp $
5 * Current development and maintenance by:
6 * (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
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)
13 * (c) 1999 Michael Gee (michael@linuxspecific.com)
15 * usb_device_id support by Adam J. Richter (adam@yggdrasil.com):
16 * (c) 2000 Yggdrasil Computing, Inc.
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.
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.
29 * Also, for certain devices, the interrupt endpoint is used to convey
30 * status of a command.
32 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
33 * information about this driver.
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
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.
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.
50 #include <linux/sched.h>
51 #include <linux/errno.h>
52 #include <linux/suspend.h>
53 #include <linux/module.h>
54 #include <linux/init.h>
55 #include <linux/slab.h>
56 #include <linux/kthread.h>
57 #include <linux/mutex.h>
59 #include <scsi/scsi.h>
60 #include <scsi/scsi_cmnd.h>
61 #include <scsi/scsi_device.h>
65 #include "transport.h"
68 #include "initializers.h"
70 #ifdef CONFIG_USB_STORAGE_USBAT
71 #include "shuttle_usbat.h"
73 #ifdef CONFIG_USB_STORAGE_SDDR09
76 #ifdef CONFIG_USB_STORAGE_SDDR55
79 #ifdef CONFIG_USB_STORAGE_DPCM
82 #ifdef CONFIG_USB_STORAGE_FREECOM
85 #ifdef CONFIG_USB_STORAGE_ISD200
88 #ifdef CONFIG_USB_STORAGE_DATAFAB
91 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
94 #ifdef CONFIG_USB_STORAGE_ONETOUCH
97 #ifdef CONFIG_USB_STORAGE_ALAUDA
101 /* Some informational data */
102 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
103 MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
104 MODULE_LICENSE("GPL");
106 static unsigned int delay_use
= 5;
107 module_param(delay_use
, uint
, S_IRUGO
| S_IWUSR
);
108 MODULE_PARM_DESC(delay_use
, "seconds to delay before using a new device");
111 /* These are used to make sure the module doesn't unload before all the
112 * threads have exited.
114 static atomic_t total_threads
= ATOMIC_INIT(0);
115 static DECLARE_COMPLETION(threads_gone
);
119 * The entries in this table correspond, line for line,
120 * with the entries of us_unusual_dev_list[].
122 #ifndef CONFIG_USB_LIBUSUAL
124 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
125 vendorName, productName,useProtocol, useTransport, \
126 initFunction, flags) \
127 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \
128 .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
130 #define USUAL_DEV(useProto, useTrans, useType) \
131 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
132 .driver_info = (USB_US_TYPE_STOR<<24) }
134 static struct usb_device_id storage_usb_ids
[] = {
136 # include "unusual_devs.h"
139 /* Terminating entry */
143 MODULE_DEVICE_TABLE (usb
, storage_usb_ids
);
144 #endif /* CONFIG_USB_LIBUSUAL */
146 /* This is the list of devices we recognize, along with their flag data */
148 /* The vendor name should be kept at eight characters or less, and
149 * the product name should be kept at 16 characters or less. If a device
150 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
151 * normally generated by a device thorugh the INQUIRY response will be
152 * taken from this list, and this is the reason for the above size
153 * restriction. However, if the flag is not present, then you
154 * are free to use as many characters as you like.
157 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
158 vendor_name, product_name, use_protocol, use_transport, \
159 init_function, Flags) \
161 .vendorName = vendor_name, \
162 .productName = product_name, \
163 .useProtocol = use_protocol, \
164 .useTransport = use_transport, \
165 .initFunction = init_function, \
168 #define USUAL_DEV(use_protocol, use_transport, use_type) \
170 .useProtocol = use_protocol, \
171 .useTransport = use_transport, \
174 static struct us_unusual_dev us_unusual_dev_list
[] = {
175 # include "unusual_devs.h"
179 /* Terminating entry */
184 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
186 static int storage_suspend(struct usb_interface
*iface
, pm_message_t message
)
188 struct us_data
*us
= usb_get_intfdata(iface
);
190 /* Wait until no command is running */
191 mutex_lock(&us
->dev_mutex
);
193 US_DEBUGP("%s\n", __FUNCTION__
);
194 if (us
->suspend_resume_hook
)
195 (us
->suspend_resume_hook
)(us
, US_SUSPEND
);
196 iface
->dev
.power
.power_state
.event
= message
.event
;
198 /* When runtime PM is working, we'll set a flag to indicate
199 * whether we should autoresume when a SCSI request arrives. */
201 mutex_unlock(&us
->dev_mutex
);
205 static int storage_resume(struct usb_interface
*iface
)
207 struct us_data
*us
= usb_get_intfdata(iface
);
209 mutex_lock(&us
->dev_mutex
);
211 US_DEBUGP("%s\n", __FUNCTION__
);
212 if (us
->suspend_resume_hook
)
213 (us
->suspend_resume_hook
)(us
, US_RESUME
);
214 iface
->dev
.power
.power_state
.event
= PM_EVENT_ON
;
216 mutex_unlock(&us
->dev_mutex
);
220 #endif /* CONFIG_PM */
223 * The next two routines get called just before and just after
224 * a USB port reset, whether from this driver or a different one.
227 static void storage_pre_reset(struct usb_interface
*iface
)
229 struct us_data
*us
= usb_get_intfdata(iface
);
231 US_DEBUGP("%s\n", __FUNCTION__
);
233 /* Make sure no command runs during the reset */
234 mutex_lock(&us
->dev_mutex
);
237 static void storage_post_reset(struct usb_interface
*iface
)
239 struct us_data
*us
= usb_get_intfdata(iface
);
241 US_DEBUGP("%s\n", __FUNCTION__
);
243 /* Report the reset to the SCSI core */
244 scsi_lock(us_to_host(us
));
245 usb_stor_report_bus_reset(us
);
246 scsi_unlock(us_to_host(us
));
248 /* FIXME: Notify the subdrivers that they need to reinitialize
250 mutex_unlock(&us
->dev_mutex
);
254 * fill_inquiry_response takes an unsigned char array (which must
255 * be at least 36 characters) and populates the vendor name,
256 * product name, and revision fields. Then the array is copied
257 * into the SCSI command's response buffer (oddly enough
258 * called request_buffer). data_len contains the length of the
259 * data array, which again must be at least 36.
262 void fill_inquiry_response(struct us_data
*us
, unsigned char *data
,
263 unsigned int data_len
)
265 if (data_len
<36) // You lose.
268 if(data
[0]&0x20) { /* USB device currently not connected. Return
269 peripheral qualifier 001b ("...however, the
270 physical device is not currently connected
271 to this logical unit") and leave vendor and
272 product identification empty. ("If the target
273 does store some of the INQUIRY data on the
274 device, it may return zeros or ASCII spaces
275 (20h) in those fields until the data is
276 available from the device."). */
279 u16 bcdDevice
= le16_to_cpu(us
->pusb_dev
->descriptor
.bcdDevice
);
280 memcpy(data
+8, us
->unusual_dev
->vendorName
,
281 strlen(us
->unusual_dev
->vendorName
) > 8 ? 8 :
282 strlen(us
->unusual_dev
->vendorName
));
283 memcpy(data
+16, us
->unusual_dev
->productName
,
284 strlen(us
->unusual_dev
->productName
) > 16 ? 16 :
285 strlen(us
->unusual_dev
->productName
));
286 data
[32] = 0x30 + ((bcdDevice
>>12) & 0x0F);
287 data
[33] = 0x30 + ((bcdDevice
>>8) & 0x0F);
288 data
[34] = 0x30 + ((bcdDevice
>>4) & 0x0F);
289 data
[35] = 0x30 + ((bcdDevice
) & 0x0F);
292 usb_stor_set_xfer_buf(data
, data_len
, us
->srb
);
295 static int usb_stor_control_thread(void * __us
)
297 struct us_data
*us
= (struct us_data
*)__us
;
298 struct Scsi_Host
*host
= us_to_host(us
);
300 current
->flags
|= PF_NOFREEZE
;
303 US_DEBUGP("*** thread sleeping.\n");
304 if(down_interruptible(&us
->sema
))
307 US_DEBUGP("*** thread awakened.\n");
309 /* lock the device pointers */
310 mutex_lock(&(us
->dev_mutex
));
312 /* if the device has disconnected, we are free to exit */
313 if (test_bit(US_FLIDX_DISCONNECTING
, &us
->flags
)) {
314 US_DEBUGP("-- exiting\n");
315 mutex_unlock(&us
->dev_mutex
);
319 /* lock access to the state */
322 /* has the command timed out *already* ? */
323 if (test_bit(US_FLIDX_TIMED_OUT
, &us
->flags
)) {
324 us
->srb
->result
= DID_ABORT
<< 16;
330 /* reject the command if the direction indicator
333 if (us
->srb
->sc_data_direction
== DMA_BIDIRECTIONAL
) {
334 US_DEBUGP("UNKNOWN data direction\n");
335 us
->srb
->result
= DID_ERROR
<< 16;
338 /* reject if target != 0 or if LUN is higher than
339 * the maximum known LUN
341 else if (us
->srb
->device
->id
&&
342 !(us
->flags
& US_FL_SCM_MULT_TARG
)) {
343 US_DEBUGP("Bad target number (%d:%d)\n",
344 us
->srb
->device
->id
, us
->srb
->device
->lun
);
345 us
->srb
->result
= DID_BAD_TARGET
<< 16;
348 else if (us
->srb
->device
->lun
> us
->max_lun
) {
349 US_DEBUGP("Bad LUN (%d:%d)\n",
350 us
->srb
->device
->id
, us
->srb
->device
->lun
);
351 us
->srb
->result
= DID_BAD_TARGET
<< 16;
354 /* Handle those devices which need us to fake
355 * their inquiry data */
356 else if ((us
->srb
->cmnd
[0] == INQUIRY
) &&
357 (us
->flags
& US_FL_FIX_INQUIRY
)) {
358 unsigned char data_ptr
[36] = {
359 0x00, 0x80, 0x02, 0x02,
360 0x1F, 0x00, 0x00, 0x00};
362 US_DEBUGP("Faking INQUIRY command\n");
363 fill_inquiry_response(us
, data_ptr
, 36);
364 us
->srb
->result
= SAM_STAT_GOOD
;
367 /* we've got a command, let's do it! */
369 US_DEBUG(usb_stor_show_command(us
->srb
));
370 us
->proto_handler(us
->srb
, us
);
373 /* lock access to the state */
376 /* indicate that the command is done */
377 if (us
->srb
->result
!= DID_ABORT
<< 16) {
378 US_DEBUGP("scsi cmd done, result=0x%x\n",
380 us
->srb
->scsi_done(us
->srb
);
383 US_DEBUGP("scsi command aborted\n");
386 /* If an abort request was received we need to signal that
387 * the abort has finished. The proper test for this is
388 * the TIMED_OUT flag, not srb->result == DID_ABORT, because
389 * the timeout might have occurred after the command had
390 * already completed with a different result code. */
391 if (test_bit(US_FLIDX_TIMED_OUT
, &us
->flags
)) {
392 complete(&(us
->notify
));
394 /* Allow USB transfers to resume */
395 clear_bit(US_FLIDX_ABORTING
, &us
->flags
);
396 clear_bit(US_FLIDX_TIMED_OUT
, &us
->flags
);
399 /* finished working on this command */
403 /* unlock the device pointers */
404 mutex_unlock(&us
->dev_mutex
);
409 /* notify the exit routine that we're actually exiting now
411 * complete()/wait_for_completion() is similar to up()/down(),
412 * except that complete() is safe in the case where the structure
413 * is getting deleted in a parallel mode of execution (i.e. just
414 * after the down() -- that's necessary for the thread-shutdown
417 * complete_and_exit() goes even further than this -- it is safe in
418 * the case that the thread of the caller is going away (not just
419 * the structure) -- this is necessary for the module-remove case.
420 * This is important in preemption kernels, which transfer the flow
421 * of execution immediately upon a complete().
423 complete_and_exit(&threads_gone
, 0);
426 /***********************************************************************
427 * Device probing and disconnecting
428 ***********************************************************************/
430 /* Associate our private data with the USB device */
431 static int associate_dev(struct us_data
*us
, struct usb_interface
*intf
)
433 US_DEBUGP("-- %s\n", __FUNCTION__
);
435 /* Fill in the device-related fields */
436 us
->pusb_dev
= interface_to_usbdev(intf
);
437 us
->pusb_intf
= intf
;
438 us
->ifnum
= intf
->cur_altsetting
->desc
.bInterfaceNumber
;
439 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n",
440 le16_to_cpu(us
->pusb_dev
->descriptor
.idVendor
),
441 le16_to_cpu(us
->pusb_dev
->descriptor
.idProduct
),
442 le16_to_cpu(us
->pusb_dev
->descriptor
.bcdDevice
));
443 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n",
444 intf
->cur_altsetting
->desc
.bInterfaceSubClass
,
445 intf
->cur_altsetting
->desc
.bInterfaceProtocol
);
447 /* Store our private data in the interface */
448 usb_set_intfdata(intf
, us
);
450 /* Allocate the device-related DMA-mapped buffers */
451 us
->cr
= usb_buffer_alloc(us
->pusb_dev
, sizeof(*us
->cr
),
452 GFP_KERNEL
, &us
->cr_dma
);
454 US_DEBUGP("usb_ctrlrequest allocation failed\n");
458 us
->iobuf
= usb_buffer_alloc(us
->pusb_dev
, US_IOBUF_SIZE
,
459 GFP_KERNEL
, &us
->iobuf_dma
);
461 US_DEBUGP("I/O buffer allocation failed\n");
465 us
->sensebuf
= kmalloc(US_SENSE_SIZE
, GFP_KERNEL
);
467 US_DEBUGP("Sense buffer allocation failed\n");
473 /* Find an unusual_dev descriptor (always succeeds in the current code) */
474 static struct us_unusual_dev
*find_unusual(const struct usb_device_id
*id
)
476 const int id_index
= id
- storage_usb_ids
;
477 return &us_unusual_dev_list
[id_index
];
480 /* Get the unusual_devs entries and the string descriptors */
481 static void get_device_info(struct us_data
*us
, const struct usb_device_id
*id
)
483 struct usb_device
*dev
= us
->pusb_dev
;
484 struct usb_interface_descriptor
*idesc
=
485 &us
->pusb_intf
->cur_altsetting
->desc
;
486 struct us_unusual_dev
*unusual_dev
= find_unusual(id
);
488 /* Store the entries */
489 us
->unusual_dev
= unusual_dev
;
490 us
->subclass
= (unusual_dev
->useProtocol
== US_SC_DEVICE
) ?
491 idesc
->bInterfaceSubClass
:
492 unusual_dev
->useProtocol
;
493 us
->protocol
= (unusual_dev
->useTransport
== US_PR_DEVICE
) ?
494 idesc
->bInterfaceProtocol
:
495 unusual_dev
->useTransport
;
496 us
->flags
= USB_US_ORIG_FLAGS(id
->driver_info
);
499 * This flag is only needed when we're in high-speed, so let's
500 * disable it if we're in full-speed
502 if (dev
->speed
!= USB_SPEED_HIGH
)
503 us
->flags
&= ~US_FL_GO_SLOW
;
505 /* Log a message if a non-generic unusual_dev entry contains an
506 * unnecessary subclass or protocol override. This may stimulate
507 * reports from users that will help us remove unneeded entries
508 * from the unusual_devs.h table.
510 if (id
->idVendor
|| id
->idProduct
) {
511 static const char *msgs
[3] = {
512 "an unneeded SubClass entry",
513 "an unneeded Protocol entry",
514 "unneeded SubClass and Protocol entries"};
515 struct usb_device_descriptor
*ddesc
= &dev
->descriptor
;
518 if (unusual_dev
->useProtocol
!= US_SC_DEVICE
&&
519 us
->subclass
== idesc
->bInterfaceSubClass
)
521 if (unusual_dev
->useTransport
!= US_PR_DEVICE
&&
522 us
->protocol
== idesc
->bInterfaceProtocol
)
524 if (msg
>= 0 && !(us
->flags
& US_FL_NEED_OVERRIDE
))
525 printk(KERN_NOTICE USB_STORAGE
"This device "
526 "(%04x,%04x,%04x S %02x P %02x)"
527 " has %s in unusual_devs.h\n"
528 " Please send a copy of this message to "
529 "<linux-usb-devel@lists.sourceforge.net>\n",
530 le16_to_cpu(ddesc
->idVendor
),
531 le16_to_cpu(ddesc
->idProduct
),
532 le16_to_cpu(ddesc
->bcdDevice
),
533 idesc
->bInterfaceSubClass
,
534 idesc
->bInterfaceProtocol
,
539 /* Get the transport settings */
540 static int get_transport(struct us_data
*us
)
542 switch (us
->protocol
) {
544 us
->transport_name
= "Control/Bulk";
545 us
->transport
= usb_stor_CB_transport
;
546 us
->transport_reset
= usb_stor_CB_reset
;
551 us
->transport_name
= "Control/Bulk/Interrupt";
552 us
->transport
= usb_stor_CBI_transport
;
553 us
->transport_reset
= usb_stor_CB_reset
;
558 us
->transport_name
= "Bulk";
559 us
->transport
= usb_stor_Bulk_transport
;
560 us
->transport_reset
= usb_stor_Bulk_reset
;
563 #ifdef CONFIG_USB_STORAGE_USBAT
565 us
->transport_name
= "Shuttle USBAT";
566 us
->transport
= usbat_transport
;
567 us
->transport_reset
= usb_stor_CB_reset
;
572 #ifdef CONFIG_USB_STORAGE_SDDR09
573 case US_PR_EUSB_SDDR09
:
574 us
->transport_name
= "EUSB/SDDR09";
575 us
->transport
= sddr09_transport
;
576 us
->transport_reset
= usb_stor_CB_reset
;
581 #ifdef CONFIG_USB_STORAGE_SDDR55
583 us
->transport_name
= "SDDR55";
584 us
->transport
= sddr55_transport
;
585 us
->transport_reset
= sddr55_reset
;
590 #ifdef CONFIG_USB_STORAGE_DPCM
592 us
->transport_name
= "Control/Bulk-EUSB/SDDR09";
593 us
->transport
= dpcm_transport
;
594 us
->transport_reset
= usb_stor_CB_reset
;
599 #ifdef CONFIG_USB_STORAGE_FREECOM
601 us
->transport_name
= "Freecom";
602 us
->transport
= freecom_transport
;
603 us
->transport_reset
= usb_stor_freecom_reset
;
608 #ifdef CONFIG_USB_STORAGE_DATAFAB
610 us
->transport_name
= "Datafab Bulk-Only";
611 us
->transport
= datafab_transport
;
612 us
->transport_reset
= usb_stor_Bulk_reset
;
617 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
619 us
->transport_name
= "Lexar Jumpshot Control/Bulk";
620 us
->transport
= jumpshot_transport
;
621 us
->transport_reset
= usb_stor_Bulk_reset
;
626 #ifdef CONFIG_USB_STORAGE_ALAUDA
628 us
->transport_name
= "Alauda Control/Bulk";
629 us
->transport
= alauda_transport
;
630 us
->transport_reset
= usb_stor_Bulk_reset
;
638 US_DEBUGP("Transport: %s\n", us
->transport_name
);
640 /* fix for single-lun devices */
641 if (us
->flags
& US_FL_SINGLE_LUN
)
646 /* Get the protocol settings */
647 static int get_protocol(struct us_data
*us
)
649 switch (us
->subclass
) {
651 us
->protocol_name
= "Reduced Block Commands (RBC)";
652 us
->proto_handler
= usb_stor_transparent_scsi_command
;
656 us
->protocol_name
= "8020i";
657 us
->proto_handler
= usb_stor_ATAPI_command
;
662 us
->protocol_name
= "QIC-157";
663 us
->proto_handler
= usb_stor_qic157_command
;
668 us
->protocol_name
= "8070i";
669 us
->proto_handler
= usb_stor_ATAPI_command
;
674 us
->protocol_name
= "Transparent SCSI";
675 us
->proto_handler
= usb_stor_transparent_scsi_command
;
679 us
->protocol_name
= "Uniform Floppy Interface (UFI)";
680 us
->proto_handler
= usb_stor_ufi_command
;
683 #ifdef CONFIG_USB_STORAGE_ISD200
685 us
->protocol_name
= "ISD200 ATA/ATAPI";
686 us
->proto_handler
= isd200_ata_command
;
693 US_DEBUGP("Protocol: %s\n", us
->protocol_name
);
697 /* Get the pipe settings */
698 static int get_pipes(struct us_data
*us
)
700 struct usb_host_interface
*altsetting
=
701 us
->pusb_intf
->cur_altsetting
;
703 struct usb_endpoint_descriptor
*ep
;
704 struct usb_endpoint_descriptor
*ep_in
= NULL
;
705 struct usb_endpoint_descriptor
*ep_out
= NULL
;
706 struct usb_endpoint_descriptor
*ep_int
= NULL
;
709 * Find the endpoints we need.
710 * We are expecting a minimum of 2 endpoints - in and out (bulk).
711 * An optional interrupt is OK (necessary for CBI protocol).
712 * We will ignore any others.
714 for (i
= 0; i
< altsetting
->desc
.bNumEndpoints
; i
++) {
715 ep
= &altsetting
->endpoint
[i
].desc
;
717 /* Is it a BULK endpoint? */
718 if ((ep
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
719 == USB_ENDPOINT_XFER_BULK
) {
720 /* BULK in or out? */
721 if (ep
->bEndpointAddress
& USB_DIR_IN
)
727 /* Is it an interrupt endpoint? */
728 else if ((ep
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
)
729 == USB_ENDPOINT_XFER_INT
) {
734 if (!ep_in
|| !ep_out
|| (us
->protocol
== US_PR_CBI
&& !ep_int
)) {
735 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
739 /* Calculate and store the pipe values */
740 us
->send_ctrl_pipe
= usb_sndctrlpipe(us
->pusb_dev
, 0);
741 us
->recv_ctrl_pipe
= usb_rcvctrlpipe(us
->pusb_dev
, 0);
742 us
->send_bulk_pipe
= usb_sndbulkpipe(us
->pusb_dev
,
743 ep_out
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
744 us
->recv_bulk_pipe
= usb_rcvbulkpipe(us
->pusb_dev
,
745 ep_in
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
747 us
->recv_intr_pipe
= usb_rcvintpipe(us
->pusb_dev
,
748 ep_int
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
749 us
->ep_bInterval
= ep_int
->bInterval
;
754 /* Initialize all the dynamic resources we need */
755 static int usb_stor_acquire_resources(struct us_data
*us
)
758 struct task_struct
*th
;
760 us
->current_urb
= usb_alloc_urb(0, GFP_KERNEL
);
761 if (!us
->current_urb
) {
762 US_DEBUGP("URB allocation failed\n");
766 /* Just before we start our control thread, initialize
767 * the device if it needs initialization */
768 if (us
->unusual_dev
->initFunction
) {
769 p
= us
->unusual_dev
->initFunction(us
);
774 /* Start up our control thread */
775 th
= kthread_create(usb_stor_control_thread
, us
, "usb-storage");
777 printk(KERN_WARNING USB_STORAGE
778 "Unable to start control thread\n");
782 /* Take a reference to the host for the control thread and
783 * count it among all the threads we have launched. Then
785 scsi_host_get(us_to_host(us
));
786 atomic_inc(&total_threads
);
792 /* Release all our dynamic resources */
793 static void usb_stor_release_resources(struct us_data
*us
)
795 US_DEBUGP("-- %s\n", __FUNCTION__
);
797 /* Tell the control thread to exit. The SCSI host must
798 * already have been removed so it won't try to queue
801 US_DEBUGP("-- sending exit command to thread\n");
802 set_bit(US_FLIDX_DISCONNECTING
, &us
->flags
);
805 /* Call the destructor routine, if it exists */
806 if (us
->extra_destructor
) {
807 US_DEBUGP("-- calling extra_destructor()\n");
808 us
->extra_destructor(us
->extra
);
811 /* Free the extra data and the URB */
813 usb_free_urb(us
->current_urb
);
816 /* Dissociate from the USB device */
817 static void dissociate_dev(struct us_data
*us
)
819 US_DEBUGP("-- %s\n", __FUNCTION__
);
823 /* Free the device-related DMA-mapped buffers */
825 usb_buffer_free(us
->pusb_dev
, sizeof(*us
->cr
), us
->cr
,
828 usb_buffer_free(us
->pusb_dev
, US_IOBUF_SIZE
, us
->iobuf
,
831 /* Remove our private data from the interface */
832 usb_set_intfdata(us
->pusb_intf
, NULL
);
835 /* First stage of disconnect processing: stop all commands and remove
837 static void quiesce_and_remove_host(struct us_data
*us
)
839 /* Prevent new USB transfers, stop the current command, and
840 * interrupt a SCSI-scan or device-reset delay */
841 set_bit(US_FLIDX_DISCONNECTING
, &us
->flags
);
842 usb_stor_stop_transport(us
);
843 wake_up(&us
->delay_wait
);
845 /* It doesn't matter if the SCSI-scanning thread is still running.
846 * The thread will exit when it sees the DISCONNECTING flag. */
848 /* Wait for the current command to finish, then remove the host */
849 mutex_lock(&us
->dev_mutex
);
850 mutex_unlock(&us
->dev_mutex
);
852 /* queuecommand won't accept any new commands and the control
853 * thread won't execute a previously-queued command. If there
854 * is such a command pending, complete it with an error. */
856 us
->srb
->result
= DID_NO_CONNECT
<< 16;
857 scsi_lock(us_to_host(us
));
858 us
->srb
->scsi_done(us
->srb
);
860 scsi_unlock(us_to_host(us
));
863 /* Now we own no commands so it's safe to remove the SCSI host */
864 scsi_remove_host(us_to_host(us
));
867 /* Second stage of disconnect processing: deallocate all resources */
868 static void release_everything(struct us_data
*us
)
870 usb_stor_release_resources(us
);
873 /* Drop our reference to the host; the SCSI core will free it
874 * (and "us" along with it) when the refcount becomes 0. */
875 scsi_host_put(us_to_host(us
));
878 /* Thread to carry out delayed SCSI-device scanning */
879 static int usb_stor_scan_thread(void * __us
)
881 struct us_data
*us
= (struct us_data
*)__us
;
884 "usb-storage: device found at %d\n", us
->pusb_dev
->devnum
);
886 /* Wait for the timeout to expire or for a disconnect */
888 printk(KERN_DEBUG
"usb-storage: waiting for device "
889 "to settle before scanning\n");
891 wait_event_interruptible_timeout(us
->delay_wait
,
892 test_bit(US_FLIDX_DISCONNECTING
, &us
->flags
),
898 /* If the device is still connected, perform the scanning */
899 if (!test_bit(US_FLIDX_DISCONNECTING
, &us
->flags
)) {
901 /* For bulk-only devices, determine the max LUN value */
902 if (us
->protocol
== US_PR_BULK
&&
903 !(us
->flags
& US_FL_SINGLE_LUN
)) {
904 mutex_lock(&us
->dev_mutex
);
905 us
->max_lun
= usb_stor_Bulk_max_lun(us
);
906 mutex_unlock(&us
->dev_mutex
);
908 scsi_scan_host(us_to_host(us
));
909 printk(KERN_DEBUG
"usb-storage: device scan complete\n");
911 /* Should we unbind if no devices were detected? */
914 scsi_host_put(us_to_host(us
));
915 complete_and_exit(&threads_gone
, 0);
919 /* Probe to see if we can drive a newly-connected USB device */
920 static int storage_probe(struct usb_interface
*intf
,
921 const struct usb_device_id
*id
)
923 struct Scsi_Host
*host
;
926 struct task_struct
*th
;
928 if (usb_usual_check_type(id
, USB_US_TYPE_STOR
))
931 US_DEBUGP("USB Mass Storage device detected\n");
934 * Ask the SCSI layer to allocate a host structure, with extra
935 * space at the end for our private us_data structure.
937 host
= scsi_host_alloc(&usb_stor_host_template
, sizeof(*us
));
939 printk(KERN_WARNING USB_STORAGE
940 "Unable to allocate the scsi host\n");
944 us
= host_to_us(host
);
945 memset(us
, 0, sizeof(struct us_data
));
946 mutex_init(&(us
->dev_mutex
));
947 init_MUTEX_LOCKED(&(us
->sema
));
948 init_completion(&(us
->notify
));
949 init_waitqueue_head(&us
->delay_wait
);
951 /* Associate the us_data structure with the USB device */
952 result
= associate_dev(us
, intf
);
957 * Get the unusual_devs entries and the descriptors
959 * id_index is calculated in the declaration to be the index number
960 * of the match from the usb_device_id table, so we can find the
961 * corresponding entry in the private table.
963 get_device_info(us
, id
);
965 /* Get the transport, protocol, and pipe settings */
966 result
= get_transport(us
);
969 result
= get_protocol(us
);
972 result
= get_pipes(us
);
976 /* Acquire all the other resources and add the host */
977 result
= usb_stor_acquire_resources(us
);
980 result
= scsi_add_host(host
, &intf
->dev
);
982 printk(KERN_WARNING USB_STORAGE
983 "Unable to add the scsi host\n");
987 /* Start up the thread for delayed SCSI-device scanning */
988 th
= kthread_create(usb_stor_scan_thread
, us
, "usb-stor-scan");
990 printk(KERN_WARNING USB_STORAGE
991 "Unable to start the device-scanning thread\n");
992 quiesce_and_remove_host(us
);
993 result
= PTR_ERR(th
);
997 /* Take a reference to the host for the scanning thread and
998 * count it among all the threads we have launched. Then
1000 scsi_host_get(us_to_host(us
));
1001 atomic_inc(&total_threads
);
1002 wake_up_process(th
);
1006 /* We come here if there are any problems */
1008 US_DEBUGP("storage_probe() failed\n");
1009 release_everything(us
);
1013 /* Handle a disconnect event from the USB core */
1014 static void storage_disconnect(struct usb_interface
*intf
)
1016 struct us_data
*us
= usb_get_intfdata(intf
);
1018 US_DEBUGP("storage_disconnect() called\n");
1019 quiesce_and_remove_host(us
);
1020 release_everything(us
);
1023 /***********************************************************************
1024 * Initialization and registration
1025 ***********************************************************************/
1027 static struct usb_driver usb_storage_driver
= {
1028 .name
= "usb-storage",
1029 .probe
= storage_probe
,
1030 .disconnect
= storage_disconnect
,
1032 .suspend
= storage_suspend
,
1033 .resume
= storage_resume
,
1035 .pre_reset
= storage_pre_reset
,
1036 .post_reset
= storage_post_reset
,
1037 .id_table
= storage_usb_ids
,
1040 static int __init
usb_stor_init(void)
1043 printk(KERN_INFO
"Initializing USB Mass Storage driver...\n");
1045 /* register the driver, return usb_register return code if error */
1046 retval
= usb_register(&usb_storage_driver
);
1048 printk(KERN_INFO
"USB Mass Storage support registered.\n");
1049 usb_usual_set_present(USB_US_TYPE_STOR
);
1054 static void __exit
usb_stor_exit(void)
1056 US_DEBUGP("usb_stor_exit() called\n");
1058 /* Deregister the driver
1059 * This will cause disconnect() to be called for each
1062 US_DEBUGP("-- calling usb_deregister()\n");
1063 usb_deregister(&usb_storage_driver
) ;
1065 /* Don't return until all of our control and scanning threads
1066 * have exited. Since each thread signals threads_gone as its
1067 * last act, we have to call wait_for_completion the right number
1070 while (atomic_read(&total_threads
) > 0) {
1071 wait_for_completion(&threads_gone
);
1072 atomic_dec(&total_threads
);
1075 usb_usual_clear_present(USB_US_TYPE_STOR
);
1078 module_init(usb_stor_init
);
1079 module_exit(usb_stor_exit
);