fstorage hang at sd_app_evt_wait()

Question

I try to using nrf_fstorage_write() to write data to fstorage and then waiting writting finish. But it hang at sd_app_evt_wait(). fstorage.h

Fullscreen 
 fstorage.c 
 Download 
 
 #include "app_timer.h"
#include "error.h"
#include "fds_flash.h"
#include "fstorage.h"
#include "nrf_delay.h"
#include "nrf_fstorage.h"
#include "nrf_fstorage_sd.h"
#include "nrf_fstorage_nvmc.h"
#include "nrf_log.h"
#include "nrf_soc.h"
#include "spi_flash.h"

#define FSTORAGE_PAGE_NUM 3
#define FSTORAGE_WAIT_CNT 1000



static bool _gFstorageInitialized = false;
static bool _gFstorageEraseDone = true;
static bool _gFstorageWriteDone = true;
static bool _gFstoragePageDirty = true;

static void _fstorageEvtHandler(nrf_fstorage_evt_t * p_evt);

NRF_FSTORAGE_DEF(nrf_fstorage_t _gFstorage) =
{
 /* Set a handler for fstorage events. */
 .evt_handler = _fstorageEvtHandler,

 /* These below are the boundaries of the flash space assigned to this instance of fstorage.
 * You must set these manually, even at runtime, before nrf_fstorage_init() is called.
 * The function nrf5_flash_end_addr_get() can be used to retrieve the last address on the
 * last page of flash available to write data. */
 .start_addr = 0x7D000,
 .end_addr = 0x80000,
};

