startup.c

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>
 */


#include <string.h>
#include <stm32f4xx.h>

/* prototype for main() that tells us not to worry about it possibly returning */
extern int              main(void) __attribute__((noreturn));

/* prototype our _main() to avoid prolog/epilog insertion and other related junk */
void                    _main(void) __attribute__((noreturn, naked, no_instrument_function));

static void             default_cpu_handler(void) __attribute__((noreturn, naked, no_instrument_function));

extern char             _sbss, _ebss;

extern char             _sidata, _sdata, _edata, _sfast, _efast;

char                    irq_stack[1024] __attribute__((section(".irqstack")));

typedef const void      (vector)(void);

struct cm3_vectors {
        void    *initial_stack;
        vector  *entry;
        vector  *vectors[14];
};

void
_main(void)
{
        /* At least some bootloaders increment the MSP off the top of the stack
         * before jumping to here. Let's set it ourselves to make sure it's good */
        asm volatile ("msr msp, %0" : : "r" (&irq_stack[sizeof(irq_stack)]) : );
        /* load the stack base for the current stack before we attempt to branch to
         * any function that might bounds-check the stack */
        asm volatile ("mov r10, %0" : : "r" (&irq_stack[0]) : );

        /* Disable all interrupts, until proper table etc is installed. */
        __disable_irq();

        /* enable usage, bus and memory faults */
        SCB->SHCSR |= SCB_SHCSR_USGFAULTENA_Msk | SCB_SHCSR_BUSFAULTENA_Msk | SCB_SHCSR_MEMFAULTENA_Msk;

        /* configure FP state save behaviour - automatic, lazy save */
        FPU->FPCCR |= FPU_FPCCR_ASPEN_Msk | FPU_FPCCR_LSPEN_Msk;

        /* configure default FPU state */
        FPU->FPDSCR |= FPU_FPDSCR_DN_Msk;       /* enable Default NaN */
        FPU->FPDSCR |= FPU_FPDSCR_FZ_Msk;       /* Use flush to zero for very
                                                 * small values. */

        /* enable the FPU */
        SCB->CPACR |= (0xf << 20);      // turn on CP10/11 for FP support on cores that implement it

        /* copy initialised data from flash to RAM */
        memcpy(&_sdata, &_sidata, &_edata - &_sdata);

        /* zero the BSS */
        memset(&_sbss, 0, &_ebss - &_sbss);

        /* zero any 'fast' RAM that's been used */
#if defined(STM32F40_41xxx)
        memset(&_sfast, 0, &_efast - &_sfast);
#endif /* defined(STM32F40_41xxx) */
        /* fill most of the IRQ/bootstrap stack with a watermark pattern so we can measure how much is used */
        /* leave a little space at the top in case memset() isn't a leaf with no locals */
        memset(&irq_stack, 0xa5, sizeof(irq_stack) - 64);

        /* call main */
        (void)main();
}

void **HARDFAULT_PSP;
register void *stack_pointer asm("sp");


static void
default_cpu_handler(void)
{
    // Hijack the process stack pointer to make backtrace work
    asm("mrs %0, psp" : "=r"(HARDFAULT_PSP) : :);
    stack_pointer = HARDFAULT_PSP;
    while(1);
}

#define HANDLER(_name)  extern vector _name __attribute__((weak, alias("default_cpu_handler")))

/* standard CMSIS vector names */
HANDLER(NMI_Handler);
HANDLER(HardFault_Handler);
HANDLER(MemManage_Handler);
HANDLER(BusFault_Handler);
HANDLER(UsageFault_Handler);
HANDLER(DebugMon_Handler);

struct cm3_vectors cpu_vectors __attribute((section(".cpu_vectors"))) = {
                .initial_stack = &irq_stack[sizeof(irq_stack)],
                .entry = (vector *)_main,
                .vectors = {
                                NMI_Handler,
                                HardFault_Handler,
                                MemManage_Handler,
                                BusFault_Handler,
                                UsageFault_Handler,
                                0,
                                0,
                                0,
                                0,
                                0,
                                DebugMon_Handler,
                                0,
                                0,
                                0,
                }
};