memtest.c

2410TK测试代码

//===============================================================================
// File Name      : memtest.c
// Function       : S3C2410 Memory Test Function
// The originator : 04/28/2004, Shin, On Pil (SOP) at Mobile Design P/J of SoC
// Upgrade        : Shin, On Pil (SOP)
// Upgrade Date   : 05/14/2004
// Version        : 0.0
// History
//     04/28/2004 : SOP, Programming Start
//================================================================================

#include <string.h>
#include "def.h"
#include "option.h"
#include "2410lib.h"
#include "usbfifo.h"

#define START_ADDRESS   (_NONCACHE_STARTADDRESS)
//#define START_ADDRESS   (_NONCACHE_STARTADDRESS+0x2f00000)   
#define END_ADDRESS     (_NONCACHE_STARTADDRESS+0x2feff00)

#define PATTERN00       0x00000000
#define PATTERN01       0x55555555
#define PATTERN11       0xffffffff
#define PATTERN10       0xaaaaaaaa

#define PATTERNADDR     0               //1: Address = Pattern ,  0: Pattern
#define PATTERN_INVERT  1               //1: Pattern Invert    ,  0: Pattern Non Invert 

void mem_write_read (int address, int end_addr, int pattern);

//================================================================================
void Test_MEM(void)
{
    int i;
    
    Uart_Printf("\n[ Memory Write/Read/Compare Test ]\n");
    
//    Uart_Printf("Start Address= 0x%08x,  End Address= 0x%08x, Size= %d Bytes\n",
//               START_ADDRESS,END_ADDRESS,(END_ADDRESS-START_ADDRESS));    

    if (!PATTERNADDR)
    {
        
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xffff5555);   
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xaaaaffff);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x5555ffff);   
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xffffaaaa);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x0000ffff); 
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xffff0000);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xa5a5a5a5);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x5a5a5a5a);
        
        mem_write_read (START_ADDRESS, END_ADDRESS,  PATTERN00);    // 0x00000000
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x11111111);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x22222222);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x33333333); 
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x44444444);
        mem_write_read (START_ADDRESS, END_ADDRESS, PATTERN01);    // 0x55555555
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x66666666);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x77777777);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x88888888);  
        mem_write_read (START_ADDRESS, END_ADDRESS, 0x99999999); 
        mem_write_read (START_ADDRESS, END_ADDRESS,  PATTERN10);    // 0xaaaaaaaa
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xbbbbbbbb);
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xcccccccc); 
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xdddddddd); 
        mem_write_read (START_ADDRESS, END_ADDRESS, 0xeeeeeeee);
        mem_write_read (START_ADDRESS, END_ADDRESS,  PATTERN11);    // 0xffffffff                                                                                                                                                          
        
//        mem_write_read (START_ADDRESS, END_ADDRESS, PATTERN01);    // 0x55555555 
//        mem_write_read (START_ADDRESS, END_ADDRESS, 0xa5a5a5a5);
 
        for (i=0;i<32;i++)          // Data Bit
            mem_write_read (START_ADDRESS, END_ADDRESS, (1<<i)); 
        for (i=0;i<31;i++)
            mem_write_read (START_ADDRESS, END_ADDRESS, (3<<i)); 
        for (i=0;i<30;i++)
            mem_write_read (START_ADDRESS, END_ADDRESS, (7<<i)); 
        for (i=0;i<29;i++)
            mem_write_read (START_ADDRESS, END_ADDRESS, (0xf<<i));           
                                                   
    }
    else
    {
        mem_write_read (START_ADDRESS, END_ADDRESS, PATTERN00);        
    }

    Uart_Printf("Memory Test Completed.\n");
}

