External vs. internal flash memory for touchGFX assets

Hi @HP​,

I guess it all depends on how you created your project. There are no guarantees, as far as CubeMX and CubeIDE are concerned, that the linker script is correct when it comes to TouchGFX. If you create an application using one of our Application Templates, you'll see the correct references to memory regions in the linker script for each compiler for each board.

Was this a custom board? The same concepts go here - Try to get some inspiration from what we already have through the Designer.

Let me know.

/Martin

This is for the F746-DISCO board but I will be working on a custom board in a short while. That board will have a larger flash since the one on the dev-board is obsolete.

I'll have a look on one of the generated files and try to update the ones in my current project. However, there is two files, one for flash and one for RAM. I guess it's only the flash one I should be looking into?

Which two files are those? Are you referring to different .icf files for IAR? Let me show you the linker scripts for The STM32F746G-DISCO. It defines both RAM and FLASH sections.

gcc (STM32F746NGHx_FLASH.ld):

/* Entry Point */
ENTRY(Reset_Handler)
 
/* Highest address of the user mode stack */
_estack = 0x20050000; /* 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
{
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 320K
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 1024K
QUADSPI (r) : ORIGIN = 0x90000000, LENGTH = 16M
}
 
/* Define output sections */
SECTIONS
{
 /* The startup code goes first into FLASH */
 .isr_vector :
 {
 . = ALIGN(4);
 KEEP(*(.isr_vector)) /* Startup code */
 . = ALIGN(4);
 } >FLASH
 
 /* 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
 
 .ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >FLASH
 .ARM : {
 __exidx_start = .;
 *(.ARM.exidx*)
 __exidx_end = .;
 } >FLASH
 
 .preinit_array :
 {
 PROVIDE_HIDDEN (__preinit_array_start = .);
 KEEP (*(.preinit_array*))
 PROVIDE_HIDDEN (__preinit_array_end = .);
 } >FLASH
 .init_array :
 {
 PROVIDE_HIDDEN (__init_array_start = .);
 KEEP (*(SORT(.init_array.*)))
 KEEP (*(.init_array*))
 PROVIDE_HIDDEN (__init_array_end = .);
 } >FLASH
 .fini_array :
 {
 PROVIDE_HIDDEN (__fini_array_start = .);
 KEEP (*(SORT(.fini_array.*)))
 KEEP (*(.fini_array*))
 PROVIDE_HIDDEN (__fini_array_end = .);
 } >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(8);
 PROVIDE ( end = . );
 PROVIDE ( _end = . );
 . = . + _Min_Heap_Size;
 . = . + _Min_Stack_Size;
 . = ALIGN(8);
 } >RAM
 
 /* Remove information from the standard libraries */
 /DISCARD/ :
 {
 libc.a ( * )
 libm.a ( * )
 libgcc.a ( * )
 }
 
 .ARM.attributes 0 : { *(.ARM.attributes) }
 
	ExtFlashSection :
	{
		*(ExtFlashSection ExtFlashSection.*)
		*(.gnu.linkonce.r.*)
 . = ALIGN(0x4);
	} >QUADSPI
 
/* Un comment this section to place fonts and text in external flash
 FontFlashSection :
	{
		*(FontFlashSection FontFlashSection.*)
		*(.gnu.linkonce.r.*)
 . = ALIGN(0x4);
	} >QUADSPI
 
 TextFlashSection :
	{
		*(TextFlashSection TextFlashSection.*)
		*(.gnu.linkonce.r.*)
 . = ALIGN(0x4);
	} >QUADSPI
*/
}

IAR (stm32f746xx_flash.icf):

/*###ICF### Section handled by ICF editor, don't touch! ****/
/*-Editor annotation file-*/
/* IcfEditorFile="$TOOLKIT_DIR$\config\ide\IcfEditor\cortex_v1_0.xml" */
/*-Specials-*/
define symbol __ICFEDIT_intvec_start__ = 0x08000000;
/*-Memory Regions-*/
define symbol __ICFEDIT_region_ROM_start__ = 0x08000000;
define symbol __ICFEDIT_region_ROM_end__ = 0x080FFFFF;
define symbol __ICFEDIT_region_RAM_start__ = 0x20000000;
define symbol __ICFEDIT_region_RAM_end__ = 0x2004FFFF;
define symbol __ICFEDIT_region_ITCMRAM_start__ = 0x00000000;
define symbol __ICFEDIT_region_ITCMRAM_end__ = 0x00003FFF;
/*-Sizes-*/
define symbol __ICFEDIT_size_cstack__ = 0x400;
define symbol __ICFEDIT_size_heap__ = 0x200;
/**** End of ICF editor section. ###ICF###*/
 
