smilmain.c

ertfs文件系统里面既有完整ucos程序

			ReadBlock=block;
			Media.Sector=sect;
			Media.PhyBlock=WriteBlock;
			return(ERROR);
		}
		if(Release$ReadBlock()) return(ERROR);
		SectCopyMode=mode;
		ReadBlock=block;
		Media.Sector=sect;
		Media.PhyBlock=WriteBlock;
		return(SUCCESS);
}
/***************************************************************************
SmartMedia Physical Block Assign/Release Subroutine
***************************************************************************/
int Assign$WriteBlock(void)
{
	ReadBlock=Media.PhyBlock;
	for(WriteBlock=AssignStart[Media.Zone]; WriteBlock<Ssfdc.MaxBlocks; WriteBlock++)
		if(! Chk$Bit(Assign[Media.Zone],WriteBlock)) {
			Set$Bit(Assign[Media.Zone],WriteBlock);
			AssignStart[Media.Zone]=WriteBlock+1;
			Media.PhyBlock=WriteBlock;
			SectCopyMode=REQ_ERASE;
			return(SUCCESS);
		}
	for(WriteBlock=0; WriteBlock<AssignStart[Media.Zone]; WriteBlock++)
		if(! Chk$Bit(Assign[Media.Zone],WriteBlock)) {
			Set$Bit(Assign[Media.Zone],WriteBlock);
			AssignStart[Media.Zone]=WriteBlock+1;
			Media.PhyBlock=WriteBlock;
			SectCopyMode=REQ_ERASE;
			return(SUCCESS);
		}
	WriteBlock=NO_ASSIGN;
	ErrCode=ERR_WriteFault;
	return(ERROR);
}
/***************************************************************************/
int Release$ReadBlock(void)
{
	unsigned int mode;
	mode=SectCopyMode;
	SectCopyMode=COMPLETED;
	if(mode==COMPLETED) return(SUCCESS);
	Log2Phy[Media.Zone][Media.LogBlock]=WriteBlock;
	Media.PhyBlock=ReadBlock;
	if(Media.PhyBlock==NO_ASSIGN)
	{ Media.PhyBlock=WriteBlock; return(SUCCESS); }
	if(mode==REQ_ERASE) {
		if(Erase$PhyOneBlock()) {
			if(ErrCode==ERR_HwError) return(ERROR);
			if(MarkFail$PhyOneBlock()) return(ERROR);
		} else Clr$Bit(Assign[Media.Zone],Media.PhyBlock);
	} else if(MarkFail$PhyOneBlock()) return(ERROR);
	Media.PhyBlock=WriteBlock;
	return(SUCCESS);
}
int Release$WriteBlock(void)
{
	SectCopyMode=COMPLETED;
	Media.PhyBlock=WriteBlock;
	if(MarkFail$PhyOneBlock()) return(ERROR);
	Media.PhyBlock=ReadBlock;
	return(SUCCESS);
}
/***************************************************************************
SmartMedia Physical Sector Data Copy Subroutine
***************************************************************************/
static int Copy$PhyOneSect(void)
{
	int i;
	unsigned int err, retry;
	if(ReadBlock!=NO_ASSIGN) {
		Media.PhyBlock=ReadBlock;
		for(retry=0; retry<2; retry++) {
			if(retry!=0) {
				Ssfdc$Reset();
				if(Ssfdc$ReadCisSect(WorkBuf,WorkRedund))
					{ ErrCode=ERR_HwError; MediaChange=ERROR; return(ERROR); }
				if(Check$CISdata(WorkBuf,WorkRedund))
					{ ErrCode=ERR_HwError; MediaChange=ERROR; return(ERROR); }
			}
			if(Ssfdc$ReadSect(WorkBuf,WorkRedund))
				{ ErrCode=ERR_HwError; MediaChange=ERROR; return(ERROR); }
			if(Check$DataStatus(WorkRedund))
				{ err=ERROR; break; }
			if(! Check$ReadError(WorkRedund))
				{ err=SUCCESS; break; }
			if(! Check$Correct(WorkBuf,WorkRedund))
				{ err=SUCCESS; break; }
			err=ERROR;
			SectCopyMode=REQ_FAIL;
		}
	} else {
		err=SUCCESS;
		for(i=0; i<SECTSIZE; i++)
			WorkBuf[i]=DUMMY_DATA;
		Clr$RedundantData(WorkRedund);
	}
	Set$LogBlockAddr(WorkRedund);
	if(err==ERROR) {
		Set$RightECC(WorkRedund);
		Set$DataStaus(WorkRedund);
	}
	Media.PhyBlock=WriteBlock;
	if(Ssfdc$WriteSectForCopy(WorkBuf,WorkRedund))
		{ ErrCode=ERR_HwError; MediaChange=ERROR; return(ERROR); }
	if(Ssfdc$CheckStatus())
		{ ErrCode=ERR_WriteFault; return(ERROR); }
	Media.PhyBlock=ReadBlock;
	return(SUCCESS);
}
/***************************************************************************
SmartMedia Physical Sector Read/Write/Erase Subroutine
***************************************************************************/
static int Read$PhyOneSect(unsigned char *buf)
{
	int i;
	unsigned int retry;
	if(Media.PhyBlock==NO_ASSIGN) {
		for(i=0; i<SECTSIZE; i++)
			*buf++=DUMMY_DATA;
		return(SUCCESS);
	}
	for(retry=0; retry<2; retry++) {
		if(retry!=0) {
			Ssfdc$Reset();
			if(Ssfdc$ReadCisSect(WorkBuf,WorkRedund))
				{ ErrCode=ERR_HwError; MediaChange=ERROR; return(ERROR); }
			if(Check$CISdata(WorkBuf,WorkRedund))
				{ ErrCode=ERR_HwError; MediaChange=ERROR; return(ERROR); }
		}
		if(Ssfdc$ReadSect(buf,Redundant))
			{ ErrCode=ERR_HwError; MediaChange=ERROR; return(ERROR); }
		if(Check$DataStatus(Redundant))
			{ ErrCode=ERR_DataStatus; return(ERROR); }
		if(! Check$ReadError(Redundant)) return(SUCCESS);
		if(! Check$Correct(buf,Redundant))
			{ ErrCode=ERR_CorReadErr; return(ERROR); }
	}
	ErrCode=ERR_EccReadErr;
	return(ERROR);
}
static int Write$PhyOneSect(unsigned char *buf)
{
	if(Ssfdc$WriteSect(buf,Redundant))
		{ ErrCode=ERR_HwError; MediaChange=ERROR; return(ERROR); }
	if(Ssfdc$CheckStatus())
		{ ErrCode=ERR_WriteFault; return(ERROR); }
	return(SUCCESS);
}
/***************************************************************************/
static int Erase$PhyOneBlock(void)
{
	if(Ssfdc$EraseBlock())
		{ ErrCode=ERR_HwError; MediaChange=ERROR; return(ERROR); }
	if(Ssfdc$CheckStatus())
		{ ErrCode=ERR_WriteFault; return(ERROR); }
	return(SUCCESS);
}
/***************************************************************************
SmartMedia Physical Format Check Local Subroutine
***************************************************************************/
static int Set$PhyFmtValue(void)
{
	unsigned char idcode[4];
	Ssfdc$ReadID(idcode);
	if(Set$SsfdcModel(idcode[1]))
		return(ERROR);
	if(Check$SsfdcWP())
		Ssfdc.Attribute|=WP;
	return(SUCCESS);
}
static int Search$CIS(void)
{
	Media.Zone=0; Media.Sector=0;
	for(Media.PhyBlock=0; Media.PhyBlock<(Ssfdc.MaxBlocks-Ssfdc.MaxLogBlocks-1); Media.PhyBlock++) {
		if(Ssfdc$ReadRedtData(Redundant))
			{ Ssfdc$Reset(); return(ERROR); }
		if(! Check$FailBlock(Redundant)) {
			break;
		}
	}
	if(Media.PhyBlock==(Ssfdc.MaxBlocks-Ssfdc.MaxLogBlocks-1))
		{ Ssfdc$Reset(); return(ERROR); }
	while(Media.Sector<CIS_SEARCH_SECT) {
		/* Sector 0 has been read out in SEARCH BLOCK */
		if(Media.Sector)
			if(Ssfdc$ReadRedtData(Redundant))
				{ Ssfdc$Reset(); return(ERROR); }
		if(! Check$DataStatus(Redundant)) {
			if(Ssfdc$ReadSect(WorkBuf,Redundant))
				{ Ssfdc$Reset(); return(ERROR); }
			if(Check$CISdata(WorkBuf,Redundant))
				{ Ssfdc$Reset(); return(ERROR); }
			CisArea.PhyBlock=Media.PhyBlock;
			CisArea.Sector=Media.Sector;
			Ssfdc$Reset();
			return(SUCCESS);
		}
		Media.Sector++;
	}
	Ssfdc$Reset();
	return(ERROR);
}
/***************************************************************************/
static int Make$LogTable(void)
{
	unsigned short phyblock,logblock;
	Media.Sector=0;
	for(Media.Zone=0; Media.Zone<MAX_ZONENUM; Media.Zone++) {
		for(Media.LogBlock=0; Media.LogBlock<Ssfdc.MaxLogBlocks; Media.LogBlock++)
			Log2Phy[Media.Zone][Media.LogBlock]=NO_ASSIGN;
		for(Media.PhyBlock=0; Media.PhyBlock<(MAX_BLOCKNUM/8); Media.PhyBlock++)
			Assign[Media.Zone][Media.PhyBlock]=0x00;
		/*******************************************************************/
		for(Media.PhyBlock=0; Media.PhyBlock<Ssfdc.MaxBlocks; Media.PhyBlock++) {
			/* CIS block */
			if((! Media.Zone) && (Media.PhyBlock<=CisArea.PhyBlock)) {
				Set$Bit(Assign[Media.Zone],Media.PhyBlock);
				continue;
			}
			if(Ssfdc$ReadRedtData(Redundant))
				{ Ssfdc$Reset(); return(ERROR); }
			if(! Check$DataBlank(Redundant))
				continue;
			Set$Bit(Assign[Media.Zone],Media.PhyBlock);
			if(Check$FailBlock(Redundant))
				continue;
			if(Load$LogBlockAddr(Redundant))
				continue;
			if(Media.LogBlock>=Ssfdc.MaxLogBlocks)
				continue;
			if(Log2Phy[Media.Zone][Media.LogBlock]==NO_ASSIGN) {
				Log2Phy[Media.Zone][Media.LogBlock]=Media.PhyBlock;
				continue;
			}
			/* Log2Phy item has been assiged, so... */
			phyblock=Media.PhyBlock;
			logblock=Media.LogBlock;
			/* Read the last sector in this block, if the logblock number is different from the first sector, then ignore */
			Media.Sector=(unsigned char)(Ssfdc.MaxSectors-1);
			if(Ssfdc$ReadRedtData(Redundant))
				{ Ssfdc$Reset(); return(ERROR); }
			if(! Load$LogBlockAddr(Redundant))
				if(Media.LogBlock==logblock) {
					Media.PhyBlock=Log2Phy[Media.Zone][Media.LogBlock];
					if(Ssfdc$ReadRedtData(Redundant))
						{ Ssfdc$Reset(); return(ERROR); }
					Media.PhyBlock=phyblock;
					if(! Load$LogBlockAddr(Redundant)) {
						if(Media.LogBlock!=logblock) {
							Media.LogBlock=logblock; //(Ver1.10 ……… Add this line)
							Media.PhyBlock=Log2Phy[Media.Zone][Media.LogBlock];
							Log2Phy[Media.Zone][Media.LogBlock]=phyblock;
						}
					} else {
						Media.LogBlock=logblock; //(Ver1.10 ……… Add this line)
						Media.PhyBlock=Log2Phy[Media.Zone][Media.LogBlock];
						Log2Phy[Media.Zone][Media.LogBlock]=phyblock;
					}
				}
			Media.Sector=0;
#ifdef L2P_ERR_ERASE /***************************************************/
			if(!(Ssfdc.Attribute &MWP)) {
				Ssfdc$Reset();
				if(Ssfdc$EraseBlock()) return(ERROR);
				if(Ssfdc$CheckStatus())
					{ if(MarkFail$PhyOneBlock()) return(ERROR); }
				else Clr$Bit(Assign[Media.Zone],Media.PhyBlock);
			}
#else /*******************************************************************/
			Ssfdc.Attribute|=MWP;
#endif /*******************************************************************/
			Media.PhyBlock=phyblock;
		}
		AssignStart[Media.Zone]=0;
	}
	Ssfdc$Reset();
	return(SUCCESS);
}
/***************************************************************************/
static int MarkFail$PhyOneBlock(void)
{
	unsigned char sect;
	sect=Media.Sector;
	Set$FailBlock(WorkRedund);
	Ssfdc$WriteRedtMode();
	for(Media.Sector=0; Media.Sector<Ssfdc.MaxSectors; Media.Sector++)
		if(Ssfdc$WriteRedtData(WorkRedund)) {
			Ssfdc$Reset();
			Media.Sector=sect;
			ErrCode=ERR_HwError;
			MediaChange=ERROR;
			return(ERROR);
		} /* NO Status Check */
	Ssfdc$Reset();
	Media.Sector=sect;
	return(SUCCESS);
}

///////////////////////////////
//////////////////////////////
int format()
{
	unsigned char buf[512]={0x01, 0x03, 0xd9, 0x01, 0xff, 0x18, 0x02, 0xdf, 0x01, 0x20};
	char redundant[16];
	
	if(Set$PhyFmtValue())
		{ ErrCode=ERR_UnknownMedia; return(ERROR); }
		
	Media.Zone = Media.PhyBlock = 0;
	Erase$PhyOneBlock();
	
	Write$PhyOneSect(buf);
	
}