bootinit.c

来自「vxwork操作系统的相关内容」· C语言 代码 · 共 706 行 · 第 1/2 页

    for(i=0;i<10;i++);  

    NF_WAITRB();     
     
    NF_nFCE_H();
    */
	while(iSize < ((UINT)wrs_kernel_data_end-(UINT)romInit)) {	
	
		((FUNCPTR)ROM_OFFSET(nandReadPage))(iBlock,iPage,iDes);
		iPage++;	
		if(iPage >= 32) {
			iPage=0;
			iBlock++;
		}
		iDes += 512;
		iSize += 512;
	}
	return 1;
}

#endif 

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)
#if BOOT_NAND /*donleo*/
	VOIDFUNCPTR ramfillLongs = (VOIDFUNCPTR)ROM_OFFSET(fillLongs);
#else 
    VOIDFUNCPTR ramfillLongs = fillLongs;     /* force call to RAM */
#endif 
#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 = &copyLongs;  /* 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, (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 */

#if BOOT_NAND /*donleo*/

	((FUNCPTR)ROM_OFFSET(nandLoadBootrom))();
#else
    ((FUNCPTR)ROM_OFFSET(copyLongs)) (ROM_TEXT_ADRS, (UINT)romInit,
		ROM_COPY_SIZE / sizeof (long));
#endif

#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)) (ROM_TEXT_ADRS, (UINT)romInit,
		((UINT)binArrayStart - (UINT)romInit)/ sizeof (long));

    ((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)

#if BOOT_NAND /*donleo*/

	fillLongs ((UINT *)((UINT)romInit + ((UINT)wrs_kernel_data_end-(UINT)romInit)),
		    ((UINT)SYS_MEM_TOP - ((UINT)romInit + ((UINT)wrs_kernel_data_end-(UINT)romInit)))
		    / sizeof(long), 0);

#else

	fillLongs ((UINT *)((UINT)romInit + ROM_COPY_SIZE),
		    ((UINT)SYS_MEM_TOP - ((UINT)romInit + ROM_COPY_SIZE))
		    / sizeof(long), 0);
#endif	/*donleo*/

#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
#if BOOT_NAND	/*donleo*/
	absEntry = (FUNCPTR)sysInit;	/*like emulator, must reset stack pointer*/
#else
    absEntry = (FUNCPTR)usrInit;			/* on to bootConfig */
#endif
#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;
    FAST UINT nchunks;

    /* Hop by chunks of longs, for speed. */
    for (nchunks = nlongs / 8; nchunks; --nchunks)
	{
#if (CPU_FAMILY == MC680X0)
	*destination++ = *source++;	/* 0 */
	*destination++ = *source++;	/* 1 */
	*destination++ = *source++;	/* 2 */
	*destination++ = *source++;	/* 3 */
	*destination++ = *source++;	/* 4 */
	*destination++ = *source++;	/* 5 */
	*destination++ = *source++;	/* 6 */
	*destination++ = *source++;	/* 7 */
#else
	destination[0] = source[0];
	destination[1] = source[1];
	destination[2] = source[2];
	destination[3] = source[3];
	destination[4] = source[4];
	destination[5] = source[5];
	destination[6] = source[6];
	destination[7] = source[7];
	destination += 8, source += 8;
#endif /* CPU_FAMILY == MC680X0 */
	}

    /* 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;
    FAST UINT nchunks;

    /* Hop by chunks of longs, for speed. */
    for (nchunks = nlongs / 8; nchunks; --nchunks)
	{
#if (CPU_FAMILY == MC680X0)
	*buf++ = val;	/* 0 */
	*buf++ = val;	/* 1 */
	*buf++ = val;	/* 2 */
	*buf++ = val;	/* 3 */
	*buf++ = val;	/* 4 */
	*buf++ = val;	/* 5 */
	*buf++ = val;	/* 6 */
	*buf++ = val;	/* 7 */
#else
	buf[0] = val;
	buf[1] = val;
	buf[2] = val;
	buf[3] = val;
	buf[4] = val;
	buf[5] = val;
	buf[6] = val;
	buf[7] = val;
	buf += 8;
#endif /* CPU_FAMILY == MC680X0 */
	}

    /* 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