Electronic – STM32 Custom Bootloader Jump to Application

bootloaderstm32

I wrote a custom bootloader for the STM32F4 microcontroller and I'm able to write an application to the flash memory at the address of 0x08008000. The issue I have is when I use the jump function the application doesn't seem to execute. I have attached the jump function below. I have disabled all the peripherals, timers and interrupts. Also, relocated the vector table to 0x08008000 to run the new app.

void bootloader_jump_to_user_app(void)
{

   //just a function pointer to hold the address of the reset handler of the user app.
    void (*app_reset_handler)(void);

    //shut down any tasks running
    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_10);
    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_11);
    HAL_TIM_Base_Stop_IT(&htim4);
    HAL_TIM_Base_DeInit(&htim4);
    HAL_RCC_DeInit();
    HAL_DeInit();


    SysTick->CTRL = 0;
    SysTick->LOAD = 0;
    SysTick->VAL = 0;

    //disbale interuppts
    __set_PRIMASK(1);
    __disable_irq();

     SCB->VTOR = FLASH_SECTOR2_BASE_ADDRESS; //0x080080000

    // 1. configure the MSP by reading the value from the base address of the sector 2
    uint32_t msp_value = *(__IO uint32_t *)FLASH_SECTOR2_BASE_ADDRESS;

    __set_MSP(msp_value);

    uint32_t resethandler_address = *(__IO uint32_t *) (FLASH_SECTOR2_BASE_ADDRESS + 4);

    app_reset_handler = (void*) resethandler_address;

    //3. jump to reset handler of the user application
    app_reset_handler();

}

In the linker file for the bootloader I have broken the flash into two parts, one for the app and the other for the bootloader. For the application linker file I have the flash starting at 0x08008000.

/* Memories definition */
MEMORY
{
    CCMRAM  (xrw)   : ORIGIN = 0x10000000,  LENGTH = 64K
    RAM (xrw)   : ORIGIN = 0x20000000,  LENGTH = 128K
    FLASH   (rx)    : ORIGIN = 0x8000000,   LENGTH = 128K
    APPLICATION (rx) : ORIGIN = 0x08008000, LENGTH = 896K
}

Best Answer

I managed to get the bootloader to work. I just needed to rename the reset_handler in the linker script and startup_stm32F40xx.s file to bootloader_reset_handler for the bootloader program.

Related Solutions

Electronic – bootloader application on arm controller

The way we do it in one of our products is like this (code is based on IAR compiler, so pragmas might differ for you):

We defined a structure which contains important information of the application part (which is called mainpart in our projects):

#pragma pack(push,1)
    struct softwareRevision_t {
        uint8_t VersionSystem;
        uint8_t VersionFunction;
        uint8_t VersionError;
        uint8_t VersionCustomer;
        uint8_t BuildNumber;
    };
#pragma pack(pop)

#pragma pack(push,1)
    struct mainInfoStruct_t {
        softwareRevision_t softwareRevision;
        uint32_t startFunctionAddress;
        uint8_t reserve[27];
        uint32_t bootControl;
    };
#pragma pack(pop)

This contains among other things the uint32_t startFunctionAddress. Now for this structure to be useful, you have to do several things:

Initialize it with meaningful values in the application
Make it const so it can be placed in flash
Tell the linker to place the structure always on the exact same location every time you compile your project
share the location and structure between application and boot part

In the application part:

To share the location, we created a header-file which is included in both parts with a simple define:

#define MAIN_INFO_MEMORY_POSITION (0x0807FFD4)

In a .cpp file of our application we create an instance of the structure which is placed accordingly:

#pragma location = MAIN_INFO_MEMORY_POSITION
extern __root const mainInfoStruct_t mainInfoStruct =
{
    {
            1U,     // mainInfo.softwareRevision.VersionSystem
            0U,     // mainInfo.softwareRevision.VersionFunction
            0U,     // mainInfo.softwareRevision.VersionError
            0U,     // mainInfo.softwareRevision.VersionCustomer
            0U      // mainInfo.softwareRevision.BuildNumber
    },

    reinterpret_cast<uint32_t>((&_start)),  // mainInfo.startFunctionAddress
    {0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U,0U},     // reserve

    0xF0F0FFFFU     // mainInfo.bootControl
};

Several things happen here: #pragma location = MAIN_INFO_MEMORY_POSITION tells the linker where to place the next structure.

The __root tells our linker that this symbol must be kept, even if it is not referenced by the application code (which it isn't). It has to be const otherwise it would not get placed in flash (if it doesn't end up in flash try adding a static).

So with this we have done everything in the application.

In the boot part:

The boot part needs access to the application part info structure. We wrapped a class around this whole thing, but basically a pointer will be enough:

volatile mainInfoStruct_t* pMainInfo = reinterpret_cast<mainInfoStruct_t*>(MAIN_INFO_MEMORY_POSITION);

We use volatile here to make sure, that the compiler will not optimize the access to the flash away. With this you can now jump into the application code with an ugly cast:

(reinterpret_cast<void (*)(void)>(pMainInfo->startFunctionAddress))();

Notes:

In our application we do a CRC check over the whole application part which includes the mainInfoStruct, so we don't jump into nirvana is something went wrong with the update.

The first thing we do in our application is to set the stackpointer to the value it is expected to start with (you can get that from the linker configuration file or your interrupt vector table). Otherwise you might end up with a stack overflow and corrupting your other data.

This is not a minimal example, but might give some hint on what might be useful in a shared structure as well.

We use C++, sorry for the reinterpret_casts.

Electronic – STM32F091 Jump to Bootloader from application

The problem was with the USART1 peripheral state. The USART1 config register values were being carried to the bootloader execution, possibly causing trouble for the proprietary bootloader. Solution was to reset USART1 via RCC_APB2RSTR.

The function now is:

void SB_SystemBootloaderJump()
{
    typedef void (*pFunction)(void);
    pFunction JumpToApplication;

    __HAL_RCC_USART1_FORCE_RESET();
    HAL_Delay(5);
    __HAL_RCC_USART1_RELEASE_RESET();
    HAL_Delay(5);

    HAL_RCC_DeInit();

    SysTick->CTRL = 0;
    SysTick->LOAD = 0;
    SysTick->VAL = 0;

    /**
     * Step: Disable all interrupts
     */
    __disable_irq();

    /* ARM Cortex-M Programming Guide to Memory Barrier Instructions.*/
    __DSB();

    __HAL_SYSCFG_REMAPMEMORY_SYSTEMFLASH()
    ;

    /* Remap is bot visible at once. Execute some unrelated command! */
    __DSB();
    __ISB();

    JumpToApplication = (void (*)(void)) (*((uint32_t *) ((0x1FFFD800 + 4))));

    /* Initialize user application's Stack Pointer */
    __set_MSP(*(__IO uint32_t*) 0x1FFFD800);

    JumpToApplication();
}

Best Answer

Related Solutions

Electronic – bootloader application on arm controller

Electronic – STM32F091 Jump to Bootloader from application

Related Topic