[mirror_ubuntu-zesty-kernel.git] / drivers / staging / keucr / init.c

#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/slab.h>

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

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

BYTE IsSSFDCCompliance;
BYTE IsXDCompliance;

/*
 * ENE_InitMedia():
 */
int ENE_InitMedia(struct us_data *us)
{
	int	result;
	BYTE	MiscReg03 = 0;

	printk(KERN_INFO "--- Init Media ---\n");
	result = ENE_Read_BYTE(us, REG_CARD_STATUS, &MiscReg03);
	if (result != USB_STOR_XFER_GOOD) {
		printk(KERN_ERR "Read register fail !!\n");
		return USB_STOR_TRANSPORT_ERROR;
	}
	printk(KERN_INFO "MiscReg03 = %x\n", MiscReg03);

	if (MiscReg03 & 0x02) {
		if (!us->SM_Status.Ready && !us->MS_Status.Ready) {
			result = ENE_SMInit(us);
			if (result != USB_STOR_XFER_GOOD) {
				result = ENE_MSInit(us);
				if (result != USB_STOR_XFER_GOOD)
					return USB_STOR_TRANSPORT_ERROR;
			}
		}

	}
	return result;
}

/*
 * ENE_Read_BYTE() :
 */
int ENE_Read_BYTE(struct us_data *us, WORD index, void *buf)
{
	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
	int result;

	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	bcb->DataTransferLength	= 0x01;
	bcb->Flags			= 0x80;
	bcb->CDB[0]			= 0xED;
	bcb->CDB[2]			= (BYTE)(index>>8);
	bcb->CDB[3]			= (BYTE)index;

	result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
	return result;
}

/*
 * ENE_MSInit():
 */
int ENE_MSInit(struct us_data *us)
{
	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
	int	result;
	BYTE	buf[0x200];
	WORD	MSP_BlockSize, MSP_UserAreaBlocks;

	printk(KERN_INFO "transport --- ENE_MSInit\n");
	result = ENE_LoadBinCode(us, MS_INIT_PATTERN);
	if (result != USB_STOR_XFER_GOOD) {
		printk(KERN_ERR "Load MS Init Code Fail !!\n");
		return USB_STOR_TRANSPORT_ERROR;
	}

	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	bcb->DataTransferLength	= 0x200;
	bcb->Flags			= 0x80;
	bcb->CDB[0]			= 0xF1;
	bcb->CDB[1]			= 0x01;

	result = ENE_SendScsiCmd(us, FDIR_READ, &buf, 0);
	if (result != USB_STOR_XFER_GOOD) {
		printk(KERN_ERR "Execution MS Init Code Fail !!\n");
		return USB_STOR_TRANSPORT_ERROR;
	}

	us->MS_Status = *(PMS_STATUS)&buf[0];

	if (us->MS_Status.Insert && us->MS_Status.Ready) {
		printk(KERN_INFO "Insert     = %x\n", us->MS_Status.Insert);
		printk(KERN_INFO "Ready      = %x\n", us->MS_Status.Ready);
		printk(KERN_INFO "IsMSPro    = %x\n", us->MS_Status.IsMSPro);
		printk(KERN_INFO "IsMSPHG    = %x\n", us->MS_Status.IsMSPHG);
		printk(KERN_INFO "WtP        = %x\n", us->MS_Status.WtP);
		if (us->MS_Status.IsMSPro) {
			MSP_BlockSize      = (buf[6] << 8) | buf[7];
			MSP_UserAreaBlocks = (buf[10] << 8) | buf[11];
			us->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
		} else {
			MS_CardInit(us);
		}
		printk(KERN_INFO "MS Init Code OK !!\n");
	} else {
		printk(KERN_INFO "MS Card Not Ready --- %x\n", buf[0]);
		return USB_STOR_TRANSPORT_ERROR;
	}

	return USB_STOR_TRANSPORT_GOOD;
}

/*
 *ENE_SMInit()
 */
