flash.c

at45081 bsp 源码

        if(temp >= size)
        {
            temp = size;
            size = 0;
        }
        else
        {
            size -= temp;
        }
        FLASH_PageWrite(pageID, pageAddr, dataAddr, temp);
        dataAddr += temp;
        pageID++;
        pageAddr = 0;

		//*******************************************************************/
		// add the following instruction to test write ok or not
		FLASH_SELECT = 0;
		Delay_us(1);
		FLASH_LoadOpCode(0x60, pageID, 0x00, 0);  // compare buf1 and page
		Delay_us(1);

		// when cs change to high,MCU begin write data from BUFF to Main Page
    	FLASH_SELECT = 1;                  
    	while(FLASH_READY == 0)
		{
			os_switch_task ();
		}
    
		FLASH_SELECT = 0;
		Delay_us(1);
		FLASH_LoadOpCode(0xd7, 0x00, 0x00, 0); // read register
		FLASH_RdDatFromSpi(p, 1);
    	Delay_us(1);
    	FLASH_SELECT = 1;

    	temp_flag=temp_flag & 0x40;
    	
		if( temp_flag == 0x00 )// write error
		{
			return (FALSE);
			break;
		}
    }//while(size > 0)
    return(TRUE);
}


/***************************************************************************/

/* 函 数 名:      FLASH_PageErase                                            

/* 功能描述:      擦除某一页                                             

/* 函数说明: 

/* 调用函数:                                                  

/* 全局变量:                                                

/* 输    入:                               

/* 返    回: 无                                                           


/*********************************************************************/
void FLASH_PageErase( UINT pageID)
{
 	FLASH_SELECT = 0;
    Delay_us(1);
    FLASH_LoadOpCode(0x81, pageID, 0x00, 0);      
    Delay_us(1);
    FLASH_SELECT = 1;
                                                                                                                                                                                                            
	// Switch the Task, Typical Page Erase time is 8ms	
	while(FLASH_READY == 0)
	{
		os_wait(K_TMO, 1, 0);
	}
}


//********************************************************************/
void Delay_us(BYTE us)
{
	BYTE temp=0;
	BYTE TimeMax = us << 3;

	for( temp = 0; temp < us; temp++)
	{
		_nop_();
	}
}

void SPI_Init(void)
{
	SPI0CN = 0x02;	// SPI Control Register
	SPI0CFG = 0x07;	// SPI Configuration Register
	SPI0CKR = 0x04;	// SPI Clock Rate Register
    SPI0CN |= 0x01;
}


void FLASH_Reset( void )
{
	uchar i;

	// Select the flash
	FLASH_SELECT = 0;
	Delay_us(1);

	// Pull down the reset line
	FLASH_RESET = 0;
	for( i = 0; i < 50; i++ )
	{
		Delay_us(1);
	}
	
	// DeSelect the flash
	FLASH_SELECT = 1;
	Delay_us(1);

	// Pull up the reset line
	FLASH_RESET = 1;

	// waiting for the reset recovery
	Delay_us( 2 );
}

/*
BOOL CheckFlash( void )
{
	uint i;
	uint k;
	char xdata Write[FLASH_PAGE_SIZE]; 
	char xdata Read[FLASH_PAGE_SIZE];

	ulong ulStartTime;

	ulStartTime = g_ulSecondCount;

	for( i = 0 ; i < FLASH_PAGE_NUM; i++ )
	{

		// check 0x55 Write
		for( k = 0; k < FLASH_PAGE_SIZE; k++ )
	    {
			Write[k] = 0x55;
		}

		FLASH_PageErase( i );
		FLASH_PageWrite( i, 0, Write, FLASH_PAGE_SIZE);
		FLASH_PageRead( i, 0, Read, FLASH_PAGE_SIZE );

		for( k = 0; k < FLASH_PAGE_SIZE; k++ )
	   	{
			if( Read[k] != Write[k] )
			{
				break;
			}
			Read[k] = 0;
		}
		
		if( k != FLASH_PAGE_SIZE )
		{
			return FALSE;
		}

		// Check 0xAA
		for( k = 0; k < FLASH_PAGE_SIZE; k++ )
	    {
			Write[k] = 0xAA;
		}

		FLASH_PageWrite( i, 0, Write, FLASH_PAGE_SIZE);
		FLASH_PageRead( i, 0, Read, FLASH_PAGE_SIZE );

		for( k = 0; k < FLASH_PAGE_SIZE; k++ )
	   	{
			if( Read[k] != 0x00 )
			{
				break;
			}
			Read[k] = 0;
		}
		
		if( k != FLASH_PAGE_SIZE )
		{
			return FALSE;
		}

	}

	ulStartTime = g_ulSecondCount - ulStartTime;
	return TRUE;
}


// Reclaim the data flash
void FLASH_Reclaim( void )
{
	
}

*/

