/*----------------------------------------------------------------------
* FILE:  mem_test.c
*-----------------------------------------------------------------------
*             (C) Copyright 2001 Metrowerks Corp.
*                 ALL RIGHTS RESERVED .
*
*   THIS IS  CONFIDENTIAL  PROPRIETARY SOURCE CODE OF METROWERKS CORP.
*
*          The copyright notice above does not evidence any
*         actual or intended publication of such source code.
*-----------------------------------------------------------------------
*
* DESCRIPTION: Test DDR 32bit 8MGB(8M*16*4 1.8v 133mhz) 
*              (base addr ,size must be changed, add init) 
*              on i.MX31 board.
*   
*
* REFERENCES: 
*      1) i.mx31 Users Manual
*
* HISTORY:
*
*--------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "bono_memory_map_defines.h"
#include "tstsrv.h"
#include "common.h"



#define MAX_TEST_ERROR_NUM 10

// DDR parameters
#define START_BASE_ADDR	CSD1_BASE_ADDR 

#define OFFSET_ADDR	(1024*1024) // 1mgbytes

#define START_RAM_ADDR	(START_BASE_ADDR + OFFSET_ADDR) // DDR addr to test

#define MEM_BYTE_SIZE (64*1024*1024) // DDR size - 64mgbyte

#define BYTE_SIZE (MEM_BYTE_SIZE - OFFSET_ADDR) // 1mgbytes memory size to test


#define END_RAM_ADDR	(START_RAM_ADDR + BYTE_SIZE)


long SdramPatterns[] = {0x1111111, 0x55555555, 0xAAAAAAAA, 0xFFFFFFFF};
//SdramPatterns[] = {0, 0x55555555, 0xAAAAAAAA, 0xFFFFFFFF};
int          SdramPatternsCount = sizeof(SdramPatterns) / sizeof(WORD);


ulong *start_adr;
ulong *end_adr;
int   ErrorsNum;
char  out_str[0x100];
char         TestName[] = "DDR";

int MEMtest (void) ;
void mem_error (ulong *mem_addr, ulong data);
int  walking_one_on32bit_databus (void);
int  addr_march_test (void);
int pattern_test (void);

/*------------------------------------------------------------------------
*
* FUNCTION NAME:  MEMtest 
*
* DESCRIPTION:
*  This is the main function for the Test DDR 8MGB 
*  (addr / size must be change) on i.mx31 board 
*
*                 
* PARAMETERS:  None
*
* RETURNS: RET_ERR if there was an error and RET_OK if there wasn't
*
*-------------------------------------------------------------------------*/
int MEMtest (void) 
{
int  rc = RET_OK;

  start_adr = (ulong *)START_RAM_ADDR;
  end_adr	= (ulong *)END_RAM_ADDR;

  ErrorsNum = 0;

  sprintf(out_str, "%s  TEST 0x%lx - 0x%lx IN PROGRESS: \n",
          TestName, (ulong)start_adr, (ulong)end_adr);
  printf(out_str);

  walking_one_on32bit_databus();

  if (ErrorsNum < MAX_TEST_ERROR_NUM)
       addr_march_test();

  if (ErrorsNum < MAX_TEST_ERROR_NUM)
       pattern_test();

  if (ErrorsNum != 0)
      rc = RET_ERR;  
  return rc;
}

