Trouble Jumping to Bootloader from Application on STM32H747 with Riverdi Display and TouchGFX

[Sasa1234]

Hello everyone,

I'm facing an issue with jumping from my application to the bootloader on an STM32H747 microcontroller. I'm using a 7-inch Riverdi display and have developed graphical interfaces using TouchGFX. My application, which I've built using only the M7 core (disabling the M4 core) and FreeRTOS for task management and graphics, has its main file structured as man1.c attached.I've also created a bootloader program with the following structure:  The bootloader works perfectly when the STM32H747xx_FLASH.ld file contains the following instruction:

Assolutamente! Ecco la traduzione del tuo post in inglese, adatta per un forum tecnico come quello di STM:

Subject: Trouble Jumping to Bootloader from Application on STM32H747 with Riverdi Display and TouchGFX

Hello everyone,

I'm facing an issue with jumping from my application to the bootloader on an STM32H747 microcontroller. I'm using a 7-inch Riverdi display and have developed graphical interfaces using TouchGFX. My application, which I've built using only the M7 core (disabling the M4 core) and FreeRTOS for task management and graphics, has its main file structured as follows:

I've also created a bootloader program with the following structure:

The bootloader works perfectly when the STM32H747xx_FLASH.ld file contains the following instruction:

MEMORY
{
RAM_D1 (xrw) : ORIGIN = 0x24000000, LENGTH = 512K
/*FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 1024K*/ /* Memory is divided. Actual start is 0x08000000 and actual length is 2048K */

FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 250K

DTCMRAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
RAM_D2 (xrw) : ORIGIN = 0x30000000, LENGTH = 288K
RAM_D3 (xrw) : ORIGIN = 0x38000000, LENGTH = 64K
ITCMRAM (xrw) : ORIGIN = 0x00000000, LENGTH = 64K
SDRAM (xrw) : ORIGIN = 0xD0000000, LENGTH = 4M
SDRAM2 (xrw) : ORIGIN = 0xD0400000, LENGTH = 4M
}

 

However, when I try to jump to the bootloader from my application using a jump_to_bootloader() function, the jump to the bootloader fails. This is code snipet:

 

typedef void (*pFunction)(void);

 

 

#define BOOT_ADDR 0x080B50000

void jump_to_bootloader(void)

{

 

 

 

__disable_irq();  // Disabilita tutti gli interrupt

 

HAL_RCC_DeInit(); // Disabilita tutti i clock

HAL_DeInit();     // Deinizializza le periferiche

 

 

 

SCB_DisableICache();

SCB_DisableDCache();

 

// Disabilita SysTick timer

   // SysTick->CTRL = 0;

   // SysTick->LOAD = 0;

   // SysTick->VAL  = 0;

 

 

// Pulisci flag di reset

__HAL_RCC_CLEAR_RESET_FLAGS();

 

 

 

__set_MSP(*(__IO uint32_t*)BOOT_ADDRESS); // Imposta il nuovo Stack Pointer

 

 

SCB->VTOR = BOOT_ADDRESS;

 

// Puntatore alla funzione di reset dell'applicativo

uint32_t JumpAddr = *(__IO uint32_t*)(BOOT_ADDRESS+ 4);

pFunction Jump = (pFunction)JumpAddr;

 

__enable_irq(); // Riabilita gli interrupt prima del salto

// Esegui il salto

Jump(); // Salta all’applicazione

// Se il salto fallisce, reset

NVIC_SystemReset();

}

 

 I've made to the .ld files of both the application and the bootloader.

// Application .ld

/* Memories definition */
MEMORY
{
RAM_D1 (xrw) : ORIGIN = 0x24000000, LENGTH = 512K
/*FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 1024K*/ /* Memory is divided. Actual start is 0x08000000 and actual length is 2048K */

FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 724K

DTCMRAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
RAM_D2 (xrw) : ORIGIN = 0x30000000, LENGTH = 288K
RAM_D3 (xrw) : ORIGIN = 0x38000000, LENGTH = 64K
ITCMRAM (xrw) : ORIGIN = 0x00000000, LENGTH = 64K
QUADSPI (r) : ORIGIN = 0x90000000, LENGTH = 64M
SDRAM (xrw) : ORIGIN = 0xD0000000, LENGTH = 4M
SDRAM2 (xrw) : ORIGIN = 0xD0400000, LENGTH = 4M
}

// Bootloader.ld

 

/* Memories definition */
MEMORY
{
RAM_D1 (xrw) : ORIGIN = 0x24000000, LENGTH = 512K
/*FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 1024K*/ /* Memory is divided. Actual start is 0x08000000 and actual length is 2048K */

FLASH (rx) : ORIGIN = 0x08B500000, LENGTH = 250K

DTCMRAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
RAM_D2 (xrw) : ORIGIN = 0x30000000, LENGTH = 288K
RAM_D3 (xrw) : ORIGIN = 0x38000000, LENGTH = 64K
ITCMRAM (xrw) : ORIGIN = 0x00000000, LENGTH = 64K
SDRAM (xrw) : ORIGIN = 0xD0000000, LENGTH = 4M
SDRAM2 (xrw) : ORIGIN = 0xD0400000, LENGTH = 4M
}

 

 

Could someone please advise on what modifications I need to make in both the application and the bootloader code to successfully jump to the bootloader? Is there something I'm missing in the process?How may I had to manage all peripherals?

Thank you in advance for your help!

 

 

 

[Tesla DeLorean]

