2010-09-08 07:42:32 +00:00
|
|
|
#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"
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
BYTE IsSSFDCCompliance;
|
|
|
|
BYTE IsXDCompliance;
|
2010-09-08 07:42:32 +00:00
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* ENE_InitMedia():
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
int ENE_InitMedia(struct us_data *us)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
BYTE MiscReg03 = 0;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO "--- Init Media ---\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
result = ENE_Read_BYTE(us, REG_CARD_STATUS, &MiscReg03);
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD) {
|
|
|
|
printk(KERN_ERR "Read register fail !!\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO "MiscReg03 = %x\n", MiscReg03);
|
2010-09-08 07:42:32 +00:00
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
if (MiscReg03 & 0x01) {
|
|
|
|
if (!us->SD_Status.Ready) {
|
2010-09-08 07:42:32 +00:00
|
|
|
result = ENE_SDInit(us);
|
|
|
|
if (result != USB_STOR_XFER_GOOD)
|
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
if (MiscReg03 & 0x02) {
|
|
|
|
if (!us->SM_Status.Ready && !us->MS_Status.Ready) {
|
2010-09-08 07:42:32 +00:00
|
|
|
result = ENE_SMInit(us);
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD) {
|
2010-09-08 07:42:32 +00:00
|
|
|
result = ENE_MSInit(us);
|
|
|
|
if (result != USB_STOR_XFER_GOOD)
|
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* ENE_Read_BYTE() :
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
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;
|
|
|
|
|
2010-10-29 01:18:18 +00:00
|
|
|
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
|
2010-09-08 07:42:32 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* ENE_SDInit():
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
int ENE_SDInit(struct us_data *us)
|
|
|
|
{
|
|
|
|
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
|
|
|
|
int result;
|
|
|
|
BYTE buf[0x200];
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO "transport --- ENE_SDInit\n");
|
|
|
|
/* SD Init Part-1 */
|
2010-09-08 07:42:32 +00:00
|
|
|
result = ENE_LoadBinCode(us, SD_INIT1_PATTERN);
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD) {
|
|
|
|
printk(KERN_ERR "Load SD Init Code Part-1 Fail !!\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
2010-10-29 01:18:18 +00:00
|
|
|
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
|
2010-09-08 07:42:32 +00:00
|
|
|
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
|
|
|
|
bcb->Flags = 0x80;
|
|
|
|
bcb->CDB[0] = 0xF2;
|
|
|
|
|
|
|
|
result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD) {
|
|
|
|
printk(KERN_ERR "Exection SD Init Code Fail !!\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* SD Init Part-2 */
|
2010-09-08 07:42:32 +00:00
|
|
|
result = ENE_LoadBinCode(us, SD_INIT2_PATTERN);
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD) {
|
|
|
|
printk(KERN_ERR "Load SD Init Code Part-2 Fail !!\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
2010-10-29 01:18:18 +00:00
|
|
|
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
|
2010-09-08 07:42:32 +00:00
|
|
|
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);
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD) {
|
|
|
|
printk(KERN_ERR "Exection SD Init Code Fail !!\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
us->SD_Status = *(PSD_STATUS)&buf[0];
|
2010-11-26 11:06:39 +00:00
|
|
|
if (us->SD_Status.Insert && us->SD_Status.Ready) {
|
2010-09-08 07:42:32 +00:00
|
|
|
ENE_ReadSDReg(us, (PBYTE)&buf);
|
2010-11-26 11:06:39 +00:00
|
|
|
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]);
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
return USB_STOR_TRANSPORT_GOOD;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* ENE_MSInit():
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
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;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO "transport --- ENE_MSInit\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
result = ENE_LoadBinCode(us, MS_INIT_PATTERN);
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD) {
|
|
|
|
printk(KERN_ERR "Load MS Init Code Fail !!\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
2010-10-29 01:18:18 +00:00
|
|
|
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
|
2010-09-08 07:42:32 +00:00
|
|
|
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);
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD) {
|
|
|
|
printk(KERN_ERR "Exection MS Init Code Fail !!\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
us->MS_Status = *(PMS_STATUS)&buf[0];
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
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];
|
2010-09-08 07:42:32 +00:00
|
|
|
us->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
|
2010-11-26 11:06:39 +00:00
|
|
|
} else {
|
2010-09-08 07:42:32 +00:00
|
|
|
MS_CardInit(us);
|
2010-11-26 11:06:39 +00:00
|
|
|
}
|
|
|
|
printk(KERN_INFO "MS Init Code OK !!\n");
|
|
|
|
} else {
|
|
|
|
printk(KERN_INFO "MS Card Not Ready --- %x\n", buf[0]);
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
return USB_STOR_TRANSPORT_GOOD;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
*ENE_SMInit()
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
int ENE_SMInit(struct us_data *us)
|
|
|
|
{
|
|
|
|
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
|
|
|
|
int result;
|
|
|
|
BYTE buf[0x200];
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO "transport --- ENE_SMInit\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
|
|
|
|
result = ENE_LoadBinCode(us, SM_INIT_PATTERN);
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD) {
|
|
|
|
printk(KERN_INFO "Load SM Init Code Fail !!\n");
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
2010-10-29 01:18:18 +00:00
|
|
|
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
|
2010-09-08 07:42:32 +00:00
|
|
|
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);
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"Exection SM Init Code Fail !! result = %x\n", result);
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
us->SM_Status = *(PSM_STATUS)&buf[0];
|
|
|
|
|
|
|
|
us->SM_DeviceID = buf[1];
|
|
|
|
us->SM_CardID = buf[2];
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
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);
|
2010-09-08 07:42:32 +00:00
|
|
|
MediaChange = 1;
|
|
|
|
Check_D_MediaFmt(us);
|
2010-11-26 11:06:39 +00:00
|
|
|
} else {
|
|
|
|
printk(KERN_ERR "SM Card Not Ready --- %x\n", buf[0]);
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
return USB_STOR_TRANSPORT_GOOD;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* ENE_ReadSDReg()
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
int ENE_ReadSDReg(struct us_data *us, u8 *RdBuf)
|
|
|
|
{
|
|
|
|
WORD tmpreg;
|
|
|
|
DWORD reg4b;
|
2010-11-26 11:06:39 +00:00
|
|
|
|
|
|
|
/* printk(KERN_INFO "transport --- ENE_ReadSDReg\n"); */
|
2010-09-08 07:42:32 +00:00
|
|
|
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]);
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
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;
|
2010-09-08 07:42:32 +00:00
|
|
|
}
|
|
|
|
return USB_STOR_TRANSPORT_GOOD;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* ENE_LoadBinCode()
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
int ENE_LoadBinCode(struct us_data *us, BYTE flag)
|
|
|
|
{
|
|
|
|
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
|
|
|
|
int result;
|
2010-11-26 11:06:39 +00:00
|
|
|
/* void *buf; */
|
2010-09-08 07:42:32 +00:00
|
|
|
PBYTE buf;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* printk(KERN_INFO "transport --- ENE_LoadBinCode\n"); */
|
2010-09-08 07:42:32 +00:00
|
|
|
if (us->BIN_FLAG == flag)
|
|
|
|
return USB_STOR_TRANSPORT_GOOD;
|
|
|
|
|
|
|
|
buf = kmalloc(0x800, GFP_KERNEL);
|
2010-09-19 07:36:23 +00:00
|
|
|
if (buf == NULL)
|
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
2010-11-26 11:06:39 +00:00
|
|
|
switch (flag) {
|
|
|
|
/* For SD */
|
|
|
|
case SD_INIT1_PATTERN:
|
|
|
|
printk(KERN_INFO "SD_INIT1_PATTERN\n");
|
|
|
|
memcpy(buf, SD_Init1, 0x800);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
2010-11-26 11:06:39 +00:00
|
|
|
case SD_INIT2_PATTERN:
|
|
|
|
printk(KERN_INFO "SD_INIT2_PATTERN\n");
|
|
|
|
memcpy(buf, SD_Init2, 0x800);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
2010-11-26 11:06:39 +00:00
|
|
|
case SD_RW_PATTERN:
|
|
|
|
printk(KERN_INFO "SD_RW_PATTERN\n");
|
|
|
|
memcpy(buf, SD_Rdwr, 0x800);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
2010-11-26 11:06:39 +00:00
|
|
|
/* For MS */
|
|
|
|
case MS_INIT_PATTERN:
|
|
|
|
printk(KERN_INFO "MS_INIT_PATTERN\n");
|
|
|
|
memcpy(buf, MS_Init, 0x800);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
2010-11-26 11:06:39 +00:00
|
|
|
case MSP_RW_PATTERN:
|
|
|
|
printk(KERN_INFO "MSP_RW_PATTERN\n");
|
|
|
|
memcpy(buf, MSP_Rdwr, 0x800);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
2010-11-26 11:06:39 +00:00
|
|
|
case MS_RW_PATTERN:
|
|
|
|
printk(KERN_INFO "MS_RW_PATTERN\n");
|
|
|
|
memcpy(buf, MS_Rdwr, 0x800);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
2010-11-26 11:06:39 +00:00
|
|
|
/* For SS */
|
|
|
|
case SM_INIT_PATTERN:
|
|
|
|
printk(KERN_INFO "SM_INIT_PATTERN\n");
|
|
|
|
memcpy(buf, SM_Init, 0x800);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
2010-11-26 11:06:39 +00:00
|
|
|
case SM_RW_PATTERN:
|
|
|
|
printk(KERN_INFO "SM_RW_PATTERN\n");
|
|
|
|
memcpy(buf, SM_Rdwr, 0x800);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-10-29 01:18:18 +00:00
|
|
|
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
|
2010-09-08 07:42:32 +00:00
|
|
|
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
|
|
|
|
bcb->DataTransferLength = 0x800;
|
2010-11-26 11:06:39 +00:00
|
|
|
bcb->Flags = 0x00;
|
2010-09-08 07:42:32 +00:00
|
|
|
bcb->CDB[0] = 0xEF;
|
|
|
|
|
|
|
|
result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
|
|
|
|
|
|
|
|
kfree(buf);
|
|
|
|
us->BIN_FLAG = flag;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* ENE_SendScsiCmd():
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
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;
|
2010-11-26 11:06:39 +00:00
|
|
|
unsigned int transfer_length = bcb->DataTransferLength,
|
|
|
|
cswlen = 0, partial = 0;
|
2010-09-08 07:42:32 +00:00
|
|
|
unsigned int residue;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* 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");
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
if (buf) {
|
2010-11-26 11:07:27 +00:00
|
|
|
unsigned int pipe = fDir;
|
|
|
|
|
|
|
|
if (fDir == FDIR_READ)
|
|
|
|
pipe = us->recv_bulk_pipe;
|
|
|
|
else
|
|
|
|
pipe = us->send_bulk_pipe;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* Bulk */
|
2010-09-08 07:42:32 +00:00
|
|
|
if (use_sg)
|
|
|
|
result = usb_stor_bulk_srb(us, pipe, us->srb);
|
|
|
|
else
|
2010-11-26 11:06:39 +00:00
|
|
|
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");
|
2010-09-08 07:42:32 +00:00
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* Get CSW for device status */
|
|
|
|
result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
|
|
|
|
US_BULK_CS_WRAP_LEN, &cswlen);
|
2010-09-08 07:42:32 +00:00
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
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);
|
2010-09-08 07:42:32 +00:00
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
if (result == USB_STOR_XFER_STALLED) {
|
2010-09-08 07:42:32 +00:00
|
|
|
/* get the status again */
|
2010-11-26 11:06:39 +00:00
|
|
|
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);
|
2010-09-08 07:42:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (result != USB_STOR_XFER_GOOD)
|
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
|
|
|
|
/* check bulk status */
|
|
|
|
residue = le32_to_cpu(bcs->Residue);
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* 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)) {
|
2010-09-08 07:42:32 +00:00
|
|
|
residue = min(residue, transfer_length);
|
2010-11-26 11:06:39 +00:00
|
|
|
scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
|
|
|
|
(int) residue));
|
2010-09-08 07:42:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bcs->Status != US_BULK_STAT_OK)
|
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
|
|
|
|
return USB_STOR_TRANSPORT_GOOD;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* ENE_Read_Data()
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
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;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* printk(KERN_INFO "transport --- ENE_Read_Data\n"); */
|
|
|
|
/* set up the command wrapper */
|
2010-10-29 01:18:18 +00:00
|
|
|
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
|
2010-09-08 07:42:32 +00:00
|
|
|
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
|
|
|
|
bcb->DataTransferLength = length;
|
2010-11-26 11:06:39 +00:00
|
|
|
bcb->Flags = 0x80;
|
2010-09-08 07:42:32 +00:00
|
|
|
bcb->CDB[0] = 0xED;
|
|
|
|
bcb->CDB[2] = 0xFF;
|
|
|
|
bcb->CDB[3] = 0x81;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* send cmd to out endpoint */
|
|
|
|
result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
|
|
|
|
US_BULK_CB_WRAP_LEN, NULL);
|
2010-09-08 07:42:32 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD)
|
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* R/W data */
|
|
|
|
result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
|
|
|
|
buf, length, NULL);
|
2010-09-08 07:42:32 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD)
|
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* Get CSW for device status */
|
|
|
|
result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
|
|
|
|
US_BULK_CS_WRAP_LEN, NULL);
|
2010-09-08 07:42:32 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* ENE_Write_Data():
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
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;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* printk("transport --- ENE_Write_Data\n"); */
|
|
|
|
/* set up the command wrapper */
|
2010-10-29 01:18:18 +00:00
|
|
|
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
|
2010-09-08 07:42:32 +00:00
|
|
|
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
|
|
|
|
bcb->DataTransferLength = length;
|
2010-11-26 11:06:39 +00:00
|
|
|
bcb->Flags = 0x00;
|
2010-09-08 07:42:32 +00:00
|
|
|
bcb->CDB[0] = 0xEE;
|
|
|
|
bcb->CDB[2] = 0xFF;
|
|
|
|
bcb->CDB[3] = 0x81;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* send cmd to out endpoint */
|
|
|
|
result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
|
|
|
|
US_BULK_CB_WRAP_LEN, NULL);
|
2010-09-08 07:42:32 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD)
|
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* R/W data */
|
|
|
|
result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
|
|
|
|
buf, length, NULL);
|
2010-09-08 07:42:32 +00:00
|
|
|
if (result != USB_STOR_XFER_GOOD)
|
|
|
|
return USB_STOR_TRANSPORT_ERROR;
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/* Get CSW for device status */
|
|
|
|
result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
|
|
|
|
US_BULK_CS_WRAP_LEN, NULL);
|
2010-09-08 07:42:32 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2010-11-26 11:06:39 +00:00
|
|
|
/*
|
|
|
|
* usb_stor_print_cmd():
|
|
|
|
*/
|
2010-09-08 07:42:32 +00:00
|
|
|
void usb_stor_print_cmd(struct scsi_cmnd *srb)
|
|
|
|
{
|
|
|
|
PBYTE Cdb = srb->cmnd;
|
|
|
|
DWORD cmd = Cdb[0];
|
2010-11-26 11:06:39 +00:00
|
|
|
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);
|
2010-09-08 07:42:32 +00:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case TEST_UNIT_READY:
|
2010-11-26 11:06:39 +00:00
|
|
|
/* printk(KERN_INFO
|
|
|
|
"scsi cmd %X --- SCSIOP_TEST_UNIT_READY\n", cmd); */
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
|
|
|
case INQUIRY:
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO "scsi cmd %X --- SCSIOP_INQUIRY\n", cmd);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
|
|
|
case MODE_SENSE:
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO "scsi cmd %X --- SCSIOP_MODE_SENSE\n", cmd);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
|
|
|
case START_STOP:
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO "scsi cmd %X --- SCSIOP_START_STOP\n", cmd);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
|
|
|
case READ_CAPACITY:
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO "scsi cmd %X --- SCSIOP_READ_CAPACITY\n", cmd);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
|
|
|
case READ_10:
|
2010-11-26 11:06:39 +00:00
|
|
|
/* printk(KERN_INFO
|
|
|
|
"scsi cmd %X --- SCSIOP_READ,bn = %X, blen = %X\n"
|
|
|
|
,cmd, bn, blen); */
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
|
|
|
case WRITE_10:
|
2010-11-26 11:06:39 +00:00
|
|
|
/* printk(KERN_INFO
|
|
|
|
"scsi cmd %X --- SCSIOP_WRITE,
|
|
|
|
bn = %X, blen = %X\n" , cmd, bn, blen); */
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
|
|
|
case ALLOW_MEDIUM_REMOVAL:
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO
|
|
|
|
"scsi cmd %X --- SCSIOP_ALLOW_MEDIUM_REMOVAL\n", cmd);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
|
|
|
default:
|
2010-11-26 11:06:39 +00:00
|
|
|
printk(KERN_INFO "scsi cmd %X --- Other cmd\n", cmd);
|
2010-09-08 07:42:32 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
bn = 0;
|
|
|
|
blen = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|