Commit 41e568d1 authored by huajun li's avatar huajun li Committed by Greg Kroah-Hartman
Browse files

Staging: Merge ENE UB6250 SD card codes from keucr to drivers/usb/storage



The usb portion of this driver can now go into drivers/usb/storage.
This leaves the non-usb portion of the code still in staging.

Signed-off-by: default avatarHuajun Li <huajun.li.lee@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 153775d9
Loading
Loading
Loading
Loading
+3 −2
Original line number Diff line number Diff line
config USB_ENESTORAGE
	tristate "USB ENE card reader support"
	tristate "USB ENE SM/MS card reader support"
	depends on USB && SCSI && m
	---help---
	  Say Y here if you wish to control a ENE Card reader.
	  Say Y here if you wish to control a ENE SM/MS Card reader.
	  To use SD card, please build driver/usb/storage/ums-eneub6250.ko

	  This option depends on 'SCSI' support being enabled, but you
	  probably also need 'SCSI device support: SCSI disk support'
+0 −1
Original line number Diff line number Diff line
@@ -7,7 +7,6 @@ keucr-y := \
		scsiglue.o	\
		transport.o	\
		init.o		\
		sdscsi.o	\
		msscsi.o	\
		ms.o		\
		smscsi.o	\
+3 −119
Original line number Diff line number Diff line
@@ -30,14 +30,6 @@ int ENE_InitMedia(struct us_data *us)
	}
	printk(KERN_INFO "MiscReg03 = %x\n", MiscReg03);

	if (MiscReg03 & 0x01) {
		if (!us->SD_Status.Ready) {
			result = ENE_SDInit(us);
			if (result != USB_STOR_XFER_GOOD)
				return USB_STOR_TRANSPORT_ERROR;
		}
	}

	if (MiscReg03 & 0x02) {
		if (!us->SM_Status.Ready && !us->MS_Status.Ready) {
			result = ENE_SMInit(us);
@@ -72,69 +64,6 @@ int ENE_Read_BYTE(struct us_data *us, WORD index, void *buf)
	return result;
}

/*
 * ENE_SDInit():
 */
int ENE_SDInit(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_SDInit\n");
	/* SD Init Part-1 */
	result = ENE_LoadBinCode(us, SD_INIT1_PATTERN);
	if (result != USB_STOR_XFER_GOOD) {
		printk(KERN_ERR "Load SD Init Code Part-1 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->Flags = 0x80;
	bcb->CDB[0] = 0xF2;

	result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
	if (result != USB_STOR_XFER_GOOD) {
		printk(KERN_ERR "Exection SD Init Code Fail !!\n");
		return USB_STOR_TRANSPORT_ERROR;
	}

	/* SD Init Part-2 */
	result = ENE_LoadBinCode(us, SD_INIT2_PATTERN);
	if (result != USB_STOR_XFER_GOOD) {
		printk(KERN_ERR "Load SD Init Code Part-2 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;

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

	us->SD_Status =  *(PSD_STATUS)&buf[0];
	if (us->SD_Status.Insert && us->SD_Status.Ready) {
		ENE_ReadSDReg(us, (PBYTE)&buf);
		printk(KERN_INFO "Insert     = %x\n", us->SD_Status.Insert);
		printk(KERN_INFO "Ready      = %x\n", us->SD_Status.Ready);
		printk(KERN_INFO "IsMMC      = %x\n", us->SD_Status.IsMMC);
		printk(KERN_INFO "HiCapacity = %x\n", us->SD_Status.HiCapacity);
		printk(KERN_INFO "HiSpeed    = %x\n", us->SD_Status.HiSpeed);
		printk(KERN_INFO "WtP        = %x\n", us->SD_Status.WtP);
	} else {
		printk(KERN_ERR "SD Card Not Ready --- %x\n", buf[0]);
		return USB_STOR_TRANSPORT_ERROR;
	}
	return USB_STOR_TRANSPORT_GOOD;
}

/*
 * ENE_MSInit():
 */
@@ -241,38 +170,6 @@ int ENE_SMInit(struct us_data *us)
	return USB_STOR_TRANSPORT_GOOD;
}

/*
 * ENE_ReadSDReg()
 */
int ENE_ReadSDReg(struct us_data *us, u8 *RdBuf)
{
	WORD	tmpreg;
	DWORD	reg4b;

	/* printk(KERN_INFO "transport --- ENE_ReadSDReg\n"); */
	reg4b = *(PDWORD)&RdBuf[0x18];
	us->SD_READ_BL_LEN = (BYTE)((reg4b >> 8) & 0x0f);

	tmpreg = (WORD) reg4b;
	reg4b = *(PDWORD)(&RdBuf[0x14]);
	if (us->SD_Status.HiCapacity && !us->SD_Status.IsMMC)
		us->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;

	us->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (WORD)(reg4b >> 22);
	us->SD_C_SIZE_MULT = (BYTE)(reg4b >> 7)  & 0x07;
	if (us->SD_Status.HiCapacity && us->SD_Status.IsMMC)
		us->HC_C_SIZE = *(PDWORD)(&RdBuf[0x100]);

	if (us->SD_READ_BL_LEN > SD_BLOCK_LEN) {
		us->SD_Block_Mult =
			1 << (us->SD_READ_BL_LEN - SD_BLOCK_LEN);
		us->SD_READ_BL_LEN = SD_BLOCK_LEN;
	} else {
		us->SD_Block_Mult = 1;
	}
	return USB_STOR_TRANSPORT_GOOD;
}

/*
 * ENE_LoadBinCode()
 */
@@ -291,19 +188,6 @@ int ENE_LoadBinCode(struct us_data *us, BYTE flag)
	if (buf == NULL)
		return USB_STOR_TRANSPORT_ERROR;
	switch (flag) {
	/* For SD */
	case SD_INIT1_PATTERN:
		printk(KERN_INFO "SD_INIT1_PATTERN\n");
		memcpy(buf, SD_Init1, 0x800);
		break;
	case SD_INIT2_PATTERN:
		printk(KERN_INFO "SD_INIT2_PATTERN\n");
		memcpy(buf, SD_Init2, 0x800);
		break;
	case SD_RW_PATTERN:
		printk(KERN_INFO "SD_RW_PATTERN\n");
		memcpy(buf, SD_Rdwr, 0x800);
		break;
	/* For MS */
	case MS_INIT_PATTERN:
		printk(KERN_INFO "MS_INIT_PATTERN\n");
@@ -412,6 +296,7 @@ int ENE_SendScsiCmd(struct us_data *us, BYTE fDir, void *buf, int use_sg)
	 */
	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));
	}
@@ -558,4 +443,3 @@ void usb_stor_print_cmd(struct scsi_cmnd *srb)
	blen = 0;
}
+0 −773

File changed.

Preview size limit exceeded, changes collapsed.

drivers/staging/keucr/sdscsi.c

deleted100644 → 0
+0 −210
Original line number Diff line number Diff line
#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"

int SD_SCSI_Test_Unit_Ready (struct us_data *us, struct scsi_cmnd *srb);
int SD_SCSI_Inquiry         (struct us_data *us, struct scsi_cmnd *srb);
int SD_SCSI_Mode_Sense      (struct us_data *us, struct scsi_cmnd *srb);
int SD_SCSI_Start_Stop      (struct us_data *us, struct scsi_cmnd *srb);
int SD_SCSI_Read_Capacity   (struct us_data *us, struct scsi_cmnd *srb);
int SD_SCSI_Read            (struct us_data *us, struct scsi_cmnd *srb);
int SD_SCSI_Write           (struct us_data *us, struct scsi_cmnd *srb);

//----- SD_SCSIIrp() --------------------------------------------------
int SD_SCSIIrp(struct us_data *us, struct scsi_cmnd *srb)
{
	int    result;

	us->SrbStatus = SS_SUCCESS;
	switch (srb->cmnd[0])
	{
		case TEST_UNIT_READY :  result = SD_SCSI_Test_Unit_Ready (us, srb);  break; //0x00
		case INQUIRY         :  result = SD_SCSI_Inquiry         (us, srb);  break; //0x12
		case MODE_SENSE      :  result = SD_SCSI_Mode_Sense      (us, srb);  break; //0x1A
//		case START_STOP      :  result = SD_SCSI_Start_Stop      (us, srb);  break; //0x1B
		case READ_CAPACITY   :  result = SD_SCSI_Read_Capacity   (us, srb);  break; //0x25
		case READ_10         :  result = SD_SCSI_Read            (us, srb);  break; //0x28
		case WRITE_10        :  result = SD_SCSI_Write           (us, srb);  break; //0x2A

		default:
			us->SrbStatus = SS_ILLEGAL_REQUEST;
			result = USB_STOR_TRANSPORT_FAILED;
			break;
	}
	return result;
}

//----- SD_SCSI_Test_Unit_Ready() --------------------------------------------------
int SD_SCSI_Test_Unit_Ready(struct us_data *us, struct scsi_cmnd *srb)
{
	//printk("SD_SCSI_Test_Unit_Ready\n");
	if (us->SD_Status.Insert && us->SD_Status.Ready)
		return USB_STOR_TRANSPORT_GOOD;
	else
	{
		ENE_SDInit(us);
		return USB_STOR_TRANSPORT_GOOD;
	}
		
	return USB_STOR_TRANSPORT_GOOD;
}

//----- SD_SCSI_Inquiry() --------------------------------------------------
int SD_SCSI_Inquiry(struct us_data *us, struct scsi_cmnd *srb)
{
	//printk("SD_SCSI_Inquiry\n");
	BYTE data_ptr[36] = {0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55, 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61, 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30};

	usb_stor_set_xfer_buf(us, data_ptr, 36, srb, TO_XFER_BUF);
	return USB_STOR_TRANSPORT_GOOD;
}


//----- SD_SCSI_Mode_Sense() --------------------------------------------------
int SD_SCSI_Mode_Sense(struct us_data *us, struct scsi_cmnd *srb)
{
	BYTE	mediaNoWP[12] = {0x0b,0x00,0x00,0x08,0x00,0x00,0x71,0xc0,0x00,0x00,0x02,0x00};
	BYTE	mediaWP[12]   = {0x0b,0x00,0x80,0x08,0x00,0x00,0x71,0xc0,0x00,0x00,0x02,0x00};

	if (us->SD_Status.WtP)
		usb_stor_set_xfer_buf(us, mediaWP, 12, srb, TO_XFER_BUF);
	else
		usb_stor_set_xfer_buf(us, mediaNoWP, 12, srb, TO_XFER_BUF);


	return USB_STOR_TRANSPORT_GOOD;
}

//----- SD_SCSI_Read_Capacity() --------------------------------------------------
int SD_SCSI_Read_Capacity(struct us_data *us, struct scsi_cmnd *srb)
{
	unsigned int offset = 0;
	struct scatterlist *sg = NULL;
	DWORD   bl_num;
	WORD    bl_len;
	BYTE    buf[8];

	printk("SD_SCSI_Read_Capacity\n");
	if ( us->SD_Status.HiCapacity )
	{
		bl_len = 0x200;
		if (us->SD_Status.IsMMC)
			bl_num = us->HC_C_SIZE-1;
		else
			bl_num = (us->HC_C_SIZE + 1) * 1024 - 1;
	}
	else
	{
		bl_len = 1<<(us->SD_READ_BL_LEN);
		bl_num = us->SD_Block_Mult*(us->SD_C_SIZE+1)*(1<<(us->SD_C_SIZE_MULT+2)) - 1;
	}
	us->bl_num = bl_num;
	printk("bl_len = %x\n", bl_len);
	printk("bl_num = %x\n", bl_num);

	//srb->request_bufflen = 8;
	buf[0] = (bl_num>>24) & 0xff;
	buf[1] = (bl_num>>16) & 0xff;
	buf[2] = (bl_num>> 8) & 0xff;
	buf[3] = (bl_num>> 0) & 0xff;
	buf[4] = (bl_len>>24) & 0xff;
	buf[5] = (bl_len>>16) & 0xff;
	buf[6] = (bl_len>> 8) & 0xff;
	buf[7] = (bl_len>> 0) & 0xff;
	
	usb_stor_access_xfer_buf(us, buf, 8, srb, &sg, &offset, TO_XFER_BUF);
	//usb_stor_set_xfer_buf(us, buf, srb->request_bufflen, srb, TO_XFER_BUF);

	return USB_STOR_TRANSPORT_GOOD;
}

//----- SD_SCSI_Read() --------------------------------------------------
int SD_SCSI_Read(struct us_data *us, struct scsi_cmnd *srb)
{
	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
	int result;
	PBYTE	Cdb = srb->cmnd;
	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);
	DWORD bnByte = bn * 0x200;
	DWORD	blenByte = blen * 0x200;

	if (bn > us->bl_num)
		return USB_STOR_TRANSPORT_ERROR;

	result = ENE_LoadBinCode(us, SD_RW_PATTERN);
	if (result != USB_STOR_XFER_GOOD)
	{
		printk("Load SD RW pattern Fail !!\n");
		return USB_STOR_TRANSPORT_ERROR;
	}

	if ( us->SD_Status.HiCapacity )
		bnByte = bn;
		
	// set up the command wrapper
	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	bcb->DataTransferLength = blenByte;
	bcb->Flags  = 0x80;
	bcb->CDB[0] = 0xF1;
	bcb->CDB[5] = (BYTE)(bnByte);
	bcb->CDB[4] = (BYTE)(bnByte>>8);
	bcb->CDB[3] = (BYTE)(bnByte>>16);
	bcb->CDB[2] = (BYTE)(bnByte>>24);

	result = ENE_SendScsiCmd(us, FDIR_READ, scsi_sglist(srb), 1);
	return result;
}

