Update cmsis_os2.c

[cmsis-freertos] / Demo / ColdFire_MCF52221_CodeWarrior / sources / startcf.c

/*
 *    CF_Startup.c - Default init/startup/termination routines for
 *                     Embedded Metrowerks C++
 *
 *    Copyright © 1993-1998 Metrowerks, Inc. All Rights Reserved.
 *    Copyright © 2005 Freescale semiConductor Inc. All Rights Reserved.
 *
 *
 *    THEORY OF OPERATION
 *
 *    This version of thestartup code is intended for linker relocated
 *    executables.  The startup code will assign the stack pointer to
 *    __SP_INIT, assign the address of the data relative base address
 *    to a5, initialize the .bss/.sbss sections to zero, call any
 *    static C++ initializers and then call main.  Upon returning from
 *    main it will call C++ destructors and call exit to terminate.
 */

#ifdef __cplusplus
#pragma cplusplus off
#endif
#pragma PID off
#pragma PIC off

#include "startcf.h"
#include "RuntimeConfig.h"

        /* imported data */

extern unsigned long far _SP_INIT, _SDA_BASE;
extern unsigned long far _START_BSS, _END_BSS;
extern unsigned long far _START_SBSS, _END_SBSS;
extern unsigned long far __DATA_RAM, __DATA_ROM, __DATA_END;

        /* imported routines */

extern void __call_static_initializers(void);
extern int main(int, char **);
extern void exit(int);

        /* exported routines */

extern void _ExitProcess(void);
extern asm void _startup(void);
extern void __initialize_hardware(void);
extern void __initialize_system(void);


/*
 *    Dummy routine for initializing hardware.  For user's custom systems, you
 *    can create your own routine of the same name that will perform HW
 *    initialization.  The linker will do the right thing to ignore this
 *    definition and use the version in your file.
 */
#pragma overload void __initialize_hardware(void);
void __initialize_hardware(void)
{
}

/*
 *    Dummy routine for initializing systems.  For user's custom systems,
 *    you can create your own routine of the same name that will perform
 *    initialization.  The linker will do the right thing to ignore this
 *    definition and use the version in your file.
 */
#pragma overload void __initialize_system(void);
void __initialize_system(void)
{
}

/*
 *    Dummy routine for initializing C++.  This routine will get overloaded by the C++ runtime.
 */
#pragma overload void __call_static_initializers(void);
void __call_static_initializers(void)
{
}

/*
 *      Routine to copy a single section from ROM to RAM ...
 */
static __declspec(register_abi) void __copy_rom_section(char* dst, const char* src, unsigned long size)
{
        if (dst != src)
                 while (size--)
                    *dst++ = *src++;
}

/*
 *      Routine that copies all sections the user marked as ROM into
 *      their target RAM addresses ...
 *
 *      __S_romp is automatically generated by the linker if it
 *      is referenced by the program.  It is a table of RomInfo
 *      structures.  The final entry in the table has all-zero
 *      fields.
 */
static void __copy_rom_sections_to_ram(void)
{
        RomInfo         *info;

        /*
         *      Go through the entire table, copying sections from ROM to RAM.
         */
        for (info = _S_romp; info->Source != 0L || info->Target != 0L || info->Size != 0; ++info)
    __copy_rom_section( (char *)info->Target,(char *)info->Source, info->Size);
                                                        
}

/*
 *    Exit handler called from the exit routine, if your OS needs
 *    to do something special for exit handling just replace this
 *    routines with what the OS needs to do ...
 */
asm void _ExitProcess(void)
{
        illegal
        rts
}

/*
 *    Routine to clear out blocks of memory should give good
 *    performance regardless of 68k or ColdFire part.
 */