int ENE_SMInit(struct us_data *us)
{
	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
	int	result;
	BYTE	buf[0x200];

	printk(KERN_INFO "transport --- ENE_SMInit\n");

	result = ENE_LoadBinCode(us, SM_INIT_PATTERN);
	if (result != USB_STOR_XFER_GOOD) {
		printk(KERN_INFO "Load SM Init Code Fail !!\n");
		return USB_STOR_TRANSPORT_ERROR;
	}

	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	bcb->DataTransferLength	= 0x200;
	bcb->Flags			= 0x80;
	bcb->CDB[0]			= 0xF1;
	bcb->CDB[1]			= 0x01;

	result = ENE_SendScsiCmd(us, FDIR_READ, &buf, 0);
	if (result != USB_STOR_XFER_GOOD) {
		printk(KERN_ERR
		       "Execution SM Init Code Fail !! result = %x\n", result);
		return USB_STOR_TRANSPORT_ERROR;
	}

	us->SM_Status = *(PSM_STATUS)&buf[0];

	us->SM_DeviceID = buf[1];
	us->SM_CardID   = buf[2];

	if (us->SM_Status.Insert && us->SM_Status.Ready) {
		printk(KERN_INFO "Insert     = %x\n", us->SM_Status.Insert);
		printk(KERN_INFO "Ready      = %x\n", us->SM_Status.Ready);
		printk(KERN_INFO "WtP        = %x\n", us->SM_Status.WtP);
		printk(KERN_INFO "DeviceID   = %x\n", us->SM_DeviceID);
		printk(KERN_INFO "CardID     = %x\n", us->SM_CardID);
		MediaChange = 1;
		Check_D_MediaFmt(us);
	} else {
		printk(KERN_ERR "SM Card Not Ready --- %x\n", buf[0]);
		return USB_STOR_TRANSPORT_ERROR;
	}

	return USB_STOR_TRANSPORT_GOOD;
}

/*
 * ENE_LoadBinCode()
 */
int ENE_LoadBinCode(struct us_data *us, BYTE flag)
{
	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
	int result;
	/* void *buf; */
	PBYTE buf;

	/* printk(KERN_INFO "transport --- ENE_LoadBinCode\n"); */
	if (us->BIN_FLAG == flag)
		return USB_STOR_TRANSPORT_GOOD;

	buf = kmalloc(0x800, GFP_KERNEL);
	if (buf == NULL)
		return USB_STOR_TRANSPORT_ERROR;
	switch (flag) {
	/* For MS */
	case MS_INIT_PATTERN:
		printk(KERN_INFO "MS_INIT_PATTERN\n");
		memcpy(buf, MS_Init, 0x800);
		break;
	case MSP_RW_PATTERN:
		printk(KERN_INFO "MSP_RW_PATTERN\n");
		memcpy(buf, MSP_Rdwr, 0x800);
		break;
	case MS_RW_PATTERN:
		printk(KERN_INFO "MS_RW_PATTERN\n");
		memcpy(buf, MS_Rdwr, 0x800);
		break;
	/* For SS */
	case SM_INIT_PATTERN:
		printk(KERN_INFO "SM_INIT_PATTERN\n");
		memcpy(buf, SM_Init, 0x800);
		break;
	case SM_RW_PATTERN:
		printk(KERN_INFO "SM_RW_PATTERN\n");
		memcpy(buf, SM_Rdwr, 0x800);
		break;
	}

	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	bcb->DataTransferLength = 0x800;
	bcb->Flags = 0x00;
	bcb->CDB[0] = 0xEF;

	result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);

	kfree(buf);
	us->BIN_FLAG = flag;
	return result;
}

/*
 * ENE_SendScsiCmd():
 */
int ENE_SendScsiCmd(struct us_data *us, BYTE fDir, void *buf, int use_sg)
{
	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
	struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;

	int result;
	unsigned int transfer_length = bcb->DataTransferLength,
		     cswlen = 0, partial = 0;
	unsigned int residue;

	/* printk(KERN_INFO "transport --- ENE_SendScsiCmd\n"); */
	/* send cmd to out endpoint */
	result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
					    bcb, US_BULK_CB_WRAP_LEN, NULL);
	if (result != USB_STOR_XFER_GOOD) {
		printk(KERN_ERR "send cmd to out endpoint fail ---\n");
		return USB_STOR_TRANSPORT_ERROR;
	}

	if (buf) {
		unsigned int pipe = fDir;

		if (fDir == FDIR_READ)
			pipe = us->recv_bulk_pipe;
		else
			pipe = us->send_bulk_pipe;

		/* Bulk */
		if (use_sg)
			result = usb_stor_bulk_srb(us, pipe, us->srb);
		else
			result = usb_stor_bulk_transfer_sg(us, pipe, buf,
						transfer_length, 0, &partial);
		if (result != USB_STOR_XFER_GOOD) {
			printk(KERN_ERR "data transfer fail ---\n");
			return USB_STOR_TRANSPORT_ERROR;
		}
	}

	/* Get CSW for device status */
	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
						US_BULK_CS_WRAP_LEN, &cswlen);

	if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
		printk(KERN_WARNING "Received 0-length CSW; retrying...\n");
		result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
					bcs, US_BULK_CS_WRAP_LEN, &cswlen);
	}

	if (result == USB_STOR_XFER_STALLED) {
		/* get the status again */
		printk(KERN_WARNING "Attempting to get CSW (2nd try)...\n");
		result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
						bcs, US_BULK_CS_WRAP_LEN, NULL);
	}

	if (result != USB_STOR_XFER_GOOD)
		return USB_STOR_TRANSPORT_ERROR;

	/* check bulk status */
	residue = le32_to_cpu(bcs->Residue);

	/*
	 * try to compute the actual residue, based on how much data
	 * was really transferred and what the device tells us
	 */
	if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
		residue = min(residue, transfer_length);
		if (us->srb)
			scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
					(int) residue));
	}

	if (bcs->Status != US_BULK_STAT_OK)
		return USB_STOR_TRANSPORT_ERROR;

	return USB_STOR_TRANSPORT_GOOD;
}

