Firmware update not working with MBOOT on a PyBoard with expanded internal file system

[saraverbeecke]

Hi!

I hope someone can help me out...
I am not able to perform a firmware update using a new firmware file placed on the internal file system using a genuine PyBoard.

1. using a pyboard (PYBV11), with updated mpconfigboard.h, mpconfigboard.mk and stm32f405.ld (and also flashbdev.c) files in order to obtain more file system space. (384kB for FLASH_TEXT, 368kB for FLASH_FS in total; see files contents below for reference)
2. micropyhton successfully built for the custom pyboard (stm32f405) and runs fine, file system also working properly with the adapted code using the extra 4 half 128k sectors.
3. bootloader successfully built from inside the ports/stm32/mboot dir
4. bootloader flashed successfully (using dfu-util over USB when in DFU mode (starting at 0x08000000))
5. firmware flashed successfully (using dfu-util over USB when in DFU mode (starting at 0x080A0000))
6. successfully put the new firmware.dfu.gz file onto the internal filesystem (FAT formatted) either using mpremote or via USB (MSC drag and drop)
7. copied fwupdate.py to the board
8. ran:

import fwupdate
fwupdate.update_mpy('/flash/firmware.dfu.gz', 0x80A00000, 3 * 128 * 1024)

Outcome: board goes into bootloader, red LED flashes a few times, then stays on for a few seconds and the board returns to old firmware. (also tried the non-gzip of the .dfu, but same result). The gzip or non-gzip new firmware file can fit in the 384kB on to the filesystem and in the FLASH_TEXT available space.

Questions

1. Is this the right call?
   fwupdate.update_mpy('/flash/firmware.dfu.gz', 0x80A00000, 3 * 128 * 1024)
   0x80A00000 is the right start address for the internal FLASH_TEXT, 3 * 128 * 1024 equals 384kB the LENGTH of the FLASH_TEXT section. Or do I need to call something else since the docs use this call for a SPI flash update...
2. What should the 4 LEDs do during the firmware flashing?
3. Can someone elaborate more on how mboot works when called from within the application (without using any SPI or I2C flash) and just using files from the internal filesystem?

Thanks for helping out!

stm32f405.ld

/*
    GNU linker script for STM32F405
*/

/* Specify the memory areas */
MEMORY
{
    FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 1024K /* entire flash */
    FLASH_ISR (rx)  : ORIGIN = 0x08000000, LENGTH = 32K   /* sector 0, 1 */
    FLASH_FS (rx)   : ORIGIN = 0x08004000, LENGTH = 160K  /* sectors 2, 3 are 16K, 4 is 64K, 5 is 128K (64K used) for filesystem */
    FLASH_FS2 (rx)  : ORIGIN = 0x08040000, LENGTH = 64K   /* sector 6 is 128K (first 64K half is used) for filesystem */
    FLASH_FS3 (rx)  : ORIGIN = 0x08060000, LENGTH = 64K   /* sector 7 is 128K (first 64K half is used) for filesystem */
    FLASH_FS4 (rx)  : ORIGIN = 0x08080000, LENGTH = 64K   /* sector 8 is 128K (first 64K half is used) for filesystem */
    FLASH_TEXT (rx) : ORIGIN = 0x080A0000, LENGTH = 384K  /* full sectors 9,10,11 of 128K each */
    CCMRAM (xrw)    : ORIGIN = 0x10000000, LENGTH = 64K   /* used for filesystem cache */
    RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 128K
}

/* produce a link error if there is not this amount of RAM for these sections */
_minimum_stack_size = 2K;
_minimum_heap_size = 16K;

/* Define the stack.  The stack is full descending so begins just above last byte
   of RAM.  Note that EABI requires the stack to be 8-byte aligned for a call. */
_estack = ORIGIN(RAM) + LENGTH(RAM) - _estack_reserve;
_sstack = _estack - 16K; /* tunable */

