flash.c

at45081 bsp 源码

	}
	
	m_pFirstReadPtr = SearchNextRecord( m_pFirstReadPtr, FLASH_NORMAL );

	return TRUE;
}

/****************************************************************************/
/* 函 数 名:  FLASH_AppendRecord											*/
/* 功能描述:  API function write a record to the firstest empty gran		*/
/* 函数说明: 																*/
/* 调用函数: 																*/
/* 全局变量: 																*/
/* 输    入: 																*/
/* 返    回: TRUE -- Everything is cool... FALSE -- something wrong			*/
/****************************************************************************/
BOOL FLASH_AppendRecord( void )
{
	// Writing the state first
	g_FlashWriteRecord.State = FLASH_WRITING;
	FLASH_WriteData( m_pWritePtr, (BYTE *)&g_FlashWriteRecord, 1 );

	// 下面的记录应该是Communication任务读取队列后自动更新	
	// writing the content
	FLASH_WriteData( m_pWritePtr, (BYTE *)&g_FlashWriteRecord, FLASH_RECORD_LEN);

	// mark the header to the normal
	g_FlashWriteRecord.State = FLASH_NORMAL;
	FLASH_WriteData( m_pWritePtr, (BYTE *)&g_FlashWriteRecord, 1 );
	
	m_pWritePtr = SearchNextRecord( m_pWritePtr, FLASH_EMPTY );

	return TRUE;
}
//////////////////////////////////////////////////////////////////////////
// Write and read the common config
BOOL WriteCommonConfig( void )
{
	uchar Data[FLASH_PAGE_SIZE];

	// prepare the data to writing
	Data[0] = FLASH_NORMAL;
	memcpy( &(Data[1]), g_pCommonConfig, sizeof(COMMON_SETTING));

	// Erase the page
	FLASH_PageErase( FLASH_PAGE_COMMON_CONFIG);

	// write the page
	return FLASH_PageWrite( FLASH_PAGE_COMMON_CONFIG, 0 ,
		Data, 1+sizeof(COMMON_SETTING) );
}

