blob: 9d66ce62542e1ed620c6d815b07f93f32a2528c7 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#include <linux/slab.h>
Alan Stern3f13e662005-10-23 19:43:36 -070057#include <linux/kthread.h>
Arjan van de Ven4186ecf2006-01-11 15:55:29 +010058#include <linux/mutex.h>
Sam Ravnborg00f8b0c12007-03-05 00:30:55 -080059#include <linux/utsname.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
61#include <scsi/scsi.h>
62#include <scsi/scsi_cmnd.h>
63#include <scsi/scsi_device.h>
64
65#include "usb.h"
66#include "scsiglue.h"
67#include "transport.h"
68#include "protocol.h"
69#include "debug.h"
70#include "initializers.h"
71
Kevin Lloyd32fe5e32008-07-10 14:14:57 -070072#include "sierra_ms.h"
Dan Williams281b0642008-12-14 12:39:22 -050073#include "option_ms.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
Hans de Goede5bfd5b52013-10-21 09:40:48 +010075#if IS_ENABLED(CONFIG_USB_UAS)
76#include "uas-detect.h"
77#endif
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079/* Some informational data */
80MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
81MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
82MODULE_LICENSE("GPL");
83
Linus Torvaldsa4a47bc2010-02-26 10:03:22 -080084static unsigned int delay_use = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085module_param(delay_use, uint, S_IRUGO | S_IWUSR);
86MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
87
Alan Sternc838ea42008-12-15 10:40:06 -050088static char quirks[128];
89module_param_string(quirks, quirks, sizeof(quirks), S_IRUGO | S_IWUSR);
Alan Sternd4f373e2008-11-10 14:07:45 -050090MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
91
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Pete Zaitceva00828e2005-10-22 20:15:09 -070093/*
94 * The entries in this table correspond, line for line,
Alan Sterne6e244b2009-02-12 14:47:44 -050095 * with the entries in usb_storage_usb_ids[], defined in usual-tables.c.
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98/* The vendor name should be kept at eight characters or less, and
99 * the product name should be kept at 16 characters or less. If a device
100 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
Mickael Maisona6cd2442014-09-18 11:25:04 +0200101 * normally generated by a device through the INQUIRY response will be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 * taken from this list, and this is the reason for the above size
103 * restriction. However, if the flag is not present, then you
104 * are free to use as many characters as you like.
105 */
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
108 vendor_name, product_name, use_protocol, use_transport, \
109 init_function, Flags) \
110{ \
111 .vendorName = vendor_name, \
112 .productName = product_name, \
113 .useProtocol = use_protocol, \
114 .useTransport = use_transport, \
115 .initFunction = init_function, \
Pete Zaitceva00828e2005-10-22 20:15:09 -0700116}
117
Alan Stern25ff1c32008-12-15 12:43:41 -0500118#define COMPLIANT_DEV UNUSUAL_DEV
119
Sebastian Andrzej Siewiorf61870e2012-08-28 22:37:13 +0200120#define USUAL_DEV(use_protocol, use_transport) \
Pete Zaitceva00828e2005-10-22 20:15:09 -0700121{ \
122 .useProtocol = use_protocol, \
123 .useTransport = use_transport, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124}
125
fangxiaozhi07c7be32013-02-04 15:14:46 +0800126#define UNUSUAL_VENDOR_INTF(idVendor, cl, sc, pr, \
127 vendor_name, product_name, use_protocol, use_transport, \
128 init_function, Flags) \
129{ \
130 .vendorName = vendor_name, \
131 .productName = product_name, \
132 .useProtocol = use_protocol, \
133 .useTransport = use_transport, \
134 .initFunction = init_function, \
135}
136
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137static struct us_unusual_dev us_unusual_dev_list[] = {
Jeffrin Josea1631062012-05-17 00:33:36 +0530138# include "unusual_devs.h"
Alan Sterne6e244b2009-02-12 14:47:44 -0500139 { } /* Terminating entry */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140};
141
Huajun Lifd7ff362012-01-14 10:16:40 +0800142static struct us_unusual_dev for_dynamic_ids =
Sebastian Andrzej Siewiorf61870e2012-08-28 22:37:13 +0200143 USUAL_DEV(USB_SC_SCSI, USB_PR_BULK);
Huajun Lifd7ff362012-01-14 10:16:40 +0800144
Alan Sterne6e244b2009-02-12 14:47:44 -0500145#undef UNUSUAL_DEV
146#undef COMPLIANT_DEV
147#undef USUAL_DEV
fangxiaozhi07c7be32013-02-04 15:14:46 +0800148#undef UNUSUAL_VENDOR_INTF
Alan Sterne6e244b2009-02-12 14:47:44 -0500149
Ming Leic825bab2012-03-19 15:20:57 +0800150#ifdef CONFIG_LOCKDEP
151
152static struct lock_class_key us_interface_key[USB_MAXINTERFACES];
153
154static void us_set_lock_class(struct mutex *mutex,
155 struct usb_interface *intf)
156{
157 struct usb_device *udev = interface_to_usbdev(intf);
158 struct usb_host_config *config = udev->actconfig;
159 int i;
160
161 for (i = 0; i < config->desc.bNumInterfaces; i++) {
162 if (config->interface[i] == intf)
163 break;
164 }
165
166 BUG_ON(i == config->desc.bNumInterfaces);
167
168 lockdep_set_class(mutex, &us_interface_key[i]);
169}
170
171#else
172
173static void us_set_lock_class(struct mutex *mutex,
174 struct usb_interface *intf)
175{
176}
177
178#endif
Alan Sternce2596d2005-10-23 19:41:39 -0700179
180#ifdef CONFIG_PM /* Minimal support for suspend and resume */
181
Alan Sterne6e244b2009-02-12 14:47:44 -0500182int usb_stor_suspend(struct usb_interface *iface, pm_message_t message)
Alan Sternce2596d2005-10-23 19:41:39 -0700183{
184 struct us_data *us = usb_get_intfdata(iface);
185
186 /* Wait until no command is running */
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100187 mutex_lock(&us->dev_mutex);
Alan Sternce2596d2005-10-23 19:41:39 -0700188
Matthew Dharm7931e1c2005-12-04 21:56:51 -0800189 if (us->suspend_resume_hook)
190 (us->suspend_resume_hook)(us, US_SUSPEND);
Alan Sternce2596d2005-10-23 19:41:39 -0700191
Greg Kroah-Hartmand5268752007-09-13 06:01:24 -0700192 /* When runtime PM is working, we'll set a flag to indicate
193 * whether we should autoresume when a SCSI request arrives. */
194
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100195 mutex_unlock(&us->dev_mutex);
Alan Sternce2596d2005-10-23 19:41:39 -0700196 return 0;
197}
Alan Sterne6e244b2009-02-12 14:47:44 -0500198EXPORT_SYMBOL_GPL(usb_stor_suspend);
Alan Sternce2596d2005-10-23 19:41:39 -0700199
Alan Sterne6e244b2009-02-12 14:47:44 -0500200int usb_stor_resume(struct usb_interface *iface)
Alan Sternce2596d2005-10-23 19:41:39 -0700201{
202 struct us_data *us = usb_get_intfdata(iface);
203
Greg Kroah-Hartmand5268752007-09-13 06:01:24 -0700204 mutex_lock(&us->dev_mutex);
Alan Stern8dfe4b12007-07-06 14:24:27 -0400205
Matthew Dharm7931e1c2005-12-04 21:56:51 -0800206 if (us->suspend_resume_hook)
207 (us->suspend_resume_hook)(us, US_RESUME);
Alan Sternce2596d2005-10-23 19:41:39 -0700208
Greg Kroah-Hartmand5268752007-09-13 06:01:24 -0700209 mutex_unlock(&us->dev_mutex);
Alan Sternce2596d2005-10-23 19:41:39 -0700210 return 0;
211}
Alan Sterne6e244b2009-02-12 14:47:44 -0500212EXPORT_SYMBOL_GPL(usb_stor_resume);
Alan Sternce2596d2005-10-23 19:41:39 -0700213
Alan Sterne6e244b2009-02-12 14:47:44 -0500214int usb_stor_reset_resume(struct usb_interface *iface)
Alan Sternf07600c2007-05-30 15:38:16 -0400215{
216 struct us_data *us = usb_get_intfdata(iface);
217
Alan Sternf07600c2007-05-30 15:38:16 -0400218 /* Report the reset to the SCSI core */
219 usb_stor_report_bus_reset(us);
220
221 /* FIXME: Notify the subdrivers that they need to reinitialize
222 * the device */
223 return 0;
224}
Alan Sterne6e244b2009-02-12 14:47:44 -0500225EXPORT_SYMBOL_GPL(usb_stor_reset_resume);
Alan Sternf07600c2007-05-30 15:38:16 -0400226
Alan Sternce2596d2005-10-23 19:41:39 -0700227#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
229/*
Alan Stern47104b02006-06-01 13:52:56 -0400230 * The next two routines get called just before and just after
231 * a USB port reset, whether from this driver or a different one.
232 */
233
Alan Sterne6e244b2009-02-12 14:47:44 -0500234int usb_stor_pre_reset(struct usb_interface *iface)
Alan Stern47104b02006-06-01 13:52:56 -0400235{
236 struct us_data *us = usb_get_intfdata(iface);
237
Alan Stern47104b02006-06-01 13:52:56 -0400238 /* Make sure no command runs during the reset */
239 mutex_lock(&us->dev_mutex);
Alan Sternf07600c2007-05-30 15:38:16 -0400240 return 0;
Alan Stern47104b02006-06-01 13:52:56 -0400241}
Alan Sterne6e244b2009-02-12 14:47:44 -0500242EXPORT_SYMBOL_GPL(usb_stor_pre_reset);
Alan Stern47104b02006-06-01 13:52:56 -0400243
Alan Sterne6e244b2009-02-12 14:47:44 -0500244int usb_stor_post_reset(struct usb_interface *iface)
Alan Stern47104b02006-06-01 13:52:56 -0400245{
246 struct us_data *us = usb_get_intfdata(iface);
247
Alan Stern47104b02006-06-01 13:52:56 -0400248 /* Report the reset to the SCSI core */
Alan Stern47104b02006-06-01 13:52:56 -0400249 usb_stor_report_bus_reset(us);
Alan Stern47104b02006-06-01 13:52:56 -0400250
251 /* FIXME: Notify the subdrivers that they need to reinitialize
252 * the device */
Alan Stern0458d5b2007-05-04 11:52:20 -0400253
Alan Sternf07600c2007-05-30 15:38:16 -0400254 mutex_unlock(&us->dev_mutex);
255 return 0;
Alan Stern47104b02006-06-01 13:52:56 -0400256}
Alan Sterne6e244b2009-02-12 14:47:44 -0500257EXPORT_SYMBOL_GPL(usb_stor_post_reset);
Alan Stern47104b02006-06-01 13:52:56 -0400258
259/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 * fill_inquiry_response takes an unsigned char array (which must
261 * be at least 36 characters) and populates the vendor name,
262 * product name, and revision fields. Then the array is copied
263 * into the SCSI command's response buffer (oddly enough
264 * called request_buffer). data_len contains the length of the
265 * data array, which again must be at least 36.
266 */
267
268void fill_inquiry_response(struct us_data *us, unsigned char *data,
269 unsigned int data_len)
270{
Jeffrin Josea1631062012-05-17 00:33:36 +0530271 if (data_len < 36) /* You lose. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 return;
273
Alan Sternf3f6faa2009-12-07 16:47:43 -0500274 memset(data+8, ' ', 28);
Jeffrin Josedb2c8622012-05-17 00:34:28 +0530275 if (data[0]&0x20) { /* USB device currently not connected. Return
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 peripheral qualifier 001b ("...however, the
277 physical device is not currently connected
278 to this logical unit") and leave vendor and
279 product identification empty. ("If the target
280 does store some of the INQUIRY data on the
Jeffrin Josea1631062012-05-17 00:33:36 +0530281 device, it may return zeros or ASCII spaces
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 (20h) in those fields until the data is
283 available from the device."). */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 } else {
285 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
Alan Sternf3f6faa2009-12-07 16:47:43 -0500286 int n;
287
288 n = strlen(us->unusual_dev->vendorName);
289 memcpy(data+8, us->unusual_dev->vendorName, min(8, n));
290 n = strlen(us->unusual_dev->productName);
291 memcpy(data+16, us->unusual_dev->productName, min(16, n));
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F);
294 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F);
295 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F);
296 data[35] = 0x30 + ((bcdDevice) & 0x0F);
297 }
298
299 usb_stor_set_xfer_buf(data, data_len, us->srb);
300}
Alan Sterne6e244b2009-02-12 14:47:44 -0500301EXPORT_SYMBOL_GPL(fill_inquiry_response);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
303static int usb_stor_control_thread(void * __us)
304{
305 struct us_data *us = (struct us_data *)__us;
306 struct Scsi_Host *host = us_to_host(us);
307
Jeffrin Josedb2c8622012-05-17 00:34:28 +0530308 for (;;) {
Joe Perches191648d2013-04-19 11:44:00 -0700309 usb_stor_dbg(us, "*** thread sleeping\n");
Alan Stern7119e3c2008-05-01 15:36:13 -0400310 if (wait_for_completion_interruptible(&us->cmnd_ready))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 break;
Alan Stern7119e3c2008-05-01 15:36:13 -0400312
Joe Perches191648d2013-04-19 11:44:00 -0700313 usb_stor_dbg(us, "*** thread awakened\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
315 /* lock the device pointers */
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100316 mutex_lock(&(us->dev_mutex));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 /* lock access to the state */
319 scsi_lock(host);
320
Alan Stern543f7812008-05-08 11:55:59 -0400321 /* When we are called with no command pending, we're done */
322 if (us->srb == NULL) {
323 scsi_unlock(host);
324 mutex_unlock(&us->dev_mutex);
Joe Perches191648d2013-04-19 11:44:00 -0700325 usb_stor_dbg(us, "-- exiting\n");
Alan Stern543f7812008-05-08 11:55:59 -0400326 break;
327 }
328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 /* has the command timed out *already* ? */
Alan Stern7e4d6c32008-05-01 15:35:18 -0400330 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 us->srb->result = DID_ABORT << 16;
332 goto SkipForAbort;
333 }
334
335 scsi_unlock(host);
336
Jeffrin Josea1631062012-05-17 00:33:36 +0530337 /* reject the command if the direction indicator
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 * is UNKNOWN
339 */
340 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
Joe Perches191648d2013-04-19 11:44:00 -0700341 usb_stor_dbg(us, "UNKNOWN data direction\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 us->srb->result = DID_ERROR << 16;
343 }
344
345 /* reject if target != 0 or if LUN is higher than
346 * the maximum known LUN
347 */
Jeffrin Josea1631062012-05-17 00:33:36 +0530348 else if (us->srb->device->id &&
Alan Stern7e4d6c32008-05-01 15:35:18 -0400349 !(us->fflags & US_FL_SCM_MULT_TARG)) {
Hannes Reinecke9cb78c12014-06-25 15:27:36 +0200350 usb_stor_dbg(us, "Bad target number (%d:%llu)\n",
351 us->srb->device->id,
352 us->srb->device->lun);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 us->srb->result = DID_BAD_TARGET << 16;
354 }
355
356 else if (us->srb->device->lun > us->max_lun) {
Hannes Reinecke9cb78c12014-06-25 15:27:36 +0200357 usb_stor_dbg(us, "Bad LUN (%d:%llu)\n",
358 us->srb->device->id,
359 us->srb->device->lun);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 us->srb->result = DID_BAD_TARGET << 16;
361 }
362
Jeffrin Josea1631062012-05-17 00:33:36 +0530363 /* Handle those devices which need us to fake
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 * their inquiry data */
365 else if ((us->srb->cmnd[0] == INQUIRY) &&
Alan Stern7e4d6c32008-05-01 15:35:18 -0400366 (us->fflags & US_FL_FIX_INQUIRY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 unsigned char data_ptr[36] = {
368 0x00, 0x80, 0x02, 0x02,
369 0x1F, 0x00, 0x00, 0x00};
370
Joe Perches191648d2013-04-19 11:44:00 -0700371 usb_stor_dbg(us, "Faking INQUIRY command\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 fill_inquiry_response(us, data_ptr, 36);
373 us->srb->result = SAM_STAT_GOOD;
374 }
375
376 /* we've got a command, let's do it! */
377 else {
Joe Perches191648d2013-04-19 11:44:00 -0700378 US_DEBUG(usb_stor_show_command(us, us->srb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 us->proto_handler(us->srb, us);
Alan Sternf2839252010-07-28 17:12:39 -0400380 usb_mark_last_busy(us->pusb_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 }
382
383 /* lock access to the state */
384 scsi_lock(host);
385
386 /* indicate that the command is done */
Alan Stern543f7812008-05-08 11:55:59 -0400387 if (us->srb->result != DID_ABORT << 16) {
Joe Perches191648d2013-04-19 11:44:00 -0700388 usb_stor_dbg(us, "scsi cmd done, result=0x%x\n",
389 us->srb->result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 us->srb->scsi_done(us->srb);
391 } else {
392SkipForAbort:
Joe Perches191648d2013-04-19 11:44:00 -0700393 usb_stor_dbg(us, "scsi command aborted\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 }
395
396 /* If an abort request was received we need to signal that
397 * the abort has finished. The proper test for this is
398 * the TIMED_OUT flag, not srb->result == DID_ABORT, because
Matthew Dharm226173e2005-08-25 20:03:50 -0700399 * the timeout might have occurred after the command had
400 * already completed with a different result code. */
Alan Stern7e4d6c32008-05-01 15:35:18 -0400401 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 complete(&(us->notify));
403
Matthew Dharm226173e2005-08-25 20:03:50 -0700404 /* Allow USB transfers to resume */
Alan Stern7e4d6c32008-05-01 15:35:18 -0400405 clear_bit(US_FLIDX_ABORTING, &us->dflags);
406 clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
Matthew Dharm226173e2005-08-25 20:03:50 -0700407 }
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 /* finished working on this command */
410 us->srb = NULL;
411 scsi_unlock(host);
412
413 /* unlock the device pointers */
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100414 mutex_unlock(&us->dev_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 } /* for (;;) */
416
Alan Sterned76cac2007-06-07 17:12:25 -0400417 /* Wait until we are told to stop */
418 for (;;) {
419 set_current_state(TASK_INTERRUPTIBLE);
420 if (kthread_should_stop())
421 break;
422 schedule();
423 }
424 __set_current_state(TASK_RUNNING);
425 return 0;
Jeffrin Josea1631062012-05-17 00:33:36 +0530426}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
428/***********************************************************************
429 * Device probing and disconnecting
430 ***********************************************************************/
431
432/* Associate our private data with the USB device */
433static int associate_dev(struct us_data *us, struct usb_interface *intf)
434{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 /* 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;
Joe Perches191648d2013-04-19 11:44:00 -0700439 usb_stor_dbg(us, "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 usb_stor_dbg(us, "Interface Subclass: 0x%02x, Protocol: 0x%02x\n",
444 intf->cur_altsetting->desc.bInterfaceSubClass,
445 intf->cur_altsetting->desc.bInterfaceProtocol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
447 /* Store our private data in the interface */
448 usb_set_intfdata(intf, us);
449
Alan Stern0ede76f2010-03-05 15:10:17 -0500450 /* Allocate the control/setup and DMA-mapped buffers */
451 us->cr = kmalloc(sizeof(*us->cr), GFP_KERNEL);
Joe Perches191648d2013-04-19 11:44:00 -0700452 if (!us->cr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Daniel Mack997ea582010-04-12 13:17:25 +0200455 us->iobuf = usb_alloc_coherent(us->pusb_dev, US_IOBUF_SIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 GFP_KERNEL, &us->iobuf_dma);
457 if (!us->iobuf) {
Joe Perches191648d2013-04-19 11:44:00 -0700458 usb_stor_dbg(us, "I/O buffer allocation failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 return -ENOMEM;
460 }
461 return 0;
462}
463
Alan Sternc838ea42008-12-15 10:40:06 -0500464/* Works only for digits and letters, but small and fast */
465#define TOLOWER(x) ((x) | 0x20)
466
Alan Sternd4f373e2008-11-10 14:07:45 -0500467/* Adjust device flags based on the "quirks=" module parameter */
Hans de Goeded24d4812013-11-16 12:09:39 +0100468void usb_stor_adjust_quirks(struct usb_device *udev, unsigned long *fflags)
Alan Sternd4f373e2008-11-10 14:07:45 -0500469{
Alan Sternc838ea42008-12-15 10:40:06 -0500470 char *p;
Hans de Goeded24d4812013-11-16 12:09:39 +0100471 u16 vid = le16_to_cpu(udev->descriptor.idVendor);
472 u16 pid = le16_to_cpu(udev->descriptor.idProduct);
Alan Sternc838ea42008-12-15 10:40:06 -0500473 unsigned f = 0;
Alan Sterna91b5932009-12-22 23:16:32 -0500474 unsigned int mask = (US_FL_SANE_SENSE | US_FL_BAD_SENSE |
Hans de Goeded24d4812013-11-16 12:09:39 +0100475 US_FL_FIX_CAPACITY | US_FL_IGNORE_UAS |
Alan Sternc838ea42008-12-15 10:40:06 -0500476 US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE |
Alan Sternd4f373e2008-11-10 14:07:45 -0500477 US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
Alan Sternc838ea42008-12-15 10:40:06 -0500478 US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
Karl Relton51169012011-05-18 21:42:34 +0100479 US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT |
Alan Stern21c13a42011-06-07 11:35:52 -0400480 US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16 |
Hans de Goede59307852014-09-15 16:04:12 +0200481 US_FL_INITIAL_READ10 | US_FL_WRITE_CACHE |
Hans de Goede734016b2014-09-16 18:36:52 +0200482 US_FL_NO_ATA_1X | US_FL_NO_REPORT_OPCODES);
Alan Sternd4f373e2008-11-10 14:07:45 -0500483
Alan Sternc838ea42008-12-15 10:40:06 -0500484 p = quirks;
485 while (*p) {
486 /* Each entry consists of VID:PID:flags */
487 if (vid == simple_strtoul(p, &p, 16) &&
488 *p == ':' &&
489 pid == simple_strtoul(p+1, &p, 16) &&
490 *p == ':')
Alan Sternd4f373e2008-11-10 14:07:45 -0500491 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500492
493 /* Move forward to the next entry */
494 while (*p) {
495 if (*p++ == ',')
496 break;
Alan Sternd4f373e2008-11-10 14:07:45 -0500497 }
498 }
Alan Sternc838ea42008-12-15 10:40:06 -0500499 if (!*p) /* No match */
500 return;
501
502 /* Collect the flags */
503 while (*++p && *p != ',') {
504 switch (TOLOWER(*p)) {
505 case 'a':
506 f |= US_FL_SANE_SENSE;
507 break;
Alan Sterna0bb1082009-12-07 16:39:16 -0500508 case 'b':
509 f |= US_FL_BAD_SENSE;
510 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500511 case 'c':
512 f |= US_FL_FIX_CAPACITY;
513 break;
Karl Relton51169012011-05-18 21:42:34 +0100514 case 'd':
515 f |= US_FL_NO_READ_DISC_INFO;
516 break;
517 case 'e':
518 f |= US_FL_NO_READ_CAPACITY_16;
519 break;
Hans de Goede734016b2014-09-16 18:36:52 +0200520 case 'f':
521 f |= US_FL_NO_REPORT_OPCODES;
522 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500523 case 'h':
524 f |= US_FL_CAPACITY_HEURISTICS;
525 break;
526 case 'i':
527 f |= US_FL_IGNORE_DEVICE;
528 break;
529 case 'l':
530 f |= US_FL_NOT_LOCKABLE;
531 break;
532 case 'm':
533 f |= US_FL_MAX_SECTORS_64;
534 break;
Alan Stern21c13a42011-06-07 11:35:52 -0400535 case 'n':
536 f |= US_FL_INITIAL_READ10;
537 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500538 case 'o':
539 f |= US_FL_CAPACITY_OK;
540 break;
Namjae Jeoneaa05df2012-07-07 23:05:28 -0400541 case 'p':
542 f |= US_FL_WRITE_CACHE;
543 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500544 case 'r':
545 f |= US_FL_IGNORE_RESIDUE;
546 break;
547 case 's':
548 f |= US_FL_SINGLE_LUN;
549 break;
Hans de Goede59307852014-09-15 16:04:12 +0200550 case 't':
551 f |= US_FL_NO_ATA_1X;
552 break;
Hans de Goeded24d4812013-11-16 12:09:39 +0100553 case 'u':
554 f |= US_FL_IGNORE_UAS;
555 break;
Alan Sternc838ea42008-12-15 10:40:06 -0500556 case 'w':
557 f |= US_FL_NO_WP_DETECT;
558 break;
559 /* Ignore unrecognized flag characters */
560 }
561 }
Hans de Goeded24d4812013-11-16 12:09:39 +0100562 *fflags = (*fflags & ~mask) | f;
Alan Sternd4f373e2008-11-10 14:07:45 -0500563}
Hans de Goeded24d4812013-11-16 12:09:39 +0100564EXPORT_SYMBOL_GPL(usb_stor_adjust_quirks);
Alan Sternd4f373e2008-11-10 14:07:45 -0500565
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566/* Get the unusual_devs entries and the string descriptors */
Alan Sterne6e244b2009-02-12 14:47:44 -0500567static int get_device_info(struct us_data *us, const struct usb_device_id *id,
568 struct us_unusual_dev *unusual_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
570 struct usb_device *dev = us->pusb_dev;
571 struct usb_interface_descriptor *idesc =
572 &us->pusb_intf->cur_altsetting->desc;
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300573 struct device *pdev = &us->pusb_intf->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
575 /* Store the entries */
576 us->unusual_dev = unusual_dev;
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200577 us->subclass = (unusual_dev->useProtocol == USB_SC_DEVICE) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 idesc->bInterfaceSubClass :
579 unusual_dev->useProtocol;
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200580 us->protocol = (unusual_dev->useTransport == USB_PR_DEVICE) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 idesc->bInterfaceProtocol :
582 unusual_dev->useTransport;
Sebastian Andrzej Siewiorf61870e2012-08-28 22:37:13 +0200583 us->fflags = id->driver_info;
Hans de Goeded24d4812013-11-16 12:09:39 +0100584 usb_stor_adjust_quirks(us->pusb_dev, &us->fflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
Alan Stern7e4d6c32008-05-01 15:35:18 -0400586 if (us->fflags & US_FL_IGNORE_DEVICE) {
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300587 dev_info(pdev, "device ignored\n");
Daniel Drake3c332422006-07-26 13:59:23 +0100588 return -ENODEV;
589 }
590
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 /*
592 * This flag is only needed when we're in high-speed, so let's
593 * disable it if we're in full-speed
594 */
595 if (dev->speed != USB_SPEED_HIGH)
Alan Stern7e4d6c32008-05-01 15:35:18 -0400596 us->fflags &= ~US_FL_GO_SLOW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
Felipe Contreras39f2f082010-05-16 23:31:07 +0300598 if (us->fflags)
599 dev_info(pdev, "Quirks match for vid %04x pid %04x: %lx\n",
600 le16_to_cpu(dev->descriptor.idVendor),
601 le16_to_cpu(dev->descriptor.idProduct),
602 us->fflags);
603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 /* Log a message if a non-generic unusual_dev entry contains an
605 * unnecessary subclass or protocol override. This may stimulate
606 * reports from users that will help us remove unneeded entries
607 * from the unusual_devs.h table.
608 */
609 if (id->idVendor || id->idProduct) {
Arjan van de Ven4c4c9432005-11-29 09:43:42 +0100610 static const char *msgs[3] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 "an unneeded SubClass entry",
612 "an unneeded Protocol entry",
613 "unneeded SubClass and Protocol entries"};
614 struct usb_device_descriptor *ddesc = &dev->descriptor;
615 int msg = -1;
616
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200617 if (unusual_dev->useProtocol != USB_SC_DEVICE &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 us->subclass == idesc->bInterfaceSubClass)
619 msg += 1;
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200620 if (unusual_dev->useTransport != USB_PR_DEVICE &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 us->protocol == idesc->bInterfaceProtocol)
622 msg += 2;
Alan Stern7e4d6c32008-05-01 15:35:18 -0400623 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300624 dev_notice(pdev, "This device "
625 "(%04x,%04x,%04x S %02x P %02x)"
626 " has %s in unusual_devs.h (kernel"
627 " %s)\n"
628 " Please send a copy of this message to "
629 "<linux-usb@vger.kernel.org> and "
630 "<usb-storage@lists.one-eyed-alien.net>\n",
631 le16_to_cpu(ddesc->idVendor),
632 le16_to_cpu(ddesc->idProduct),
633 le16_to_cpu(ddesc->bcdDevice),
634 idesc->bInterfaceSubClass,
635 idesc->bInterfaceProtocol,
636 msgs[msg],
637 utsname()->release);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 }
Daniel Drake3c332422006-07-26 13:59:23 +0100639
640 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641}
642
643/* Get the transport settings */
Alan Sterne6e244b2009-02-12 14:47:44 -0500644static void get_transport(struct us_data *us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645{
646 switch (us->protocol) {
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200647 case USB_PR_CB:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 us->transport_name = "Control/Bulk";
649 us->transport = usb_stor_CB_transport;
650 us->transport_reset = usb_stor_CB_reset;
651 us->max_lun = 7;
652 break;
653
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200654 case USB_PR_CBI:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 us->transport_name = "Control/Bulk/Interrupt";
Alan Stern64648a92008-11-20 14:20:03 -0500656 us->transport = usb_stor_CB_transport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 us->transport_reset = usb_stor_CB_reset;
658 us->max_lun = 7;
659 break;
660
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200661 case USB_PR_BULK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 us->transport_name = "Bulk";
663 us->transport = usb_stor_Bulk_transport;
664 us->transport_reset = usb_stor_Bulk_reset;
665 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667}
668
669/* Get the protocol settings */
Alan Sterne6e244b2009-02-12 14:47:44 -0500670static void get_protocol(struct us_data *us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671{
672 switch (us->subclass) {
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200673 case USB_SC_RBC:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 us->protocol_name = "Reduced Block Commands (RBC)";
675 us->proto_handler = usb_stor_transparent_scsi_command;
676 break;
677
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200678 case USB_SC_8020:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 us->protocol_name = "8020i";
Alan Stern3dae5342008-11-20 14:22:18 -0500680 us->proto_handler = usb_stor_pad12_command;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 us->max_lun = 0;
682 break;
683
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200684 case USB_SC_QIC:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 us->protocol_name = "QIC-157";
Alan Stern3dae5342008-11-20 14:22:18 -0500686 us->proto_handler = usb_stor_pad12_command;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 us->max_lun = 0;
688 break;
689
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200690 case USB_SC_8070:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 us->protocol_name = "8070i";
Alan Stern3dae5342008-11-20 14:22:18 -0500692 us->proto_handler = usb_stor_pad12_command;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 us->max_lun = 0;
694 break;
695
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200696 case USB_SC_SCSI:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 us->protocol_name = "Transparent SCSI";
698 us->proto_handler = usb_stor_transparent_scsi_command;
699 break;
700
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200701 case USB_SC_UFI:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 us->protocol_name = "Uniform Floppy Interface (UFI)";
703 us->proto_handler = usb_stor_ufi_command;
704 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706}
707
708/* Get the pipe settings */
709static int get_pipes(struct us_data *us)
710{
711 struct usb_host_interface *altsetting =
712 us->pusb_intf->cur_altsetting;
713 int i;
714 struct usb_endpoint_descriptor *ep;
715 struct usb_endpoint_descriptor *ep_in = NULL;
716 struct usb_endpoint_descriptor *ep_out = NULL;
717 struct usb_endpoint_descriptor *ep_int = NULL;
718
719 /*
Alan Stern1096f782007-01-22 11:58:34 -0500720 * Find the first endpoint of each type we need.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 * We are expecting a minimum of 2 endpoints - in and out (bulk).
Alan Stern1096f782007-01-22 11:58:34 -0500722 * An optional interrupt-in is OK (necessary for CBI protocol).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 * We will ignore any others.
724 */
725 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
726 ep = &altsetting->endpoint[i].desc;
727
Luiz Fernando N. Capitulino04720742006-10-26 13:03:03 -0300728 if (usb_endpoint_xfer_bulk(ep)) {
Alan Stern1096f782007-01-22 11:58:34 -0500729 if (usb_endpoint_dir_in(ep)) {
730 if (!ep_in)
731 ep_in = ep;
732 } else {
733 if (!ep_out)
734 ep_out = ep;
735 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 }
737
Alan Stern1096f782007-01-22 11:58:34 -0500738 else if (usb_endpoint_is_int_in(ep)) {
739 if (!ep_int)
740 ep_int = ep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 }
742 }
743
Michal Nazarewicz8fa7fd72010-10-07 13:05:21 +0200744 if (!ep_in || !ep_out || (us->protocol == USB_PR_CBI && !ep_int)) {
Joe Perches191648d2013-04-19 11:44:00 -0700745 usb_stor_dbg(us, "Endpoint sanity check failed! Rejecting dev.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 return -EIO;
747 }
748
749 /* Calculate and store the pipe values */
750 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
751 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
752 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
Julia Lawall2e0fe702008-12-29 11:22:14 +0100753 usb_endpoint_num(ep_out));
Jeffrin Josea1631062012-05-17 00:33:36 +0530754 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
Julia Lawall2e0fe702008-12-29 11:22:14 +0100755 usb_endpoint_num(ep_in));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 if (ep_int) {
757 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
Julia Lawall2e0fe702008-12-29 11:22:14 +0100758 usb_endpoint_num(ep_int));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 us->ep_bInterval = ep_int->bInterval;
760 }
761 return 0;
762}
763
764/* Initialize all the dynamic resources we need */
765static int usb_stor_acquire_resources(struct us_data *us)
766{
767 int p;
Alan Stern3f13e662005-10-23 19:43:36 -0700768 struct task_struct *th;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
770 us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
771 if (!us->current_urb) {
Joe Perches191648d2013-04-19 11:44:00 -0700772 usb_stor_dbg(us, "URB allocation failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 return -ENOMEM;
774 }
775
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 /* Just before we start our control thread, initialize
777 * the device if it needs initialization */
Alan Sternb876aef2005-10-23 19:38:56 -0700778 if (us->unusual_dev->initFunction) {
779 p = us->unusual_dev->initFunction(us);
780 if (p)
781 return p;
782 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
784 /* Start up our control thread */
Alan Sterned76cac2007-06-07 17:12:25 -0400785 th = kthread_run(usb_stor_control_thread, us, "usb-storage");
Alan Stern3f13e662005-10-23 19:43:36 -0700786 if (IS_ERR(th)) {
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300787 dev_warn(&us->pusb_intf->dev,
788 "Unable to start control thread\n");
Alan Stern3f13e662005-10-23 19:43:36 -0700789 return PTR_ERR(th);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 }
Alan Sterned76cac2007-06-07 17:12:25 -0400791 us->ctl_thread = th;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
793 return 0;
794}
795
796/* Release all our dynamic resources */
797static void usb_stor_release_resources(struct us_data *us)
798{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 /* Tell the control thread to exit. The SCSI host must
Alan Stern543f7812008-05-08 11:55:59 -0400800 * already have been removed and the DISCONNECTING flag set
801 * so that we won't accept any more commands.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 */
Joe Perches191648d2013-04-19 11:44:00 -0700803 usb_stor_dbg(us, "-- sending exit command to thread\n");
Alan Stern7119e3c2008-05-01 15:36:13 -0400804 complete(&us->cmnd_ready);
Alan Sterned76cac2007-06-07 17:12:25 -0400805 if (us->ctl_thread)
806 kthread_stop(us->ctl_thread);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
808 /* Call the destructor routine, if it exists */
809 if (us->extra_destructor) {
Joe Perches191648d2013-04-19 11:44:00 -0700810 usb_stor_dbg(us, "-- calling extra_destructor()\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 us->extra_destructor(us->extra);
812 }
813
814 /* Free the extra data and the URB */
815 kfree(us->extra);
816 usb_free_urb(us->current_urb);
817}
818
819/* Dissociate from the USB device */
820static void dissociate_dev(struct us_data *us)
821{
Alan Stern0ede76f2010-03-05 15:10:17 -0500822 /* Free the buffers */
823 kfree(us->cr);
Daniel Mack997ea582010-04-12 13:17:25 +0200824 usb_free_coherent(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
826 /* Remove our private data from the interface */
827 usb_set_intfdata(us->pusb_intf, NULL);
828}
829
Alan Stern543f7812008-05-08 11:55:59 -0400830/* First stage of disconnect processing: stop SCSI scanning,
831 * remove the host, and stop accepting new commands
832 */
Matthew Dharm77f46322005-07-28 14:44:29 -0700833static void quiesce_and_remove_host(struct us_data *us)
834{
Alan Sterneecd11e2006-06-19 14:50:15 -0400835 struct Scsi_Host *host = us_to_host(us);
836
Alan Stern543f7812008-05-08 11:55:59 -0400837 /* If the device is really gone, cut short reset delays */
Alan Sternbb94a402012-02-21 13:16:32 -0500838 if (us->pusb_dev->state == USB_STATE_NOTATTACHED) {
Alan Stern543f7812008-05-08 11:55:59 -0400839 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
Alan Sternbb94a402012-02-21 13:16:32 -0500840 wake_up(&us->delay_wait);
841 }
Alan Stern543f7812008-05-08 11:55:59 -0400842
Alan Sternbb94a402012-02-21 13:16:32 -0500843 /* Prevent SCSI scanning (if it hasn't started yet)
844 * or wait for the SCSI-scanning routine to stop.
Alan Stern543f7812008-05-08 11:55:59 -0400845 */
Alan Sternbb94a402012-02-21 13:16:32 -0500846 cancel_delayed_work_sync(&us->scan_dwork);
847
848 /* Balance autopm calls if scanning was cancelled */
849 if (test_bit(US_FLIDX_SCAN_PENDING, &us->dflags))
850 usb_autopm_put_interface_no_suspend(us->pusb_intf);
Alan Stern543f7812008-05-08 11:55:59 -0400851
852 /* Removing the host will perform an orderly shutdown: caches
853 * synchronized, disks spun down, etc.
854 */
855 scsi_remove_host(host);
856
857 /* Prevent any new commands from being accepted and cut short
858 * reset delays.
859 */
Alan Sterneecd11e2006-06-19 14:50:15 -0400860 scsi_lock(host);
Alan Stern7e4d6c32008-05-01 15:35:18 -0400861 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
Alan Sterneecd11e2006-06-19 14:50:15 -0400862 scsi_unlock(host);
Matthew Dharm77f46322005-07-28 14:44:29 -0700863 wake_up(&us->delay_wait);
Matthew Dharm77f46322005-07-28 14:44:29 -0700864}
865
866/* Second stage of disconnect processing: deallocate all resources */
867static void release_everything(struct us_data *us)
868{
869 usb_stor_release_resources(us);
870 dissociate_dev(us);
871
872 /* Drop our reference to the host; the SCSI core will free it
873 * (and "us" along with it) when the refcount becomes 0. */
874 scsi_host_put(us_to_host(us));
875}
876
Alan Sternbb94a402012-02-21 13:16:32 -0500877/* Delayed-work routine to carry out SCSI-device scanning */
878static void usb_stor_scan_dwork(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879{
Alan Sternbb94a402012-02-21 13:16:32 -0500880 struct us_data *us = container_of(work, struct us_data,
881 scan_dwork.work);
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300882 struct device *dev = &us->pusb_intf->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883
Alan Sternbb94a402012-02-21 13:16:32 -0500884 dev_dbg(dev, "starting scan\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885
Alan Sternbb94a402012-02-21 13:16:32 -0500886 /* For bulk-only devices, determine the max LUN value */
887 if (us->protocol == USB_PR_BULK && !(us->fflags & US_FL_SINGLE_LUN)) {
888 mutex_lock(&us->dev_mutex);
889 us->max_lun = usb_stor_Bulk_max_lun(us);
890 mutex_unlock(&us->dev_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 }
Alan Sternbb94a402012-02-21 13:16:32 -0500892 scsi_scan_host(us_to_host(us));
893 dev_dbg(dev, "scan complete\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
Alan Sternbb94a402012-02-21 13:16:32 -0500895 /* Should we unbind if no devices were detected? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Alan Sternf2839252010-07-28 17:12:39 -0400897 usb_autopm_put_interface(us->pusb_intf);
Alan Sternbb94a402012-02-21 13:16:32 -0500898 clear_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899}
900
David Vrabel4c1bd3d2009-08-24 14:44:30 +0100901static unsigned int usb_stor_sg_tablesize(struct usb_interface *intf)
902{
903 struct usb_device *usb_dev = interface_to_usbdev(intf);
904
905 if (usb_dev->bus->sg_tablesize) {
906 return usb_dev->bus->sg_tablesize;
907 }
908 return SG_ALL;
909}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
Alan Sterne6e244b2009-02-12 14:47:44 -0500911/* First part of general USB mass-storage probing */
912int usb_stor_probe1(struct us_data **pus,
913 struct usb_interface *intf,
914 const struct usb_device_id *id,
915 struct us_unusual_dev *unusual_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916{
917 struct Scsi_Host *host;
918 struct us_data *us;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 int result;
Pete Zaitceva00828e2005-10-22 20:15:09 -0700920
Joe Perches191648d2013-04-19 11:44:00 -0700921 dev_info(&intf->dev, "USB Mass Storage device detected\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923 /*
924 * Ask the SCSI layer to allocate a host structure, with extra
925 * space at the end for our private us_data structure.
926 */
927 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
928 if (!host) {
Joe Perches191648d2013-04-19 11:44:00 -0700929 dev_warn(&intf->dev, "Unable to allocate the scsi host\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 return -ENOMEM;
931 }
932
Richard Sharpe17f060222007-10-10 10:56:28 -0700933 /*
934 * Allow 16-byte CDBs and thus > 2TB
935 */
936 host->max_cmd_len = 16;
David Vrabel4c1bd3d2009-08-24 14:44:30 +0100937 host->sg_tablesize = usb_stor_sg_tablesize(intf);
Alan Sterne6e244b2009-02-12 14:47:44 -0500938 *pus = us = host_to_us(host);
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100939 mutex_init(&(us->dev_mutex));
Ming Leic825bab2012-03-19 15:20:57 +0800940 us_set_lock_class(&us->dev_mutex, intf);
Alan Stern7119e3c2008-05-01 15:36:13 -0400941 init_completion(&us->cmnd_ready);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 init_completion(&(us->notify));
943 init_waitqueue_head(&us->delay_wait);
Alan Sternbb94a402012-02-21 13:16:32 -0500944 INIT_DELAYED_WORK(&us->scan_dwork, usb_stor_scan_dwork);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
946 /* Associate the us_data structure with the USB device */
947 result = associate_dev(us, intf);
948 if (result)
949 goto BadDevice;
950
Alan Sterne6e244b2009-02-12 14:47:44 -0500951 /* Get the unusual_devs entries and the descriptors */
952 result = get_device_info(us, id, unusual_dev);
Daniel Drake3c332422006-07-26 13:59:23 +0100953 if (result)
954 goto BadDevice;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
Alan Sterne6e244b2009-02-12 14:47:44 -0500956 /* Get standard transport and protocol settings */
957 get_transport(us);
958 get_protocol(us);
959
960 /* Give the caller a chance to fill in specialized transport
961 * or protocol settings.
962 */
963 return 0;
964
965BadDevice:
Joe Perches191648d2013-04-19 11:44:00 -0700966 usb_stor_dbg(us, "storage_probe() failed\n");
Alan Sterne6e244b2009-02-12 14:47:44 -0500967 release_everything(us);
968 return result;
969}
970EXPORT_SYMBOL_GPL(usb_stor_probe1);
971
972/* Second part of general USB mass-storage probing */
973int usb_stor_probe2(struct us_data *us)
974{
Alan Sterne6e244b2009-02-12 14:47:44 -0500975 int result;
Felipe Contrerascbd3af52010-05-16 23:31:06 +0300976 struct device *dev = &us->pusb_intf->dev;
Alan Sterne6e244b2009-02-12 14:47:44 -0500977
978 /* Make sure the transport and protocol have both been set */
979 if (!us->transport || !us->proto_handler) {
980 result = -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 goto BadDevice;
Alan Sterne6e244b2009-02-12 14:47:44 -0500982 }
Joe Perches191648d2013-04-19 11:44:00 -0700983 usb_stor_dbg(us, "Transport: %s\n", us->transport_name);
984 usb_stor_dbg(us, "Protocol: %s\n", us->protocol_name);
Alan Sterne6e244b2009-02-12 14:47:44 -0500985
986 /* fix for single-lun devices */
987 if (us->fflags & US_FL_SINGLE_LUN)
988 us->max_lun = 0;
989
Ming Leif4cc1832013-01-19 19:30:30 +0800990 if (!(us->fflags & US_FL_SCM_MULT_TARG))
991 us_to_host(us)->max_id = 1;
992
Alan Stern50c4e962014-09-02 11:35:50 -0400993 /*
994 * Like Windows, we won't store the LUN bits in CDB[1] for SCSI-2
995 * devices using the Bulk-Only transport (even though this violates
996 * the SCSI spec).
997 */
998 if (us->transport == usb_stor_Bulk_transport)
999 us_to_host(us)->no_scsi2_lun_in_cdb = 1;
1000
Alan Sterne6e244b2009-02-12 14:47:44 -05001001 /* Find the endpoints and calculate pipe values */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 result = get_pipes(us);
1003 if (result)
1004 goto BadDevice;
1005
Alan Stern21c13a42011-06-07 11:35:52 -04001006 /*
1007 * If the device returns invalid data for the first READ(10)
1008 * command, indicate the command should be retried.
1009 */
1010 if (us->fflags & US_FL_INITIAL_READ10)
1011 set_bit(US_FLIDX_REDO_READ10, &us->dflags);
1012
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 /* Acquire all the other resources and add the host */
1014 result = usb_stor_acquire_resources(us);
1015 if (result)
1016 goto BadDevice;
Matthew Wilcox00fa43e2009-09-24 16:19:11 -06001017 snprintf(us->scsi_name, sizeof(us->scsi_name), "usb-storage %s",
1018 dev_name(&us->pusb_intf->dev));
Felipe Contrerascbd3af52010-05-16 23:31:06 +03001019 result = scsi_add_host(us_to_host(us), dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 if (result) {
Felipe Contrerascbd3af52010-05-16 23:31:06 +03001021 dev_warn(dev,
1022 "Unable to add the scsi host\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 goto BadDevice;
1024 }
1025
Alan Sternbb94a402012-02-21 13:16:32 -05001026 /* Submit the delayed_work for SCSI-device scanning */
Alan Sternf2839252010-07-28 17:12:39 -04001027 usb_autopm_get_interface_no_resume(us->pusb_intf);
Alan Sternbb94a402012-02-21 13:16:32 -05001028 set_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
Alan Sternbb94a402012-02-21 13:16:32 -05001030 if (delay_use > 0)
1031 dev_dbg(dev, "waiting for device to settle before scanning\n");
1032 queue_delayed_work(system_freezable_wq, &us->scan_dwork,
1033 delay_use * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 return 0;
1035
1036 /* We come here if there are any problems */
1037BadDevice:
Joe Perches191648d2013-04-19 11:44:00 -07001038 usb_stor_dbg(us, "storage_probe() failed\n");
Matthew Dharm77f46322005-07-28 14:44:29 -07001039 release_everything(us);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 return result;
1041}
Alan Sterne6e244b2009-02-12 14:47:44 -05001042EXPORT_SYMBOL_GPL(usb_stor_probe2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
Alan Sterne6e244b2009-02-12 14:47:44 -05001044/* Handle a USB mass-storage disconnect */
1045void usb_stor_disconnect(struct usb_interface *intf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046{
1047 struct us_data *us = usb_get_intfdata(intf);
1048
Matthew Dharm77f46322005-07-28 14:44:29 -07001049 quiesce_and_remove_host(us);
1050 release_everything(us);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051}
Alan Sterne6e244b2009-02-12 14:47:44 -05001052EXPORT_SYMBOL_GPL(usb_stor_disconnect);
1053
1054/* The main probe routine for standard devices */
1055static int storage_probe(struct usb_interface *intf,
1056 const struct usb_device_id *id)
1057{
Huajun Lifd7ff362012-01-14 10:16:40 +08001058 struct us_unusual_dev *unusual_dev;
Alan Sterne6e244b2009-02-12 14:47:44 -05001059 struct us_data *us;
1060 int result;
Huajun Lifd7ff362012-01-14 10:16:40 +08001061 int size;
Alan Sterne6e244b2009-02-12 14:47:44 -05001062
Hans de Goede5bfd5b52013-10-21 09:40:48 +01001063 /* If uas is enabled and this device can do uas then ignore it. */
1064#if IS_ENABLED(CONFIG_USB_UAS)
1065 if (uas_use_uas_driver(intf, id))
1066 return -ENXIO;
1067#endif
1068
Alan Sterne6e244b2009-02-12 14:47:44 -05001069 /*
Alan Sterne6e244b2009-02-12 14:47:44 -05001070 * If the device isn't standard (is handled by a subdriver
1071 * module) then don't accept it.
1072 */
Sebastian Andrzej Siewiorf61870e2012-08-28 22:37:13 +02001073 if (usb_usual_ignore_device(intf))
Alan Sterne6e244b2009-02-12 14:47:44 -05001074 return -ENXIO;
1075
1076 /*
1077 * Call the general probe procedures.
1078 *
1079 * The unusual_dev_list array is parallel to the usb_storage_usb_ids
1080 * table, so we use the index of the id entry to find the
1081 * corresponding unusual_devs entry.
1082 */
Huajun Lifd7ff362012-01-14 10:16:40 +08001083
1084 size = ARRAY_SIZE(us_unusual_dev_list);
1085 if (id >= usb_storage_usb_ids && id < usb_storage_usb_ids + size) {
1086 unusual_dev = (id - usb_storage_usb_ids) + us_unusual_dev_list;
1087 } else {
1088 unusual_dev = &for_dynamic_ids;
1089
Joe Perches191648d2013-04-19 11:44:00 -07001090 dev_dbg(&intf->dev, "Use Bulk-Only transport with the Transparent SCSI protocol for dynamic id: 0x%04x 0x%04x\n",
Huajun Lifd7ff362012-01-14 10:16:40 +08001091 id->idVendor, id->idProduct);
1092 }
1093
1094 result = usb_stor_probe1(&us, intf, id, unusual_dev);
Alan Sterne6e244b2009-02-12 14:47:44 -05001095 if (result)
1096 return result;
1097
1098 /* No special transport or protocol settings in the main module */
1099
1100 result = usb_stor_probe2(us);
1101 return result;
1102}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103
Alan Sternce2596d2005-10-23 19:41:39 -07001104static struct usb_driver usb_storage_driver = {
Alan Sternce2596d2005-10-23 19:41:39 -07001105 .name = "usb-storage",
1106 .probe = storage_probe,
Alan Sterne6e244b2009-02-12 14:47:44 -05001107 .disconnect = usb_stor_disconnect,
1108 .suspend = usb_stor_suspend,
1109 .resume = usb_stor_resume,
1110 .reset_resume = usb_stor_reset_resume,
1111 .pre_reset = usb_stor_pre_reset,
1112 .post_reset = usb_stor_post_reset,
1113 .id_table = usb_storage_usb_ids,
Alan Sternf2839252010-07-28 17:12:39 -04001114 .supports_autosuspend = 1,
Alan Stern543f7812008-05-08 11:55:59 -04001115 .soft_unbind = 1,
Alan Sternce2596d2005-10-23 19:41:39 -07001116};
1117
Greg Kroah-Hartman4601de82013-04-19 11:50:10 -07001118module_usb_driver(usb_storage_driver);