Branch data Line data Source code
1 : : /* Driver for USB Mass Storage compliant devices
2 : : *
3 : : * 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)
8 : : * (c) 2003-2009 Alan Stern (stern@rowland.harvard.edu)
9 : : *
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 : :
48 : : #ifdef CONFIG_USB_STORAGE_DEBUG
49 : : #define DEBUG
50 : : #endif
51 : :
52 : : #include <linux/sched.h>
53 : : #include <linux/errno.h>
54 : : #include <linux/freezer.h>
55 : : #include <linux/module.h>
56 : : #include <linux/slab.h>
57 : : #include <linux/kthread.h>
58 : : #include <linux/mutex.h>
59 : : #include <linux/utsname.h>
60 : :
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 : :
72 : : #include "sierra_ms.h"
73 : : #include "option_ms.h"
74 : :
75 : : /* Some informational data */
76 : : MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
77 : : MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
78 : : MODULE_LICENSE("GPL");
79 : :
80 : : static unsigned int delay_use = 1;
81 : : module_param(delay_use, uint, S_IRUGO | S_IWUSR);
82 : : MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
83 : :
84 : : static char quirks[128];
85 : : module_param_string(quirks, quirks, sizeof(quirks), S_IRUGO | S_IWUSR);
86 : : MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
87 : :
88 : :
89 : : /*
90 : : * The entries in this table correspond, line for line,
91 : : * with the entries in usb_storage_usb_ids[], defined in usual-tables.c.
92 : : */
93 : :
94 : : /* The vendor name should be kept at eight characters or less, and
95 : : * the product name should be kept at 16 characters or less. If a device
96 : : * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
97 : : * normally generated by a device thorugh the INQUIRY response will be
98 : : * taken from this list, and this is the reason for the above size
99 : : * restriction. However, if the flag is not present, then you
100 : : * are free to use as many characters as you like.
101 : : */
102 : :
103 : : #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
104 : : vendor_name, product_name, use_protocol, use_transport, \
105 : : init_function, Flags) \
106 : : { \
107 : : .vendorName = vendor_name, \
108 : : .productName = product_name, \
109 : : .useProtocol = use_protocol, \
110 : : .useTransport = use_transport, \
111 : : .initFunction = init_function, \
112 : : }
113 : :
114 : : #define COMPLIANT_DEV UNUSUAL_DEV
115 : :
116 : : #define USUAL_DEV(use_protocol, use_transport) \
117 : : { \
118 : : .useProtocol = use_protocol, \
119 : : .useTransport = use_transport, \
120 : : }
121 : :
122 : : #define UNUSUAL_VENDOR_INTF(idVendor, cl, sc, pr, \
123 : : vendor_name, product_name, use_protocol, use_transport, \
124 : : init_function, Flags) \
125 : : { \
126 : : .vendorName = vendor_name, \
127 : : .productName = product_name, \
128 : : .useProtocol = use_protocol, \
129 : : .useTransport = use_transport, \
130 : : .initFunction = init_function, \
131 : : }
132 : :
133 : : static struct us_unusual_dev us_unusual_dev_list[] = {
134 : : # include "unusual_devs.h"
135 : : { } /* Terminating entry */
136 : : };
137 : :
138 : : static struct us_unusual_dev for_dynamic_ids =
139 : : USUAL_DEV(USB_SC_SCSI, USB_PR_BULK);
140 : :
141 : : #undef UNUSUAL_DEV
142 : : #undef COMPLIANT_DEV
143 : : #undef USUAL_DEV
144 : : #undef UNUSUAL_VENDOR_INTF
145 : :
146 : : #ifdef CONFIG_LOCKDEP
147 : :
148 : : static struct lock_class_key us_interface_key[USB_MAXINTERFACES];
149 : :
150 : : static void us_set_lock_class(struct mutex *mutex,
151 : : struct usb_interface *intf)
152 : : {
153 : : struct usb_device *udev = interface_to_usbdev(intf);
154 : : struct usb_host_config *config = udev->actconfig;
155 : : int i;
156 : :
157 : : for (i = 0; i < config->desc.bNumInterfaces; i++) {
158 : : if (config->interface[i] == intf)
159 : : break;
160 : : }
161 : :
162 : : BUG_ON(i == config->desc.bNumInterfaces);
163 : :
164 : : lockdep_set_class(mutex, &us_interface_key[i]);
165 : : }
166 : :
167 : : #else
168 : :
169 : : static void us_set_lock_class(struct mutex *mutex,
170 : : struct usb_interface *intf)
171 : : {
172 : : }
173 : :
174 : : #endif
175 : :
176 : : #ifdef CONFIG_PM /* Minimal support for suspend and resume */
177 : :
178 : 0 : int usb_stor_suspend(struct usb_interface *iface, pm_message_t message)
179 : : {
180 : : struct us_data *us = usb_get_intfdata(iface);
181 : :
182 : : /* Wait until no command is running */
183 : 0 : mutex_lock(&us->dev_mutex);
184 : :
185 [ # # ]: 0 : if (us->suspend_resume_hook)
186 : 0 : (us->suspend_resume_hook)(us, US_SUSPEND);
187 : :
188 : : /* When runtime PM is working, we'll set a flag to indicate
189 : : * whether we should autoresume when a SCSI request arrives. */
190 : :
191 : 0 : mutex_unlock(&us->dev_mutex);
192 : 0 : return 0;
193 : : }
194 : : EXPORT_SYMBOL_GPL(usb_stor_suspend);
195 : :
196 : 0 : int usb_stor_resume(struct usb_interface *iface)
197 : : {
198 : : struct us_data *us = usb_get_intfdata(iface);
199 : :
200 : 0 : mutex_lock(&us->dev_mutex);
201 : :
202 [ # # ]: 0 : if (us->suspend_resume_hook)
203 : 0 : (us->suspend_resume_hook)(us, US_RESUME);
204 : :
205 : 0 : mutex_unlock(&us->dev_mutex);
206 : 0 : return 0;
207 : : }
208 : : EXPORT_SYMBOL_GPL(usb_stor_resume);
209 : :
210 : 0 : int usb_stor_reset_resume(struct usb_interface *iface)
211 : : {
212 : : struct us_data *us = usb_get_intfdata(iface);
213 : :
214 : : /* Report the reset to the SCSI core */
215 : 0 : usb_stor_report_bus_reset(us);
216 : :
217 : : /* FIXME: Notify the subdrivers that they need to reinitialize
218 : : * the device */
219 : 0 : return 0;
220 : : }
221 : : EXPORT_SYMBOL_GPL(usb_stor_reset_resume);
222 : :
223 : : #endif /* CONFIG_PM */
224 : :
225 : : /*
226 : : * The next two routines get called just before and just after
227 : : * a USB port reset, whether from this driver or a different one.
228 : : */
229 : :
230 : 0 : int usb_stor_pre_reset(struct usb_interface *iface)
231 : : {
232 : : struct us_data *us = usb_get_intfdata(iface);
233 : :
234 : : /* Make sure no command runs during the reset */
235 : 0 : mutex_lock(&us->dev_mutex);
236 : 0 : return 0;
237 : : }
238 : : EXPORT_SYMBOL_GPL(usb_stor_pre_reset);
239 : :
240 : 0 : int usb_stor_post_reset(struct usb_interface *iface)
241 : : {
242 : : struct us_data *us = usb_get_intfdata(iface);
243 : :
244 : : /* Report the reset to the SCSI core */
245 : 0 : usb_stor_report_bus_reset(us);
246 : :
247 : : /* FIXME: Notify the subdrivers that they need to reinitialize
248 : : * the device */
249 : :
250 : 0 : mutex_unlock(&us->dev_mutex);
251 : 0 : return 0;
252 : : }
253 : : EXPORT_SYMBOL_GPL(usb_stor_post_reset);
254 : :
255 : : /*
256 : : * fill_inquiry_response takes an unsigned char array (which must
257 : : * be at least 36 characters) and populates the vendor name,
258 : : * product name, and revision fields. Then the array is copied
259 : : * into the SCSI command's response buffer (oddly enough
260 : : * called request_buffer). data_len contains the length of the
261 : : * data array, which again must be at least 36.
262 : : */
263 : :
264 : 0 : void fill_inquiry_response(struct us_data *us, unsigned char *data,
265 : : unsigned int data_len)
266 : : {
267 [ # # ]: 0 : if (data_len < 36) /* You lose. */
268 : 0 : return;
269 : :
270 : 0 : memset(data+8, ' ', 28);
271 [ # # ]: 0 : if (data[0]&0x20) { /* USB device currently not connected. Return
272 : : peripheral qualifier 001b ("...however, the
273 : : physical device is not currently connected
274 : : to this logical unit") and leave vendor and
275 : : product identification empty. ("If the target
276 : : does store some of the INQUIRY data on the
277 : : device, it may return zeros or ASCII spaces
278 : : (20h) in those fields until the data is
279 : : available from the device."). */
280 : : } else {
281 : 0 : u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
282 : : int n;
283 : :
284 : 0 : n = strlen(us->unusual_dev->vendorName);
285 : 0 : memcpy(data+8, us->unusual_dev->vendorName, min(8, n));
286 : 0 : n = strlen(us->unusual_dev->productName);
287 : 0 : memcpy(data+16, us->unusual_dev->productName, min(16, n));
288 : :
289 : 0 : data[32] = 0x30 + ((bcdDevice>>12) & 0x0F);
290 : 0 : data[33] = 0x30 + ((bcdDevice>>8) & 0x0F);
291 : 0 : data[34] = 0x30 + ((bcdDevice>>4) & 0x0F);
292 : 0 : data[35] = 0x30 + ((bcdDevice) & 0x0F);
293 : : }
294 : :
295 : 0 : usb_stor_set_xfer_buf(data, data_len, us->srb);
296 : : }
297 : : EXPORT_SYMBOL_GPL(fill_inquiry_response);
298 : :
299 : 0 : static int usb_stor_control_thread(void * __us)
300 : : {
301 : : struct us_data *us = (struct us_data *)__us;
302 : : struct Scsi_Host *host = us_to_host(us);
303 : :
304 : : for (;;) {
305 : : usb_stor_dbg(us, "*** thread sleeping\n");
306 [ + - ]: 401979 : if (wait_for_completion_interruptible(&us->cmnd_ready))
307 : : break;
308 : :
309 : : usb_stor_dbg(us, "*** thread awakened\n");
310 : :
311 : : /* lock the device pointers */
312 : 401979 : mutex_lock(&(us->dev_mutex));
313 : :
314 : : /* lock access to the state */
315 : 401979 : scsi_lock(host);
316 : :
317 : : /* When we are called with no command pending, we're done */
318 [ - + ]: 401979 : if (us->srb == NULL) {
319 : 0 : scsi_unlock(host);
320 : 0 : mutex_unlock(&us->dev_mutex);
321 : : usb_stor_dbg(us, "-- exiting\n");
322 : 0 : break;
323 : : }
324 : :
325 : : /* has the command timed out *already* ? */
326 [ - + ]: 401979 : if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
327 : 0 : us->srb->result = DID_ABORT << 16;
328 : 0 : goto SkipForAbort;
329 : : }
330 : :
331 : 401979 : scsi_unlock(host);
332 : :
333 : : /* reject the command if the direction indicator
334 : : * is UNKNOWN
335 : : */
336 [ - + ]: 401979 : if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
337 : : usb_stor_dbg(us, "UNKNOWN data direction\n");
338 : 0 : us->srb->result = DID_ERROR << 16;
339 : : }
340 : :
341 : : /* reject if target != 0 or if LUN is higher than
342 : : * the maximum known LUN
343 : : */
344 [ - + ][ # # ]: 401979 : else if (us->srb->device->id &&
345 : 0 : !(us->fflags & US_FL_SCM_MULT_TARG)) {
346 : : usb_stor_dbg(us, "Bad target number (%d:%d)\n",
347 : : us->srb->device->id, us->srb->device->lun);
348 : 0 : us->srb->result = DID_BAD_TARGET << 16;
349 : : }
350 : :
351 [ - + ]: 401979 : else if (us->srb->device->lun > us->max_lun) {
352 : : usb_stor_dbg(us, "Bad LUN (%d:%d)\n",
353 : : us->srb->device->id, us->srb->device->lun);
354 : 0 : us->srb->result = DID_BAD_TARGET << 16;
355 : : }
356 : :
357 : : /* Handle those devices which need us to fake
358 : : * their inquiry data */
359 [ - + ][ # # ]: 401979 : else if ((us->srb->cmnd[0] == INQUIRY) &&
360 : 0 : (us->fflags & US_FL_FIX_INQUIRY)) {
361 : 0 : unsigned char data_ptr[36] = {
362 : : 0x00, 0x80, 0x02, 0x02,
363 : : 0x1F, 0x00, 0x00, 0x00};
364 : :
365 : : usb_stor_dbg(us, "Faking INQUIRY command\n");
366 : 0 : fill_inquiry_response(us, data_ptr, 36);
367 : 0 : us->srb->result = SAM_STAT_GOOD;
368 : : }
369 : :
370 : : /* we've got a command, let's do it! */
371 : : else {
372 : : US_DEBUG(usb_stor_show_command(us, us->srb));
373 : 401979 : us->proto_handler(us->srb, us);
374 : : usb_mark_last_busy(us->pusb_dev);
375 : : }
376 : :
377 : : /* lock access to the state */
378 : 401979 : scsi_lock(host);
379 : :
380 : : /* indicate that the command is done */
381 [ + - ]: 401979 : if (us->srb->result != DID_ABORT << 16) {
382 : : usb_stor_dbg(us, "scsi cmd done, result=0x%x\n",
383 : : us->srb->result);
384 : 401979 : us->srb->scsi_done(us->srb);
385 : : } else {
386 : : SkipForAbort:
387 : : usb_stor_dbg(us, "scsi command aborted\n");
388 : : }
389 : :
390 : : /* If an abort request was received we need to signal that
391 : : * the abort has finished. The proper test for this is
392 : : * the TIMED_OUT flag, not srb->result == DID_ABORT, because
393 : : * the timeout might have occurred after the command had
394 : : * already completed with a different result code. */
395 [ - + ]: 401979 : if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
396 : 0 : complete(&(us->notify));
397 : :
398 : : /* Allow USB transfers to resume */
399 : 0 : clear_bit(US_FLIDX_ABORTING, &us->dflags);
400 : 0 : clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
401 : : }
402 : :
403 : : /* finished working on this command */
404 : 401979 : us->srb = NULL;
405 : 401979 : scsi_unlock(host);
406 : :
407 : : /* unlock the device pointers */
408 : 401979 : mutex_unlock(&us->dev_mutex);
409 : 401979 : } /* for (;;) */
410 : :
411 : : /* Wait until we are told to stop */
412 : : for (;;) {
413 : 0 : set_current_state(TASK_INTERRUPTIBLE);
414 [ # # ]: 0 : if (kthread_should_stop())
415 : : break;
416 : 0 : schedule();
417 : 0 : }
418 : 0 : __set_current_state(TASK_RUNNING);
419 : 0 : return 0;
420 : : }
421 : :
422 : : /***********************************************************************
423 : : * Device probing and disconnecting
424 : : ***********************************************************************/
425 : :
426 : : /* Associate our private data with the USB device */
427 : 0 : static int associate_dev(struct us_data *us, struct usb_interface *intf)
428 : : {
429 : : /* Fill in the device-related fields */
430 : 0 : us->pusb_dev = interface_to_usbdev(intf);
431 : 0 : us->pusb_intf = intf;
432 : 0 : us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
433 : : usb_stor_dbg(us, "Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n",
434 : : le16_to_cpu(us->pusb_dev->descriptor.idVendor),
435 : : le16_to_cpu(us->pusb_dev->descriptor.idProduct),
436 : : le16_to_cpu(us->pusb_dev->descriptor.bcdDevice));
437 : : usb_stor_dbg(us, "Interface Subclass: 0x%02x, Protocol: 0x%02x\n",
438 : : intf->cur_altsetting->desc.bInterfaceSubClass,
439 : : intf->cur_altsetting->desc.bInterfaceProtocol);
440 : :
441 : : /* Store our private data in the interface */
442 : : usb_set_intfdata(intf, us);
443 : :
444 : : /* Allocate the control/setup and DMA-mapped buffers */
445 : 0 : us->cr = kmalloc(sizeof(*us->cr), GFP_KERNEL);
446 [ # # ]: 0 : if (!us->cr)
447 : : return -ENOMEM;
448 : :
449 : 0 : us->iobuf = usb_alloc_coherent(us->pusb_dev, US_IOBUF_SIZE,
450 : : GFP_KERNEL, &us->iobuf_dma);
451 [ # # ]: 0 : if (!us->iobuf) {
452 : : usb_stor_dbg(us, "I/O buffer allocation failed\n");
453 : : return -ENOMEM;
454 : : }
455 : 0 : return 0;
456 : : }
457 : :
458 : : /* Works only for digits and letters, but small and fast */
459 : : #define TOLOWER(x) ((x) | 0x20)
460 : :
461 : : /* Adjust device flags based on the "quirks=" module parameter */
462 : 0 : static void adjust_quirks(struct us_data *us)
463 : : {
464 : : char *p;
465 : 0 : u16 vid = le16_to_cpu(us->pusb_dev->descriptor.idVendor);
466 : 0 : u16 pid = le16_to_cpu(us->pusb_dev->descriptor.idProduct);
467 : : unsigned f = 0;
468 : : unsigned int mask = (US_FL_SANE_SENSE | US_FL_BAD_SENSE |
469 : : US_FL_FIX_CAPACITY |
470 : : US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE |
471 : : US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
472 : : US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
473 : : US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT |
474 : : US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16 |
475 : : US_FL_INITIAL_READ10 | US_FL_WRITE_CACHE);
476 : :
477 : 0 : p = quirks;
478 [ # # ]: 0 : while (*p) {
479 : : /* Each entry consists of VID:PID:flags */
480 [ # # ][ # # ]: 0 : if (vid == simple_strtoul(p, &p, 16) &&
481 [ # # ]: 0 : *p == ':' &&
482 [ # # ]: 0 : pid == simple_strtoul(p+1, &p, 16) &&
483 : 0 : *p == ':')
484 : : break;
485 : :
486 : : /* Move forward to the next entry */
487 [ # # ]: 0 : while (*p) {
488 [ # # ]: 0 : if (*p++ == ',')
489 : : break;
490 : : }
491 : : }
492 [ # # ]: 0 : if (!*p) /* No match */
493 : 0 : return;
494 : :
495 : : /* Collect the flags */
496 [ # # ][ # # ]: 0 : while (*++p && *p != ',') {
497 [ # # # # : 0 : switch (TOLOWER(*p)) {
# # # # #
# # # # #
# # ]
498 : : case 'a':
499 : 0 : f |= US_FL_SANE_SENSE;
500 : : break;
501 : : case 'b':
502 : 0 : f |= US_FL_BAD_SENSE;
503 : : break;
504 : : case 'c':
505 : 0 : f |= US_FL_FIX_CAPACITY;
506 : : break;
507 : : case 'd':
508 : 0 : f |= US_FL_NO_READ_DISC_INFO;
509 : : break;
510 : : case 'e':
511 : 0 : f |= US_FL_NO_READ_CAPACITY_16;
512 : : break;
513 : : case 'h':
514 : 0 : f |= US_FL_CAPACITY_HEURISTICS;
515 : : break;
516 : : case 'i':
517 : 0 : f |= US_FL_IGNORE_DEVICE;
518 : : break;
519 : : case 'l':
520 : 0 : f |= US_FL_NOT_LOCKABLE;
521 : : break;
522 : : case 'm':
523 : 0 : f |= US_FL_MAX_SECTORS_64;
524 : : break;
525 : : case 'n':
526 : 0 : f |= US_FL_INITIAL_READ10;
527 : : break;
528 : : case 'o':
529 : 0 : f |= US_FL_CAPACITY_OK;
530 : : break;
531 : : case 'p':
532 : 0 : f |= US_FL_WRITE_CACHE;
533 : : break;
534 : : case 'r':
535 : 0 : f |= US_FL_IGNORE_RESIDUE;
536 : : break;
537 : : case 's':
538 : 0 : f |= US_FL_SINGLE_LUN;
539 : : break;
540 : : case 'w':
541 : 0 : f |= US_FL_NO_WP_DETECT;
542 : : break;
543 : : /* Ignore unrecognized flag characters */
544 : : }
545 : : }
546 : 0 : us->fflags = (us->fflags & ~mask) | f;
547 : : }
548 : :
549 : : /* Get the unusual_devs entries and the string descriptors */
550 : 0 : static int get_device_info(struct us_data *us, const struct usb_device_id *id,
551 : : struct us_unusual_dev *unusual_dev)
552 : : {
553 : 0 : struct usb_device *dev = us->pusb_dev;
554 : : struct usb_interface_descriptor *idesc =
555 : 0 : &us->pusb_intf->cur_altsetting->desc;
556 : 0 : struct device *pdev = &us->pusb_intf->dev;
557 : :
558 : : /* Store the entries */
559 : 0 : us->unusual_dev = unusual_dev;
560 [ # # ]: 0 : us->subclass = (unusual_dev->useProtocol == USB_SC_DEVICE) ?
561 : : idesc->bInterfaceSubClass :
562 : : unusual_dev->useProtocol;
563 [ # # ]: 0 : us->protocol = (unusual_dev->useTransport == USB_PR_DEVICE) ?
564 : : idesc->bInterfaceProtocol :
565 : : unusual_dev->useTransport;
566 : 0 : us->fflags = id->driver_info;
567 : 0 : adjust_quirks(us);
568 : :
569 [ # # ]: 0 : if (us->fflags & US_FL_IGNORE_DEVICE) {
570 : 0 : dev_info(pdev, "device ignored\n");
571 : 0 : return -ENODEV;
572 : : }
573 : :
574 : : /*
575 : : * This flag is only needed when we're in high-speed, so let's
576 : : * disable it if we're in full-speed
577 : : */
578 [ # # ]: 0 : if (dev->speed != USB_SPEED_HIGH)
579 : 0 : us->fflags &= ~US_FL_GO_SLOW;
580 : :
581 [ # # ]: 0 : if (us->fflags)
582 : 0 : dev_info(pdev, "Quirks match for vid %04x pid %04x: %lx\n",
583 : : le16_to_cpu(dev->descriptor.idVendor),
584 : : le16_to_cpu(dev->descriptor.idProduct),
585 : : us->fflags);
586 : :
587 : : /* Log a message if a non-generic unusual_dev entry contains an
588 : : * unnecessary subclass or protocol override. This may stimulate
589 : : * reports from users that will help us remove unneeded entries
590 : : * from the unusual_devs.h table.
591 : : */
592 [ # # ][ # # ]: 0 : if (id->idVendor || id->idProduct) {
593 : : static const char *msgs[3] = {
594 : : "an unneeded SubClass entry",
595 : : "an unneeded Protocol entry",
596 : : "unneeded SubClass and Protocol entries"};
597 : : struct usb_device_descriptor *ddesc = &dev->descriptor;
598 : : int msg = -1;
599 : :
600 [ # # ][ # # ]: 0 : if (unusual_dev->useProtocol != USB_SC_DEVICE &&
601 : 0 : us->subclass == idesc->bInterfaceSubClass)
602 : : msg += 1;
603 [ # # ][ # # ]: 0 : if (unusual_dev->useTransport != USB_PR_DEVICE &&
604 : 0 : us->protocol == idesc->bInterfaceProtocol)
605 : 0 : msg += 2;
606 [ # # ][ # # ]: 0 : if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
607 : 0 : dev_notice(pdev, "This device "
608 : : "(%04x,%04x,%04x S %02x P %02x)"
609 : : " has %s in unusual_devs.h (kernel"
610 : : " %s)\n"
611 : : " Please send a copy of this message to "
612 : : "<linux-usb@vger.kernel.org> and "
613 : : "<usb-storage@lists.one-eyed-alien.net>\n",
614 : 0 : le16_to_cpu(ddesc->idVendor),
615 : 0 : le16_to_cpu(ddesc->idProduct),
616 : 0 : le16_to_cpu(ddesc->bcdDevice),
617 : 0 : idesc->bInterfaceSubClass,
618 : 0 : idesc->bInterfaceProtocol,
619 : : msgs[msg],
620 : 0 : utsname()->release);
621 : : }
622 : :
623 : : return 0;
624 : : }
625 : :
626 : : /* Get the transport settings */
627 : 0 : static void get_transport(struct us_data *us)
628 : : {
629 [ # # # # ]: 0 : switch (us->protocol) {
630 : : case USB_PR_CB:
631 : 0 : us->transport_name = "Control/Bulk";
632 : 0 : us->transport = usb_stor_CB_transport;
633 : 0 : us->transport_reset = usb_stor_CB_reset;
634 : 0 : us->max_lun = 7;
635 : 0 : break;
636 : :
637 : : case USB_PR_CBI:
638 : 0 : us->transport_name = "Control/Bulk/Interrupt";
639 : 0 : us->transport = usb_stor_CB_transport;
640 : 0 : us->transport_reset = usb_stor_CB_reset;
641 : 0 : us->max_lun = 7;
642 : 0 : break;
643 : :
644 : : case USB_PR_BULK:
645 : 0 : us->transport_name = "Bulk";
646 : 0 : us->transport = usb_stor_Bulk_transport;
647 : 0 : us->transport_reset = usb_stor_Bulk_reset;
648 : 0 : break;
649 : : }
650 : 0 : }
651 : :
652 : : /* Get the protocol settings */
653 : 0 : static void get_protocol(struct us_data *us)
654 : : {
655 [ # # # # : 0 : switch (us->subclass) {
# # # ]
656 : : case USB_SC_RBC:
657 : 0 : us->protocol_name = "Reduced Block Commands (RBC)";
658 : 0 : us->proto_handler = usb_stor_transparent_scsi_command;
659 : 0 : break;
660 : :
661 : : case USB_SC_8020:
662 : 0 : us->protocol_name = "8020i";
663 : 0 : us->proto_handler = usb_stor_pad12_command;
664 : 0 : us->max_lun = 0;
665 : 0 : break;
666 : :
667 : : case USB_SC_QIC:
668 : 0 : us->protocol_name = "QIC-157";
669 : 0 : us->proto_handler = usb_stor_pad12_command;
670 : 0 : us->max_lun = 0;
671 : 0 : break;
672 : :
673 : : case USB_SC_8070:
674 : 0 : us->protocol_name = "8070i";
675 : 0 : us->proto_handler = usb_stor_pad12_command;
676 : 0 : us->max_lun = 0;
677 : 0 : break;
678 : :
679 : : case USB_SC_SCSI:
680 : 0 : us->protocol_name = "Transparent SCSI";
681 : 0 : us->proto_handler = usb_stor_transparent_scsi_command;
682 : 0 : break;
683 : :
684 : : case USB_SC_UFI:
685 : 0 : us->protocol_name = "Uniform Floppy Interface (UFI)";
686 : 0 : us->proto_handler = usb_stor_ufi_command;
687 : 0 : break;
688 : : }
689 : 0 : }
690 : :
691 : : /* Get the pipe settings */
692 : 0 : static int get_pipes(struct us_data *us)
693 : : {
694 : 0 : struct usb_host_interface *altsetting =
695 : 0 : us->pusb_intf->cur_altsetting;
696 : : int i;
697 : 0 : struct usb_endpoint_descriptor *ep;
698 : 0 : struct usb_endpoint_descriptor *ep_in = NULL;
699 : 0 : struct usb_endpoint_descriptor *ep_out = NULL;
700 : 0 : struct usb_endpoint_descriptor *ep_int = NULL;
701 : :
702 : : /*
703 : : * Find the first endpoint of each type we need.
704 : : * We are expecting a minimum of 2 endpoints - in and out (bulk).
705 : : * An optional interrupt-in is OK (necessary for CBI protocol).
706 : : * We will ignore any others.
707 : : */
708 [ # # ]: 0 : for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
709 : 0 : ep = &altsetting->endpoint[i].desc;
710 : :
711 [ # # ]: 0 : if (usb_endpoint_xfer_bulk(ep)) {
712 [ # # ]: 0 : if (usb_endpoint_dir_in(ep)) {
713 [ # # ]: 0 : if (!ep_in)
714 : : ep_in = ep;
715 : : } else {
716 [ # # ]: 0 : if (!ep_out)
717 : : ep_out = ep;
718 : : }
719 : : }
720 : :
721 [ # # ]: 0 : else if (usb_endpoint_is_int_in(ep)) {
722 [ # # ]: 0 : if (!ep_int)
723 : : ep_int = ep;
724 : : }
725 : : }
726 : :
727 [ # # ][ # # ]: 0 : if (!ep_in || !ep_out || (us->protocol == USB_PR_CBI && !ep_int)) {
[ # # ]
728 : : usb_stor_dbg(us, "Endpoint sanity check failed! Rejecting dev.\n");
729 : : return -EIO;
730 : : }
731 : :
732 : : /* Calculate and store the pipe values */
733 : 0 : us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
734 : 0 : us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
735 : 0 : us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
736 : : usb_endpoint_num(ep_out));
737 : 0 : us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
738 : : usb_endpoint_num(ep_in));
739 [ # # ]: 0 : if (ep_int) {
740 : 0 : us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
741 : : usb_endpoint_num(ep_int));
742 : 0 : us->ep_bInterval = ep_int->bInterval;
743 : : }
744 : : return 0;
745 : : }
746 : :
747 : : /* Initialize all the dynamic resources we need */
748 : 0 : static int usb_stor_acquire_resources(struct us_data *us)
749 : : {
750 : : int p;
751 : : struct task_struct *th;
752 : :
753 : 0 : us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
754 [ # # ]: 0 : if (!us->current_urb) {
755 : : usb_stor_dbg(us, "URB allocation failed\n");
756 : : return -ENOMEM;
757 : : }
758 : :
759 : : /* Just before we start our control thread, initialize
760 : : * the device if it needs initialization */
761 [ # # ]: 0 : if (us->unusual_dev->initFunction) {
762 : 0 : p = us->unusual_dev->initFunction(us);
763 [ # # ]: 0 : if (p)
764 : : return p;
765 : : }
766 : :
767 : : /* Start up our control thread */
768 [ # # ]: 0 : th = kthread_run(usb_stor_control_thread, us, "usb-storage");
769 [ # # ]: 0 : if (IS_ERR(th)) {
770 : 0 : dev_warn(&us->pusb_intf->dev,
771 : : "Unable to start control thread\n");
772 : 0 : return PTR_ERR(th);
773 : : }
774 : 0 : us->ctl_thread = th;
775 : :
776 : 0 : return 0;
777 : : }
778 : :
779 : : /* Release all our dynamic resources */
780 : 0 : static void usb_stor_release_resources(struct us_data *us)
781 : : {
782 : : /* Tell the control thread to exit. The SCSI host must
783 : : * already have been removed and the DISCONNECTING flag set
784 : : * so that we won't accept any more commands.
785 : : */
786 : : usb_stor_dbg(us, "-- sending exit command to thread\n");
787 : 0 : complete(&us->cmnd_ready);
788 [ # # ]: 0 : if (us->ctl_thread)
789 : 0 : kthread_stop(us->ctl_thread);
790 : :
791 : : /* Call the destructor routine, if it exists */
792 [ # # ]: 0 : if (us->extra_destructor) {
793 : : usb_stor_dbg(us, "-- calling extra_destructor()\n");
794 : 0 : us->extra_destructor(us->extra);
795 : : }
796 : :
797 : : /* Free the extra data and the URB */
798 : 0 : kfree(us->extra);
799 : 0 : usb_free_urb(us->current_urb);
800 : 0 : }
801 : :
802 : : /* Dissociate from the USB device */
803 : 0 : static void dissociate_dev(struct us_data *us)
804 : : {
805 : : /* Free the buffers */
806 : 0 : kfree(us->cr);
807 : 0 : usb_free_coherent(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma);
808 : :
809 : : /* Remove our private data from the interface */
810 : 0 : usb_set_intfdata(us->pusb_intf, NULL);
811 : 0 : }
812 : :
813 : : /* First stage of disconnect processing: stop SCSI scanning,
814 : : * remove the host, and stop accepting new commands
815 : : */
816 : 0 : static void quiesce_and_remove_host(struct us_data *us)
817 : : {
818 : 0 : struct Scsi_Host *host = us_to_host(us);
819 : :
820 : : /* If the device is really gone, cut short reset delays */
821 [ # # ]: 0 : if (us->pusb_dev->state == USB_STATE_NOTATTACHED) {
822 : 0 : set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
823 : 0 : wake_up(&us->delay_wait);
824 : : }
825 : :
826 : : /* Prevent SCSI scanning (if it hasn't started yet)
827 : : * or wait for the SCSI-scanning routine to stop.
828 : : */
829 : 0 : cancel_delayed_work_sync(&us->scan_dwork);
830 : :
831 : : /* Balance autopm calls if scanning was cancelled */
832 : : if (test_bit(US_FLIDX_SCAN_PENDING, &us->dflags))
833 : : usb_autopm_put_interface_no_suspend(us->pusb_intf);
834 : :
835 : : /* Removing the host will perform an orderly shutdown: caches
836 : : * synchronized, disks spun down, etc.
837 : : */
838 : 0 : scsi_remove_host(host);
839 : :
840 : : /* Prevent any new commands from being accepted and cut short
841 : : * reset delays.
842 : : */
843 : 0 : scsi_lock(host);
844 : 0 : set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
845 : 0 : scsi_unlock(host);
846 : 0 : wake_up(&us->delay_wait);
847 : 0 : }
848 : :
849 : : /* Second stage of disconnect processing: deallocate all resources */
850 : 0 : static void release_everything(struct us_data *us)
851 : : {
852 : 0 : usb_stor_release_resources(us);
853 : 0 : dissociate_dev(us);
854 : :
855 : : /* Drop our reference to the host; the SCSI core will free it
856 : : * (and "us" along with it) when the refcount becomes 0. */
857 : 0 : scsi_host_put(us_to_host(us));
858 : 0 : }
859 : :
860 : : /* Delayed-work routine to carry out SCSI-device scanning */
861 : 0 : static void usb_stor_scan_dwork(struct work_struct *work)
862 : : {
863 : 0 : struct us_data *us = container_of(work, struct us_data,
864 : : scan_dwork.work);
865 : : struct device *dev = &us->pusb_intf->dev;
866 : :
867 : : dev_dbg(dev, "starting scan\n");
868 : :
869 : : /* For bulk-only devices, determine the max LUN value */
870 [ # # ][ # # ]: 0 : if (us->protocol == USB_PR_BULK && !(us->fflags & US_FL_SINGLE_LUN)) {
871 : 0 : mutex_lock(&us->dev_mutex);
872 : 0 : us->max_lun = usb_stor_Bulk_max_lun(us);
873 : 0 : mutex_unlock(&us->dev_mutex);
874 : : }
875 : 0 : scsi_scan_host(us_to_host(us));
876 : : dev_dbg(dev, "scan complete\n");
877 : :
878 : : /* Should we unbind if no devices were detected? */
879 : :
880 : : usb_autopm_put_interface(us->pusb_intf);
881 : 0 : clear_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
882 : 0 : }
883 : :
884 : 0 : static unsigned int usb_stor_sg_tablesize(struct usb_interface *intf)
885 : : {
886 : : struct usb_device *usb_dev = interface_to_usbdev(intf);
887 : :
888 [ # # ]: 0 : if (usb_dev->bus->sg_tablesize) {
889 : : return usb_dev->bus->sg_tablesize;
890 : : }
891 : : return SG_ALL;
892 : : }
893 : :
894 : : /* First part of general USB mass-storage probing */
895 : 0 : int usb_stor_probe1(struct us_data **pus,
896 : : struct usb_interface *intf,
897 : : const struct usb_device_id *id,
898 : : struct us_unusual_dev *unusual_dev)
899 : : {
900 : : struct Scsi_Host *host;
901 : : struct us_data *us;
902 : : int result;
903 : :
904 : 0 : dev_info(&intf->dev, "USB Mass Storage device detected\n");
905 : :
906 : : /*
907 : : * Ask the SCSI layer to allocate a host structure, with extra
908 : : * space at the end for our private us_data structure.
909 : : */
910 : 0 : host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
911 [ # # ]: 0 : if (!host) {
912 : 0 : dev_warn(&intf->dev, "Unable to allocate the scsi host\n");
913 : 0 : return -ENOMEM;
914 : : }
915 : :
916 : : /*
917 : : * Allow 16-byte CDBs and thus > 2TB
918 : : */
919 : 0 : host->max_cmd_len = 16;
920 : 0 : host->sg_tablesize = usb_stor_sg_tablesize(intf);
921 : 0 : *pus = us = host_to_us(host);
922 : 0 : mutex_init(&(us->dev_mutex));
923 : : us_set_lock_class(&us->dev_mutex, intf);
924 : : init_completion(&us->cmnd_ready);
925 : : init_completion(&(us->notify));
926 : 0 : init_waitqueue_head(&us->delay_wait);
927 : 0 : INIT_DELAYED_WORK(&us->scan_dwork, usb_stor_scan_dwork);
928 : :
929 : : /* Associate the us_data structure with the USB device */
930 : 0 : result = associate_dev(us, intf);
931 [ # # ]: 0 : if (result)
932 : : goto BadDevice;
933 : :
934 : : /* Get the unusual_devs entries and the descriptors */
935 : 0 : result = get_device_info(us, id, unusual_dev);
936 [ # # ]: 0 : if (result)
937 : : goto BadDevice;
938 : :
939 : : /* Get standard transport and protocol settings */
940 : 0 : get_transport(us);
941 : 0 : get_protocol(us);
942 : :
943 : : /* Give the caller a chance to fill in specialized transport
944 : : * or protocol settings.
945 : : */
946 : 0 : return 0;
947 : :
948 : : BadDevice:
949 : : usb_stor_dbg(us, "storage_probe() failed\n");
950 : 0 : release_everything(us);
951 : 0 : return result;
952 : : }
953 : : EXPORT_SYMBOL_GPL(usb_stor_probe1);
954 : :
955 : : /* Second part of general USB mass-storage probing */
956 : 0 : int usb_stor_probe2(struct us_data *us)
957 : : {
958 : : int result;
959 : 0 : struct device *dev = &us->pusb_intf->dev;
960 : :
961 : : /* Make sure the transport and protocol have both been set */
962 [ # # ][ # # ]: 0 : if (!us->transport || !us->proto_handler) {
963 : : result = -ENXIO;
964 : : goto BadDevice;
965 : : }
966 : : usb_stor_dbg(us, "Transport: %s\n", us->transport_name);
967 : : usb_stor_dbg(us, "Protocol: %s\n", us->protocol_name);
968 : :
969 : : /* fix for single-lun devices */
970 [ # # ]: 0 : if (us->fflags & US_FL_SINGLE_LUN)
971 : 0 : us->max_lun = 0;
972 : :
973 [ # # ]: 0 : if (!(us->fflags & US_FL_SCM_MULT_TARG))
974 : 0 : us_to_host(us)->max_id = 1;
975 : :
976 : : /* Find the endpoints and calculate pipe values */
977 : 0 : result = get_pipes(us);
978 [ # # ]: 0 : if (result)
979 : : goto BadDevice;
980 : :
981 : : /*
982 : : * If the device returns invalid data for the first READ(10)
983 : : * command, indicate the command should be retried.
984 : : */
985 [ # # ]: 0 : if (us->fflags & US_FL_INITIAL_READ10)
986 : 0 : set_bit(US_FLIDX_REDO_READ10, &us->dflags);
987 : :
988 : : /* Acquire all the other resources and add the host */
989 : 0 : result = usb_stor_acquire_resources(us);
990 [ # # ]: 0 : if (result)
991 : : goto BadDevice;
992 : 0 : snprintf(us->scsi_name, sizeof(us->scsi_name), "usb-storage %s",
993 : 0 : dev_name(&us->pusb_intf->dev));
994 : 0 : result = scsi_add_host(us_to_host(us), dev);
995 [ # # ]: 0 : if (result) {
996 : 0 : dev_warn(dev,
997 : : "Unable to add the scsi host\n");
998 : 0 : goto BadDevice;
999 : : }
1000 : :
1001 : : /* Submit the delayed_work for SCSI-device scanning */
1002 : : usb_autopm_get_interface_no_resume(us->pusb_intf);
1003 : 0 : set_bit(US_FLIDX_SCAN_PENDING, &us->dflags);
1004 : :
1005 : : if (delay_use > 0)
1006 : : dev_dbg(dev, "waiting for device to settle before scanning\n");
1007 : 0 : queue_delayed_work(system_freezable_wq, &us->scan_dwork,
1008 : 0 : delay_use * HZ);
1009 : 0 : return 0;
1010 : :
1011 : : /* We come here if there are any problems */
1012 : : BadDevice:
1013 : : usb_stor_dbg(us, "storage_probe() failed\n");
1014 : 0 : release_everything(us);
1015 : 0 : return result;
1016 : : }
1017 : : EXPORT_SYMBOL_GPL(usb_stor_probe2);
1018 : :
1019 : : /* Handle a USB mass-storage disconnect */
1020 : 0 : void usb_stor_disconnect(struct usb_interface *intf)
1021 : : {
1022 : : struct us_data *us = usb_get_intfdata(intf);
1023 : :
1024 : 0 : quiesce_and_remove_host(us);
1025 : 0 : release_everything(us);
1026 : 0 : }
1027 : : EXPORT_SYMBOL_GPL(usb_stor_disconnect);
1028 : :
1029 : : /* The main probe routine for standard devices */
1030 : 0 : static int storage_probe(struct usb_interface *intf,
1031 : : const struct usb_device_id *id)
1032 : : {
1033 : : struct us_unusual_dev *unusual_dev;
1034 : : struct us_data *us;
1035 : : int result;
1036 : : int size;
1037 : :
1038 : : /*
1039 : : * If the device isn't standard (is handled by a subdriver
1040 : : * module) then don't accept it.
1041 : : */
1042 [ # # ]: 0 : if (usb_usual_ignore_device(intf))
1043 : : return -ENXIO;
1044 : :
1045 : : /*
1046 : : * Call the general probe procedures.
1047 : : *
1048 : : * The unusual_dev_list array is parallel to the usb_storage_usb_ids
1049 : : * table, so we use the index of the id entry to find the
1050 : : * corresponding unusual_devs entry.
1051 : : */
1052 : :
1053 : : size = ARRAY_SIZE(us_unusual_dev_list);
1054 [ # # ][ # # ]: 0 : if (id >= usb_storage_usb_ids && id < usb_storage_usb_ids + size) {
1055 : 0 : unusual_dev = (id - usb_storage_usb_ids) + us_unusual_dev_list;
1056 : : } else {
1057 : : unusual_dev = &for_dynamic_ids;
1058 : :
1059 : : dev_dbg(&intf->dev, "Use Bulk-Only transport with the Transparent SCSI protocol for dynamic id: 0x%04x 0x%04x\n",
1060 : : id->idVendor, id->idProduct);
1061 : : }
1062 : :
1063 : 0 : result = usb_stor_probe1(&us, intf, id, unusual_dev);
1064 [ # # ]: 0 : if (result)
1065 : : return result;
1066 : :
1067 : : /* No special transport or protocol settings in the main module */
1068 : :
1069 : 0 : result = usb_stor_probe2(us);
1070 : 0 : return result;
1071 : : }
1072 : :
1073 : : static struct usb_driver usb_storage_driver = {
1074 : : .name = "usb-storage",
1075 : : .probe = storage_probe,
1076 : : .disconnect = usb_stor_disconnect,
1077 : : .suspend = usb_stor_suspend,
1078 : : .resume = usb_stor_resume,
1079 : : .reset_resume = usb_stor_reset_resume,
1080 : : .pre_reset = usb_stor_pre_reset,
1081 : : .post_reset = usb_stor_post_reset,
1082 : : .id_table = usb_storage_usb_ids,
1083 : : .supports_autosuspend = 1,
1084 : : .soft_unbind = 1,
1085 : : };
1086 : :
1087 : 0 : module_usb_driver(usb_storage_driver);
|