/*
 * ENE_Read_Data()
 */
int ENE_Read_Data(struct us_data *us, void *buf, unsigned int length)
{
	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
	struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
	int result;

	/* printk(KERN_INFO "transport --- ENE_Read_Data\n"); */
	/* set up the command wrapper */
	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	bcb->DataTransferLength = length;
	bcb->Flags = 0x80;
	bcb->CDB[0] = 0xED;
	bcb->CDB[2] = 0xFF;
	bcb->CDB[3] = 0x81;

	/* send cmd to out endpoint */
	result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
						US_BULK_CB_WRAP_LEN, NULL);
	if (result != USB_STOR_XFER_GOOD)
		return USB_STOR_TRANSPORT_ERROR;

	/* R/W data */
	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
						buf, length, NULL);
	if (result != USB_STOR_XFER_GOOD)
		return USB_STOR_TRANSPORT_ERROR;

	/* Get CSW for device status */
	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
						US_BULK_CS_WRAP_LEN, NULL);
	if (result != USB_STOR_XFER_GOOD)
		return USB_STOR_TRANSPORT_ERROR;
	if (bcs->Status != US_BULK_STAT_OK)
		return USB_STOR_TRANSPORT_ERROR;

	return USB_STOR_TRANSPORT_GOOD;
}

/*
 * ENE_Write_Data():
 */
int ENE_Write_Data(struct us_data *us, void *buf, unsigned int length)
{
	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
	struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
	int result;

	/* printk("transport --- ENE_Write_Data\n"); */
	/* set up the command wrapper */
	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	bcb->DataTransferLength = length;
	bcb->Flags = 0x00;
	bcb->CDB[0] = 0xEE;
	bcb->CDB[2] = 0xFF;
	bcb->CDB[3] = 0x81;

	/* send cmd to out endpoint */
	result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
						US_BULK_CB_WRAP_LEN, NULL);
	if (result != USB_STOR_XFER_GOOD)
		return USB_STOR_TRANSPORT_ERROR;

	/* R/W data */
	result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
						buf, length, NULL);
	if (result != USB_STOR_XFER_GOOD)
		return USB_STOR_TRANSPORT_ERROR;

	/* Get CSW for device status */
	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
						US_BULK_CS_WRAP_LEN, NULL);
	if (result != USB_STOR_XFER_GOOD)
		return USB_STOR_TRANSPORT_ERROR;
	if (bcs->Status != US_BULK_STAT_OK)
		return USB_STOR_TRANSPORT_ERROR;

	return USB_STOR_TRANSPORT_GOOD;
}

/*
 * usb_stor_print_cmd():
 */
