solve #9, disable softdevice when upgrading with uf2 file

This commit is contained in:
hathach 2018-08-08 18:01:09 +07:00
parent 69ff86ffd2
commit 25671db338
3 changed files with 23 additions and 70 deletions

View File

@ -196,7 +196,7 @@ void board_init(void)
// Init scheduler // Init scheduler
APP_SCHED_INIT(SCHED_MAX_EVENT_DATA_SIZE, SCHED_QUEUE_SIZE); APP_SCHED_INIT(SCHED_MAX_EVENT_DATA_SIZE, SCHED_QUEUE_SIZE);
// Init timer (RTC1) // Init app timer (use RTC1)
app_timer_init(); app_timer_init();
// Configure Systick for led blinky // Configure Systick for led blinky
@ -230,7 +230,7 @@ void board_teardown(void)
* be initialized if a chip reset has occured. Soft reset (jump ) from * be initialized if a chip reset has occured. Soft reset (jump ) from
* application must not reinitialize the SoftDevice. * application must not reinitialize the SoftDevice.
*/ */
static uint32_t softdev_init(bool init_softdevice) uint32_t softdev_init(bool init_softdevice)
{ {
if (init_softdevice) if (init_softdevice)
{ {
@ -292,18 +292,19 @@ static uint32_t softdev_init(bool init_softdevice)
APP_ERROR_CHECK( sd_ble_cfg_set(BLE_CONN_CFG_GAP, &blecfg, ram_start) ); APP_ERROR_CHECK( sd_ble_cfg_set(BLE_CONN_CFG_GAP, &blecfg, ram_start) );
// Enable BLE stack. // Enable BLE stack.
// Note: Interrupt state (enabled, forwarding) is not work properly if not enable ble
APP_ERROR_CHECK( sd_ble_enable(&ram_start) ); APP_ERROR_CHECK( sd_ble_enable(&ram_start) );
return NRF_SUCCESS; return NRF_SUCCESS;
} }
uint32_t softdev_teardown(void) void softdev_teardown(void)
{ {
APP_ERROR_CHECK ( sd_softdevice_disable() ); sd_softdevice_disable();
return NRF_SUCCESS;
} }
int main(void) int main(void)
{ {
// SD is already Initialized in case of BOOTLOADER_DFU_OTA_MAGIC // SD is already Initialized in case of BOOTLOADER_DFU_OTA_MAGIC
@ -350,6 +351,9 @@ int main(void)
if ( dfu_start || !bootloader_app_is_valid(DFU_BANK_0_REGION_START) ) if ( dfu_start || !bootloader_app_is_valid(DFU_BANK_0_REGION_START) )
{ {
// Enable BLE if in OTA
// if ( _ota_update ) softdev_ble_enable();
// Initiate an update of the firmware. // Initiate an update of the firmware.
APP_ERROR_CHECK( bootloader_dfu_start(_ota_update, 0) ); APP_ERROR_CHECK( bootloader_dfu_start(_ota_update, 0) );
} }

View File

@ -38,8 +38,6 @@
#if CFG_TUD_MSC #if CFG_TUD_MSC
#include "pstorage.h"
/*------------------------------------------------------------------*/ /*------------------------------------------------------------------*/
/* MACRO TYPEDEF CONSTANT ENUM /* MACRO TYPEDEF CONSTANT ENUM
*------------------------------------------------------------------*/ *------------------------------------------------------------------*/

View File

@ -8,8 +8,6 @@
#include "bootloader_settings.h" #include "bootloader_settings.h"
#include "bootloader.h" #include "bootloader.h"
#include "pstorage.h"
typedef struct { typedef struct {
uint8_t JumpInstruction[3]; uint8_t JumpInstruction[3];
@ -125,13 +123,8 @@ static const FAT_BootBlock BootBlock = {
uint32_t flashAddr = NO_CACHE; uint32_t flashAddr = NO_CACHE;
uint8_t flashBuf[FLASH_PAGE_SIZE] __attribute__((aligned(4))); uint8_t flashBuf[FLASH_PAGE_SIZE] __attribute__((aligned(4)));
bool firstFlush = true; bool firstFlush = true;
//bool hadWrite = false;
static WriteState _wr_state = { 0 }; static WriteState _wr_state = { 0 };
static WriteState* state = &_wr_state;
volatile bool _is_flashing = false;
static pstorage_handle_t _fat_psh = { .module_id = 0, .block_id = USER_FLASH_END } ;
static uint32_t get_flash_size(void) static uint32_t get_flash_size(void)
{ {
static uint32_t flash_sz = 0; static uint32_t flash_sz = 0;
@ -234,8 +227,8 @@ void read_block(uint32_t block_no, uint8_t *data) {
/* Write UF2 /* Write UF2
*------------------------------------------------------------------*/ *------------------------------------------------------------------*/
/** inform bootloader to update setting and reset */ /** uf2 upgrade complete -> inform bootloader to update setting and reset */
static void uf2_write_complete(void) static void uf2_write_complete(uint32_t numBlocks)
{ {
led_blink_fast(false); led_blink_fast(false);
@ -244,37 +237,15 @@ static void uf2_write_complete(void)
memset(&update_status, 0, sizeof(dfu_update_status_t )); memset(&update_status, 0, sizeof(dfu_update_status_t ));
update_status.status_code = DFU_UPDATE_APP_COMPLETE; update_status.status_code = DFU_UPDATE_APP_COMPLETE;
update_status.app_crc = 0; // skip CRC checking with uf2 upgrade update_status.app_crc = 0; // skip CRC checking with uf2 upgrade
update_status.app_size = state->numBlocks*256; update_status.app_size = numBlocks*256;
// re-enable softdevice
extern uint32_t softdev_init(bool init_softdevice);
softdev_init(false);
bootloader_dfu_update_process(update_status); bootloader_dfu_update_process(update_status);
} }
static void fat_pstorage_cb(pstorage_handle_t * p_handle, uint8_t op_code, uint32_t result, uint8_t * p_data, uint32_t data_len)
{
if ( result != NRF_SUCCESS )
{
TU_ASSERT(false, );
}
if ( PSTORAGE_CLEAR_OP_CODE == op_code)
{
// erase complete start writing
_fat_psh.block_id = p_handle->block_id;
TU_ASSERT( pstorage_store(&_fat_psh, flashBuf, FLASH_PAGE_SIZE, 0), );
}
else if ( PSTORAGE_STORE_OP_CODE == op_code)
{
// write completes
_is_flashing = false;
// whole uf2 file is written, complete the write op
if ( state->numWritten >= state->numBlocks )
{
uf2_write_complete();
}
}
}
void flushFlash() { void flushFlash() {
if (flashAddr == NO_CACHE) if (flashAddr == NO_CACHE)
return; return;
@ -282,9 +253,8 @@ void flushFlash() {
if (firstFlush) { if (firstFlush) {
firstFlush = false; firstFlush = false;
// Init pstorage // disable softdevice
pstorage_module_param_t fat_psp = { .cb = fat_pstorage_cb}; sd_softdevice_disable();
pstorage_register(&fat_psp, &_fat_psh);
led_blink_fast(true); led_blink_fast(true);
} }
@ -292,11 +262,8 @@ void flushFlash() {
NRF_LOG_DEBUG("Flush at %x", flashAddr); NRF_LOG_DEBUG("Flush at %x", flashAddr);
if (memcmp(flashBuf, (void *)flashAddr, FLASH_PAGE_SIZE) != 0) { if (memcmp(flashBuf, (void *)flashAddr, FLASH_PAGE_SIZE) != 0) {
NRF_LOG_DEBUG("Write flush at %x", flashAddr); NRF_LOG_DEBUG("Write flush at %x", flashAddr);
_is_flashing = true; nrf_nvmc_page_erase(flashAddr);
nrf_nvmc_write_words(flashAddr, (uint32_t *)flashBuf, FLASH_PAGE_SIZE / sizeof(uint32_t));
// Writing to flash will be done in erase complete callback
_fat_psh.block_id = flashAddr;
TU_ASSERT ( pstorage_clear(&_fat_psh, FLASH_PAGE_SIZE), );
} }
flashAddr = NO_CACHE; flashAddr = NO_CACHE;
@ -305,15 +272,8 @@ void flushFlash() {
void flash_write(uint32_t dst, const uint8_t *src, int len) { void flash_write(uint32_t dst, const uint8_t *src, int len) {
uint32_t newAddr = dst & ~(FLASH_PAGE_SIZE - 1); uint32_t newAddr = dst & ~(FLASH_PAGE_SIZE - 1);
// hadWrite = true;
if (newAddr != flashAddr) { if (newAddr != flashAddr) {
flushFlash(); flushFlash();
// writing previous cached data, skip current data until flashing is done
// tinyusb stack will invoke write_block() with the same parameters later on
if ( _is_flashing ) return;
flashAddr = newAddr; flashAddr = newAddr;
memcpy(flashBuf, (void *)newAddr, FLASH_PAGE_SIZE); memcpy(flashBuf, (void *)newAddr, FLASH_PAGE_SIZE);
} }
@ -329,6 +289,7 @@ void flash_write(uint32_t dst, const uint8_t *src, int len) {
*/ */
int write_block(uint32_t block_no, uint8_t *data, bool quiet/*, WriteState *state*/) { int write_block(uint32_t block_no, uint8_t *data, bool quiet/*, WriteState *state*/) {
UF2_Block *bl = (void *)data; UF2_Block *bl = (void *)data;
WriteState* state = &_wr_state;
NRF_LOG_DEBUG("Write magic: %x", bl->magicStart0); NRF_LOG_DEBUG("Write magic: %x", bl->magicStart0);
@ -336,9 +297,6 @@ int write_block(uint32_t block_no, uint8_t *data, bool quiet/*, WriteState *stat
return -1; return -1;
} }
// still busy with flashing previous blocks
if ( _is_flashing ) return 0;
if ((bl->flags & UF2_FLAG_NOFLASH) || bl->payloadSize > 256 || (bl->targetAddr & 0xff) || if ((bl->flags & UF2_FLAG_NOFLASH) || bl->payloadSize > 256 || (bl->targetAddr & 0xff) ||
bl->targetAddr < USER_FLASH_START || bl->targetAddr + bl->payloadSize > USER_FLASH_END) { bl->targetAddr < USER_FLASH_START || bl->targetAddr + bl->payloadSize > USER_FLASH_END) {
#if USE_DBG_MSC #if USE_DBG_MSC
@ -354,9 +312,6 @@ int write_block(uint32_t block_no, uint8_t *data, bool quiet/*, WriteState *stat
flash_write(bl->targetAddr, bl->data, bl->payloadSize); flash_write(bl->targetAddr, bl->data, bl->payloadSize);
} }
// flash_write cause a flush to write previous cached data, this write data is not consumed yet
if ( _is_flashing ) return 0;
if (state && bl->numBlocks) { if (state && bl->numBlocks) {
if (state->numBlocks != bl->numBlocks) { if (state->numBlocks != bl->numBlocks) {
if (bl->numBlocks >= MAX_BLOCKS || state->numBlocks) if (bl->numBlocks >= MAX_BLOCKS || state->numBlocks)
@ -379,14 +334,10 @@ int write_block(uint32_t block_no, uint8_t *data, bool quiet/*, WriteState *stat
} }
// flush last blocks // flush last blocks if needed
flushFlash(); flushFlash();
// no flashing due to last blocks is the same to contents on the flash already uf2_write_complete(state->numBlocks);
// complete the write
if (!_is_flashing) {
uf2_write_complete();
}
} }
} }
NRF_LOG_DEBUG("wr %d=%d (of %d)", state->numWritten, bl->blockNo, bl->numBlocks); NRF_LOG_DEBUG("wr %d=%d (of %d)", state->numWritten, bl->blockNo, bl->numBlocks);