/*--------------------------------------------------------------------------
*
* FUNCTION NAME:  addr_march_test
*
* DESCRIPTION: Address march test
*
* EXTERNAL EFFECTS:  None
*
* PARAMETERS: None
*
* RETURNS: Count of error if there was an error and 0 if there wasn't
*
*--------------------------------------------------------------------------*/
int addr_march_test (void)
{
ulong  *CurrSdram;
int    error = 0;
//ulong  BlinkNum=0;
static int  first;

    printf("Address march...\n");
    // write Address
    first = 0;
  	for (CurrSdram = start_adr; CurrSdram < end_adr; CurrSdram++) 
  	{
		*CurrSdram  = (ulong)CurrSdram;
		if (first == 0)
		{
			if (*(ulong *)START_RAM_ADDR != START_RAM_ADDR)
			{
			  sprintf(out_str, "Start sdram value has been changed when wrote to addrs 0x%lx\n", (ulong)CurrSdram);
			  printf(out_str);
			  sprintf(out_str, "START_RAM_ADDR = 0x%lx, val = 0x%lx(must be 0x%lx)\n", (ulong)START_RAM_ADDR, *(ulong *)START_RAM_ADDR, (ulong)START_RAM_ADDR);
			  printf(out_str);
			  first++;
		      error++;
		      if (error + ErrorsNum >= MAX_TEST_ERROR_NUM)
		        break;
			}
		}        
    }
    if (error + ErrorsNum < MAX_TEST_ERROR_NUM)
    {
	    // verify Address
	  	for (CurrSdram = start_adr; CurrSdram < end_adr; CurrSdram++) 
	  	{
		    if(*CurrSdram != (ulong)CurrSdram) 
		    {
		      mem_error (CurrSdram, (ulong)CurrSdram);
		      error++;
		      if(error + ErrorsNum >= MAX_TEST_ERROR_NUM)
		        break;
		    }
		}
	}
    ErrorsNum += error;
    return error;
}
/*--------------------------------------------------------------------------
*
* FUNCTION NAME:  pattern_test
*
* DESCRIPTION:Patterns test
*
* EXTERNAL EFFECTS:  None
*
* PARAMETERS: None
*
* RETURNS: Count of error if there was an error and 0 if there wasn't
*
*--------------------------------------------------------------------------*/
int pattern_test (void)
{

ulong  *CurrSdram;
int    error = 0;
int    i;
ulong  CurrPatterns;
//ulong  BlinkNum=0;

  
  for (i = 0; i < SdramPatternsCount;i++)
  {
    sprintf(out_str, "Pattern 0x%lx ...\n", SdramPatterns[i]);
    printf(out_str);
    CurrPatterns = SdramPatterns[i];
 
    // write current pattern
  	for (CurrSdram =start_adr; CurrSdram < end_adr;CurrSdram++) 
  	{
        *CurrSdram  = CurrPatterns;
    }
    // verify current pattern
  	for (CurrSdram = start_adr; CurrSdram < end_adr;CurrSdram++) 
  	{
	    if(*CurrSdram != CurrPatterns) 
	    {
	      mem_error (CurrSdram, CurrPatterns);
	      error++;
	      if(error + ErrorsNum >= MAX_TEST_ERROR_NUM)
	        break;
	    }
	}
  }
  ErrorsNum += error;
  return error;
}
/*--------------------------------------------------------------------------
*
* FUNCTION NAME:  walking_one_on32bit_databus
*
* DESCRIPTION: Test memory with the walking one
*
*
* EXTERNAL EFFECTS:  None
*
* PARAMETERS: ptrl - pointer to the start memory to test
*			  
* RETURNS: Count of error if there was an error and 0 if there wasn't
*
*--------------------------------------------------------------------------*/
int walking_one_on32bit_databus (void)
{
int   i;
ulong *CurrAddr;
int   error = 0;
ulong currVal;

  CurrAddr = start_adr;
  currVal = 1;
  
  printf("Walking one...\n");
    
  for (i = 0; i < DATA_32_BUS_WIDTH; i++)
  {
	*CurrAddr = currVal;
    if (*CurrAddr != currVal)
    {
      mem_error (CurrAddr, currVal);
      error++;
      if(error + ErrorsNum >= MAX_TEST_ERROR_NUM)
        break;
    }
    currVal <<= 1;
  }
  ErrorsNum += error;

  return error;
}
/*--------------------------------------------------------------------------
*
* FUNCTION NAME:  mem_error
*
* DESCRIPTION: Make and display error message 
*
*
* EXTERNAL EFFECTS:  None
*
* PARAMETERS: 
*			  mem_addr - pointer to the memory 
*			  data - the wrote value 
*
* RETURNS: None
*
*--------------------------------------------------------------------------*/
void mem_error (ulong *mem_addr, ulong data)
{
char *ptrch;
short len;

  sprintf(out_str, "ERROR AT ADDRESS ");
  len = strlen(out_str);
  ptrch = &out_str[0] + len+1;
  out_str[len] = ' ';
  sprintf(ptrch, "0x%lx\n: WROTE : 0x%lx\n: READ  : 0x%lx \n",
         (ulong)mem_addr,  data, *mem_addr);
  printf(out_str);
}