define symbol __region_QSPI_start__ = 0x90000000;
define symbol __region_QSPI_end__ = 0x90FFFFFF;
 
define memory mem with size = 4G;
define region ROM_region = mem:[from __ICFEDIT_region_ROM_start__ to __ICFEDIT_region_ROM_end__];
define region RAM_region = mem:[from __ICFEDIT_region_RAM_start__ to __ICFEDIT_region_RAM_end__];
define region QSPI_region = mem:[from __region_QSPI_start__ to __region_QSPI_end__];
define region ITCMRAM_region = mem:[from __ICFEDIT_region_ITCMRAM_start__ to __ICFEDIT_region_ITCMRAM_end__];
 
define block CSTACK with alignment = 8, size = __ICFEDIT_size_cstack__ { };
define block HEAP with alignment = 8, size = __ICFEDIT_size_heap__ { };
 
initialize by copy { readwrite };
do not initialize { section .noinit };
 
place at address mem:__ICFEDIT_intvec_start__ { readonly section .intvec };
 
place in ROM_region { readonly };
place in RAM_region { readwrite,
 block CSTACK, block HEAP };
 
place in QSPI_region { section ExtFlashSection, section FontFlashSection, section TextFlashSection };

I've done a bit of testing and the results are in: from a memory perspective this works like a charm - and might I suggest that this be implemented as a checkbox during project generation?

Prerequisites:

• Working project in CubeIDE
• This is tested only on the F746-DISCO board but I take it that it will work on all boards with QSPI.

The issue is that all assets (fonts, images etc) are stored in the internal flash of the MCU. this creates quite a memory footprint even with just a few font sizes and backgrounds.

This picture shows the memory usage with just 2 screens with two different font sizes (20pt and 200pt) and a single button. We are already maxed out here!!

Next step is to edit the linker file so it allows storage in the QSPI memory.

In my working project I have a file called 'STM32F746NGHX_FLASH.ld' Note that we're ONLY editing the FLASH linker script!!!

The file is opened and the memory section is changed so the QUADSPI region is also available. (Just add the last line to the section)

MEMORY
{
 RAM	(xrw)	: ORIGIN = 0x20000000,	LENGTH = 320K
 FLASH	(rx)	: ORIGIN = 0x8000000,	LENGTH = 1024K
 QUADSPI (r) : ORIGIN = 0x90000000, LENGTH = 16M
}

Now we have defined the QSPI section and by looking in any example code generated by the TouchGFX Designer we can see the following snippet added to the fale BEFORE the last curly brace:

	ExtFlashSection :
	{
		*(ExtFlashSection ExtFlashSection.*)
		*(.gnu.linkonce.r.*)
 . = ALIGN(0x4);
	} >QUADSPI
 
/* Un comment this section to place fonts and text in external flash
 FontFlashSection :
	{
		*(FontFlashSection FontFlashSection.*)
		*(.gnu.linkonce.r.*)
 . = ALIGN(0x4);
	} >QUADSPI
 
 TextFlashSection :
	{
		*(TextFlashSection TextFlashSection.*)
		*(.gnu.linkonce.r.*)
 . = ALIGN(0x4);
	} >QUADSPI
*/

With this change in place we can do another build of the project and the memory footprint now looks like this:

A pretty radical change :) You should be able to fit almost anything into that QSPI footprint.

But wait - There's more!

The code even states that if you remove the comments for the last section you get the fonts and text moved as well - let's just try that.

Beware that just removing the multi-line comment will result in the decribing text becoming exposed so just move the '*/' to the same line as the beginning of the comment - or remove the comment text altogether.

Now the result is this:

So this is it. By adding to the linkerfiler you get muuuuuch more space in your application :)

Hum.. One thing is that the project builds and locates the assets in the right locations in QSPI.

Next issue is with loading the assets onto the external flash. Luckily this have already been solved by @Community member​  and his answer here: https://community.st.com/s/question/0D50X0000Ap1gIO/problem-using-qspi-with-stm32f746-and-touchgfx

The console writes this:

Memory Programming ...
Opening and parsing file: ST-LINK_GDB_server_a04824.srec
 File : ST-LINK_GDB_server_a04824.srec
 Size : 830520 Bytes
 Address : 0x08000000 
 
 
Erasing memory corresponding to segment 0:
Erasing internal memory sectors [0 4]
Erasing memory corresponding to segment 1:
Erasing external memory sectors [0 10]
Download in Progress:
 
 
File download complete
Time elapsed during download operation: 00:00:09.524
 
 
 
Verifying ...

Which is all fine and dandy - note the 'Erasing external memory sectors [0 10]..

