1 #include <linux/sched.h>
2 #include <linux/errno.h>
3 #include <linux/freezer.h>
4 #include <linux/module.h>
5 #include <linux/init.h>
6 #include <linux/slab.h>
7 #include <linux/kthread.h>
8 #include <linux/mutex.h>
9 #include <linux/utsname.h>
11 #include <scsi/scsi.h>
12 #include <scsi/scsi_cmnd.h>
13 #include <scsi/scsi_device.h>
17 #include "transport.h"
19 /* Some informational data */
20 MODULE_AUTHOR("Domao");
21 MODULE_DESCRIPTION("ENE USB Mass Storage driver for Linux");
22 MODULE_LICENSE("GPL");
24 static unsigned int delay_use
= 1;
26 static struct usb_device_id eucr_usb_ids
[] = {
27 { USB_DEVICE(0x058f, 0x6366) },
28 { USB_DEVICE(0x0cf2, 0x6230) },
29 { USB_DEVICE(0x0cf2, 0x6250) },
30 { } /* Terminating entry */
32 MODULE_DEVICE_TABLE (usb
, eucr_usb_ids
);
37 int eucr_suspend(struct usb_interface
*iface
, pm_message_t message
)
39 struct us_data
*us
= usb_get_intfdata(iface
);
40 printk("--- eucr_suspend ---\n");
41 /* Wait until no command is running */
42 mutex_lock(&us
->dev_mutex
);
44 //US_DEBUGP("%s\n", __func__);
45 if (us
->suspend_resume_hook
)
46 (us
->suspend_resume_hook
)(us
, US_SUSPEND
);
48 /* When runtime PM is working, we'll set a flag to indicate
49 * whether we should autoresume when a SCSI request arrives. */
50 // us->Power_IsResum = true;
51 //us->SD_Status.Ready = 0;
53 mutex_unlock(&us
->dev_mutex
);
56 //EXPORT_SYMBOL_GPL(eucr_suspend);
58 int eucr_resume(struct usb_interface
*iface
)
62 struct us_data
*us
= usb_get_intfdata(iface
);
63 printk("--- eucr_resume---\n");
64 mutex_lock(&us
->dev_mutex
);
66 //US_DEBUGP("%s\n", __func__);
67 if (us
->suspend_resume_hook
)
68 (us
->suspend_resume_hook
)(us
, US_RESUME
);
71 mutex_unlock(&us
->dev_mutex
);
74 us
->Power_IsResum
= true;
76 //us->SD_Status.Ready = 0; //??
77 us
->SD_Status
= *(PSD_STATUS
)&tmp
;
78 us
->MS_Status
= *(PMS_STATUS
)&tmp
;
79 us
->SM_Status
= *(PSM_STATUS
)&tmp
;
83 //EXPORT_SYMBOL_GPL(eucr_resume);
84 int eucr_reset_resume(struct usb_interface
*iface
)
87 struct us_data
*us
= usb_get_intfdata(iface
);
89 printk("--- eucr_reset_resume---\n");
90 //US_DEBUGP("%s\n", __func__);
92 /* Report the reset to the SCSI core */
93 usb_stor_report_bus_reset(us
);
95 /* FIXME: Notify the subdrivers that they need to reinitialize
98 us
->Power_IsResum
= true;
100 //us->SD_Status.Ready = 0; //??
101 us
->SD_Status
= *(PSD_STATUS
)&tmp
;
102 us
->MS_Status
= *(PMS_STATUS
)&tmp
;
103 us
->SM_Status
= *(PSM_STATUS
)&tmp
;
106 //EXPORT_SYMBOL_GPL(usb_stor_reset_resume);
110 #define eucr_suspend NULL
111 #define eucr_resume NULL
112 #define eucr_reset_resume NULL
116 //----- eucr_pre_reset() ---------------------
117 static int eucr_pre_reset(struct usb_interface
*iface
)
119 struct us_data
*us
= usb_get_intfdata(iface
);
121 printk("usb --- eucr_pre_reset\n");
123 /* Make sure no command runs during the reset */
124 mutex_lock(&us
->dev_mutex
);
128 //----- eucr_post_reset() ---------------------
129 static int eucr_post_reset(struct usb_interface
*iface
)
131 struct us_data
*us
= usb_get_intfdata(iface
);
133 printk("usb --- eucr_post_reset\n");
135 /* Report the reset to the SCSI core */
136 usb_stor_report_bus_reset(us
);
138 mutex_unlock(&us
->dev_mutex
);
142 //----- fill_inquiry_response() ---------------------
143 void fill_inquiry_response(struct us_data
*us
, unsigned char *data
, unsigned int data_len
)
145 printk("usb --- fill_inquiry_response\n");
146 if (data_len
<36) // You lose.
155 u16 bcdDevice
= le16_to_cpu(us
->pusb_dev
->descriptor
.bcdDevice
);
156 memcpy(data
+8, us
->unusual_dev
->vendorName
,
157 strlen(us
->unusual_dev
->vendorName
) > 8 ? 8 :
158 strlen(us
->unusual_dev
->vendorName
));
159 memcpy(data
+16, us
->unusual_dev
->productName
,
160 strlen(us
->unusual_dev
->productName
) > 16 ? 16 :
161 strlen(us
->unusual_dev
->productName
));
162 data
[32] = 0x30 + ((bcdDevice
>>12) & 0x0F);
163 data
[33] = 0x30 + ((bcdDevice
>>8) & 0x0F);
164 data
[34] = 0x30 + ((bcdDevice
>>4) & 0x0F);
165 data
[35] = 0x30 + ((bcdDevice
) & 0x0F);
167 usb_stor_set_xfer_buf(us
, data
, data_len
, us
->srb
, TO_XFER_BUF
);
170 //----- usb_stor_control_thread() ---------------------
171 static int usb_stor_control_thread(void * __us
)
173 struct us_data
*us
= (struct us_data
*)__us
;
174 struct Scsi_Host
*host
= us_to_host(us
);
176 printk("usb --- usb_stor_control_thread\n");
179 if (wait_for_completion_interruptible(&us
->cmnd_ready
))
182 /* lock the device pointers */
183 mutex_lock(&(us
->dev_mutex
));
185 /* if the device has disconnected, we are free to exit */
186 if (test_bit(US_FLIDX_DISCONNECTING
, &us
->dflags
)) {
187 mutex_unlock(&us
->dev_mutex
);
191 /* lock access to the state */
194 /* When we are called with no command pending, we're done */
198 mutex_unlock(&us
->dev_mutex
);
199 //US_DEBUGP("-- exiting\n");
203 /* has the command timed out *already* ? */
204 if (test_bit(US_FLIDX_TIMED_OUT
, &us
->dflags
))
206 us
->srb
->result
= DID_ABORT
<< 16;
212 if (us
->srb
->sc_data_direction
== DMA_BIDIRECTIONAL
)
214 us
->srb
->result
= DID_ERROR
<< 16;
216 else if (us
->srb
->device
->id
&& !(us
->fflags
& US_FL_SCM_MULT_TARG
))
218 us
->srb
->result
= DID_BAD_TARGET
<< 16;
220 else if (us
->srb
->device
->lun
> us
->max_lun
)
222 us
->srb
->result
= DID_BAD_TARGET
<< 16;
224 else if ((us
->srb
->cmnd
[0] == INQUIRY
) && (us
->fflags
& US_FL_FIX_INQUIRY
))
226 unsigned char data_ptr
[36] = {0x00, 0x80, 0x02, 0x02, 0x1F, 0x00, 0x00, 0x00};
228 fill_inquiry_response(us
, data_ptr
, 36);
229 us
->srb
->result
= SAM_STAT_GOOD
;
233 us
->proto_handler(us
->srb
, us
);
236 /* lock access to the state */
239 /* indicate that the command is done */
240 if (us
->srb
->result
!= DID_ABORT
<< 16)
242 us
->srb
->scsi_done(us
->srb
);
247 printk("scsi command aborted\n");
250 if (test_bit(US_FLIDX_TIMED_OUT
, &us
->dflags
))
252 complete(&(us
->notify
));
254 /* Allow USB transfers to resume */
255 clear_bit(US_FLIDX_ABORTING
, &us
->dflags
);
256 clear_bit(US_FLIDX_TIMED_OUT
, &us
->dflags
);
259 /* finished working on this command */
263 /* unlock the device pointers */
264 mutex_unlock(&us
->dev_mutex
);
267 /* Wait until we are told to stop */
270 set_current_state(TASK_INTERRUPTIBLE
);
271 if (kthread_should_stop())
275 __set_current_state(TASK_RUNNING
);
279 //----- associate_dev() ---------------------
280 static int associate_dev(struct us_data
*us
, struct usb_interface
*intf
)
282 printk("usb --- associate_dev\n");
284 /* Fill in the device-related fields */
285 us
->pusb_dev
= interface_to_usbdev(intf
);
286 us
->pusb_intf
= intf
;
287 us
->ifnum
= intf
->cur_altsetting
->desc
.bInterfaceNumber
;
289 /* Store our private data in the interface */
290 usb_set_intfdata(intf
, us
);
292 /* Allocate the device-related DMA-mapped buffers */
293 us
->cr
= usb_alloc_coherent(us
->pusb_dev
, sizeof(*us
->cr
), GFP_KERNEL
, &us
->cr_dma
);
296 printk("usb_ctrlrequest allocation failed\n");
300 us
->iobuf
= usb_alloc_coherent(us
->pusb_dev
, US_IOBUF_SIZE
, GFP_KERNEL
, &us
->iobuf_dma
);
303 printk("I/O buffer allocation failed\n");
307 us
->sensebuf
= kmalloc(US_SENSE_SIZE
, GFP_KERNEL
);
310 printk("Sense buffer allocation failed\n");
316 //----- get_device_info() ---------------------
317 static int get_device_info(struct us_data
*us
, const struct usb_device_id
*id
)
319 struct usb_device
*dev
= us
->pusb_dev
;
320 struct usb_interface_descriptor
*idesc
= &us
->pusb_intf
->cur_altsetting
->desc
;
322 printk("usb --- get_device_info\n");
324 us
->subclass
= idesc
->bInterfaceSubClass
;
325 us
->protocol
= idesc
->bInterfaceProtocol
;
326 us
->fflags
= USB_US_ORIG_FLAGS(id
->driver_info
);
327 us
->Power_IsResum
= false;
329 if (us
->fflags
& US_FL_IGNORE_DEVICE
)
331 printk("device ignored\n");
335 if (dev
->speed
!= USB_SPEED_HIGH
)
336 us
->fflags
&= ~US_FL_GO_SLOW
;
341 //----- get_transport() ---------------------
342 static int get_transport(struct us_data
*us
)
344 printk("usb --- get_transport\n");
345 switch (us
->protocol
) {
347 us
->transport_name
= "Bulk";
348 us
->transport
= usb_stor_Bulk_transport
;
349 us
->transport_reset
= usb_stor_Bulk_reset
;
355 //printk("Transport: %s\n", us->transport_name);
357 /* fix for single-lun devices */
358 if (us
->fflags
& US_FL_SINGLE_LUN
)
363 //----- get_protocol() ---------------------
364 static int get_protocol(struct us_data
*us
)
366 printk("usb --- get_protocol\n");
367 printk("us->pusb_dev->descriptor.idVendor = %x\n", us
->pusb_dev
->descriptor
.idVendor
);
368 printk("us->pusb_dev->descriptor.idProduct = %x\n", us
->pusb_dev
->descriptor
.idProduct
);
369 switch (us
->subclass
) {
371 us
->protocol_name
= "Transparent SCSI";
372 if( (us
->pusb_dev
->descriptor
.idVendor
== 0x0CF2) && (us
->pusb_dev
->descriptor
.idProduct
== 0x6250) )
373 us
->proto_handler
= ENE_stor_invoke_transport
;
375 us
->proto_handler
= usb_stor_invoke_transport
;
381 //printk("Protocol: %s\n", us->protocol_name);
385 //----- get_pipes() ---------------------
386 static int get_pipes(struct us_data
*us
)
388 struct usb_host_interface
*altsetting
= us
->pusb_intf
->cur_altsetting
;
390 struct usb_endpoint_descriptor
*ep
;
391 struct usb_endpoint_descriptor
*ep_in
= NULL
;
392 struct usb_endpoint_descriptor
*ep_out
= NULL
;
393 struct usb_endpoint_descriptor
*ep_int
= NULL
;
395 printk("usb --- get_pipes\n");
397 for (i
= 0; i
< altsetting
->desc
.bNumEndpoints
; i
++)
399 ep
= &altsetting
->endpoint
[i
].desc
;
401 if (usb_endpoint_xfer_bulk(ep
))
403 if (usb_endpoint_dir_in(ep
))
414 else if (usb_endpoint_is_int_in(ep
))
421 if (!ep_in
|| !ep_out
|| (us
->protocol
== USB_PR_CBI
&& !ep_int
))
423 printk("Endpoint sanity check failed! Rejecting dev.\n");
427 /* Calculate and store the pipe values */
428 us
->send_ctrl_pipe
= usb_sndctrlpipe(us
->pusb_dev
, 0);
429 us
->recv_ctrl_pipe
= usb_rcvctrlpipe(us
->pusb_dev
, 0);
430 us
->send_bulk_pipe
= usb_sndbulkpipe(us
->pusb_dev
, ep_out
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
431 us
->recv_bulk_pipe
= usb_rcvbulkpipe(us
->pusb_dev
, ep_in
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
434 us
->recv_intr_pipe
= usb_rcvintpipe(us
->pusb_dev
, ep_int
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
);
435 us
->ep_bInterval
= ep_int
->bInterval
;
440 //----- usb_stor_acquire_resources() ---------------------
441 static int usb_stor_acquire_resources(struct us_data
*us
)
443 struct task_struct
*th
;
445 printk("usb --- usb_stor_acquire_resources\n");
446 us
->current_urb
= usb_alloc_urb(0, GFP_KERNEL
);
447 if (!us
->current_urb
)
449 printk("URB allocation failed\n");
453 /* Start up our control thread */
454 th
= kthread_run(usb_stor_control_thread
, us
, "eucr-storage");
457 printk("Unable to start control thread\n");
465 //----- usb_stor_release_resources() ---------------------
466 static void usb_stor_release_resources(struct us_data
*us
)
468 printk("usb --- usb_stor_release_resources\n");
472 complete(&us
->cmnd_ready
);
474 kthread_stop(us
->ctl_thread
);
476 /* Call the destructor routine, if it exists */
477 if (us
->extra_destructor
)
479 printk("-- calling extra_destructor()\n");
480 us
->extra_destructor(us
->extra
);
483 /* Free the extra data and the URB */
485 usb_free_urb(us
->current_urb
);
488 //----- dissociate_dev() ---------------------
489 static void dissociate_dev(struct us_data
*us
)
491 printk("usb --- dissociate_dev\n");
495 /* Free the device-related DMA-mapped buffers */
497 usb_free_coherent(us
->pusb_dev
, sizeof(*us
->cr
), us
->cr
, us
->cr_dma
);
499 usb_free_coherent(us
->pusb_dev
, US_IOBUF_SIZE
, us
->iobuf
, us
->iobuf_dma
);
501 /* Remove our private data from the interface */
502 usb_set_intfdata(us
->pusb_intf
, NULL
);
505 //----- quiesce_and_remove_host() ---------------------
506 static void quiesce_and_remove_host(struct us_data
*us
)
508 struct Scsi_Host
*host
= us_to_host(us
);
510 printk("usb --- quiesce_and_remove_host\n");
512 /* If the device is really gone, cut short reset delays */
513 if (us
->pusb_dev
->state
== USB_STATE_NOTATTACHED
)
514 set_bit(US_FLIDX_DISCONNECTING
, &us
->dflags
);
516 /* Prevent SCSI-scanning (if it hasn't started yet)
517 * and wait for the SCSI-scanning thread to stop.
519 set_bit(US_FLIDX_DONT_SCAN
, &us
->dflags
);
520 wake_up(&us
->delay_wait
);
521 wait_for_completion(&us
->scanning_done
);
523 /* Removing the host will perform an orderly shutdown: caches
524 * synchronized, disks spun down, etc.
526 scsi_remove_host(host
);
528 /* Prevent any new commands from being accepted and cut short
532 set_bit(US_FLIDX_DISCONNECTING
, &us
->dflags
);
534 wake_up(&us
->delay_wait
);
537 //----- release_everything() ---------------------
538 static void release_everything(struct us_data
*us
)
540 printk("usb --- release_everything\n");
542 usb_stor_release_resources(us
);
544 scsi_host_put(us_to_host(us
));
547 //----- usb_stor_scan_thread() ---------------------
548 static int usb_stor_scan_thread(void * __us
)
550 struct us_data
*us
= (struct us_data
*)__us
;
552 printk("usb --- usb_stor_scan_thread\n");
553 printk("EUCR : device found at %d\n", us
->pusb_dev
->devnum
);
556 /* Wait for the timeout to expire or for a disconnect */
558 wait_event_freezable_timeout(us
->delay_wait
,
559 test_bit(US_FLIDX_DONT_SCAN
, &us
->dflags
),
563 /* If the device is still connected, perform the scanning */
564 if (!test_bit(US_FLIDX_DONT_SCAN
, &us
->dflags
))
566 /* For bulk-only devices, determine the max LUN value */
567 if (us
->protocol
== USB_PR_BULK
&& !(us
->fflags
& US_FL_SINGLE_LUN
))
569 mutex_lock(&us
->dev_mutex
);
570 us
->max_lun
= usb_stor_Bulk_max_lun(us
);
571 mutex_unlock(&us
->dev_mutex
);
573 scsi_scan_host(us_to_host(us
));
574 printk("EUCR : device scan complete\n");
576 complete_and_exit(&us
->scanning_done
, 0);
579 //----- eucr_probe() ---------------------
580 static int eucr_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
582 struct Scsi_Host
*host
;
585 struct task_struct
*th
;
587 printk("usb --- eucr_probe\n");
589 host
= scsi_host_alloc(&usb_stor_host_template
, sizeof(*us
));
592 printk("Unable to allocate the scsi host\n");
596 /* Allow 16-byte CDBs and thus > 2TB */
597 host
->max_cmd_len
= 16;
598 us
= host_to_us(host
);
599 memset(us
, 0, sizeof(struct us_data
));
600 mutex_init(&(us
->dev_mutex
));
601 init_completion(&us
->cmnd_ready
);
602 init_completion(&(us
->notify
));
603 init_waitqueue_head(&us
->delay_wait
);
604 init_completion(&us
->scanning_done
);
606 /* Associate the us_data structure with the USB device */
607 result
= associate_dev(us
, intf
);
611 /* Get Device info */
612 result
= get_device_info(us
, id
);
616 /* Get the transport, protocol, and pipe settings */
617 result
= get_transport(us
);
620 result
= get_protocol(us
);
623 result
= get_pipes(us
);
627 /* Acquire all the other resources and add the host */
628 result
= usb_stor_acquire_resources(us
);
632 result
= scsi_add_host(host
, &intf
->dev
);
635 printk("Unable to add the scsi host\n");
639 /* Start up the thread for delayed SCSI-device scanning */
640 th
= kthread_create(usb_stor_scan_thread
, us
, "eucr-stor-scan");
643 printk("Unable to start the device-scanning thread\n");
644 complete(&us
->scanning_done
);
645 quiesce_and_remove_host(us
);
646 result
= PTR_ERR(th
);
652 /* We come here if there are any problems */
654 printk("usb --- eucr_probe failed\n");
655 release_everything(us
);
659 //----- eucr_disconnect() ---------------------
660 static void eucr_disconnect(struct usb_interface
*intf
)
662 struct us_data
*us
= usb_get_intfdata(intf
);
664 printk("usb --- eucr_disconnect\n");
665 quiesce_and_remove_host(us
);
666 release_everything(us
);
669 /***********************************************************************
670 * Initialization and registration
671 ***********************************************************************/
673 //----- usb_storage_driver() ---------------------
674 static struct usb_driver usb_storage_driver
= {
677 .suspend
= eucr_suspend
,
678 .resume
= eucr_resume
,
679 .reset_resume
= eucr_reset_resume
,
680 .disconnect
= eucr_disconnect
,
681 .pre_reset
= eucr_pre_reset
,
682 .post_reset
= eucr_post_reset
,
683 .id_table
= eucr_usb_ids
,
687 //----- usb_stor_init() ---------------------
688 static int __init
usb_stor_init(void)
691 printk("usb --- usb_stor_init start\n");
693 retval
= usb_register(&usb_storage_driver
);
695 printk("ENE USB Mass Storage support registered.\n");
700 //----- usb_stor_exit() ---------------------
701 static void __exit
usb_stor_exit(void)
703 printk("usb --- usb_stor_exit\n");
705 usb_deregister(&usb_storage_driver
) ;
708 module_init(usb_stor_init
);
709 module_exit(usb_stor_exit
);