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