void usb_stor_print_cmd(struct scsi_cmnd *srb)
{
	PBYTE	Cdb = srb->cmnd;
	DWORD	cmd = Cdb[0];
	DWORD	bn  =	((Cdb[2] << 24) & 0xff000000) |
			((Cdb[3] << 16) & 0x00ff0000) |
			((Cdb[4] << 8) & 0x0000ff00) |
			((Cdb[5] << 0) & 0x000000ff);
	WORD	blen = ((Cdb[7] << 8) & 0xff00) | ((Cdb[8] << 0) & 0x00ff);

	switch (cmd) {
	case TEST_UNIT_READY:
		/* printk(KERN_INFO
			 "scsi cmd %X --- SCSIOP_TEST_UNIT_READY\n", cmd); */
		break;
	case INQUIRY:
		printk(KERN_INFO "scsi cmd %X --- SCSIOP_INQUIRY\n", cmd);
		break;
	case MODE_SENSE:
		printk(KERN_INFO "scsi cmd %X --- SCSIOP_MODE_SENSE\n", cmd);
		break;
	case START_STOP:
		printk(KERN_INFO "scsi cmd %X --- SCSIOP_START_STOP\n", cmd);
		break;
	case READ_CAPACITY:
		printk(KERN_INFO "scsi cmd %X --- SCSIOP_READ_CAPACITY\n", cmd);
		break;
	case READ_10:
		/*  printk(KERN_INFO
			   "scsi cmd %X --- SCSIOP_READ,bn = %X, blen = %X\n"
			   ,cmd, bn, blen); */
		break;
	case WRITE_10:
		/* printk(KERN_INFO
			  "scsi cmd %X --- SCSIOP_WRITE,
			  bn = %X, blen = %X\n" , cmd, bn, blen); */
		break;
	case ALLOW_MEDIUM_REMOVAL:
		printk(KERN_INFO
			"scsi cmd %X --- SCSIOP_ALLOW_MEDIUM_REMOVAL\n", cmd);
		break;
	default:
		printk(KERN_INFO "scsi cmd %X --- Other cmd\n", cmd);
		break;
	}
	bn = 0;
	blen = 0;
}
Commit	Line	Data
126bb03b AC	1	#include <linux/sched.h>
	2	#include <linux/errno.h>
	3	#include <linux/slab.h>
	4
	5	#include <scsi/scsi.h>
	6	#include <scsi/scsi_eh.h>
	7	#include <scsi/scsi_device.h>
	8
	9	#include "usb.h"
	10	#include "scsiglue.h"
	11	#include "transport.h"
	12	#include "init.h"
	13
e93192ac AC	14	BYTE IsSSFDCCompliance;
e93192ac AC	15	BYTE IsXDCompliance;
126bb03b	16
e93192ac AC	17	/*
	18	* ENE_InitMedia():
	19	*/
126bb03b AC	20	int ENE_InitMedia(struct us_data *us)
	21	{
	22	int result;
	23	BYTE MiscReg03 = 0;
	24
e93192ac	25	printk(KERN_INFO "--- Init Media ---\n");
126bb03b	26	result = ENE_Read_BYTE(us, REG_CARD_STATUS, &MiscReg03);
e93192ac AC	27	if (result != USB_STOR_XFER_GOOD) {
e93192ac AC	28	printk(KERN_ERR "Read register fail !!\n");
126bb03b AC	29	return USB_STOR_TRANSPORT_ERROR;
126bb03b AC	30	}
e93192ac	31	printk(KERN_INFO "MiscReg03 = %x\n", MiscReg03);
126bb03b	32
e93192ac AC	33	if (MiscReg03 & 0x02) {
e93192ac AC	34	if (!us->SM_Status.Ready && !us->MS_Status.Ready) {
126bb03b	35	result = ENE_SMInit(us);
e93192ac	36	if (result != USB_STOR_XFER_GOOD) {
126bb03b AC	37	result = ENE_MSInit(us);
	38	if (result != USB_STOR_XFER_GOOD)
	39	return USB_STOR_TRANSPORT_ERROR;
	40	}
	41	}
	42
	43	}
	44	return result;
	45	}
	46
e93192ac AC	47	/*
	48	* ENE_Read_BYTE() :
	49	*/
126bb03b AC	50	int ENE_Read_BYTE(struct us_data us, WORD index, void buf)
	51	{
	52	struct bulk_cb_wrap bcb = (struct bulk_cb_wrap ) us->iobuf;
	53	int result;
	54
307ae1d3	55	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b AC	56	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	57	bcb->DataTransferLength = 0x01;
	58	bcb->Flags = 0x80;
	59	bcb->CDB[0] = 0xED;
	60	bcb->CDB[2] = (BYTE)(index>>8);
	61	bcb->CDB[3] = (BYTE)index;
	62
	63	result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
	64	return result;
	65	}
	66
e93192ac AC	67	/*
	68	* ENE_MSInit():
	69	*/
