781 lines
25 KiB
C
781 lines
25 KiB
C
/*==========================================================================================================
|
|
Copyright (c) 2021, Quectel Wireless Solutions Co., Ltd. All rights reserved.
|
|
Quectel Wireless Solutions Proprietary and Confidential.
|
|
===========================================================================================================*/
|
|
|
|
/*==========================================================================================================
|
|
|
|
EDIT HISTORY FOR MODULE
|
|
|
|
This section contains comments describing changes made to the module.
|
|
Notice that changes are listed in reverse chronological order.
|
|
|
|
WHEN WHO WHAT, WHERE, WHY
|
|
------------ ------- -------------------------------------------------------------------------------
|
|
10/04/2022 Sharon.li 此文件是操作内部Nor Flash的(QSPI)的接口INTERNAL_NORFLASH
|
|
===========================================================================================================*/
|
|
#include "loadTable.h"
|
|
#include "quec_debug.h"
|
|
#include <string.h>
|
|
#include "loadTable.h"
|
|
#include "quec_flash.h"
|
|
#include "UART.h"
|
|
#include "qspi_nor.h"
|
|
#include <lfs_cache.h>
|
|
#include "Flash_wk.h"
|
|
|
|
#define quec_flash_printf(msg, ...) custom_log("Flash_LOG", msg, ##__VA_ARGS__)
|
|
|
|
|
|
#ifdef QUEC_LIMIT_FLASH_ERASE //分区擦除保护功能，用于实现当前分区是否可以被擦除
|
|
typedef struct
|
|
{
|
|
UINT32 start_addr; //addr not 0x80000000
|
|
UINT32 end_addr;
|
|
}QUEC_PART_ADDR_S;
|
|
|
|
typedef struct
|
|
{
|
|
char name[16];//分区名称
|
|
char erase_flag;//分区是否能被擦除 1,可以被擦除；0,不能被擦除
|
|
QUEC_PART_ADDR_S AddrInfo;//分区的结束地址和起始地址
|
|
}QUEC_PART_ADDR_TYPE_S;
|
|
|
|
QUEC_PART_ADDR_TYPE_S QUEC_PART_ADDR_TYPE_AERA[]={
|
|
{"nvm",1,NULL},
|
|
{"quec_cfg",1,NULL},
|
|
{"fota_param",1,NULL},
|
|
{"factory_a",1,NULL},
|
|
{"factory_b",1,NULL},
|
|
{"erase_rd",1,NULL},
|
|
{"bootloader",NULL},
|
|
{"ptable",0,NULL},
|
|
{"fwcerts",0,NULL},
|
|
{"rd",0,NULL},
|
|
{"cp",0,NULL},
|
|
{"dsp",0,NULL},
|
|
{"rfbin",0,NULL},
|
|
{"customer_app",1,NULL},
|
|
{"reserved",0,NULL},
|
|
{"logo",0,NULL},
|
|
};
|
|
#define QFTEST_PARTITION_COUNT_MAX (sizeof(QUEC_PART_ADDR_TYPE_AERA)/sizeof(QUEC_PART_ADDR_TYPE_AERA[0]))
|
|
UINT32 G_QftestEraseCount[QFTEST_PARTITION_COUNT_MAX] = {0};
|
|
|
|
//初始化分区信息
|
|
UINT32 CHECK_FLASH_AREA_ADDR_CONFIG(void)
|
|
{
|
|
int len = QFTEST_PARTITION_COUNT_MAX;
|
|
_ptentry *pnt;
|
|
int i;
|
|
for(i=0;i<len;i++)
|
|
{
|
|
pnt=ptable_find_entry(QUEC_PART_ADDR_TYPE_AERA[i].name);
|
|
if(pnt==NULL)
|
|
{
|
|
uart_printf("Egan_check flash not found name=%s\r\n",QUEC_PART_ADDR_TYPE_AERA[i].name);
|
|
continue;
|
|
}
|
|
QUEC_PART_ADDR_TYPE_AERA[i].AddrInfo.start_addr=pnt->start;
|
|
QUEC_PART_ADDR_TYPE_AERA[i].AddrInfo.end_addr=pnt->start + pnt->size;
|
|
// uart_printf("Egan_flash_name=%s flash_addr=0x%x flash_end=0x%x \r\n",QUEC_PART_ADDR_TYPE_AERA[i].name,QUEC_PART_ADDR_TYPE_AERA[i].AddrInfo.start_addr,QUEC_PART_ADDR_TYPE_AERA[i].AddrInfo.end_addr);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
//检查指定的Flash地址和大小是否可以被擦除
|
|
//flash_addr:要擦除Flash地址
|
|
//flash_size:擦除的大小
|
|
//rw_flag:是否记录此次擦除，0，不记录；1，记录
|
|
UINT32 FLASH_LIMIT_ALLOW_AREA(UINT32 flash_addr,UINT32 flash_size,BOOL rw_flag)
|
|
{
|
|
int len = QFTEST_PARTITION_COUNT_MAX;
|
|
int i;
|
|
QUEC_PART_ADDR_TYPE_S *ptr=QUEC_PART_ADDR_TYPE_AERA;
|
|
for(i=0;i<len;i++)
|
|
{
|
|
if((flash_addr>=ptr[i].AddrInfo.start_addr)&&((flash_addr + flash_size) <= ptr[i].AddrInfo.end_addr))
|
|
{
|
|
if((ptr[i].erase_flag==1)&&(flash_size!=NULL))
|
|
{
|
|
if(rw_flag)
|
|
G_QftestEraseCount[i]++;
|
|
break;
|
|
}
|
|
else{
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
/*****************************************************************
|
|
* Function: QUEC_PART_ADDR_TYPE_AERA_GET_CNT
|
|
*
|
|
* Description:
|
|
* 获取数组QUEC_PART_ADDR_TYPE_AERA的下标值
|
|
* Parameters:
|
|
* name [in] partition name
|
|
*
|
|
* Return:
|
|
* -1 failure
|
|
*****************************************************************/
|
|
|
|
int QUEC_PART_ADDR_TYPE_AERA_GET_CNT(const char *name)
|
|
{
|
|
int len = QFTEST_PARTITION_COUNT_MAX;
|
|
int i;
|
|
for(i=0;i<len;i++)
|
|
{
|
|
if(!strcmp(name, QUEC_PART_ADDR_TYPE_AERA[i].name))
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
#define CHIP_SECTOR_SIZE 0x1000 //erase 4k each times
|
|
UINT16 g_FlashBlkEraseCnt[1024]; //4M for nvm erea
|
|
UINT16 g_FlashBlkEraseTotal = 0;
|
|
|
|
extern UINT32 nvm_flash_start_addr;
|
|
|
|
#ifdef QUEC_FS_WEAR_BALANCE_VERIFY //QuecOpen 记录文件系统均衡的次数
|
|
UINT32 customer_fs_flash_start_addr = 0;
|
|
UINT32 gFsRWBkTotalCnt = 0; //存储文件系统擦写的总次数
|
|
UINT32 *gFsPerBkRWCnt = NULL; //存储每块block的擦写次数
|
|
UINT32 gFsTotalBkCnt = 0; //存储文件系统block的数量
|
|
#endif
|
|
|
|
|
|
|
|
//检查指定的Flash地址是否在某个分区内
|
|
//0:Flash地址不在指定的分区内;1:Flash地址在指定的分区内部
|
|
UINT32 CHECK_FLASH_AREA(const char *name,UINT32 flash_addr,UINT32 flash_size)
|
|
{
|
|
_ptentry *pnt;
|
|
pnt=ptable_find_entry(name);
|
|
if(pnt==NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
if(flash_addr>=pnt->start)
|
|
{
|
|
if((flash_addr+ flash_size)<= (pnt->start + pnt->size))
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
#define CRANE_NVM_ON_FLASH_BASE_ADD (nvm_flash_start_addr&0xF0000000)
|
|
#define CRANE_COUSTOMER_FS_ON_FLASH_BASE_ADD (customer_fs_flash_start_addr&0XF0000000)
|
|
|
|
|
|
//记录flash_addr所在分区的第几个block，被擦除的次数
|
|
UINT32 Flash_erase_count_Set(UINT32 flash_addr,UINT32 size)
|
|
{
|
|
int i=0;
|
|
|
|
UINT32 nvm_block_id=(CRANE_NVM_ON_FLASH_BASE_ADD+flash_addr-nvm_flash_start_addr)/CHIP_SECTOR_SIZE;
|
|
|
|
if(g_FlashBlkEraseCnt == NULL)
|
|
return 0;
|
|
|
|
if(CHECK_FLASH_AREA("nvm",flash_addr,size))
|
|
{
|
|
for(i=0;i*CHIP_SECTOR_SIZE<size;i++)
|
|
{
|
|
g_FlashBlkEraseCnt[nvm_block_id+i]++;
|
|
g_FlashBlkEraseTotal++;
|
|
}
|
|
}
|
|
#ifdef QUEC_FS_WEAR_BALANCE_VERIFY //QuecOpen 记录文件系统均衡的次数
|
|
if(CHECK_FLASH_AREA("customer_fs",flash_addr,size))
|
|
{
|
|
UINT32 customer_fs_block_id=(CRANE_COUSTOMER_FS_ON_FLASH_BASE_ADD+flash_addr-customer_fs_flash_start_addr)/CHIP_SECTOR_SIZE;
|
|
//RTI_LOG("flash_addr(0x%x),size(0x%x),customer_fs_block_id(0x%x)\r\n",flash_addr,size,customer_fs_block_id);
|
|
if(NULL != gFsPerBkRWCnt)
|
|
{
|
|
for(i=0;i*CHIP_SECTOR_SIZE<size;i++)
|
|
{
|
|
gFsPerBkRWCnt[customer_fs_block_id+i]++;
|
|
gFsRWBkTotalCnt++;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
|
|
void quec_norflash_get_addr(unsigned char *patition_name, unsigned int *start_addr, unsigned int *size)
|
|
{
|
|
unsigned int end_addr=0;
|
|
|
|
*start_addr=quec_get_patition_start_address((const char *)patition_name);
|
|
end_addr=quec_get_patition_end_address((const char *)patition_name);
|
|
*size=end_addr-*start_addr;
|
|
}
|
|
|
|
|
|
unsigned int quec_norflash_do_read(unsigned char *patition_name, unsigned int addr, unsigned int buf_addr, unsigned int size)
|
|
{
|
|
unsigned int ret=FLASH_RW_ERROR;
|
|
unsigned int start_address=0;
|
|
unsigned int end_address=0;
|
|
unsigned int free_size=0;
|
|
unsigned int relative_addr = 0;
|
|
|
|
relative_addr = addr&0x7FFFFFFF;
|
|
start_address=quec_get_patition_start_address((const char *)patition_name);
|
|
end_address=quec_get_patition_end_address((const char *)patition_name);
|
|
|
|
if(addr<start_address || addr>end_address)
|
|
{
|
|
uart_printf("error address param \n");
|
|
return FLASH_RW_ERROR;
|
|
}
|
|
|
|
free_size=end_address-addr;
|
|
if(size<=free_size)
|
|
{
|
|
ret = spi_nor_do_read(relative_addr, buf_addr, size, 0);
|
|
}
|
|
else
|
|
{
|
|
uart_printf("no enough free space \n");
|
|
ret = FLASH_RW_ERROR;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
unsigned int quec_norflash_do_write(unsigned char *patition_name, unsigned int addr, unsigned int buf_addr, unsigned int size)
|
|
{
|
|
unsigned int ret=FLASH_RW_ERROR;
|
|
unsigned int start_address=0;
|
|
unsigned int end_address=0;
|
|
unsigned int free_size=0;
|
|
unsigned int relative_addr = 0;
|
|
unsigned char buf[10] = {0};
|
|
|
|
relative_addr = addr&0x7FFFFFFF;
|
|
start_address=quec_get_patition_start_address((const char *)patition_name);
|
|
end_address=quec_get_patition_end_address((const char *)patition_name);
|
|
|
|
if(addr<start_address || addr>end_address)
|
|
{
|
|
uart_printf("error address param \n");
|
|
return FLASH_RW_ERROR;
|
|
}
|
|
|
|
free_size=end_address-addr;
|
|
if(size<=free_size)
|
|
{
|
|
if(size >= 8)
|
|
{
|
|
ret = spi_nor_do_write(relative_addr, buf_addr, size, 0);
|
|
|
|
}
|
|
else
|
|
{
|
|
memset(buf, 0xFF, 10);
|
|
memcpy(buf,(const void *)buf_addr, size);
|
|
ret = spi_nor_do_write(relative_addr, (unsigned int)&buf, 8, 0);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
uart_printf("no enough free space \n");
|
|
ret = FLASH_RW_ERROR;
|
|
}
|
|
return ret;
|
|
|
|
}
|
|
|
|
//erase a block for internal test
|
|
int quec_erase_block(int blk_index, unsigned int disable_protect)
|
|
{
|
|
int flash_err = 0;
|
|
lfsBlockInfo * p_blk_prop = NULL;
|
|
|
|
p_blk_prop = GetLfsBlkInfo(0);
|
|
|
|
//fatal_printf("EraseFlash_4k 0x%x 0x%x\r\n", flash_addr, size);
|
|
|
|
if(blk_index*p_blk_prop->FlashBlockSize > quec_get_patition_end_address("all"))
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
return spi_nor_do_erase_4k(blk_index*p_blk_prop->FlashBlockSize,p_blk_prop->FlashBlockSize, BOOT_FLASH);
|
|
|
|
}
|
|
|
|
//擦除,实现了非4K对齐的擦除
|
|
int quec_norflash_do_erase(unsigned char *patition_name, unsigned int addr, unsigned int size)
|
|
{
|
|
unsigned int ret = 0;
|
|
unsigned int sector_size = 4*1024;//4K
|
|
unsigned int back_recovery_size=0;
|
|
unsigned int start_address = 0;
|
|
unsigned int end_address = 0;
|
|
unsigned int free_size = 0;
|
|
unsigned int erase_size = 0;
|
|
volatile unsigned int sector_size_num = 0;
|
|
volatile unsigned int sector_addr_num = 0;
|
|
unsigned int relative_addr = 0;
|
|
unsigned char *recovery_buf1 = NULL;
|
|
unsigned char *recovery_buf2 = NULL;
|
|
|
|
relative_addr = addr&0x7FFFFFFF;
|
|
start_address = quec_get_patition_start_address((const char *)patition_name);
|
|
end_address = quec_get_patition_end_address((const char *)patition_name);
|
|
|
|
if(addr<start_address || addr>end_address)
|
|
{
|
|
uart_printf("error address param \n");
|
|
return FLASH_RW_ERROR;
|
|
}
|
|
|
|
free_size=end_address-addr;
|
|
if(size <= free_size)
|
|
{
|
|
if(relative_addr%sector_size == 0)
|
|
{
|
|
if((size%sector_size == 0))
|
|
{
|
|
ret = spi_nor_do_erase_4k(relative_addr, size, 0);
|
|
}
|
|
else
|
|
{
|
|
recovery_buf1 = malloc(sector_size);
|
|
sector_size_num = (relative_addr+size)/sector_size;
|
|
back_recovery_size = size%sector_size;
|
|
|
|
spi_nor_do_read((sector_size_num*sector_size),(unsigned int)recovery_buf1, sector_size, 0);
|
|
|
|
ret = spi_nor_do_erase_4k(relative_addr, (size - (size%sector_size) + sector_size), 0);
|
|
|
|
spi_nor_do_write((relative_addr+size),(unsigned int)(recovery_buf1+back_recovery_size), (sector_size-back_recovery_size), 0);
|
|
|
|
free(recovery_buf1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if((relative_addr+size)%sector_size ==0)
|
|
{
|
|
recovery_buf1 = malloc(sector_size);
|
|
sector_addr_num = relative_addr/sector_size;
|
|
|
|
spi_nor_do_read((sector_addr_num*sector_size), (unsigned int)recovery_buf1, sector_size, 0);
|
|
|
|
ret = spi_nor_do_erase_4k((sector_addr_num*sector_size), (size + (relative_addr%sector_size)), 0);
|
|
|
|
spi_nor_do_write((sector_addr_num*sector_size), (unsigned int)recovery_buf1, (relative_addr%sector_size), 0);
|
|
|
|
free(recovery_buf1);
|
|
}
|
|
else
|
|
{
|
|
recovery_buf1 = malloc(sector_size);
|
|
recovery_buf2 = malloc(sector_size);
|
|
|
|
sector_size_num = (relative_addr+size)/sector_size;
|
|
sector_addr_num = relative_addr/sector_size;
|
|
back_recovery_size = (relative_addr+size)%sector_size;
|
|
erase_size = (size + relative_addr%sector_size);
|
|
|
|
spi_nor_do_read((sector_addr_num*sector_size), (unsigned int)recovery_buf1, sector_size, 0);
|
|
spi_nor_do_read((sector_size_num*sector_size), (unsigned int)recovery_buf2, sector_size, 0);
|
|
|
|
ret = spi_nor_do_erase_4k((sector_addr_num*sector_size), (erase_size - (erase_size%sector_size) +sector_size), 0);
|
|
|
|
spi_nor_do_write((sector_addr_num*sector_size), (unsigned int)recovery_buf1, (relative_addr%sector_size), 0);
|
|
|
|
spi_nor_do_write((relative_addr+size), (unsigned int)(recovery_buf2+back_recovery_size), (sector_size-back_recovery_size), 0);
|
|
|
|
free(recovery_buf1);
|
|
free(recovery_buf2);
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
uart_printf("no enough free space \n");
|
|
ret = FLASH_RW_ERROR;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
extern unsigned int nor_flash_id;
|
|
//获取内部QSPI Nor Flash的id
|
|
int quec_norflash_read_id(void)
|
|
{
|
|
return nor_flash_id;
|
|
}
|
|
|
|
UINT32 get_quec_cfg_start_address(void)
|
|
{
|
|
_ptentry * QUEC_CFG_Entry= ptable_find_entry("quec_cfg");
|
|
return QUEC_CFG_Entry->vstart;
|
|
}
|
|
|
|
|
|
|
|
#ifdef QUEC_NORFLASH_ERASE_OPTIMIZE //补擦的实现
|
|
|
|
unsigned int Quec_EraseFlashExt(unsigned int addr, unsigned int size, unsigned char flashType);
|
|
unsigned int Quec_ReadFlashExt(unsigned int addr, unsigned int buf_addr, unsigned int size, unsigned char flashType);
|
|
unsigned int Quec_WriteFlashExt(unsigned int addr, unsigned int buf_addr,unsigned int size, unsigned char flashType);
|
|
|
|
UINT32 get_erase_rd_start_address(void)
|
|
{
|
|
_ptentry * erase_rd_start_Entry= ptable_find_entry("erase_rd");
|
|
if(erase_rd_start_Entry==NULL)
|
|
return NULL;
|
|
return erase_rd_start_Entry->start;
|
|
}
|
|
UINT32 get_erase_rd_bin_size(void)
|
|
{
|
|
_ptentry * erase_rd_begin_Entry= ptable_find_entry("erase_rd");
|
|
if(erase_rd_begin_Entry==NULL)
|
|
return NULL;
|
|
return erase_rd_begin_Entry->vsize;
|
|
}
|
|
|
|
extern const char USER_ERASE_RECORD_AREA[2][16]; //user 补擦区域
|
|
char ERASE_RECORD_AREA[][16]={
|
|
"nvm",
|
|
};//此数组+USER_ERASE_RECORD_AREA需要与boot33同步
|
|
|
|
int quec_repair_erase_get_parti_name_valid(char* parti_name)
|
|
{
|
|
int len =sizeof(ERASE_RECORD_AREA)/sizeof(ERASE_RECORD_AREA[0]);
|
|
_ptentry *pnt = NULL;
|
|
int i = 0;
|
|
for(i=0;i<len;i++)
|
|
{
|
|
pnt=ptable_find_entry(ERASE_RECORD_AREA[i]);
|
|
//分区存在，且属于补擦区域，必须要是内部flash
|
|
if(pnt && !strcmp(ERASE_RECORD_AREA[i], parti_name) && ((pnt->vstart & 0xF0000000) == 0x80000000))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
len =sizeof(USER_ERASE_RECORD_AREA)/sizeof(USER_ERASE_RECORD_AREA[0]);
|
|
for(i=0;i<len;i++)
|
|
{
|
|
pnt=ptable_find_entry(USER_ERASE_RECORD_AREA[i]);
|
|
//分区存在，且属于补擦区域，必须要是内部flash
|
|
if(pnt && !strcmp(USER_ERASE_RECORD_AREA[i], parti_name) && ((pnt->vstart & 0xF0000000) == 0x80000000))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
UINT32 FLASH_ERASE_RECORD_ALLOW_AREA(UINT32 flash_addr,UINT32 size)
|
|
{
|
|
int len =sizeof(ERASE_RECORD_AREA)/sizeof(ERASE_RECORD_AREA[0]);
|
|
_ptentry *pnt;
|
|
int i;
|
|
for(i=0;i<len;i++)
|
|
{
|
|
pnt=ptable_find_entry(ERASE_RECORD_AREA[i]);
|
|
//补擦的分区必须是内部分区才能判断地址范围
|
|
if(pnt && ((pnt->vstart & 0xF0000000) == 0x80000000))
|
|
{
|
|
if(flash_addr >= pnt->start)
|
|
{
|
|
if((flash_addr+size) <= (pnt->start + pnt->size))
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
len =sizeof(USER_ERASE_RECORD_AREA)/sizeof(USER_ERASE_RECORD_AREA[0]);
|
|
for(i=0;i<len;i++)
|
|
{
|
|
pnt=ptable_find_entry(USER_ERASE_RECORD_AREA[i]);
|
|
//补擦的分区必须是内部分区才能判断地址范围
|
|
if(pnt && ((pnt->vstart & 0xF0000000) == 0x80000000))
|
|
{
|
|
if(flash_addr >= pnt->start)
|
|
{
|
|
if((flash_addr+size) <= (pnt->start + pnt->size))
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
#define NoError 0x0
|
|
#define QUEC_RECORD_MAGIC1 (0x78E5D4C2)
|
|
#define QUEC_RECORD_MAGIC2 (0x54F7D60E) // only record cell 0 used , for mark record area is erase successed
|
|
#define CHIP_SECTOR_SIZE 0x1000 //erase 4k each times
|
|
#define CHIP_BLOCK_SIZE 0x10000 //erase 4k each times
|
|
|
|
typedef struct
|
|
{
|
|
UINT32 flag;// 0xAAA55AA55
|
|
UINT32 reserve;
|
|
}quec_Eraseflag_s;
|
|
|
|
typedef struct
|
|
{
|
|
UINT32 RecordMagic;
|
|
UINT32 PageId; // recored the eraseing block id ,
|
|
UINT32 Record_type; // recored the eraseing block or page
|
|
}quec_RecordInfo_s;
|
|
|
|
typedef struct
|
|
{
|
|
quec_RecordInfo_s ReInfo;
|
|
quec_Eraseflag_s Eflag;
|
|
}quec_flashErase_record_s;
|
|
|
|
|
|
UINT32 g_RecordCell = 0xffffffff;
|
|
UINT8 g_IsfirstTimeReadRecordblock = 1;
|
|
|
|
|
|
void Quec_FlashEraseRecord_step1(UINT32 flash_addr,quec_Record_type_enum type)
|
|
{
|
|
UINT32 Retval = NoError;
|
|
quec_flashErase_record_s *p_BlkEraseRecordCell = NULL;
|
|
quec_RecordInfo_s *p_BlkERCellInfo = NULL;
|
|
quec_Eraseflag_s *p_BlkERCellflag = NULL;
|
|
quec_RecordInfo_s BlkERecordCellInfo;
|
|
char *Record_buff = NULL;
|
|
int i=0, flash_BlkSize = 0;
|
|
UINT32 QUEC_RECORD_BLOCKREASE_AREA_SIZE=get_erase_rd_bin_size();
|
|
UINT32 QUEC_RECORD_BLOCKREASE_AREA_ADD=get_erase_rd_start_address();
|
|
//如果是AT补擦测试，把当前cell的reserve记录为0X12345678,需先正常记录，此次必须为第二次记录
|
|
#ifdef QUEC_FLASH_TEST_REPAIR_ERASE
|
|
if(type == QUEC_FLASH_TEST_REPAIR_ERASE)
|
|
{
|
|
quec_flashErase_record_s* now_record = (quec_flashErase_record_s*)(QUEC_RECORD_BLOCKREASE_AREA_ADD+g_RecordCell*(sizeof(quec_flashErase_record_s)));
|
|
uint32_t test_reserve_fg = 0X12345678;
|
|
Retval = Quec_WriteFlashExt((unsigned int)&now_record->Eflag.reserve, (unsigned int)&test_reserve_fg, sizeof(uint32_t), 0);
|
|
if(NoError != Retval)
|
|
{
|
|
RTI_LOG("WriteFlash failed, retval=%d, g_RecordCell=%d need Record EraseblockId=%d !!!!\r\n", Retval, g_RecordCell,BlkERecordCellInfo.PageId);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
#endif
|
|
if((!QUEC_RECORD_BLOCKREASE_AREA_SIZE)||(!QUEC_RECORD_BLOCKREASE_AREA_ADD))
|
|
{
|
|
quec_flash_printf("not found erase_rd !!!");
|
|
return ;
|
|
}
|
|
flash_BlkSize=type?CHIP_SECTOR_SIZE:CHIP_BLOCK_SIZE;
|
|
if(0 == g_IsfirstTimeReadRecordblock)
|
|
{
|
|
g_RecordCell++;
|
|
}
|
|
else
|
|
{
|
|
Record_buff = malloc(QUEC_RECORD_BLOCKREASE_AREA_SIZE);
|
|
if(NULL == Record_buff)
|
|
{
|
|
quec_flash_printf("malloc failed !!!!!!!!");
|
|
return;
|
|
}
|
|
Retval = Quec_ReadFlashExt(QUEC_RECORD_BLOCKREASE_AREA_ADD,(unsigned int)Record_buff,QUEC_RECORD_BLOCKREASE_AREA_SIZE, 0);
|
|
if( NoError != Retval)
|
|
{
|
|
|
|
if( NULL !=Record_buff )
|
|
{
|
|
free(Record_buff);
|
|
Record_buff = NULL;
|
|
}
|
|
quec_flash_printf("Flash read failed !!");
|
|
return;
|
|
}
|
|
// check record block is erase successed
|
|
p_BlkEraseRecordCell = (quec_flashErase_record_s*)Record_buff; // check the 0 cell which is mark for record area not erase
|
|
p_BlkERCellInfo = (quec_RecordInfo_s*)Record_buff;
|
|
if(QUEC_RECORD_MAGIC2 == p_BlkERCellInfo->RecordMagic && 0x00 == p_BlkERCellInfo->PageId)
|
|
{
|
|
// scan for 1 . because cell 0 is a flag which mark the block is not erase
|
|
for( i=1; i*sizeof(quec_flashErase_record_s)<QUEC_RECORD_BLOCKREASE_AREA_SIZE; i++)
|
|
{
|
|
p_BlkEraseRecordCell = (quec_flashErase_record_s*)Record_buff+i;
|
|
p_BlkERCellInfo = (quec_RecordInfo_s *)p_BlkEraseRecordCell;//
|
|
p_BlkERCellflag = (quec_Eraseflag_s *)((char *)p_BlkEraseRecordCell + sizeof(p_BlkEraseRecordCell->ReInfo));
|
|
if(( 0xffffffff == p_BlkERCellInfo->PageId ) && ( 0xffffffff == p_BlkERCellflag->flag)) // this record cell is not used
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
g_RecordCell = i;
|
|
quec_flash_printf("g_RecordCall =%d\r\n",g_RecordCell);
|
|
g_IsfirstTimeReadRecordblock = 0;
|
|
if( NULL !=Record_buff )
|
|
{
|
|
free(Record_buff);
|
|
Record_buff = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Retval = NoError;
|
|
if( 0xffffffff != p_BlkERCellInfo->RecordMagic )
|
|
{
|
|
Retval = Quec_EraseFlashExt(QUEC_RECORD_BLOCKREASE_AREA_ADD, QUEC_RECORD_BLOCKREASE_AREA_SIZE, 0);
|
|
}
|
|
if(NoError ==Retval)
|
|
{
|
|
BlkERecordCellInfo.RecordMagic = QUEC_RECORD_MAGIC2;
|
|
BlkERecordCellInfo.PageId = 0x00;
|
|
Retval = Quec_WriteFlashExt(QUEC_RECORD_BLOCKREASE_AREA_ADD, (unsigned int)&BlkERecordCellInfo, sizeof(BlkERecordCellInfo),0);
|
|
if(NoError !=Retval)
|
|
{
|
|
quec_flash_printf("[Ramos], write cell0 EraseRecord area erase flag faild !!!!!");
|
|
return ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
quec_flash_printf("[Ramos], erase record area fail !!!!!!");
|
|
return ;
|
|
}
|
|
g_RecordCell = 1; // record block erase cell form cell 1. because cell 0 used record RecordArea erase success flag
|
|
}
|
|
if( NULL !=Record_buff )
|
|
{
|
|
free(Record_buff);
|
|
Record_buff = NULL;
|
|
}
|
|
}
|
|
//quec_flashErase_record_s 20 Byte 最后一个cell不止要小于尾地址，而且范围也不能超过
|
|
if( (g_RecordCell*sizeof(quec_flashErase_record_s) >= QUEC_RECORD_BLOCKREASE_AREA_SIZE) ||
|
|
(g_RecordCell*sizeof(quec_flashErase_record_s)+sizeof(quec_flashErase_record_s) > QUEC_RECORD_BLOCKREASE_AREA_SIZE)
|
|
)
|
|
{
|
|
Retval = Quec_EraseFlashExt(QUEC_RECORD_BLOCKREASE_AREA_ADD, QUEC_RECORD_BLOCKREASE_AREA_SIZE, 0);
|
|
if(NoError ==Retval)
|
|
{
|
|
BlkERecordCellInfo.RecordMagic = QUEC_RECORD_MAGIC2;
|
|
BlkERecordCellInfo.PageId = 0x00;
|
|
Retval = Quec_WriteFlashExt(QUEC_RECORD_BLOCKREASE_AREA_ADD, (unsigned int)&BlkERecordCellInfo, sizeof(BlkERecordCellInfo),0);
|
|
if(NoError !=Retval)
|
|
{
|
|
quec_flash_printf("[Ramos], write cell0 EraseRecord area erase flag faild !!!!!");
|
|
return ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
quec_flash_printf("[Ramos], erase record area fail !!!!!!");
|
|
return ;
|
|
}
|
|
g_RecordCell = 1; // record block erase cell form cell 1. because cell 0 used record RecordArea erase success flag
|
|
}
|
|
|
|
BlkERecordCellInfo.RecordMagic = QUEC_RECORD_MAGIC1;
|
|
BlkERecordCellInfo.PageId = flash_addr/flash_BlkSize;
|
|
BlkERecordCellInfo.Record_type=type;
|
|
quec_flash_printf("addr %x type %d",flash_addr,type);
|
|
Retval = Quec_WriteFlashExt((QUEC_RECORD_BLOCKREASE_AREA_ADD+g_RecordCell*(sizeof(quec_flashErase_record_s))), (unsigned int)&(BlkERecordCellInfo), sizeof(BlkERecordCellInfo),0);
|
|
if(NoError != Retval)
|
|
{
|
|
quec_flash_printf("WriteFlash failed, retval=%d, g_RecordCell=%d need Record EraseblockId=%d !!!!", Retval, g_RecordCell,BlkERecordCellInfo.PageId);
|
|
}
|
|
memset(&BlkERecordCellInfo,0,sizeof(BlkERecordCellInfo));
|
|
Retval = Quec_ReadFlashExt((QUEC_RECORD_BLOCKREASE_AREA_ADD+g_RecordCell*(sizeof(quec_flashErase_record_s))), (unsigned int)&(BlkERecordCellInfo), sizeof(BlkERecordCellInfo),0);
|
|
if(NoError != Retval)
|
|
{
|
|
quec_flash_printf("readFlash failed, retval=%d, g_RecordCell=%d need Record EraseblockId=%d !!!!", Retval, g_RecordCell,BlkERecordCellInfo.PageId);
|
|
}
|
|
uint32_t read_record_addr = BlkERecordCellInfo.PageId * (flash_BlkSize=type?CHIP_SECTOR_SIZE:CHIP_BLOCK_SIZE);
|
|
if( (BlkERecordCellInfo.RecordMagic != QUEC_RECORD_MAGIC1) ||
|
|
(!FLASH_ERASE_RECORD_ALLOW_AREA(read_record_addr, flash_BlkSize)) ||
|
|
(BlkERecordCellInfo.Record_type != type))
|
|
{
|
|
quec_Eraseflag_s BlkERecordCellflag;
|
|
BlkERecordCellflag.flag=0xAAAA5555;
|
|
BlkERecordCellflag.reserve = 0xffffffff;
|
|
|
|
if(0xffffffff != g_RecordCell)
|
|
{
|
|
//quec_debug("[Ramos] write cell(%d) RecordEraseblock(%d) flag 0xAA55!!",g_RecordCell, flash_addr/flash_BlkSize);
|
|
Retval = Quec_WriteFlashExt((QUEC_RECORD_BLOCKREASE_AREA_ADD+g_RecordCell*sizeof(quec_flashErase_record_s)+sizeof(quec_RecordInfo_s)), (unsigned int)&BlkERecordCellflag, sizeof(BlkERecordCellflag),0);
|
|
if(NoError != Retval)
|
|
{
|
|
quec_flash_printf("WriteFlash failed, retval=%d, g_RecordCell=%d, need Record EraseblockId=%d !!", Retval,g_RecordCell, flash_addr/flash_BlkSize);
|
|
}
|
|
quec_flash_printf("magic %x addr %x type %x %x",BlkERecordCellInfo.RecordMagic,BlkERecordCellInfo.PageId * (flash_BlkSize=type?CHIP_SECTOR_SIZE:CHIP_BLOCK_SIZE),BlkERecordCellInfo.Record_type,type);
|
|
}
|
|
else
|
|
{
|
|
quec_flash_printf("g_RecordCall(0x%x) not found !! need Record EraseblockId=%d!", g_RecordCell, flash_addr/flash_BlkSize);
|
|
}
|
|
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
void Quec_FlashEraseRecord_step2(UINT32 flash_addr,quec_Record_type_enum type)
|
|
{
|
|
UINT32 Retval = NoError, flash_BlkSize = 0;
|
|
quec_Eraseflag_s BlkERecordCellflag;
|
|
UINT32 QUEC_RECORD_BLOCKREASE_AREA_SIZE=get_erase_rd_bin_size();
|
|
UINT32 QUEC_RECORD_BLOCKREASE_AREA_ADD=get_erase_rd_start_address();
|
|
if((!QUEC_RECORD_BLOCKREASE_AREA_SIZE)||(!QUEC_RECORD_BLOCKREASE_AREA_ADD))
|
|
{
|
|
quec_flash_printf("not found erase_rd !!!");
|
|
return ;
|
|
}
|
|
flash_BlkSize=type?CHIP_SECTOR_SIZE:CHIP_BLOCK_SIZE;;
|
|
|
|
if(0xffffffff != g_RecordCell)
|
|
{
|
|
Retval = Quec_ReadFlashExt((QUEC_RECORD_BLOCKREASE_AREA_ADD+g_RecordCell*sizeof(quec_flashErase_record_s)+sizeof(quec_RecordInfo_s)), (unsigned int)&BlkERecordCellflag, sizeof(BlkERecordCellflag),0);
|
|
if(NoError != Retval)
|
|
{
|
|
quec_flash_printf("readFlash failed, retval=%d, g_RecordCell=%d!!!!", Retval, g_RecordCell);
|
|
}
|
|
if(BlkERecordCellflag.flag == 0xAAAA5555)
|
|
{
|
|
quec_flash_printf("flag is already write,jump it!!!");
|
|
} else {
|
|
BlkERecordCellflag.flag=0xAAAA5555;
|
|
BlkERecordCellflag.reserve = 0xffffffff;
|
|
//quec_debug("[Ramos] write cell(%d) RecordEraseblock(%d) flag 0xAA55!!",g_RecordCell, flash_addr/flash_BlkSize);
|
|
Retval = Quec_WriteFlashExt((QUEC_RECORD_BLOCKREASE_AREA_ADD+g_RecordCell*sizeof(quec_flashErase_record_s)+sizeof(quec_RecordInfo_s)), (unsigned int)&BlkERecordCellflag, sizeof(BlkERecordCellflag),0);
|
|
if(NoError != Retval)
|
|
{
|
|
quec_flash_printf("WriteFlash failed, retval=%d, g_RecordCell=%d, need Record EraseblockId=%d !!", Retval,g_RecordCell, flash_addr/flash_BlkSize);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
quec_flash_printf("g_RecordCall(0x%x) not found !! need Record EraseblockId=%d!", g_RecordCell, flash_addr/flash_BlkSize);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|