blob: 12aa72630aedbb7f88e4cb40b5eb233fae828f72 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* Driver for USB Mass Storage compliant devices
2 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Current development and maintenance by:
4 * (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
5 *
6 * Developed with the assistance of:
7 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
Alan Sterne6e244b2009-02-12 14:47:44 -05008 * (c) 2003-2009 Alan Stern (stern@rowland.harvard.edu)
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
10 * Initial work by:
11 * (c) 1999 Michael Gee (michael@linuxspecific.com)
12 *
13 * usb_device_id support by Adam J. Richter (adam@yggdrasil.com):
14 * (c) 2000 Yggdrasil Computing, Inc.
15 *
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.
21 *
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.
26 *
27 * Also, for certain devices, the interrupt endpoint is used to convey
28 * status of a command.
29 *
30 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
31 * information about this driver.
32 *
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
36 * later version.
37 *
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.
42 *
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.
46 */
47
Matthew Wilcox9eb66f72009-09-24 16:19:49 -060048#ifdef CONFIG_USB_STORAGE_DEBUG
49#define DEBUG
50#endif
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <linux/sched.h>
53#include <linux/errno.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080054#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#include <linux/module.h>
56#include <linux/init.h>
57#include <linux/slab.h>
Alan Stern3f13e662005-10-23 19:43:36 -070058#include <linux/kthread.h>
Arjan van de Ven4186ecf2006-01-11 15:55:29 +010059#include <linux/mutex.h>
Sam Ravnborg00f8b0c12007-03-05 00:30:55 -080060#include <linux/utsname.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62#include <scsi/scsi.h>
63#include <scsi/scsi_cmnd.h>
64#include <scsi/scsi_device.h>
65
66#include "usb.h"
67#include "scsiglue.h"
68#include "transport.h"
69#include "protocol.h"
70#include "debug.h"
71#include "initializers.h"
72
Kevin Lloyd32fe5e32008-07-10 14:14:57 -070073#include "sierra_ms.h"
Dan Williams281b0642008-12-14 12:39:22 -050074#include "option_ms.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
76/* Some informational data */
77MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
78MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
79MODULE_LICENSE("GPL");
80
Linus Torvaldsa4a47bc2010-02-26 10:03:22 -080081static unsigned int delay_use = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082module_param(delay_use, uint, S_IRUGO | S_IWUSR);
83MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
84
Alan Sternc838ea42008-12-15 10:40:06 -050085static char quirks[128];
86module_param_string(quirks, quirks, sizeof(quirks), S_IRUGO | S_IWUSR);
Alan Sternd4f373e2008-11-10 14:07:45 -050087MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
88
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Pete Zaitceva00828e2005-10-22 20:15:09 -070090/*
91 * The entries in this table correspond, line for line,
Alan Sterne6e244b2009-02-12 14:47:44 -050092 * with the entries in usb_storage_usb_ids[], defined in usual-tables.c.
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95/* The vendor name should be kept at eight characters or less, and
96 * the product name should be kept at 16 characters or less. If a device
97 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
98 * normally generated by a device thorugh the INQUIRY response will be
99 * taken from this list, and this is the reason for the above size
100 * restriction. However, if the flag is not present, then you
101 * are free to use as many characters as you like.
102 */
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
105 vendor_name, product_name, use_protocol, use_transport, \
106 init_function, Flags) \
107{ \
108 .vendorName = vendor_name, \
109 .productName = product_name, \
110 .useProtocol = use_protocol, \
111 .useTransport = use_transport, \
112 .initFunction = init_function, \
Pete Zaitceva00828e2005-10-22 20:15:09 -0700113}
114
Alan Stern25ff1c32008-12-15 12:43:41 -0500115#define COMPLIANT_DEV UNUSUAL_DEV
116
Sebastian Andrzej Siewiorf61870e2012-08-28 22:37:13 +0200117#define USUAL_DEV(use_protocol, use_transport) \
Pete Zaitceva00828e2005-10-22 20:15:09 -0700118{ \
119 .useProtocol = use_protocol, \
120 .useTransport = use_transport, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121}
122
123static struct us_unusual_dev us_unusual_dev_list[] = {
Jeffrin Josea1631062012-05-17 00:33:36 +0530124# include "unusual_devs.h"
Alan Sterne6e244b2009-02-12 14:47:44 -0500125 { } /* Terminating entry */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126};
127
Huajun Lifd7ff362012-01-14 10:16:40 +0800128static struct us_unusual_dev for_dynamic_ids =
Sebastian Andrzej Siewiorf61870e2012-08-28 22:37:13 +0200129 USUAL_DEV(USB_SC_SCSI, USB_PR_BULK);
Huajun Lifd7ff362012-01-14 10:16:40 +0800130
Alan Sterne6e244b2009-02-12 14:47:44 -0500131#undef UNUSUAL_DEV
132#undef COMPLIANT_DEV
133#undef USUAL_DEV
134
Ming Leic825bab2012-03-19 15:20:57 +0800135#ifdef CONFIG_LOCKDEP
136
137static struct lock_class_key us_interface_key[USB_MAXINTERFACES];
138
139static void us_set_lock_class(struct mutex *mutex,
140 struct usb_interface *intf)
141{
142 struct usb_device *udev = interface_to_usbdev(intf);
143 struct usb_host_config *config = udev->actconfig;
144 int i;
145
146 for (i = 0; i < config->desc.bNumInterfaces; i++) {
147 if (config->interface[i] == intf)
148 break;
149 }
150
151 BUG_ON(i == config->desc.bNumInterfaces);
152
153 lockdep_set_class(mutex, &us_interface_key[i]);
154}
155
156#else
157
158static void us_set_lock_class(struct mutex *mutex,
159 struct usb_interface *intf)
160{
161}
162
163#endif
Alan Sternce2596d2005-10-23 19:41:39 -0700164
165#ifdef CONFIG_PM /* Minimal support for suspend and resume */
166
Alan Sterne6e244b2009-02-12 14:47:44 -0500167int usb_stor_suspend(struct usb_interface *iface, pm_message_t message)
Alan Sternce2596d2005-10-23 19:41:39 -0700168{
169 struct us_data *us = usb_get_intfdata(iface);
170
171 /* Wait until no command is running */
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100172 mutex_lock(&us->dev_mutex);
Alan Sternce2596d2005-10-23 19:41:39 -0700173
Harvey Harrison441b62c2008-03-03 16:08:34 -0800174 US_DEBUGP("%s\n", __func__);
Matthew Dharm7931e1c2005-12-04 21:56:51 -0800175 if (us->suspend_resume_hook)
176 (us->suspend_resume_hook)(us, US_SUSPEND);
Alan Sternce2596d2005-10-23 19:41:39 -0700177
Greg Kroah-Hartmand5268752007-09-13 06:01:24 -0700178 /* When runtime PM is working, we'll set a flag to indicate
179 * whether we should autoresume when a SCSI request arrives. */
180
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100181 mutex_unlock(&us->dev_mutex);
Alan Sternce2596d2005-10-23 19:41:39 -0700182 return 0;
183}
Alan Sterne6e244b2009-02-12 14:47:44 -0500184EXPORT_SYMBOL_GPL(usb_stor_suspend);
Alan Sternce2596d2005-10-23 19:41:39 -0700185
Alan Sterne6e244b2009-02-12 14:47:44 -0500186int usb_stor_resume(struct usb_interface *iface)
Alan Sternce2596d2005-10-23 19:41:39 -0700187{
188 struct us_data *us = usb_get_intfdata(iface);
189
Greg Kroah-Hartmand5268752007-09-13 06:01:24 -0700190 mutex_lock(&us->dev_mutex);
Alan Stern8dfe4b12007-07-06 14:24:27 -0400191
Harvey Harrison441b62c2008-03-03 16:08:34 -0800192 US_DEBUGP("%s\n", __func__);
Matthew Dharm7931e1c2005-12-04 21:56:51 -0800193 if (us->suspend_resume_hook)
194 (us->suspend_resume_hook)(us, US_RESUME);
Alan Sternce2596d2005-10-23 19:41:39 -0700195
Greg Kroah-Hartmand5268752007-09-13 06:01:24 -0700196 mutex_unlock(&us->dev_mutex);
Alan Sternce2596d2005-10-23 19:41:39 -0700197 return 0;
198}
Alan Sterne6e244b2009-02-12 14:47:44 -0500199EXPORT_SYMBOL_GPL(usb_stor_resume);
Alan Sternce2596d2005-10-23 19:41:39 -0700200
Alan Sterne6e244b2009-02-12 14:47:44 -0500201int usb_stor_reset_resume(struct usb_interface *iface)
Alan Sternf07600c2007-05-30 15:38:16 -0400202{
203 struct us_data *us = usb_get_intfdata(iface);
204
Harvey Harrison441b62c2008-03-03 16:08:34 -0800205 US_DEBUGP("%s\n", __func__);
Alan Sternf07600c2007-05-30 15:38:16 -0400206
207 /* Report the reset to the SCSI core */
208 usb_stor_report_bus_reset(us);
209
210 /* FIXME: Notify the subdrivers that they need to reinitialize
211 * the device */
212 return 0;
213}
Alan Sterne6e244b2009-02-12 14:47:44 -0500214EXPORT_SYMBOL_GPL(usb_stor_reset_resume);
Alan Sternf07600c2007-05-30 15:38:16 -0400215
Alan Sternce2596d2005-10-23 19:41:39 -0700216#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
218/*
Alan Stern47104b02006-06-01 13:52:56 -0400219 * The next two routines get called just before and just after
220 * a USB port reset, whether from this driver or a different one.
221 */
222
Alan Sterne6e244b2009-02-12 14:47:44 -0500223int usb_stor_pre_reset(struct usb_interface *iface)
Alan Stern47104b02006-06-01 13:52:56 -0400224{
225 struct us_data *us = usb_get_intfdata(iface);
226
Harvey Harrison441b62c2008-03-03 16:08:34 -0800227 US_DEBUGP("%s\n", __func__);
Alan Stern47104b02006-06-01 13:52:56 -0400228
229 /* Make sure no command runs during the reset */
230 mutex_lock(&us->dev_mutex);
Alan Sternf07600c2007-05-30 15:38:16 -0400231 return 0;
Alan Stern47104b02006-06-01 13:52:56 -0400232}
Alan Sterne6e244b2009-02-12 14:47:44 -0500233EXPORT_SYMBOL_GPL(usb_stor_pre_reset);
Alan Stern47104b02006-06-01 13:52:56 -0400234
Alan Sterne6e244b2009-02-12 14:47:44 -0500235int usb_stor_post_reset(struct usb_interface *iface)
Alan Stern47104b02006-06-01 13:52:56 -0400236{
237 struct us_data *us = usb_get_intfdata(iface);
238
Harvey Harrison441b62c2008-03-03 16:08:34 -0800239 US_DEBUGP("%s\n", __func__);
Alan Stern47104b02006-06-01 13:52:56 -0400240
241 /* Report the reset to the SCSI core */
Alan Stern47104b02006-06-01 13:52:56 -0400242 usb_stor_report_bus_reset(us);
Alan Stern47104b02006-06-01 13:52:56 -0400243
244 /* FIXME: Notify the subdrivers that they need to reinitialize
245 * the device */
Alan Stern0458d5b2007-05-04 11:52:20 -0400246
Alan Sternf07600c2007-05-30 15:38:16 -0400247 mutex_unlock(&us->dev_mutex);
248 return 0;
Alan Stern47104b02006-06-01 13:52:56 -0400249}
Alan Sterne6e244b2009-02-12 14:47:44 -0500250EXPORT_SYMBOL_GPL(usb_stor_post_reset);
Alan Stern47104b02006-06-01 13:52:56 -0400251
252/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 * fill_inquiry_response takes an unsigned char array (which must
254 * be at least 36 characters) and populates the vendor name,
255 * product name, and revision fields. Then the array is copied
256 * into the SCSI command's response buffer (oddly enough
257 * called request_buffer). data_len contains the length of the
258 * data array, which again must be at least 36.
259 */
260
261void fill_inquiry_response(struct us_data *us, unsigned char *data,
262 unsigned int data_len)
263{
Jeffrin Josea1631062012-05-17 00:33:36 +0530264 if (data_len < 36) /* You lose. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 return;
266
Alan Sternf3f6faa2009-12-07 16:47:43 -0500267 memset(data+8, ' ', 28);
Jeffrin Josedb2c8622012-05-17 00:34:28 +0530268 if (data[0]&0x20) { /* USB device currently not connected. Return
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 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
Jeffrin Josea1631062012-05-17 00:33:36 +0530274 device, it may return zeros or ASCII spaces
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 (20h) in those fields until the data is
276 available from the device."). */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 } else {
278 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
Alan Sternf3f6faa2009-12-07 16:47:43 -0500279 int n;
280
281 n = strlen(us->unusual_dev->vendorName);
282 memcpy(data+8, us->unusual_dev->vendorName, min(8, n));
283 n = strlen(us->unusual_dev->productName);
284 memcpy(data+16, us->unusual_dev->productName, min(16, n));
285
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 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);
290 }
291
292 usb_stor_set_xfer_buf(data, data_len, us->srb);
293}
Alan Sterne6e244b2009-02-12 14:47:44 -0500294EXPORT_SYMBOL_GPL(fill_inquiry_response);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
296static int usb_stor_control_thread(void * __us)
297{
298 struct us_data *us = (struct us_data *)__us;
299 struct Scsi_Host *host = us_to_host(us);
300
Jeffrin Josedb2c8622012-05-17 00:34:28 +0530301 for (;;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 US_DEBUGP("*** thread sleeping.\n");
Alan Stern7119e3c2008-05-01 15:36:13 -0400303 if (wait_for_completion_interruptible(&us->cmnd_ready))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 break;
Alan Stern7119e3c2008-05-01 15:36:13 -0400305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 US_DEBUGP("*** thread awakened.\n");
307
308 /* lock the device pointers */
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100309 mutex_lock(&(us->dev_mutex));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 /* lock access to the state */
312 scsi_lock(host);
313
Alan Stern543f7812008-05-08 11:55:59 -0400314 /* When we are called with no command pending, we're done */
315 if (us->srb == NULL) {
316 scsi_unlock(host);
317 mutex_unlock(&us->dev_mutex);
318 US_DEBUGP("-- exiting\n");
319 break;
320 }
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 /* has the command timed out *already* ? */
Alan Stern7e4d6c32008-05-01 15:35:18 -0400323 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 us->srb->result = DID_ABORT << 16;
325 goto SkipForAbort;
326 }
327
328 scsi_unlock(host);
329
Jeffrin Josea1631062012-05-17 00:33:36 +0530330 /* reject the command if the direction indicator
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 * is UNKNOWN
332 */
333 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
334 US_DEBUGP("UNKNOWN data direction\n");
335 us->srb->result = DID_ERROR << 16;
336 }
337
338 /* reject if target != 0 or if LUN is higher than
339 * the maximum known LUN
340 */
Jeffrin Josea1631062012-05-17 00:33:36 +0530341 else if (us->srb->device->id &&
Alan Stern7e4d6c32008-05-01 15:35:18 -0400342 !(us->fflags & US_FL_SCM_MULT_TARG)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 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;
346 }
347
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;
352 }
353
Jeffrin Josea1631062012-05-17 00:33:36 +0530354 /* Handle those devices which need us to fake
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 * their inquiry data */
356 else if ((us->srb->cmnd[0] == INQUIRY) &&
Alan Stern7e4d6c32008-05-01 15:35:18 -0400357 (us->fflags & US_FL_FIX_INQUIRY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 unsigned char data_ptr[36] = {
359 0x00, 0x80, 0x02, 0x02,
360 0x1F, 0x00, 0x00, 0x00};
361
362 US_DEBUGP("Faking INQUIRY command\n");
363 fill_inquiry_response(us, data_ptr, 36);
364 us->srb->result = SAM_STAT_GOOD;
365 }
366
367 /* we've got a command, let's do it! */
368 else {
369 US_DEBUG(usb_stor_show_command(us->srb));
370 us->proto_handler(us->srb, us);
Alan Sternf2839252010-07-28 17:12:39 -0400371 usb_mark_last_busy(us->pusb_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 }
373
374 /* lock access to the state */
375 scsi_lock(host);
376
377 /* indicate that the command is done */
Alan Stern543f7812008-05-08 11:55:59 -0400378 if (us->srb->result != DID_ABORT << 16) {
Jeffrin Josea1631062012-05-17 00:33:36 +0530379 US_DEBUGP("scsi cmd done, result=0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 us->srb->result);
381 us->srb->scsi_done(us->srb);
382 } else {
383SkipForAbort:
384 US_DEBUGP("scsi command aborted\n");
385 }
386
387 /* If an abort request was received we need to signal that
388 * the abort has finished. The proper test for this is
389 * the TIMED_OUT flag, not srb->result == DID_ABORT, because
Matthew Dharm226173e2005-08-25 20:03:50 -0700390 * the timeout might have occurred after the command had
391 * already completed with a different result code. */
Alan Stern7e4d6c32008-05-01 15:35:18 -0400392 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 complete(&(us->notify));
394
Matthew Dharm226173e2005-08-25 20:03:50 -0700395 /* Allow USB transfers to resume */
Alan Stern7e4d6c32008-05-01 15:35:18 -0400396 clear_bit(US_FLIDX_ABORTING, &us->dflags);
397 clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
Matthew Dharm226173e2005-08-25 20:03:50 -0700398 }
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 /* finished working on this command */
401 us->srb = NULL;
402 scsi_unlock(host);
403
404 /* unlock the device pointers */
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100405 mutex_unlock(&us->dev_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 } /* for (;;) */
407
Alan Sterned76cac2007-06-07 17:12:25 -0400408 /* Wait until we are told to stop */
409 for (;;) {
410 set_current_state(TASK_INTERRUPTIBLE);
411 if (kthread_should_stop())
412 break;
413 schedule();
414 }
415 __set_current_state(TASK_RUNNING);
416 return 0;
Jeffrin Josea1631062012-05-17 00:33:36 +0530417}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
419/***********************************************************************
420 * Device probing and disconnecting
421 ***********************************************************************/
422
423/* Associate our private data with the USB device */
424static int associate_dev(struct us_data *us, struct usb_interface *intf)
425{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800426 US_DEBUGP("-- %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
428 /* Fill in the device-related fields */
429 us->pusb_dev = interface_to_usbdev(intf);
430 us->pusb_intf = intf;
431 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
432 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n",
433 le16_to_cpu(us->pusb_dev->descriptor.idVendor),
434 le16_to_cpu(us->pusb_dev->descriptor.idProduct),
435 le16_to_cpu(us->pusb_dev->descriptor.bcdDevice));
436 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n",
437 intf->cur_altsetting->desc.bInterfaceSubClass,
438 intf->cur_altsetting->desc.bInterfaceProtocol);
439
440 /* Store our private data in the interface */
441 usb_set_intfdata(intf, us);
442
Alan Stern0ede76f2010-03-05 15:10:17 -0500443 /* Allocate the control/setup and DMA-mapped buffers */
444 us->cr = kmalloc(sizeof(*us->cr), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 if (!us->cr) {
446 US_DEBUGP("usb_ctrlrequest allocation failed\n");
447 return -ENOMEM;
448 }
449
Daniel Mack997ea582010-04-12 13:17:25 +0200450 us->iobuf = usb_alloc_coherent(us->pusb_dev, US_IOBUF_SIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 GFP_KERNEL, &us->iobuf_dma);
452 if (!us->iobuf) {
453 US_DEBUGP("I/O buffer allocation failed\n");
454 return -ENOMEM;
455 }
456 return 0;
457}
458
Alan Sternc838ea42008-12-15 10:40:06 -0500459/* Works only for digits and letters, but small and fast */
460#define TOLOWER(x) ((x) | 0x20)
461
Alan Sternd4f373e2008-11-10 14:07:45 -0500462/* Adjust device flags based on the "quirks=" module parameter */
463static void adjust_quirks(struct us_data *us)
464{
Alan Sternc838ea42008-12-15 10:40:06 -0500465 char *p;
466 u16 vid = le16_to_cpu(us->pusb_dev->descriptor.idVendor);
467 u16 pid = le16_to_cpu(us->pusb_dev->descriptor.idProduct);
468 unsigned f = 0;
Alan Sterna91b5932009-12-22 23:16:32 -0500469 unsigned int mask = (US_FL_SANE_SENSE | US_FL_BAD_SENSE |
470 US_FL_FIX_CAPACITY |
Alan Sternc838ea42008-12-15 10:40:06 -0500471 US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE |
Alan Sternd4f373e2008-11-10 14:07:45 -0500472 US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
Alan Sternc838ea42008-12-15 10:40:06 -0500473 US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
Karl Relton51169012011-05-18 21:42:34 +0100474 US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT |
Alan Stern21c13a42011-06-07 11:35:52 -0400475 US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16 |
Namjae Jeoneaa05df2012-07-07 23:05:28 -0400476 US_FL_INITIAL_READ10 | US_FL_WRITE_CACHE);
Alan Sternd4f373e2008-11-10 14:07:45 -0500477
Alan Sternc838ea42008-12-15 10:40:06 -0500478 p = quirks;
479 while (*p) {
480 /* Each entry consists of VID:PID:flags */
481 if (vid == simple_strtoul(p, &p, 16) &&
482 *p == ':' &&
483 pid == simple_strtoul(p+1, &p, 16) &&
484 *p == ':')
Alan Sternd4f373e2008-11-10 14:07:45 -0500485 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500486
487 /* Move forward to the next entry */
488 while (*p) {
489 if (*p++ == ',')
490 break;
Alan Sternd4f373e2008-11-10 14:07:45 -0500491 }
492 }
Alan Sternc838ea42008-12-15 10:40:06 -0500493 if (!*p) /* No match */
494 return;
495
496 /* Collect the flags */
497 while (*++p && *p != ',') {
498 switch (TOLOWER(*p)) {
499 case 'a':
500 f |= US_FL_SANE_SENSE;
501 break;
Alan Sterna0bb1082009-12-07 16:39:16 -0500502 case 'b':
503 f |= US_FL_BAD_SENSE;
504 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500505 case 'c':
506 f |= US_FL_FIX_CAPACITY;
507 break;
Karl Relton51169012011-05-18 21:42:34 +0100508 case 'd':
509 f |= US_FL_NO_READ_DISC_INFO;
510 break;
511 case 'e':
512 f |= US_FL_NO_READ_CAPACITY_16;
513 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500514 case 'h':
515 f |= US_FL_CAPACITY_HEURISTICS;
516 break;
517 case 'i':
518 f |= US_FL_IGNORE_DEVICE;
519 break;
520 case 'l':
521 f |= US_FL_NOT_LOCKABLE;
522 break;
523 case 'm':
524 f |= US_FL_MAX_SECTORS_64;
525 break;
Alan Stern21c13a42011-06-07 11:35:52 -0400526 case 'n':
527 f |= US_FL_INITIAL_READ10;
528 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500529 case 'o':
530 f |= US_FL_CAPACITY_OK;
531 break;
Namjae Jeoneaa05df2012-07-07 23:05:28 -0400532 case 'p':
533 f |= US_FL_WRITE_CACHE;
534 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500535 case 'r':
536 f |= US_FL_IGNORE_RESIDUE;
537 break;
538 case 's':
539 f |= US_FL_SINGLE_LUN;
540 break;
541 case 'w':
542 f |= US_FL_NO_WP_DETECT;
543 break;
544 /* Ignore unrecognized flag characters */
545 }
546 }
547 us->fflags = (us->fflags & ~mask) | f;
Alan Sternd4f373e2008-11-10 14:07:45 -0500548}
549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550/* Get the unusual_devs entries and the string descriptors */
Alan Sterne6e244b2009-02-12 14:47:44 -0500551static int get_device_info(struct us_data *us, const struct usb_device_id *id,
552 struct us_unusual_dev *unusual_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553{
554 struct usb_device *dev = us->pusb_dev;
555 struct usb_interface_descriptor *idesc =
556 &us->pusb_intf->cur_altsetting->desc;
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300557 struct device *pdev = &us->pusb_intf->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
559 /* Store the entries */
560 us->unusual_dev = unusual_dev;
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200561 us->subclass = (unusual_dev->useProtocol == USB_SC_DEVICE) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 idesc->bInterfaceSubClass :
563 unusual_dev->useProtocol;
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200564 us->protocol = (unusual_dev->useTransport == USB_PR_DEVICE) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 idesc->bInterfaceProtocol :
566 unusual_dev->useTransport;
Sebastian Andrzej Siewiorf61870e2012-08-28 22:37:13 +0200567 us->fflags = id->driver_info;
Alan Sternd4f373e2008-11-10 14:07:45 -0500568 adjust_quirks(us);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Alan Stern7e4d6c32008-05-01 15:35:18 -0400570 if (us->fflags & US_FL_IGNORE_DEVICE) {
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300571 dev_info(pdev, "device ignored\n");
Daniel Drake3c332422006-07-26 13:59:23 +0100572 return -ENODEV;
573 }
574
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 /*
576 * This flag is only needed when we're in high-speed, so let's
577 * disable it if we're in full-speed
578 */
579 if (dev->speed != USB_SPEED_HIGH)
Alan Stern7e4d6c32008-05-01 15:35:18 -0400580 us->fflags &= ~US_FL_GO_SLOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
Felipe Contreras39f2f082010-05-16 23:31:07 +0300582 if (us->fflags)
583 dev_info(pdev, "Quirks match for vid %04x pid %04x: %lx\n",
584 le16_to_cpu(dev->descriptor.idVendor),
585 le16_to_cpu(dev->descriptor.idProduct),
586 us->fflags);
587
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 /* Log a message if a non-generic unusual_dev entry contains an
589 * unnecessary subclass or protocol override. This may stimulate
590 * reports from users that will help us remove unneeded entries
591 * from the unusual_devs.h table.
592 */
593 if (id->idVendor || id->idProduct) {
Arjan van de Ven4c4c9432005-11-29 09:43:42 +0100594 static const char *msgs[3] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 "an unneeded SubClass entry",
596 "an unneeded Protocol entry",
597 "unneeded SubClass and Protocol entries"};
598 struct usb_device_descriptor *ddesc = &dev->descriptor;
599 int msg = -1;
600
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200601 if (unusual_dev->useProtocol != USB_SC_DEVICE &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 us->subclass == idesc->bInterfaceSubClass)
603 msg += 1;
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200604 if (unusual_dev->useTransport != USB_PR_DEVICE &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 us->protocol == idesc->bInterfaceProtocol)
606 msg += 2;
Alan Stern7e4d6c32008-05-01 15:35:18 -0400607 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300608 dev_notice(pdev, "This device "
609 "(%04x,%04x,%04x S %02x P %02x)"
610 " has %s in unusual_devs.h (kernel"
611 " %s)\n"
612 " Please send a copy of this message to "
613 "<linux-usb@vger.kernel.org> and "
614 "<usb-storage@lists.one-eyed-alien.net>\n",
615 le16_to_cpu(ddesc->idVendor),
616 le16_to_cpu(ddesc->idProduct),
617 le16_to_cpu(ddesc->bcdDevice),
618 idesc->bInterfaceSubClass,
619 idesc->bInterfaceProtocol,
620 msgs[msg],
621 utsname()->release);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 }
Daniel Drake3c332422006-07-26 13:59:23 +0100623
624 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625}
626
627/* Get the transport settings */
Alan Sterne6e244b2009-02-12 14:47:44 -0500628static void get_transport(struct us_data *us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
630 switch (us->protocol) {
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200631 case USB_PR_CB:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 us->transport_name = "Control/Bulk";
633 us->transport = usb_stor_CB_transport;
634 us->transport_reset = usb_stor_CB_reset;
635 us->max_lun = 7;
636 break;
637
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200638 case USB_PR_CBI:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 us->transport_name = "Control/Bulk/Interrupt";
Alan Stern64648a92008-11-20 14:20:03 -0500640 us->transport = usb_stor_CB_transport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 us->transport_reset = usb_stor_CB_reset;
642 us->max_lun = 7;
643 break;
644
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200645 case USB_PR_BULK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 us->transport_name = "Bulk";
647 us->transport = usb_stor_Bulk_transport;
648 us->transport_reset = usb_stor_Bulk_reset;
649 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651}
652
653/* Get the protocol settings */
Alan Sterne6e244b2009-02-12 14:47:44 -0500654static void get_protocol(struct us_data *us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655{
656 switch (us->subclass) {
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200657 case USB_SC_RBC:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 us->protocol_name = "Reduced Block Commands (RBC)";
659 us->proto_handler = usb_stor_transparent_scsi_command;
660 break;
661
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200662 case USB_SC_8020:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 us->protocol_name = "8020i";
Alan Stern3dae5342008-11-20 14:22:18 -0500664 us->proto_handler = usb_stor_pad12_command;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 us->max_lun = 0;
666 break;
667
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200668 case USB_SC_QIC:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 us->protocol_name = "QIC-157";
Alan Stern3dae5342008-11-20 14:22:18 -0500670 us->proto_handler = usb_stor_pad12_command;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 us->max_lun = 0;
672 break;
673
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200674 case USB_SC_8070:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 us->protocol_name = "8070i";
Alan Stern3dae5342008-11-20 14:22:18 -0500676 us->proto_handler = usb_stor_pad12_command;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 us->max_lun = 0;
678 break;
679
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200680 case USB_SC_SCSI:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 us->protocol_name = "Transparent SCSI";
682 us->proto_handler = usb_stor_transparent_scsi_command;
683 break;
684
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200685 case USB_SC_UFI:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 us->protocol_name = "Uniform Floppy Interface (UFI)";
687 us->proto_handler = usb_stor_ufi_command;
688 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690}
691
692/* Get the pipe settings */
693static int get_pipes(struct us_data *us)
694{
695 struct usb_host_interface *altsetting =
696 us->pusb_intf->cur_altsetting;
697 int i;
698 struct usb_endpoint_descriptor *ep;
699 struct usb_endpoint_descriptor *ep_in = NULL;
700 struct usb_endpoint_descriptor *ep_out = NULL;
701 struct usb_endpoint_descriptor *ep_int = NULL;
702
703 /*
Alan Stern1096f782007-01-22 11:58:34 -0500704 * Find the first endpoint of each type we need.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 * We are expecting a minimum of 2 endpoints - in and out (bulk).
Alan Stern1096f782007-01-22 11:58:34 -0500706 * An optional interrupt-in is OK (necessary for CBI protocol).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 * We will ignore any others.
708 */
709 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
710 ep = &altsetting->endpoint[i].desc;
711
Luiz Fernando N. Capitulino04720742006-10-26 13:03:03 -0300712 if (usb_endpoint_xfer_bulk(ep)) {
Alan Stern1096f782007-01-22 11:58:34 -0500713 if (usb_endpoint_dir_in(ep)) {
714 if (!ep_in)
715 ep_in = ep;
716 } else {
717 if (!ep_out)
718 ep_out = ep;
719 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 }
721
Alan Stern1096f782007-01-22 11:58:34 -0500722 else if (usb_endpoint_is_int_in(ep)) {
723 if (!ep_int)
724 ep_int = ep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 }
726 }
727
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200728 if (!ep_in || !ep_out || (us->protocol == USB_PR_CBI && !ep_int)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
730 return -EIO;
731 }
732
733 /* Calculate and store the pipe values */
734 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
735 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
736 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
Julia Lawall2e0fe702008-12-29 11:22:14 +0100737 usb_endpoint_num(ep_out));
Jeffrin Josea1631062012-05-17 00:33:36 +0530738 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
Julia Lawall2e0fe702008-12-29 11:22:14 +0100739 usb_endpoint_num(ep_in));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 if (ep_int) {
741 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
Julia Lawall2e0fe702008-12-29 11:22:14 +0100742 usb_endpoint_num(ep_int));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 us->ep_bInterval = ep_int->bInterval;
744 }
745 return 0;
746}
747
748/* Initialize all the dynamic resources we need */
749static int usb_stor_acquire_resources(struct us_data *us)
750{
751 int p;
Alan Stern3f13e662005-10-23 19:43:36 -0700752 struct task_struct *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
754 us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
755 if (!us->current_urb) {
756 US_DEBUGP("URB allocation failed\n");
757 return -ENOMEM;
758 }
759
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 /* Just before we start our control thread, initialize
761 * the device if it needs initialization */
Alan Sternb876aef2005-10-23 19:38:56 -0700762 if (us->unusual_dev->initFunction) {
763 p = us->unusual_dev->initFunction(us);
764 if (p)
765 return p;
766 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
768 /* Start up our control thread */
Alan Sterned76cac2007-06-07 17:12:25 -0400769 th = kthread_run(usb_stor_control_thread, us, "usb-storage");
Alan Stern3f13e662005-10-23 19:43:36 -0700770 if (IS_ERR(th)) {
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300771 dev_warn(&us->pusb_intf->dev,
772 "Unable to start control thread\n");
Alan Stern3f13e662005-10-23 19:43:36 -0700773 return PTR_ERR(th);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 }
Alan Sterned76cac2007-06-07 17:12:25 -0400775 us->ctl_thread = th;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
777 return 0;
778}
779
780/* Release all our dynamic resources */
781static void usb_stor_release_resources(struct us_data *us)
782{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800783 US_DEBUGP("-- %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
785 /* Tell the control thread to exit. The SCSI host must
Alan Stern543f7812008-05-08 11:55:59 -0400786 * already have been removed and the DISCONNECTING flag set
787 * so that we won't accept any more commands.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 */
789 US_DEBUGP("-- sending exit command to thread\n");
Alan Stern7119e3c2008-05-01 15:36:13 -0400790 complete(&us->cmnd_ready);
Alan Sterned76cac2007-06-07 17:12:25 -0400791 if (us->ctl_thread)
792 kthread_stop(us->ctl_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
794 /* Call the destructor routine, if it exists */
795 if (us->extra_destructor) {
796 US_DEBUGP("-- calling extra_destructor()\n");
797 us->extra_destructor(us->extra);
798 }
799
800 /* Free the extra data and the URB */
801 kfree(us->extra);
802 usb_free_urb(us->current_urb);
803}
804
805/* Dissociate from the USB device */
806static void dissociate_dev(struct us_data *us)
807{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800808 US_DEBUGP("-- %s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
Alan Stern0ede76f2010-03-05 15:10:17 -0500810 /* Free the buffers */
811 kfree(us->cr);
Daniel Mack997ea582010-04-12 13:17:25 +0200812 usb_free_coherent(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
814 /* Remove our private data from the interface */
815 usb_set_intfdata(us->pusb_intf, NULL);
816}
817
Alan Stern543f7812008-05-08 11:55:59 -0400818/* First stage of disconnect processing: stop SCSI scanning,
819 * remove the host, and stop accepting new commands
820 */
Matthew Dharm77f46322005-07-28 14:44:29 -0700821static void quiesce_and_remove_host(struct us_data *us)
822{
Alan Sterneecd11e2006-06-19 14:50:15 -0400823 struct Scsi_Host *host = us_to_host(us);
824
Alan Stern543f7812008-05-08 11:55:59 -0400825 /* If the device is really gone, cut short reset delays */
Alan Sternbb94a402012-02-21 13:16:32 -0500826 if (us->pusb_dev->state == USB_STATE_NOTATTACHED) {
Alan Stern543f7812008-05-08 11:55:59 -0400827 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
Alan Sternbb94a402012-02-21 13:16:32 -0500828 wake_up(&us->delay_wait);
829 }
Alan Stern543f7812008-05-08 11:55:59 -0400830
Alan Sternbb94a402012-02-21 13:16:32 -0500831 /* Prevent SCSI scanning (if it hasn't started yet)
832 * or wait for the SCSI-scanning routine to stop.
Alan Stern543f7812008-05-08 11:55:59 -0400833 */
Alan Sternbb94a402012-02-21 13:16:32 -0500834 cancel_delayed_work_sync(&us->scan_dwork);
835
836 /* Balance autopm calls if scanning was cancelled */
837 if (test_bit(US_FLIDX_SCAN_PENDING, &us->dflags))
838 usb_autopm_put_interface_no_suspend(us->pusb_intf);
Alan Stern543f7812008-05-08 11:55:59 -0400839
840 /* Removing the host will perform an orderly shutdown: caches
841 * synchronized, disks spun down, etc.
842 */
843 scsi_remove_host(host);
844
845 /* Prevent any new commands from being accepted and cut short
846 * reset delays.
847 */
Alan Sterneecd11e2006-06-19 14:50:15 -0400848 scsi_lock(host);
Alan Stern7e4d6c32008-05-01 15:35:18 -0400849 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
Alan Sterneecd11e2006-06-19 14:50:15 -0400850 scsi_unlock(host);
Matthew Dharm77f46322005-07-28 14:44:29 -0700851 wake_up(&us->delay_wait);
Matthew Dharm77f46322005-07-28 14:44:29 -0700852}
853
854/* Second stage of disconnect processing: deallocate all resources */
855static void release_everything(struct us_data *us)
856{
857 usb_stor_release_resources(us);
858 dissociate_dev(us);
859
860 /* Drop our reference to the host; the SCSI core will free it
861 * (and "us" along with it) when the refcount becomes 0. */
862 scsi_host_put(us_to_host(us));
863}
864
Alan Sternbb94a402012-02-21 13:16:32 -0500865/* Delayed-work routine to carry out SCSI-device scanning */
866static void usb_stor_scan_dwork(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867{
Alan Sternbb94a402012-02-21 13:16:32 -0500868 struct us_data *us = container_of(work, struct us_data,
869 scan_dwork.work);
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300870 struct device *dev = &us->pusb_intf->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Alan Sternbb94a402012-02-21 13:16:32 -0500872 dev_dbg(dev, "starting scan\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
Alan Sternbb94a402012-02-21 13:16:32 -0500874 /* For bulk-only devices, determine the max LUN value */
875 if (us->protocol == USB_PR_BULK && !(us->fflags & US_FL_SINGLE_LUN)) {
876 mutex_lock(&us->dev_mutex);
877 us->max_lun = usb_stor_Bulk_max_lun(us);
878 mutex_unlock(&us->dev_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 }
Alan Sternbb94a402012-02-21 13:16:32 -0500880 scsi_scan_host(us_to_host(us));
881 dev_dbg(dev, "scan complete\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
Alan Sternbb94a402012-02-21 13:16:32 -0500883 /* Should we unbind if no devices were detected? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884
Alan Sternf2839252010-07-28 17:12:39 -0400885 usb_autopm_put_interface(us->pusb_intf);
Alan Sternbb94a402012-02-21 13:16:32 -0500886 clear_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887}
888
David Vrabel4c1bd3d2009-08-24 14:44:30 +0100889static unsigned int usb_stor_sg_tablesize(struct usb_interface *intf)
890{
891 struct usb_device *usb_dev = interface_to_usbdev(intf);
892
893 if (usb_dev->bus->sg_tablesize) {
894 return usb_dev->bus->sg_tablesize;
895 }
896 return SG_ALL;
897}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
Alan Sterne6e244b2009-02-12 14:47:44 -0500899/* First part of general USB mass-storage probing */
900int usb_stor_probe1(struct us_data **pus,
901 struct usb_interface *intf,
902 const struct usb_device_id *id,
903 struct us_unusual_dev *unusual_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904{
905 struct Scsi_Host *host;
906 struct us_data *us;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 int result;
Pete Zaitceva00828e2005-10-22 20:15:09 -0700908
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 US_DEBUGP("USB Mass Storage device detected\n");
910
911 /*
912 * Ask the SCSI layer to allocate a host structure, with extra
913 * space at the end for our private us_data structure.
914 */
915 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
916 if (!host) {
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300917 dev_warn(&intf->dev,
918 "Unable to allocate the scsi host\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 return -ENOMEM;
920 }
921
Richard Sharpe17f060222007-10-10 10:56:28 -0700922 /*
923 * Allow 16-byte CDBs and thus > 2TB
924 */
925 host->max_cmd_len = 16;
David Vrabel4c1bd3d2009-08-24 14:44:30 +0100926 host->sg_tablesize = usb_stor_sg_tablesize(intf);
Alan Sterne6e244b2009-02-12 14:47:44 -0500927 *pus = us = host_to_us(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 memset(us, 0, sizeof(struct us_data));
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100929 mutex_init(&(us->dev_mutex));
Ming Leic825bab2012-03-19 15:20:57 +0800930 us_set_lock_class(&us->dev_mutex, intf);
Alan Stern7119e3c2008-05-01 15:36:13 -0400931 init_completion(&us->cmnd_ready);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 init_completion(&(us->notify));
933 init_waitqueue_head(&us->delay_wait);
Alan Sternbb94a402012-02-21 13:16:32 -0500934 INIT_DELAYED_WORK(&us->scan_dwork, usb_stor_scan_dwork);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
936 /* Associate the us_data structure with the USB device */
937 result = associate_dev(us, intf);
938 if (result)
939 goto BadDevice;
940
Alan Sterne6e244b2009-02-12 14:47:44 -0500941 /* Get the unusual_devs entries and the descriptors */
942 result = get_device_info(us, id, unusual_dev);
Daniel Drake3c332422006-07-26 13:59:23 +0100943 if (result)
944 goto BadDevice;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
Alan Sterne6e244b2009-02-12 14:47:44 -0500946 /* Get standard transport and protocol settings */
947 get_transport(us);
948 get_protocol(us);
949
950 /* Give the caller a chance to fill in specialized transport
951 * or protocol settings.
952 */
953 return 0;
954
955BadDevice:
956 US_DEBUGP("storage_probe() failed\n");
957 release_everything(us);
958 return result;
959}
960EXPORT_SYMBOL_GPL(usb_stor_probe1);
961
962/* Second part of general USB mass-storage probing */
963int usb_stor_probe2(struct us_data *us)
964{
Alan Sterne6e244b2009-02-12 14:47:44 -0500965 int result;
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300966 struct device *dev = &us->pusb_intf->dev;
Alan Sterne6e244b2009-02-12 14:47:44 -0500967
968 /* Make sure the transport and protocol have both been set */
969 if (!us->transport || !us->proto_handler) {
970 result = -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 goto BadDevice;
Alan Sterne6e244b2009-02-12 14:47:44 -0500972 }
973 US_DEBUGP("Transport: %s\n", us->transport_name);
974 US_DEBUGP("Protocol: %s\n", us->protocol_name);
975
976 /* fix for single-lun devices */
977 if (us->fflags & US_FL_SINGLE_LUN)
978 us->max_lun = 0;
979
980 /* Find the endpoints and calculate pipe values */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 result = get_pipes(us);
982 if (result)
983 goto BadDevice;
984
Alan Stern21c13a42011-06-07 11:35:52 -0400985 /*
986 * If the device returns invalid data for the first READ(10)
987 * command, indicate the command should be retried.
988 */
989 if (us->fflags & US_FL_INITIAL_READ10)
990 set_bit(US_FLIDX_REDO_READ10, &us->dflags);
991
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 /* Acquire all the other resources and add the host */
993 result = usb_stor_acquire_resources(us);
994 if (result)
995 goto BadDevice;
Matthew Wilcox00fa43e2009-09-24 16:19:11 -0600996 snprintf(us->scsi_name, sizeof(us->scsi_name), "usb-storage %s",
997 dev_name(&us->pusb_intf->dev));
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300998 result = scsi_add_host(us_to_host(us), dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 if (result) {
Felipe Contrerascbd3af52010-05-16 23:31:06 +03001000 dev_warn(dev,
1001 "Unable to add the scsi host\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 goto BadDevice;
1003 }
1004
Alan Sternbb94a402012-02-21 13:16:32 -05001005 /* Submit the delayed_work for SCSI-device scanning */
Alan Sternf2839252010-07-28 17:12:39 -04001006 usb_autopm_get_interface_no_resume(us->pusb_intf);
Alan Sternbb94a402012-02-21 13:16:32 -05001007 set_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
Alan Sternbb94a402012-02-21 13:16:32 -05001009 if (delay_use > 0)
1010 dev_dbg(dev, "waiting for device to settle before scanning\n");
1011 queue_delayed_work(system_freezable_wq, &us->scan_dwork,
1012 delay_use * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 return 0;
1014
1015 /* We come here if there are any problems */
1016BadDevice:
1017 US_DEBUGP("storage_probe() failed\n");
Matthew Dharm77f46322005-07-28 14:44:29 -07001018 release_everything(us);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 return result;
1020}
Alan Sterne6e244b2009-02-12 14:47:44 -05001021EXPORT_SYMBOL_GPL(usb_stor_probe2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022
Alan Sterne6e244b2009-02-12 14:47:44 -05001023/* Handle a USB mass-storage disconnect */
1024void usb_stor_disconnect(struct usb_interface *intf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025{
1026 struct us_data *us = usb_get_intfdata(intf);
1027
1028 US_DEBUGP("storage_disconnect() called\n");
Matthew Dharm77f46322005-07-28 14:44:29 -07001029 quiesce_and_remove_host(us);
1030 release_everything(us);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031}
Alan Sterne6e244b2009-02-12 14:47:44 -05001032EXPORT_SYMBOL_GPL(usb_stor_disconnect);
1033
1034/* The main probe routine for standard devices */
1035static int storage_probe(struct usb_interface *intf,
1036 const struct usb_device_id *id)
1037{
Huajun Lifd7ff362012-01-14 10:16:40 +08001038 struct us_unusual_dev *unusual_dev;
Alan Sterne6e244b2009-02-12 14:47:44 -05001039 struct us_data *us;
1040 int result;
Huajun Lifd7ff362012-01-14 10:16:40 +08001041 int size;
Alan Sterne6e244b2009-02-12 14:47:44 -05001042
1043 /*
Alan Sterne6e244b2009-02-12 14:47:44 -05001044 * If the device isn't standard (is handled by a subdriver
1045 * module) then don't accept it.
1046 */
Sebastian Andrzej Siewiorf61870e2012-08-28 22:37:13 +02001047 if (usb_usual_ignore_device(intf))
Alan Sterne6e244b2009-02-12 14:47:44 -05001048 return -ENXIO;
1049
1050 /*
1051 * Call the general probe procedures.
1052 *
1053 * The unusual_dev_list array is parallel to the usb_storage_usb_ids
1054 * table, so we use the index of the id entry to find the
1055 * corresponding unusual_devs entry.
1056 */
Huajun Lifd7ff362012-01-14 10:16:40 +08001057
1058 size = ARRAY_SIZE(us_unusual_dev_list);
1059 if (id >= usb_storage_usb_ids && id < usb_storage_usb_ids + size) {
1060 unusual_dev = (id - usb_storage_usb_ids) + us_unusual_dev_list;
1061 } else {
1062 unusual_dev = &for_dynamic_ids;
1063
1064 US_DEBUGP("%s %s 0x%04x 0x%04x\n", "Use Bulk-Only transport",
1065 "with the Transparent SCSI protocol for dynamic id:",
1066 id->idVendor, id->idProduct);
1067 }
1068
1069 result = usb_stor_probe1(&us, intf, id, unusual_dev);
Alan Sterne6e244b2009-02-12 14:47:44 -05001070 if (result)
1071 return result;
1072
1073 /* No special transport or protocol settings in the main module */
1074
1075 result = usb_stor_probe2(us);
1076 return result;
1077}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078
1079/***********************************************************************
1080 * Initialization and registration
1081 ***********************************************************************/
1082
Alan Sternce2596d2005-10-23 19:41:39 -07001083static struct usb_driver usb_storage_driver = {
Alan Sternce2596d2005-10-23 19:41:39 -07001084 .name = "usb-storage",
1085 .probe = storage_probe,
Alan Sterne6e244b2009-02-12 14:47:44 -05001086 .disconnect = usb_stor_disconnect,
1087 .suspend = usb_stor_suspend,
1088 .resume = usb_stor_resume,
1089 .reset_resume = usb_stor_reset_resume,
1090 .pre_reset = usb_stor_pre_reset,
1091 .post_reset = usb_stor_post_reset,
1092 .id_table = usb_storage_usb_ids,
Alan Sternf2839252010-07-28 17:12:39 -04001093 .supports_autosuspend = 1,
Alan Stern543f7812008-05-08 11:55:59 -04001094 .soft_unbind = 1,
Alan Sternce2596d2005-10-23 19:41:39 -07001095};
1096
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097static int __init usb_stor_init(void)
1098{
1099 int retval;
Alan Sternd4f373e2008-11-10 14:07:45 -05001100
Felipe Contrerascbd3af52010-05-16 23:31:06 +03001101 pr_info("Initializing USB Mass Storage driver...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102
1103 /* register the driver, return usb_register return code if error */
1104 retval = usb_register(&usb_storage_driver);
Sebastian Andrzej Siewiorf61870e2012-08-28 22:37:13 +02001105 if (retval == 0)
Felipe Contrerascbd3af52010-05-16 23:31:06 +03001106 pr_info("USB Mass Storage support registered.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 return retval;
1108}
1109
1110static void __exit usb_stor_exit(void)
1111{
1112 US_DEBUGP("usb_stor_exit() called\n");
1113
1114 /* Deregister the driver
1115 * This will cause disconnect() to be called for each
1116 * attached unit
1117 */
1118 US_DEBUGP("-- calling usb_deregister()\n");
1119 usb_deregister(&usb_storage_driver) ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120}
1121
1122module_init(usb_stor_init);
1123module_exit(usb_stor_exit);