[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/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);

	if (us->suspend_resume_hook)
		(us->suspend_resume_hook)(us, US_SUSPEND);

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

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);

	if (us->suspend_resume_hook)
		(us->suspend_resume_hook)(us, US_RESUME);


	mutex_unlock(&us->dev_mutex);

	us->Power_IsResum = true;

	us->SM_Status = *(struct keucr_sm_status *)&tmp;

	return 0;
}

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");

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

	/*
	 * FIXME: Notify the subdrivers that they need to reinitialize
	 * the device
	 */

	us->Power_IsResum = true;

	us->SM_Status = *(struct keucr_sm_status *)&tmp;

	return 0;
}

#else

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

#endif

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;
}

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;
}

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);
}

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);
			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;
}

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)
		return -ENOMEM;

	return 0;
}

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 = 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;
}

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;
	}

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

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;
	}
	return 0;
}

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;
}

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;
}

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);
}

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

	kfree(us->sensebuf);

	/* Free the device-related DMA-mapped buffers */
	usb_free_coherent(us->pusb_dev, sizeof(*us->cr), us->cr, us->cr_dma);
	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);
}

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);
}

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));
}

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);
}

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;
}

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 */
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,
};

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