126bb03b AC	70	int ENE_MSInit(struct us_data *us)
	71	{
	72	struct bulk_cb_wrap bcb = (struct bulk_cb_wrap ) us->iobuf;
	73	int result;
	74	BYTE buf[0x200];
	75	WORD MSP_BlockSize, MSP_UserAreaBlocks;
126bb03b	76
e93192ac	77	printk(KERN_INFO "transport --- ENE_MSInit\n");
126bb03b	78	result = ENE_LoadBinCode(us, MS_INIT_PATTERN);
e93192ac AC	79	if (result != USB_STOR_XFER_GOOD) {
e93192ac AC	80	printk(KERN_ERR "Load MS Init Code Fail !!\n");
126bb03b AC	81	return USB_STOR_TRANSPORT_ERROR;
	82	}
	83
307ae1d3	84	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b AC	85	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	86	bcb->DataTransferLength = 0x200;
	87	bcb->Flags = 0x80;
	88	bcb->CDB[0] = 0xF1;
	89	bcb->CDB[1] = 0x01;
	90
	91	result = ENE_SendScsiCmd(us, FDIR_READ, &buf, 0);
e93192ac	92	if (result != USB_STOR_XFER_GOOD) {
25985edc	93	printk(KERN_ERR "Execution MS Init Code Fail !!\n");
126bb03b AC	94	return USB_STOR_TRANSPORT_ERROR;
	95	}
	96
	97	us->MS_Status = *(PMS_STATUS)&buf[0];
	98
e93192ac AC	99	if (us->MS_Status.Insert && us->MS_Status.Ready) {
	100	printk(KERN_INFO "Insert = %x\n", us->MS_Status.Insert);
	101	printk(KERN_INFO "Ready = %x\n", us->MS_Status.Ready);
	102	printk(KERN_INFO "IsMSPro = %x\n", us->MS_Status.IsMSPro);
	103	printk(KERN_INFO "IsMSPHG = %x\n", us->MS_Status.IsMSPHG);
	104	printk(KERN_INFO "WtP = %x\n", us->MS_Status.WtP);
	105	if (us->MS_Status.IsMSPro) {
	106	MSP_BlockSize = (buf[6] << 8) \| buf[7];
	107	MSP_UserAreaBlocks = (buf[10] << 8) \| buf[11];
126bb03b	108	us->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
e93192ac	109	} else {
126bb03b	110	MS_CardInit(us);
e93192ac AC	111	}
	112	printk(KERN_INFO "MS Init Code OK !!\n");
	113	} else {
	114	printk(KERN_INFO "MS Card Not Ready --- %x\n", buf[0]);
126bb03b AC	115	return USB_STOR_TRANSPORT_ERROR;
	116	}
	117
	118	return USB_STOR_TRANSPORT_GOOD;
	119	}
	120
e93192ac AC	121	/*
	122	*ENE_SMInit()
	123	*/
126bb03b AC	124	int ENE_SMInit(struct us_data *us)
	125	{
	126	struct bulk_cb_wrap bcb = (struct bulk_cb_wrap ) us->iobuf;
	127	int result;
	128	BYTE buf[0x200];
	129
e93192ac	130	printk(KERN_INFO "transport --- ENE_SMInit\n");
126bb03b AC	131
126bb03b AC	132	result = ENE_LoadBinCode(us, SM_INIT_PATTERN);
e93192ac AC	133	if (result != USB_STOR_XFER_GOOD) {
e93192ac AC	134	printk(KERN_INFO "Load SM Init Code Fail !!\n");
126bb03b AC	135	return USB_STOR_TRANSPORT_ERROR;
	136	}
	137
307ae1d3	138	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b AC	139	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	140	bcb->DataTransferLength = 0x200;
	141	bcb->Flags = 0x80;
	142	bcb->CDB[0] = 0xF1;
	143	bcb->CDB[1] = 0x01;
	144
	145	result = ENE_SendScsiCmd(us, FDIR_READ, &buf, 0);
e93192ac AC	146	if (result != USB_STOR_XFER_GOOD) {
e93192ac AC	147	printk(KERN_ERR
25985edc	148	"Execution SM Init Code Fail !! result = %x\n", result);
126bb03b AC	149	return USB_STOR_TRANSPORT_ERROR;
	150	}
	151
	152	us->SM_Status = *(PSM_STATUS)&buf[0];
	153
	154	us->SM_DeviceID = buf[1];
	155	us->SM_CardID = buf[2];
	156
e93192ac AC	157	if (us->SM_Status.Insert && us->SM_Status.Ready) {
	158	printk(KERN_INFO "Insert = %x\n", us->SM_Status.Insert);
	159	printk(KERN_INFO "Ready = %x\n", us->SM_Status.Ready);
	160	printk(KERN_INFO "WtP = %x\n", us->SM_Status.WtP);
	161	printk(KERN_INFO "DeviceID = %x\n", us->SM_DeviceID);
	162	printk(KERN_INFO "CardID = %x\n", us->SM_CardID);
126bb03b AC	163	MediaChange = 1;
126bb03b AC	164	Check_D_MediaFmt(us);
e93192ac AC	165	} else {
e93192ac AC	166	printk(KERN_ERR "SM Card Not Ready --- %x\n", buf[0]);
126bb03b AC	167	return USB_STOR_TRANSPORT_ERROR;
	168	}
	169
	170	return USB_STOR_TRANSPORT_GOOD;
	171	}
	172
