📄 smilsub.c

📁 ertfs文件系统里面既有完整ucos程序
💻 C
📖 第 1 页 / 共 2 页
字号:
上一页 12
	_Hw$SetRdCmd();
	_Hw$OutData(cmd);
	_Hw$SetRdData();
}
static void _Set$SsfdcRdAddr(unsigned char add)
{
	unsigned short addr;
	addr=(unsigned short)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
	addr=addr*(unsigned short)Ssfdc.MaxSectors+Media.Sector;
	if((Ssfdc.Attribute &MPS)==PS256) /* for 256byte/page */
		addr=addr*2+(unsigned short)add;
	/*-----------------------------------------------*/
	_Hw$SetRdAddr();
	_Hw$OutData(0x00);
	_Hw$OutData((unsigned char)addr);
	_Hw$OutData((unsigned char)(addr/0x0100));
	if((Ssfdc.Attribute &MADC)==AD4CYC)
		_Hw$OutData((unsigned char)(Media.Zone/2)); /* Patch */
	_Hw$SetRdData();
}
static void _Set$SsfdcRdChip(void)
{
	_Hw$SetRdAddr();
	_Hw$OutData(0x00);
	_Hw$SetRdData();
}
static void _Set$SsfdcRdStandby(void)
{
	_Hw$SetRdStandby();
}
/***************************************************************************/
static void _Start$SsfdcRdHwECC(void)
{
#ifdef HW_ECC_SUPPORTED /***************************************************/
	_Hw$EccRdReset();
	_Hw$InData();
	_Hw$EccRdStart();
#endif /*******************************************************************/
}
static void _Stop$SsfdcRdHwECC(void)
{
#ifdef HW_ECC_SUPPORTED /***************************************************/
	_Hw$EccRdStop();
#endif /*******************************************************************/
}
static void _Load$SsfdcRdHwECC(unsigned char add)
{
#ifdef HW_ECC_SUPPORTED /***************************************************/
	_Hw$EccRdRead();
	if(! (add==ODD && (Ssfdc.Attribute &MPS)==PS256)) {
		EccBuf[0]=_Hw$InData();
		EccBuf[1]=_Hw$InData();
		EccBuf[2]=_Hw$InData();
	}
	if(! (add==EVEN && (Ssfdc.Attribute &MPS)==PS256)) {
		EccBuf[3]=_Hw$InData();
		EccBuf[4]=_Hw$InData();
		EccBuf[5]=_Hw$InData();
	}
	_Hw$EccRdStop();
#endif /*******************************************************************/
}
/***************************************************************************
NAND Memory (SmartMedia) Control Subroutine for Write Data
***************************************************************************/
static void _Set$SsfdcWrCmd(unsigned char cmd)
{
	_Hw$SetWrCmd();
	_Hw$OutData(cmd);
	_Hw$SetWrData();
}
static void _Set$SsfdcWrAddr(unsigned char add)
{
	unsigned short addr;
	addr=(unsigned short)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
	addr=addr*(unsigned short)Ssfdc.MaxSectors+Media.Sector;
	if((Ssfdc.Attribute &MPS)==PS256) /* for 256byte/page */
		addr=addr*2+(unsigned short)add;
	/*-----------------------------------------------*/
	_Hw$SetWrAddr();
	_Hw$OutData(0x00);
	_Hw$OutData((unsigned char)addr);
	_Hw$OutData((unsigned char)(addr/0x0100));
	if((Ssfdc.Attribute &MADC)==AD4CYC)
		_Hw$OutData((unsigned char)(Media.Zone/2)); /* Patch */
	_Hw$SetWrData();
}
static void _Set$SsfdcWrBlock(void)
{
	unsigned short addr;
	addr=(unsigned short)Media.Zone*Ssfdc.MaxBlocks+Media.PhyBlock;
	addr=addr*(unsigned short)Ssfdc.MaxSectors;
	if((Ssfdc.Attribute &MPS)==PS256) /* for 256byte/page */
		addr=addr*2;
	/*-----------------------------------------------*/
	_Hw$SetWrAddr();
	_Hw$OutData((unsigned char)addr);
	_Hw$OutData((unsigned char)(addr/0x0100));
	if((Ssfdc.Attribute &MADC)==AD4CYC)
		_Hw$OutData((unsigned char)(Media.Zone/2)); /* Patch */
	_Hw$SetWrData();
}
static void _Set$SsfdcWrStandby(void)
{
	_Hw$SetWrStandby();
}
/***************************************************************************/
static void _Start$SsfdcWrHwECC(void)
{
#ifdef HW_ECC_SUPPORTED /***************************************************/
	_Hw$EccWrReset();
	_Hw$InData();
	_Hw$EccWrStart();
#endif /*******************************************************************/
}
static void _Load$SsfdcWrHwECC(unsigned char add)
{
#ifdef HW_ECC_SUPPORTED /***************************************************/
	_Hw$EccWrRead();
	if(! (add==ODD && (Ssfdc.Attribute &MPS)==PS256)) {
		EccBuf[0]=_Hw$InData();
		EccBuf[1]=_Hw$InData();
		EccBuf[2]=_Hw$InData();
	}
	if(! (add==EVEN && (Ssfdc.Attribute &MPS)==PS256)) {
		EccBuf[3]=_Hw$InData();
		EccBuf[4]=_Hw$InData();
		EccBuf[5]=_Hw$InData();
	}
	_Hw$EccWrStop();
#endif /*******************************************************************/
}
/***************************************************************************
NAND Memory (SmartMedia) Control Subroutine
***************************************************************************/
static int _Check$SsfdcBusy(unsigned short time)
{
	while(!_Hw$ChkBusy());
	return(SUCCESS);
	/*
	_Set$Timer(time);
	while(_Check$Timer())
		if(! _Hw$ChkBusy()) {
			_Stop$Timer();
			return(SUCCESS);
		}
	_Stop$Timer();
	return(ERROR);
	*/
}
static int _Check$SsfdcStatus(void)
{
	if(_Hw$InData() &WR_FAIL) return(ERROR);
	return(SUCCESS);
}
static void _Reset$SsfdcErr(void)
{
	_Hw$SetRdCmd();
	_Hw$OutData(RST_CHIP);
	_Hw$SetRdData();
	_Set$Timer(BUSY_RESET);
	while(_Check$Timer())
		if(! _Hw$ChkBusy()) break;
	_Stop$Timer();
	_Hw$SetRdStandby();
}
/***************************************************************************
NAND Memory (SmartMedia) Buffer Data Xfer Subroutine
***************************************************************************/
static void _Read$SsfdcBuf(unsigned char *databuf)
{
	int i;
	for(i=0x0000;i<(((Ssfdc.Attribute &MPS)==PS256)?0x0100:0x0200);i++)
		*databuf++ =_Hw$InData();
}
static void _Write$SsfdcBuf(unsigned char *databuf)
{
	int i;
	for(i=0x0000;i<(((Ssfdc.Attribute &MPS)==PS256)?0x0100:0x0200);i++)
		_Hw$OutData(*databuf++);
}
static void _Read$SsfdcByte(unsigned char *databuf)
{
	*databuf=(unsigned char)_Hw$InData();
}
static void _ReadRedt$SsfdcBuf(unsigned char *redundant)
{
	char i;
	for(i=0x00;i<(((Ssfdc.Attribute &MPS)==PS256)?0x08:0x10);i++)
		redundant[i] =_Hw$InData();
}
static void _WriteRedt$SsfdcBuf(unsigned char *redundant)
{
	char i;
	for(i=0x00;i<(((Ssfdc.Attribute &MPS)==PS256)?0x08:0x10);i++)
		_Hw$OutData(*redundant++);
}
/***************************************************************************
SmartMedia ID Code Check & Mode Set Subroutine
***************************************************************************/
int Set$SsfdcModel(unsigned char dcode)
{
	switch(_Check$DevCode(dcode)) {
	case SSFDC1MB:
		Ssfdc.Model = SSFDC1MB;
		Ssfdc.Attribute = FLASH | AD3CYC | BS16 | PS256;
		Ssfdc.MaxZones = 1;
		Ssfdc.MaxBlocks = 256;
		Ssfdc.MaxLogBlocks = 250;
		Ssfdc.MaxSectors = 8;
		break;
	case SSFDC2MB:
		Ssfdc.Model = SSFDC2MB;
		Ssfdc.Attribute = FLASH | AD3CYC | BS16 | PS256;
		Ssfdc.MaxZones = 1;
		Ssfdc.MaxBlocks = 512;
		Ssfdc.MaxLogBlocks = 500;
		Ssfdc.MaxSectors = 8;
		break;
	case SSFDC4MB:
		Ssfdc.Model = SSFDC4MB;
		Ssfdc.Attribute = FLASH | AD3CYC | BS16 | PS512;
		Ssfdc.MaxZones = 1;
		Ssfdc.MaxBlocks = 512;
		Ssfdc.MaxLogBlocks = 500;
		Ssfdc.MaxSectors = 16;
		break;
	case SSFDC8MB:
		Ssfdc.Model = SSFDC8MB;
		Ssfdc.Attribute = FLASH | AD3CYC | BS16 | PS512;
		Ssfdc.MaxZones = 1;
		Ssfdc.MaxBlocks = 1024;
		Ssfdc.MaxLogBlocks = 1000;
		Ssfdc.MaxSectors = 16;
		break;
	case SSFDC16MB:
		Ssfdc.Model = SSFDC16MB;
		Ssfdc.Attribute = FLASH | AD3CYC | BS32 | PS512;
		Ssfdc.MaxZones = 1;
		Ssfdc.MaxBlocks = 1024;
		Ssfdc.MaxLogBlocks = 1000;
		Ssfdc.MaxSectors = 32;
		break;
	case SSFDC32MB:
		Ssfdc.Model = SSFDC32MB;
		Ssfdc.Attribute = FLASH | AD3CYC | BS32 | PS512;
		Ssfdc.MaxZones = 2;
		Ssfdc.MaxBlocks = 1024;
		Ssfdc.MaxLogBlocks = 1000;
		Ssfdc.MaxSectors = 32;
		break;
	case SSFDC64MB:
		Ssfdc.Model = SSFDC64MB;
		Ssfdc.Attribute = FLASH | AD4CYC | BS32 | PS512;
		Ssfdc.MaxZones = 4;
		Ssfdc.MaxBlocks = 1024;
		Ssfdc.MaxLogBlocks = 1000;
		Ssfdc.MaxSectors = 32;
		break;
	case SSFDC128MB:
		Ssfdc.Model = SSFDC128MB;
		Ssfdc.Attribute = FLASH | AD4CYC | BS32 | PS512;
		Ssfdc.MaxZones = 8;
		Ssfdc.MaxBlocks = 1024;
		Ssfdc.MaxLogBlocks = 1000;
		Ssfdc.MaxSectors = 32;
		break;
	default:
		Ssfdc.Model = NOSSFDC;
		return(ERROR);
	}
	return(SUCCESS);
}
/***************************************************************************/
static unsigned char _Check$DevCode(unsigned char dcode)
{
	switch(dcode){
	case 0x6E:
	case 0xE8:
	case 0xEC: return(SSFDC1MB); /* 8Mbit (1M) NAND */
	case 0x64:
	case 0xEA: return(SSFDC2MB); /* 16Mbit (2M) NAND */
	case 0x6B:
	case 0xE3:
	case 0xE5: return(SSFDC4MB); /* 32Mbit (4M) NAND */
	case 0xE6: return(SSFDC8MB); /* 64Mbit (8M) NAND */
	case 0x73: return(SSFDC16MB); /*128Mbit (16M)NAND */
	case 0x75: return(SSFDC32MB); /*256Mbit (32M)NAND */
	case 0x76: return(SSFDC64MB); /*512Mbit (64M)NAND */
	case 0x79: return(SSFDC128MB); /* 1Gbit(128M)NAND */
	default: return(NOSSFDC);
	}
}
/***************************************************************************
SmartMedia Power Controll Subroutine
***************************************************************************/
void Cnt$Reset(void)
{
	_Hw$LedOff();
	_Hw$SetRdStandby();
	_Hw$VccOff();
}
int Cnt$PowerOn(void)
{
	_Hw$VccOn();
	_Hw$SetRdStandby();
	_Wait$Timer(TIME_PON);
	if(_Hw$ChkPower())
		return(SUCCESS);
	_Hw$VccOff();
	return(ERROR);
}
void Cnt$PowerOff(void)
{
	_Hw$SetRdStandby();
	_Hw$VccOff();
}
/***************************************************************************/
void Cnt$LedOn(void)
{
	_Hw$LedOn();
}
void Cnt$LedOff(void)
{
	_Hw$LedOff();
}
/***************************************************************************/
int Check$CntPower(void)
{
	if(_Hw$ChkPower())
		return(SUCCESS); /* Power On */
	return(ERROR); /* Power Off */
}
int Check$CardExist(void)
{
	char i,j,k;
	if(! _Hw$ChkStatus()) /***** Not Status Change *****/
		if(_Hw$ChkCardIn()) return(SUCCESS); /* Card exist in Slot */
	for(i=0,j=0,k=0; i<16; i++) {
		if(_Hw$ChkCardIn()) /***** Status Change *****/
			{ j++; k=0; }
		else { j=0; k++; }
		if(j>3) return(SUCCESS); /* Card exist in Slot */
		if(k>3) return(ERROR); /* NO Card exist in Slot */
		_Wait$Timer(TIME_CDCHK);
	}
	return(ERROR);
}
int Check$CardStsChg(void)
{
	if(_Hw$ChkStatus())
		return(ERROR); /* Status Change */
	return(SUCCESS); /* Not Status Change */
}
int Check$SsfdcWP(void)
{ /* ERROR: WP, SUCCESS: Not WP */
	char i;
	for(i=0; i<8; i++) {
		if(_Hw$ChkWP())
			return(ERROR);
		_Wait$Timer(TIME_WPCHK);
	}
	return(SUCCESS);
}
/***************************************************************************
SmartMedia ECC Controll Subroutine
***************************************************************************/
int Check$ReadError(unsigned char *redundant)
{
	if(! StringCmp((char *)(redundant+0x0D),(char *)EccBuf,3))
		if(! StringCmp((char *)(redundant+0x08),(char *)(EccBuf+0x03),3))
			return(SUCCESS);
	return(ERROR);
}
int Check$Correct(unsigned char *buf,unsigned char *redundant)
{
	if(StringCmp((char *)(redundant+0x0D),(char *)EccBuf,3))
		if(_Correct$SwECC(buf,redundant+0x0D,EccBuf))
			return(ERROR);
	buf+=0x100;
	if(StringCmp((char *)(redundant+0x08),(char *)(EccBuf+0x03),3))
		if(_Correct$SwECC(buf,redundant+0x08,EccBuf+0x03))
			return(ERROR);
	return(SUCCESS);
}
int Check$CISdata(unsigned char *buf, unsigned char *redundant)
{
	static unsigned char cis[]={ 0x01,0x03,0xD9,0x01,0xFF,0x18,0x02,0xDF,0x01,0x20 };
	if(! StringCmp((char *)(redundant+0x0D),(char *)EccBuf,3))
		return(StringCmp((char *)buf,(char *)cis,10));
	if(! _Correct$SwECC(buf,redundant+0x0D,EccBuf))
		return(StringCmp((char *)buf,(char *)cis,10));
	buf+=0x100;
	if(! StringCmp((char *)(redundant+0x08),(char *)(EccBuf+0x03),3))
		return(StringCmp((char *)buf,(char *)cis,10));
	if(! _Correct$SwECC(buf,redundant+0x08,EccBuf+0x03))
		return(StringCmp((char *)buf,(char *)cis,10));
	return(ERROR);
}
void Set$RightECC(unsigned char *redundant)
{
	StringCopy((char *)(redundant+0x0D),(char *)EccBuf,3);
	StringCopy((char *)(redundant+0x08),(char *)(EccBuf+0x03),3);
}
/***************************************************************************/
static void _Calc$ECCdata(unsigned char *buf)
{
#ifdef HW_ECC_SUPPORTED /***************************************************/
#else /*******************************************************************/
	_Calculate$SwECC(buf,EccBuf);
	buf+=0x0100;
	_Calculate$SwECC(buf,EccBuf+0x03);
#endif /*******************************************************************/
}
static void _Set$ECCdata(unsigned char add,unsigned char *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);
}
上一页 12
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -