bootinit.c.bak

44b0 vxwork5.5 bsp 支持基于flash 39VF3201的tffs驱动

			 ((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)) (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)
		
				
				
				
			/*	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;
    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;
    
    /*test*/
    int i=0;

    /* 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;
	
	/*test*/
	if (nchunks % 1000 == 0)
		i++;
	
#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