Store variable in external flash at compile time

Question

Hello, I'm working with nRF5340DK, and need to initialize some variables - long arrays of approximately 16 KB each 
 
 they must be included at compile time (without depending on any external serial transmission on runtime) 
 they must be stored in QSPI external flash MX25R64, already available in the kit 
 if it is possible, I would prefer not to use any storage system (LittleFS, NVS, FAT), but straight linker description and variables locating on specified memory regions 
 
 This post is highly related, with the only difference that it refers to internal instead of external flash, but nevertheless that post does not seem to be solved yet. 
 I have already enabled external flash from proj.conf : 
 CONFIG_NORDIC_QSPI_NOR=y

CONFIG_FLASH=y
CONFIG_FLASH_PAGE_LAYOUT=y

CONFIG_NVS=y
CONFIG_NVS_LOG_LEVEL_DBG=y
CONFIG_MPU_ALLOW_FLASH_WRITE=y 
 I have also enabled external flash from overlay file: 
 / {
	chosen {
 nordic,pm-ext-flash = &mx25r64;
	};

}; 
 I have created a custom .ld file and declared a memory region located in external_flash: 
 SECTION_PROLOGUE(my_external_flash, 0x00000000 (NOLOAD),)
{
 __my_external_flash_start = 0x00000000;
	KEEP(*(".my_external_flash*"));
 __my_external_flash_end = 0x000E0000;
} GROUP_LINK_IN(external_flash) 
 I have added the instruction in CMakeLists.txt to use that linker file: 
 zephyr_linker_sources(SECTIONS custom-sections.ld) 
 I have declared a variable in my source file to be located in the previously defined region: 
 uint32_t __attribute__((section ("my_external_flash"))) testArray4[1024] = {0} ; 
 When the size of the variable is below or equal to 4096 bytes (1024 uint32_t), I can read and write values to that variable. 
 But, if I raise the size by one, I get a bus fault error during run time. 
 
 Is there some obvious mistake that I am making in any of the steps? 
 I have also tried locating the storage partition on external flash, through my pm_static.yml file, and even after verifying the partition was correctly created and located on both partitions.yml and zephyr.dts, I keep getting the same error described above when I declare the variable in "storage" region/partition (?). 
 Would you have any recomendation on how to achieve this? How to locate a variable on external flash at compile time? 
 Another acceptable alternative, no so efficient as what we are looking for above, but still acceptable, would be to be able to create arrays to be stored at NVS located on external flash, at compile time. (which means that this initialized values must be defined and stored during compilation, without taking any primary flash or ram space). Is there a way to do this? 
 
 Thanks in advance! 
 Leopoldo

ovrebekk · Accepted Answer

Hi Leopoldo 
 It should be possible to modify the code_relocation_nocopy example to store const variables in external flash that can be easily accessed from the application, but I don't think this will work so well if you need to write to the variable as well. 
 How are you writing to the variable in your example? 
 How often are you planning to write to the variable during normal operation? 
 Would you be willing to share your project with me so I can try to reproduce the issue? 
 Best regards Torbjørn

ovrebekk · Answer

Hi Leopoldo 
 Me and a colleague had a look at your code for a long while and in the end I think we got to a working stage, with a couple of caveats (I'll get to that later). 
 The code we ended up with is this one: 
 1_7_1_code_relocation_modified_by_nordic.rar 
 I went back to the prj.conf configuration, and removed the zephyr_linker_sources line from CMakeLists.txt (only keeping the zephyr_code_relocate line). 
 If you look at the linker script I put back in the MEMORY portion, and also added a custom section below it that I named sound_data, in order to allow you to define these variables by referencing the section, rather than putting them in a specific file. 
 Then I changed the variables to be declared using the section attribute, like this: 
 const uint16_t __attribute__ ((section(".sound_data"))) sound0[SOUND_LEN] = {1, 2, 3}; 
 Now you should technically be able to read these variables using XIP, like in the original example, but I would not recommend this as using XIP for reading data comes with some drawbacks. In particular you are unlikely to get very good power consumption in this case, since you won't be able to disable the QSPI interface in between reads. Secondly, if you want to use DFU at any point to read and write DFU images to the external flash you won't be able to combine this with XIP in the same project. 
 In other words I would strongly recommend just using the flash API to read out the variables instead. 
 In order to do this you simply need to declare the variables in a similar way, but subtract the 0x10000000 XIP offset before issuing a read over the flash interface (since the local address in the flash starts at 0, not 0x10000000). 
 I wish I could provide a bit more context on some of the changes we ended up with, but as you might have picked up on we are sort of learning as we go here Still, if you have any questions I will do my best to answer. 
 Can you give the modified example a go and see if it works better? 
 Please note that I didn't implement the flash read mechanism in the example, you would need to add this. 
 Also, it seems that flashing the XIP directly from VSCode does not work in v1.7.1. This means you need to manually flash the code from the command line using nrfjprog: 
 nrfjprog --program zephyr.hex --sectorerase --verify 
 You might also need to manually erase the flash device: 
 nrfjprog --qspieraseall 
 Best regards Torbjørn

Store variable in external flash at compile time

Top Replies