e93192ac AC	173	/*
	174	* ENE_LoadBinCode()
	175	*/
126bb03b AC	176	int ENE_LoadBinCode(struct us_data *us, BYTE flag)
	177	{
	178	struct bulk_cb_wrap bcb = (struct bulk_cb_wrap ) us->iobuf;
	179	int result;
e93192ac	180	/* void buf; /
126bb03b AC	181	PBYTE buf;
126bb03b AC	182
e93192ac	183	/* printk(KERN_INFO "transport --- ENE_LoadBinCode\n"); */
126bb03b AC	184	if (us->BIN_FLAG == flag)
	185	return USB_STOR_TRANSPORT_GOOD;
	186
	187	buf = kmalloc(0x800, GFP_KERNEL);
b1f5f54e VK	188	if (buf == NULL)
b1f5f54e VK	189	return USB_STOR_TRANSPORT_ERROR;
e93192ac	190	switch (flag) {
e93192ac AC	191	/* For MS */
	192	case MS_INIT_PATTERN:
	193	printk(KERN_INFO "MS_INIT_PATTERN\n");
	194	memcpy(buf, MS_Init, 0x800);
126bb03b	195	break;
e93192ac AC	196	case MSP_RW_PATTERN:
	197	printk(KERN_INFO "MSP_RW_PATTERN\n");
	198	memcpy(buf, MSP_Rdwr, 0x800);
126bb03b	199	break;
e93192ac AC	200	case MS_RW_PATTERN:
	201	printk(KERN_INFO "MS_RW_PATTERN\n");
	202	memcpy(buf, MS_Rdwr, 0x800);
126bb03b	203	break;
e93192ac AC	204	/* For SS */
	205	case SM_INIT_PATTERN:
	206	printk(KERN_INFO "SM_INIT_PATTERN\n");
	207	memcpy(buf, SM_Init, 0x800);
126bb03b	208	break;
e93192ac AC	209	case SM_RW_PATTERN:
	210	printk(KERN_INFO "SM_RW_PATTERN\n");
	211	memcpy(buf, SM_Rdwr, 0x800);
126bb03b AC	212	break;
	213	}
	214
307ae1d3	215	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b AC	216	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
126bb03b AC	217	bcb->DataTransferLength = 0x800;
e93192ac	218	bcb->Flags = 0x00;
126bb03b AC	219	bcb->CDB[0] = 0xEF;
	220
	221	result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
	222
	223	kfree(buf);
	224	us->BIN_FLAG = flag;
	225	return result;
	226	}
	227
e93192ac AC	228	/*
	229	* ENE_SendScsiCmd():
	230	*/
126bb03b AC	231	int ENE_SendScsiCmd(struct us_data us, BYTE fDir, void buf, int use_sg)
	232	{
	233	struct bulk_cb_wrap bcb = (struct bulk_cb_wrap ) us->iobuf;
	234	struct bulk_cs_wrap bcs = (struct bulk_cs_wrap ) us->iobuf;
	235
	236	int result;
e93192ac AC	237	unsigned int transfer_length = bcb->DataTransferLength,
e93192ac AC	238	cswlen = 0, partial = 0;
126bb03b AC	239	unsigned int residue;
126bb03b AC	240
e93192ac AC	241	/* printk(KERN_INFO "transport --- ENE_SendScsiCmd\n"); */
	242	/* send cmd to out endpoint */
	243	result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
	244	bcb, US_BULK_CB_WRAP_LEN, NULL);
	245	if (result != USB_STOR_XFER_GOOD) {
	246	printk(KERN_ERR "send cmd to out endpoint fail ---\n");
126bb03b AC	247	return USB_STOR_TRANSPORT_ERROR;
	248	}
	249