/* RAM extents for the garbage collector */
_ram_start = ORIGIN(RAM);
_ram_end = ORIGIN(RAM) + LENGTH(RAM);
_heap_start = _ebss; /* heap starts just after statically allocated memory */
_heap_end = _sstack;

/* Filesystem cache in RAM, and storage in flash */
_micropy_hw_internal_flash_storage_ram_cache_start = ORIGIN(CCMRAM);
_micropy_hw_internal_flash_storage_ram_cache_end = ORIGIN(CCMRAM) + LENGTH(CCMRAM);
_micropy_hw_internal_flash_storage_start = ORIGIN(FLASH_FS);
_micropy_hw_internal_flash_storage_end = ORIGIN(FLASH_FS) + LENGTH(FLASH_FS);
_micropy_hw_internal_flash_storage2_start = ORIGIN(FLASH_FS2);
_micropy_hw_internal_flash_storage2_end = ORIGIN(FLASH_FS2) + LENGTH(FLASH_FS2);
_micropy_hw_internal_flash_storage3_start = ORIGIN(FLASH_FS3);
_micropy_hw_internal_flash_storage3_end = ORIGIN(FLASH_FS3) + LENGTH(FLASH_FS3);
_micropy_hw_internal_flash_storage4_start = ORIGIN(FLASH_FS4);
_micropy_hw_internal_flash_storage4_end = ORIGIN(FLASH_FS4) + LENGTH(FLASH_FS4);

mpconfigboard.h (is te same as default for PYBV11 except the lines below were added)

#define MICROPY_HW_HAS_FLASH        (1)
#define MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE (1)
#define MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE_SEGMENT2 (1)
#define MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE_SEGMENT3 (1)
#define MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE_SEGMENT4 (1)

#define MBOOT_FSLOAD (1)
#define MBOOT_VFS_FAT (1)  // Enable FAT filesystem support
#define MBOOT_VFS_LFS2 (1) // Enable LittleFS version 2 support

mpconfigboard.mk (complete for reference, check TEXT1_ADDR pointing to the correct start address of the FLASH_TEXT startin at sector 9)

MCU_SERIES = f4
CMSIS_MCU = STM32F405xx
AF_FILE = boards/stm32f405_af.csv

USE_MBOOT = 1
# MBOOT_ENABLE_PACKING = 1

ifeq ($(USE_MBOOT),1)
# When using Mboot all the text goes together after the filesystem
LD_FILES = boards/stm32f405.ld boards/common_blifs.ld
TEXT0_ADDR = 0x080A0000
else
# When not using Mboot the ISR text goes first, then the rest after the filesystem
LD_FILES = boards/stm32f405.ld boards/common_ifs.ld
TEXT0_ADDR = 0x08000000
TEXT1_ADDR = 0x080A0000
endif

# MicroPython settings
MICROPY_VFS_LFS2 = 1

# PYB-specific frozen modules
FROZEN_MANIFEST ?= boards/PYBV10/manifest.py

flashbdev.c (the same except added the necessary lines for handling extra sectors see below)

...


extern uint8_t _micropy_hw_internal_flash_storage3_end;
extern uint8_t _micropy_hw_internal_flash_storage4_start;
extern uint8_t _micropy_hw_internal_flash_storage4_end;
extern uint8_t _micropy_hw_internal_flash_storage_ram_cache_start[];
extern uint8_t _micropy_hw_internal_flash_storage_ram_cache_end[];


...


#if MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE_SEGMENT3
#define FLASH_MEM_SEG3_START_ADDR \
    ((long)&_micropy_hw_internal_flash_storage3_start)
#define FLASH_MEM_SEG3_NUM_BLOCKS \
    ((&_micropy_hw_internal_flash_storage3_end - &_micropy_hw_internal_flash_storage3_start) / 512)
#endif

#if MICROPY_HW_ENABLE_INTERNAL_FLASH_STORAGE_SEGMENT4
#define FLASH_MEM_SEG4_START_ADDR \
    ((long)&_micropy_hw_internal_flash_storage4_start)
