GitHub-Mirror/bl_mcu_sdk
2
0
Fork 0
mirror of https://github.com/Fishwaldo/bl_mcu_sdk.git synced 2025-07-08 13:58:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[feat][sf] add 2 line flash program support

Browse source
This commit is contained in:
jzlv 2021-07-16 16:09:37 +08:00
parent 21e2591a25
commit 147df677b1
8 changed files with 868 additions and 340 deletions
Download patch file Download diff file Expand all files Collapse all files

1
drivers/bl602_driver/std_drv/inc/bl602_sec_eng.h
View file

@ -469,6 +469,7 @@ BL_Err_Type Sec_Eng_Trng_Enable(void);
void Sec_Eng_Trng_Int_Enable(void);
void Sec_Eng_Trng_Int_Disable(void);
BL_Err_Type Sec_Eng_Trng_Read(uint8_t data[32]);
BL_Err_Type Sec_Eng_Trng_Get_Random(uint8_t *data, uint32_t len);
void Sec_Eng_Trng_Int_Read_Trigger(void);
void Sec_Eng_Trng_Int_Read(uint8_t data[32]);
void Sec_Eng_Trng_Disable(void);

25
drivers/bl602_driver/std_drv/inc/bl602_xip_sflash_ext.h
View file

@ -38,15 +38,14 @@
#include "bl602_common.h"
#include "bl602_sflash.h"
#include "bl602_sflash_ext.h"
#include "bl602_xip_sflash.h"
#include "bl602_sf_cfg.h"
#include "bl602_sf_cfg_ext.h"
/** @addtogroup BL602_Peripheral_Driver
* @{
*/
/** @addtogroup XIP_SFLASH
/** @addtogroup XIP_SFLASH_EXT
* @{
*/
@ -71,7 +70,23 @@
/** @defgroup XIP_SFLASH_EXT_Public_Functions
* @{
*/
BL_Err_Type XIP_SFlash_State_Restore_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t offset);
BL_Err_Type XIP_SFlash_Erase_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t startaddr,
uint32_t endaddr);
BL_Err_Type XIP_SFlash_Write_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t addr,uint8_t *data,
uint32_t len);
BL_Err_Type XIP_SFlash_Read_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t addr,uint8_t *data,
uint32_t len);
BL_Err_Type XIP_SFlash_GetJedecId_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint8_t *data);
BL_Err_Type XIP_SFlash_GetDeviceId_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint8_t *data);
BL_Err_Type XIP_SFlash_GetUniqueId_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint8_t *data,
uint8_t idLen);
BL_Err_Type XIP_SFlash_RCV_Enable_Need_Lock(SPI_Flash_Cfg_Type *pFlashCfg, uint8_t rCmd, uint8_t wCmd,
uint8_t bitPos);
int XIP_SFlash_Read_With_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t addr, uint8_t *dst, int len);
int XIP_SFlash_Write_With_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t addr, uint8_t *src, int len);
int XIP_SFlash_Erase_With_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t addr, int len);
int XIP_SFlash_RCV_Enable_With_Lock(SPI_Flash_Cfg_Type *pFlashCfg, uint8_t rCmd, uint8_t wCmd, uint8_t bitPos);
BL_Err_Type XIP_SFlash_Init(SPI_Flash_Cfg_Type *pFlashCfg);
int XIP_SFlash_Read(uint32_t addr, uint8_t *dst, int len);
int XIP_SFlash_Write(uint32_t addr, uint8_t *src, int len);
@ -79,7 +94,7 @@ int XIP_SFlash_Erase(uint32_t addr, int len);
/*@} end of group XIP_SFLASH_EXT_Public_Functions */
/*@} end of group XIP_SFLASH */
/*@} end of group XIP_SFLASH_EXT */
/*@} end of group BL602_Peripheral_Driver */

8
drivers/bl602_driver/std_drv/src/bl602_mfg_flash.c
View file