static __declspec(register_abi) void clear_mem(char *dst, unsigned long n)
{
        unsigned long i;
        long *lptr;

        if (n >= 32)
        {
                /* align start address to a 4 byte boundary */
                i = (- (unsigned long) dst) & 3;

                if (i)
                {
                        n -= i;
                        do
                                *dst++ = 0;
                        while (--i);
                }

                /* use an unrolled loop to zero out 32byte blocks */
                i = n >> 5;
                if (i)
                {
                        lptr = (long *)dst;
                        dst += i * 32;
                        do
                        {
                                *lptr++ = 0;
                                *lptr++ = 0;
                                *lptr++ = 0;
                                *lptr++ = 0;
                                *lptr++ = 0;
                                *lptr++ = 0;
                                *lptr++ = 0;
                                *lptr++ = 0;
                        }
                        while (--i);
                }
                i = (n & 31) >> 2;

                /* handle any 4 byte blocks left */
                if (i)
                {
                        lptr = (long *)dst;
                        dst += i * 4;
                        do
                                *lptr++ = 0;
                        while (--i);
                }
                n &= 3;
        }

        /* handle any byte blocks left */
        if (n)
                do
                        *dst++ = 0;
                while (--n);
}

/*
 *    Startup routine for embedded application ...
 */

asm void _startup(void)
{
        /* disable interrupts */
    move.w        #0x2700,sr
    
        /* Pre-init SP, in case memory for stack is not valid it should be setup using 
           MEMORY_INIT before __initialize_hardware is called 
        */
        lea __SP_AFTER_RESET,a7; 

    /* initialize memory */
    MEMORY_INIT

        /* initialize any hardware specific issues */
    jsr           __initialize_hardware   
  
        /* setup the stack pointer */
    lea           _SP_INIT,a7

        /* setup A6 dummy stackframe */
    movea.l       #0,a6
    link          a6,#0

        /* setup A5 */
    lea           _SDA_BASE,a5


        /* zero initialize the .bss section */

    lea           _END_BSS, a0
    lea           _START_BSS, a1
    suba.l        a1, a0
    move.l        a0, d0

    beq           __skip_bss__

    lea           _START_BSS, a0

    /* call clear_mem with base pointer in a0 and size in d0 */
    jsr           clear_mem

__skip_bss__:

        /* zero initialize the .sbss section */

    lea           _END_SBSS, a0
    lea           _START_SBSS, a1
    suba.l        a1, a0
    move.l        a0, d0

    beq           __skip_sbss__

    lea           _START_SBSS, a0

    /* call clear_mem with base pointer in a0 and size in d0 */
    jsr           clear_mem

__skip_sbss__:

        /* copy all ROM sections to their RAM locations ... */
#if SUPPORT_ROM_TO_RAM

        /*
         * _S_romp is a null terminated array of
         * typedef struct RomInfo {
     *      unsigned long       Source;
     *      unsigned long       Target;
     *      unsigned long       Size;
     *  } RomInfo;
     *
     * Watch out if you're rebasing using _PICPID_DELTA
     */

    lea           _S_romp, a0
    move.l        a0, d0
    beq           __skip_rom_copy__            
    jsr           __copy_rom_sections_to_ram

#else

        /*
   * There's a single block to copy from ROM to RAM, perform
   * the copy directly without using the __S_romp structure
   */

    lea           __DATA_RAM, a0
    lea           __DATA_ROM, a1
    
    cmpa          a0,a1
    beq           __skip_rom_copy__
              
    move.l        #__DATA_END, d0
    sub.l         a0, d0
                  
    jsr           __copy_rom_section

#endif
__skip_rom_copy__:
        
        /* call C++ static initializers (__sinit__(void)) */
        jsr                       __call_static_initializers

        jsr                       __initialize_system

        /* call main(int, char **) */
        pea                       __argv
        clr.l             -(sp)                         /* clearing a long is ok since it's caller cleanup */
        jsr                       main
        addq.l          #8, sp
        
        unlk              a6
        
        /* now call exit(0) to terminate the application */
        clr.l             -(sp)
        jsr                       exit
        addq.l          #4, sp

        /* should never reach here but just in case */
        illegal
        rts

        /* exit will never return */
__argv:
    dc.l          0
}