BOOL ReadCommonConfig( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	
	// read from the flash
	FLASH_PageRead( FLASH_PAGE_COMMON_CONFIG, 0,
		Data, 1+sizeof(COMMON_SETTING));

	// prepare the data to writing
	if( Data[0] == FLASH_NORMAL )
	{
		memcpy( g_pCommonConfig, &(Data[1]), sizeof(COMMON_SETTING));
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

//////////////////////////////////////////////////////////////////////////
// Write and read the dialin config
BOOL WriteDialInConfig( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	
	// prepare the data to writing
	Data[0] = FLASH_NORMAL;
	memcpy( &(Data[1]), g_pDialInSetting, sizeof(DIALIN_SETTING));
	
	// Erase the page
	FLASH_PageErase( FLASH_PAGE_DIALIN);
	
	// write the page
	return FLASH_PageWrite( FLASH_PAGE_DIALIN, 0 ,
		Data, 1+sizeof(DIALIN_SETTING) );
}

BOOL ReadDialInConfig( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	
	// read from the flash
	FLASH_PageRead( FLASH_PAGE_DIALIN, 0,
		Data, 1+sizeof(DIALIN_SETTING));
	
	// prepare the data to writing
	if( Data[0] == FLASH_NORMAL )
	{
		memcpy( g_pDialInSetting, &(Data[1]), sizeof(DIALIN_SETTING));
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

//////////////////////////////////////////////////////////////////////////
// Write and read the dialin config
BOOL WriteDialOutConfig( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	
	// prepare the data to writing
	Data[0] = FLASH_NORMAL;
	memcpy( &(Data[1]), g_pDialOutSetting, sizeof(DIALOUT_SETTING));
	
	// Erase the page
	FLASH_PageErase( FLASH_PAGE_DIALOUT);
	
	// write the page
	return FLASH_PageWrite( FLASH_PAGE_DIALOUT, 0 ,
		Data, 1+sizeof(DIALOUT_SETTING) );
}

BOOL ReadDialOutConfig( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	
	// read from the flash
	FLASH_PageRead( FLASH_PAGE_DIALOUT, 0,
		Data, 1+sizeof(DIALOUT_SETTING));
	
	// prepare the data to writing
	if( Data[0] == FLASH_NORMAL )
	{
		memcpy( g_pDialOutSetting, &(Data[1]), sizeof(DIALOUT_SETTING));
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

//////////////////////////////////////////////////////////////////////////
BOOL WriteMultiInstance( uint Page, uchar * Instance, uchar Size)
{
	uchar Num;
	uchar Data[FLASH_PAGE_SIZE];
	uint i;
	uchar * p;
	uint StartAddr;
	uchar WriteByte;

	// check the parameter
	if( Size == 0 )
	{
		return  FALSE;
	}

	// take the state byte into account
	Size += 1;
	p = Data;

	// calculate the num of the instance
	Num = (uchar)((uint)FLASH_PAGE_SIZE / Size );

	// read the whole page from the flash
	FLASH_PageRead( Page, 0, Data, FLASH_PAGE_SIZE );

	// Get the first empty instance and fill the instance
	for( i = 0; i < Num; i++ )
	{
		if( * p == FLASH_EMPTY )
		{
			uchar k;

			// invalid the previous one
			if( i != 0 )
			{
				Data[(i-1)*Size] = FLASH_INVALID;

				StartAddr = (i-1)* Size;
				WriteByte = 2 * Size;
			}
			else
			{
				StartAddr = 0;
				WriteByte = Size;
			}
			* p = FLASH_NORMAL;
			p +=1;
			for( k = 0; k < (Size-1); k++ )
			{
				p[k] = Instance[k];
			}
			break;
		}

		// point to the next page
		p += Size;
	}

	// all instance full
	if( i == Num )
	{
		uchar k;

		// Erase the page
		FLASH_PageErase( Page );

		// fill the first instance
		p = Data;
		* p = FLASH_NORMAL;
		p +=1;
		for( k = 0; k < (Size-1); k++ )
		{
			p[k] = Instance[k];
		}

		StartAddr = 0;
		WriteByte = Size;
	}
	
	// write it back to the flash
	return FLASH_PageWrite( Page, StartAddr, &Data[StartAddr], WriteByte );
}

BOOL ReadMultiInstance( uint Page, uchar * Instance, uchar Size )
{
	uchar Num;
	uchar Data[FLASH_PAGE_SIZE];
	uchar i;
	uchar * p;
	
	// check the parameter
	if( Size == 0 )
	{
		return  FALSE;
	}
	
	// take the state byte into account
	Size += 1;
	p = Data;
	
	// calculate the num of the instance
	Num = (uchar)((uint)FLASH_PAGE_SIZE / Size );
	
	// read the whole page from the flash
	FLASH_PageRead( Page, 0, Data, FLASH_PAGE_SIZE );

	for( i = 0; i < Num; i++ )
	{
		if( * p == FLASH_NORMAL )
		{
			uchar k;
			
			p +=1;
			for( k = 0; k < (Size-1); k++ )
			{
				Instance[k] = p[k];
			}
			break;
		}
		
		// point to the next page
		p += Size;		
	}

	if( i == Num )
	{
		return FALSE;
	}
	else
	{
		return TRUE;
	}
}

//////////////////////////////////////////////////////////////////////////
// write and read reply message
BOOL WriteReplyMessage( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	uint Page;

	// Get the page of the message
	Page = FLASH_PAGE_FIRST_REPLY + (uint)g_ucUpdateReplyMessageIndex;

	// prepare the data to writing
	Data[0] = FLASH_NORMAL;
	memcpy( &(Data[1]), &(g_pReplyMessage[g_ucUpdateReplyMessageIndex]), 
		sizeof(REPLY_MESSAGE));
	
	// Erase the page
	FLASH_PageErase( Page );
	
	// write the page
	return FLASH_PageWrite( Page, 0, Data, 1+sizeof(REPLY_MESSAGE) );
}

BOOL ReadReplyMessage( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	uint Page;

	// Get the page of the message
	Page = FLASH_PAGE_FIRST_REPLY + (uint)g_ucUpdateReplyMessageIndex;
	
	// read from the flash
	FLASH_PageRead( Page, 0, Data, 1+sizeof(REPLY_MESSAGE));
	
	// prepare the data to writing
	if( Data[0] == FLASH_NORMAL )
	{
		memcpy( &g_pReplyMessage[g_ucUpdateReplyMessageIndex], 
			&(Data[1]), sizeof(REPLY_MESSAGE));
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}


//////////////////////////////////////////////////////////////////////////
// Write and read the line information here
BOOL WriteLineInfo( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	
	// prepare the data to writing
	Data[0] = FLASH_NORMAL;
	memcpy( &(Data[1]), g_pLineInfo, sizeof(LINE_INFO));
	
	// Erase the page
	FLASH_PageErase( FLASH_PAGE_LINE );
	
	// write the page
	return FLASH_PageWrite( FLASH_PAGE_LINE, 0 ,
		Data, 1+sizeof(LINE_INFO) );
}

BOOL ReadLineInfo( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	
	// read from the flash
	FLASH_PageRead( FLASH_PAGE_LINE, 0,
		Data, 1+sizeof(LINE_INFO));
	
	// prepare the data to writing
	if( Data[0] == FLASH_NORMAL )
	{
		memcpy( g_pLineInfo, &(Data[1]), sizeof(LINE_INFO));
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

//////////////////////////////////////////////////////////////////////////
// Write and read the station information here
BOOL WriteStationInfo( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	uint Page;
	
	// Get the page of the message
	Page = FLASH_PAGE_FIRST_STATION + (uint)g_ucUpdateStationIndex;
	
	// prepare the data to writing
	Data[0] = FLASH_NORMAL;
	memcpy( &(Data[1]), &(g_pStationInfo[g_ucUpdateStationIndex]), 
		sizeof(STATION_INFO));
	
	// Erase the page
	FLASH_PageErase( Page );
	
	if( g_ucUpdateStationCommand == STATION_CMD_DELETE )
	{
		// leave it empty
		return TRUE;
	}
	else
	{
		// write the page
		return FLASH_PageWrite( Page, 0 ,
			Data, 1+sizeof(STATION_INFO) );
	}
}

BOOL ReadStationInfo( void )
{
	uchar Data[FLASH_PAGE_SIZE];
	uint Page;
	
	// Get the page of the message
	Page = FLASH_PAGE_FIRST_STATION + (uint)g_ucUpdateStationIndex;
	
	// read from the flash
	FLASH_PageRead( Page, 0, Data, 1+sizeof(STATION_INFO));
	
	// prepare the data to writing
	if( Data[0] == FLASH_NORMAL )
	{
		memcpy( &g_pStationInfo[g_ucUpdateStationIndex], 
			&(Data[1]), sizeof(STATION_INFO));
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

//////////////////////////////////////////////////////////////////////////
BOOL FLASH_WriteConfig( uchar Type )
{
	switch( Type )
	{
	case CONFIG_TYPE_COMMON:		// 常用的设置信息
		return WriteCommonConfig();
		break;
	case CONFIG_TYPE_GASVALUE:		// 油量纪录
		return WriteMultiInstance( FLASH_PAGE_GASVALUE,
			(BYTE *)&g_uiGasValue, sizeof(g_uiGasValue));
		break;
	case CONFIG_TYPE_RATESTUDY:		// 速度学习纪录
		return WriteMultiInstance( FLASH_PAGE_RATESTUDY,
			(BYTE *)&g_uiRateStudy, sizeof(g_uiRateStudy));
		break;
	case CONFIG_TYPE_MILEMETER:		// 里程记录表
		return WriteMultiInstance( FLASH_PAGE_MILEMETER,
			(BYTE *)&g_ulMileMeter, sizeof(g_ulMileMeter));
		break;
	case CONFIG_TYPE_DIALOUT:		// 拨出记录表
		return WriteDialOutConfig();
		break;
	case CONFIG_TYPE_DIALIN:		// 拨入记录表
		return WriteDialInConfig();
		break;
	case CONFIG_TYPE_REPLYMSG:		// 回复消息设置
		return WriteReplyMessage();
		break;
	case CONFIG_TYPE_LINEINFO:		// 线路信息
		return WriteLineInfo();
		break;
	case CONFIG_TYPE_STATIONINFO:	// 站点信息
		return WriteStationInfo();
		break;
	default:
		break;
	}

	return TRUE;
}

BOOL FLASH_ReadConfig( uchar Type )
{
	switch( Type )
	{
	case CONFIG_TYPE_COMMON:		// 常用的设置信息
		return ReadCommonConfig();
		break;
	case CONFIG_TYPE_GASVALUE:		// 油量纪录
		return ReadMultiInstance( FLASH_PAGE_GASVALUE,
			(BYTE *)&g_uiGasValue, sizeof(g_uiGasValue));
		break;
	case CONFIG_TYPE_RATESTUDY:		// 速度学习纪录
		return ReadMultiInstance( FLASH_PAGE_RATESTUDY,
			(BYTE *)&g_uiRateStudy, sizeof(g_uiRateStudy));
		break;
	case CONFIG_TYPE_MILEMETER:		// 里程记录表
		return ReadMultiInstance( FLASH_PAGE_MILEMETER,
			(BYTE *)&g_ulMileMeter, sizeof(g_ulMileMeter));
		break;
	case CONFIG_TYPE_DIALOUT:		// 拨出记录表
		return ReadDialOutConfig();
		break;
	case CONFIG_TYPE_DIALIN:		// 拨入记录表
		return ReadDialInConfig();
		break;
	case CONFIG_TYPE_REPLYMSG:		// 回复消息设置
		return ReadReplyMessage();
		break;
	case CONFIG_TYPE_LINEINFO:		// 线路信息
		return ReadLineInfo();
		break;
	case CONFIG_TYPE_STATIONINFO:	// 站点信息
		return ReadStationInfo();
		break;
	default:
		break;
	}
	
	return TRUE;
}