/****************************************************************************/
/* 函 数 名:  FLASH_EraseDataFlash											*/
/* 功能描述:  Erase the  data pages											*/
/* 函数说明: 																*/
/* 调用函数: 																*/
/* 全局变量: 																*/
/* 输    入: 																*/
/* 返    回: void															*/
/****************************************************************************/
void FLASH_EraseDataFlash(void)
{ 
	UINT page;
	BYTE temp;
#if (_PRINT_TO_PC_ == TRUE )
	print("\nErase Data flash in progress");
#endif
	
	// Updating the ERASE PAGE state for Power loss
	temp = FLASH_ERASEPAGE_ERASING;
	FLASH_WriteData( FLASH_ERASEPAGE_DATA_START_ADDR, (BYTE *)&temp, 1 );
	
	// Erase the ERASE PAGE itself
	FLASH_PageErase(FLASH_ERASEPAGE_DATA_NO);

	// Set the ERASE PAGE STATE to "UPDATING"
	temp = FLASH_ERASEPAGE_UPDATING;
	FLASH_WriteData( FLASH_ERASEPAGE_DATA_START_ADDR, (BYTE *)&temp, 1 );

	// Set the WHOLE FLASH STATE (Located within ERASE PAGE) to "ERASING"
	temp = FLASH_STATE_ERASING;
	FLASH_WriteData( (FLASH_ERASEPAGE_DATA_START_ADDR+1), (BYTE *)&temp, 1 );

	// Erase the other blocks one by one
	for(page = FLASH_PAGE_DATA_FIRST;page <= FLASH_PAGE_DATA_LAST; page++)
	{
		// Reset the watch dog counter
		g_ucWatchDogCount = 0;
		
		FLASH_PageErase(page);

#if (_PRINT_TO_PC_ == TRUE )
		if( (page%50) == 0 )
		{
			print(".");
		}
#endif
	}
	

	// Set the WHOLE FLASH STATE to "NORMAL"
	temp = FLASH_STATE_NORMAL;
	FLASH_WriteData( (FLASH_ERASEPAGE_DATA_START_ADDR+1), (BYTE *)&temp, 1 );

	// Set the ERASE PAGE to "NORMAL"
	temp = FLASH_ERASEPAGE_NORMAL;
	FLASH_WriteData( FLASH_ERASEPAGE_DATA_START_ADDR, (BYTE *)&temp, 1 );

	return;
}


/****************************************************************************/
/* 函 数 名:  FLASH_EraseConfigFlash										*/
/* 功能描述:  Erase the config  pages										*/
/* 函数说明: 																*/
/* 调用函数: 																*/
/* 全局变量: 																*/
/* 输    入: 																*/
/* 返    回: void															*/
/****************************************************************************/
void FLASH_EraseConfigFlash(void)
{ 
	UINT page;
	BYTE temp;

#if (_PRINT_TO_PC_ == TRUE )
	print("\nErase config flash in progress");
#endif
	// Updating the ERASE PAGE state for Power loss
	temp = FLASH_ERASEPAGE_ERASING;
	FLASH_WriteData( FLASH_ERASEPAGE_CONFIG_START_ADDR, (BYTE *)&temp, 1 );
	
	// Erase the ERASE PAGE itself
	FLASH_PageErase(FLASH_ERASEPAGE_CONFIG_NO);

	// Set the ERASE PAGE STATE to "UPDATING"
	temp = FLASH_ERASEPAGE_UPDATING;
	FLASH_WriteData( FLASH_ERASEPAGE_CONFIG_START_ADDR, (BYTE *)&temp, 1 );

	// Set the WHOLE FLASH STATE (Located within ERASE PAGE) to "ERASING"
	temp = FLASH_STATE_ERASING;
	FLASH_WriteData( (FLASH_ERASEPAGE_CONFIG_START_ADDR+1), (BYTE *)&temp, 1 );

	// Erase the other blocks one by one
	for(page = FLASH_PAGE_CONFIG_FIRST;page < FLASH_PAGE_CONFIG_LAST; page++)
	{
		// Reset the watch dog counter
		g_ucWatchDogCount = 0;
		
		FLASH_PageErase(page);

#if (_PRINT_TO_PC_ == TRUE )
		if( (page%50) == 0 )
		{
			print(".");
		}
#endif
	}
	

	// Set the WHOLE FLASH STATE to "NORMAL"
	temp = FLASH_STATE_NORMAL;
	FLASH_WriteData( (FLASH_ERASEPAGE_CONFIG_START_ADDR+1), (BYTE *)&temp, 1 );

	// Set the ERASE PAGE to "NORMAL"
	temp = FLASH_ERASEPAGE_NORMAL;
	FLASH_WriteData( FLASH_ERASEPAGE_CONFIG_START_ADDR, (BYTE *)&temp, 1 );

	return;
}	
 
 
   
/****************************************************************************/
/* 函 数 名:  FLASH_EraseVerify												*/
/* 功能描述:  check the WHOLE FLASH STATE by reading ERASE PAGE,			*/
/* 			  if not initialized normally, erase all flash pages one by one */
/* 函数说明: 																*/
/* 调用函数: 																*/
/* 全局变量: 																*/
/* 输    入: 																*/
/* 返    回: 0 -- Everything is cool... other -- something wrong			*/
/****************************************************************************/
#if(0)
BOOL FLASH_EraseVerify()
{
	char read[264];
	UINT page;

	// Erase the other blocks one by one
	for(page = 0;page < FLASH_PAGE_NUM; page++)
	{
		FLASH_ReadData( page*(ulong)(FLASH_PAGE_SIZE), 
			&read, sizeof(read));
	}

	return TRUE;
}
#endif


