[deliverable/linux.git] / drivers / staging / keucr / usb.c

#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/freezer.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/kthread.h>
#include <linux/mutex.h>
#include <linux/utsname.h>

#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>

#include "usb.h"
#include "scsiglue.h"
#include "smil.h"
#include "transport.h"

/* Some informational data */
MODULE_AUTHOR("Domao");
MODULE_DESCRIPTION("ENE USB Mass Storage driver for Linux");
MODULE_LICENSE("GPL");

static unsigned int delay_use = 1;

static struct usb_device_id eucr_usb_ids [] = {
	{ USB_DEVICE(0x058f, 0x6366) },
	{ USB_DEVICE(0x0cf2, 0x6230) },
	{ USB_DEVICE(0x0cf2, 0x6250) },
	{ }                                            /* Terminating entry */
};
MODULE_DEVICE_TABLE (usb, eucr_usb_ids);


#ifdef CONFIG_PM

static int eucr_suspend(struct usb_interface *iface, pm_message_t message)
{
	struct us_data *us = usb_get_intfdata(iface);
	pr_info("--- eucr_suspend ---\n");
	/* Wait until no command is running */
	mutex_lock(&us->dev_mutex);

	//US_DEBUGP("%s\n", __func__);
	if (us->suspend_resume_hook)
		(us->suspend_resume_hook)(us, US_SUSPEND);

	/* When runtime PM is working, we'll set a flag to indicate
	 * whether we should autoresume when a SCSI request arrives. */
	// us->Power_IsResum = true;
	//us->SD_Status.Ready = 0;

	mutex_unlock(&us->dev_mutex);
	return 0;
}
//EXPORT_SYMBOL_GPL(eucr_suspend);

static int eucr_resume(struct usb_interface *iface)
{
	BYTE    tmp = 0;

	struct us_data *us = usb_get_intfdata(iface);
	pr_info("--- eucr_resume---\n");
	mutex_lock(&us->dev_mutex);

	//US_DEBUGP("%s\n", __func__);
	if (us->suspend_resume_hook)
		(us->suspend_resume_hook)(us, US_RESUME);


	mutex_unlock(&us->dev_mutex);

	
         us->Power_IsResum = true;
	//
	//us->SD_Status.Ready = 0; //??
    	us->SM_Status = *(PSM_STATUS)&tmp;
    	
	return 0;
}
//EXPORT_SYMBOL_GPL(eucr_resume);
static int eucr_reset_resume(struct usb_interface *iface)
{
	BYTE    tmp = 0;
	struct us_data *us = usb_get_intfdata(iface);

	pr_info("--- eucr_reset_resume---\n");
	//US_DEBUGP("%s\n", __func__);

	/* Report the reset to the SCSI core */
	usb_stor_report_bus_reset(us);

	/* FIXME: Notify the subdrivers that they need to reinitialize
	 * the device */
	//ENE_InitMedia(us);
 	us->Power_IsResum = true;
	//
	//us->SD_Status.Ready = 0; //??
    	us->SM_Status = *(PSM_STATUS)&tmp;
	return 0;
}
//EXPORT_SYMBOL_GPL(usb_stor_reset_resume);

#else

#define eucr_suspend		NULL
#define eucr_resume		NULL
#define eucr_reset_resume	NULL

#endif

//----- eucr_pre_reset() ---------------------
static int eucr_pre_reset(struct usb_interface *iface)
{
	struct us_data *us = usb_get_intfdata(iface);

	pr_info("usb --- eucr_pre_reset\n");

	/* Make sure no command runs during the reset */
	mutex_lock(&us->dev_mutex);
	return 0;
}

//----- eucr_post_reset() ---------------------
static int eucr_post_reset(struct usb_interface *iface)
{
	struct us_data *us = usb_get_intfdata(iface);

	pr_info("usb --- eucr_post_reset\n");

	/* Report the reset to the SCSI core */
	usb_stor_report_bus_reset(us);

	mutex_unlock(&us->dev_mutex);
	return 0;
}

//----- fill_inquiry_response() ---------------------
void fill_inquiry_response(struct us_data *us, unsigned char *data, unsigned int data_len)
{
	pr_info("usb --- fill_inquiry_response\n");
	if (data_len<36) // You lose.
		return;

	if (data[0]&0x20)
	{
		memset(data+8,0,28);
	}
	else
	{
		u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
		memcpy(data+8, us->unusual_dev->vendorName,
			strlen(us->unusual_dev->vendorName) > 8 ? 8 :
			strlen(us->unusual_dev->vendorName));
		memcpy(data+16, us->unusual_dev->productName,
			strlen(us->unusual_dev->productName) > 16 ? 16 :
			strlen(us->unusual_dev->productName));
		data[32] = 0x30 + ((bcdDevice>>12) & 0x0F);
		data[33] = 0x30 + ((bcdDevice>>8) & 0x0F);
		data[34] = 0x30 + ((bcdDevice>>4) & 0x0F);
		data[35] = 0x30 + ((bcdDevice) & 0x0F);
	}
	usb_stor_set_xfer_buf(us, data, data_len, us->srb, TO_XFER_BUF);
}

