1348 lines
42 KiB
C
1348 lines
42 KiB
C
/** ##########################################################################
|
||
** Filename :
|
||
** Project :
|
||
** Module :
|
||
** Processor :
|
||
** Version : 1.0
|
||
** Compiler :
|
||
** Date/Time :
|
||
** Abstract :
|
||
** Contents :
|
||
** Note :
|
||
**
|
||
** (c) Copyright dmdz Co.,Ltd
|
||
** --------------------------------------------------------------------------
|
||
** R E V I S I O N H I S T O R Y
|
||
** --------------------------------------------------------------------------
|
||
** Date Ver Author Description
|
||
|
||
** -20230602- --V1.0-- --mingyea--- --修改--
|
||
|
||
** #########################################################################*/
|
||
|
||
/*---------------------------------------------------------------------------
|
||
- I N C L U D E F I L E S
|
||
----------------------------------------------------------------------------*/
|
||
|
||
#include "error.h"
|
||
#include "eeprom.h"
|
||
#include "eeprom_seq.h"
|
||
#include "eeprom_state_machine.h"
|
||
#include "system_voltage_manage.h"
|
||
#include "wdog.h"
|
||
|
||
#ifdef NVM_EEPROM_EXT_EN
|
||
/*---------------------------------------------------------------------------
|
||
- D E F I N E S / M A C R O S
|
||
----------------------------------------------------------------------------*/
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
- T Y P E D E F I N I T I O N S
|
||
----------------------------------------------------------------------------*/
|
||
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
- S T A T I C V A R I A B L E S
|
||
----------------------------------------------------------------------------*/
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
* G L O B A L V A R I A B L E S
|
||
----------------------------------------------------------------------------*/
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
- C O N S T A N T S
|
||
----------------------------------------------------------------------------*/
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
- F U N C T I O N P R O T O T Y P E
|
||
----------------------------------------------------------------------------*/
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by :
|
||
|Preconditions :
|
||
|Input parameters :
|
||
|Output parameters :
|
||
|Return value :
|
||
|Description : 擦除数据
|
||
----------------------------------------------------------------------------*/
|
||
eeprom_statys_t eeprom_erase_page(u32 page_addr)
|
||
{
|
||
eeprom_statys_t l_flash_status ;
|
||
|
||
#ifdef EEPROM_EXT_JUDGE_PAGE_ADDR
|
||
assert_param(page_addr>=EEPROM_FLASH_ADDR_START);
|
||
assert_param(page_addr<EEPROM_FLASH_ADDR_END);
|
||
#endif
|
||
wdog_task();
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
//EEPROM_EXT_ERASE_TEST_ON();
|
||
#endif
|
||
if (FL_FAIL == FL_FLASH_SectorErase(FLASH, page_addr))
|
||
{
|
||
l_flash_status = EFLASH_STATUS_BUSY;
|
||
}
|
||
else
|
||
{
|
||
l_flash_status = EFLASH_STATUS_SUCCESS;
|
||
}
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
//EEPROM_EXT_ERASE_TEST_OFF();
|
||
#endif
|
||
return l_flash_status;
|
||
}
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by :
|
||
|Preconditions :
|
||
|Input parameters :
|
||
|Output parameters :
|
||
|Return value :
|
||
|Description : 写一个word
|
||
----------------------------------------------------------------------------*/
|
||
eeprom_statys_t eeprom_program_u32(u32 addr, u32 data)
|
||
{
|
||
eeprom_statys_t l_flash_status ;
|
||
#ifdef EEPROM_EXT_JUDGE_PAGE_ADDR
|
||
assert_param(addr>=EEPROM_FLASH_ADDR_START);
|
||
assert_param(addr<=EEPROM_AERA_END_ADDR);
|
||
assert_param((addr&FLASH_ADDRS_ALIGN_RES_MASK)==0u);
|
||
#endif
|
||
wdog_task();
|
||
if (FL_FAIL == FL_FLASH_Program_Word(FLASH, addr, data))
|
||
{
|
||
l_flash_status = EFLASH_STATUS_BUSY;
|
||
}
|
||
else
|
||
{
|
||
l_flash_status = EFLASH_STATUS_SUCCESS;
|
||
}
|
||
return l_flash_status;
|
||
}
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by :
|
||
|Preconditions :
|
||
|Input parameters :
|
||
|Output parameters :
|
||
|Return value :
|
||
|Description :初始化
|
||
----------------------------------------------------------------------------*/
|
||
u16 eeprom_drv_init(u8 area_id)
|
||
{
|
||
u16 i;
|
||
u16 l_page0_status, l_page1_status;
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
#else
|
||
u16 l_page0_auxi, l_page1_auxi;
|
||
#endif
|
||
//u16 l_addr_index = 0u;
|
||
//u16 l_eeprom_status = 0u, l_read_status = EFLASH_READ_FAILED;
|
||
u16 l_flash_status = EFLASH_STATUS_SUCCESS;
|
||
u8 l_flag_out=0u;
|
||
|
||
assert_param(area_id<EEPROM_AREA_TOTAL);
|
||
|
||
if(area_id>=EEPROM_AREA_TOTAL)
|
||
{
|
||
l_flash_status = EFLASH_STATUS_PPADRER_ERROR;
|
||
//return l_flash_status;
|
||
}
|
||
else
|
||
{
|
||
/* Get Page0 status */
|
||
l_page0_status = (*(__IO eflash_operate_t*)EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id));
|
||
/* Get Page1 status */
|
||
l_page1_status = (*(__IO eflash_operate_t*)EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id));
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
#else
|
||
/* Get Page0 status */
|
||
l_page0_auxi = (*(__IO eflash_operate_t*)(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id)+EFLASH_OPERATION_LEN));
|
||
/* Get Page1 status */
|
||
l_page1_auxi = (*(__IO eflash_operate_t*)(EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id)+EFLASH_OPERATION_LEN));
|
||
#endif
|
||
/* Check for invalid header states and repair if necessary */
|
||
switch (l_page0_status)
|
||
{
|
||
case EFLASH_ERASED:
|
||
if (l_page1_status == EFLASH_VALID_PAGE) /* Page0 erased, Page1 valid */
|
||
{
|
||
//其实不需要每次都擦除，
|
||
#if 1 //其实没必要，每次都删除
|
||
if(g_eeprom_ext[area_id].first_reset_flag != EEPROM_FLAG_NOT_FIRST_RESET)
|
||
{
|
||
for(i = 0; i < EEPROM_AREAx_EFLASH_PAGE_NUM(area_id); i ++)
|
||
{
|
||
l_flash_status = eeprom_erase_page(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) + i * EFLASH_PAGE_SIEZ);
|
||
if(l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
/* If erase operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
//return l_flash_status;
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
else if (l_page1_status == EFLASH_RECEIVE_DATA) /* Page0 erased, Page1 receive */
|
||
{
|
||
//g_eeprom_ext[area_id].first_reset_flag = EEPROM_FLAG_FIRST_RESET_CLEAR;
|
||
/* Erase Page0 */
|
||
for(i = 0; i < EEPROM_AREAx_EFLASH_PAGE_NUM(area_id); i ++)
|
||
{
|
||
l_flash_status = eeprom_erase_page(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) + i * EFLASH_PAGE_SIEZ);
|
||
if(l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
/* If erase operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
/* Mark Page1 as valid */
|
||
l_flash_status = eeprom_program_u32(EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id), EFLASH_VALID_PAGE);
|
||
/* If program operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
g_eeprom_ext[area_id].state = EFLASH_STATE_IDLE;
|
||
break;
|
||
}
|
||
#endif
|
||
else /* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */
|
||
{
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
|
||
#else
|
||
if( l_page0_auxi == EFLASH_RECEIVE_DATA )
|
||
{
|
||
//正在转移，不用格式化--并且把FFFFF清成0，
|
||
l_flash_status = eeprom_program_u32(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id), EFLASH_VALID_PAGE);
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
//return l_flash_status;
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
g_eeprom_ext[area_id].state = EFLASH_STATE_IDLE;
|
||
}
|
||
else if(l_page1_auxi == EFLASH_RECEIVE_DATA )
|
||
{
|
||
//正在转移，不用格式化--并且把FFFFF清成0，
|
||
l_flash_status = eeprom_program_u32(EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id), EFLASH_VALID_PAGE);
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
//return l_flash_status;
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
g_eeprom_ext[area_id].state = EFLASH_STATE_IDLE;
|
||
}
|
||
else
|
||
#endif
|
||
{
|
||
/* Erase both Page0 and Page1 and set Page0 as valid page */
|
||
l_flash_status = eeprom_format(area_id);
|
||
/* If erase/program operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
//return l_flash_status;
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
g_eeprom_ext[area_id].first_reset_flag = EEPROM_FLAG_FIRST_RESET_CLEAR;
|
||
}
|
||
}
|
||
break;
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
case EFLASH_RECEIVE_DATA:
|
||
if (l_page1_status == EFLASH_VALID_PAGE) /* Page0 receive, Page1 valid */
|
||
{
|
||
#ifdef EEPROM_EXT_STATE_MACHILE_ENABLE
|
||
//--其实可以考虙删除PAGE0，重新在状态机中搬
|
||
/* Erase Page1 */
|
||
for(i = 0; i < EEPROM_AREAx_EFLASH_PAGE_NUM(area_id); i ++)
|
||
{
|
||
//wdog_task();
|
||
//wdt_disable();
|
||
l_flash_status = eeprom_erase_page(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) + i * EFLASH_PAGE_SIEZ);
|
||
//wdog_init();
|
||
//wdog_task();
|
||
if(l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
/* If erase operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
//g_eeprom_ext[area_id].first_reset_flag = EEPROM_FLAG_FIRST_RESET_CLEAR;
|
||
g_eeprom_ext[area_id].trans_page_count =0u;
|
||
g_eeprom_ext[area_id].transfer_state = EFLASH_PAGE_TRANSFER_STATE_WRITE_NEW_DATA;
|
||
#else
|
||
/* Transfer data from Page1 to Page0 */ //--其实可以考虙删除PAGE0，重新在状态机中搬
|
||
eeprom_reset_page_transfer_continus(area_id,g_eeprom_ext[area_id].page_cur_id, g_logic_page_write_data[area_id]);
|
||
#endif
|
||
}
|
||
else if(l_page1_status == EFLASH_ERASED) /* Page0 receive, Page1 erased */
|
||
{
|
||
/* Erase Page1 */
|
||
//g_eeprom_ext[area_id].first_reset_flag = EEPROM_FLAG_FIRST_RESET_CLEAR;
|
||
for(i = 0; i < EEPROM_AREAx_EFLASH_PAGE_NUM(area_id); i ++)
|
||
{
|
||
l_flash_status = eeprom_erase_page(EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id) + i * EFLASH_PAGE_SIEZ);
|
||
if(l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
/* If erase operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
/* Mark Page0 as valid */
|
||
l_flash_status = eeprom_program_u32(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id), EFLASH_VALID_PAGE);
|
||
/* If program operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
g_eeprom_ext[area_id].state = EFLASH_STATE_IDLE;
|
||
}
|
||
else /* Invalid state -> format eeprom */
|
||
{
|
||
/* Erase both Page0 and Page1 and set Page0 as valid page */
|
||
l_flash_status = eeprom_format(area_id);
|
||
/* If erase/program operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
//return l_flash_status;
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
g_eeprom_ext[area_id].first_reset_flag = EEPROM_FLAG_FIRST_RESET_CLEAR;
|
||
}
|
||
break;
|
||
#endif
|
||
case EFLASH_VALID_PAGE:
|
||
if (l_page1_status == EFLASH_VALID_PAGE) /* Invalid state -> format eeprom */
|
||
{
|
||
/* Erase both Page0 and Page1 and set Page0 as valid page */
|
||
l_flash_status = eeprom_format(area_id);
|
||
/* If erase/program operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
//return l_flash_status;
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
g_eeprom_ext[area_id].first_reset_flag = EEPROM_FLAG_FIRST_RESET_CLEAR;
|
||
}
|
||
else if (l_page1_status == EFLASH_ERASED) /* Page0 valid, Page1 erased */
|
||
{
|
||
/* Erase Page1 */
|
||
#if 1 //其实没必要，每次都删除
|
||
if(g_eeprom_ext[area_id].first_reset_flag != EEPROM_FLAG_NOT_FIRST_RESET)
|
||
{
|
||
for(i = 0; i < EEPROM_AREAx_EFLASH_PAGE_NUM(area_id); i ++)
|
||
{
|
||
l_flash_status = eeprom_erase_page(EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id) + i * EFLASH_PAGE_SIEZ);
|
||
if(l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
/* If erase operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
//return l_flash_status;
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
else /* Page0 valid, Page1 receive */
|
||
{
|
||
#ifdef EEPROM_EXT_STATE_MACHILE_ENABLE
|
||
for(i = 0; i < EEPROM_AREAx_EFLASH_PAGE_NUM(area_id); i ++)
|
||
{
|
||
//wdog_task();
|
||
//wdt_disable();
|
||
l_flash_status = eeprom_erase_page(EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id) + i * EFLASH_PAGE_SIEZ);
|
||
//wdog_init();
|
||
//wdog_task();
|
||
if(l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
/* If erase operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
g_eeprom_ext[area_id].trans_page_count =0u;
|
||
g_eeprom_ext[area_id].transfer_state = EFLASH_PAGE_TRANSFER_STATE_WRITE_NEW_DATA;
|
||
#else
|
||
/* Transfer data from Page0 to Page1 */ //--其实可以考虙删除PAGE1，重新在状态机中搬
|
||
eeprom_reset_page_transfer_continus(area_id,g_eeprom_ext[area_id].page_cur_id, g_logic_page_write_data[area_id]);
|
||
#endif
|
||
}
|
||
|
||
break;
|
||
|
||
default: /* Any other state -> format eeprom */
|
||
/* Erase both Page0 and Page1 and set Page0 as valid page */
|
||
l_flash_status = eeprom_format(area_id);
|
||
/* If erase/program operation was failed, a Flash error code is returned */
|
||
if (l_flash_status != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
//return l_flash_status;
|
||
l_flag_out=1u;
|
||
break;
|
||
}
|
||
g_eeprom_ext[area_id].first_reset_flag = EEPROM_FLAG_FIRST_RESET_CLEAR;
|
||
break;
|
||
}
|
||
}
|
||
if(l_flag_out==0u)
|
||
{
|
||
l_flash_status = EFLASH_STATUS_SUCCESS;
|
||
}
|
||
return l_flash_status;
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by :
|
||
|Preconditions :
|
||
|Input parameters : area_id: Var片区；virt_addr: Variable virtual address；data: Global variable contains the read variable value
|
||
|Output parameters :
|
||
|Return value : Success or error status:
|
||
* - 0: if variable was found
|
||
* - 1: if the variable was not found
|
||
* - EFLASH_NO_VALID_PAGE: if no valid page was found.
|
||
|Description :读取一个U32
|
||
----------------------------------------------------------------------------*/
|
||
u16 eeprom_read_one_element(u8 area_id,u16 virt_addr, u32* data)
|
||
{
|
||
u16 l_valid_page = EFLASH_PAGE0;
|
||
u16 l_addr_value = 0x5555, l_read_status = EFLASH_READ_FAILED;
|
||
u32 l_addr, l_page_start_addr;
|
||
|
||
assert_param(area_id<EEPROM_AREA_TOTAL);
|
||
|
||
/* Get active Page for read operation */
|
||
l_valid_page = eeprom_find_valid_page(area_id,EFLASH_READ_FROM_VALID_PAGE);
|
||
|
||
/* Check if there is no valid page */
|
||
if (l_valid_page == EFLASH_NO_VALID_PAGE)
|
||
{
|
||
return EFLASH_NO_VALID_PAGE;
|
||
}
|
||
|
||
/* Get the valid Page start l_addr */
|
||
l_page_start_addr = (u32)(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) + (u32)(l_valid_page * EFLASH_AREAx_MASS_PAGE_SIZE(area_id)));
|
||
#ifdef EEPROM_OPTIMIZE_SEARCH_FAST
|
||
if(eeprom_get_cur_page_id(area_id) == l_valid_page)
|
||
{
|
||
l_addr = eeprom_get_cur_end_addr(area_id);
|
||
}
|
||
else
|
||
{
|
||
l_addr = (u32)((EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) - EFLASH_OPERATION_LEN ) + (u32)((1 + l_valid_page) * EFLASH_AREAx_MASS_PAGE_SIZE(area_id) ));
|
||
}
|
||
#else
|
||
/* Get the valid Page end l_addr */
|
||
l_addr = (u32)((EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) - EFLASH_OPERATION_LEN ) + (u32)((1 + l_valid_page) * EFLASH_AREAx_MASS_PAGE_SIZE(area_id) ));
|
||
#endif
|
||
/* Check each active page address starting from end */
|
||
while (l_addr > (l_page_start_addr + EFLASH_OPERATION_LEN))
|
||
{
|
||
/* Get the current location content to be compared with virtual address */
|
||
l_addr_value = (*(__IO eflash_operate_t*)l_addr);
|
||
|
||
/* Compare the read address with the virtual address */
|
||
if (l_addr_value == (virt_addr + EEPROM_VIRT_ADDRESS_OFFSET))
|
||
{
|
||
/* Get content of l_addr-EFLASH_OPERATION_LEN which is variable value */
|
||
*data = (*(__IO eflash_operate_t*)(l_addr - EFLASH_OPERATION_LEN));
|
||
|
||
/* In case variable value is read, reset l_read_status flag */
|
||
l_read_status = EFLASH_READ_OK;
|
||
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
/* Next address location */
|
||
l_addr = l_addr - EFLASH_ELEMENT_LEN;
|
||
}
|
||
}
|
||
|
||
//如果讀取，沒有該數據，返回一個默認值
|
||
if(l_read_status!=EFLASH_READ_OK)
|
||
{
|
||
*data= EEPROM_EXT_UN_WRITE_INIT;
|
||
}
|
||
|
||
/* Return l_read_status value: (0: variable exist, 1: variable doesn't exist) */
|
||
return l_read_status;
|
||
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by :
|
||
|Preconditions :
|
||
|Input parameters : area_id: Var片区；virt_addr: 16 bit virtual address of the variable
|
||
data: 16 bit data to be written as variable value
|
||
|Output parameters :
|
||
|Return value : Success or error status:
|
||
* - EFLASH_STATUS_SUCCESS: on success
|
||
* - EFLASH_PAGE_FULL: if valid page is full
|
||
* - EFLASH_NO_VALID_PAGE: if no valid page was found
|
||
* - Flash error code: on write Flash error
|
||
|Description :快速定位地址；
|
||
----------------------------------------------------------------------------*/
|
||
void eeprom_get_current_page_addr(u8 area_id,u16 *p_valid_page,u32 *p_addr)
|
||
{
|
||
u16 l_valid_page = EFLASH_PAGE0;
|
||
//eeprom_statys_t l_status_res = EFLASH_STATUS_SUCCESS;
|
||
u32 l_current_addr = 0u;
|
||
u32 l_addr, l_page_end_addr;
|
||
|
||
/* Get active Page for read operation */
|
||
l_valid_page = eeprom_find_valid_page(area_id,EFLASH_READ_FROM_VALID_PAGE);
|
||
|
||
/* Check if there is no valid page */
|
||
if (l_valid_page == EFLASH_NO_VALID_PAGE)
|
||
{
|
||
*p_valid_page = EFLASH_NO_VALID_PAGE;
|
||
*p_addr = EFLASH_READ_NOT_VALID_ADDR_CUR; //表示没有 有效的页
|
||
return ;
|
||
}
|
||
*p_valid_page = l_valid_page;
|
||
/* Get the valid Page start l_addr */
|
||
l_addr = (u32)(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) + (u32)(l_valid_page * EFLASH_AREAx_MASS_PAGE_SIZE(area_id)) + EFLASH_PAGE_FIRST_VARIABLE_ADDRESS);
|
||
|
||
/* Get the valid Page end l_addr */
|
||
l_page_end_addr = (u32)((EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) - EFLASH_OPERATION_LEN) + (u32)((1 + l_valid_page) * EFLASH_AREAx_MASS_PAGE_SIZE(area_id)));
|
||
/* Check each active page address starting from begining */
|
||
while (l_addr <= l_page_end_addr)
|
||
{
|
||
/* Verify if l_addr and l_addr+EFLASH_OPERATION_LEN contents are all 0xF */
|
||
#if (EFLASH_OPERATION_LEN == 2)
|
||
if ((*(__IO eflash_operate_t*)l_addr) == 0xFFFFFFFF)
|
||
#elif (EFLASH_OPERATION_LEN == 4)
|
||
if (((*(__IO eflash_operate_t*)l_addr) == 0xFFFFFFFF) &&
|
||
((*(__IO eflash_operate_t*)(l_addr - EFLASH_OPERATION_LEN)) == 0xFFFFFFFF)) //我认为目前-4是合理的 因为数据在地址前面
|
||
#endif
|
||
{
|
||
/* Set variable data */
|
||
//向前找，如果先找到FFFF，则认为是空的，当前可以填的。
|
||
l_current_addr = l_addr;
|
||
*p_addr = l_current_addr;
|
||
/* Return program operation status */
|
||
return ;//l_current_addr;
|
||
}
|
||
else
|
||
{
|
||
/* Next address location */
|
||
l_addr = l_addr + EFLASH_ELEMENT_LEN;
|
||
}
|
||
}
|
||
|
||
l_current_addr = l_page_end_addr;
|
||
*p_addr = l_current_addr; //对齐到实际地址
|
||
/* Return EFLASH_PAGE_FULL in case the valid page is full */
|
||
return ;//l_current_addr;
|
||
|
||
}
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by :
|
||
|Preconditions :
|
||
|Input parameters : Erases EFLASH_PAGE0 and EFLASH_PAGE1 and writes EFLASH_VALID_PAGE header to EFLASH_PAGE0
|
||
|Output parameters :
|
||
|Return value : Status of the last operation (Flash write or erase) done during
|
||
* EEPROM formating
|
||
|Description :
|
||
----------------------------------------------------------------------------*/
|
||
eeprom_statys_t eeprom_format(u8 area_id)
|
||
{
|
||
eeprom_statys_t l_status_res = EFLASH_STATUS_SUCCESS;
|
||
u8 i;
|
||
|
||
assert_param(area_id<EEPROM_AREA_TOTAL);
|
||
|
||
/* Erase Page0 */
|
||
for(i = 0; i < EEPROM_AREAx_EFLASH_PAGE_NUM(area_id); i ++)
|
||
{
|
||
l_status_res = eeprom_erase_page(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) + i * EFLASH_PAGE_SIEZ);
|
||
if (l_status_res != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* If erase operation was failed, a Flash error code is returned */
|
||
if (l_status_res != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
return l_status_res;
|
||
}
|
||
|
||
/* Set Page0 as valid page: Write EFLASH_VALID_PAGE at Page0 base address */
|
||
l_status_res = eeprom_program_u32(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id), EFLASH_VALID_PAGE);
|
||
|
||
/* If program operation was failed, a Flash error code is returned */
|
||
if (l_status_res != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
return l_status_res;
|
||
}
|
||
|
||
/* Erase Page1 */
|
||
for(i = 0; i < EEPROM_AREAx_EFLASH_PAGE_NUM(area_id); i ++)
|
||
{
|
||
l_status_res = eeprom_erase_page(EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id) + i * EFLASH_PAGE_SIEZ);
|
||
if (l_status_res != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* Return Page1 erase operation status */
|
||
return l_status_res;
|
||
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by :
|
||
|Preconditions :
|
||
|Input parameters : area_id: Var片区 ； operation: operation to achieve on the valid page.
|
||
* This parameter can be one of the following values:
|
||
* @arg EFLASH_READ_FROM_VALID_PAGE: read operation from valid page
|
||
* @arg EFLASH_WRITE_IN_VALID_PAGE: write operation from valid page
|
||
|Output parameters :
|
||
|Return value :Valid page number (EFLASH_PAGE0 or EFLASH_PAGE1) or EFLASH_NO_VALID_PAGE in case
|
||
* of no valid page was found
|
||
|Description : Find valid Page for write or read operation
|
||
----------------------------------------------------------------------------*/
|
||
u16 eeprom_find_valid_page(u8 area_id,u8 operation)
|
||
{
|
||
u16 l_page0_status, l_page1_status;
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
#else
|
||
u16 l_page0_auxi, l_page1_auxi;
|
||
#endif
|
||
u16 l_result =0u;
|
||
assert_param(area_id<EEPROM_AREA_TOTAL);
|
||
|
||
/* Get Page0 actual status */
|
||
l_page0_status = (*(__IO eflash_operate_t*)EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id));
|
||
|
||
/* Get Page1 actual status */
|
||
l_page1_status = (*(__IO eflash_operate_t*)EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id));
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
#else
|
||
/* Get Page0 status */
|
||
l_page0_auxi = (*(__IO eflash_operate_t*)(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id)+EFLASH_OPERATION_LEN));
|
||
/* Get Page1 status */
|
||
l_page1_auxi = (*(__IO eflash_operate_t*)(EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id)+EFLASH_OPERATION_LEN));
|
||
#endif
|
||
/* Write or read operation */
|
||
switch (operation)
|
||
{
|
||
case EFLASH_WRITE_IN_VALID_PAGE: /* ---- Write operation ---- */
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
if(l_page1_status == EFLASH_VALID_PAGE)
|
||
{
|
||
if(l_page0_status == EFLASH_RECEIVE_DATA)
|
||
{
|
||
l_result = EFLASH_PAGE0; /* Page0 valid */
|
||
}
|
||
else
|
||
{
|
||
l_result = EFLASH_PAGE1; /* Page1 valid */
|
||
}
|
||
}
|
||
else if(l_page0_status == EFLASH_VALID_PAGE)
|
||
{
|
||
if(l_page1_status == EFLASH_RECEIVE_DATA)
|
||
{
|
||
l_result = EFLASH_PAGE1; /* Page1 valid */
|
||
}
|
||
else
|
||
{
|
||
l_result = EFLASH_PAGE0; /* Page0 valid */
|
||
}
|
||
}
|
||
else
|
||
{
|
||
l_result = EFLASH_NO_VALID_PAGE ; /* No valid Page */
|
||
}
|
||
#else
|
||
if ((l_page0_status == EFLASH_VALID_PAGE) && (l_page1_status == EFLASH_ERASED) )
|
||
{
|
||
l_result = EFLASH_PAGE0; /* Page0 valid */
|
||
}
|
||
else if ( (l_page1_status == EFLASH_VALID_PAGE) && (l_page0_status == EFLASH_ERASED) )
|
||
{
|
||
l_result = EFLASH_PAGE1; /* Page1 valid */
|
||
}
|
||
else if ( (l_page1_status == EFLASH_ERASED) && (l_page0_status == EFLASH_ERASED) )
|
||
{
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
#else
|
||
if(l_page0_auxi == EFLASH_RECEIVE_DATA)
|
||
{
|
||
l_result = EFLASH_PAGE0; /* Page0 valid */
|
||
}
|
||
else if(l_page1_auxi == EFLASH_RECEIVE_DATA)
|
||
{
|
||
l_result = EFLASH_PAGE1; /* Page0 valid */
|
||
}
|
||
else
|
||
#endif
|
||
{
|
||
l_result = EFLASH_NO_VALID_PAGE ; /* No valid Page */
|
||
}
|
||
}
|
||
else
|
||
{
|
||
l_result = EFLASH_NO_VALID_PAGE ; /* No valid Page */
|
||
}
|
||
#endif
|
||
break;
|
||
case EFLASH_READ_FROM_VALID_PAGE: /* ---- Read operation ---- */
|
||
if ( (l_page0_status == EFLASH_VALID_PAGE) && (l_page1_status != EFLASH_VALID_PAGE))
|
||
{
|
||
l_result = EFLASH_PAGE0; /* Page0 valid */
|
||
}
|
||
else if ((l_page1_status == EFLASH_VALID_PAGE) && (l_page0_status != EFLASH_VALID_PAGE))
|
||
{
|
||
l_result = EFLASH_PAGE1; /* Page1 valid */
|
||
}
|
||
else if ( (l_page1_status == EFLASH_ERASED) && (l_page0_status == EFLASH_ERASED) )
|
||
{
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
#else
|
||
if(l_page0_auxi == EFLASH_RECEIVE_DATA)
|
||
{
|
||
l_result = EFLASH_PAGE0; /* Page0 valid */
|
||
}
|
||
else if(l_page1_auxi == EFLASH_RECEIVE_DATA)
|
||
{
|
||
l_result = EFLASH_PAGE1; /* Page0 valid */
|
||
}
|
||
else
|
||
#endif
|
||
{
|
||
l_result = EFLASH_NO_VALID_PAGE ; /* No valid Page */
|
||
}
|
||
}
|
||
else
|
||
{
|
||
l_result = EFLASH_NO_VALID_PAGE ; /* No valid Page */
|
||
}
|
||
break;
|
||
default:
|
||
l_result = EFLASH_PAGE0; /* Page0 valid */
|
||
break;
|
||
}
|
||
return l_result;
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by :
|
||
|Preconditions :
|
||
|Input parameters : area_id: Var片区；
|
||
virt_addr: 16 bit virtual address of the variable
|
||
data: 16 bit data to be written as variable value
|
||
|Output parameters :
|
||
|Return value : Success or error status:
|
||
* - EFLASH_STATUS_SUCCESS: on success
|
||
* - EFLASH_PAGE_FULL: if valid page is full
|
||
* - EFLASH_NO_VALID_PAGE: if no valid page was found
|
||
* - Flash error code: on write Flash error
|
||
|Description : Verify if active page is full and Writes variable in EEPROM.
|
||
----------------------------------------------------------------------------*/
|
||
eeprom_statys_t eeprom_verify_page_ful_write_one_ele(u8 area_id,u16 valid_page, u16 virt_addr, u32 data)
|
||
{
|
||
|
||
eeprom_statys_t l_status_res = EFLASH_STATUS_SUCCESS;
|
||
|
||
u32 l_addr, l_page_end_addr;
|
||
|
||
#ifdef EEPROM_OPTIMIZE_SEARCH_FAST
|
||
if(eeprom_get_cur_page_id(area_id) == valid_page)
|
||
{
|
||
l_addr = eeprom_get_cur_end_addr(area_id) - EFLASH_OPERATION_LEN;
|
||
}
|
||
else
|
||
{
|
||
l_addr = (u32)(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) + (u32)(valid_page * EFLASH_AREAx_MASS_PAGE_SIZE(area_id)) + EFLASH_PAGE_FIRST_VARIABLE_ADDRESS - EFLASH_OPERATION_LEN);
|
||
}
|
||
#else
|
||
/* Get the valid Page start l_addr */
|
||
l_addr = (u32)(EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) + (u32)(valid_page * EFLASH_AREAx_MASS_PAGE_SIZE(area_id)) + EFLASH_PAGE_FIRST_VARIABLE_ADDRESS - EFLASH_OPERATION_LEN);
|
||
#endif
|
||
/* Get the valid Page end l_addr */
|
||
l_page_end_addr = (u32)((EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id) - EFLASH_OPERATION_LEN) + (u32)((1u + valid_page) * EFLASH_AREAx_MASS_PAGE_SIZE(area_id)));
|
||
|
||
/* Check each active page address starting from begining */
|
||
while (l_addr < l_page_end_addr)
|
||
{
|
||
/* Verify if l_addr and l_addr+EFLASH_OPERATION_LEN contents are all 0xF */
|
||
#if (EFLASH_OPERATION_LEN == 2)
|
||
if ((*(__IO eflash_operate_t*)l_addr) == 0xFFFFFFFF)
|
||
#elif (EFLASH_OPERATION_LEN == 4)
|
||
if (((*(__IO eflash_operate_t*)l_addr) == 0xFFFFFFFF) &&
|
||
((*(__IO eflash_operate_t*)(l_addr + EFLASH_OPERATION_LEN)) == 0xFFFFFFFF))
|
||
#endif
|
||
{
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
EEPROM_EXT_TEST1_ON(area_id);
|
||
#endif
|
||
/* Set variable data */
|
||
l_status_res = eeprom_program_u32(l_addr, data);
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
EEPROM_EXT_TEST1_OFF(area_id);
|
||
#endif
|
||
/* If program operation was failed, a Flash error code is returned */
|
||
if (l_status_res != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
return l_status_res;
|
||
}
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
EEPROM_EXT_TEST1_ON(area_id);
|
||
#endif
|
||
/* Set variable virtual address */
|
||
l_status_res = eeprom_program_u32(l_addr + EFLASH_OPERATION_LEN, (virt_addr + EEPROM_VIRT_ADDRESS_OFFSET));
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
EEPROM_EXT_TEST1_OFF(area_id);
|
||
#endif
|
||
/* Return program operation status */
|
||
return l_status_res;
|
||
}
|
||
else
|
||
{
|
||
/* Next address location */
|
||
l_addr = l_addr + EFLASH_ELEMENT_LEN;
|
||
}
|
||
}
|
||
|
||
/* Return EFLASH_PAGE_FULL in case the valid page is full */
|
||
return EFLASH_PAGE_FULL;
|
||
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by : None
|
||
|Preconditions : None
|
||
|Input parameters : area_id: Var片区
|
||
|Output parameters : None
|
||
|Return value : None
|
||
|Description : 转移
|
||
----------------------------------------------------------------------------*/
|
||
eeprom_statys_t eeprom_page_transfer(u8 area_id,u16 virt_addr, u32 data)
|
||
{
|
||
u16 l_valid_page = EFLASH_PAGE0;
|
||
eeprom_statys_t l_status_res = EFLASH_STATUS_BUSY;
|
||
u16 ReadStatus = 0;
|
||
u32 DataVar;
|
||
u8 i;
|
||
switch (g_eeprom_ext[area_id].transfer_state)
|
||
{
|
||
case EFLASH_PAGE_TRANSFER_STATE_WRITE_NEW_DATA:
|
||
/* Get active Page for read operation */
|
||
l_valid_page = eeprom_find_valid_page(area_id,EFLASH_READ_FROM_VALID_PAGE);
|
||
|
||
if (l_valid_page == EFLASH_PAGE1) /* Page1 valid */
|
||
{
|
||
/* New page address where variable will be moved to */
|
||
g_eeprom_ext[area_id].page_addr_new = EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id);
|
||
g_eeprom_ext[area_id].valid_page_new = EFLASH_PAGE0;
|
||
|
||
/* Old page address where variable will be taken from */
|
||
g_eeprom_ext[area_id].page_addr_old = EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id);
|
||
}
|
||
else if (l_valid_page == EFLASH_PAGE0) /* Page0 valid */
|
||
{
|
||
/* New page address where variable will be moved to */
|
||
g_eeprom_ext[area_id].page_addr_new = EFLASH_AREAx_PAGE1_BASE_ADDRESS(area_id);
|
||
g_eeprom_ext[area_id].valid_page_new = EFLASH_PAGE1;
|
||
|
||
/* Old page address where variable will be taken from */
|
||
g_eeprom_ext[area_id].page_addr_old = EFLASH_AREAx_PAGE0_BASE_ADDRESS(area_id);
|
||
}
|
||
else
|
||
{
|
||
return EFLASH_NO_VALID_PAGE; /* No valid Page */
|
||
}
|
||
#ifdef EEPROM_FLASH_CAN_REWRITE_TO_BIT_ZERO
|
||
l_status_res = eeprom_program_u32(g_eeprom_ext[area_id].page_addr_new, EFLASH_RECEIVE_DATA);
|
||
#else
|
||
l_status_res = eeprom_program_u32(g_eeprom_ext[area_id].page_addr_new+EFLASH_OPERATION_LEN, EFLASH_RECEIVE_DATA);
|
||
#endif
|
||
/* If program operation was failed, a Flash error code is returned */
|
||
if (l_status_res != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[0]++;
|
||
#endif
|
||
return l_status_res; //这里要不要返回
|
||
}
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
EEPROM_EXT_TEST1_ON(area_id);
|
||
#endif
|
||
/* Write the variable passed as parameter in the new active page */
|
||
l_status_res = eeprom_verify_page_ful_write_one_ele(area_id,g_eeprom_ext[area_id].valid_page_new,virt_addr, data);
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
EEPROM_EXT_TEST1_OFF(area_id);
|
||
#endif
|
||
/* If program operation was failed, a Flash error code is returned */
|
||
if (l_status_res != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[1]++;
|
||
#endif
|
||
return l_status_res; //这里要不要返回？
|
||
}
|
||
g_eeprom_ext[area_id].trans_page_count = 0;
|
||
l_status_res = EFLASH_STATUS_BUSY;
|
||
g_eeprom_ext[area_id].transfer_state = EFLASH_PAGE_TRANSFER_STATE_COPY;
|
||
g_eeprom_ext[area_id].page_addr_cur_total =1u; //从1开始，因为这个数据，就是存进去的
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[2]++;
|
||
#endif
|
||
break;
|
||
case EFLASH_PAGE_TRANSFER_STATE_COPY:
|
||
/* Transfer process: transfer vari[area_id]ables from old to the new active page */
|
||
for (i = 0u; i < 4u; i ++)
|
||
{
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[3]++;
|
||
#endif
|
||
if (g_eeprom_ext[area_id].trans_page_count != (virt_addr)) /* Check each variable except the one passed as parameter */
|
||
{
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[4]++;
|
||
#endif
|
||
/* Read the other last variable updates */
|
||
ReadStatus = eeprom_read_one_element(area_id,g_eeprom_ext[area_id].trans_page_count, &DataVar);
|
||
/* In case variable corresponding to the virtual address was found */
|
||
if (ReadStatus == EFLASH_READ_OK)
|
||
{
|
||
/* Transfer the variable to the new active page */
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
EEPROM_EXT_TEST_ON(area_id);
|
||
#endif
|
||
l_status_res = eeprom_verify_page_ful_write_one_ele(area_id,g_eeprom_ext[area_id].valid_page_new,g_eeprom_ext[area_id].trans_page_count, DataVar);
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
EEPROM_EXT_TEST_OFF(area_id);
|
||
#endif
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[5]++;
|
||
#endif
|
||
/* If program operation was failed, a Flash error code is returned */
|
||
if (l_status_res != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[6]++;
|
||
#endif
|
||
return l_status_res;
|
||
}
|
||
g_eeprom_ext[area_id].page_addr_cur_total++;
|
||
}
|
||
else
|
||
{
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[7]++;
|
||
#endif
|
||
}
|
||
}
|
||
g_eeprom_ext[area_id].trans_page_count ++;
|
||
if(g_eeprom_ext[area_id].trans_page_count >= EEPROM_AREAx_ADDR_TOTAL_U32(area_id))
|
||
{
|
||
g_eeprom_ext[area_id].trans_page_count = 0;
|
||
l_status_res = EFLASH_STATUS_BUSY;
|
||
g_eeprom_ext[area_id].eflash_page_index = 0;
|
||
g_eeprom_ext[area_id].transfer_state = EFLASH_PAGE_TRANSFER_STATE_ERASE;
|
||
g_eeprom_ext[area_id].erase_state = EFLASH_PAGE_ERASE_STATE_WAIT_LAST_OPERATION;
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[8]++;
|
||
#endif
|
||
break;
|
||
}
|
||
}
|
||
l_status_res = EFLASH_STATUS_BUSY;
|
||
break;
|
||
case EFLASH_PAGE_TRANSFER_STATE_ERASE:
|
||
|
||
l_status_res = eeprom_erase_page(g_eeprom_ext[area_id].page_addr_old + g_eeprom_ext[area_id].eflash_page_index * EFLASH_PAGE_SIEZ);
|
||
if (l_status_res != EFLASH_STATUS_SUCCESS)
|
||
{
|
||
return l_status_res;
|
||
}
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[9]++;
|
||
#endif
|
||
g_eeprom_ext[area_id].eflash_page_index ++;
|
||
if(g_eeprom_ext[area_id].eflash_page_index >= EEPROM_AREAx_EFLASH_PAGE_NUM(area_id))
|
||
{
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
EEPROM_EXT_TEST_ON(area_id);
|
||
#endif
|
||
l_status_res = eeprom_program_u32(g_eeprom_ext[area_id].page_addr_new, EFLASH_VALID_PAGE);
|
||
#ifdef EEPROM_EXT_DEBUG_IO_EN
|
||
EEPROM_EXT_TEST_OFF(area_id);
|
||
#endif
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[10]++;
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
l_status_res = EFLASH_STATUS_BUSY;
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
g_eeprom_ext_test[area_id].test_count[11]++;
|
||
#endif
|
||
}
|
||
break;
|
||
default:
|
||
l_status_res = EFLASH_STATUS_CMD_INVALID;
|
||
break;
|
||
}
|
||
return (l_status_res);
|
||
}
|
||
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by : None
|
||
|Preconditions : None
|
||
|Input parameters :
|
||
|Output parameters : None
|
||
|Return value : None
|
||
|Description :
|
||
----------------------------------------------------------------------------*/
|
||
err_flag_e ram_read_bytes_for_eeprom(u32 addr,u8 *p_data,u16 len)
|
||
{
|
||
err_flag_e l_result;
|
||
u8 *p_src;
|
||
u16 i;
|
||
|
||
if( (addr<EEPROM_RAM_ADDR_START) || (addr>EEPROM_RAM_ADDR_END) || ((addr+len)>(EEPROM_RAM_ADDR_END+1u)) )
|
||
{
|
||
l_result = ERR_FAILED;
|
||
}
|
||
else
|
||
{
|
||
p_src = (u8 *)(addr);
|
||
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
p_data[i] = p_src[i]; /*lint !e511*/
|
||
}
|
||
|
||
l_result = ERR_OK;
|
||
}
|
||
|
||
return l_result;
|
||
}
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by : None
|
||
|Preconditions : None
|
||
|Input parameters :
|
||
|Output parameters : None
|
||
|Return value : None
|
||
|Description
|
||
----------------------------------------------------------------------------*/
|
||
err_flag_e ram_write_bytes_for_eeprom(u32 addr,u8 *p_data,u16 len)
|
||
{
|
||
err_flag_e l_result;
|
||
u8 *p_addr;
|
||
u16 i;
|
||
|
||
if( (addr<EEPROM_RAM_ADDR_START) || (addr>EEPROM_RAM_ADDR_END) || ((addr+len)>(EEPROM_RAM_ADDR_END+1u)) )
|
||
{
|
||
l_result = ERR_FAILED;
|
||
}
|
||
else
|
||
{
|
||
p_addr = (u8 *)(addr);
|
||
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
p_addr[i] = p_data[i] ; /*lint !e511*/
|
||
}
|
||
|
||
l_result = ERR_OK;
|
||
}
|
||
|
||
return l_result;
|
||
}
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by : None
|
||
|Preconditions : None
|
||
|Input parameters :
|
||
|Output parameters : None
|
||
|Return value : None
|
||
|Description
|
||
----------------------------------------------------------------------------*/
|
||
u8 eeprom_read_u8_ext(u32 w_addr, u8 *p_data, u16 b_number)
|
||
{
|
||
u8 l_result ;
|
||
l_result = ram_read_bytes_for_eeprom(w_addr+EEPROM_RAM_ADDR_START,p_data,b_number);
|
||
return l_result;
|
||
}
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by : None
|
||
|Preconditions : None
|
||
|Input parameters :
|
||
|Output parameters : None
|
||
|Return value : None
|
||
|Description
|
||
----------------------------------------------------------------------------*/
|
||
u8 eeprom_write_u8_ext(u32 w_addr, u8 *p_data, u16 b_number)
|
||
{
|
||
u8 l_result ;
|
||
#ifdef EEPROM_EXT_STATE_MACHILE_ENABLE
|
||
#else
|
||
u16 l_start_addr;
|
||
u16 l_offset;
|
||
u16 l_len;
|
||
u16 i;
|
||
u32 *p_u32;
|
||
u32 l_data;
|
||
#endif
|
||
l_result = ram_write_bytes_for_eeprom(w_addr+EEPROM_RAM_ADDR_START,p_data,b_number);
|
||
#ifdef EEPROM_EXT_STATE_MACHILE_ENABLE
|
||
#else
|
||
l_offset = w_addr&(u32)0x03u;
|
||
l_start_addr = (w_addr-l_offset)/4u;
|
||
l_len = ((b_number+l_offset)/0x04u+1u);
|
||
for(i = 0; i < l_len; i++)
|
||
{
|
||
if( ((w_addr+EEPROM_RAM_ADDR_START)>=EEPROM_AREAx_RAM_ADDR_START(EEPROM_AREA_ID_0) )
|
||
&& ((w_addr+EEPROM_RAM_ADDR_START+b_number)<=EEPROM_AREAx_RAM_ADDR_END(EEPROM_AREA_ID_0) ) )
|
||
{
|
||
p_u32 = (u32*)(l_start_addr*4u+EEPROM_RAM_ADDR_START);
|
||
l_data = *p_u32;
|
||
eeprom_write_one_element_seq(EEPROM_AREA_ID_0,l_start_addr,l_data);
|
||
}
|
||
else if( ((w_addr+EEPROM_RAM_ADDR_START)>=EEPROM_AREAx_RAM_ADDR_START(EEPROM_AREA_ID_1) )
|
||
&& ((w_addr+EEPROM_RAM_ADDR_START+b_number)<=EEPROM_AREAx_RAM_ADDR_END(EEPROM_AREA_ID_1) ) )
|
||
{
|
||
p_u32 = (u32*)(l_start_addr*4u+EEPROM_RAM_ADDR_START);
|
||
l_data = *p_u32;
|
||
l_offset = (EEPROM_AREAx_RAM_ADDR_START(EEPROM_AREA_ID_1)-EEPROM_AREAx_RAM_ADDR_START(EEPROM_AREA_ID_0))/4;
|
||
eeprom_write_one_element_seq(EEPROM_AREA_ID_1,l_start_addr-l_offset,l_data);
|
||
}
|
||
else
|
||
{
|
||
|
||
}
|
||
p_u32++;
|
||
}
|
||
#endif
|
||
return l_result;
|
||
}
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by : None
|
||
|Preconditions : None
|
||
|Input parameters :
|
||
|Output parameters : None
|
||
|Return value : None
|
||
|Description
|
||
----------------------------------------------------------------------------*/
|
||
u8 eeprom_ext_get_state(u8 area_id)
|
||
{
|
||
assert_param(area_id<EEPROM_AREA_TOTAL);
|
||
return g_eeprom_ext[area_id].state;
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by : None
|
||
|Preconditions : None
|
||
|Input parameters :
|
||
|Output parameters : None
|
||
|Return value : None
|
||
|Description 初始化
|
||
----------------------------------------------------------------------------*/
|
||
void eeprom_init(void)
|
||
{
|
||
eeprom_area_init(EEPROM_AREA_ID_0);
|
||
#if EEPROM_AREA_TOTAL >1u
|
||
eeprom_area_init(EEPROM_AREA_ID_1);
|
||
#endif
|
||
}
|
||
|
||
|
||
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by : None
|
||
|Preconditions : None
|
||
|Input parameters :
|
||
|Output parameters : None
|
||
|Return value : None
|
||
|Description 任务
|
||
----------------------------------------------------------------------------*/
|
||
void eeprom_task(void)
|
||
{
|
||
eeprom_test_task();
|
||
#if 0
|
||
//if(g_eeprom_input_test.flag==0x1)
|
||
{
|
||
//g_eeprom_input_test.flag=2u;
|
||
//g_eeprom_input_test.count++;
|
||
//eeprom_ext_input_test();
|
||
//eeprom_ext_restart();
|
||
if(SVD_ISR_SVDR_Msk != FL_SVD_GetLatchedPowerStatus(SVD))
|
||
{
|
||
return ; //l_result;
|
||
}
|
||
#ifdef EEPROM_EXT_STATE_MACHILE_ENABLE
|
||
{
|
||
eeprom_state_machine_task(EEPROM_AREA_ID_0);
|
||
#if EEPROM_AREA_TOTAL >1u
|
||
eeprom_state_machine_task(EEPROM_AREA_ID_1);
|
||
#endif
|
||
}
|
||
#endif
|
||
}
|
||
#else
|
||
#ifdef EEPROM_EXT_STATE_MACHILE_ENABLE
|
||
u8 l_power_grade;
|
||
l_power_grade = system_voltage_manage_mode_get(FUNC_SYSTEM_VOLTAGE_MANAGE_ID);
|
||
if( ( (l_power_grade == SYSTEM_VOLTAGE_MODE_NORMAL) || (l_power_grade == SYSTEM_VOLTAGE_MODE_HIGH) ) //电压不能低于9v
|
||
&& (SVD_ISR_SVDR_Msk == FL_SVD_GetLatchedPowerStatus(SVD)) )
|
||
{
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
//g_eeprom_ext_test.test_count[37]++;
|
||
#endif
|
||
#ifdef EEPROM_EXT_STATE_MACHILE_ENABLE
|
||
eeprom_state_machine_task(EEPROM_AREA_ID_0);
|
||
#if EEPROM_AREA_TOTAL >1u
|
||
eeprom_state_machine_task(EEPROM_AREA_ID_1);
|
||
#endif
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
#ifdef EEPROM_EXT_DEBUG_EN
|
||
//g_eeprom_ext_test.test_count[38]++;
|
||
#endif
|
||
}
|
||
#endif
|
||
#endif
|
||
}
|
||
|
||
|
||
#if 0
|
||
//
|
||
/*---------------------------------------------------------------------------
|
||
|Prototype :
|
||
|Called by : None
|
||
|Preconditions : None
|
||
|Input parameters :
|
||
|Output parameters : None
|
||
|Return value : None
|
||
|Description 测试用
|
||
----------------------------------------------------------------------------*/
|
||
u8 eeprom_write_u8_ext1(u32 w_addr, u8 *p_data, u16 b_number)
|
||
{
|
||
u8 l_result ;
|
||
u16 l_start_addr;
|
||
u16 l_offset;
|
||
u16 l_len;
|
||
u16 i;
|
||
u32 *p_u32;
|
||
u32 l_data;
|
||
l_result = ram_write_bytes_for_eeprom(w_addr+EEPROM_RAM_ADDR_START,p_data,b_number);
|
||
#if 0 //def EEPROM_EXT_STATE_MACHILE_ENABLE
|
||
#else
|
||
l_offset = w_addr&(u32)0x03u;
|
||
l_start_addr = (w_addr-l_offset)/4u;
|
||
l_len = ((b_number+l_offset)/0x04u+1u);
|
||
for(i = 0; i < l_len; i++)
|
||
{
|
||
if( ((w_addr+EEPROM_RAM_ADDR_START)>=EEPROM_AREAx_RAM_ADDR_START(EEPROM_AREA_ID_0) )
|
||
&& ((w_addr+EEPROM_RAM_ADDR_START+b_number)<=EEPROM_AREAx_RAM_ADDR_END(EEPROM_AREA_ID_0) ) )
|
||
{
|
||
p_u32 = (u32*)(l_start_addr*4u+EEPROM_RAM_ADDR_START);
|
||
l_data = *p_u32;
|
||
eeprom_write_one_element_seq(EEPROM_AREA_ID_0,l_start_addr,l_data);
|
||
}
|
||
else if( ((w_addr+EEPROM_RAM_ADDR_START)>=EEPROM_AREAx_RAM_ADDR_START(EEPROM_AREA_ID_1) )
|
||
&& ((w_addr+EEPROM_RAM_ADDR_START+b_number)<=EEPROM_AREAx_RAM_ADDR_END(EEPROM_AREA_ID_1) ) )
|
||
{
|
||
p_u32 = (u32*)(l_start_addr*4u+EEPROM_RAM_ADDR_START);
|
||
l_data = *p_u32;
|
||
l_offset = (EEPROM_AREAx_RAM_ADDR_START(EEPROM_AREA_ID_1)-EEPROM_AREAx_RAM_ADDR_START(EEPROM_AREA_ID_0))/4;
|
||
eeprom_write_one_element_seq(EEPROM_AREA_ID_1,l_start_addr-l_offset,l_data);
|
||
}
|
||
else
|
||
{
|
||
|
||
}
|
||
p_u32++;
|
||
}
|
||
#endif
|
||
return l_result;
|
||
}
|
||
#endif
|
||
|
||
|
||
#endif
|
||
|