1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48#include <linux/sched.h>
49#include <linux/errno.h>
50#include <linux/freezer.h>
51#include <linux/module.h>
52#include <linux/init.h>
53#include <linux/slab.h>
54#include <linux/kthread.h>
55#include <linux/mutex.h>
56#include <linux/utsname.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#ifdef CONFIG_USB_STORAGE_ONETOUCH
94#include "onetouch.h"
95#endif
96#ifdef CONFIG_USB_STORAGE_ALAUDA
97#include "alauda.h"
98#endif
99#ifdef CONFIG_USB_STORAGE_KARMA
100#include "karma.h"
101#endif
102#ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
103#include "cypress_atacb.h"
104#endif
105#include "sierra_ms.h"
106
107
108MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
109MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
110MODULE_LICENSE("GPL");
111
112static unsigned int delay_use = 5;
113module_param(delay_use, uint, S_IRUGO | S_IWUSR);
114MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
115
116
117
118
119
120
121#ifndef CONFIG_USB_LIBUSUAL
122
123#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
124 vendorName, productName,useProtocol, useTransport, \
125 initFunction, flags) \
126{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \
127 .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
128
129#define USUAL_DEV(useProto, useTrans, useType) \
130{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
131 .driver_info = (USB_US_TYPE_STOR<<24) }
132
133static struct usb_device_id storage_usb_ids [] = {
134
135# include "unusual_devs.h"
136#undef UNUSUAL_DEV
137#undef USUAL_DEV
138
139 { }
140};
141
142MODULE_DEVICE_TABLE (usb, storage_usb_ids);
143#endif
144
145
146
147
148
149
150
151
152
153
154
155
156#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
157 vendor_name, product_name, use_protocol, use_transport, \
158 init_function, Flags) \
159{ \
160 .vendorName = vendor_name, \
161 .productName = product_name, \
162 .useProtocol = use_protocol, \
163 .useTransport = use_transport, \
164 .initFunction = init_function, \
165}
166
167#define USUAL_DEV(use_protocol, use_transport, use_type) \
168{ \
169 .useProtocol = use_protocol, \
170 .useTransport = use_transport, \
171}
172
173static struct us_unusual_dev us_unusual_dev_list[] = {
174# include "unusual_devs.h"
175# undef UNUSUAL_DEV
176# undef USUAL_DEV
177
178
179 { NULL }
180};
181
182
183#ifdef CONFIG_PM
184
185static int storage_suspend(struct usb_interface *iface, pm_message_t message)
186{
187 struct us_data *us = usb_get_intfdata(iface);
188
189
190 mutex_lock(&us->dev_mutex);
191
192 US_DEBUGP("%s\n", __func__);
193 if (us->suspend_resume_hook)
194 (us->suspend_resume_hook)(us, US_SUSPEND);
195
196
197
198
199 mutex_unlock(&us->dev_mutex);
200 return 0;
201}
202
203static int storage_resume(struct usb_interface *iface)
204{
205 struct us_data *us = usb_get_intfdata(iface);
206
207 mutex_lock(&us->dev_mutex);
208
209 US_DEBUGP("%s\n", __func__);
210 if (us->suspend_resume_hook)
211 (us->suspend_resume_hook)(us, US_RESUME);
212
213 mutex_unlock(&us->dev_mutex);
214 return 0;
215}
216
217static int storage_reset_resume(struct usb_interface *iface)
218{
219 struct us_data *us = usb_get_intfdata(iface);
220
221 US_DEBUGP("%s\n", __func__);
222
223
224 usb_stor_report_bus_reset(us);
225
226
227
228 return 0;
229}
230
231#endif
232
233
234
235
236
237
238static int storage_pre_reset(struct usb_interface *iface)
239{
240 struct us_data *us = usb_get_intfdata(iface);
241
242 US_DEBUGP("%s\n", __func__);
243
244
245 mutex_lock(&us->dev_mutex);
246 return 0;
247}
248
249static int storage_post_reset(struct usb_interface *iface)
250{
251 struct us_data *us = usb_get_intfdata(iface);
252
253 US_DEBUGP("%s\n", __func__);
254
255
256 usb_stor_report_bus_reset(us);
257
258
259
260
261 mutex_unlock(&us->dev_mutex);
262 return 0;
263}
264
265
266
267
268
269
270
271
272
273
274void fill_inquiry_response(struct us_data *us, unsigned char *data,
275 unsigned int data_len)
276{
277 if (data_len<36)
278 return;
279
280 if(data[0]&0x20) {
281
282
283
284
285
286
287
288
289 memset(data+8,0,28);
290 } else {
291 u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
292 memcpy(data+8, us->unusual_dev->vendorName,
293 strlen(us->unusual_dev->vendorName) > 8 ? 8 :
294 strlen(us->unusual_dev->vendorName));
295 memcpy(data+16, us->unusual_dev->productName,
296 strlen(us->unusual_dev->productName) > 16 ? 16 :
297 strlen(us->unusual_dev->productName));
298 data[32] = 0x30 + ((bcdDevice>>12) & 0x0F);
299 data[33] = 0x30 + ((bcdDevice>>8) & 0x0F);
300 data[34] = 0x30 + ((bcdDevice>>4) & 0x0F);
301 data[35] = 0x30 + ((bcdDevice) & 0x0F);
302 }
303
304 usb_stor_set_xfer_buf(data, data_len, us->srb);
305}
306
307static int usb_stor_control_thread(void * __us)
308{
309 struct us_data *us = (struct us_data *)__us;
310 struct Scsi_Host *host = us_to_host(us);
311
312 for(;;) {
313 US_DEBUGP("*** thread sleeping.\n");
314 if (wait_for_completion_interruptible(&us->cmnd_ready))
315 break;
316
317 US_DEBUGP("*** thread awakened.\n");
318
319
320 mutex_lock(&(us->dev_mutex));
321
322
323 scsi_lock(host);
324
325
326 if (us->srb == NULL) {
327 scsi_unlock(host);
328 mutex_unlock(&us->dev_mutex);
329 US_DEBUGP("-- exiting\n");
330 break;
331 }
332
333
334 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
335 us->srb->result = DID_ABORT << 16;
336 goto SkipForAbort;
337 }
338
339 scsi_unlock(host);
340
341
342
343
344 if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL) {
345 US_DEBUGP("UNKNOWN data direction\n");
346 us->srb->result = DID_ERROR << 16;
347 }
348
349
350
351
352 else if (us->srb->device->id &&
353 !(us->fflags & US_FL_SCM_MULT_TARG)) {
354 US_DEBUGP("Bad target number (%d:%d)\n",
355 us->srb->device->id, us->srb->device->lun);
356 us->srb->result = DID_BAD_TARGET << 16;
357 }
358
359 else if (us->srb->device->lun > us->max_lun) {
360 US_DEBUGP("Bad LUN (%d:%d)\n",
361 us->srb->device->id, us->srb->device->lun);
362 us->srb->result = DID_BAD_TARGET << 16;
363 }
364
365
366
367 else if ((us->srb->cmnd[0] == INQUIRY) &&
368 (us->fflags & US_FL_FIX_INQUIRY)) {
369 unsigned char data_ptr[36] = {
370 0x00, 0x80, 0x02, 0x02,
371 0x1F, 0x00, 0x00, 0x00};
372
373 US_DEBUGP("Faking INQUIRY command\n");
374 fill_inquiry_response(us, data_ptr, 36);
375 us->srb->result = SAM_STAT_GOOD;
376 }
377
378
379 else {
380 US_DEBUG(usb_stor_show_command(us->srb));
381 us->proto_handler(us->srb, us);
382 }
383
384
385 scsi_lock(host);
386
387
388 if (us->srb->result != DID_ABORT << 16) {
389 US_DEBUGP("scsi cmd done, result=0x%x\n",
390 us->srb->result);
391 us->srb->scsi_done(us->srb);
392 } else {
393SkipForAbort:
394 US_DEBUGP("scsi command aborted\n");
395 }
396
397
398
399
400
401
402 if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
403 complete(&(us->notify));
404
405
406 clear_bit(US_FLIDX_ABORTING, &us->dflags);
407 clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
408 }
409
410
411 us->srb = NULL;
412 scsi_unlock(host);
413
414
415 mutex_unlock(&us->dev_mutex);
416 }
417
418
419 for (;;) {
420 set_current_state(TASK_INTERRUPTIBLE);
421 if (kthread_should_stop())
422 break;
423 schedule();
424 }
425 __set_current_state(TASK_RUNNING);
426 return 0;
427}
428
429
430
431
432
433
434static int associate_dev(struct us_data *us, struct usb_interface *intf)
435{
436 US_DEBUGP("-- %s\n", __func__);
437
438
439 us->pusb_dev = interface_to_usbdev(intf);
440 us->pusb_intf = intf;
441 us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
442 US_DEBUGP("Vendor: 0x%04x, Product: 0x%04x, Revision: 0x%04x\n",
443 le16_to_cpu(us->pusb_dev->descriptor.idVendor),
444 le16_to_cpu(us->pusb_dev->descriptor.idProduct),
445 le16_to_cpu(us->pusb_dev->descriptor.bcdDevice));
446 US_DEBUGP("Interface Subclass: 0x%02x, Protocol: 0x%02x\n",
447 intf->cur_altsetting->desc.bInterfaceSubClass,
448 intf->cur_altsetting->desc.bInterfaceProtocol);
449
450
451 usb_set_intfdata(intf, us);
452
453
454 us->cr = usb_buffer_alloc(us->pusb_dev, sizeof(*us->cr),
455 GFP_KERNEL, &us->cr_dma);
456 if (!us->cr) {
457 US_DEBUGP("usb_ctrlrequest allocation failed\n");
458 return -ENOMEM;
459 }
460
461 us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE,
462 GFP_KERNEL, &us->iobuf_dma);
463 if (!us->iobuf) {
464 US_DEBUGP("I/O buffer allocation failed\n");
465 return -ENOMEM;
466 }
467
468 us->sensebuf = kmalloc(US_SENSE_SIZE, GFP_KERNEL);
469 if (!us->sensebuf) {
470 US_DEBUGP("Sense buffer allocation failed\n");
471 return -ENOMEM;
472 }
473 return 0;
474}
475
476
477static struct us_unusual_dev *find_unusual(const struct usb_device_id *id)
478{
479 const int id_index = id - storage_usb_ids;
480 return &us_unusual_dev_list[id_index];
481}
482
483
484static int get_device_info(struct us_data *us, const struct usb_device_id *id)
485{
486 struct usb_device *dev = us->pusb_dev;
487 struct usb_interface_descriptor *idesc =
488 &us->pusb_intf->cur_altsetting->desc;
489 struct us_unusual_dev *unusual_dev = find_unusual(id);
490
491
492 us->unusual_dev = unusual_dev;
493 us->subclass = (unusual_dev->useProtocol == US_SC_DEVICE) ?
494 idesc->bInterfaceSubClass :
495 unusual_dev->useProtocol;
496 us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ?
497 idesc->bInterfaceProtocol :
498 unusual_dev->useTransport;
499 us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
500
501 if (us->fflags & US_FL_IGNORE_DEVICE) {
502 printk(KERN_INFO USB_STORAGE "device ignored\n");
503 return -ENODEV;
504 }
505
506
507
508
509
510 if (dev->speed != USB_SPEED_HIGH)
511 us->fflags &= ~US_FL_GO_SLOW;
512
513
514
515
516
517
518 if (id->idVendor || id->idProduct) {
519 static const char *msgs[3] = {
520 "an unneeded SubClass entry",
521 "an unneeded Protocol entry",
522 "unneeded SubClass and Protocol entries"};
523 struct usb_device_descriptor *ddesc = &dev->descriptor;
524 int msg = -1;
525
526 if (unusual_dev->useProtocol != US_SC_DEVICE &&
527 us->subclass == idesc->bInterfaceSubClass)
528 msg += 1;
529 if (unusual_dev->useTransport != US_PR_DEVICE &&
530 us->protocol == idesc->bInterfaceProtocol)
531 msg += 2;
532 if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
533 printk(KERN_NOTICE USB_STORAGE "This device "
534 "(%04x,%04x,%04x S %02x P %02x)"
535 " has %s in unusual_devs.h (kernel"
536 " %s)\n"
537 " Please send a copy of this message to "
538 "<linux-usb@vger.kernel.org> and "
539 "<usb-storage@lists.one-eyed-alien.net>\n",
540 le16_to_cpu(ddesc->idVendor),
541 le16_to_cpu(ddesc->idProduct),
542 le16_to_cpu(ddesc->bcdDevice),
543 idesc->bInterfaceSubClass,
544 idesc->bInterfaceProtocol,
545 msgs[msg],
546 utsname()->release);
547 }
548
549 return 0;
550}
551
552
553static int get_transport(struct us_data *us)
554{
555 switch (us->protocol) {
556 case US_PR_CB:
557 us->transport_name = "Control/Bulk";
558 us->transport = usb_stor_CB_transport;
559 us->transport_reset = usb_stor_CB_reset;
560 us->max_lun = 7;
561 break;
562
563 case US_PR_CBI:
564 us->transport_name = "Control/Bulk/Interrupt";
565 us->transport = usb_stor_CBI_transport;
566 us->transport_reset = usb_stor_CB_reset;
567 us->max_lun = 7;
568 break;
569
570 case US_PR_BULK:
571 us->transport_name = "Bulk";
572 us->transport = usb_stor_Bulk_transport;
573 us->transport_reset = usb_stor_Bulk_reset;
574 break;
575
576#ifdef CONFIG_USB_STORAGE_USBAT
577 case US_PR_USBAT:
578 us->transport_name = "Shuttle USBAT";
579 us->transport = usbat_transport;
580 us->transport_reset = usb_stor_CB_reset;
581 us->max_lun = 1;
582 break;
583#endif
584
585#ifdef CONFIG_USB_STORAGE_SDDR09
586 case US_PR_EUSB_SDDR09:
587 us->transport_name = "EUSB/SDDR09";
588 us->transport = sddr09_transport;
589 us->transport_reset = usb_stor_CB_reset;
590 us->max_lun = 0;
591 break;
592#endif
593
594#ifdef CONFIG_USB_STORAGE_SDDR55
595 case US_PR_SDDR55:
596 us->transport_name = "SDDR55";
597 us->transport = sddr55_transport;
598 us->transport_reset = sddr55_reset;
599 us->max_lun = 0;
600 break;
601#endif
602
603#ifdef CONFIG_USB_STORAGE_DPCM
604 case US_PR_DPCM_USB:
605 us->transport_name = "Control/Bulk-EUSB/SDDR09";
606 us->transport = dpcm_transport;
607 us->transport_reset = usb_stor_CB_reset;
608 us->max_lun = 1;
609 break;
610#endif
611
612#ifdef CONFIG_USB_STORAGE_FREECOM
613 case US_PR_FREECOM:
614 us->transport_name = "Freecom";
615 us->transport = freecom_transport;
616 us->transport_reset = usb_stor_freecom_reset;
617 us->max_lun = 0;
618 break;
619#endif
620
621#ifdef CONFIG_USB_STORAGE_DATAFAB
622 case US_PR_DATAFAB:
623 us->transport_name = "Datafab Bulk-Only";
624 us->transport = datafab_transport;
625 us->transport_reset = usb_stor_Bulk_reset;
626 us->max_lun = 1;
627 break;
628#endif
629
630#ifdef CONFIG_USB_STORAGE_JUMPSHOT
631 case US_PR_JUMPSHOT:
632 us->transport_name = "Lexar Jumpshot Control/Bulk";
633 us->transport = jumpshot_transport;
634 us->transport_reset = usb_stor_Bulk_reset;
635 us->max_lun = 1;
636 break;
637#endif
638
639#ifdef CONFIG_USB_STORAGE_ALAUDA
640 case US_PR_ALAUDA:
641 us->transport_name = "Alauda Control/Bulk";
642 us->transport = alauda_transport;
643 us->transport_reset = usb_stor_Bulk_reset;
644 us->max_lun = 1;
645 break;
646#endif
647
648#ifdef CONFIG_USB_STORAGE_KARMA
649 case US_PR_KARMA:
650 us->transport_name = "Rio Karma/Bulk";
651 us->transport = rio_karma_transport;
652 us->transport_reset = usb_stor_Bulk_reset;
653 break;
654#endif
655
656 default:
657 return -EIO;
658 }
659 US_DEBUGP("Transport: %s\n", us->transport_name);
660
661
662 if (us->fflags & US_FL_SINGLE_LUN)
663 us->max_lun = 0;
664 return 0;
665}
666
667
668static int get_protocol(struct us_data *us)
669{
670 switch (us->subclass) {
671 case US_SC_RBC:
672 us->protocol_name = "Reduced Block Commands (RBC)";
673 us->proto_handler = usb_stor_transparent_scsi_command;
674 break;
675
676 case US_SC_8020:
677 us->protocol_name = "8020i";
678 us->proto_handler = usb_stor_ATAPI_command;
679 us->max_lun = 0;
680 break;
681
682 case US_SC_QIC:
683 us->protocol_name = "QIC-157";
684 us->proto_handler = usb_stor_qic157_command;
685 us->max_lun = 0;
686 break;
687
688 case US_SC_8070:
689 us->protocol_name = "8070i";
690 us->proto_handler = usb_stor_ATAPI_command;
691 us->max_lun = 0;
692 break;
693
694 case US_SC_SCSI:
695 us->protocol_name = "Transparent SCSI";
696 us->proto_handler = usb_stor_transparent_scsi_command;
697 break;
698
699 case US_SC_UFI:
700 us->protocol_name = "Uniform Floppy Interface (UFI)";
701 us->proto_handler = usb_stor_ufi_command;
702 break;
703
704#ifdef CONFIG_USB_STORAGE_ISD200
705 case US_SC_ISD200:
706 us->protocol_name = "ISD200 ATA/ATAPI";
707 us->proto_handler = isd200_ata_command;
708 break;
709#endif
710
711#ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
712 case US_SC_CYP_ATACB:
713 us->protocol_name = "Transparent SCSI with Cypress ATACB";
714 us->proto_handler = cypress_atacb_passthrough;
715 break;
716#endif
717
718 default:
719 return -EIO;
720 }
721 US_DEBUGP("Protocol: %s\n", us->protocol_name);
722 return 0;
723}
724
725
726static int get_pipes(struct us_data *us)
727{
728 struct usb_host_interface *altsetting =
729 us->pusb_intf->cur_altsetting;
730 int i;
731 struct usb_endpoint_descriptor *ep;
732 struct usb_endpoint_descriptor *ep_in = NULL;
733 struct usb_endpoint_descriptor *ep_out = NULL;
734 struct usb_endpoint_descriptor *ep_int = NULL;
735
736
737
738
739
740
741
742 for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
743 ep = &altsetting->endpoint[i].desc;
744
745 if (usb_endpoint_xfer_bulk(ep)) {
746 if (usb_endpoint_dir_in(ep)) {
747 if (!ep_in)
748 ep_in = ep;
749 } else {
750 if (!ep_out)
751 ep_out = ep;
752 }
753 }
754
755 else if (usb_endpoint_is_int_in(ep)) {
756 if (!ep_int)
757 ep_int = ep;
758 }
759 }
760
761 if (!ep_in || !ep_out || (us->protocol == US_PR_CBI && !ep_int)) {
762 US_DEBUGP("Endpoint sanity check failed! Rejecting dev.\n");
763 return -EIO;
764 }
765
766
767 us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
768 us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
769 us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev,
770 ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
771 us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev,
772 ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
773 if (ep_int) {
774 us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev,
775 ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
776 us->ep_bInterval = ep_int->bInterval;
777 }
778 return 0;
779}
780
781
782static int usb_stor_acquire_resources(struct us_data *us)
783{
784 int p;
785 struct task_struct *th;
786
787 us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
788 if (!us->current_urb) {
789 US_DEBUGP("URB allocation failed\n");
790 return -ENOMEM;
791 }
792
793
794
795 if (us->unusual_dev->initFunction) {
796 p = us->unusual_dev->initFunction(us);
797 if (p)
798 return p;
799 }
800
801
802 th = kthread_run(usb_stor_control_thread, us, "usb-storage");
803 if (IS_ERR(th)) {
804 printk(KERN_WARNING USB_STORAGE
805 "Unable to start control thread\n");
806 return PTR_ERR(th);
807 }
808 us->ctl_thread = th;
809
810 return 0;
811}
812
813
814static void usb_stor_release_resources(struct us_data *us)
815{
816 US_DEBUGP("-- %s\n", __func__);
817
818
819
820
821
822 US_DEBUGP("-- sending exit command to thread\n");
823 complete(&us->cmnd_ready);
824 if (us->ctl_thread)
825 kthread_stop(us->ctl_thread);
826
827
828 if (us->extra_destructor) {
829 US_DEBUGP("-- calling extra_destructor()\n");
830 us->extra_destructor(us->extra);
831 }
832
833
834 kfree(us->extra);
835 usb_free_urb(us->current_urb);
836}
837
838
839static void dissociate_dev(struct us_data *us)
840{
841 US_DEBUGP("-- %s\n", __func__);
842
843 kfree(us->sensebuf);
844
845
846 if (us->cr)
847 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr,
848 us->cr_dma);
849 if (us->iobuf)
850 usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf,
851 us->iobuf_dma);
852
853
854 usb_set_intfdata(us->pusb_intf, NULL);
855}
856
857
858
859
860static void quiesce_and_remove_host(struct us_data *us)
861{
862 struct Scsi_Host *host = us_to_host(us);
863
864
865 if (us->pusb_dev->state == USB_STATE_NOTATTACHED)
866 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
867
868
869
870
871 set_bit(US_FLIDX_DONT_SCAN, &us->dflags);
872 wake_up(&us->delay_wait);
873 wait_for_completion(&us->scanning_done);
874
875
876
877
878 scsi_remove_host(host);
879
880
881
882
883 scsi_lock(host);
884 set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
885 scsi_unlock(host);
886 wake_up(&us->delay_wait);
887}
888
889
890static void release_everything(struct us_data *us)
891{
892 usb_stor_release_resources(us);
893 dissociate_dev(us);
894
895
896
897 scsi_host_put(us_to_host(us));
898}
899
900
901static int usb_stor_scan_thread(void * __us)
902{
903 struct us_data *us = (struct us_data *)__us;
904
905 printk(KERN_DEBUG
906 "usb-storage: device found at %d\n", us->pusb_dev->devnum);
907
908 set_freezable();
909
910 if (delay_use > 0) {
911 printk(KERN_DEBUG "usb-storage: waiting for device "
912 "to settle before scanning\n");
913 wait_event_freezable_timeout(us->delay_wait,
914 test_bit(US_FLIDX_DONT_SCAN, &us->dflags),
915 delay_use * HZ);
916 }
917
918
919 if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) {
920
921
922 if (us->protocol == US_PR_BULK &&
923 !(us->fflags & US_FL_SINGLE_LUN)) {
924 mutex_lock(&us->dev_mutex);
925 us->max_lun = usb_stor_Bulk_max_lun(us);
926 mutex_unlock(&us->dev_mutex);
927 }
928 scsi_scan_host(us_to_host(us));
929 printk(KERN_DEBUG "usb-storage: device scan complete\n");
930
931
932 }
933
934 complete_and_exit(&us->scanning_done, 0);
935}
936
937
938
939static int storage_probe(struct usb_interface *intf,
940 const struct usb_device_id *id)
941{
942 struct Scsi_Host *host;
943 struct us_data *us;
944 int result;
945 struct task_struct *th;
946
947 if (usb_usual_check_type(id, USB_US_TYPE_STOR))
948 return -ENXIO;
949
950 US_DEBUGP("USB Mass Storage device detected\n");
951
952
953
954
955
956 host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
957 if (!host) {
958 printk(KERN_WARNING USB_STORAGE
959 "Unable to allocate the scsi host\n");
960 return -ENOMEM;
961 }
962
963
964
965
966 host->max_cmd_len = 16;
967 us = host_to_us(host);
968 memset(us, 0, sizeof(struct us_data));
969 mutex_init(&(us->dev_mutex));
970 init_completion(&us->cmnd_ready);
971 init_completion(&(us->notify));
972 init_waitqueue_head(&us->delay_wait);
973 init_completion(&us->scanning_done);
974
975
976 result = associate_dev(us, intf);
977 if (result)
978 goto BadDevice;
979
980
981
982
983
984
985
986
987 result = get_device_info(us, id);
988 if (result)
989 goto BadDevice;
990
991
992 result = get_transport(us);
993 if (result)
994 goto BadDevice;
995 result = get_protocol(us);
996 if (result)
997 goto BadDevice;
998 result = get_pipes(us);
999 if (result)
1000 goto BadDevice;
1001
1002
1003 result = usb_stor_acquire_resources(us);
1004 if (result)
1005 goto BadDevice;
1006 result = scsi_add_host(host, &intf->dev);
1007 if (result) {
1008 printk(KERN_WARNING USB_STORAGE
1009 "Unable to add the scsi host\n");
1010 goto BadDevice;
1011 }
1012
1013
1014 th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan");
1015 if (IS_ERR(th)) {
1016 printk(KERN_WARNING USB_STORAGE
1017 "Unable to start the device-scanning thread\n");
1018 complete(&us->scanning_done);
1019 quiesce_and_remove_host(us);
1020 result = PTR_ERR(th);
1021 goto BadDevice;
1022 }
1023
1024 wake_up_process(th);
1025
1026 return 0;
1027
1028
1029BadDevice:
1030 US_DEBUGP("storage_probe() failed\n");
1031 release_everything(us);
1032 return result;
1033}
1034
1035
1036static void storage_disconnect(struct usb_interface *intf)
1037{
1038 struct us_data *us = usb_get_intfdata(intf);
1039
1040 US_DEBUGP("storage_disconnect() called\n");
1041 quiesce_and_remove_host(us);
1042 release_everything(us);
1043}
1044
1045
1046
1047
1048
1049static struct usb_driver usb_storage_driver = {
1050 .name = "usb-storage",
1051 .probe = storage_probe,
1052 .disconnect = storage_disconnect,
1053#ifdef CONFIG_PM
1054 .suspend = storage_suspend,
1055 .resume = storage_resume,
1056 .reset_resume = storage_reset_resume,
1057#endif
1058 .pre_reset = storage_pre_reset,
1059 .post_reset = storage_post_reset,
1060 .id_table = storage_usb_ids,
1061 .soft_unbind = 1,
1062};
1063
1064static int __init usb_stor_init(void)
1065{
1066 int retval;
1067 printk(KERN_INFO "Initializing USB Mass Storage driver...\n");
1068
1069
1070 retval = usb_register(&usb_storage_driver);
1071 if (retval == 0) {
1072 printk(KERN_INFO "USB Mass Storage support registered.\n");
1073 usb_usual_set_present(USB_US_TYPE_STOR);
1074 }
1075 return retval;
1076}
1077
1078static void __exit usb_stor_exit(void)
1079{
1080 US_DEBUGP("usb_stor_exit() called\n");
1081
1082
1083
1084
1085
1086 US_DEBUGP("-- calling usb_deregister()\n");
1087 usb_deregister(&usb_storage_driver) ;
1088
1089 usb_usual_clear_present(USB_US_TYPE_STOR);
1090}
1091
1092module_init(usb_stor_init);
1093module_exit(usb_stor_exit);