//----- usb_stor_control_thread() ---------------------
static int usb_stor_control_thread(void * __us)
{
	struct us_data *us = (struct us_data *)__us;
	struct Scsi_Host *host = us_to_host(us);

	pr_info("usb --- usb_stor_control_thread\n");
	for(;;)
	{
		if (wait_for_completion_interruptible(&us->cmnd_ready))
			break;
			
		/* lock the device pointers */
		mutex_lock(&(us->dev_mutex));

		/* if the device has disconnected, we are free to exit */
		if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
			mutex_unlock(&us->dev_mutex);
			break;
		}

		/* lock access to the state */
		scsi_lock(host);

		/* When we are called with no command pending, we're done */
		if (us->srb == NULL)
		{
			scsi_unlock(host);
			mutex_unlock(&us->dev_mutex);
			//US_DEBUGP("-- exiting\n");
			break;
		}

		/* has the command timed out *already* ? */
		if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags))
		{
			us->srb->result = DID_ABORT << 16;
			goto SkipForAbort;
		}

		scsi_unlock(host);

		if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL)
		{
			us->srb->result = DID_ERROR << 16;
		}
		else if (us->srb->device->id && !(us->fflags & US_FL_SCM_MULT_TARG))
		{
			us->srb->result = DID_BAD_TARGET << 16;
		}
		else if (us->srb->device->lun > us->max_lun)
		{
			us->srb->result = DID_BAD_TARGET << 16;
		}
		else if ((us->srb->cmnd[0] == INQUIRY) && (us->fflags & US_FL_FIX_INQUIRY))
		{
			unsigned char data_ptr[36] = {0x00, 0x80, 0x02, 0x02, 0x1F, 0x00, 0x00, 0x00};

			fill_inquiry_response(us, data_ptr, 36);
			us->srb->result = SAM_STAT_GOOD;
		}
		else
		{
			us->proto_handler(us->srb, us);
		}

		/* lock access to the state */
		scsi_lock(host);

		/* indicate that the command is done */
		if (us->srb->result != DID_ABORT << 16)
		{
			us->srb->scsi_done(us->srb);
		}
		else
		{
SkipForAbort:
			pr_info("scsi command aborted\n");
		}

		if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags))
		{
			complete(&(us->notify));

			/* Allow USB transfers to resume */
			clear_bit(US_FLIDX_ABORTING, &us->dflags);
			clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
		}

		/* finished working on this command */
		us->srb = NULL;
		scsi_unlock(host);

		/* unlock the device pointers */
		mutex_unlock(&us->dev_mutex);
	} /* for (;;) */

	/* Wait until we are told to stop */
	for (;;)
	{
		set_current_state(TASK_INTERRUPTIBLE);
		if (kthread_should_stop())
			break;
		schedule();
	}
	__set_current_state(TASK_RUNNING);
	return 0;
}	

//----- associate_dev() ---------------------
static int associate_dev(struct us_data *us, struct usb_interface *intf)
{
	pr_info("usb --- associate_dev\n");

	/* Fill in the device-related fields */
	us->pusb_dev = interface_to_usbdev(intf);
	us->pusb_intf = intf;
	us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;

	/* Store our private data in the interface */
	usb_set_intfdata(intf, us);

	/* Allocate the device-related DMA-mapped buffers */
	us->cr = usb_alloc_coherent(us->pusb_dev, sizeof(*us->cr), GFP_KERNEL, &us->cr_dma);
	if (!us->cr)
	{
		pr_info("usb_ctrlrequest allocation failed\n");
		return -ENOMEM;
	}

	us->iobuf = usb_alloc_coherent(us->pusb_dev, US_IOBUF_SIZE, GFP_KERNEL, &us->iobuf_dma);
	if (!us->iobuf)
	{
		pr_info("I/O buffer allocation failed\n");
		return -ENOMEM;
	}

	us->sensebuf = kmalloc(US_SENSE_SIZE, GFP_KERNEL);
	if (!us->sensebuf)
	{
		pr_info("Sense buffer allocation failed\n");
		return -ENOMEM;
	}
	return 0;
}

//----- get_device_info() ---------------------
static int get_device_info(struct us_data *us, const struct usb_device_id *id)
{
	struct usb_device *dev = us->pusb_dev;
	struct usb_interface_descriptor *idesc = &us->pusb_intf->cur_altsetting->desc;

	pr_info("usb --- get_device_info\n");

	us->subclass = idesc->bInterfaceSubClass;
	us->protocol = idesc->bInterfaceProtocol;
	us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
	us->Power_IsResum = false;

	if (us->fflags & US_FL_IGNORE_DEVICE)
	{
		pr_info("device ignored\n");
		return -ENODEV;
	}

	if (dev->speed != USB_SPEED_HIGH)
		us->fflags &= ~US_FL_GO_SLOW;

	return 0;
}

//----- get_transport() ---------------------
static int get_transport(struct us_data *us)
{
	pr_info("usb --- get_transport\n");
	switch (us->protocol) {
	case USB_PR_BULK:
		us->transport_name = "Bulk";
		us->transport = usb_stor_Bulk_transport;
		us->transport_reset = usb_stor_Bulk_reset;
		break;

	default:
		return -EIO;
	}
	/* pr_info("Transport: %s\n", us->transport_name); */

	/* fix for single-lun devices */
	if (us->fflags & US_FL_SINGLE_LUN)
		us->max_lun = 0;
	return 0;
}

//----- get_protocol() ---------------------
static int get_protocol(struct us_data *us)
{
	pr_info("usb --- get_protocol\n");
	pr_info("us->pusb_dev->descriptor.idVendor = %x\n",
			us->pusb_dev->descriptor.idVendor);
	pr_info("us->pusb_dev->descriptor.idProduct = %x\n",
			us->pusb_dev->descriptor.idProduct);
	switch (us->subclass) {
	case USB_SC_SCSI:
		us->protocol_name = "Transparent SCSI";
		if( (us->pusb_dev->descriptor.idVendor == 0x0CF2) && (us->pusb_dev->descriptor.idProduct == 0x6250) )
			us->proto_handler = ENE_stor_invoke_transport;
		else
			us->proto_handler = usb_stor_invoke_transport;
		break;

	default:
		return -EIO;
	}
	/* pr_info("Protocol: %s\n", us->protocol_name); */
	return 0;
}

//----- get_pipes() ---------------------
static int get_pipes(struct us_data *us)
{
	struct usb_host_interface *altsetting = us->pusb_intf->cur_altsetting;
	int i;
	struct usb_endpoint_descriptor *ep;
	struct usb_endpoint_descriptor *ep_in = NULL;
	struct usb_endpoint_descriptor *ep_out = NULL;
	struct usb_endpoint_descriptor *ep_int = NULL;

	pr_info("usb --- get_pipes\n");

	for (i = 0; i < altsetting->desc.bNumEndpoints; i++)
	{
		ep = &altsetting->endpoint[i].desc;

		if (usb_endpoint_xfer_bulk(ep))
		{
			if (usb_endpoint_dir_in(ep))
			{
				if (!ep_in)
					ep_in = ep;
			}
			else
			{
				if (!ep_out)
					ep_out = ep;
			}
		}
		else if (usb_endpoint_is_int_in(ep))
		{
			if (!ep_int)
				ep_int = ep;
		}
	}

	if (!ep_in || !ep_out || (us->protocol == USB_PR_CBI && !ep_int))
	{
		pr_info("Endpoint sanity check failed! Rejecting dev.\n");
		return -EIO;
	}

	/* Calculate and store the pipe values */
	us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
	us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
	us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev, ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
	us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
	if (ep_int)
	{
		us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev, ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
		us->ep_bInterval = ep_int->bInterval;
	}
	return 0;
}

