memory.c

~{WwU_J9SC5D~}ucos~{T4Bk#,1`RkA4=S5wJT>y?IRT#,4x~}uart~{2bJT~}

	for (i=0 ; i < lsize ; i++) 
	{
		for (j=0 ; j < 4 ; j++)
		{
			MemTestInit(src, tsize);
			if ( !ByteCopyTest(src, dst, tsize) ) 
				{ 
				Print(" Fail !!") ;
				return MemTestFail ;
				}
			PrintMemTestStatus(j) ;
		}
	}
	Print("Ok") ;

	return MemTestOk ;
}




// Initialize Memory Test, Test Pattern Generation
void MemTestInit(U32 *src, int tsize)
{
	U32 *InitSrcAddr;
	int cnt ;
	int pat ;

	InitSrcAddr = src ;
	cnt = tsize ;
	pat = 0;

	while(cnt--) {
		*InitSrcAddr++ = (U32)PatternGen(pat++);
        }
}

int ByteCopyTest(U32 *src,U32 *dst,int tsize) 
{
	bcopy(src, dst, tsize) ;
	if (!bcomp(src, dst, tsize)) return MemTestFail  ;

	return MemTestOk ;
}
int SWordCopyTest(U32 *src,U32 *dst,int tsize) 
{
	scopy(src, dst, tsize) ;
	if (!scomp(src, dst, tsize)) return MemTestFail  ;

	return MemTestOk ;
}
int WordCopyTest(U32 *src,U32 *dst,int tsize) 
{
	wcopy(src, dst, tsize) ;
	if (!wcomp(src, dst, tsize)) return MemTestFail  ;

	return MemTestOk ;
}

#if 0
// Byte Copy Function
void bcopy(void *src, void *dst, int tsize)
{
	U8 *SrcAddr; 
	U8 *DstAddr;
	int cnt ;

	SrcAddr	= (U8 *)src ;
	DstAddr	= (U8 *)dst ;
	cnt	= tsize;

	while(cnt--)
		*DstAddr++ = *SrcAddr++ ;
}
#endif

// Half Word Copy Function
void scopy(void *src, void *dst, int tsize)
{
	U16 *SrcAddr; 
	U16 *DstAddr;
	int cnt ;

	SrcAddr	= (U16 *)src;
	DstAddr	= (U16 *)dst;
	cnt	= tsize ;

	while(cnt--)
		*DstAddr++ = *SrcAddr++ ;
}

// Word Copy Function
void wcopy(void *src, void *dst, int tsize)
{
	U32 *SrcAddr; 
	U32 *DstAddr;
	int cnt ;

	SrcAddr	= (U32 *)src ;
	DstAddr	= (U32 *)dst ;
	cnt	= tsize ;

	while(cnt--)
		*DstAddr++ = *SrcAddr++ ;
}

// Byte Compare Function
int bcomp(void *src, void *dst, int tsize)
{
	U8 *SrcAddr; 
	U8 *DstAddr;
	int cnt ;

	SrcAddr	= (U8 *)src ;
	DstAddr	= (U8 *)dst ;
	cnt	= tsize ;

	while(cnt--)
	{
		if ( *DstAddr != *SrcAddr )
			{
			Print("\rMemory Byte Test Error") ;
			Print("\rSource Data is %02x at Addr %08x",*SrcAddr,SrcAddr) ;
			Print("\rDestin Data is %02x at Addr %08x",*DstAddr,DstAddr) ;
			return MemTestFail ;
			}
                DstAddr++;
                SrcAddr++;
	}
	return MemTestOk ;
}

// Half Word Compare Function
int scomp(void *src, void *dst, int tsize)
{
	U16 *SrcAddr;
	U16 *DstAddr;
	int cnt ;

	SrcAddr	= (U16 *)src ;
	DstAddr	= (U16 *)dst ;
	cnt	= tsize ;

	while(cnt--)
	{
		if ( *DstAddr != *SrcAddr )
			{
			Print("\rMemory Short Test Error") ;
			Print("\rSource Data is %04x at Addr %08x",*SrcAddr,SrcAddr) ;
			Print("\rDestin Data is %04x at Addr %08x",*DstAddr,DstAddr) ;
			return MemTestFail ;
			}
                DstAddr++;
                SrcAddr++;
                
	}
	return MemTestOk ;
}

// Word Compare Function
int wcomp(void *src, void *dst, int tsize)
{
	U32 *SrcAddr;
	U32 *DstAddr;
	int cnt ;

	SrcAddr	= (U32 *)src ;
	DstAddr	= (U32 *)dst ;
	cnt	= tsize ;

	while(cnt--)
	{
		if ( *DstAddr != *SrcAddr )
			{
			Print("\rMemory Long Test Error") ;
			Print("\rSource Data is %08x at Addr %08x",*SrcAddr,SrcAddr) ;
			Print("\rDestin Data is %08x at Addr %08x",*DstAddr,DstAddr) ;
			return MemTestFail ;
			}
                DstAddr++;
                SrcAddr++;
	}
	return MemTestOk ;
}

