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