static void _fstorageEvtHandler(nrf_fstorage_evt_t * pEvt) {
 NRF_LOG_DEBUG("Evt e
");
 switch (pEvt->id) {
 case NRF_FSTORAGE_EVT_WRITE_RESULT:
 {
 NRF_LOG_DEBUG("Evt w
");
 _gFstorageWriteDone = true;
 if (pEvt->result != NRF_SUCCESS) {
 NRF_LOG_WARNING("fstorage writing failed %d bytes at address 0x%x.",
 pEvt->len, pEvt->addr);
 } else {
 NRF_LOG_DEBUG("NRF_FSTORAGE_EVT_WRITE_RESULT ok");
 _gFstoragePageDirty = true;
 }
 } break;

 case NRF_FSTORAGE_EVT_ERASE_RESULT:
 {
 NRF_LOG_DEBUG("Evt er
");
 _gFstorageEraseDone = true;
 if (pEvt->result != NRF_SUCCESS) {
 NRF_LOG_WARNING("fstorage erased failed %d page from address 0x%x.",
 pEvt->len, pEvt->addr);
 } else {
 NRF_LOG_DEBUG("NRF_FSTORAGE_EVT_ERASE_RESULT ok");
 _gFstoragePageDirty = false;
 }
 } break;

 default:
 break;
 }
 NRF_LOG_DEBUG("Evt x
");
}

static uint32_t _fstorageGetEndAddr(void) {
 const uint32_t bootloaderAddr = BOOTLOADER_ADDRESS;
 const uint32_t pageSz = NRF_FICR->CODEPAGESIZE;
 const uint32_t codeSz = NRF_FICR->CODESIZE;

 return (bootloaderAddr != 0xFFFFFFFF ?
 bootloaderAddr : (codeSz * pageSz));
}

static uint32_t _fstorageGetStartAddr(void) {
 const uint32_t eraseUnit = _gFstorage.p_flash_info->erase_unit;
 const uint32_t endAddr = _fstorageGetEndAddr();
 const uint32_t bootloaderAddr = BOOTLOADER_ADDRESS;
 uint32_t startAddr;
 if (bootloaderAddr == 0xFFFFFFFF) {
 startAddr = endAddr - FDS_VIRTUAL_PAGES * eraseUnit; 
 } else {
 startAddr = bootloaderAddr - FSTORAGE_PAGE_NUM * eraseUnit;
 }

 NRF_LOG_DEBUG("endAddr=0x%x", endAddr);
 NRF_LOG_DEBUG("startAddr=0x%x", startAddr);
 return startAddr;
}
static bool _fstorageIsEraseNeeded(void) {
 return _gFstoragePageDirty;
} 

static uint32_t _fstorageRoundUpU32(const uint32_t len) {
 if (len % sizeof(uint32_t)) {
 return (len + sizeof(uint32_t) - (len % sizeof(uint32_t)));
 }

 return len;
}

static void power_manage(void)
{
#ifdef SOFTDEVICE_PRESENT
 (void) sd_app_evt_wait();
#else
 __WFE();
#endif
}

int _fstorageWait(const uint32_t timeOutCnt) {
#if 0
 NRF_LOG_DEBUG("timeOutCnt=%u
", timeOutCnt);
 const uint32_t startCnt = app_timer_cnt_get();
 NRF_LOG_DEBUG("startCnt=%u
", startCnt);
 uint32_t endCnt;
 uint32_t diffCnt;

 do {
 endCnt = app_timer_cnt_get();
 diffCnt = app_timer_cnt_diff_compute(endCnt, startCnt);
 if (diffCnt >= timeOutCnt) {
 NRF_LOG_WARNING("_fstorage wait timeout
");
 return ERROR_FSTORAGE_WAIT_TIMEOUT;
 }

 if (_gFstorageEraseDone && _gFstorageWriteDone) {
 break;
 }
 } while (true);

 NRF_LOG_DEBUG("endCnt=%u
", endCnt);
#else
 while (nrf_fstorage_is_busy(&_gFstorage))
 {
 power_manage();
 }
#endif
 return 0;
 
}

int _fstorageRead(const uint32_t addr, const uint32_t len, uint8_t* data) {
 if (!_gFstorageInitialized) {
 return ERROR_FSTORAGE_UNINITIALIZED;
 } 

 const ret_code_t errCode = nrf_fstorage_read(&_gFstorage, addr, data, len);
 if (errCode != NRF_SUCCESS) {
 NRF_LOG_WARNING("nrf_fstorage_read() failed 0x%x
", errCode);
 return ERROR_FSTORAGE_READ_FAIL;
 }

 return 0;
}

int _fstorageWrite(const uint32_t addr, const uint32_t len, void const* pData) {
 if (!_gFstorageInitialized) {
 return ERROR_FSTORAGE_UNINITIALIZED;
 }

 if (!_gFstorageEraseDone) {
 return ERROR_FSTORAGE_ERASE_ON_GOING;
 }

 if (!_gFstorageWriteDone) {
 return ERROR_FSTORAGE_WRITE_ON_GOING;
 }

 _gFstorageWriteDone = false;
 
 const uint32_t wlen = _fstorageRoundUpU32(len);
 const ret_code_t retCode = nrf_fstorage_write(&_gFstorage, addr, pData, wlen, NULL);
 if (retCode != NRF_SUCCESS) {
 NRF_LOG_WARNING("nrf_fstorage_write() failed 0x%x", retCode);
 return ERROR_FSTORAGE_WRITE_FAIL;
 }

 _fstorageWait(FSTORAGE_WAIT_CNT);

 return 0;
}


int fstorageInit(void) {
 _gFstorageInitialized = false;
 const ret_code_t errCode = nrf_fstorage_init(&_gFstorage, &nrf_fstorage_sd, NULL);
 if (errCode != NRF_SUCCESS) {
 NRF_LOG_WARNING("nrf_fstorage_init() failed 0x%x", errCode);
 return ERROR_FSTORAGE_INITIALIZE_FAIL;
 }

 _gFstorageInitialized = true;

 return 0;
} 

int fstorageErase(const uint32_t addr, const uint32_t pagesCnt) {
 if (!_gFstorageInitialized) {
 return ERROR_FSTORAGE_UNINITIALIZED;
 }

 if (!_gFstorageEraseDone) {
 return ERROR_FSTORAGE_ERASE_ON_GOING;
 }

 if (!_gFstorageWriteDone) {
 return ERROR_FSTORAGE_WRITE_ON_GOING;
 } 

 _gFstorageEraseDone = false;
 const ret_code_t errCode = nrf_fstorage_erase(&_gFstorage, addr, pagesCnt, NULL);
 if (errCode != NRF_SUCCESS) { 
 NRF_LOG_WARNING("nrf_fstorage_erase() failed 0x%x", errCode);
 return ERROR_FSTORAGE_ERASE_FAIL;
 }

 _fstorageWait(FSTORAGE_WAIT_CNT);
 
 return 0;
}

/*
int fstorageEraseFDS(void) {
 const uint32_t eraseUnit = _gFstorage.p_flash_info->erase_unit;
 const uint32_t endAddr = _fstorageGetEndAddr();
 const uint32_t bootloaderAddr = BOOTLOADER_ADDRESS;
 uint32_t addr;
 if (bootloaderAddr == 0xFFFFFFFF) {
 addr = endAddr - FDS_VIRTUAL_PAGES * eraseUnit; 
 } else {
 addr = bootloaderAddr - FDS_VIRTUAL_PAGES * eraseUnit;
 }
 
 const uint32_t pagesCnt = FDS_VIRTUAL_PAGES;
 const ret_code_t errCode = nrf_fstorage_erase(&_gFstorage, addr, pagesCnt, NULL);
 if (errCode != NRF_SUCCESS) { 
 NRF_LOG_WARNING("nrf_fstorage_erase() failed 0x%x
", errCode);
 return ERROR_FSTORAGE_ERASE_FAIL;
 }

 return 0;
}
*/

int fstorageReadRecord(const uint32_t addr, record_t* pRecord) {
 uint8_t data[RECORD_LEN] = {0};
 if (_fstorageRead(addr, RECORD_LEN, data) != 0) {
 return ERROR_FDS_READ_FAIL;
 }

 data2Record(data, pRecord);

 return 0;
} 

int fstorageUpdateRecord(const record_data_type_t type, const record_t* pRecord) {
 const uint32_t addr = _fstorageGetStartAddr();
 NRF_LOG_DEBUG("type=%d, add=0x%x
", type, addr);
 switch (type) {
 case RECORD_DATA_TYPE_START:
 { 
 NRF_LOG_DEBUG("RECORD_DATA_TYPE_START E
");
 if (_fstorageIsEraseNeeded()) {
 NRF_LOG_DEBUG("fstorageErase() E
");
 fstorageErase(addr, 1);
 } 
 NRF_LOG_DEBUG("fstorageWriteRecord() E
");
 record_t record;
 record.offsetStart = 0;
 record.offsetEnd = 0;
 fstorageWriteRecord(addr, &record);
 NRF_LOG_DEBUG("RECORD_DATA_TYPE_START x
");
 } 
 break;

 case RECORD_DATA_TYPE_END:
 {
 NRF_LOG_DEBUG("RECORD_DATA_TYPE_END E
");
 record_t record;
 NRF_LOG_DEBUG("fstorageReadRecord() E
");
 if (fstorageReadRecord(addr, &record) != 0) {
 return ERROR_FSTORAGE_READ_FAIL;
 }
 NRF_LOG_DEBUG("fstorageReadRecord() x
");
 NRF_LOG_DEBUG("record.offsetStart=0x%x", record.offsetStart);
 NRF_LOG_DEBUG("record.offsetEnd=0x%x", record.offsetEnd);

 if (_fstorageIsEraseNeeded()) {
 NRF_LOG_DEBUG("fstorageErase() E
");
 fstorageErase(addr, 1);
 }
 record.offsetEnd = pRecord->offsetEnd;
 NRF_LOG_DEBUG("record.offsetEnd=0x%x", record.offsetEnd);
 NRF_LOG_DEBUG("fstorageWriteRecord() E
");
 fstorageWriteRecord(addr, &record);
 NRF_LOG_DEBUG("RECORD_DATA_TYPE_END X");
 } 
 break; 
 } 

 return 0;
}

int fstorageWriteRecord(const uint32_t addr, record_t* pRecord) {
 uint8_t data[RECORD_LEN] = {0};
 record2Data(pRecord, data);
 if (_fstorageWrite(addr, RECORD_LEN, data) != 0) {
 return ERROR_FSTORAGE_WRITE_FAIL;
 }

 return 0;
}

int _fstorageWrite(const uint32_t addr, const uint32_t len, void const* pData) { if (!_gFstorageInitialized) { return ERROR_FSTORAGE_UNINITIALIZED; } 
 if (!_gFstorageEraseDone) { return ERROR_FSTORAGE_ERASE_ON_GOING; } 
 if (!_gFstorageWriteDone) { return ERROR_FSTORAGE_WRITE_ON_GOING; } 
 _gFstorageWriteDone = false; const uint32_t wlen = _fstorageRoundUpU32(len); const ret_code_t retCode = nrf_fstorage_write(&_gFstorage, addr, pData, wlen, NULL); if (retCode != NRF_SUCCESS) { NRF_LOG_WARNING("nrf_fstorage_write() failed 0x%x", retCode); return ERROR_FSTORAGE_WRITE_FAIL; } 
 _fstorageWait(FSTORAGE_WAIT_CNT); 
 return 0; }