STM32F401 Using flash memory sector 0 as storage

[Chuckero]

Hello,

I'm searching for a way to use sector 0 as storage memory but no luck so far.

I'm using STM32F401CCU6 and I'm working on a firmware which have to save about 300 bytes in a no volatile memory. For this microcontroller family we have this memory map:

Sector   -  Address ini    ~ Address end   - Size
Sector 0 - 0x0800 0000 ~ 0x0800 3FFF - 16 Kbytes
Sector 1 - 0x0800 4000 ~ 0x0800 7FFF - 16 Kbytes
Sector 2 - 0x0800 8000 ~ 0x0800 BFFF - 16 Kbytes
Sector 3 - 0x0800 C000 ~ 0x0800 FFFF - 16 Kbytes
Sector 4 - 0x0801 0000 ~ 0x0801 FFFF - 64 Kbytes
Sector 5 - 0x0802 0000 ~ 0x0803 FFFF - 128 Kbytes
Sector 6 - 0x0804 0000 ~ 0x0805 FFFF - 128 Kbytes
Sector 7 - 0x0806 0000 ~ 0x0807 FFFF - 128 Kbytes

So far I already used a little bit more then 66kB, which means, my firmware is using sectors 0 to 4 and increasing.

Now, I'm already saving the data in flash memory, all good for the sector 5 using HAL. But it's only 500 bytes in a block of 128Kbytes, it's a waste of memory, and when the firmware reaches the block 5 I'll have to move the data to next sector.

So, the question is: is it possible to use sector 0 as storage and make the boot start from block 1?

The best information I found about it, was this post, but it's about STM32F7 and that solution is not available for F4:
https://stackoverflow.com/questions/56896375/how-can-i-change-the-start-address-on-flash/56902284#56902284

Thank you all.

[jiangfan]

in fact, no need to make the boot start from block 1.

it is possible to use part of sector 0 as storage as shown below.

#pragma location = 0x08003000
uint8_t DATA_IN_FLASH[500] = {0xFF}; /* DATA_IN_FLASH at fixed address: Sector 0 */

[Tesla DeLorean]

You can't change the boot address.

You can carve a hole in your image so you can use sector 1, 2 or 3 as a 16KB configuration space.

You could use sector 0, but you'd want to prepend the Vector Table to your 300 bytes. You could create a vector table deeper in the IMAGE, say 0x08010000 and point SCB->VTOR at that, and then copy those first 512 bytes, or whatever the vector table size, to 0x08000000 at the front of sector 0.

[Danish1]

There's an inherent risk in what @Tesla DeLorean says for using sector 0

You could use sector 0, but you'd want to prepend the Vector Table to your 300 bytes. You could create a vector table deeper in the IMAGE, say 0x08010000 and point SCB->VTOR at that, and then copy those first 512 bytes, or whatever the vector table size, to 0x08000000 at the front of sector 0.

The problem occurs if you ever need to "recycle" sector 0 - that is you've used up all the storage locations in that FLASH sector so you erase it before starting again. There will be a short period of time between the erase and rewriting the vectors in the first 512 bytes. If the processor resets in that period, perhaps due to loss-of-power, EMC event or bug in the code, the processor will not be able to restart executing your code. It will be "bricked" until attached to a JTAG programmer or similar.

So I strongly recommend using sectors 1, 2 and/or 3. Do look at ST EEPROM-emulation examples which use two sectors to guarantee no loss-of-information even with power-loss at the worst possible moment.

[jiangfan]

I agree, obviously better to use sector 1 or later instead of sector 0 to avoid potential issue. ST EEPROM-emulation example provides good start point on this topic.

[Chuckero]

Thank you all for the comments,

Considering that every erase cycle will clean the entire sector (which will happen at least once a day) and the risk highlighted when using sector 0, I liked the idea of reserve a vector for a sector, like:

 

#pragma location = 0x0800C000
uint8_t DATA_IN_FLASH[16383] = {0xFF}; /* DATA_IN_FLASH at fixed address: Sector 3 */

 

 This way I will have the entire sector 3 for data storage.

Thanks again!

[Chuckero]

I've tried that code but looks like it does not work in GCC. I'm using STM32CubeIDE 1.12.0.

I've searched everywhere on the internet and I didn't find a solution that works, it's the first time I touch in the linker script.
So, what I did so far was different combinations of this:
In the c file:

uint8_t __attribute__((section (".myDataStorage"))) memoryReserve[16383];

In the linker script (first thing in SECTIONS):

/* Memories definition */
MEMORY
{
 RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 64K
 FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 256K
}