#define FLASH_MEM_SEG4_NUM_BLOCKS \
    ((&_micropy_hw_internal_flash_storage4_end - &_micropy_hw_internal_flash_storage4_start) / 512)
#endif


...


#if !defined(FLASH_MEM_SEG3_START_ADDR)
#define FLASH_MEM_SEG3_NUM_BLOCKS (0) // no third segment
#endif

#if !defined(FLASH_MEM_SEG4_START_ADDR)
#define FLASH_MEM_SEG4_NUM_BLOCKS (0) // no fourth segment
#endif


...


int32_t flash_bdev_ioctl(uint32_t op, uint32_t arg) {
    (void)arg;
    switch (op) {
        case BDEV_IOCTL_INIT:
            flash_flags = 0;
            flash_cache_sector_start = (uint32_t)-1;
            flash_tick_counter_last_write = 0;
            return 0;

        case BDEV_IOCTL_NUM_BLOCKS:
            // Units are FLASH_BLOCK_SIZE
            return FLASH_MEM_SEG1_NUM_BLOCKS + FLASH_MEM_SEG2_NUM_BLOCKS + FLASH_MEM_SEG3_NUM_BLOCKS + FLASH_MEM_SEG4_NUM_BLOCKS;

        case BDEV_IOCTL_IRQ_HANDLER:
            flash_bdev_irq_handler();
            return 0;

        case BDEV_IOCTL_SYNC: {
            uint32_t basepri = raise_irq_pri(IRQ_PRI_FLASH); // prevent cache flushing and USB access
            if (flash_flags & FLASH_FLAG_DIRTY) {
                flash_flags |= FLASH_FLAG_FORCE_WRITE;
                while (flash_flags & FLASH_FLAG_DIRTY) {
                    flash_bdev_irq_handler();
                }
            }
            restore_irq_pri(basepri);
            return 0;
        }
    }
    return -MP_EINVAL;
}


...


static uint32_t convert_block_to_flash_addr(uint32_t block) {
    if (block < FLASH_MEM_SEG1_NUM_BLOCKS) {
        return FLASH_MEM_SEG1_START_ADDR + block * FLASH_BLOCK_SIZE;
    }
    #ifdef FLASH_MEM_SEG2_START_ADDR
    if (block < FLASH_MEM_SEG1_NUM_BLOCKS + FLASH_MEM_SEG2_NUM_BLOCKS) {
        return FLASH_MEM_SEG2_START_ADDR + (block - FLASH_MEM_SEG1_NUM_BLOCKS) * FLASH_BLOCK_SIZE;
    }
    #endif
    #ifdef FLASH_MEM_SEG3_START_ADDR
    if (block < FLASH_MEM_SEG1_NUM_BLOCKS + FLASH_MEM_SEG2_NUM_BLOCKS + FLASH_MEM_SEG3_NUM_BLOCKS) {
        return FLASH_MEM_SEG3_START_ADDR + (block - FLASH_MEM_SEG1_NUM_BLOCKS - FLASH_MEM_SEG2_NUM_BLOCKS) * FLASH_BLOCK_SIZE;
    }
    #endif
    #ifdef FLASH_MEM_SEG4_START_ADDR
    if (block < FLASH_MEM_SEG1_NUM_BLOCKS + FLASH_MEM_SEG2_NUM_BLOCKS + FLASH_MEM_SEG3_NUM_BLOCKS + FLASH_MEM_SEG4_NUM_BLOCKS) {
        return FLASH_MEM_SEG4_START_ADDR + (block - FLASH_MEM_SEG1_NUM_BLOCKS - FLASH_MEM_SEG2_NUM_BLOCKS - FLASH_MEM_SEG3_NUM_BLOCKS) * FLASH_BLOCK_SIZE;
    }
    #endif
    // can add more flash segments here if needed, following above pattern

    // bad block
    return -1;
}