@ -27,7 +27,7 @@ void main(void)
static BL_Err_Type PtTable_Flash_Read(uint32_t addr, uint8_t *data, uint32_t len)
{
XIP_SFlash_Read_Need_Lock(pFlashCfg, addr, data, len);
XIP_SFlash_Read_Need_Lock_Ext(pFlashCfg, addr, data, len);
return SUCCESS;
}
@ -68,14 +68,14 @@ static int8_t mfg_flash_program(void)
mfg_print("mfg_flash_write\r\n");
ret = XIP_SFlash_Erase_Need_Lock(pFlashCfg, rf_para_addr, rf_para_addr + 15);
ret = XIP_SFlash_Erase_Need_Lock_Ext(pFlashCfg, rf_para_addr, rf_para_addr + 15);
if (ret != SUCCESS) {
mfg_print("Flash erase error\r\n");
return -1;
}
ret = XIP_SFlash_Write_Need_Lock(pFlashCfg, rf_para_addr, (uint8_t *)&rf_para, sizeof(rf_para));
ret = XIP_SFlash_Write_Need_Lock_Ext(pFlashCfg, rf_para_addr, (uint8_t *)&rf_para, sizeof(rf_para));
if (ret != SUCCESS) {
mfg_print("Flash write error\r\n");
@ -91,7 +91,7 @@ static int8_t mfg_flash_read(void)
mfg_print("mfg_flash_read\r\n");
ret = XIP_SFlash_Read_Need_Lock(pFlashCfg, rf_para_addr, (uint8_t *)&rf_para, sizeof(rf_para));
ret = XIP_SFlash_Read_Need_Lock_Ext(pFlashCfg, rf_para_addr, (uint8_t *)&rf_para, sizeof(rf_para));
if (ret != SUCCESS) {
mfg_print("Flash write error\r\n");

37
drivers/bl602_driver/std_drv/src/bl602_sec_eng.c
View file

@ -1529,6 +1529,43 @@ BL_Err_Type Sec_Eng_Trng_Read(uint8_t data[32])
return SUCCESS;
}
/****************************************************************************/ /**
* @brief TRNG get random data out
*
* @param data: TRNG output data buffer
*
* @param len: total length to get in bytes
*
* @return SUCCESS
*
*******************************************************************************/
BL_Err_Type Sec_Eng_Trng_Get_Random(uint8_t *data, uint32_t len)
{
uint8_t tmpBuf[32];
uint32_t readLen = 0;
uint32_t i = 0, cnt = 0;
while (readLen < len) {
if (Sec_Eng_Trng_Read(tmpBuf) != SUCCESS) {
return -1;
}
cnt = len - readLen;
if (cnt > sizeof(tmpBuf)) {
cnt = sizeof(tmpBuf);
}
for (i = 0; i < cnt; i++) {
data[readLen + i] = tmpBuf[i];
}
readLen += cnt;
}
return 0;
}
/****************************************************************************/ /**
* @brief TRNG Interrupt Read Trigger
*

149
drivers/bl602_driver/std_drv/src/bl602_sf_cfg_ext.c
View file

@ -58,8 +58,7 @@
/** @defgroup SF_CFG_EXT_Private_Types
* @{
*/
typedef struct
{
typedef struct {
uint32_t jedecID;
char *name;
const SPI_Flash_Cfg_Type *cfg;
@ -104,7 +103,7 @@ static const ATTR_TCM_CONST_SECTION SPI_Flash_Cfg_Type flashCfg_FM_25Q08 = {
.fastReadQioCmd=0xeb,
.frQioDmyClk=16/8,
.cReadSupport=1,
.cReadMode = 0x20,
.cReadMode=0xa0,
.burstWrapCmd=0x77,
.burstWrapCmdDmyClk=0x3,
@ -364,6 +363,104 @@ static const ATTR_TCM_CONST_SECTION SPI_Flash_Cfg_Type flashCfg_XM25QH16 = {
.qeData=0,
};
static const ATTR_TCM_CONST_SECTION SPI_Flash_Cfg_Type flashCfg_MX_KH25={
.resetCreadCmd=0xff,
.resetCreadCmdSize=3,
.mid=0xc2,
.deBurstWrapCmd=0x77,
.deBurstWrapCmdDmyClk=0x3,
.deBurstWrapDataMode=SF_CTRL_DATA_4_LINES,
.deBurstWrapData=0xF0,
/*reg*/
.writeEnableCmd=0x06,
.wrEnableIndex=0x00,
.wrEnableBit=0x01,
.wrEnableReadRegLen=0x01,
.qeIndex=1,
.qeBit=0x01,
.qeWriteRegLen=0x01,
.qeReadRegLen=0x1,
.busyIndex=0,
.busyBit=0x00,
.busyReadRegLen=0x1,
.releasePowerDown=0xab,
.readRegCmd[0]=0x05,
.readRegCmd[1]=0x00,
.writeRegCmd[0]=0x01,
.writeRegCmd[1]=0x00,
.fastReadQioCmd=0xeb,
.frQioDmyClk=16/8,
.cReadSupport=0,
.cReadMode=0x20,
.burstWrapCmd=0x77,
.burstWrapCmdDmyClk=0x3,
.burstWrapDataMode=SF_CTRL_DATA_4_LINES,
.burstWrapData=0x40,
/*erase*/
.chipEraseCmd=0xc7,
.sectorEraseCmd=0x20,
.blk32EraseCmd=0x52,
.blk64EraseCmd=0xd8,
/*write*/
.pageProgramCmd=0x02,
.qpageProgramCmd=0x32,
.qppAddrMode=SF_CTRL_ADDR_1_LINE,
.ioMode=0x11,
.clkDelay=1,
.clkInvert=0x3f,
.resetEnCmd=0x66,
.resetCmd=0x99,
.cRExit=0xff,
.wrEnableWriteRegLen=0x00,
/*id*/
.jedecIdCmd=0x9f,
.jedecIdCmdDmyClk=0,
.qpiJedecIdCmd=0x9f,
.qpiJedecIdCmdDmyClk=0x00,
.sectorSize=4,
.pageSize=256,
/*read*/
.fastReadCmd=0x0b,
.frDmyClk=8/8,
.qpiFastReadCmd =0x0b,
.qpiFrDmyClk=8/8,
.fastReadDoCmd=0x3b,
.frDoDmyClk=8/8,
.fastReadDioCmd=0xbb,
.frDioDmyClk=0,
.fastReadQoCmd=0x6b,
.frQoDmyClk=8/8,
.qpiFastReadQioCmd=0xeb,
.qpiFrQioDmyClk=16/8,
.qpiPageProgramCmd=0x02,
.writeVregEnableCmd=0x50,
/* qpi mode */
.enterQpi=0x38,
.exitQpi=0xff,
/*AC*/
.timeEsector=300,
.timeE32k=1200,
.timeE64k=1200,
.timePagePgm=5,
.timeCe=20*1000,
.pdDelay=20,
.qeData=0,
};
static const ATTR_TCM_CONST_SECTION Flash_Info_t flashInfos[]={
{
.jedecID=0x1440A1,
@ -390,11 +487,46 @@ static const ATTR_TCM_CONST_SECTION Flash_Info_t flashInfos[] = {
//.name="XM_25QH32_32_33",
.cfg=&flashCfg_XM25QH16,
},
{
.jedecID=0x1320C2,
//.name="MX_KH40_04_33",
.cfg=&flashCfg_MX_KH25,
},
{
.jedecID=0x1420C2,
//.name="MX_KH80_08_33",
.cfg=&flashCfg_MX_KH25,
},
{
.jedecID=0x1520C2,
//.name="MX_KH16_16_33",
.cfg=&flashCfg_MX_KH25,
},
{
.jedecID=0x13325E,
//.name="ZB_D40B_80_33",
.cfg=&flashCfg_MX_KH25,
},
{
.jedecID=0x14325E,
//.name="ZB_D80B_80_33",
.cfg=&flashCfg_MX_KH25,
},
{
.jedecID=0x15605E,
//.name="ZB_25VQ16_16_33",
.cfg=&flashCfg_XM25QH16,
},
{
.jedecID=0x15345E,
//.name="ZB_25WQ16_16_33",
.cfg=&flashCfg_XM25QH16,
},
{
.jedecID=0x1560EB,
//.name="TH_25Q16",
.cfg=&flashCfg_FM_25Q08,
},
};
/*@} end of group SF_CFG_EXT_Private_Variables */
@ -432,21 +564,18 @@ BL_Err_Type ATTR_TCM_SECTION SF_Cfg_Get_Flash_Cfg_Need_Lock_Ext(uint32_t flashID
if(flashID==0){
XIP_SFlash_Read_Via_Cache_Need_Lock(8+BL602_FLASH_XIP_BASE,buf,sizeof(SPI_Flash_Cfg_Type)+8);
if(BL602_MemCmp(buf,BFLB_FLASH_CFG_MAGIC,4)==0){
crc=BFLB_Soft_CRC32((uint8_t *)buf+4,sizeof(SPI_Flash_Cfg_Type));
pCrc=(uint32_t *)(buf+4+sizeof(SPI_Flash_Cfg_Type));
if(*pCrc==crc){
BL602_MemCpy_Fast(pFlashCfg,(uint8_t *)buf+4,sizeof(SPI_Flash_Cfg_Type));
return SUCCESS ;
}
}
}else{
if (SF_Cfg_Get_Flash_Cfg_Need_Lock(flashID, pFlashCfg)) {
if(SF_Cfg_Get_Flash_Cfg_Need_Lock(flashID, pFlashCfg) == SUCCESS){
return SUCCESS;
}
for(i=0;i<sizeof(flashInfos)/sizeof(flashInfos[0]);i++){
if(flashInfos[i].jedecID==flashID){
BL602_MemCpy_Fast(pFlashCfg,flashInfos[i].cfg,sizeof(SPI_Flash_Cfg_Type));
@ -478,20 +607,20 @@ uint32_t ATTR_TCM_SECTION SF_Cfg_Flash_Identify_Ext(uint8_t callFromFlash,
uint32_t ret=0;
ret=SF_Cfg_Flash_Identify(callFromFlash,autoScan,flashPinCfg,restoreDefault,pFlashCfg);
if(callFromFlash){
SFlash_Set_IDbus_Cfg(pFlashCfg,pFlashCfg->ioMode&0xf,1,0,32);
}
if((ret&BFLB_FLASH_ID_VALID_FLAG)!=0){
return ret;
}
jdecId=(ret&0xffffff);
for(i=0;i<sizeof(flashInfos)/sizeof(flashInfos[0]);i++){
if(flashInfos[i].jedecID==jdecId){
BL602_MemCpy_Fast(pFlashCfg,flashInfos[i].cfg,sizeof(SPI_Flash_Cfg_Type));
break;
}
}
if(i==sizeof(flashInfos)/sizeof(flashInfos[0])){
return jdecId;
}else{

35
drivers/bl602_driver/std_drv/src/bl602_timer.c
View file

@ -399,12 +399,45 @@ BL_Err_Type TIMER_Init(TIMER_CFG_Type *timerCfg)
if (timerCfg->countMode == TIMER_COUNT_PRELOAD) {
/* Configure timer preload value */
TIMER_SetPreloadValue(timerCh, timerCfg->preLoadVal);
}
/* Configure match compare values */
if (timerCfg->matchVal0 > 1 + timerCfg->preLoadVal) {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_0, timerCfg->matchVal0 - 2);
} else {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_0, timerCfg->matchVal0);
}
if (timerCfg->matchVal1 > 1 + timerCfg->preLoadVal) {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_1, timerCfg->matchVal1 - 2);
} else {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_1, timerCfg->matchVal1);
}
if (timerCfg->matchVal2 > 1 + timerCfg->preLoadVal) {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_2, timerCfg->matchVal2 - 2);
} else {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_2, timerCfg->matchVal2);
}
} else {
/* Configure match compare values */
if (timerCfg->matchVal0 > 1) {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_0, timerCfg->matchVal0 - 2);
} else {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_0, timerCfg->matchVal0);
}
if (timerCfg->matchVal1 > 1) {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_1, timerCfg->matchVal1 - 2);
} else {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_1, timerCfg->matchVal1);
}
if (timerCfg->matchVal2 > 1) {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_2, timerCfg->matchVal2 - 2);
} else {
TIMER_SetCompValue(timerCh, TIMER_COMP_ID_2, timerCfg->matchVal2);
}
}
#ifndef BFLB_USE_HAL_DRIVER
Interrupt_Handler_Register(TIMER_CH0_IRQn, TIMER_CH0_IRQHandler);