//----- usb_stor_acquire_resources() ---------------------
static int usb_stor_acquire_resources(struct us_data *us)
{
	struct task_struct *th;

	pr_info("usb --- usb_stor_acquire_resources\n");
	us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!us->current_urb)
	{
		pr_info("URB allocation failed\n");
		return -ENOMEM;
	}

	/* Start up our control thread */
	th = kthread_run(usb_stor_control_thread, us, "eucr-storage");
	if (IS_ERR(th))
	{
		pr_info("Unable to start control thread\n");
		return PTR_ERR(th);
	}
	us->ctl_thread = th;

	return 0;
}

//----- usb_stor_release_resources() ---------------------
static void usb_stor_release_resources(struct us_data *us)
{
	pr_info("usb --- usb_stor_release_resources\n");

	SM_FreeMem();

	complete(&us->cmnd_ready);
	if (us->ctl_thread)
		kthread_stop(us->ctl_thread);

	/* Call the destructor routine, if it exists */
	if (us->extra_destructor)
	{
		pr_info("-- calling extra_destructor()\n");
		us->extra_destructor(us->extra);
	}

	/* Free the extra data and the URB */
	kfree(us->extra);
	usb_free_urb(us->current_urb);
}

//----- dissociate_dev() ---------------------
static void dissociate_dev(struct us_data *us)
{
	pr_info("usb --- dissociate_dev\n");

	kfree(us->sensebuf);

	/* Free the device-related DMA-mapped buffers */
	if (us->cr)
		usb_free_coherent(us->pusb_dev, sizeof(*us->cr), us->cr, us->cr_dma);
	if (us->iobuf)
		usb_free_coherent(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma);

	/* Remove our private data from the interface */
	usb_set_intfdata(us->pusb_intf, NULL);
}

//----- quiesce_and_remove_host() ---------------------
static void quiesce_and_remove_host(struct us_data *us)
{
	struct Scsi_Host *host = us_to_host(us);

	pr_info("usb --- quiesce_and_remove_host\n");

	/* If the device is really gone, cut short reset delays */
	if (us->pusb_dev->state == USB_STATE_NOTATTACHED)
		set_bit(US_FLIDX_DISCONNECTING, &us->dflags);

	/* Prevent SCSI-scanning (if it hasn't started yet)
	 * and wait for the SCSI-scanning thread to stop.
	 */
	set_bit(US_FLIDX_DONT_SCAN, &us->dflags);
	wake_up(&us->delay_wait);
	wait_for_completion(&us->scanning_done);

	/* Removing the host will perform an orderly shutdown: caches
	 * synchronized, disks spun down, etc.
	 */
	scsi_remove_host(host);

	/* Prevent any new commands from being accepted and cut short
	 * reset delays.
	 */
	scsi_lock(host);
	set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
	scsi_unlock(host);
	wake_up(&us->delay_wait);
}

//----- release_everything() ---------------------
static void release_everything(struct us_data *us)
{
	pr_info("usb --- release_everything\n");

	usb_stor_release_resources(us);
	dissociate_dev(us);
	scsi_host_put(us_to_host(us));
}

//----- usb_stor_scan_thread() ---------------------
static int usb_stor_scan_thread(void * __us)
{
	struct us_data *us = (struct us_data *)__us;

	pr_info("usb --- usb_stor_scan_thread\n");
	pr_info("EUCR : device found at %d\n", us->pusb_dev->devnum);

	set_freezable();
	/* Wait for the timeout to expire or for a disconnect */
	if (delay_use > 0) {
		wait_event_freezable_timeout(us->delay_wait,
				test_bit(US_FLIDX_DONT_SCAN, &us->dflags),
				delay_use * HZ);
	}

	/* If the device is still connected, perform the scanning */
	if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags))
	{
		/* For bulk-only devices, determine the max LUN value */
		if (us->protocol == USB_PR_BULK && !(us->fflags & US_FL_SINGLE_LUN))
		{
			mutex_lock(&us->dev_mutex);
			us->max_lun = usb_stor_Bulk_max_lun(us);
			mutex_unlock(&us->dev_mutex);
		}
		scsi_scan_host(us_to_host(us));
		pr_info("EUCR : device scan complete\n");
	}
	complete_and_exit(&us->scanning_done, 0);
}