e93192ac	250	if (buf) {
6efe04ee AC	251	unsigned int pipe = fDir;
	252
	253	if (fDir == FDIR_READ)
	254	pipe = us->recv_bulk_pipe;
	255	else
	256	pipe = us->send_bulk_pipe;
	257
e93192ac	258	/* Bulk */
126bb03b AC	259	if (use_sg)
	260	result = usb_stor_bulk_srb(us, pipe, us->srb);
	261	else
e93192ac AC	262	result = usb_stor_bulk_transfer_sg(us, pipe, buf,
	263	transfer_length, 0, &partial);
	264	if (result != USB_STOR_XFER_GOOD) {
	265	printk(KERN_ERR "data transfer fail ---\n");
126bb03b AC	266	return USB_STOR_TRANSPORT_ERROR;
	267	}
	268	}
	269
e93192ac AC	270	/* Get CSW for device status */
	271	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
	272	US_BULK_CS_WRAP_LEN, &cswlen);
126bb03b	273
e93192ac AC	274	if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
	275	printk(KERN_WARNING "Received 0-length CSW; retrying...\n");
	276	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
	277	bcs, US_BULK_CS_WRAP_LEN, &cswlen);
126bb03b AC	278	}
126bb03b AC	279
e93192ac	280	if (result == USB_STOR_XFER_STALLED) {
126bb03b	281	/* get the status again */
e93192ac AC	282	printk(KERN_WARNING "Attempting to get CSW (2nd try)...\n");
	283	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
	284	bcs, US_BULK_CS_WRAP_LEN, NULL);
126bb03b AC	285	}
	286
	287	if (result != USB_STOR_XFER_GOOD)
	288	return USB_STOR_TRANSPORT_ERROR;
	289
	290	/* check bulk status */
	291	residue = le32_to_cpu(bcs->Residue);
	292
e93192ac AC	293	/*
	294	* try to compute the actual residue, based on how much data
	295	* was really transferred and what the device tells us
	296	*/
	297	if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
126bb03b	298	residue = min(residue, transfer_length);
41e568d1	299	if (us->srb)
	300	scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
	301	(int) residue));
126bb03b AC	302	}
	303
	304	if (bcs->Status != US_BULK_STAT_OK)
	305	return USB_STOR_TRANSPORT_ERROR;
	306
	307	return USB_STOR_TRANSPORT_GOOD;
	308	}
	309
e93192ac AC	310	/*
	311	* ENE_Read_Data()
	312	*/
126bb03b AC	313	int ENE_Read_Data(struct us_data us, void buf, unsigned int length)
	314	{
	315	struct bulk_cb_wrap bcb = (struct bulk_cb_wrap ) us->iobuf;
	316	struct bulk_cs_wrap bcs = (struct bulk_cs_wrap ) us->iobuf;
	317	int result;
	318
e93192ac AC	319	/* printk(KERN_INFO "transport --- ENE_Read_Data\n"); */
e93192ac AC	320	/* set up the command wrapper */
307ae1d3	321	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b AC	322	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
126bb03b AC	323	bcb->DataTransferLength = length;
e93192ac	324	bcb->Flags = 0x80;
126bb03b AC	325	bcb->CDB[0] = 0xED;
	326	bcb->CDB[2] = 0xFF;
	327	bcb->CDB[3] = 0x81;
	328
e93192ac AC	329	/* send cmd to out endpoint */
	330	result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
	331	US_BULK_CB_WRAP_LEN, NULL);
126bb03b AC	332	if (result != USB_STOR_XFER_GOOD)
	333	return USB_STOR_TRANSPORT_ERROR;
	334
e93192ac AC	335	/* R/W data */
	336	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
	337	buf, length, NULL);
126bb03b AC	338	if (result != USB_STOR_XFER_GOOD)
	339	return USB_STOR_TRANSPORT_ERROR;
	340
e93192ac AC	341	/* Get CSW for device status */
	342	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
	343	US_BULK_CS_WRAP_LEN, NULL);
126bb03b AC	344	if (result != USB_STOR_XFER_GOOD)
	345	return USB_STOR_TRANSPORT_ERROR;
	346	if (bcs->Status != US_BULK_STAT_OK)
	347	return USB_STOR_TRANSPORT_ERROR;
	348
	349	return USB_STOR_TRANSPORT_GOOD;
	350	}
	351
e93192ac AC	352	/*
	353	* ENE_Write_Data():
	354	*/