//----- SD_SCSI_Write() --------------------------------------------------
int SD_SCSI_Write(struct us_data *us, struct scsi_cmnd *srb)
{
	struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
	int result;
	PBYTE	Cdb = srb->cmnd;
	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);
	DWORD bnByte = bn * 0x200;
	DWORD	blenByte = blen * 0x200;

	if (bn > us->bl_num)
		return USB_STOR_TRANSPORT_ERROR;

	result = ENE_LoadBinCode(us, SD_RW_PATTERN);
	if (result != USB_STOR_XFER_GOOD)
	{
		printk("Load SD RW pattern Fail !!\n");
		return USB_STOR_TRANSPORT_ERROR;
	}

	if ( us->SD_Status.HiCapacity )
		bnByte = bn;

	// set up the command wrapper
	memset(bcb, 0, sizeof(struct bulk_cb_wrap));
	bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
	bcb->DataTransferLength = blenByte;
	bcb->Flags  = 0x00;
	bcb->CDB[0] = 0xF0;
	bcb->CDB[5] = (BYTE)(bnByte);
	bcb->CDB[4] = (BYTE)(bnByte>>8);
	bcb->CDB[3] = (BYTE)(bnByte>>16);
	bcb->CDB[2] = (BYTE)(bnByte>>24);

	result = ENE_SendScsiCmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
	return result;
}


Loading