//----- eucr_probe() ---------------------
static int eucr_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
	struct Scsi_Host *host;
	struct us_data *us;
	int result;
	BYTE	MiscReg03 = 0;
	struct task_struct *th;

	pr_info("usb --- eucr_probe\n");

      host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
	if (!host)
	{
		pr_info("Unable to allocate the scsi host\n");
		return -ENOMEM;
	}

	/* Allow 16-byte CDBs and thus > 2TB */
	host->max_cmd_len = 16;
	us = host_to_us(host);
	memset(us, 0, sizeof(struct us_data));
	mutex_init(&(us->dev_mutex));
	init_completion(&us->cmnd_ready);
	init_completion(&(us->notify));
	init_waitqueue_head(&us->delay_wait);
	init_completion(&us->scanning_done);

	/* Associate the us_data structure with the USB device */
	result = associate_dev(us, intf);
	if (result)
		goto BadDevice;

	/* Get Device info */
	result = get_device_info(us, id);
	if (result)
		goto BadDevice;

	/* Get the transport, protocol, and pipe settings */
	result = get_transport(us);
	if (result)
		goto BadDevice;
	result = get_protocol(us);
	if (result)
		goto BadDevice;
	result = get_pipes(us);
	if (result)
		goto BadDevice;

	/* Acquire all the other resources and add the host */
	result = usb_stor_acquire_resources(us);
	if (result)
		goto BadDevice;

	result = scsi_add_host(host, &intf->dev);
	if (result)
	{
		pr_info("Unable to add the scsi host\n");
		goto BadDevice;
	}

	/* Start up the thread for delayed SCSI-device scanning */
	th = kthread_create(usb_stor_scan_thread, us, "eucr-stor-scan");
	if (IS_ERR(th)) {
		pr_info("Unable to start the device-scanning thread\n");
		complete(&us->scanning_done);
		quiesce_and_remove_host(us);
		result = PTR_ERR(th);
		goto BadDevice;
	}
	wake_up_process(th);

	/* probe card type */
	result = ENE_Read_BYTE(us, REG_CARD_STATUS, &MiscReg03);
	if (result != USB_STOR_XFER_GOOD) {
		result = USB_STOR_TRANSPORT_ERROR;
		quiesce_and_remove_host(us);
		goto BadDevice;
	}

	if (!(MiscReg03 & 0x02)) {
		result = -ENODEV;
		quiesce_and_remove_host(us);
		pr_info("keucr: The driver only supports SM/MS card.\
			To use SD card, \
			please build driver/usb/storage/ums-eneub6250.ko\n");
		goto BadDevice;
	}

	return 0;

	/* We come here if there are any problems */
BadDevice:
	pr_info("usb --- eucr_probe failed\n");
	release_everything(us);
	return result;
}

//----- eucr_disconnect() ---------------------
static void eucr_disconnect(struct usb_interface *intf)
{
	struct us_data *us = usb_get_intfdata(intf);

	pr_info("usb --- eucr_disconnect\n");
	quiesce_and_remove_host(us);
	release_everything(us);
}

/***********************************************************************
 * Initialization and registration
 ***********************************************************************/

//----- usb_storage_driver() ---------------------
static struct usb_driver usb_storage_driver = {
	.name =		"eucr",
	.probe =		eucr_probe,
    	.suspend =	    eucr_suspend,
	.resume =	    eucr_resume,
    	.reset_resume =	eucr_reset_resume,
	.disconnect =	eucr_disconnect,
	.pre_reset =	eucr_pre_reset,
	.post_reset =	eucr_post_reset,
	.id_table =		eucr_usb_ids,
	.soft_unbind =	1,
};

//----- usb_stor_init() ---------------------
static int __init usb_stor_init(void)
{
	int retval;
	pr_info("usb --- usb_stor_init start\n");

	retval = usb_register(&usb_storage_driver);
	if (retval == 0)
		pr_info("ENE USB Mass Storage support registered.\n");

	return retval;
}

//----- usb_stor_exit() ---------------------
static void __exit usb_stor_exit(void)
{
	pr_info("usb --- usb_stor_exit\n");

	usb_deregister(&usb_storage_driver) ;
}

module_init(usb_stor_init);
module_exit(usb_stor_exit);
Commit	Line	Data
126bb03b AC	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>
	10
	11	#include <scsi/scsi.h>
	12	#include <scsi/scsi_cmnd.h>
	13	#include <scsi/scsi_device.h>
	14
	15	#include "usb.h"
	16	#include "scsiglue.h"
d8aba9d5	17	#include "smil.h"
126bb03b AC	18	#include "transport.h"
	19
	20	/* Some informational data */
	21	MODULE_AUTHOR("Domao");
	22	MODULE_DESCRIPTION("ENE USB Mass Storage driver for Linux");
	23	MODULE_LICENSE("GPL");
	24
a8718692 AC	25	static unsigned int delay_use = 1;
a8718692 AC	26
126bb03b AC	27	static struct usb_device_id eucr_usb_ids [] = {
	28	{ USB_DEVICE(0x058f, 0x6366) },
	29	{ USB_DEVICE(0x0cf2, 0x6230) },
	30	{ USB_DEVICE(0x0cf2, 0x6250) },
	31	{ } /* Terminating entry */
	32	};
	33	MODULE_DEVICE_TABLE (usb, eucr_usb_ids);
	34
	35
e23f773e	36	#ifdef CONFIG_PM
126bb03b	37
d8aba9d5	38	static int eucr_suspend(struct usb_interface *iface, pm_message_t message)
126bb03b AC	39	{
126bb03b AC	40	struct us_data *us = usb_get_intfdata(iface);
871f8477	41	pr_info("--- eucr_suspend ---\n");
126bb03b AC	42	/* Wait until no command is running */
	43	mutex_lock(&us->dev_mutex);
	44
	45	//US_DEBUGP("%s\n", __func__);
	46	if (us->suspend_resume_hook)
	47	(us->suspend_resume_hook)(us, US_SUSPEND);
	48
	49	/* When runtime PM is working, we'll set a flag to indicate
	50	* whether we should autoresume when a SCSI request arrives. */
	51	// us->Power_IsResum = true;
	52	//us->SD_Status.Ready = 0;
	53
	54	mutex_unlock(&us->dev_mutex);
	55	return 0;
	56	}
	57	//EXPORT_SYMBOL_GPL(eucr_suspend);
	58
d8aba9d5	59	static int eucr_resume(struct usb_interface *iface)
126bb03b AC	60	{
	61	BYTE tmp = 0;
	62
	63	struct us_data *us = usb_get_intfdata(iface);
871f8477	64	pr_info("--- eucr_resume---\n");
126bb03b AC	65	mutex_lock(&us->dev_mutex);
	66
	67	//US_DEBUGP("%s\n", __func__);
	68	if (us->suspend_resume_hook)
	69	(us->suspend_resume_hook)(us, US_RESUME);
	70
	71
	72	mutex_unlock(&us->dev_mutex);
	73
	74
	75	us->Power_IsResum = true;
	76	//
	77	//us->SD_Status.Ready = 0; //??
126bb03b AC	78	us->SM_Status = *(PSM_STATUS)&tmp;
	79
	80	return 0;
	81	}
	82	//EXPORT_SYMBOL_GPL(eucr_resume);