/****************************************************************************/
/* 函 数 名:  FLASH_EraseCheck												*/
/* 功能描述:  Check the flash to confirm formated or not					*/
/* 函数说明: 																*/
/* 调用函数: 																*/
/* 全局变量: 																*/
/* 输    入: 																*/
/* 返    回: TRUE -- Everything is cool... FALSE -- something wrong			*/
/****************************************************************************/
BOOL FLASH_EraseCheck( void )
{
	ERASEPAGEINFO pageInfo;

	// check the data sections
	FLASH_ReadData( FLASH_ERASEPAGE_DATA_START_ADDR, 
		(BYTE *)&pageInfo, sizeof(pageInfo));

	if( pageInfo.ucErasePageState != FLASH_ERASEPAGE_NORMAL ||
		pageInfo.ucFlashState != FLASH_STATE_NORMAL )
	{
		// check the data sections AGAIN to ensure mis-action
		FLASH_ReadData( FLASH_ERASEPAGE_DATA_START_ADDR, 
			(BYTE *)&pageInfo, sizeof(pageInfo));
		
		if( pageInfo.ucErasePageState != FLASH_ERASEPAGE_NORMAL ||
			pageInfo.ucFlashState != FLASH_STATE_NORMAL )
		{
#if ( _PRINT_TO_PC_ == TRUE )
			print( "\nData pages crack, erasing...");
#endif
			// erase all data pages
			FLASH_EraseDataFlash();
#if ( _PRINT_TO_PC_ == TRUE )
			print( "done!");
#endif
		}
	}

	// check the config sections	
	FLASH_ReadData( FLASH_ERASEPAGE_CONFIG_START_ADDR, 
		(BYTE *)&pageInfo, sizeof(pageInfo));

	if( pageInfo.ucErasePageState != FLASH_ERASEPAGE_NORMAL ||
		pageInfo.ucFlashState != FLASH_STATE_NORMAL )
	{
		// check the config sections AGAIN to ensure mis-action
		// check the config sections	
		FLASH_ReadData( FLASH_ERASEPAGE_CONFIG_START_ADDR, 
			(BYTE *)&pageInfo, sizeof(pageInfo));
		
		if( pageInfo.ucErasePageState != FLASH_ERASEPAGE_NORMAL ||
			pageInfo.ucFlashState != FLASH_STATE_NORMAL )
		{
#if ( _PRINT_TO_PC_ == TRUE )
			print( "Config pages crack, erasing...");
#endif
			// erase all config pages
			FLASH_EraseConfigFlash();
#if ( _PRINT_TO_PC_ == TRUE )
			print( "done!");
#endif
		}
	}

	return TRUE;
}


/****************************************************************************/
/* 函 数 名:  FLASH_Format													*/
/* 功能描述:  Format the whole flash and init the parameters again			*/
/* 函数说明: 																*/
/* 调用函数: 																*/
/* 全局变量: 																*/
/* 输    入: 																*/
/* 返    回: 0 -- Everything is cool... other -- something wrong			*/
/****************************************************************************/
BOOL FLASH_Format( void )
{
#if ( _PRINT_TO_PC_ == TRUE )
	print( "\nBegin Flash Format ...");
#endif

	// SPI init
	SPI_Init();
	
	// Reset the flash
	FLASH_Reset();
	
	// format all data pages
	FLASH_EraseDataFlash();

	// format all config pages
	FLASH_EraseConfigFlash();

	return FLASH_Init();
	
}

/****************************************************************************/
/* 函 数 名:  FLASH_Init													*/
/* 功能描述:  init the flash status pointers or finish writing 				*/
/* 函数说明: 																*/
/* 调用函数: 																*/
/* 全局变量: 																*/
/* 输    入: 																*/
/* 返    回: 0 -- Everything is cool... other -- something wrong			*/
/****************************************************************************/
BOOL FLASH_Init( void )
{
	// SPI init
	SPI_Init();

	// Reset the flash
	FLASH_Reset();

	// Check the flash
	//
//	 CheckFlash();

#if ( _PRINT_TO_PC_ == TRUE )
	print( "\nBegin Flash Erase Check...");
#endif

	// Format the Flash if necessary
	FLASH_EraseCheck();
//	FLASH_EraseVerify();

	
	//////////////// Read Configs ////////////////////////////////////////////////
	FLASH_InitConfig();
	
	//////////////////// Check the record ////////////////////////////////////////
	FLASH_InitData();

	return TRUE;

}

/****************************************************************************/
/* 函 数 名:  FLASH_InitData												*/
/* 功能描述:  init the flash status pointers or finish writing 				*/
/* 函数说明: 																*/
/* 调用函数: 																*/
/* 全局变量: 																*/
/* 输    入: 																*/
/* 返    回: 0 -- Everything is cool... other -- something wrong			*/
/****************************************************************************/
void FLASH_InitData( void )
{