Skip to content

L
linux
Commit 74a5e01e authored by Ruslan Pisarev's avatar Ruslan Pisarev Committed by Greg Kroah-Hartman
Browse files
Options

Staging: keucr: Remove dead (comment) code in drivers/staging/keucr/smilsub.c 

Remove dead (comment) code in drivers/staging/keucr/smilsub.c
Signed-off-by: default avatarRuslan Pisarev <ruslan@rpisarev.org.ua>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 581cd7ee
Hide whitespace changes
Inline Side-by-side
Showing with 12 additions and 918 deletions
drivers/staging/keucr/smilsub.c
View file @ 74a5e01e
......@@ -2,10 +2,7 @@
#include "usb.h"
#include "scsiglue.h"
#include "transport.h"
//#include "init.h"
//#include "stdlib.h"
//#include "EUCR6SK.h"
#include "smcommon.h"
#include "smil.h"
......@@ -35,9 +32,7 @@ BYTE _Check_D_DevCode (BYTE);
void _Set_D_ECCdata (BYTE,BYTE *);
void _Calc_D_ECCdata (BYTE *);
//void SM_ReadDataWithDMA (PFDO_DEVICE_EXTENSION, BYTE *, WORD);
//void SM_WriteDataWithDMA (PFDO_DEVICE_EXTENSION, BYTE *, WORD);
//
struct SSFDCTYPE Ssfdc;
struct ADDRESS Media;
struct CIS_AREA CisArea;
......@@ -49,7 +44,7 @@ extern DWORD ErrXDCode;
extern WORD ReadBlock;
extern WORD WriteBlock;
//KEVENT SM_DMADoneEvent;
#define EVEN 0 // Even Page for 256byte/page
#define ODD 1 // Odd Page for 256byte/page
......@@ -108,8 +103,6 @@ int Check_D_DataStatus(BYTE *redundant)
int Load_D_LogBlockAddr(BYTE *redundant)
{
WORD addr1,addr2;
//SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
//ADDRESS_T bb = (ADDRESS_T) &Media;
addr1=(WORD)*(redundant+REDT_ADDR1H)*0x0100+(WORD)*(redundant+REDT_ADDR1L);
addr2=(WORD)*(redundant+REDT_ADDR2H)*0x0100+(WORD)*(redundant+REDT_ADDR2L);
......@@ -177,27 +170,7 @@ void Set_D_DataStaus(BYTE *redundant)
//----- Ssfdc_D_Reset() ------------------------------------------------
void Ssfdc_D_Reset(struct us_data *us)
{
//NTSTATUS ntStatus = STATUS_SUCCESS;
//PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
//BYTE buf[0x200];
//printk("Ssfdc_D_Reset --- But do nothing !!\n");
return;
/* RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
pBulkCbw->dCBWSignature = CBW_SIGNTURE;
pBulkCbw->bCBWLun = CBW_LUN;
//pBulkCbw->dCBWDataTransferLength = 0x200;
pBulkCbw->bmCBWFlags = 0x80;
pBulkCbw->CBWCb[0] = 0xF2;
pBulkCbw->CBWCb[1] = 0x07;
ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_READ, NULL);
if (!NT_SUCCESS(ntStatus))
{
ENE_Print("Ssfdc_D_Reset Fail !!\n");
//return ntStatus;
}*/
}
//----- Ssfdc_D_ReadCisSect() ------------------------------------------
......@@ -205,8 +178,6 @@ int Ssfdc_D_ReadCisSect(struct us_data *us, BYTE *buf,BYTE *redundant)
{
BYTE zone,sector;
WORD block;
//SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
//ADDRESS_T bb = (ADDRESS_T) &Media;
zone=Media.Zone; block=Media.PhyBlock; sector=Media.Sector;
Media.Zone=0;
......@@ -222,29 +193,7 @@ int Ssfdc_D_ReadCisSect(struct us_data *us, BYTE *buf,BYTE *redundant)
Media.Zone=zone; Media.PhyBlock=block; Media.Sector=sector;
return(SMSUCCESS);
}
/*
////----- Ssfdc_D_WriteRedtMode() ----------------------------------------
//void Ssfdc_D_WriteRedtMode(void)
//{
// _Set_D_SsfdcRdCmd (RST_CHIP);
// _Check_D_SsfdcBusy (BUSY_RESET);
// _Set_D_SsfdcRdCmd (READ_REDT);
// _Check_D_SsfdcBusy (BUSY_READ);
// _Set_D_SsfdcRdStandby ();
//}
//
////----- Ssfdc_D_ReadID() -----------------------------------------------
//void Ssfdc_D_ReadID(BYTE *buf, BYTE ReadID)
//{
// _Set_D_SsfdcRdCmd (ReadID);
// _Set_D_SsfdcRdChip ();
// _Read_D_SsfdcByte (buf++);
// _Read_D_SsfdcByte (buf++);
// _Read_D_SsfdcByte (buf++);
// _Read_D_SsfdcByte (buf);
// _Set_D_SsfdcRdStandby ();
//}
*/
// 6250 CMD 1
//----- Ssfdc_D_ReadSect() ---------------------------------------------
int Ssfdc_D_ReadSect(struct us_data *us, BYTE *buf,BYTE *redundant)
......@@ -305,7 +254,6 @@ int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
int result;
WORD addr;
//printk("Ssfdc_D_ReadBlock\n");
result = ENE_LoadBinCode(us, SM_RW_PATTERN);
if (result != USB_STOR_XFER_GOOD)
{
......@@ -350,177 +298,15 @@ int Ssfdc_D_ReadBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
return USB_STOR_TRANSPORT_GOOD;
}
/*
////----- Ssfdc_D_ReadSect_DMA() ---------------------------------------------
//int Ssfdc_D_ReadSect_DMA(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
//{
// WORD SectByteCount, addr;
// DWORD Buffer[4];
// WORD len;
//
// if (!_Hw_D_ChkCardIn())
// return(ERROR);
// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
// addr=addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
// // cycle starting address
// SM_STARTADDR_LSB = 0x00;
// SM_STARTADDR_IISB = (BYTE)addr;
// SM_STARTADDR_IIISB = (BYTE)(addr/0x0100);
// SM_STARTADDR_MSB = Media.Zone/2;
//
// //Sector byte count = 0x200(DMA)
// SectByteCount = 0x20f;
// SM_BYTECNT_LO = (BYTE)SectByteCount;
// SM_CMD_CTRL3 = (SM_CMD_CTRL3 & 0xFC) | (BYTE)(SectByteCount/0x0100);
// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
// SM_FIFO_CTRL = (SM_APB08_MASK | SM_DMAEN_MASK | SM_DMA_UPSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
// else
// SM_FIFO_CTRL = (SM_APB32_MASK | SM_DMAEN_MASK | SM_DMA_UPSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
//
// _Hw_D_EccRdReset();
// _Hw_D_EccRdStart();
//
// SM_CMD_CTRL1 = (SM_CMD_READ_1);
// SM_CMD_CTRL1 = (SM_CMD_READ_1 | SM_CMD_START_BIT);
//
// SectByteCount = 0x1ff;
// //SM_ReadDataWithDMA(fdoExt, buf, SectByteCount);
// //_ReadRedt_D_SsfdcBuf(redundant);
// len = 0x1000 - ((WORD)(buf) & 0x0FFF);
// if (len < 0x200)
// {
// SM_ReadDataWithDMA(fdoExt, buf, len-1);
// SM_ReadDataWithDMA(fdoExt, buf+len, SectByteCount-len);
// //ENE_Print("Read DMA !!! buf1 = %p, len = %x, buf2 = %p\n", buf, len, buf+len);
// }
// else
// SM_ReadDataWithDMA(fdoExt, buf, SectByteCount);
//
// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
// {
// _ReadRedt_D_SsfdcBuf(redundant);
// }
// else
// {
// Buffer[0] = READ_PORT_DWORD(SM_REG_DATA);
// Buffer[1] = READ_PORT_DWORD(SM_REG_DATA);
// Buffer[2] = READ_PORT_DWORD(SM_REG_DATA);
// Buffer[3] = READ_PORT_DWORD(SM_REG_DATA);
// memcpy(redundant, Buffer, 0x10);
// }
//
// while ( _Hw_D_ChkCardIn() )
// {
// if((READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x10))
// {
// WRITE_PORT_BYTE(SM_REG_INT_STATUS, 0x10);
// break;
// }
// }
// _Hw_D_EccRdStop();
// _Hw_D_SetRdStandby();
// _Load_D_SsfdcRdHwECC(EVEN);
//
// _Calc_D_ECCdata(buf);
// _Set_D_SsfdcRdStandby();
//
// if (!_Hw_D_ChkCardIn())
// return(ERROR);
// return(SMSUCCESS);
//}
//
////----- Ssfdc_D_ReadSect_PIO() ---------------------------------------------
//int Ssfdc_D_ReadSect_PIO(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
//{
// _Set_D_SsfdcRdCmd(READ);
// _Set_D_SsfdcRdAddr(EVEN);
//
// if (_Check_D_SsfdcBusy(BUSY_READ))
// { _Reset_D_SsfdcErr(); return(ERROR); }
//
// _Start_D_SsfdcRdHwECC();
// _Read_D_SsfdcBuf(buf);
// _Stop_D_SsfdcRdHwECC();
// _ReadRedt_D_SsfdcBuf(redundant);
// _Load_D_SsfdcRdHwECC(EVEN);
//
// if (_Check_D_SsfdcBusy(BUSY_READ))
// { _Reset_D_SsfdcErr(); return(ERROR); }
//
// _Calc_D_ECCdata(buf);
// _Set_D_SsfdcRdStandby();
// return(SMSUCCESS);
//}
// 6250 CMD 3
//----- Ssfdc_D_WriteSect() --------------------------------------------
int Ssfdc_D_WriteSect(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
{
PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
NTSTATUS ntStatus;
WORD addr;
//ENE_Print("SMILSUB --- Ssfdc_D_WriteSect\n");
ENE_LoadBinCode(fdoExt, SM_RW_PATTERN);
addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
// Write sect data
RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
pBulkCbw->dCBWSignature = CBW_SIGNTURE;
pBulkCbw->bCBWLun = CBW_LUN;
pBulkCbw->dCBWDataTransferLength = 0x200;
pBulkCbw->bmCBWFlags = 0x00;
pBulkCbw->CBWCb[0] = 0xF0;
pBulkCbw->CBWCb[1] = 0x04;
//pBulkCbw->CBWCb[4] = (BYTE)addr;
//pBulkCbw->CBWCb[3] = (BYTE)(addr/0x0100);
//pBulkCbw->CBWCb[2] = Media.Zone/2;
//pBulkCbw->CBWCb[5] = *(redundant+REDT_ADDR1H);
//pBulkCbw->CBWCb[6] = *(redundant+REDT_ADDR1L);
pBulkCbw->CBWCb[7] = (BYTE)addr;
pBulkCbw->CBWCb[6] = (BYTE)(addr/0x0100);
pBulkCbw->CBWCb[5] = Media.Zone/2;
pBulkCbw->CBWCb[8] = *(redundant+REDT_ADDR1H);
pBulkCbw->CBWCb[9] = *(redundant+REDT_ADDR1L);
ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_WRITE, buf);
if (!NT_SUCCESS(ntStatus))
return(ERROR);
// // For Test
// {
// BYTE bf[0x200], rdd[0x10];
// ULONG i;
//
// RtlZeroMemory(bf, 0x200);
// RtlZeroMemory(rdd, 0x10);
// ntStatus = SM_ReadBlock(fdoExt, bf, rdd);
// for (i=0; i<0x200; i++)
// {
// if (buf[i] != bf[i])
// ENE_Print("buf[%x] = %x, bf[%x] = %x\n", buf, bf);
// }
// if (!NT_SUCCESS(ntStatus))
// ENE_Print("Error\n");
// }
return(SMSUCCESS);
}
*/
//----- Ssfdc_D_CopyBlock() --------------------------------------------
int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
{
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
int result;
//PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
//NTSTATUS ntStatus;
WORD ReadAddr, WriteAddr;
//printk("Ssfdc_D_WriteSect --- ZONE = %x, ReadBlock = %x, WriteBlock = %x\n", Media.Zone, ReadBlock, WriteBlock);
result = ENE_LoadBinCode(us, SM_RW_PATTERN);
if (result != USB_STOR_XFER_GOOD)
{
......@@ -562,184 +348,14 @@ int Ssfdc_D_CopyBlock(struct us_data *us, WORD count, BYTE *buf,BYTE *redundant)
return USB_STOR_TRANSPORT_GOOD;
}
/*
//----- Ssfdc_D_WriteBlock() --------------------------------------------
int Ssfdc_D_WriteBlock(PFDO_DEVICE_EXTENSION fdoExt, WORD count, BYTE *buf,BYTE *redundant)
{
PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
NTSTATUS ntStatus;
WORD addr;
//ENE_Print("SMILSUB --- Ssfdc_D_WriteSect\n");
ENE_LoadBinCode(fdoExt, SM_RW_PATTERN);
addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
// Write sect data
RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
pBulkCbw->dCBWSignature = CBW_SIGNTURE;
pBulkCbw->bCBWLun = CBW_LUN;
pBulkCbw->dCBWDataTransferLength = 0x200*count;
pBulkCbw->bmCBWFlags = 0x00;
pBulkCbw->CBWCb[0] = 0xF0;
pBulkCbw->CBWCb[1] = 0x04;
pBulkCbw->CBWCb[7] = (BYTE)addr;
pBulkCbw->CBWCb[6] = (BYTE)(addr/0x0100);
pBulkCbw->CBWCb[5] = Media.Zone/2;
pBulkCbw->CBWCb[8] = *(redundant+REDT_ADDR1H);
pBulkCbw->CBWCb[9] = *(redundant+REDT_ADDR1L);
ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_WRITE, buf);
if (!NT_SUCCESS(ntStatus))
return(ERROR);
// // For Test
// {
// BYTE bf[0x200], rdd[0x10];
// ULONG i;
//
// RtlZeroMemory(bf, 0x200);
// RtlZeroMemory(rdd, 0x10);
// ntStatus = SM_ReadBlock(fdoExt, bf, rdd);
// for (i=0; i<0x200; i++)
// {
// if (buf[i] != bf[i])
// ENE_Print("buf[%x] = %x, bf[%x] = %x\n", buf, bf);
// }
// if (!NT_SUCCESS(ntStatus))
// ENE_Print("Error\n");
// }
return(SMSUCCESS);
}
//
////----- Ssfdc_D_WriteSect_DMA() --------------------------------------------
//int Ssfdc_D_WriteSect_DMA(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
//{
// WORD SectByteCount, addr;
// DWORD Buffer[4];
// WORD len;
//
// if (!_Hw_D_ChkCardIn())
// return(ERROR);
// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
// addr=addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
// // cycle starting address
// SM_STARTADDR_LSB = 0x00;
// SM_STARTADDR_IISB = (BYTE)addr;
// SM_STARTADDR_IIISB = (BYTE)(addr/0x0100);
// SM_STARTADDR_MSB = Media.Zone/2;
//
// //Sector byte count (DMA)
// SectByteCount = 0x20f;
// SM_BYTECNT_LO = (BYTE)SectByteCount;
// SM_CMD_CTRL3 = (SM_CMD_CTRL3 & 0xFC) | 0x20 | (BYTE)(SectByteCount/0x0100);
// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
// SM_FIFO_CTRL = (SM_APB08_MASK | SM_DMAEN_MASK | SM_DMA_DOWNSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
// else
// SM_FIFO_CTRL = (SM_APB32_MASK | SM_DMAEN_MASK | SM_DMA_DOWNSTREAM_MASK | SM_FIFOSHLDVLU_8_MASK);
//
// _Hw_D_EccRdReset();
// _Hw_D_EccRdStart();
//
// SM_CMD_CTRL1 = SM_CMD_PAGPRGM_TRUE;
// SM_CMD_CTRL1 = (SM_CMD_PAGPRGM_TRUE | SM_CMD_START_BIT);
//
// SectByteCount = 0x1ff;
// //SM_WriteDataWithDMA(fdoExt, buf, SectByteCount);
// //_WriteRedt_D_SsfdcBuf(redundant);
// len = 0x1000 - ((WORD)(buf) & 0x0FFF);
// if (len < 0x200)
// {
// SM_WriteDataWithDMA(fdoExt, buf, len-1);
// SM_WriteDataWithDMA(fdoExt, buf+len, SectByteCount-len);
// //ENE_Print("Read DMA !!! buf1 = %p, len = %x, buf2 = %p\n", buf, len, buf+len);
// }
// else
// SM_WriteDataWithDMA(fdoExt, buf, SectByteCount);
//
// //T1 = (ULONGLONG)buf & 0xFFFFFFFFFFFFF000;
// //T2 = ((ULONGLONG)buf + 0x1FF) & 0xFFFFFFFFFFFFF000;
// //if (T1 != T2)
// // ENE_Print("Ssfdc_D_WriteSect_DMA !!! buf = %p, T1 = %p, T2 = %p\n", buf, T1, T2);
// //if (T2-T1)
// //{
// // l1 = (WORD)(T2 - (ULONGLONG)buf);
// // SM_WriteDataWithDMA(fdoExt, buf, l1-1);
// // SM_WriteDataWithDMA(fdoExt, (PBYTE)T2, SectByteCount-l1);
// //}
// //else
// // SM_WriteDataWithDMA(fdoExt, buf, SectByteCount);
//
// if ( ((fdoExt->ChipID==READER_CB712)&&(fdoExt->RevID==CHIP_A)) || fdoExt->IsHibernate )
// {
// _WriteRedt_D_SsfdcBuf(redundant);
// }
// else
// {
// memcpy(Buffer, redundant, 0x10);
// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[0]);
// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[1]);
// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[2]);
// WRITE_PORT_DWORD(SM_REG_DATA, Buffer[3]);
// }
//
// while ( _Hw_D_ChkCardIn() )
// {
// if ((READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x10))
// {
// WRITE_PORT_BYTE(SM_REG_INT_STATUS, 0x10);
// break;
// }
// }
// _Hw_D_EccRdStop();
// _Hw_D_SetRdStandby();
//
// _Set_D_SsfdcWrStandby();
// _Set_D_SsfdcRdStandby();
// if (!_Hw_D_ChkCardIn())
// return(ERROR);
//
// return(SMSUCCESS);
//}
//
////----- Ssfdc_D_WriteSect_PIO() --------------------------------------------
//int Ssfdc_D_WriteSect_PIO(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
//{
// _Calc_D_ECCdata(buf);
// _Set_D_SsfdcWrCmd(WRDATA);
// _Set_D_SsfdcWrAddr(EVEN);
// _Start_D_SsfdcWrHwECC();
//
// _Write_D_SsfdcBuf(buf);
//
// _Load_D_SsfdcWrHwECC(EVEN);
// _Set_D_ECCdata(EVEN,redundant);
//
// _WriteRedt_D_SsfdcBuf(redundant);
//
// _Set_D_SsfdcWrCmd(WRITE);
//
// if (_Check_D_SsfdcBusy(BUSY_PROG))
// { _Reset_D_SsfdcErr(); return(ERROR); }
//
// _Set_D_SsfdcWrStandby();
// _Set_D_SsfdcRdStandby();
// return(SMSUCCESS);
//}
*/
//----- Ssfdc_D_WriteSectForCopy() -------------------------------------
int Ssfdc_D_WriteSectForCopy(struct us_data *us, BYTE *buf, BYTE *redundant)
{
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
int result;
//PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
//NTSTATUS ntStatus;
WORD addr;
//printk("SMILSUB --- Ssfdc_D_WriteSectForCopy\n");
result = ENE_LoadBinCode(us, SM_RW_PATTERN);
if (result != USB_STOR_XFER_GOOD)
{
......@@ -838,7 +454,6 @@ int Ssfdc_D_ReadRedtData(struct us_data *us, BYTE *redundant)
bcb->CDB[9] = 1;
buf = kmalloc(0x10, GFP_KERNEL);
//result = ENE_SendScsiCmd(us, FDIR_READ, redundant, 0);
result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
memcpy(redundant, buf, 0x10);
kfree(buf);
......@@ -854,8 +469,6 @@ int Ssfdc_D_WriteRedtData(struct us_data *us, BYTE *redundant)
{
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
int result;
//PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
//NTSTATUS ntStatus;
WORD addr;
result = ENE_LoadBinCode(us, SM_RW_PATTERN);
......@@ -890,347 +503,11 @@ int Ssfdc_D_WriteRedtData(struct us_data *us, BYTE *redundant)
//----- Ssfdc_D_CheckStatus() ------------------------------------------
int Ssfdc_D_CheckStatus(void)
{
// Driver
return(SMSUCCESS);
//_Set_D_SsfdcRdCmd(RDSTATUS);
//
//if (_Check_D_SsfdcStatus())
//{ _Set_D_SsfdcRdStandby(); return(ERROR); }
//
//_Set_D_SsfdcRdStandby();
//return(SMSUCCESS);
}
/*
////NAND Memory (SmartMedia) Control Subroutine for Read Data
////----- _Set_D_SsfdcRdCmd() --------------------------------------------
//void _Set_D_SsfdcRdCmd(BYTE cmd)
//{
// _Hw_D_SetRdCmd();
// _Hw_D_OutData(cmd);
// _Hw_D_SetRdData();
//}
//
////----- _Set_D_SsfdcRdAddr() -------------------------------------------
//void _Set_D_SsfdcRdAddr(BYTE add)
//{
// WORD addr;
// SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
// ADDRESS_T bb = (ADDRESS_T) &Media;
//
// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
// addr=addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
//
// //if ((Ssfdc.Attribute &MPS)==PS256) // for 256byte/page
// // addr=addr*2+(WORD)add;
//
// _Hw_D_SetRdAddr();
// _Hw_D_OutData(0x00);
// _Hw_D_OutData((BYTE)addr);
// _Hw_D_OutData((BYTE)(addr/0x0100));
//
// if ((Ssfdc.Attribute &MADC)==AD4CYC)
// _Hw_D_OutData((BYTE)(Media.Zone/2)); // Patch
//
// _Hw_D_SetRdData();
//}
//
////----- _Set_D_SsfdcRdChip() -------------------------------------------
//void _Set_D_SsfdcRdChip(void)
//{
// _Hw_D_SetRdAddr();
// _Hw_D_OutData(0x00);
// _Hw_D_SetRdData();
//}
//
////----- _Set_D_SsfdcRdStandby() ----------------------------------------
//void _Set_D_SsfdcRdStandby(void)
//{
// _Hw_D_SetRdStandby();
//}
//
////----- _Start_D_SsfdcRdHwECC() ----------------------------------------
//void _Start_D_SsfdcRdHwECC(void)
//{
//#ifdef HW_ECC_SUPPORTED
// _Hw_D_EccRdReset();
// _Hw_D_InData();
// _Hw_D_EccRdStart();
//#endif
//}
//
////----- _Stop_D_SsfdcRdHwECC() -----------------------------------------
//void _Stop_D_SsfdcRdHwECC(void)
//{
//#ifdef HW_ECC_SUPPORTED
// _Hw_D_EccRdStop();
//#endif
//}
//
////----- _Load_D_SsfdcRdHwECC() -----------------------------------------
//void _Load_D_SsfdcRdHwECC(BYTE add)
//{
//#ifdef HW_ECC_SUPPORTED
// _Hw_D_EccRdRead();
// //if (!(add==ODD && (Ssfdc.Attribute &MPS)==PS256))
// {
// EccBuf[0]=_Hw_D_InData();
// EccBuf[1]=_Hw_D_InData();
// EccBuf[2]=_Hw_D_InData();
// }
//
// //if (!(add==EVEN && (Ssfdc.Attribute &MPS)==PS256))
// {
// EccBuf[3]=_Hw_D_InData();
// EccBuf[4]=_Hw_D_InData();
// EccBuf[5]=_Hw_D_InData();
// }
//
// _Hw_D_EccRdStop();
//#endif
//}
//
////NAND Memory (SmartMedia) Control Subroutine for Write Data
//
////----- _Set_D_SsfdcWrCmd() -----------------------------------------
//void _Set_D_SsfdcWrCmd(BYTE cmd)
//{
// _Hw_D_SetWrCmd();
// _Hw_D_OutData(cmd);
// _Hw_D_SetWrData();
//}
//
////----- _Set_D_SsfdcWrAddr() -----------------------------------------
//void _Set_D_SsfdcWrAddr(BYTE add)
//{
// WORD addr;
// SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
// ADDRESS_T bb = (ADDRESS_T) &Media;
//
// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
// addr=addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
//
// //if ((Ssfdc.Attribute &MPS)==PS256) // for 256byte/page
// // addr=addr*2+(WORD)add;
//
// _Hw_D_SetWrAddr();
// _Hw_D_OutData(0x00);
// _Hw_D_OutData((BYTE)addr);
// _Hw_D_OutData((BYTE)(addr/0x0100));
//
// if ((Ssfdc.Attribute &MADC)==AD4CYC)
// _Hw_D_OutData((BYTE)(Media.Zone/2)); // Patch
//
// _Hw_D_SetWrData();
//}
//
////----- _Set_D_SsfdcWrBlock() -----------------------------------------
//void _Set_D_SsfdcWrBlock(void)
//{
// WORD addr;
// SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
// ADDRESS_T bb = (ADDRESS_T) &Media;
//
// addr=(WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
// addr=addr*(WORD)Ssfdc.MaxSectors;
//
// //if ((Ssfdc.Attribute &MPS)==PS256) // for 256byte/page
// // addr=addr*2;
//
// _Hw_D_SetWrAddr();
// _Hw_D_OutData((BYTE)addr);
// _Hw_D_OutData((BYTE)(addr/0x0100));
//
// if ((Ssfdc.Attribute &MADC)==AD4CYC)
// _Hw_D_OutData((BYTE)(Media.Zone/2)); // Patch
//
// _Hw_D_SetWrData();
//}
//
////----- _Set_D_SsfdcWrStandby() -----------------------------------------
//void _Set_D_SsfdcWrStandby(void)
//{
// _Hw_D_SetWrStandby();
//}
//
////----- _Start_D_SsfdcWrHwECC() -----------------------------------------
//void _Start_D_SsfdcWrHwECC(void)
//{
//#ifdef HW_ECC_SUPPORTED
// _Hw_D_EccWrReset();
// _Hw_D_InData();
// _Hw_D_EccWrStart();
//#endif
//}
//
////----- _Load_D_SsfdcWrHwECC() -----------------------------------------
//void _Load_D_SsfdcWrHwECC(BYTE add)
//{
//#ifdef HW_ECC_SUPPORTED
// _Hw_D_EccWrRead();
// //if (!(add==ODD && (Ssfdc.Attribute &MPS)==PS256))
// {
// EccBuf[0]=_Hw_D_InData();
// EccBuf[1]=_Hw_D_InData();
// EccBuf[2]=_Hw_D_InData();
// }
//
// //if (!(add==EVEN && (Ssfdc.Attribute &MPS)==PS256))
// {
// EccBuf[3]=_Hw_D_InData();
// EccBuf[4]=_Hw_D_InData();
// EccBuf[5]=_Hw_D_InData();
// }
//
// _Hw_D_EccWrStop();
//#endif
//}
//
////NAND Memory (SmartMedia) Control Subroutine
////----- _Check_D_SsfdcBusy() -------------------------------------------
//int _Check_D_SsfdcBusy(WORD time)
//{
// WORD count = 0;
//
// do {
// if (!_Hw_D_ChkBusy())
// return(SMSUCCESS);
// EDelay(100);
// count++;
// } while (count<=time);
//
// return(ERROR);
//}
//
////----- _Check_D_SsfdcStatus() -----------------------------------------
//int _Check_D_SsfdcStatus(void)
//{
// if (_Hw_D_InData() & WR_FAIL)
// return(ERROR);
//
// return(SMSUCCESS);
//}
//
//// For 712
////----- _Reset_D_SsfdcErr() -----------------------------------------
//void _Reset_D_SsfdcErr(void)
//{
// WORD count = 0;
//
// _Hw_D_SetRdCmd();
// _Hw_D_OutData(RST_CHIP);
// _Hw_D_SetRdData();
//
// do {
// if (!_Hw_D_ChkBusy())
// break;
// EDelay(100);
// count++;
// } while (count<=BUSY_RESET);
//
// _Hw_D_SetRdStandby();
//}
//
////NAND Memory (SmartMedia) Buffer Data Xfer Subroutine
////----- SM_ReadDataWithDMA() -----------------------------------------
//void SM_ReadDataWithDMA(PFDO_DEVICE_EXTENSION fdoExt, BYTE *databuf, WORD SectByteCount)
//{
// PHYSICAL_ADDRESS Addr;
// LARGE_INTEGER ptimeout ;
//
// KeClearEvent(&fdoExt->SM_DMADoneEvent);
//
// Addr = MmGetPhysicalAddress(databuf);
//
// WRITE_PORT_DWORD(SM_DMA_ADDR_REG, (DWORD)Addr.LowPart);
// WRITE_PORT_BYTE(SM_DMA_DATA_CTRL, 0);
// WRITE_PORT_WORD(SM_DMA_BYTE_COUNT_REG, SectByteCount);
//
// while ( _Hw_D_ChkCardIn() )
// {
// if ((READ_PORT_BYTE(SM_REG_FIFO_STATUS) & 0x80))
// break;
// }
// if (!_Hw_D_ChkCardIn()) return;
// WRITE_PORT_BYTE(SM_DMA_DATA_CTRL, 0x01);
//
// ptimeout.QuadPart = 2000 * (-10000); // 2 sec
// KeWaitForSingleObject(&fdoExt->SM_DMADoneEvent, Executive, KernelMode, FALSE, &ptimeout);
// _Hw_D_SetDMAIntMask();
//}
//
////----- SM_WriteDataWithDMA() -----------------------------------------
//void SM_WriteDataWithDMA(PFDO_DEVICE_EXTENSION fdoExt, BYTE *databuf, WORD SectByteCount)
//{
// PHYSICAL_ADDRESS Addr;
// LARGE_INTEGER ptimeout ;
//
// KeClearEvent(&fdoExt->SM_DMADoneEvent);
//
// Addr = MmGetPhysicalAddress(databuf);
//
// WRITE_PORT_DWORD(SM_DMA_ADDR_REG, (DWORD)Addr.LowPart);
// WRITE_PORT_BYTE(SM_DMA_DATA_CTRL, 2);
// WRITE_PORT_WORD(SM_DMA_BYTE_COUNT_REG, SectByteCount);
//
// while ( _Hw_D_ChkCardIn() )
// {
// if ((READ_PORT_BYTE(SM_REG_FIFO_STATUS) & 0x40))
// break;
// }
// if (!_Hw_D_ChkCardIn()) return;
// WRITE_PORT_BYTE(SM_DMA_DATA_CTRL, 0x03);
//
// ptimeout.QuadPart = 2000 * (-10000); // 2 sec
// KeWaitForSingleObject(&fdoExt->SM_DMADoneEvent, Executive, KernelMode, FALSE, &ptimeout);
// _Hw_D_SetDMAIntMask();
//}
//
////----- _Read_D_SsfdcBuf() -----------------------------------------
//void _Read_D_SsfdcBuf(BYTE *databuf)
//{
// int i;
//
// //for(i=0x0000;i<(((Ssfdc.Attribute &MPS)==PS256)?0x0100:0x0200);i++)
// for(i=0; i<0x200; i++)
// *databuf++ =_Hw_D_InData();
//}
//
////----- _Write_D_SsfdcBuf() -----------------------------------------
//void _Write_D_SsfdcBuf(BYTE *databuf)
//{
// int i;
//
// //for(i=0x0000;i<(((Ssfdc.Attribute &MPS)==PS256)?0x0100:0x0200);i++)
// for(i=0; i<0x200; i++)
// _Hw_D_OutData(*databuf++);
//}
//
////----- _Read_D_SsfdcByte() -----------------------------------------
//void _Read_D_SsfdcByte(BYTE *databuf)
//{
// *databuf=(BYTE)_Hw_D_InData();
//}
//
////----- _ReadRedt_D_SsfdcBuf() -----------------------------------------
//void _ReadRedt_D_SsfdcBuf(BYTE *redundant)
//{
// char i;
//
// //for(i=0x00;i<(((Ssfdc.Attribute &MPS)==PS256)?0x08:0x10);i++)
// for(i=0; i<0x10; i++)
// redundant[i] =_Hw_D_InData();
//}
//
////----- _WriteRedt_D_SsfdcBuf() -----------------------------------------
//void _WriteRedt_D_SsfdcBuf(BYTE *redundant)
//{
// char i;
//
// //for(i=0x00;i<(((Ssfdc.Attribute &MPS)==PS256)?0x08:0x10);i++)
// for(i=0; i<0x10; i++)
// _Hw_D_OutData(*redundant++);
//}
*/
//SmartMedia ID Code Check & Mode Set Subroutine
//----- Set_D_SsfdcModel() ---------------------------------------------
int Set_D_SsfdcModel(BYTE dcode)
......@@ -1364,118 +641,10 @@ BYTE _Check_D_DevCode(BYTE dcode)
default: return(NOSSFDC);
}
}
/*
////SmartMedia Power Control Subroutine
////----- Cnt_D_Reset() ----------------------------------------------
//void Cnt_D_Reset(void)
//{
// _Hw_D_LedOff();
// _Hw_D_SetRdStandby();
// _Hw_D_VccOff();
//}
//
////----- Cnt_D_PowerOn() ----------------------------------------------
//int Cnt_D_PowerOn(void)
//{
// // No support 5V.
// _Hw_D_EnableVcc3VOn(); // Set SM_REG_CTRL_5 Reg. to 3V
// _Hw_D_VccOn();
// _Hw_D_SetRdStandby();
// _Wait_D_Timer(TIME_PON);
//
// if (_Hw_D_ChkPower())
// {
// _Hw_D_EnableOB(); // Set SM_REG_CTRL_5 Reg. to 0x83
// return(SMSUCCESS);
// }
//
// _Hw_D_SetVccOff();
// return(ERROR);
//}
//
////----- Cnt_D_PowerOff() ----------------------------------------------
//void Cnt_D_PowerOff(void)
//{
// _Hw_D_SetRdStandby();
// _Hw_D_SetVccOff();
// _Hw_D_VccOff();
//}
//
////----- Cnt_D_LedOn() ----------------------------------------------
//void Cnt_D_LedOn(void)
//{
// _Hw_D_LedOn();
//}
//
////----- Cnt_D_LedOff() ----------------------------------------------
//void Cnt_D_LedOff(void)
//{
// _Hw_D_LedOff();
//}
//
////----- Check_D_CntPower() ----------------------------------------------
//int Check_D_CntPower(void)
//{
// if (_Hw_D_ChkPower())
// return(SMSUCCESS); // Power On
//
// return(ERROR); // Power Off
//}
//
////----- Check_D_CardExist() ----------------------------------------------
//int Check_D_CardExist(void)
//{
// char i,j,k;
//
// if (!_Hw_D_ChkStatus()) // Not Status Change
// if (_Hw_D_ChkCardIn())
// return(SMSUCCESS); // Card exist in Slot
//
// for(i=0,j=0,k=0; i<16; i++) {
// if (_Hw_D_ChkCardIn()) // Status Change
// {
// j++; k=0;
// }
// else
// {
// j=0; k++;
// }
//
// if (j>3)
// return(SMSUCCESS); // Card exist in Slot
// if (k>3)
// return(ERROR); // NO Card exist in Slot
//
// _Wait_D_Timer(TIME_CDCHK);
// }
//
// return(ERROR);
//}
//
////----- Check_D_CardStsChg() ----------------------------------------------
//int Check_D_CardStsChg(void)
//{
// if (_Hw_D_ChkStatus())
// return(ERROR); // Status Change
//
// return(SMSUCCESS); // Not Status Change
//}
//
////----- Check_D_SsfdcWP() ----------------------------------------------
//int Check_D_SsfdcWP(void)
//{ // ERROR: WP, SMSUCCESS: Not WP
// char i;
//
// for(i=0; i<8; i++) {
// if (_Hw_D_ChkWP())
// return(ERROR);
// _Wait_D_Timer(TIME_WPCHK);
// }
//
// return(SMSUCCESS);
//}
//
*/
//SmartMedia ECC Control Subroutine
//----- Check_D_ReadError() ----------------------------------------------
int Check_D_ReadError(BYTE *redundant)
......@@ -1521,81 +690,6 @@ void Set_D_RightECC(BYTE *redundant)
{
// Driver ECC Check
return;
//StringCopy((char *)(redundant+0x0D),(char *)EccBuf,3);
//StringCopy((char *)(redundant+0x08),(char *)(EccBuf+0x03),3);
}
/*
////----- _Calc_D_ECCdata() ----------------------------------------------
//void _Calc_D_ECCdata(BYTE *buf)
//{
//#ifdef HW_ECC_SUPPORTED
//#else
// _Calculate_D_SwECC(buf,EccBuf);
// buf+=0x0100;
// _Calculate_D_SwECC(buf,EccBuf+0x03);
//#endif
//}
//
////----- _Set_D_ECCdata() ----------------------------------------------
//void _Set_D_ECCdata(BYTE add,BYTE *redundant)
//{
// //if (add==EVEN && (Ssfdc.Attribute &MPS)==PS256)
// // return;
//
// // for 256byte/page
// StringCopy((char *)(redundant+0x0D),(char *)EccBuf,3);
// StringCopy((char *)(redundant+0x08),(char *)(EccBuf+0x03),3);
//}
*/
/*
//----- SM_ReadBlock() ---------------------------------------------
int SM_ReadBlock(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf,BYTE *redundant)
{
PBULK_CBW pBulkCbw = fdoExt->pBulkCbw;
NTSTATUS ntStatus;
WORD addr;
ENE_LoadBinCode(fdoExt, SM_RW_PATTERN);
addr = (WORD)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
addr = addr*(WORD)Ssfdc.MaxSectors+Media.Sector;
// Read sect data
RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
pBulkCbw->dCBWSignature = CBW_SIGNTURE;
pBulkCbw->bCBWLun = CBW_LUN;
pBulkCbw->dCBWDataTransferLength = 0x200;
pBulkCbw->bmCBWFlags = 0x80;
pBulkCbw->CBWCb[0] = 0xF1;
pBulkCbw->CBWCb[1] = 0x02;
pBulkCbw->CBWCb[4] = (BYTE)addr;
pBulkCbw->CBWCb[3] = (BYTE)(addr/0x0100);
pBulkCbw->CBWCb[2] = Media.Zone/2;
ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_READ, buf);
if (!NT_SUCCESS(ntStatus))
return(ERROR);
// Read redundant
RtlZeroMemory(pBulkCbw, sizeof(struct _BULK_CBW));
pBulkCbw->dCBWSignature = CBW_SIGNTURE;
pBulkCbw->bCBWLun = CBW_LUN;
pBulkCbw->dCBWDataTransferLength = 0x10;
pBulkCbw->bmCBWFlags = 0x80;
pBulkCbw->CBWCb[0] = 0xF1;
pBulkCbw->CBWCb[1] = 0x03;
pBulkCbw->CBWCb[4] = (BYTE)addr;
pBulkCbw->CBWCb[3] = (BYTE)(addr/0x0100);
pBulkCbw->CBWCb[2] = Media.Zone/2;
pBulkCbw->CBWCb[5] = 0;
pBulkCbw->CBWCb[6] = 1;
ntStatus = ENE_SendScsiCmd(fdoExt, FDIR_READ, redundant);
if (!NT_SUCCESS(ntStatus))
return(ERROR);
return(SMSUCCESS);
}*/
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7