startup.c_bk

    //*****************************************************************************

    //

    // startup.c - Startup code for use with GNU tools.

    //

    //*****************************************************************************

     

    //*****************************************************************************

    //

    // Forward declaration of the default fault handlers.

    //

    //*****************************************************************************

    void ResetISR(void);

    static void NmiSR(void);

    static void FaultISR(void);

    static void IntDefaultHandler(void);

     

    //*****************************************************************************

    //

    // The entry point for the application.

    //

    //*****************************************************************************

    extern int main(void);

     

    //*****************************************************************************

    //

    // Reserve space for the system stack.

    //

    //*****************************************************************************

    static unsigned long pulStack[64];

     

    //*****************************************************************************

    //

    // The vector table.  Note that the proper constructs must be placed on this to

    // ensure that it ends up at physical address 0x0000.0000.

    //

    //*****************************************************************************

    __attribute__ ((section(".isr_vector")))

    void (* const g_pfnVectors[])(void) =

    {

        (void (*)(void))((unsigned long)pulStack + sizeof(pulStack)),

                                                // The initial stack pointer

        ResetISR,                               // The reset handler

        NmiSR,                                  // The NMI handler

        FaultISR,                               // The hard fault handler

        IntDefaultHandler,                      // The MPU fault handler

        IntDefaultHandler,                      // The bus fault handler

        IntDefaultHandler,                      // The usage fault handler

        0,                                      // Reserved

        0,                                      // Reserved

        0,                                      // Reserved

        0,                                      // Reserved

        IntDefaultHandler,                      // SVCall handler

        IntDefaultHandler,                      // Debug monitor handler

        0,                                      // Reserved

        IntDefaultHandler,                      // The PendSV handler

        IntDefaultHandler                       // The SysTick handler

    };

     

    //*****************************************************************************

    //

    // The following are constructs created by the linker, indicating where the

    // the "data" and "bss" segments reside in memory.  The initializers for the

    // "data" segment resides immediately following the "text" segment.

    //

    //*****************************************************************************

    extern unsigned long _etext;

    extern unsigned long _data;

    extern unsigned long _edata;

    extern unsigned long _bss;

    extern unsigned long _ebss;

     

    //*****************************************************************************

    //

    // This is the code that gets called when the processor first starts execution

    // following a reset event.  Only the absolutely necessary set is performed,

    // after which the application supplied entry() routine is called. 

    //

    //*****************************************************************************

    void ResetISR(void)

    {

        unsigned long *pulSrc, *pulDest;

     

        //

        // Copy the data segment initializers from flash to SRAM.

        //

        pulSrc = &_etext;

        pulDest = &_data; 

     

        while(pulDest < &_edata )

        {

            *pulDest++ = *pulSrc++;

        }

     

        //

        // Zero fill the bss segment.

        //

        __asm("    ldr     r0, =_bss\n"

              "    ldr     r1, =_ebss\n"

              "    mov     r2, #0\n"

              "    .thumb_func\n"

              "zero_loop:\n"

              "        cmp     r0, r1\n"

              "        it      lt\n"

              "        strlt   r2, [r0], #4\n"

              "        blt     zero_loop");

     

        //

        // Call the application's entry point.

        //

        main();

    }

     

    //*****************************************************************************

    //

    // This is the code that gets called when the processor receives a NMI.  This

    // simply enters an infinite loop, preserving the system state for examination

    // by a debugger.

    //

    //*****************************************************************************

    static void NmiSR(void)

    {

        //

        // Enter an infinite loop.

        //

        while(1) {

            ;

        }

    }

     

    //*****************************************************************************

    //

    // This is the code that gets called when the processor receives a fault

    // interrupt.  This simply enters an infinite loop, preserving the system state

    // for examination by a debugger.

    //

    //*****************************************************************************

    static void FaultISR(void)

    {

        //

        // Enter an infinite loop.

        //

        while(1) {

            ;

        }

    }

     

    //*****************************************************************************

    //

    // This is the code that gets called when the processor receives an unexpected

    // interrupt.  This simply enters an infinite loop, preserving the system state

    // for examination by a debugger.

    //

    //*****************************************************************************

    static void IntDefaultHandler(void)

    {

        //

        // Go into an infinite loop.

        //

        while(1) {

            ;

        }

    }