//================================================================================
void mem_write_read (int address, int end_addr, int pattern)
{
    int i, addr1, addr2;
    
    addr1 = 0x31000000;
    addr2 = 0x33feff00;
    
    Uart_Printf("\n*** Memory Test Pattern= 0x%08x and 0x%08x\n",pattern,~pattern);
   
//    Uart_Printf("Now, Writing ...\n");

    Uart_Printf("Memory Testing ...\n");    

    for(i=0;i<1000000;i++)
    {    
        *((U32 *)addr1) = pattern;
        *((U32 *)addr2) = ~pattern;            
    
   	    if (!(*((U32 *)addr1) == pattern))
            Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",addr1,pattern,*((U32 *)addr1));
        
   	    if (!(*((U32 *)addr2) == ~pattern))
            Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",addr2,~pattern,*((U32 *)addr2));        
            
        *((U32 *)addr1) = ~pattern;
        *((U32 *)addr2) = pattern;            
    
   	    if (!(*((U32 *)addr1) == ~pattern))
            Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",addr1,~pattern,*((U32 *)addr1));
        
   	    if (!(*((U32 *)addr2) == pattern))
            Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",addr2,pattern,*((U32 *)addr2));            
    }
    Uart_Printf("Testing Completed.\n");      	    
    //Uart_Printf("Press to any key. Continue...\n");
    //while(!Uart_GetKey());      
}

/*
//================================================================================
void mem_write_read (int address, int end_addr, int pattern)
{
    int i;
    volatile U32 memSum0=0, memSum1=0;    

    
    if (!PATTERNADDR)
    {
        if (PATTERN_INVERT)
            Uart_Printf("\n*** Memory Test Pattern= 0x%08x and 0x%08x\n",pattern,~pattern);
        else
            Uart_Printf("\n*** Memory Test Pattern= 0x%08x\n",pattern);             
    }        
    else
        Uart_Printf("\n*** Memory Test Pattern= Address\n");     
    
    Uart_Printf("Now, Writing ...\n");
       
    for(i=address;i<end_addr;i+=4)
    {
        if (!PATTERNADDR)
        {
            memSum0+=*((U32 *)i)=pattern;
            //Uart_Printf("Address= 0x%08x,    Write= 0x%08x\n",i,*((U32 *)i)); 
            
            if (PATTERN_INVERT)
            {
                i+=4;
                memSum0+=*((U32 *)i)= ~pattern;            
                //Uart_Printf("Address= 0x%08x,    Write= 0x%08x\n",i,*((U32 *)i));             
            }
        }
        else            
        {
            memSum0+=*((U32 *)i)=i; 
            //Uart_Printf("Address= 0x%08x,    Write= 0x%08x\n",i,i);                   
        }
    }

    Uart_Printf("Now, Reading and Comparing ...\n");
    
    for(i=address;i<end_addr;i+=4)
    {
        if (!PATTERNADDR)        
        {
        	if (*((U32 *)i) == pattern)
        	{
       	        memSum1+=*((U32 *)i)=pattern; 
                //Uart_Printf("Address: 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",i,pattern,*((U32 *)i));       	        
            }
    	    else
    	    {
                Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",i,pattern,*((U32 *)i));
                //Uart_Printf("Press to any key. Continue...\n");
                //while(!Uart_GetKey());         	        
            }
        
            if (PATTERN_INVERT)
            {
                i+=4;       
            
                if(*((U32 *)i) == ~pattern)
                {
                    memSum1+=*((U32 *)i)= ~pattern;        	          
                    //Uart_Printf("Address: 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",i,~pattern,*((U32 *)i));
                }
    	        else
    	        {
                    Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",i,~pattern,*((U32 *)i));
                    //Uart_Printf("Press to any key. Continue...\n");
                    //while(!Uart_GetKey());         	        
                }
            }        
        }
        else
        {       	    
    	    if (*((U32 *)i) == i)
    	    {
       	        memSum1+=*((U32 *)i)=i;        	     	
                //Uart_Printf("Address: 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",i,i,*((U32 *)i));       	        
       	    }
    	    else
    	    {
                Uart_Printf("Error!!!: Address= 0x%08x,    Write= 0x%08x,   Read= 0x%08x\n",i,i,*((U32 *)i));
                //Uart_Printf("Press to any key. Continue...\n");
                //while(!Uart_GetKey());
            }
        }
    }        
    
    if(memSum0 == memSum1)
    ;
    	//Uart_Printf("OK. Memory Test Result.\n");
    else
    ;
    { 
    	//Uart_Printf("\nERROR!!! Memory Test Result.\n");        
        //Uart_Printf("memSum0= 0x%x , memSum1= 0x%x\n",memSum0,memSum1);    
    }    	    
}
*/