memtest.c

TMS320F2808的完整驱动测试程序源码

/*H*****************************************************************************
*
* $Archive::                                                                   $
* $Revision::                                                                  $
* $Date::                                                                      $
* $Author::                                                                    $
*
* DESCRIPTION: R2808 Post
*
* GLOBALS 
*
* PUBLIC FUNCTIONS:
*                              
* PRIVATE FUNCTIONS:
*
* USAGE/LIMITATIONS:
*
* NOTES:  
*     
* (C) Copyright 2004 by Spectrum Digital Incorporated
* All rights reserved
*
*H*****************************************************************************/

#include "DSP280x_Device.h"
#include "r2808cfg.h"
#include "memtest.h"

volatile unsigned Error_CheckPattern  = 0;		// The memory errors
volatile unsigned Error_AddressAsData = 0;
volatile unsigned Error_AltPattern    = 0;
volatile unsigned Error_EEPROM        = 0;

//---------------------------------------------------------------------------
// Write a simple pattern to memory
//---------------------------------------------------------------------------
int MEM_PatternTest (int pattern, UFP start_address, long size_in_word )
{

  long i;
  int error = 0;
  UFP mem_ptr = start_address;

  /* Write pattern to the memory */
  for(i=0;i<size_in_word;i++)
  {
    *mem_ptr++ = pattern;
  }

  /* Read memory and compare contents to the pattern written */
  mem_ptr = start_address;
  for(i=0;i<size_in_word;i++)
  {
    if ( *mem_ptr++ != pattern) error++;
  }
  return error;
}

//---------------------------------------------------------------------------
// Write the pattern and the complement of the pattern.
//---------------------------------------------------------------------------
int MEM_AlternateDataTest(int pattern, UFP start_address, long size_in_word )
{
  long i;
  int temp_read, temp_expected;
  int error = 0;
  UFP mem_ptr = start_address;

  /* Write pattern to the memory */
  for(i=0;i<size_in_word;i++)
  {
	if(i%2)
	  *mem_ptr++ = ~pattern;
	else
	  *mem_ptr++ = pattern;
  }

  /* Read memory and compare contents to the pattern written */
  mem_ptr = start_address;
  for(i=0;i<size_in_word;i++)
  {
	temp_read = *mem_ptr++;

	if(i%2)
	  temp_expected = ~pattern;
	else
	  temp_expected = pattern;

    if ( temp_read != temp_expected ) error++;
  }
  return error;
}

//---------------------------------------------------------------------------
// Write current address as the data value
//---------------------------------------------------------------------------
int MEM_AdressAsDataTest( UFP SramAddr, long Count )
{
	volatile UFP pSRAM_WORD;
	unsigned     TestPattern;
	long i;
	int Error;
	
	pSRAM_WORD   =  SramAddr;
	TestPattern  = (unsigned)((unsigned long)SramAddr); 
	
	for( i=0; i<Count; i++ )
	{
	    // Write the test pattern
	    *pSRAM_WORD = TestPattern;
	    pSRAM_WORD++;
	    TestPattern++;
	}
	
	Error        = 0;
	
	pSRAM_WORD   =  SramAddr;
	TestPattern  = (unsigned)((unsigned long)SramAddr); 
		
    for( i=0; i<Count; i++ )
	{
	   // Read the test pattern
	   if( *pSRAM_WORD != TestPattern )
		    Error++;
	    pSRAM_WORD++;
	    TestPattern++;
	}

	return( Error );
}

//---------------------------------------------------------------------------
// Write a memory pattern.
//---------------------------------------------------------------------------
static void 
SetPattern(int pattern, UFP start_address, long size_in_word )
{
  UFP mem_ptr = start_address;
  long i;
    
  for(i=0;i<size_in_word;i++)
  {
    *mem_ptr++ = pattern;
  }
}

//---------------------------------------------------------------------------
// Verify a memory pattern.
//---------------------------------------------------------------------------
static int
CheckPattern(int pattern, UFP start_address, long size_in_word )
{

  UFP mem_ptr = start_address;
  long i;
  
  for(i=0;i<size_in_word;i++)
  {
    if ( *mem_ptr++ != pattern )
        return(1);
    
  }
  return(0);
}

//---------------------------------------------------------------------------
// Run external memory tests at speed
//---------------------------------------------------------------------------

int MEM_DoTest( int TestLoop )
{
	int           Error = 0;
	int           Error_CheckPattern = 0;
	unsigned long SramAddr;
	    
    while( TestLoop-- )
    {
        SramAddr = EXT_SRAM_BASE;
        SetPattern( 0xaaaa, (UFP)SramAddr, (long) EXT_SRAM_BLOCK);
		
	    SramAddr += EXT_SRAM_BLOCK;
	    SetPattern( 0x5555, (UFP)SramAddr, (long) EXT_SRAM_BLOCK);
	    
	    SramAddr += EXT_SRAM_BLOCK;
	    SetPattern( 0xcccc, (UFP)SramAddr, (long) EXT_SRAM_BLOCK);

	    SramAddr += EXT_SRAM_BLOCK;
	    SetPattern( 0x9999, (UFP)SramAddr, (long) EXT_SRAM_BLOCK);
	    
	    SramAddr = EXT_SRAM_BASE;
		Error = CheckPattern( 0xaaaa, (UFP)SramAddr, (long) EXT_SRAM_BLOCK);
		if( Error != 0 )
			Error_CheckPattern++;

	    SramAddr += EXT_SRAM_BLOCK;
	    Error = CheckPattern( 0x5555, (UFP)SramAddr, (long) EXT_SRAM_BLOCK);
		if( Error != 0 )
			Error_CheckPattern++;
			
	    SramAddr += EXT_SRAM_BLOCK;
		Error = CheckPattern( 0xcccc, (UFP)SramAddr, (long) EXT_SRAM_BLOCK);
		if( Error != 0 )
			Error_CheckPattern++;
		
	    SramAddr += EXT_SRAM_BLOCK;
		Error = CheckPattern( 0x9999, (UFP)SramAddr, (long) EXT_SRAM_BLOCK);
		if( Error != 0 )
			Error_CheckPattern++;
		
		Error = MEM_AdressAsDataTest( (UFP)EXT_SRAM_BASE, (long) EXT_SRAM_LENGTH );
		if( Error != 0 )
		 	Error_AddressAsData++;
		
		Error = MEM_AlternateDataTest (0x1234, (UFP)EXT_SRAM_BASE, (long) EXT_SRAM_LENGTH  );
		if( Error != 0 )
			Error_AltPattern++;
	 	  
	    if( Error != 0 ) {
		    break;
	    }	      
	 }
	 return( Error );
}