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