126bb03b AC	355	int ENE_Write_Data(struct us_data us, void buf, unsigned int length)
	356	{
	357	struct bulk_cb_wrap bcb = (struct bulk_cb_wrap ) us->iobuf;
	358	struct bulk_cs_wrap bcs = (struct bulk_cs_wrap ) us->iobuf;
	359	int result;
	360
e93192ac AC	361	/* printk("transport --- ENE_Write_Data\n"); */
e93192ac AC	362	/* set up the command wrapper */
307ae1d3	363	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
126bb03b AC	364	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
126bb03b AC	365	bcb->DataTransferLength = length;
e93192ac	366	bcb->Flags = 0x00;
126bb03b AC	367	bcb->CDB[0] = 0xEE;
	368	bcb->CDB[2] = 0xFF;
	369	bcb->CDB[3] = 0x81;
	370
e93192ac AC	371	/* send cmd to out endpoint */
	372	result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
	373	US_BULK_CB_WRAP_LEN, NULL);
126bb03b AC	374	if (result != USB_STOR_XFER_GOOD)
	375	return USB_STOR_TRANSPORT_ERROR;
	376
e93192ac AC	377	/* R/W data */
	378	result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
	379	buf, length, NULL);
126bb03b AC	380	if (result != USB_STOR_XFER_GOOD)
	381	return USB_STOR_TRANSPORT_ERROR;
	382
e93192ac AC	383	/* Get CSW for device status */
	384	result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
	385	US_BULK_CS_WRAP_LEN, NULL);
126bb03b AC	386	if (result != USB_STOR_XFER_GOOD)
	387	return USB_STOR_TRANSPORT_ERROR;
	388	if (bcs->Status != US_BULK_STAT_OK)
	389	return USB_STOR_TRANSPORT_ERROR;
	390
	391	return USB_STOR_TRANSPORT_GOOD;
	392	}
	393
e93192ac AC	394	/*
	395	* usb_stor_print_cmd():
	396	*/
126bb03b AC	397	void usb_stor_print_cmd(struct scsi_cmnd *srb)
	398	{
	399	PBYTE Cdb = srb->cmnd;
	400	DWORD cmd = Cdb[0];
e93192ac AC	401	DWORD bn = ((Cdb[2] << 24) & 0xff000000) \|
	402	((Cdb[3] << 16) & 0x00ff0000) \|
	403	((Cdb[4] << 8) & 0x0000ff00) \|
	404	((Cdb[5] << 0) & 0x000000ff);
	405	WORD blen = ((Cdb[7] << 8) & 0xff00) \| ((Cdb[8] << 0) & 0x00ff);
126bb03b AC	406
	407	switch (cmd) {
	408	case TEST_UNIT_READY:
e93192ac AC	409	/* printk(KERN_INFO
e93192ac AC	410	"scsi cmd %X --- SCSIOP_TEST_UNIT_READY\n", cmd); */
126bb03b AC	411	break;
126bb03b AC	412	case INQUIRY:
e93192ac	413	printk(KERN_INFO "scsi cmd %X --- SCSIOP_INQUIRY\n", cmd);
126bb03b AC	414	break;
126bb03b AC	415	case MODE_SENSE:
e93192ac	416	printk(KERN_INFO "scsi cmd %X --- SCSIOP_MODE_SENSE\n", cmd);
126bb03b AC	417	break;
126bb03b AC	418	case START_STOP:
e93192ac	419	printk(KERN_INFO "scsi cmd %X --- SCSIOP_START_STOP\n", cmd);
126bb03b AC	420	break;
126bb03b AC	421	case READ_CAPACITY:
e93192ac	422	printk(KERN_INFO "scsi cmd %X --- SCSIOP_READ_CAPACITY\n", cmd);
126bb03b AC	423	break;
126bb03b AC	424	case READ_10:
e93192ac AC	425	/* printk(KERN_INFO
	426	"scsi cmd %X --- SCSIOP_READ,bn = %X, blen = %X\n"
	427	,cmd, bn, blen); */
126bb03b AC	428	break;
126bb03b AC	429	case WRITE_10:
e93192ac AC	430	/* printk(KERN_INFO
	431	"scsi cmd %X --- SCSIOP_WRITE,
	432	bn = %X, blen = %X\n" , cmd, bn, blen); */
126bb03b AC	433	break;
126bb03b AC	434	case ALLOW_MEDIUM_REMOVAL:
e93192ac AC	435	printk(KERN_INFO
e93192ac AC	436	"scsi cmd %X --- SCSIOP_ALLOW_MEDIUM_REMOVAL\n", cmd);
126bb03b AC	437	break;
126bb03b AC	438	default:
e93192ac	439	printk(KERN_INFO "scsi cmd %X --- Other cmd\n", cmd);
126bb03b AC	440	break;
	441	}
	442	bn = 0;
	443	blen = 0;
	444	}
	445