actually, my application need to download to flash, and i need part of the flash space to store some parameters when running.
i just init flash in main and run flash_read_write_test()
hal_init_flash ();
flash_read_write_test();
i find it will crash at hal_erase_flash_sector();
could you help to check it.
void dflash_init()
{
#ifndef FLASH_TARGET
#ifdef S32K144_SERIES
MSCM->OCMDR[0u] |= MSCM_OCMDR_OCM1(0x3u);
MSCM->OCMDR[1u] |= MSCM_OCMDR_OCM1(0x3u);
#endif /* S32K144_SERIES */
#endif /* FLASH_TARGET */
hal_init_flash ();
#if 0
/* Install interrupt for Flash Command Complete event */
INT_SYS_InstallHandler(FTFC_IRQn, CCIF_Handler, (isr_t*) 0);
INT_SYS_EnableIRQ(FTFC_IRQn);
/* Enable global interrupt */
INT_SYS_EnableIRQGlobal();
#endif
}
status_t hal_init_flash (void)
{
return FLASH_DRV_Init (&Flash1_InitConfig0, &ssdConfig);
}
status_t hal_erase_flash_sector (uint32_t address, uint32_t length)
{
return FLASH_DRV_EraseSector (&ssdConfig, address, length);
}
status_t hal_write_to_flash (uint32_t address, const uint8_t *p_bufSrc,
uint32_t length)
{
status_t ret = STATUS_SUCCESS;
bool lenAligned = (length & (FEATURE_FLS_PF_BLOCK_WRITE_UNIT_SIZE - 1U))
== 0U;
bool addrAligned = (address & (FEATURE_FLS_PF_BLOCK_WRITE_UNIT_SIZE - 1U))
== 0U;
bool inBoundaries = (address >= Flash1_InitConfig0.DFlashBase)
&& ((address + length)
< (Flash1_InitConfig0.DFlashBase + FEATURE_FLS_DF_BLOCK_SIZE));
if (!lenAligned || !addrAligned || !inBoundaries)
{
ret = STATUS_ERROR;
return ret;
}
else
{
bool multiplePages = ((address % FEATURE_FLS_DF_BLOCK_SECTOR_SIZE)
+ length) > FEATURE_FLS_DF_BLOCK_SECTOR_SIZE;
if (!multiplePages) // single sector write
{
ret = hal_write_to_flash_single_sector (address, p_bufSrc, length);
}
else
{
// Write first part - could be not aligned with sector start address
uint16_t lenOfFirstWrite = FEATURE_FLS_DF_BLOCK_SECTOR_SIZE
- (address % FEATURE_FLS_DF_BLOCK_SECTOR_SIZE);
ret = hal_write_to_flash_single_sector (address, p_bufSrc,
lenOfFirstWrite);
length -= lenOfFirstWrite;
address += lenOfFirstWrite;
p_bufSrc += lenOfFirstWrite;
// Write other part of the data, which is aligned with the sector start address
while ((length > 0) & (ret == STATUS_SUCCESS))
{
ret = hal_write_to_flash_single_sector (address, p_bufSrc,
length);
address += FEATURE_FLS_DF_BLOCK_SECTOR_SIZE;
p_bufSrc += FEATURE_FLS_DF_BLOCK_SECTOR_SIZE;
length =
(length > FEATURE_FLS_DF_BLOCK_SECTOR_SIZE) ?
(length - FEATURE_FLS_DF_BLOCK_SECTOR_SIZE) : 0;
}
}
}
return ret;
}
#define FAC_CALIB_SECTOR_ADDRESS (0x10000000U)
#define FAC_CALIB_SPACE (2 * FEATURE_FLS_DF_BLOCK_SECTOR_SIZE) //4KB
uint8_t flash_read_write_test()
{
int ret = 0;
int i;
dflash_init();
int read_count = 188;
uint8_t fac_buf[read_count];
uint8_t read_buf[1024];
int read_pos = 0;
int test_time = 1;
int tmp_buf_len = (read_count/8) * 8;
uint8_t tmp_buf[tmp_buf_len];
int remain_len = 0;
int old_remain_len = 0;
memset(read_buf,0,1024);
hal_erase_flash_sector (FAC_CALIB_SECTOR_ADDRESS,FAC_CALIB_SPACE);
for(i=0;i<test_time;i++)
{
memset(fac_buf,(i+10),read_count);
memcpy(&tmp_buf[remain_len],fac_buf,tmp_buf_len-remain_len);
remain_len = read_count - tmp_buf_len + old_remain_len;
ret = hal_write_to_flash((FAC_CALIB_SECTOR_ADDRESS + i * tmp_buf_len),tmp_buf,tmp_buf_len);
//ret = hal_read_from_flash((FAC_CALIB_SECTOR_ADDRESS + i * tmp_buf_len),(read_buf + i * tmp_buf_len),tmp_buf_len);
memset(tmp_buf,0,tmp_buf_len);
if(tmp_buf_len > old_remain_len)
memcpy(tmp_buf,&fac_buf[tmp_buf_len-old_remain_len],remain_len);
else
{
printf("out of range\n");
}
old_remain_len = remain_len;
}
if(remain_len)
{
ret = hal_write_to_flash(FAC_CALIB_SECTOR_ADDRESS+ i * tmp_buf_len,tmp_buf,tmp_buf_len);
//ret = hal_read_from_flash((CALIB_SECTOR_ADDRESS + i * tmp_buf_len),(read_buf + i * tmp_buf_len),remain_len);
}
for(i=0;i<test_time;i++)
{
ret = hal_read_from_flash((FAC_CALIB_SECTOR_ADDRESS + i * read_count),(read_buf + i * read_count),read_count);
}
return ret;
}
