blob: 5164900e40c18b3fa56e7fccd6926ddfa0d90995 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* Driver for USB Mass Storage compliant devices
2 *
3 * $Id: usb.c,v 1.75 2002/04/22 03:39:43 mdharm Exp $
4 *
5 * Current development and maintenance by:
6 * (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
7 *
8 * Developed with the assistance of:
9 * (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
10 * (c) 2003 Alan Stern (stern@rowland.harvard.edu)
11 *
12 * Initial work by:
13 * (c) 1999 Michael Gee (michael@linuxspecific.com)
14 *
15 * usb_device_id support by Adam J. Richter (adam@yggdrasil.com):
16 * (c) 2000 Yggdrasil Computing, Inc.
17 *
18 * This driver is based on the 'USB Mass Storage Class' document. This
19 * describes in detail the protocol used to communicate with such
20 * devices. Clearly, the designers had SCSI and ATAPI commands in
21 * mind when they created this document. The commands are all very
22 * similar to commands in the SCSI-II and ATAPI specifications.
23 *
24 * It is important to note that in a number of cases this class
25 * exhibits class-specific exemptions from the USB specification.
26 * Notably the usage of NAK, STALL and ACK differs from the norm, in
27 * that they are used to communicate wait, failed and OK on commands.
28 *
29 * Also, for certain devices, the interrupt endpoint is used to convey
30 * status of a command.
31 *
32 * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
33 * information about this driver.
34 *
35 * This program is free software; you can redistribute it and/or modify it
36 * under the terms of the GNU General Public License as published by the
37 * Free Software Foundation; either version 2, or (at your option) any
38 * later version.
39 *
40 * This program is distributed in the hope that it will be useful, but
41 * WITHOUT ANY WARRANTY; without even the implied warranty of
42 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
43 * General Public License for more details.
44 *
45 * You should have received a copy of the GNU General Public License along
46 * with this program; if not, write to the Free Software Foundation, Inc.,
47 * 675 Mass Ave, Cambridge, MA 02139, USA.
48 */
49
50#include <linux/config.h>
51#include <linux/sched.h>
52#include <linux/errno.h>
53#include <linux/suspend.h>
54#include <linux/module.h>
55#include <linux/init.h>
56#include <linux/slab.h>
57
58#include <scsi/scsi.h>
59#include <scsi/scsi_cmnd.h>
60#include <scsi/scsi_device.h>
61
62#include "usb.h"
63#include "scsiglue.h"
64#include "transport.h"
65#include "protocol.h"
66#include "debug.h"
67#include "initializers.h"
68
69#ifdef CONFIG_USB_STORAGE_USBAT
70#include "shuttle_usbat.h"
71#endif
72#ifdef CONFIG_USB_STORAGE_SDDR09
73#include "sddr09.h"
74#endif
75#ifdef CONFIG_USB_STORAGE_SDDR55
76#include "sddr55.h"
77#endif
78#ifdef CONFIG_USB_STORAGE_DPCM
79#include "dpcm.h"
80#endif
81#ifdef CONFIG_USB_STORAGE_FREECOM
82#include "freecom.h"
83#endif
84#ifdef CONFIG_USB_STORAGE_ISD200
85#include "isd200.h"
86#endif
87#ifdef CONFIG_USB_STORAGE_DATAFAB
88#include "datafab.h"
89#endif
90#ifdef CONFIG_USB_STORAGE_JUMPSHOT
91#include "jumpshot.h"
92#endif
Matthew Dharm34008db2005-07-28 14:49:01 -070093#ifdef CONFIG_USB_STORAGE_ONETOUCH
94#include "onetouch.h"
95#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070096
97/* Some informational data */
98MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
99MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
100MODULE_LICENSE("GPL");
101
102static unsigned int delay_use = 5;
103module_param(delay_use, uint, S_IRUGO | S_IWUSR);
104MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
105
106
107/* These are used to make sure the module doesn't unload before all the
108 * threads have exited.
109 */
110static atomic_t total_threads = ATOMIC_INIT(0);
111static DECLARE_COMPLETION(threads_gone);
112
113
114static int storage_probe(struct usb_interface *iface,
115 const struct usb_device_id *id);
116
117static void storage_disconnect(struct usb_interface *iface);
118
119/* The entries in this table, except for final ones here
120 * (USB_MASS_STORAGE_CLASS and the empty entry), correspond,
121 * line for line with the entries of us_unsuaul_dev_list[].
122 */
123
124#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
125 vendorName, productName,useProtocol, useTransport, \
126 initFunction, flags) \
127{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax) }
128
129static struct usb_device_id storage_usb_ids [] = {
130
131# include "unusual_devs.h"
132#undef UNUSUAL_DEV
133 /* Control/Bulk transport for all SubClass values */
134 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_CB) },
135 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_CB) },
136 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_CB) },
137 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_CB) },
138 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_CB) },
139 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_CB) },
140
141 /* Control/Bulk/Interrupt transport for all SubClass values */
142 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_CBI) },
143 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_CBI) },
144 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_CBI) },
145 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_CBI) },
146 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_CBI) },
147 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_CBI) },
148
149 /* Bulk-only transport for all SubClass values */
150 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_RBC, US_PR_BULK) },
151 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8020, US_PR_BULK) },
152 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_QIC, US_PR_BULK) },
153 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_UFI, US_PR_BULK) },
154 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_8070, US_PR_BULK) },
155 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, US_SC_SCSI, US_PR_BULK) },
156
157 /* Terminating entry */
158 { }
159};
160
161MODULE_DEVICE_TABLE (usb, storage_usb_ids);
162
163/* This is the list of devices we recognize, along with their flag data */
164
165/* The vendor name should be kept at eight characters or less, and
166 * the product name should be kept at 16 characters or less. If a device
167 * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
168 * normally generated by a device thorugh the INQUIRY response will be
169 * taken from this list, and this is the reason for the above size
170 * restriction. However, if the flag is not present, then you
171 * are free to use as many characters as you like.
172 */
173
174#undef UNUSUAL_DEV
175#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
176 vendor_name, product_name, use_protocol, use_transport, \
177 init_function, Flags) \
178{ \
179 .vendorName = vendor_name, \
180 .productName = product_name, \
181 .useProtocol = use_protocol, \
182 .useTransport = use_transport, \
183 .initFunction = init_function, \
184 .flags = Flags, \
185}
186
187static struct us_unusual_dev us_unusual_dev_list[] = {
188# include "unusual_devs.h"
189# undef UNUSUAL_DEV
190 /* Control/Bulk transport for all SubClass values */
191 { .useProtocol = US_SC_RBC,
192 .useTransport = US_PR_CB},
193 { .useProtocol = US_SC_8020,
194 .useTransport = US_PR_CB},
195 { .useProtocol = US_SC_QIC,
196 .useTransport = US_PR_CB},
197 { .useProtocol = US_SC_UFI,
198 .useTransport = US_PR_CB},
199 { .useProtocol = US_SC_8070,
200 .useTransport = US_PR_CB},
201 { .useProtocol = US_SC_SCSI,
202 .useTransport = US_PR_CB},
203
204 /* Control/Bulk/Interrupt transport for all SubClass values */
205 { .useProtocol = US_SC_RBC,
206 .useTransport = US_PR_CBI},
207 { .useProtocol = US_SC_8020,
208 .useTransport = US_PR_CBI},
209 { .useProtocol = US_SC_QIC,
210 .useTransport = US_PR_CBI},
211 { .useProtocol = US_SC_UFI,
212 .useTransport = US_PR_CBI},
213 { .useProtocol = US_SC_8070,
214 .useTransport = US_PR_CBI},
215 { .useProtocol = US_SC_SCSI,
216 .useTransport = US_PR_CBI},
217
218 /* Bulk-only transport for all SubClass values */
219 { .useProtocol = US_SC_RBC,
220 .useTransport = US_PR_BULK},
221 { .useProtocol = US_SC_8020,
222 .useTransport = US_PR_BULK},
223 { .useProtocol = US_SC_QIC,
224 .useTransport = US_PR_BULK},
225 { .useProtocol = US_SC_UFI,
226 .useTransport = US_PR_BULK},
227 { .useProtocol = US_SC_8070,
228 .useTransport = US_PR_BULK},
229 { .useProtocol = US_SC_SCSI,
230 .useTransport = US_PR_BULK},
231
232 /* Terminating entry */
233 { NULL }
234};
235
236static struct usb_driver usb_storage_driver = {
237 .owner = THIS_MODULE,
238 .name = "usb-storage",
239 .probe = storage_probe,
240 .disconnect = storage_disconnect,
241 .id_table = storage_usb_ids,
242};
243
244/*
245 * fill_inquiry_response takes an unsigned char array (which must
246 * be at least 36 characters) and populates the vendor name,
247 * product name, and revision fields. Then the array is copied
248 * into the SCSI command's response buffer (oddly enough
249 * called request_buffer). data_len contains the length of the
250 * data array, which again must be at least 36.
251 */
252
253void fill_inquiry_response(struct us_data *us, unsigned char *data,
254 unsigned int data_len)
255{
256 if (data_len<36) // You lose.
257 return;
258
259 if(data[0]&0x20) { /* USB device currently not connected. Return
260 peripheral qualifier 001b ("...however, the
261 physical device is not currently connected
262 to this logical unit") and leave vendor and
263 product identification empty. ("If the target
264 does store some of the INQUIRY data on the
265 device, it may return zeros or ASCII spaces
266 (20h) in those fields until the data is
267 available from the device."). */
268 memset(data+8,0,28);
269 } else {
270 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
271 memcpy(data+8, us->unusual_dev->vendorName,
272 strlen(us->unusual_dev->vendorName) > 8 ? 8 :
273 strlen(us->unusual_dev->vendorName));
274 memcpy(data+16, us->unusual_dev->productName,
275 strlen(us->unusual_dev->productName) > 16 ? 16 :
276 strlen(us->unusual_dev->productName));
277 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F);
278 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F);
279 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F);
280 data[35] = 0x30 + ((bcdDevice) & 0x0F);
281 }
282
283 usb_stor_set_xfer_buf(data, data_len, us->srb);
284}
285
286static int usb_stor_control_thread(void * __us)
287{
288 struct us_data *us = (struct us_data *)__us;
289 struct Scsi_Host *host = us_to_host(us);
290
291 lock_kernel();
292
293 /*
294 * This thread doesn't need any user-level access,
295 * so get rid of all our resources.
296 */
297 daemonize("usb-storage");
298 current->flags |= PF_NOFREEZE;
299 unlock_kernel();
300
301 /* acquire a reference to the host, so it won't be deallocated
302 * until we're ready to exit */
303 scsi_host_get(host);
304
305 /* signal that we've started the thread */
306 complete(&(us->notify));
307
308 for(;;) {
309 US_DEBUGP("*** thread sleeping.\n");
310 if(down_interruptible(&us->sema))
311 break;
312
313 US_DEBUGP("*** thread awakened.\n");
314
315 /* lock the device pointers */
316 down(&(us->dev_semaphore));
317
318 /* if the device has disconnected, we are free to exit */
319 if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
320 US_DEBUGP("-- exiting\n");
321 up(&(us->dev_semaphore));
322 break;
323 }
324
325 /* lock access to the state */
326 scsi_lock(host);
327
328 /* has the command timed out *already* ? */
329 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
330 us->srb->result = DID_ABORT << 16;
331 goto SkipForAbort;
332 }
333
334 scsi_unlock(host);
335
336 /* reject the command if the direction indicator
337 * is UNKNOWN
338 */
339 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
340 US_DEBUGP("UNKNOWN data direction\n");
341 us->srb->result = DID_ERROR << 16;
342 }
343
344 /* reject if target != 0 or if LUN is higher than
345 * the maximum known LUN
346 */
347 else if (us->srb->device->id &&
348 !(us->flags & US_FL_SCM_MULT_TARG)) {
349 US_DEBUGP("Bad target number (%d:%d)\n",
350 us->srb->device->id, us->srb->device->lun);
351 us->srb->result = DID_BAD_TARGET << 16;
352 }
353
354 else if (us->srb->device->lun > us->max_lun) {
355 US_DEBUGP("Bad LUN (%d:%d)\n",
356 us->srb->device->id, us->srb->device->lun);
357 us->srb->result = DID_BAD_TARGET << 16;
358 }
359
360 /* Handle those devices which need us to fake
361 * their inquiry data */
362 else if ((us->srb->cmnd[0] == INQUIRY) &&
363 (us->flags & US_FL_FIX_INQUIRY)) {
364 unsigned char data_ptr[36] = {
365 0x00, 0x80, 0x02, 0x02,
366 0x1F, 0x00, 0x00, 0x00};
367
368 US_DEBUGP("Faking INQUIRY command\n");
369 fill_inquiry_response(us, data_ptr, 36);
370 us->srb->result = SAM_STAT_GOOD;
371 }
372
373 /* we've got a command, let's do it! */
374 else {
375 US_DEBUG(usb_stor_show_command(us->srb));
376 us->proto_handler(us->srb, us);
377 }
378
379 /* lock access to the state */
380 scsi_lock(host);
381
382 /* indicate that the command is done */
383 if (us->srb->result != DID_ABORT << 16) {
384 US_DEBUGP("scsi cmd done, result=0x%x\n",
385 us->srb->result);
386 us->srb->scsi_done(us->srb);
387 } else {
388SkipForAbort:
389 US_DEBUGP("scsi command aborted\n");
390 }
391
392 /* If an abort request was received we need to signal that
393 * the abort has finished. The proper test for this is
394 * the TIMED_OUT flag, not srb->result == DID_ABORT, because
Matthew Dharm226173e2005-08-25 20:03:50 -0700395 * the timeout might have occurred after the command had
396 * already completed with a different result code. */
397 if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 complete(&(us->notify));
399
Matthew Dharm226173e2005-08-25 20:03:50 -0700400 /* Allow USB transfers to resume */
401 clear_bit(US_FLIDX_ABORTING, &us->flags);
402 clear_bit(US_FLIDX_TIMED_OUT, &us->flags);
403 }
404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 /* finished working on this command */
406 us->srb = NULL;
407 scsi_unlock(host);
408
409 /* unlock the device pointers */
410 up(&(us->dev_semaphore));
411 } /* for (;;) */
412
413 scsi_host_put(host);
414
415 /* notify the exit routine that we're actually exiting now
416 *
417 * complete()/wait_for_completion() is similar to up()/down(),
418 * except that complete() is safe in the case where the structure
419 * is getting deleted in a parallel mode of execution (i.e. just
420 * after the down() -- that's necessary for the thread-shutdown
421 * case.
422 *
423 * complete_and_exit() goes even further than this -- it is safe in
424 * the case that the thread of the caller is going away (not just
425 * the structure) -- this is necessary for the module-remove case.
426 * This is important in preemption kernels, which transfer the flow
427 * of execution immediately upon a complete().
428 */
429 complete_and_exit(&threads_gone, 0);
430}
431
432/***********************************************************************
433 * Device probing and disconnecting
434 ***********************************************************************/
435
436/* Associate our private data with the USB device */
437static int associate_dev(struct us_data *us, struct usb_interface *intf)
438{
439 US_DEBUGP("-- %s\n", __FUNCTION__);
440
441 /* Fill in the device-related fields */
442 us->pusb_dev = interface_to_usbdev(intf);
443 us->pusb_intf = intf;
444 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
445 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n",
446 le16_to_cpu(us->pusb_dev->descriptor.idVendor),
447 le16_to_cpu(us->pusb_dev->descriptor.idProduct),
448 le16_to_cpu(us->pusb_dev->descriptor.bcdDevice));
449 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n",
450 intf->cur_altsetting->desc.bInterfaceSubClass,
451 intf->cur_altsetting->desc.bInterfaceProtocol);
452
453 /* Store our private data in the interface */
454 usb_set_intfdata(intf, us);
455
456 /* Allocate the device-related DMA-mapped buffers */
457 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr),
458 GFP_KERNEL, &us->cr_dma);
459 if (!us->cr) {
460 US_DEBUGP("usb_ctrlrequest allocation failed\n");
461 return -ENOMEM;
462 }
463
464 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE,
465 GFP_KERNEL, &us->iobuf_dma);
466 if (!us->iobuf) {
467 US_DEBUGP("I/O buffer allocation failed\n");
468 return -ENOMEM;
469 }
470 return 0;
471}
472
473/* Get the unusual_devs entries and the string descriptors */
474static void get_device_info(struct us_data *us, int id_index)
475{
476 struct usb_device *dev = us->pusb_dev;
477 struct usb_interface_descriptor *idesc =
478 &us->pusb_intf->cur_altsetting->desc;
479 struct us_unusual_dev *unusual_dev = &us_unusual_dev_list[id_index];
480 struct usb_device_id *id = &storage_usb_ids[id_index];
481
482 /* Store the entries */
483 us->unusual_dev = unusual_dev;
484 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ?
485 idesc->bInterfaceSubClass :
486 unusual_dev->useProtocol;
487 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ?
488 idesc->bInterfaceProtocol :
489 unusual_dev->useTransport;
490 us->flags = unusual_dev->flags;
491
492 /*
493 * This flag is only needed when we're in high-speed, so let's
494 * disable it if we're in full-speed
495 */
496 if (dev->speed != USB_SPEED_HIGH)
497 us->flags &= ~US_FL_GO_SLOW;
498
499 /* Log a message if a non-generic unusual_dev entry contains an
500 * unnecessary subclass or protocol override. This may stimulate
501 * reports from users that will help us remove unneeded entries
502 * from the unusual_devs.h table.
503 */
504 if (id->idVendor || id->idProduct) {
505 static char *msgs[3] = {
506 "an unneeded SubClass entry",
507 "an unneeded Protocol entry",
508 "unneeded SubClass and Protocol entries"};
509 struct usb_device_descriptor *ddesc = &dev->descriptor;
510 int msg = -1;
511
512 if (unusual_dev->useProtocol != US_SC_DEVICE &&
513 us->subclass == idesc->bInterfaceSubClass)
514 msg += 1;
515 if (unusual_dev->useTransport != US_PR_DEVICE &&
516 us->protocol == idesc->bInterfaceProtocol)
517 msg += 2;
518 if (msg >= 0 && !(unusual_dev->flags & US_FL_NEED_OVERRIDE))
519 printk(KERN_NOTICE USB_STORAGE "This device "
520 "(%04x,%04x,%04x S %02x P %02x)"
521 " has %s in unusual_devs.h\n"
522 " Please send a copy of this message to "
523 "<linux-usb-devel@lists.sourceforge.net>\n",
524 le16_to_cpu(ddesc->idVendor),
525 le16_to_cpu(ddesc->idProduct),
526 le16_to_cpu(ddesc->bcdDevice),
527 idesc->bInterfaceSubClass,
528 idesc->bInterfaceProtocol,
529 msgs[msg]);
530 }
531}
532
533/* Get the transport settings */
534static int get_transport(struct us_data *us)
535{
536 switch (us->protocol) {
537 case US_PR_CB:
538 us->transport_name = "Control/Bulk";
539 us->transport = usb_stor_CB_transport;
540 us->transport_reset = usb_stor_CB_reset;
541 us->max_lun = 7;
542 break;
543
544 case US_PR_CBI:
545 us->transport_name = "Control/Bulk/Interrupt";
546 us->transport = usb_stor_CBI_transport;
547 us->transport_reset = usb_stor_CB_reset;
548 us->max_lun = 7;
549 break;
550
551 case US_PR_BULK:
552 us->transport_name = "Bulk";
553 us->transport = usb_stor_Bulk_transport;
554 us->transport_reset = usb_stor_Bulk_reset;
555 break;
556
557#ifdef CONFIG_USB_STORAGE_USBAT
Daniel Drakeb7b1e652005-09-30 12:49:36 +0100558 case US_PR_USBAT:
559 us->transport_name = "Shuttle USBAT";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 us->transport = usbat_transport;
561 us->transport_reset = usb_stor_CB_reset;
562 us->max_lun = 1;
563 break;
564#endif
565
566#ifdef CONFIG_USB_STORAGE_SDDR09
567 case US_PR_EUSB_SDDR09:
568 us->transport_name = "EUSB/SDDR09";
569 us->transport = sddr09_transport;
570 us->transport_reset = usb_stor_CB_reset;
571 us->max_lun = 0;
572 break;
573#endif
574
575#ifdef CONFIG_USB_STORAGE_SDDR55
576 case US_PR_SDDR55:
577 us->transport_name = "SDDR55";
578 us->transport = sddr55_transport;
579 us->transport_reset = sddr55_reset;
580 us->max_lun = 0;
581 break;
582#endif
583
584#ifdef CONFIG_USB_STORAGE_DPCM
585 case US_PR_DPCM_USB:
586 us->transport_name = "Control/Bulk-EUSB/SDDR09";
587 us->transport = dpcm_transport;
588 us->transport_reset = usb_stor_CB_reset;
589 us->max_lun = 1;
590 break;
591#endif
592
593#ifdef CONFIG_USB_STORAGE_FREECOM
594 case US_PR_FREECOM:
595 us->transport_name = "Freecom";
596 us->transport = freecom_transport;
597 us->transport_reset = usb_stor_freecom_reset;
598 us->max_lun = 0;
599 break;
600#endif
601
602#ifdef CONFIG_USB_STORAGE_DATAFAB
603 case US_PR_DATAFAB:
604 us->transport_name = "Datafab Bulk-Only";
605 us->transport = datafab_transport;
606 us->transport_reset = usb_stor_Bulk_reset;
607 us->max_lun = 1;
608 break;
609#endif
610
611#ifdef CONFIG_USB_STORAGE_JUMPSHOT
612 case US_PR_JUMPSHOT:
613 us->transport_name = "Lexar Jumpshot Control/Bulk";
614 us->transport = jumpshot_transport;
615 us->transport_reset = usb_stor_Bulk_reset;
616 us->max_lun = 1;
617 break;
618#endif
619
620 default:
621 return -EIO;
622 }
623 US_DEBUGP("Transport: %s\n", us->transport_name);
624
625 /* fix for single-lun devices */
626 if (us->flags & US_FL_SINGLE_LUN)
627 us->max_lun = 0;
628 return 0;
629}
630
631/* Get the protocol settings */
632static int get_protocol(struct us_data *us)
633{
634 switch (us->subclass) {
635 case US_SC_RBC:
636 us->protocol_name = "Reduced Block Commands (RBC)";
637 us->proto_handler = usb_stor_transparent_scsi_command;
638 break;
639
640 case US_SC_8020:
641 us->protocol_name = "8020i";
642 us->proto_handler = usb_stor_ATAPI_command;
643 us->max_lun = 0;
644 break;
645
646 case US_SC_QIC:
647 us->protocol_name = "QIC-157";
648 us->proto_handler = usb_stor_qic157_command;
649 us->max_lun = 0;
650 break;
651
652 case US_SC_8070:
653 us->protocol_name = "8070i";
654 us->proto_handler = usb_stor_ATAPI_command;
655 us->max_lun = 0;
656 break;
657
658 case US_SC_SCSI:
659 us->protocol_name = "Transparent SCSI";
660 us->proto_handler = usb_stor_transparent_scsi_command;
661 break;
662
663 case US_SC_UFI:
664 us->protocol_name = "Uniform Floppy Interface (UFI)";
665 us->proto_handler = usb_stor_ufi_command;
666 break;
667
668#ifdef CONFIG_USB_STORAGE_ISD200
669 case US_SC_ISD200:
670 us->protocol_name = "ISD200 ATA/ATAPI";
671 us->proto_handler = isd200_ata_command;
672 break;
673#endif
674
675 default:
676 return -EIO;
677 }
678 US_DEBUGP("Protocol: %s\n", us->protocol_name);
679 return 0;
680}
681
682/* Get the pipe settings */
683static int get_pipes(struct us_data *us)
684{
685 struct usb_host_interface *altsetting =
686 us->pusb_intf->cur_altsetting;
687 int i;
688 struct usb_endpoint_descriptor *ep;
689 struct usb_endpoint_descriptor *ep_in = NULL;
690 struct usb_endpoint_descriptor *ep_out = NULL;
691 struct usb_endpoint_descriptor *ep_int = NULL;
692
693 /*
694 * Find the endpoints we need.
695 * We are expecting a minimum of 2 endpoints - in and out (bulk).
696 * An optional interrupt is OK (necessary for CBI protocol).
697 * We will ignore any others.
698 */
699 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
700 ep = &altsetting->endpoint[i].desc;
701
702 /* Is it a BULK endpoint? */
703 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
704 == USB_ENDPOINT_XFER_BULK) {
705 /* BULK in or out? */
706 if (ep->bEndpointAddress & USB_DIR_IN)
707 ep_in = ep;
708 else
709 ep_out = ep;
710 }
711
712 /* Is it an interrupt endpoint? */
713 else if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
714 == USB_ENDPOINT_XFER_INT) {
715 ep_int = ep;
716 }
717 }
718
719 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) {
720 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
721 return -EIO;
722 }
723
724 /* Calculate and store the pipe values */
725 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
726 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
727 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
728 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
729 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
730 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
731 if (ep_int) {
732 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
733 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
734 us->ep_bInterval = ep_int->bInterval;
735 }
736 return 0;
737}
738
739/* Initialize all the dynamic resources we need */
740static int usb_stor_acquire_resources(struct us_data *us)
741{
742 int p;
743
744 us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
745 if (!us->current_urb) {
746 US_DEBUGP("URB allocation failed\n");
747 return -ENOMEM;
748 }
749
750 /* Lock the device while we carry out the next two operations */
751 down(&us->dev_semaphore);
752
753 /* For bulk-only devices, determine the max LUN value */
754 if (us->protocol == US_PR_BULK) {
755 p = usb_stor_Bulk_max_lun(us);
756 if (p < 0) {
757 up(&us->dev_semaphore);
758 return p;
759 }
760 us->max_lun = p;
761 }
762
763 /* Just before we start our control thread, initialize
764 * the device if it needs initialization */
765 if (us->unusual_dev->initFunction)
766 us->unusual_dev->initFunction(us);
767
768 up(&us->dev_semaphore);
769
770 /* Start up our control thread */
771 p = kernel_thread(usb_stor_control_thread, us, CLONE_VM);
772 if (p < 0) {
773 printk(KERN_WARNING USB_STORAGE
774 "Unable to start control thread\n");
775 return p;
776 }
777 us->pid = p;
778 atomic_inc(&total_threads);
779
780 /* Wait for the thread to start */
781 wait_for_completion(&(us->notify));
782
783 return 0;
784}
785
786/* Release all our dynamic resources */
787static void usb_stor_release_resources(struct us_data *us)
788{
789 US_DEBUGP("-- %s\n", __FUNCTION__);
790
791 /* Tell the control thread to exit. The SCSI host must
792 * already have been removed so it won't try to queue
793 * any more commands.
794 */
795 US_DEBUGP("-- sending exit command to thread\n");
Matthew Dharm77f46322005-07-28 14:44:29 -0700796 set_bit(US_FLIDX_DISCONNECTING, &us->flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 up(&us->sema);
798
799 /* Call the destructor routine, if it exists */
800 if (us->extra_destructor) {
801 US_DEBUGP("-- calling extra_destructor()\n");
802 us->extra_destructor(us->extra);
803 }
804
805 /* Free the extra data and the URB */
806 kfree(us->extra);
807 usb_free_urb(us->current_urb);
808}
809
810/* Dissociate from the USB device */
811static void dissociate_dev(struct us_data *us)
812{
813 US_DEBUGP("-- %s\n", __FUNCTION__);
814
815 /* Free the device-related DMA-mapped buffers */
816 if (us->cr)
817 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr,
818 us->cr_dma);
819 if (us->iobuf)
820 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf,
821 us->iobuf_dma);
822
823 /* Remove our private data from the interface */
824 usb_set_intfdata(us->pusb_intf, NULL);
825}
826
Matthew Dharm77f46322005-07-28 14:44:29 -0700827/* First stage of disconnect processing: stop all commands and remove
828 * the host */
829static void quiesce_and_remove_host(struct us_data *us)
830{
831 /* Prevent new USB transfers, stop the current command, and
832 * interrupt a SCSI-scan or device-reset delay */
833 set_bit(US_FLIDX_DISCONNECTING, &us->flags);
834 usb_stor_stop_transport(us);
835 wake_up(&us->delay_wait);
836
837 /* It doesn't matter if the SCSI-scanning thread is still running.
838 * The thread will exit when it sees the DISCONNECTING flag. */
839
840 /* Wait for the current command to finish, then remove the host */
841 down(&us->dev_semaphore);
842 up(&us->dev_semaphore);
Matthew Dharm26186ba2005-07-28 14:45:50 -0700843
844 /* queuecommand won't accept any new commands and the control
845 * thread won't execute a previously-queued command. If there
846 * is such a command pending, complete it with an error. */
847 if (us->srb) {
848 us->srb->result = DID_NO_CONNECT << 16;
849 scsi_lock(us_to_host(us));
850 us->srb->scsi_done(us->srb);
851 us->srb = NULL;
852 scsi_unlock(us_to_host(us));
853 }
854
855 /* Now we own no commands so it's safe to remove the SCSI host */
Matthew Dharm77f46322005-07-28 14:44:29 -0700856 scsi_remove_host(us_to_host(us));
857}
858
859/* Second stage of disconnect processing: deallocate all resources */
860static void release_everything(struct us_data *us)
861{
862 usb_stor_release_resources(us);
863 dissociate_dev(us);
864
865 /* Drop our reference to the host; the SCSI core will free it
866 * (and "us" along with it) when the refcount becomes 0. */
867 scsi_host_put(us_to_host(us));
868}
869
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870/* Thread to carry out delayed SCSI-device scanning */
871static int usb_stor_scan_thread(void * __us)
872{
873 struct us_data *us = (struct us_data *)__us;
874
875 /*
876 * This thread doesn't need any user-level access,
877 * so get rid of all our resources.
878 */
879 lock_kernel();
880 daemonize("usb-stor-scan");
881 unlock_kernel();
882
883 /* Acquire a reference to the host, so it won't be deallocated
884 * until we're ready to exit */
885 scsi_host_get(us_to_host(us));
886
887 /* Signal that we've started the thread */
888 complete(&(us->notify));
889
890 printk(KERN_DEBUG
891 "usb-storage: device found at %d\n", us->pusb_dev->devnum);
892
893 /* Wait for the timeout to expire or for a disconnect */
894 if (delay_use > 0) {
895 printk(KERN_DEBUG "usb-storage: waiting for device "
896 "to settle before scanning\n");
897retry:
898 wait_event_interruptible_timeout(us->delay_wait,
899 test_bit(US_FLIDX_DISCONNECTING, &us->flags),
900 delay_use * HZ);
Christoph Lameter3e1d1d22005-06-24 23:13:50 -0700901 if (try_to_freeze())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 goto retry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 }
904
905 /* If the device is still connected, perform the scanning */
906 if (!test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
907 scsi_scan_host(us_to_host(us));
908 printk(KERN_DEBUG "usb-storage: device scan complete\n");
909
910 /* Should we unbind if no devices were detected? */
911 }
912
913 scsi_host_put(us_to_host(us));
914 complete_and_exit(&threads_gone, 0);
915}
916
917
918/* Probe to see if we can drive a newly-connected USB device */
919static int storage_probe(struct usb_interface *intf,
920 const struct usb_device_id *id)
921{
922 struct Scsi_Host *host;
923 struct us_data *us;
924 const int id_index = id - storage_usb_ids;
925 int result;
926
927 US_DEBUGP("USB Mass Storage device detected\n");
928
929 /*
930 * Ask the SCSI layer to allocate a host structure, with extra
931 * space at the end for our private us_data structure.
932 */
933 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
934 if (!host) {
935 printk(KERN_WARNING USB_STORAGE
936 "Unable to allocate the scsi host\n");
937 return -ENOMEM;
938 }
939
940 us = host_to_us(host);
941 memset(us, 0, sizeof(struct us_data));
942 init_MUTEX(&(us->dev_semaphore));
943 init_MUTEX_LOCKED(&(us->sema));
944 init_completion(&(us->notify));
945 init_waitqueue_head(&us->delay_wait);
946
947 /* Associate the us_data structure with the USB device */
948 result = associate_dev(us, intf);
949 if (result)
950 goto BadDevice;
951
952 /*
953 * Get the unusual_devs entries and the descriptors
954 *
955 * id_index is calculated in the declaration to be the index number
956 * of the match from the usb_device_id table, so we can find the
957 * corresponding entry in the private table.
958 */
959 get_device_info(us, id_index);
960
961#ifdef CONFIG_USB_STORAGE_SDDR09
962 if (us->protocol == US_PR_EUSB_SDDR09 ||
963 us->protocol == US_PR_DPCM_USB) {
964 /* set the configuration -- STALL is an acceptable response here */
965 if (us->pusb_dev->actconfig->desc.bConfigurationValue != 1) {
966 US_DEBUGP("active config #%d != 1 ??\n", us->pusb_dev
967 ->actconfig->desc.bConfigurationValue);
968 goto BadDevice;
969 }
970 result = usb_reset_configuration(us->pusb_dev);
971
972 US_DEBUGP("Result of usb_reset_configuration is %d\n", result);
973 if (result == -EPIPE) {
974 US_DEBUGP("-- stall on control interface\n");
975 } else if (result != 0) {
976 /* it's not a stall, but another error -- time to bail */
977 US_DEBUGP("-- Unknown error. Rejecting device\n");
978 goto BadDevice;
979 }
980 }
981#endif
982
983 /* Get the transport, protocol, and pipe settings */
984 result = get_transport(us);
985 if (result)
986 goto BadDevice;
987 result = get_protocol(us);
988 if (result)
989 goto BadDevice;
990 result = get_pipes(us);
991 if (result)
992 goto BadDevice;
993
994 /* Acquire all the other resources and add the host */
995 result = usb_stor_acquire_resources(us);
996 if (result)
997 goto BadDevice;
998 result = scsi_add_host(host, &intf->dev);
999 if (result) {
1000 printk(KERN_WARNING USB_STORAGE
1001 "Unable to add the scsi host\n");
1002 goto BadDevice;
1003 }
1004
1005 /* Start up the thread for delayed SCSI-device scanning */
1006 result = kernel_thread(usb_stor_scan_thread, us, CLONE_VM);
1007 if (result < 0) {
1008 printk(KERN_WARNING USB_STORAGE
1009 "Unable to start the device-scanning thread\n");
Matthew Dharm77f46322005-07-28 14:44:29 -07001010 quiesce_and_remove_host(us);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 goto BadDevice;
1012 }
1013 atomic_inc(&total_threads);
1014
1015 /* Wait for the thread to start */
1016 wait_for_completion(&(us->notify));
1017
1018 return 0;
1019
1020 /* We come here if there are any problems */
1021BadDevice:
1022 US_DEBUGP("storage_probe() failed\n");
Matthew Dharm77f46322005-07-28 14:44:29 -07001023 release_everything(us);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 return result;
1025}
1026
1027/* Handle a disconnect event from the USB core */
1028static void storage_disconnect(struct usb_interface *intf)
1029{
1030 struct us_data *us = usb_get_intfdata(intf);
1031
1032 US_DEBUGP("storage_disconnect() called\n");
Matthew Dharm77f46322005-07-28 14:44:29 -07001033 quiesce_and_remove_host(us);
1034 release_everything(us);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035}
1036
1037/***********************************************************************
1038 * Initialization and registration
1039 ***********************************************************************/
1040
1041static int __init usb_stor_init(void)
1042{
1043 int retval;
1044 printk(KERN_INFO "Initializing USB Mass Storage driver...\n");
1045
1046 /* register the driver, return usb_register return code if error */
1047 retval = usb_register(&usb_storage_driver);
1048 if (retval == 0)
1049 printk(KERN_INFO "USB Mass Storage support registered.\n");
1050
1051 return retval;
1052}
1053
1054static void __exit usb_stor_exit(void)
1055{
1056 US_DEBUGP("usb_stor_exit() called\n");
1057
1058 /* Deregister the driver
1059 * This will cause disconnect() to be called for each
1060 * attached unit
1061 */
1062 US_DEBUGP("-- calling usb_deregister()\n");
1063 usb_deregister(&usb_storage_driver) ;
1064
1065 /* Don't return until all of our control and scanning threads
1066 * have exited. Since each thread signals threads_gone as its
1067 * last act, we have to call wait_for_completion the right number
1068 * of times.
1069 */
1070 while (atomic_read(&total_threads) > 0) {
1071 wait_for_completion(&threads_gone);
1072 atomic_dec(&total_threads);
1073 }
1074}
1075
1076module_init(usb_stor_init);
1077module_exit(usb_stor_exit);