/* Sections */
SECTIONS
{
 /* Reserve section 3 from flash memory. */
 .myDataStorage 0x0800C000 :
 {
 KEEP(*(.myDataStorage)) ;
 } > FLASH
 ...

 That way I got:
 - a warning in the STM32CubeProgrammer: Warning:The code is locked up!
 - flash memory, sectors 0, 1 and 2 (address 0x08000000 to 0x0800BFFF) are empty - 0xFF
 - flash memory, sector 3 (address 0x0800C000 to 0x0800FFFF) is empty - 0x00
 - the code starts at sector 4 (address 0x08010000)
 - the firmware does not run, because there is nothing in the boot sector (0x08000000)

I was imaging to have sectors 0, 1 and 2 for code, sector 3 for storage, and sectors 4, 5... for more code. I'm not sure if this is possible.
What is missing?

[Tesla DeLorean]

Try this

/* Entry Point */
ENTRY(Reset_Handler)

/* Highest address of the user mode stack */
_estack = 0x20010000; /* end of RAM */
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x200;; /* required amount of heap */
_Min_Stack_Size = 0x400;; /* required amount of stack */

/* Specify the memory areas */
MEMORY
{
FLASH_ISR (rx) : ORIGIN = 0x08000000, LENGTH = 48K
FLASH_HOLE (rx) : ORIGIN = 0x0800C000, LENGTH = 16K
FLASH (rx) : ORIGIN = 0x08010000, LENGTH = 256K-64K
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 64K
}

/* Define output sections */
SECTIONS
{
 /* The startup code goes first into FLASH */
 .isr_vector :
 {
 . = ALIGN(4);
 KEEP(*(.isr_vector)) /* Startup code */
 . = ALIGN(4);
 } >FLASH_ISR

 .ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >FLASH
 .ARM : {
 __exidx_start = .;
 *(.ARM.exidx*)
 __exidx_end = .;
 } >FLASH_ISR

 .preinit_array :
 {
 PROVIDE_HIDDEN (__preinit_array_start = .);
 KEEP (*(.preinit_array*))
 PROVIDE_HIDDEN (__preinit_array_end = .);
 } >FLASH_ISR

 .init_array :
 {
 PROVIDE_HIDDEN (__init_array_start = .);
 KEEP (*(SORT(.init_array.*)))
 KEEP (*(.init_array*))
 PROVIDE_HIDDEN (__init_array_end = .);
 } >FLASH_ISR

 .fini_array :
 {
 PROVIDE_HIDDEN (__fini_array_start = .);
 KEEP (*(SORT(.fini_array.*)))
 KEEP (*(.fini_array*))
 PROVIDE_HIDDEN (__fini_array_end = .);
 } >FLASH_ISR

 /* Reserve section 3 from flash memory. */
 .myDataStorage :
 {
 . = ALIGN(4);
 KEEP(*(.myDataStorage)) ;
 . = ALIGN(4);
 } > FLASH_HOLE

 /* The program code and other data goes into FLASH */
 .text :
 {
 . = ALIGN(4);
 *(.text) /* .text sections (code) */
 *(.text*) /* .text* sections (code) */
 *(.glue_7) /* glue arm to thumb code */
 *(.glue_7t) /* glue thumb to arm code */
 *(.eh_frame)

 KEEP (*(.init))
 KEEP (*(.fini))

 . = ALIGN(4);
 _etext = .; /* define a global symbols at end of code */
 } >FLASH

 /* Constant data goes into FLASH */
 .rodata :
 {
 . = ALIGN(4);
 *(.rodata) /* .rodata sections (constants, strings, etc.) */
 *(.rodata*) /* .rodata* sections (constants, strings, etc.) */
 . = ALIGN(4);
 } >FLASH

 /* used by the startup to initialize data */
 _sidata = LOADADDR(.data);

 /* Initialized data sections goes into RAM, load LMA copy after code */
 .data :
 {
 . = ALIGN(4);
 _sdata = .; /* create a global symbol at data start */
 *(.data) /* .data sections */
 *(.data*) /* .data* sections */

 . = ALIGN(4);
 _edata = .; /* define a global symbol at data end */
 } >RAM AT> FLASH


 /* Uninitialized data section */
 . = ALIGN(4);
 .bss :
 {
 /* This is used by the startup in order to initialize the .bss secion */
 _sbss = .; /* define a global symbol at bss start */
 __bss_start__ = _sbss;
 *(.bss)
 *(.bss*)
 *(COMMON)

 . = ALIGN(4);
 _ebss = .; /* define a global symbol at bss end */
 __bss_end__ = _ebss;
 } >RAM

 /* User_heap_stack section, used to check that there is enough RAM left */
 ._user_heap_stack :
 {
 . = ALIGN(4);
 PROVIDE ( end = . );
 PROVIDE ( _end = . );
 . = . + _Min_Heap_Size;
 . = . + _Min_Stack_Size;
 . = ALIGN(4);
 } >RAM

 /* Remove information from the standard libraries */
 /DISCARD/ :
 {
 libc.a ( * )
 libm.a ( * )
 libgcc.a ( * )
 }

 .ARM.attributes 0 : { *(.ARM.attributes) }
}

 

[Pavel A.]

In addition to what @Tesla DeLorean wrote: you cannot rewrite a portion of flash sector , even if the data written there is all FFs (I don't quite understand why, but this is from experience). You can write each "write unit" only once after erase. This means that you should write the sector 0 so that the unused space after the vectors and other stuff remains virgin. Make a separate small "image" (hex/bin) for the sector 0 and write it using CubeProgrammer or other tool, usually these tools won't fill end of sector after the data.

Then locate the start of unwritten area in sector 0 and program your data there as usual.

[Chuckero]

---

@Pavel A. wrote:

In addition to what @Tesla DeLorean wrote: you cannot rewrite a portion of flash sector , even if the data written there is all FFs (I don't quite understand why, but this is from experience). You can write each "write unit" only once after erase. This means that you should write the sector 0 so that the unused space after the vectors and other stuff remains virgin. Make a separate small "image" (hex/bin) for the sector 0 and write it using CubeProgrammer or other tool, usually these tools won't fill end of sector after the data.

Then locate the start of unwritten area in sector 0 and program your data there as usual.

---

Hello @Pavel A.,
What you mean with "you cannot rewrite a portion of flash sector"? I didn't understand, because, at this moment my firmware is writing about 300 bytes at the first address of sector 1, then, when the user change some parameters the new data is saved at first address + 300, next time it goes at first address + 600, etc. All working perfectly and this way I can increase the flash lifespan hundreds of times.

[Pavel A.]

>next time it goes at first address + 600

So you are not RE-writing at (first address + 0x300), you're writing at a new fresh location. What I meant was writing twice at the same address without erase.

[Chuckero]

Thanks @Tesla DeLorean everything is working as planned now.

One last question, about the memory optimization. Now I have this memory usage:

I notice the initial block (sectors 0 to 2) is using only 412 bytes.So, my first shot is to move my storage from sector 3 to sector 1. Other than that, can I freely play with the sectors in linker script? Is there something to avoid or "dangerous"? My intention is to fill as much of sector 0 as possible.
This is what I have in linker script following the suggestions:

 

/* Entry Point */
ENTRY(Reset_Handler)

/* Highest address of the user mode stack */
_estack = ORIGIN(RAM) + LENGTH(RAM); /* end of "RAM" Ram type memory */

_Min_Heap_Size = 0x200; /* required amount of heap */
_Min_Stack_Size = 0x400; /* required amount of stack */

/* Memories definition */
MEMORY
{
 RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 64K
 FLASH_ISR (rx) : ORIGIN = 0x08000000, LENGTH = 48K
 FLASH_HOLE (rx) : ORIGIN = 0x0800C000, LENGTH = 16K
 FLASH (rx) : ORIGIN = 0x08010000, LENGTH = 256K-64K
}

/* Sections */
SECTIONS
{
 /* The startup code into "FLASH" Rom type memory */
 .isr_vector :
 {...} >FLASH_ISR

 /* The program code and other data into "FLASH" Rom type memory */
 .text :
 {...} >FLASH

 /* Constant data into "FLASH" Rom type memory */
 .rodata :
 {...} >FLASH

 .ARM.extab :
 {...} >FLASH_ISR

 .ARM :
 {...} >FLASH

 .preinit_array :
 {
 } >FLASH_ISR

 .init_array :
 {
 } >FLASH_ISR

 .fini_array :
 {
 } >FLASH_ISR

 /* Reserve section 3 from flash memory. */
 .myDataStorage 0x800C000 :
 {...} > FLASH_HOLE

 /* Initialized data sections into "RAM" Ram type memory */
 .data :
 {...} >RAM AT> FLASH

 /* Uninitialized data section into "RAM" Ram type memory */
 . = ALIGN(4);
 .bss :
 {...} >RAM

 /* User_heap_stack section, used to check that there is enough "RAM" Ram type memory left */
 ._user_heap_stack :
 {...} >RAM
}

 

Thanks again

[Tesla DeLorean]

The Linker Script  an be used to funnel the content of particular objects into the desired section. Perhaps cherry pick C library content to start filling that section