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