#define BOOT_ADDR 0x080B50000

FLASH (rx) : ORIGIN = 0x08B500000, LENGTH = 250K

Should be 0x080B5000, Memory in range 0x08000000..0x081FFFFF (2MB)

[MM..1]

Are you sure ? FLASH (rx) : ORIGIN = 0x08B500000, LENGTH = 250K

too your main dont show where and how you try jump. Primary jump to system bootloader is safe from safe state of MCU optimaly after boot main with som marker. No inside RTOS No with 20 peripherals active ... NEVER.

 

[Sasa1234]

Hi @MM..1 ,

 

Do you mean that jump from bootloader app to main application is simpler than viceversa?

Thank you again

[Sasa1234]

Hi everyone,
I'm currently doing some experiments with an STM32H7 dual-core setup (Cortex-M7 + Cortex-M4), where the main application runs on the M7 core with FreeRTOS.

I've attached two key files:

• The main application (app_file.c.txt), which receives a CAN message and is supposed to jump to the bootloader.

• The bootloader, (bootfile_c.txt) which is responsible for programming via QSPI and Flash, and is expected to send an initial CAN message upon startup.

The jump from the application to the bootloader seems to occur correctly (without a reset), but the bootloader doesn't send the first CAN message, even though this behavior is defined in its code. I suspect this might be due to the fact that I'm not performing a full system reset before jumping.

I’m also unsure if I missed modifying some required files for proper bootloader support:

• system_stm32h7xx_dualcore_boot_cm4_cm7.c

• startup_stm32h757xihx.s

• STM32H757XIHX_RAM.ld

Should I be doing a full NVIC_SystemReset instead of just jumping?
Any guidance or examples would be greatly appreciated. Thanks in advance!

[GGODA]

Hello @Sasa1234 ,

 

So beside changing your address which contained 9 characters instead of 8, what else did you change?

Right now, how do you know that the jump worked?
How do you know that the bootloarder doesn't send the CAN message?

Can you put breakpoint or other debugging means to figure out what is being executed correctly and what is blocking?

 

Regards,

[Sasa1234]

Hi @GGODA ,

 

Honestly I am not sure about jump action but I see that, after my bootloader CAN message, display turns off and I observed  an absorbed current equal 0.0 A.However If I analyze my attached code, there is a QSPI Erase that is not performed and this state ST Link can't connect to microcontroler.

 

Thank you again for your reply!!!!

[urbito]

Isnt it safer for example, if you have an EEPROM, when you receive the signal from CAN to go to bootloader, to put a byte in eeprom, restart the mcu so it goes to bootloader, check the eeprom, and then if the byte is there, start the CAN procedure you need to do? 

 

hope it helps.

 

greetings.

[Sasa1234]

Hi @urbito ,

 

Thank for your suggestion but I made your  mechanism with a Flag and in my code, if there is this flag, the function "jump_to_bootloader()" is called but unfornately it does not work!!!!

 

 

 

 

[Sasa1234]

Hi everyone!
After a lot of trial and error, I finally solved my STM32 dual-application setup issue. I created two projects:

1. A bootloader, which starts at address 0x08000000

2. An application, located at  0x08020000

they have these .ld files

Bootloader .ld (128KB at start of Flash):
MEMORY
{
 FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 128K
 RAM_D1 (xrw) : ORIGIN = 0x24000000, LENGTH = 512K
 DTCMRAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
 RAM_D2 (xrw) : ORIGIN = 0x30000000, LENGTH = 288K
 RAM_D3 (xrw) : ORIGIN = 0x38000000, LENGTH = 64K
 ITCMRAM (xrw) : ORIGIN = 0x00000000, LENGTH = 64K
}

  and .ld file for the second project.

MEMORY
{
 FLASH (rx) : ORIGIN = 0x08020000, LENGTH = 896K
 RAM_D1 (xrw) : ORIGIN = 0x24000000, LENGTH = 512K
 DTCMRAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
 RAM_D2 (xrw) : ORIGIN = 0x30000000, LENGTH = 288K
 RAM_D3 (xrw) : ORIGIN = 0x38000000, LENGTH = 64K
 ITCMRAM (xrw) : ORIGIN = 0x00000000, LENGTH = 64K
 QUADSPI (r) : ORIGIN = 0x90000000, LENGTH = 64M
 SDRAM (xrw) : ORIGIN = 0xD0000000, LENGTH = 4M
 SDRAM2 (xrw) : ORIGIN = 0xD0400000, LENGTH = 4M
}

 In the main.c file of bootloader I use this function

typedef void (*pFunction)(void);

static void JumpToApplication(void)
{
 __disable_irq(); // Disable all interrupts
 HAL_RCC_DeInit(); // Reset clock configuration
 HAL_DeInit(); // Deinit peripherals
 SysTick->CTRL = 0; // Disable SysTick if running

 __set_MSP(*(__IO uint32_t*)0x08020000); // Set new MSP from app vector table
 SCB->VTOR = 0x08020000; // Point VTOR to new app

 uint32_t JumpAddr = *(__IO uint32_t*)(0x08020000 + 4); // Reset_Handler address
 pFunction Jump = (pFunction)JumpAddr;

 __enable_irq(); // Re-enable interrupts if needed

 Jump(); // Execute the jump

 NVIC_SystemReset(); // If jump fails, reset
}

  

Everything now works perfectly. The bootloader initializes, then jumps to the second application at 0x0802000 without issues.

Big thanks to everyone who offered support and tips during this process — your help made it happen!