// External I/O Bank Test
void ExtIOBankTest(void)
{

	U32 *ExtIoBase0, *ExtIoBase1, *ExtIoBase2, *ExtIoBase3 ;
	U32 *src ;
	U32 ExtIoTestSize = 0xFF0 ; 
        int lsize = 5 ;   // Ext IO test loop count
	char TestBankSel ;

	EXTACON0  = TCOS0 | TACS0 | TCOH0 | TACC0 ; 
	EXTACON0 |= TCOS1 | TACS1 | TCOH1 | TACC1 ; 
	EXTACON1  = TCOS2 | TACS2 | TCOH2 | TACC2 ; 
	EXTACON1 |= TCOS3 | TACS3 | TCOH3 | TACC3 ; 

	Print("\n >> External I/O Bank Test <<") ;
	ExtIoBase0 = (U32 *)EXTIOBASE ;
	ExtIoBase1 = ExtIoBase0 + 4096 ;
	ExtIoBase2 = ExtIoBase1 + 4096 ;
	ExtIoBase3 = ExtIoBase2 + 4096 ;

	Print("\r +- External I/O Bank #0 Base Addr : 0x%x",ExtIoBase0) ;
	Print("\r +- External I/O Bank #1 Base Addr : 0x%x",ExtIoBase1) ;
	Print("\r +- External I/O Bank #2 Base Addr : 0x%x",ExtIoBase2) ;
	Print("\r +- External I/O Bank #3 Base Addr : 0x%x",ExtIoBase3) ;

        src = (U32 *)MemCopySrc;

	Print("\n $$ Select Test External I/O Bank (0,1,2,3,Q) ? ") ;
	TestBankSel = get_byte() ;
	

	if (TestBankSel == '0' )
	{
		Print("\n <<>> External I/O Bank #0 Test ") ;
        	MemTest(src,ExtIoBase0,ExtIoTestSize,lsize);
	}

	else if (TestBankSel == '1' )
	{
		Print("\n <<>> External I/O Bank #1 Test ") ;
        	MemTest(src,ExtIoBase1,ExtIoTestSize,lsize);
	}

	else if (TestBankSel == '2' )
	{
		Print("\n <<>> External I/O Bank #2 Test ") ;
        	MemTest(src,ExtIoBase2,ExtIoTestSize,lsize);
	}

	else if (TestBankSel == '3' )
	{
		Print("\n <<>> External I/O Bank #3 Test ") ;
        	MemTest(src,ExtIoBase3,ExtIoTestSize,lsize);
	}
	else Print("\r +- Invalid External I/O Bank Selected") ;
}

// Print Memory Test Status
void PrintMemTestStatus(int j)
{
    /*
	if (j==0) PrintStatus(0xE,'/') ;
	else if (j==1) PrintStatus(0xD,'-') ;
	else if (j==2) PrintStatus(0xB,'\\') ;
	else PrintStatus(0x7,'|') ;
	*/
	if (j==0) Print("/") ;
	else if (j==1) Print("-") ;
	else if (j==2) Print("\\") ;
	else Print("|") ;
}

int PatternGen(unsigned int seed)
{
     if(!(seed%0x100)) srand(seed);
     return((unsigned int)(rand())%1501);
}

// Allocation for NonCacheable Area
void *nmalloc(unsigned nbyte) 
/*Very simple; Use nmalloc() & free() like Stack*/
{
        void *returnPt=nmallocPt;

        nmallocPt= (int *)nmallocPt+nbyte/4+((nbyte%4)>0);
        if( (int)nmallocPt > AllocNonCacheAreaEnd)return NULL;
        return returnPt;
}


#if 0  //stdlib.h: previous declaration of malloc
// Allocation for Cacheable Area
/*
 * Function : *malloc
 * Input    : Number of byte for necessary
 * Output   : Start pointer of allocated memory location.
 */
void *malloc(unsigned nbyte)
{
        void *returnPt=mallocPt;

        mallocPt= (int *)mallocPt+nbyte/4+((nbyte%4)>0);
        if( (int)mallocPt > HEAPEND)return NULL;
        return returnPt;
}

/*
 * Function : free
 * Input    : Start pointer for freeze memory location
 * Output   : No
 */
void free(void *pt)
{
        mallocPt=pt;
}

#endif 

void nmfree(void *pt)
{
        nmallocPt=pt;
}