Staging: Merge ENE UB6250 SD card codes from keucr to drivers/usb/storage (41e568d1) · Commits · 戴 / test

drivers/staging/keucr/Kconfig

+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'

drivers/staging/keucr/Makefile

+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 \

drivers/staging/keucr/init.c

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

drivers/staging/keucr/init.h

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

Admin message