bootInit.c程序
#include "copyright_wrs.h"
#include "vxWorks.h"
#include "sysLib.h"
#include "config.h"
#include "errno.h"
#include "sioLib.h"
#define UNCMP_RTN inflate
#ifndef USER_RESERVED_MEM
# define USER_RESERVED_MEM 0
#endif
/*
* If memory is to be cleared, it will be cleared from SYS_MEM_BOTTOM
* up to (but not including) SYS_MEM_TOP, except for text and data segments.
* The user reserved area is not cleared.
*/
#define SYS_MEM_TOP \
(LOCAL_MEM_LOCAL_ADRS + LOCAL_MEM_SIZE - USER_RESERVED_MEM)
#define SYS_MEM_BOTTOM \
(LOCAL_MEM_LOCAL_ADRS + RESERVED)
#define BINARRAYEND_ROUNDOFF (ROUND_DOWN(binArrayEnd, sizeof(long)))
IMPORT void romInit ();
IMPORT STATUS UNCMP_RTN ();
IMPORT void usrInit ();
IMPORT void sysInitAlt ();
IMPORT void start ();
IMPORT UCHAR binArrayStart []; /* compressed binary image */
IMPORT UCHAR binArrayEnd []; /* end of compressed binary image */
IMPORT char etext []; /* defined by the loader */
IMPORT char end []; /* defined by the loader */
IMPORT UCHAR wrs_kernel_data_start []; /* defined by the loader */
IMPORT UCHAR wrs_kernel_data_end []; /* defined by the loader */
#if ((CPU_FAMILY == MIPS) || (CPU_FAMILY==PPC) || \
(CPU_FAMILY==COLDFIRE))
#define RESIDENT_DATA RAM_DST_ADRS
#else
#define RESIDENT_DATA wrs_kernel_data_start
#endif
#ifndef RAM_DST_ADRS /* default uncompress dest. */
#define RAM_DST_ADRS RAM_HIGH_ADRS
#endif
/* If the boot code is in RAM and the RAM is already initialized,
* clearing the RAM is not necessary. Macro BOOTCODE_IN_RAM is
* used not to clear the RAM.
*/
#ifdef BOOTCODE_IN_RAM /* not to clear RAM */
#undef ROM_TEXT_ADRS
#undef ROM_BASE_ADRS
#define ROM_TEXT_ADRS ((UINT)romInit)
#define ROM_BASE_ADRS ((UINT)romInit)
#endif /* BOOTCODE_IN_RAM */
/* #if defined (UNCOMPRESS) || defined (ROM_RESIDENT) */
#ifndef ROM_COPY_SIZE
#define ROM_COPY_SIZE (ROM_SIZE - (ROM_TEXT_ADRS - ROM_BASE_ADRS))
#endif
/* #endif*/ /* UNCOMPRESS */
#define ROM_OFFSET(adr) (((UINT)adr - (UINT)romInit) + ROM_TEXT_ADRS)
/* forward declarations */
LOCAL void copyLongs (FAST UINT *source, FAST UINT *destination, UINT nlongs);
#ifndef BOOTCODE_IN_RAM
LOCAL void fillLongs (FAST UINT *buf, UINT nlongs, FAST UINT val);
#endif /* BOOTCODE_IN_RAM */
#if (CPU==XSCALE)
int checkLongs (FAST UINT *source, FAST UINT *destination, UINT nlongs);
#endif
/*******************************************************************************
*
* romStart - generic ROM initialization
*
* This is the first C code executed after reset.
*
* This routine is called by the assembly start-up code in romInit().
* It clears memory, copies ROM to RAM, and possibly invokes the uncompressor.
* It then jumps to the entry point of the uncompressed object code.
*
* RETURNS: N/A
*/
void romStart
(
FAST int startType /* start type */
)
{
#if ((CPU_FAMILY==SPARC) || (CPU_FAMILY==MIPS) || (CPU_FAMILY==I80X86) || \
(CPU_FAMILY==PPC) || (CPU_FAMILY==ARM))
volatile /* to force absolute adressing */
#endif /* (CPU_FAMILY==SPARC) */
FUNCPTR absEntry; /* to avoid PC Relative Jump Subroutine */
#if (CPU_FAMILY==ARM) && (!defined(ROM_RESIDENT)) && !defined(BOOTCODE_IN_RAM)
VOIDFUNCPTR ramfillLongs = fillLongs; /* force call to RAM */
#define fillLongs(a,b,c) ramfillLongs(a,b,c)
#endif /* (CPU_FAMILY==ARM) */
#if (CPU_FAMILY==MC680X0) && !defined(ROM_RESIDENT) && !defined(BOOTCODE_IN_RAM)
volatile VOIDFUNCPTR romcopyLongs = ©Longs; /* force call to ROM */
#define copyLongs romcopyLongs
#endif /* (CPU_FAMILY==MC680X0) */
/*
* Copy from ROM to RAM, minus the compressed image
* if compressed boot ROM which relies on binArray
* appearing last in DATA segment.
*/
#ifdef ROM_RESIDENT
/* If ROM resident code, then copy only data segment
* from ROM to RAM, initialize memory and jump
* to usrInit.
*/
#if (CPU_FAMILY == SPARC)
copyLongs ((UINT *)(etext + 8), (UINT *) RESIDENT_DATA,
#else
copyLongs ((UINT *)(etext + 4), (UINT *) RESIDENT_DATA,
#endif
((UINT) wrs_kernel_data_end - (UINT) RESIDENT_DATA) / sizeof (long));
#else /* ROM_RESIDENT */
#ifdef UNCOMPRESS
#if (CPU_FAMILY == MIPS)
/*
* copy text to uncached locations to avoid problems with
* copy back caches
*/
((FUNCPTR)ROM_OFFSET(copyLongs)) (ROM_TEXT_ADRS, (UINT)K0_TO_K1(romInit),
ROM_COPY_SIZE / sizeof (long));
#else /* CPU_FAMILY == MIPS */
((FUNCPTR)ROM_OFFSET(copyLongs)) (ROM_TEXT_ADRS, (UINT)romInit,
ROM_COPY_SIZE / sizeof (long));
#endif /* CPU_FAMILY == MIPS */
#else /* UNCOMPRESS */
#if (CPU_FAMILY == MIPS)
/*
* copy text to uncached locations to avoid problems with
* copy back caches
* copy the entire data segment because there is no way to ensure that
* binArray is the last thing in the data segment because of GP relative
* addressing
*/
((FUNCPTR)ROM_OFFSET(copyLongs)) (ROM_TEXT_ADRS, (UINT)K0_TO_K1(romInit),
((UINT)wrs_kernel_data_end - (UINT)romInit) / sizeof (long));
#else /* CPU_FAMILY == MIPS */
((FUNCPTR)ROM_OFFSET(copyLongs))
((UINT *)((UINT)ROM_TEXT_ADRS + ((UINT)BINARRAYEND_ROUNDOFF -
(UINT)romInit)), (UINT *)BINARRAYEND_ROUNDOFF,
((UINT)wrs_kernel_data_end - (UINT)binArrayEnd) / sizeof (long));
#if (CPU==XSCALE)
/* validate coherence, can not assume uncached area... */
((FUNCPTR)ROM_OFFSET(checkLongs))
(ROM_TEXT_ADRS, (UINT)romInit,
((UINT)binArrayStart - (UINT)romInit) / sizeof (long));
((FUNCPTR)ROM_OFFSET(checkLongs))
((UINT *)((UINT)ROM_TEXT_ADRS + ((UINT)BINARRAYEND_ROUNDOFF -
(UINT)romInit)), (UINT *)BINARRAYEND_ROUNDOFF,
((UINT)wrs_kernel_data_end - (UINT)binArrayEnd) / sizeof (long));
#endif
#endif /* CPU_FAMILY == MIPS */
#endif /* UNCOMPRESS */
#endif /* ROM_RESIDENT */
#if (CPU_FAMILY != MIPS) && (!defined (BOOTCODE_IN_RAM))
/* clear all memory if cold booting */
if (startType & BOOT_CLEAR)
{
#ifdef ROM_RESIDENT
/* Clear memory not loaded with text & data.
*
* We are careful about initializing all memory (except
* STACK_SAVE bytes) due to parity error generation (on
* some hardware) at a later stage. This is usually
* caused by read accesses without initialization.
*/
fillLongs ((UINT *)SYS_MEM_BOTTOM,
((UINT) RESIDENT_DATA - STACK_SAVE - (UINT)SYS_MEM_BOTTOM)
/ sizeof(long), 0);
fillLongs (((UINT *) wrs_kernel_data_end),
((UINT)SYS_MEM_TOP - ((UINT) wrs_kernel_data_end)) / sizeof(long), 0);
#else /* ROM_RESIDENT */
fillLongs ((UINT *)(SYS_MEM_BOTTOM),
((UINT)romInit - STACK_SAVE - (UINT)SYS_MEM_BOTTOM) /
sizeof(long), 0);
#if defined (UNCOMPRESS)
fillLongs ((UINT *)((UINT)romInit + ROM_COPY_SIZE),
((UINT)SYS_MEM_TOP - ((UINT)romInit + ROM_COPY_SIZE))
/ sizeof(long), 0);
#else
fillLongs ((UINT *)wrs_kernel_data_end,
((UINT)SYS_MEM_TOP - (UINT)wrs_kernel_data_end) / sizeof (long), 0);
#endif /* UNCOMPRESS */
#endif /* ROM_RESIDENT */
/*
* Ensure the boot line is null. This is necessary for those
* targets whose boot line is excluded from cleaning.
*/
*(BOOT_LINE_ADRS) = EOS;
}
#endif /* (CPU_FAMILY != MIPS) && (!defined (BOOTCODE_IN_RAM)) */
/* jump to VxWorks entry point (after uncompressing) */
#if defined (UNCOMPRESS) || defined (ROM_RESIDENT)
#if (CPU_FAMILY == I960)
absEntry = (FUNCPTR)sysInitAlt; /* reinit proc tbl */
#else
absEntry = (FUNCPTR)usrInit; /* on to bootConfig */
#endif /* CPU_FAMILY == I960 */
#else
{
#if (CPU_FAMILY == MIPS)
volatile FUNCPTR absUncompress = (FUNCPTR) UNCMP_RTN;
if ((absUncompress) ((UCHAR *)ROM_OFFSET(binArrayStart),
(UCHAR *)K0_TO_K1(RAM_DST_ADRS),
(int)((UINT)binArrayEnd - (UINT)binArrayStart)) != OK)
#elif (CPU_FAMILY == I80X86) || (CPU_FAMILY == ARM)
volatile FUNCPTR absUncompress = (FUNCPTR) UNCMP_RTN;
if ((absUncompress) ((UCHAR *)ROM_OFFSET(binArrayStart),
(UCHAR *)RAM_DST_ADRS, binArrayEnd - binArrayStart) != OK)
#else
if (UNCMP_RTN ((UCHAR *)ROM_OFFSET(binArrayStart),
(UCHAR *)RAM_DST_ADRS, binArrayEnd - binArrayStart) != OK)
#endif /* (CPU_FAMILY == MIPS) */
return; /* if we return then ROM's will halt */
absEntry = (FUNCPTR)RAM_DST_ADRS; /* compressedEntry () */
}
#endif /* defined UNCOMPRESS || defined ROM_RESIDENT */
#if ((CPU_FAMILY == ARM) && ARM_THUMB)
absEntry = (FUNCPTR)((UINT32)absEntry | 1); /* force Thumb state */
#endif /* CPU_FAMILY == ARM */
(absEntry) (startType);
}
#if (CPU_FAMILY==ARM) && (!defined(ROM_RESIDENT))
#undef fillLongs
#endif /* (CPU_FAMILY==ARM) */
#if (CPU_FAMILY==MC680X0) && !defined(ROM_RESIDENT) && !defined(BOOTCODE_IN_RAM)
#undef copyLongs /* undo effects from above define */
#endif /* CPU_FAMILY==MC680X0 */
/*******************************************************************************
*
* copyLongs - copy one buffer to another a long at a time
*
* This routine copies the first <nlongs> longs from <source> to <destination>.
*/
LOCAL void copyLongs (source, destination, nlongs)
FAST UINT *source; /* pointer to source buffer */
FAST UINT *destination; /* pointer to destination buffer */
UINT nlongs; /* number of longs to copy */
{
FAST UINT *dstend = destination + nlongs;
/* Do the remainder one long at a time. */
while (destination < dstend)
*destination++ = *source++;
}
#ifndef BOOTCODE_IN_RAM
/*******************************************************************************
*
* fillLongs - fill a buffer with a value a long at a time
*
* This routine fills the first <nlongs> longs of the buffer with <val>.
*/
LOCAL void fillLongs (buf, nlongs, val)
FAST UINT *buf; /* pointer to buffer */
UINT nlongs; /* number of longs to fill */
FAST UINT val; /* char with which to fill buffer */
{
FAST UINT *bufend = buf + nlongs;
/* Do the remainder one long at a time. */
while (buf < bufend)
*buf++ = val;
}
#endif /* BOOTCODE_IN_RAM */
#if (CPU==XSCALE)
int checkLongs (source, destination, nlongs)
FAST UINT *source; /* pointer to source buffer */
FAST UINT *destination; /* pointer to destination buffer */
UINT nlongs; /* number of longs to copy */
{
int fine = 1;
FAST UINT *dstend = destination + nlongs;
while (destination < dstend)
{
if (*destination++ != *source++)
{
fine = 0;
break;
}
}
return fine;
}
#endif
[align=right][color=#000066][此贴子已经被作者于2005-8-16 16:54:49编辑过][/color][/align]
STM32
MCU
通讯及无线技术
物联网技术
电子DIY
板卡试用
基础知识
软件与操作系统
我爱生活
小e食堂