d8aba9d5	83	static int eucr_reset_resume(struct usb_interface *iface)
126bb03b AC	84	{
	85	BYTE tmp = 0;
	86	struct us_data *us = usb_get_intfdata(iface);
	87
871f8477	88	pr_info("--- eucr_reset_resume---\n");
126bb03b AC	89	//US_DEBUGP("%s\n", __func__);
	90
	91	/* Report the reset to the SCSI core */
	92	usb_stor_report_bus_reset(us);
	93
	94	/* FIXME: Notify the subdrivers that they need to reinitialize
	95	* the device */
	96	//ENE_InitMedia(us);
	97	us->Power_IsResum = true;
	98	//
	99	//us->SD_Status.Ready = 0; //??
126bb03b AC	100	us->SM_Status = *(PSM_STATUS)&tmp;
	101	return 0;
	102	}
	103	//EXPORT_SYMBOL_GPL(usb_stor_reset_resume);
	104
e23f773e RD	105	#else
	106
	107	#define eucr_suspend NULL
	108	#define eucr_resume NULL
	109	#define eucr_reset_resume NULL
	110
	111	#endif
	112
126bb03b AC	113	//----- eucr_pre_reset() ---------------------
	114	static int eucr_pre_reset(struct usb_interface *iface)
	115	{
	116	struct us_data *us = usb_get_intfdata(iface);
	117
871f8477	118	pr_info("usb --- eucr_pre_reset\n");
126bb03b AC	119
	120	/* Make sure no command runs during the reset */
	121	mutex_lock(&us->dev_mutex);
	122	return 0;
	123	}
	124
	125	//----- eucr_post_reset() ---------------------
	126	static int eucr_post_reset(struct usb_interface *iface)
	127	{
	128	struct us_data *us = usb_get_intfdata(iface);
	129
871f8477	130	pr_info("usb --- eucr_post_reset\n");
126bb03b AC	131
	132	/* Report the reset to the SCSI core */
	133	usb_stor_report_bus_reset(us);
	134
	135	mutex_unlock(&us->dev_mutex);
	136	return 0;
	137	}
	138
	139	//----- fill_inquiry_response() ---------------------
	140	void fill_inquiry_response(struct us_data us, unsigned char data, unsigned int data_len)
	141	{
871f8477	142	pr_info("usb --- fill_inquiry_response\n");
126bb03b AC	143	if (data_len<36) // You lose.
	144	return;
	145
	146	if (data[0]&0x20)
	147	{
	148	memset(data+8,0,28);
	149	}
	150	else
	151	{
	152	u16 bcdDevice = le16_to_cpu(us->pusb_dev->descriptor.bcdDevice);
	153	memcpy(data+8, us->unusual_dev->vendorName,
	154	strlen(us->unusual_dev->vendorName) > 8 ? 8 :
	155	strlen(us->unusual_dev->vendorName));
	156	memcpy(data+16, us->unusual_dev->productName,
	157	strlen(us->unusual_dev->productName) > 16 ? 16 :
	158	strlen(us->unusual_dev->productName));
	159	data[32] = 0x30 + ((bcdDevice>>12) & 0x0F);
	160	data[33] = 0x30 + ((bcdDevice>>8) & 0x0F);
	161	data[34] = 0x30 + ((bcdDevice>>4) & 0x0F);
	162	data[35] = 0x30 + ((bcdDevice) & 0x0F);
	163	}
	164	usb_stor_set_xfer_buf(us, data, data_len, us->srb, TO_XFER_BUF);
	165	}
	166
	167	//----- usb_stor_control_thread() ---------------------
	168	static int usb_stor_control_thread(void * __us)
	169	{
	170	struct us_data us = (struct us_data )__us;
	171	struct Scsi_Host *host = us_to_host(us);
	172
871f8477	173	pr_info("usb --- usb_stor_control_thread\n");
126bb03b AC	174	for(;;)
	175	{
	176	if (wait_for_completion_interruptible(&us->cmnd_ready))
	177	break;
	178
	179	/* lock the device pointers */
	180	mutex_lock(&(us->dev_mutex));
	181
	182	/* if the device has disconnected, we are free to exit */
a8718692	183	if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
126bb03b AC	184	mutex_unlock(&us->dev_mutex);
126bb03b AC	185	break;
a8718692	186	}
126bb03b AC	187
	188	/* lock access to the state */
	189	scsi_lock(host);
	190
	191	/* When we are called with no command pending, we're done */
	192	if (us->srb == NULL)
	193	{
	194	scsi_unlock(host);
	195	mutex_unlock(&us->dev_mutex);
	196	//US_DEBUGP("-- exiting\n");
	197	break;
	198	}
	199
	200	/* has the command timed out already ? */
	201	if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags))
	202	{
	203	us->srb->result = DID_ABORT << 16;
	204	goto SkipForAbort;
	205	}
	206
	207	scsi_unlock(host);
	208
	209	if (us->srb->sc_data_direction == DMA_BIDIRECTIONAL)
	210	{
	211	us->srb->result = DID_ERROR << 16;
	212	}
	213	else if (us->srb->device->id && !(us->fflags & US_FL_SCM_MULT_TARG))
	214	{
	215	us->srb->result = DID_BAD_TARGET << 16;
	216	}
	217	else if (us->srb->device->lun > us->max_lun)
	218	{
	219	us->srb->result = DID_BAD_TARGET << 16;
	220	}
	221	else if ((us->srb->cmnd[0] == INQUIRY) && (us->fflags & US_FL_FIX_INQUIRY))
	222	{
	223	unsigned char data_ptr[36] = {0x00, 0x80, 0x02, 0x02, 0x1F, 0x00, 0x00, 0x00};
	224
	225	fill_inquiry_response(us, data_ptr, 36);
	226	us->srb->result = SAM_STAT_GOOD;
	227	}
	228	else
	229	{
	230	us->proto_handler(us->srb, us);
	231	}
	232
	233	/* lock access to the state */
	234	scsi_lock(host);
	235
	236	/* indicate that the command is done */
	237	if (us->srb->result != DID_ABORT << 16)
	238	{
	239	us->srb->scsi_done(us->srb);
	240	}
	241	else
	242	{
	243	SkipForAbort:
871f8477	244	pr_info("scsi command aborted\n");
126bb03b AC	245	}
	246
	247	if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags))
	248	{
	249	complete(&(us->notify));
	250
	251	/* Allow USB transfers to resume */
	252	clear_bit(US_FLIDX_ABORTING, &us->dflags);
	253	clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
	254	}
	255
	256	/* finished working on this command */
	257	us->srb = NULL;
	258	scsi_unlock(host);
	259
	260	/* unlock the device pointers */
	261	mutex_unlock(&us->dev_mutex);
	262	} /* for (;;) */
	263
	264	/* Wait until we are told to stop */
	265	for (;;)
	266	{
	267	set_current_state(TASK_INTERRUPTIBLE);
	268	if (kthread_should_stop())
	269	break;
	270	schedule();
	271	}
	272	__set_current_state(TASK_RUNNING);
	273	return 0;
	274	}
	275
	276	//----- associate_dev() ---------------------
	277	static int associate_dev(struct us_data us, struct usb_interface intf)
	278	{
871f8477	279	pr_info("usb --- associate_dev\n");
126bb03b AC	280
	281	/* Fill in the device-related fields */
	282	us->pusb_dev = interface_to_usbdev(intf);
	283	us->pusb_intf = intf;
	284	us->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
	285
	286	/* Store our private data in the interface */
	287	usb_set_intfdata(intf, us);
	288
	289	/* Allocate the device-related DMA-mapped buffers */
	290	us->cr = usb_alloc_coherent(us->pusb_dev, sizeof(*us->cr), GFP_KERNEL, &us->cr_dma);
	291	if (!us->cr)
	292	{
871f8477	293	pr_info("usb_ctrlrequest allocation failed\n");
126bb03b AC	294	return -ENOMEM;
	295	}
	296
	297	us->iobuf = usb_alloc_coherent(us->pusb_dev, US_IOBUF_SIZE, GFP_KERNEL, &us->iobuf_dma);
	298	if (!us->iobuf)
	299	{
871f8477	300	pr_info("I/O buffer allocation failed\n");
126bb03b AC	301	return -ENOMEM;
	302	}
	303
	304	us->sensebuf = kmalloc(US_SENSE_SIZE, GFP_KERNEL);
	305	if (!us->sensebuf)
	306	{
871f8477	307	pr_info("Sense buffer allocation failed\n");
126bb03b AC	308	return -ENOMEM;
	309	}
	310	return 0;
	311	}
	312
	313	//----- get_device_info() ---------------------
	314	static int get_device_info(struct us_data us, const struct usb_device_id id)
	315	{
	316	struct usb_device *dev = us->pusb_dev;
	317	struct usb_interface_descriptor *idesc = &us->pusb_intf->cur_altsetting->desc;
	318
871f8477	319	pr_info("usb --- get_device_info\n");
126bb03b AC	320
	321	us->subclass = idesc->bInterfaceSubClass;
	322	us->protocol = idesc->bInterfaceProtocol;
	323	us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
	324	us->Power_IsResum = false;
	325
	326	if (us->fflags & US_FL_IGNORE_DEVICE)
	327	{
871f8477	328	pr_info("device ignored\n");
126bb03b AC	329	return -ENODEV;
	330	}
	331
	332	if (dev->speed != USB_SPEED_HIGH)
	333	us->fflags &= ~US_FL_GO_SLOW;
	334
	335	return 0;
	336	}
	337
	338	//----- get_transport() ---------------------
	339	static int get_transport(struct us_data *us)
	340	{
871f8477	341	pr_info("usb --- get_transport\n");
126bb03b	342	switch (us->protocol) {
bceadddd	343	case USB_PR_BULK:
126bb03b AC	344	us->transport_name = "Bulk";
	345	us->transport = usb_stor_Bulk_transport;
	346	us->transport_reset = usb_stor_Bulk_reset;
	347	break;
	348
	349	default:
	350	return -EIO;
	351	}
871f8477	352	/* pr_info("Transport: %s\n", us->transport_name); */
126bb03b AC	353
	354	/* fix for single-lun devices */
	355	if (us->fflags & US_FL_SINGLE_LUN)
	356	us->max_lun = 0;
	357	return 0;
	358	}
	359
	360	//----- get_protocol() ---------------------
	361	static int get_protocol(struct us_data *us)
	362	{
871f8477 CYC	363	pr_info("usb --- get_protocol\n");
	364	pr_info("us->pusb_dev->descriptor.idVendor = %x\n",
	365	us->pusb_dev->descriptor.idVendor);
	366	pr_info("us->pusb_dev->descriptor.idProduct = %x\n",
	367	us->pusb_dev->descriptor.idProduct);
126bb03b	368	switch (us->subclass) {
bceadddd	369	case USB_SC_SCSI:
126bb03b AC	370	us->protocol_name = "Transparent SCSI";
	371	if( (us->pusb_dev->descriptor.idVendor == 0x0CF2) && (us->pusb_dev->descriptor.idProduct == 0x6250) )
	372	us->proto_handler = ENE_stor_invoke_transport;
	373	else
	374	us->proto_handler = usb_stor_invoke_transport;
	375	break;
	376
	377	default:
	378	return -EIO;
	379	}
871f8477	380	/* pr_info("Protocol: %s\n", us->protocol_name); */
126bb03b AC	381	return 0;
	382	}
	383
	384	//----- get_pipes() ---------------------
	385	static int get_pipes(struct us_data *us)
	386	{
	387	struct usb_host_interface *altsetting = us->pusb_intf->cur_altsetting;
	388	int i;
	389	struct usb_endpoint_descriptor *ep;
	390	struct usb_endpoint_descriptor *ep_in = NULL;
	391	struct usb_endpoint_descriptor *ep_out = NULL;
	392	struct usb_endpoint_descriptor *ep_int = NULL;
	393
871f8477	394	pr_info("usb --- get_pipes\n");
126bb03b AC	395
	396	for (i = 0; i < altsetting->desc.bNumEndpoints; i++)
	397	{
	398	ep = &altsetting->endpoint[i].desc;
	399
	400	if (usb_endpoint_xfer_bulk(ep))
	401	{
	402	if (usb_endpoint_dir_in(ep))
	403	{
	404	if (!ep_in)
	405	ep_in = ep;
	406	}
	407	else
	408	{
	409	if (!ep_out)
	410	ep_out = ep;
	411	}
	412	}
	413	else if (usb_endpoint_is_int_in(ep))
	414	{
	415	if (!ep_int)
	416	ep_int = ep;
	417	}
	418	}
	419
bceadddd	420	if (!ep_in \|\| !ep_out \|\| (us->protocol == USB_PR_CBI && !ep_int))
126bb03b	421	{
871f8477	422	pr_info("Endpoint sanity check failed! Rejecting dev.\n");
126bb03b AC	423	return -EIO;
	424	}
	425
	426	/* Calculate and store the pipe values */
	427	us->send_ctrl_pipe = usb_sndctrlpipe(us->pusb_dev, 0);
	428	us->recv_ctrl_pipe = usb_rcvctrlpipe(us->pusb_dev, 0);
	429	us->send_bulk_pipe = usb_sndbulkpipe(us->pusb_dev, ep_out->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
	430	us->recv_bulk_pipe = usb_rcvbulkpipe(us->pusb_dev, ep_in->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
	431	if (ep_int)
	432	{
	433	us->recv_intr_pipe = usb_rcvintpipe(us->pusb_dev, ep_int->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
	434	us->ep_bInterval = ep_int->bInterval;
	435	}
	436	return 0;
	437	}
	438
	439	//----- usb_stor_acquire_resources() ---------------------
	440	static int usb_stor_acquire_resources(struct us_data *us)
	441	{
	442	struct task_struct *th;
	443
871f8477	444	pr_info("usb --- usb_stor_acquire_resources\n");
126bb03b AC	445	us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
	446	if (!us->current_urb)
	447	{
871f8477	448	pr_info("URB allocation failed\n");
126bb03b AC	449	return -ENOMEM;
	450	}
	451
	452	/* Start up our control thread */
	453	th = kthread_run(usb_stor_control_thread, us, "eucr-storage");
	454	if (IS_ERR(th))
	455	{
871f8477	456	pr_info("Unable to start control thread\n");
126bb03b AC	457	return PTR_ERR(th);
	458	}
	459	us->ctl_thread = th;
	460
	461	return 0;
	462	}
	463
	464	//----- usb_stor_release_resources() ---------------------
	465	static void usb_stor_release_resources(struct us_data *us)
	466	{
871f8477	467	pr_info("usb --- usb_stor_release_resources\n");
126bb03b AC	468
	469	SM_FreeMem();
	470
	471	complete(&us->cmnd_ready);
	472	if (us->ctl_thread)
	473	kthread_stop(us->ctl_thread);
	474
	475	/* Call the destructor routine, if it exists */
	476	if (us->extra_destructor)
	477	{
871f8477	478	pr_info("-- calling extra_destructor()\n");
126bb03b AC	479	us->extra_destructor(us->extra);
	480	}
	481
	482	/* Free the extra data and the URB */
	483	kfree(us->extra);
	484	usb_free_urb(us->current_urb);
	485	}
	486
	487	//----- dissociate_dev() ---------------------
	488	static void dissociate_dev(struct us_data *us)
	489	{
871f8477	490	pr_info("usb --- dissociate_dev\n");
126bb03b AC	491
	492	kfree(us->sensebuf);
	493
	494	/* Free the device-related DMA-mapped buffers */
	495	if (us->cr)
	496	usb_free_coherent(us->pusb_dev, sizeof(*us->cr), us->cr, us->cr_dma);
	497	if (us->iobuf)
	498	usb_free_coherent(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma);
	499
	500	/* Remove our private data from the interface */
	501	usb_set_intfdata(us->pusb_intf, NULL);
	502	}
	503
	504	//----- quiesce_and_remove_host() ---------------------
	505	static void quiesce_and_remove_host(struct us_data *us)
	506	{
	507	struct Scsi_Host *host = us_to_host(us);
	508
871f8477	509	pr_info("usb --- quiesce_and_remove_host\n");
126bb03b AC	510
	511	/* If the device is really gone, cut short reset delays */
	512	if (us->pusb_dev->state == USB_STATE_NOTATTACHED)
	513	set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
	514
	515	/* Prevent SCSI-scanning (if it hasn't started yet)
	516	* and wait for the SCSI-scanning thread to stop.
	517	*/
	518	set_bit(US_FLIDX_DONT_SCAN, &us->dflags);
	519	wake_up(&us->delay_wait);
	520	wait_for_completion(&us->scanning_done);
	521
	522	/* Removing the host will perform an orderly shutdown: caches
	523	* synchronized, disks spun down, etc.
	524	*/
	525	scsi_remove_host(host);
	526
	527	/* Prevent any new commands from being accepted and cut short
	528	* reset delays.
	529	*/
	530	scsi_lock(host);
	531	set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
	532	scsi_unlock(host);
	533	wake_up(&us->delay_wait);
	534	}
	535
	536	//----- release_everything() ---------------------
	537	static void release_everything(struct us_data *us)
	538	{
871f8477	539	pr_info("usb --- release_everything\n");
126bb03b AC	540
	541	usb_stor_release_resources(us);
	542	dissociate_dev(us);
	543	scsi_host_put(us_to_host(us));
	544	}
	545
	546	//----- usb_stor_scan_thread() ---------------------
	547	static int usb_stor_scan_thread(void * __us)
	548	{
	549	struct us_data us = (struct us_data )__us;
	550
871f8477 CYC	551	pr_info("usb --- usb_stor_scan_thread\n");
871f8477 CYC	552	pr_info("EUCR : device found at %d\n", us->pusb_dev->devnum);
126bb03b	553
a8718692 AC	554	set_freezable();
	555	/* Wait for the timeout to expire or for a disconnect */
	556	if (delay_use > 0) {
	557	wait_event_freezable_timeout(us->delay_wait,
	558	test_bit(US_FLIDX_DONT_SCAN, &us->dflags),
	559	delay_use * HZ);
	560	}
126bb03b AC	561
	562	/* If the device is still connected, perform the scanning */
	563	if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags))
	564	{
	565	/* For bulk-only devices, determine the max LUN value */
bceadddd	566	if (us->protocol == USB_PR_BULK && !(us->fflags & US_FL_SINGLE_LUN))
126bb03b AC	567	{
	568	mutex_lock(&us->dev_mutex);
	569	us->max_lun = usb_stor_Bulk_max_lun(us);
	570	mutex_unlock(&us->dev_mutex);
	571	}
	572	scsi_scan_host(us_to_host(us));
871f8477	573	pr_info("EUCR : device scan complete\n");
126bb03b AC	574	}
	575	complete_and_exit(&us->scanning_done, 0);
	576	}
	577
	578	//----- eucr_probe() ---------------------
	579	static int eucr_probe(struct usb_interface intf, const struct usb_device_id id)
	580	{
	581	struct Scsi_Host *host;
	582	struct us_data *us;
	583	int result;
41e568d1	584	BYTE MiscReg03 = 0;
126bb03b AC	585	struct task_struct *th;
126bb03b AC	586
871f8477	587	pr_info("usb --- eucr_probe\n");
126bb03b AC	588
	589	host = scsi_host_alloc(&usb_stor_host_template, sizeof(*us));
	590	if (!host)
	591	{
871f8477	592	pr_info("Unable to allocate the scsi host\n");
126bb03b AC	593	return -ENOMEM;
	594	}
	595
	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);
	605
	606	/* Associate the us_data structure with the USB device */
	607	result = associate_dev(us, intf);
	608	if (result)
	609	goto BadDevice;
	610
	611	/* Get Device info */
	612	result = get_device_info(us, id);
	613	if (result)
	614	goto BadDevice;
	615
	616	/* Get the transport, protocol, and pipe settings */
	617	result = get_transport(us);
	618	if (result)
	619	goto BadDevice;
	620	result = get_protocol(us);
	621	if (result)
	622	goto BadDevice;
	623	result = get_pipes(us);
	624	if (result)
	625	goto BadDevice;
	626
	627	/* Acquire all the other resources and add the host */
	628	result = usb_stor_acquire_resources(us);
	629	if (result)
	630	goto BadDevice;
	631
	632	result = scsi_add_host(host, &intf->dev);
	633	if (result)
	634	{
871f8477	635	pr_info("Unable to add the scsi host\n");
126bb03b AC	636	goto BadDevice;
	637	}
	638
	639	/* Start up the thread for delayed SCSI-device scanning */
	640	th = kthread_create(usb_stor_scan_thread, us, "eucr-stor-scan");
7d51b77a	641	if (IS_ERR(th)) {
871f8477	642	pr_info("Unable to start the device-scanning thread\n");
126bb03b AC	643	complete(&us->scanning_done);
	644	quiesce_and_remove_host(us);
	645	result = PTR_ERR(th);
	646	goto BadDevice;
	647	}
	648	wake_up_process(th);
41e568d1	649
	650	/* probe card type */
	651	result = ENE_Read_BYTE(us, REG_CARD_STATUS, &MiscReg03);
	652	if (result != USB_STOR_XFER_GOOD) {
	653	result = USB_STOR_TRANSPORT_ERROR;
	654	quiesce_and_remove_host(us);
	655	goto BadDevice;
	656	}
	657
	658	if (!(MiscReg03 & 0x02)) {
	659	result = -ENODEV;
	660	quiesce_and_remove_host(us);
871f8477	661	pr_info("keucr: The driver only supports SM/MS card.\
41e568d1	662	To use SD card, \
	663	please build driver/usb/storage/ums-eneub6250.ko\n");
	664	goto BadDevice;
	665	}
	666
126bb03b AC	667	return 0;
	668
	669	/* We come here if there are any problems */
	670	BadDevice:
871f8477	671	pr_info("usb --- eucr_probe failed\n");
126bb03b AC	672	release_everything(us);
	673	return result;
	674	}
	675
	676	//----- eucr_disconnect() ---------------------
	677	static void eucr_disconnect(struct usb_interface *intf)
	678	{
	679	struct us_data *us = usb_get_intfdata(intf);
	680
871f8477	681	pr_info("usb --- eucr_disconnect\n");
126bb03b AC	682	quiesce_and_remove_host(us);
	683	release_everything(us);
	684	}
	685
	686	/***********************************************************************
	687	* Initialization and registration
	688	***********************************************************************/
	689
	690	//----- usb_storage_driver() ---------------------
	691	static struct usb_driver usb_storage_driver = {
	692	.name = "eucr",
	693	.probe = eucr_probe,
	694	.suspend = eucr_suspend,
	695	.resume = eucr_resume,
	696	.reset_resume = eucr_reset_resume,
	697	.disconnect = eucr_disconnect,
	698	.pre_reset = eucr_pre_reset,
	699	.post_reset = eucr_post_reset,
	700	.id_table = eucr_usb_ids,
	701	.soft_unbind = 1,
	702	};
	703
	704	//----- usb_stor_init() ---------------------
	705	static int __init usb_stor_init(void)
	706	{
	707	int retval;
871f8477	708	pr_info("usb --- usb_stor_init start\n");
126bb03b AC	709
	710	retval = usb_register(&usb_storage_driver);
	711	if (retval == 0)
871f8477	712	pr_info("ENE USB Mass Storage support registered.\n");
126bb03b AC	713
	714	return retval;
	715	}
	716
	717	//----- usb_stor_exit() ---------------------
	718	static void __exit usb_stor_exit(void)
	719	{
871f8477	720	pr_info("usb --- usb_stor_exit\n");
126bb03b AC	721
	722	usb_deregister(&usb_storage_driver) ;
	723	}
	724
	725	module_init(usb_stor_init);
	726	module_exit(usb_stor_exit);