325
drivers/bl602_driver/std_drv/src/bl602_xip_sflash_ext.c
View file

@ -35,13 +35,16 @@
*/
#include "string.h"
#include "bl602_sf_cfg.h"
#include "bl602_sf_cfg_ext.h"
#include "bl602_xip_sflash.h"
#include "bl602_xip_sflash_ext.h"
/** @addtogroup BL602_Peripheral_Driver
* @{
*/
/** @addtogroup XIP_SFLASH
/** @addtogroup XIP_SFLASH_EXT
* @{
*/
@ -82,6 +85,318 @@ static uint8_t aesEnable;
* @{
*/
/*@} end of group XIP_SFLASH_EXT_Private_Functions */
/** @defgroup XIP_SFLASH_EXT_Public_Functions
* @{
*/
/****************************************************************************//**
* @brief Restore flash controller state
*
* @param pFlashCfg: Flash config pointer
* @param offset: CPU XIP flash offset
*
* @return SUCCESS or ERROR
*
*******************************************************************************/
__WEAK
BL_Err_Type ATTR_TCM_SECTION XIP_SFlash_State_Restore_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t offset)
{
uint32_t tmp[1];
SF_Ctrl_IO_Type ioMode = (SF_Ctrl_IO_Type)pFlashCfg->ioMode&0xf;
SF_Ctrl_Set_Flash_Image_Offset(offset);
SFlash_SetBurstWrap(pFlashCfg);
SFlash_Read(pFlashCfg,ioMode,1,0x0,(uint8_t *)tmp, sizeof(tmp));
SFlash_Set_IDbus_Cfg(pFlashCfg,ioMode,1,0,32);
return SUCCESS;
}
/*@} end of group XIP_SFLASH_EXT_Public_Functions */
/** @defgroup XIP_SFLASH_EXT_Public_Functions
* @{
*/
/****************************************************************************//**
* @brief Erase flash one region
*
* @param pFlashCfg: Flash config pointer
* @param startaddr: start address to erase
* @param endaddr: end address(include this address) to erase
*
* @return SUCCESS or ERROR
*
*******************************************************************************/
__WEAK
BL_Err_Type ATTR_TCM_SECTION XIP_SFlash_Erase_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t startaddr,uint32_t endaddr)
{
BL_Err_Type stat;
uint32_t offset;
SF_Ctrl_IO_Type ioMode = (SF_Ctrl_IO_Type)pFlashCfg->ioMode&0xf;
stat=XIP_SFlash_State_Save(pFlashCfg,&offset);
if(stat!=SUCCESS){
SFlash_Set_IDbus_Cfg(pFlashCfg,ioMode,1,0,32);
}else{
stat=SFlash_Erase(pFlashCfg,startaddr,endaddr);
XIP_SFlash_State_Restore_Ext(pFlashCfg,offset);
}
return stat;
}
/****************************************************************************//**
* @brief Program flash one region
*
* @param pFlashCfg: Flash config pointer
* @param addr: start address to be programed
* @param data: data pointer to be programed
* @param len: data length to be programed
*
* @return SUCCESS or ERROR
*
*******************************************************************************/
__WEAK
BL_Err_Type ATTR_TCM_SECTION XIP_SFlash_Write_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t addr,uint8_t *data, uint32_t len)
{
BL_Err_Type stat;
uint32_t offset;
SF_Ctrl_IO_Type ioMode = (SF_Ctrl_IO_Type)pFlashCfg->ioMode&0xf;
stat=XIP_SFlash_State_Save(pFlashCfg,&offset);
if(stat!=SUCCESS){
SFlash_Set_IDbus_Cfg(pFlashCfg,ioMode,1,0,32);
}else{
stat= SFlash_Program(pFlashCfg,ioMode,addr,data,len);
XIP_SFlash_State_Restore_Ext(pFlashCfg,offset);
}
return stat;
}
/****************************************************************************//**
* @brief Read data from flash
*
* @param pFlashCfg: Flash config pointer
* @param addr: flash read start address
* @param data: data pointer to store data read from flash
* @param len: data length to read
*
* @return SUCCESS or ERROR
*
*******************************************************************************/
__WEAK
BL_Err_Type ATTR_TCM_SECTION XIP_SFlash_Read_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t addr,uint8_t *data, uint32_t len)
{
BL_Err_Type stat;
uint32_t offset;
SF_Ctrl_IO_Type ioMode = (SF_Ctrl_IO_Type)pFlashCfg->ioMode&0xf;
stat=XIP_SFlash_State_Save(pFlashCfg,&offset);
if(stat!=SUCCESS){
SFlash_Set_IDbus_Cfg(pFlashCfg,ioMode,1,0,32);
}else{
stat=SFlash_Read(pFlashCfg,ioMode,0,addr, data,len);
XIP_SFlash_State_Restore_Ext(pFlashCfg,offset);
}
return stat;
}
/****************************************************************************//**
* @brief Get Flash Jedec ID
*
* @param pFlashCfg: Flash config pointer
* @param data: data pointer to store Jedec ID Read from flash
*
* @return SUCCESS or ERROR
*
*******************************************************************************/
__WEAK
BL_Err_Type ATTR_TCM_SECTION XIP_SFlash_GetJedecId_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint8_t *data)
{
BL_Err_Type stat;
uint32_t offset;
SF_Ctrl_IO_Type ioMode = (SF_Ctrl_IO_Type)pFlashCfg->ioMode&0xf;
stat=XIP_SFlash_State_Save(pFlashCfg,&offset);
if(stat!=SUCCESS){
SFlash_Set_IDbus_Cfg(pFlashCfg,ioMode,1,0,32);
}else{
SFlash_GetJedecId(pFlashCfg,data);
XIP_SFlash_State_Restore_Ext(pFlashCfg,offset);
}
return SUCCESS;
}
/****************************************************************************//**
* @brief Get Flash Device ID
*
* @param pFlashCfg: Flash config pointer
* @param data: data pointer to store Device ID Read from flash
*
* @return SUCCESS or ERROR
*
*******************************************************************************/
__WEAK
BL_Err_Type ATTR_TCM_SECTION XIP_SFlash_GetDeviceId_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint8_t *data)
{
BL_Err_Type stat;
uint32_t offset;
SF_Ctrl_IO_Type ioMode = (SF_Ctrl_IO_Type)pFlashCfg->ioMode&0xf;
stat=XIP_SFlash_State_Save(pFlashCfg,&offset);
if(stat!=SUCCESS){
SFlash_Set_IDbus_Cfg(pFlashCfg,ioMode,1,0,32);
}else{
SFlash_GetDeviceId(data);
XIP_SFlash_State_Restore_Ext(pFlashCfg,offset);
}
return SUCCESS;
}
/****************************************************************************//**
* @brief Get Flash Unique ID
*
* @param pFlashCfg: Flash config pointer
* @param data: data pointer to store Device ID Read from flash
* @param idLen: Unique id len
*
* @return SUCCESS or ERROR
*
*******************************************************************************/
__WEAK
BL_Err_Type ATTR_TCM_SECTION XIP_SFlash_GetUniqueId_Need_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint8_t *data,uint8_t idLen)
{
BL_Err_Type stat;
uint32_t offset;
SF_Ctrl_IO_Type ioMode = (SF_Ctrl_IO_Type)pFlashCfg->ioMode&0xf;
stat=XIP_SFlash_State_Save(pFlashCfg,&offset);
if(stat!=SUCCESS){
SFlash_Set_IDbus_Cfg(pFlashCfg,ioMode,1,0,32);
}else{
SFlash_GetUniqueId(data,idLen);
XIP_SFlash_State_Restore_Ext(pFlashCfg,offset);
}
return SUCCESS;
}
/****************************************************************************//**
* @brief Sflash enable RCV mode to recovery for erase while power drop need lock
*
* @param pFlashCfg: Flash config pointer
* @param rCmd: Read RCV register cmd
* @param wCmd: Write RCV register cmd
* @param bitPos: RCV register bit pos
*
* @return SUCCESS or ERROR
*
*******************************************************************************/
__WEAK
BL_Err_Type ATTR_TCM_SECTION XIP_SFlash_RCV_Enable_Need_Lock(SPI_Flash_Cfg_Type *pFlashCfg, uint8_t rCmd, uint8_t wCmd, uint8_t bitPos)
{
BL_Err_Type stat;
uint32_t offset;
SF_Ctrl_IO_Type ioMode = (SF_Ctrl_IO_Type)pFlashCfg->ioMode&0xf;
stat=XIP_SFlash_State_Save(pFlashCfg,&offset);
if(stat!=SUCCESS){
SFlash_Set_IDbus_Cfg(pFlashCfg,ioMode,1,0,32);
}else{
stat=SFlash_RCV_Enable(pFlashCfg, rCmd, wCmd, bitPos);
XIP_SFlash_State_Restore_Ext(pFlashCfg,offset);
}
return stat;
}
/****************************************************************************//**
* @brief Read data from flash with lock
*
* @param pFlashCfg: Flash config pointer
* @param addr: flash read start address
* @param dst: data pointer to store data read from flash
* @param len: data length to read
*
* @return 0
*
*******************************************************************************/
__WEAK
int ATTR_TCM_SECTION XIP_SFlash_Read_With_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t addr, uint8_t *dst, int len)
{
__disable_irq();
XIP_SFlash_Read_Need_Lock_Ext(pFlashCfg, addr, dst, len);
__enable_irq();
return 0;
}
/****************************************************************************//**
* @brief Program flash one region with lock
*
* @param pFlashCfg: Flash config pointer
* @param addr: Start address to be programed
* @param src: Data pointer to be programed
* @param len: Data length to be programed
*
* @return 0
*
*******************************************************************************/
__WEAK
int ATTR_TCM_SECTION XIP_SFlash_Write_With_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t addr, uint8_t *src, int len)
{
__disable_irq();
XIP_SFlash_Write_Need_Lock_Ext(pFlashCfg, addr, src, len);
__enable_irq();
return 0;
}
/****************************************************************************//**
* @brief Erase flash one region with lock
*
* @param pFlashCfg: Flash config pointer
* @param addr: Start address to be erased
* @param len: Data length to be erased
*
* @return 0
*
*******************************************************************************/
__WEAK
int ATTR_TCM_SECTION XIP_SFlash_Erase_With_Lock_Ext(SPI_Flash_Cfg_Type *pFlashCfg,uint32_t addr, int len)
{
__disable_irq();
XIP_SFlash_Erase_Need_Lock_Ext(pFlashCfg, addr, addr + len - 1);
__enable_irq();
return 0;
}
/****************************************************************************//**
* @brief Sflash enable RCV mode to recovery for erase while power drop with lock
*
* @param pFlashCfg: Flash config pointer
* @param rCmd: Read RCV register cmd
* @param wCmd: Write RCV register cmd
* @param bitPos: RCV register bit pos
*
* @return 0
*
*******************************************************************************/
__WEAK
int ATTR_TCM_SECTION XIP_SFlash_RCV_Enable_With_Lock(SPI_Flash_Cfg_Type *pFlashCfg, uint8_t rCmd, uint8_t wCmd, uint8_t bitPos)
{
__disable_irq();
XIP_SFlash_RCV_Enable_Need_Lock(pFlashCfg, rCmd, wCmd, bitPos);
__enable_irq();
return 0;
}
/****************************************************************************//**
* @brief Read data from flash with lock
*
@ -100,7 +415,6 @@ BL_Err_Type ATTR_TCM_SECTION XIP_SFlash_Init(SPI_Flash_Cfg_Type *pFlashCfg)
XIP_SFlash_Opt_Enter(&aesEnable);
ret=SF_Cfg_Flash_Identify_Ext(1,1,0,0,&flashCfg);
XIP_SFlash_Opt_Exit(aesEnable);
if((ret&BFLB_FLASH_ID_VALID_FLAG)==0){
return ERROR;
}
@ -126,7 +440,7 @@ int ATTR_TCM_SECTION XIP_SFlash_Read(uint32_t addr, uint8_t *dst, int len)
{
__disable_irq();
XIP_SFlash_Opt_Enter(&aesEnable);
XIP_SFlash_Read_Need_Lock(&flashCfg, addr, dst, len);
XIP_SFlash_Read_Need_Lock_Ext(&flashCfg, addr, dst, len);
XIP_SFlash_Opt_Exit(aesEnable);
__enable_irq();
return 0;
@ -147,7 +461,7 @@ int ATTR_TCM_SECTION XIP_SFlash_Write(uint32_t addr, uint8_t *src, int len)
{
__disable_irq();
XIP_SFlash_Opt_Enter(&aesEnable);
XIP_SFlash_Write_Need_Lock(&flashCfg, addr, src, len);
XIP_SFlash_Write_Need_Lock_Ext(&flashCfg, addr, src, len);
XIP_SFlash_Opt_Exit(aesEnable);
__enable_irq();
return 0;
@ -167,12 +481,11 @@ int ATTR_TCM_SECTION XIP_SFlash_Erase(uint32_t addr, int len)
{
__disable_irq();
XIP_SFlash_Opt_Enter(&aesEnable);
XIP_SFlash_Erase_Need_Lock(&flashCfg, addr, addr + len - 1);
XIP_SFlash_Erase_Need_Lock_Ext(&flashCfg, addr, addr + len - 1);
XIP_SFlash_Opt_Exit(aesEnable);
__enable_irq();
return 0;
}
/*@} end of group XIP_SFLASH_EXT_Public_Functions */
/*@} end of group XIP_SFLASH_EXT */