But no luck so far - I only get garbage on screen. It looks like the application have a hard time figuring out where to load the images from. Anyone else have luck with this???

Having the same issue over here, I don't think its an issue with the contents of the QSPI as the images will display fine when running through the debugger- as configured in the thread by charles. Something about running in debug fixes the issue but if you try to run out of debug then the images are garbage.

Anyone know how debug mode differs from normal? the only thing i can think of is that there will be longer delays.

Looking with a fresh pair of eyes I could not believe that I could take a complex application example from touchGFX Designer and see it work directly on my F746 board while my painstakingly pieced together code running in CubeIDE would not.

I have now looked into the TouchGFX Designer code and look what I found:

This is the QSPI init code:

hqspi.Instance = QUADSPI;
 hqspi.Init.ClockPrescaler = 1;
 hqspi.Init.FifoThreshold = 4;
 hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE;
 hqspi.Init.FlashSize = 24;
 hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_6_CYCLE;
 hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;
 hqspi.Init.FlashID = QSPI_FLASH_ID_1;
 hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;

A quick look at my (CubeMX generated) code revealed that THEY ARE NOT THE SAME!!!!!!!!!!!!11111oneoneone

Please, can someone verify that this is not just me?

I have now changed my MX_QUADSPI_Init() code for the above one and hey. It works!

I now have external flash programming as part of the debugging routine as per Charles' post mentioned above. No need for external loaders.

I'm still en debug though...

I'm posting this for continuity in the thread. This have solved my issue with not being able to load from QSPI outside the debugging environment:

I'm running my application from cubeIDE so that's a prerequisite.

You will need to do the following:

1. launch TouchGFX designer and load an application template.
2. Generate the code and go the the folder where the sources are located.
3. From the folder Driver-> BSP-> STM32746G-Discovery copy the qspi files - there should be 2, a 'c' and a 'h' file (code and header)
4. paste the files into your project, preferably into the directory 'STM32746G-Discovery' which you might have in your project root.
5. Add the following include to the top of your main.cpp file:

#include <stm32746g_discovery_qspi.h>

6. change your MX_QUADSPI_Init to this:

 hqspi.Instance = QUADSPI;
 hqspi.Init.ClockPrescaler = 1;
 hqspi.Init.FifoThreshold = 4;
 hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_HALFCYCLE;
 hqspi.Init.FlashSize = 24;
 hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_6_CYCLE;
 hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;
 hqspi.Init.FlashID = QSPI_FLASH_ID_1;
 hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;
 
 
 if (HAL_QSPI_Init(&hqspi) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN QUADSPI_Init 2 */
 BSP_QSPI_Init();
 
 BSP_QSPI_MemoryMappedMode();
 HAL_NVIC_DisableIRQ(QUADSPI_IRQn);
 
 MPU_Region_InitTypeDef MPU_InitStruct;
 MPU_InitStruct.Enable = MPU_REGION_ENABLE;
 MPU_InitStruct.BaseAddress = 0x90000000;
 MPU_InitStruct.Size = MPU_REGION_SIZE_256MB;
 MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
 MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
 MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
 MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
 MPU_InitStruct.Number = MPU_REGION_NUMBER2;
 MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
 MPU_InitStruct.SubRegionDisable = 0x00;
 MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
 
 HAL_MPU_ConfigRegion(&MPU_InitStruct);
 
 /* Configure the MPU attributes as WT for QSPI (used 16Mbytes) */
 MPU_InitStruct.Enable = MPU_REGION_ENABLE;
 MPU_InitStruct.BaseAddress = 0x90000000;
 MPU_InitStruct.Size = MPU_REGION_SIZE_16MB; /* NOTE! Change this if you change QSPI flash size! */
 MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
 MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
 MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
 MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
 MPU_InitStruct.Number = MPU_REGION_NUMBER3;
 MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
 MPU_InitStruct.SubRegionDisable = 0x00;
 MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
 
 HAL_MPU_ConfigRegion(&MPU_InitStruct);
 HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);

The code should be able to compile and debug. Try unplugging the board and plugging it back in. Does it work now?

@George Journeaux​  and @BPark.3​ 

Nice to know! I was pretty excited when I got my board to run yesterday evening so thank you both for verifying this!

I did a video of the initial configuration for youtube and during the preparation of that (remember the step where you copy the touchscreen driver?) there is also a qspi driver, but in the original video Martin deletes those files.

I had to delete it too since the video guide I did only covers the initial config with internal memory.

Seeing this it raises another question - the SDRAM driver is also not loaded. could it be possible to run without external SDRAM? That would make a PCB design even cheaper :)