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