rheatest.c

OMAP1030 处理器的ARM 侧硬件测试代码 OMAP1030 是TI的双核处理器

/* 
===============================================================================
            TEXAS INSTRUMENTS INCORPORATED PROPRIETARY INFORMATION           
                                                                             
   Property of Texas Instruments 
   For  Unrestricted  Internal  Use  Only 
   Unauthorized reproduction and/or distribution is strictly prohibited.  
   This product is protected under copyright law and trade secret law 
   as an unpublished work.  
   Created 1999, (C) Copyright 1999 Texas Instruments.  All rights reserved.
   Filename       	: RheaTest.c

   Description    	: Body file for the test of Rhea Bridge

   Project        	: ARM925ST

   Author         	: Francis Huguenin [e-mail]

===============================================================================
*/
#include "rheatest.h"
#include "result.h"
#include "mem.h"
#include "test.h"
#include "dma.h"
#include "intvecs.h"
#include "global_types.h"
 
//==ASSEMBLER EXTERNAL FUNCTIONS 
//==The result is a 16 bits integer value returned inside R0 register
//==under Thumb mode i.e. 16 bits mode state

extern int multiple (int Addr);
extern int str_ldr (int Addr);
extern int w_8(int Addr);
extern int w_16(int Addr);
extern int w_32(int Addr);

#define TIMEOUT_RHEA 0xFF
#define MAX_WAIT_IT_RHEA 10


//-------------------------------------------------------------------
// RHEATST_Write8Bits                                       -
//-------------------------------------------------------------------
UWORD16 RHEATST_Write8Bits(UWORD32 Strobe0Address,
                             UWORD32 Strobe1Address)
{											
UWORD16 result= RES_OK;

/* To enable the Registers Update */
//INT_SetSupervisor();
/* init. access factors and timeout */
RHEA_InitCtrolReg(RHEA_FACTOR2_STROBE,
						RHEA_FACTOR2_STROBE, 
                  TIMEOUT_RHEA); // timeout
// disable write buffer on strobe 0, disable on strobe 1
RHEA_SetPostedWrite(RHEA_DISABLE_WRITE_BUFFER_STROBE0, 
                    RHEA_DISABLE_WRITE_BUFFER_STROBE1);

// enable timeout access and Irg generation in abort access
RHEA_EnableTimeOutDisableMskIt();

/* Return to User mode after Register Update done */
//INT_SetUser(); 

result  &=  w_8(Strobe0Address); 
result  &=  w_8(Strobe1Address); 

if (result == RES_OK) 
	return RES_OK;
else 
	return RES_BAD;
}


//-------------------------------------------------------------------
//RHEATST_Write16Bits                                      -
//-------------------------------------------------------------------
UWORD16 RHEATST_Write16Bits(UWORD32 Strobe0Address,
                              UWORD32 Strobe1Address)
{
UWORD16 result= RES_OK;

/* To enable the Registers Update */
//INT_SetSupervisor();
/* init. access factors and timeout */
RHEA_InitCtrolReg(RHEA_FACTOR2_STROBE, 
                  RHEA_FACTOR2_STROBE,
                  TIMEOUT_RHEA); // timeout
// disable write buffer on strobe 0, disable on strobe 1
RHEA_SetPostedWrite(RHEA_DISABLE_WRITE_BUFFER_STROBE0, 
                    RHEA_DISABLE_WRITE_BUFFER_STROBE1);
/* Return to User mode after Register Update done */
//INT_SetUser(); 

result  &=  w_16(Strobe0Address); 
result  &=  w_16(Strobe1Address); 

if (result == RES_OK) 
	return RES_OK;
else 
	return RES_BAD;
}

//-------------------------------------------------------------------
// RHEATST_Write32Bits                                      
//-------------------------------------------------------------------
UWORD16 RHEATST_Write32Bits(UWORD32 Strobe0Address,
                              UWORD32 Strobe1Address)
{
UWORD16 result=RES_OK;

/* To enable the Registers Update */
//INT_SetSupervisor();
/* init. access factors and timeout */
RHEA_InitCtrolReg(RHEA_FACTOR2_STROBE, 
                  RHEA_FACTOR2_STROBE,
                  TIMEOUT_RHEA); // timeout
// disable write buffer on strobe 0, disable on strobe 1
RHEA_SetPostedWrite(RHEA_DISABLE_WRITE_BUFFER_STROBE0, 
                    RHEA_DISABLE_WRITE_BUFFER_STROBE1);
/* Return to User mode after Register Update done */
//INT_SetUser(); 

result  &=  w_32(Strobe0Address); 
result  &=  w_32(Strobe1Address); 

if (result == RES_OK) 
	return RES_OK;
else 
	return RES_BAD;
}

//-------------------------------------------------------------------
//	RHEATEST_fast_store_load on memory 32 bits 
//-------------------------------------------------------------------
UWORD16  RHEATST_FastStoreLoadOn32Bits(UWORD32 Strobe0Address,
                                 			  UWORD32 Strobe1Address)
{
UWORD8 ResultStrobe0;
UWORD8 ResultStrobe1;

  /* Set Supervisor Mode to enable Register Update */
  //INT_SetSupervisor();
  /* Set access factors and timeout */
  RHEA_InitCtrolReg(RHEA_FACTOR2_STROBE, 
                    RHEA_FACTOR2_STROBE, TIMEOUT_RHEA);
  // disable write buffer on strobe 0, disable on strobe 1
  RHEA_SetPostedWrite(RHEA_DISABLE_WRITE_BUFFER_STROBE0, 
                      RHEA_DISABLE_WRITE_BUFFER_STROBE1);
  /* Goback to user mode after commit update of Registers */
  //INT_SetUser();

  /***** Strobe 0 *****/
  ResultStrobe0 = str_ldr(Strobe0Address); 

  /***** Strobe 1 *****/
  ResultStrobe1 = str_ldr(Strobe1Address); 

   if ( (ResultStrobe0 == RES_OK) && (ResultStrobe1 == RES_OK) )
	return RES_OK;
   else return RES_BAD;
}


//-------------------------------------------------------------------
// rheatest_access
//-------------------------------------------------------------------
UWORD16 rheatest_access
       (const UWORD32                  Strobe0Address,
        const UWORD32                  Strobe1Address,
		  const RHEA_Access_Size_t					MemoryWidth)
{
static UWORD8 strobe0_value_8bits  =0x55;
static UWORD8 strobe1_value_8bits  =0xaa;
static UWORD16 strobe0_value_16bits =0xa1a2;
static UWORD16 strobe1_value_16bits =0x5152;
static UWORD32 strobe0_value_32bits =0xabcdef59;
static UWORD32 strobe1_value_32bits =0xf417278c;
BOOL ok =True;

switch (MemoryWidth)
	  {
	  case RHEA_BITS8_SIZE :
		  {
   	  /* write to the fast and slow strobe domains with 8 bits access*/
   	  *(UWORD8*) (Strobe0Address) = strobe0_value_8bits;  
   	  *(UWORD8*) (Strobe1Address) = strobe1_value_8bits;

   	  /* Check that data transfered into strobe 0 & 1 are correct */
   	  if ((*(UWORD8*) (Strobe0Address) != strobe0_value_8bits ) ||
      		(*(UWORD8*) (Strobe1Address) != strobe1_value_8bits ))
				ok=False;
		  // increment test values so that next test is perform on different values
   	  strobe0_value_8bits++;  
   	  strobe1_value_8bits++;
		  break;
		  }
	  case RHEA_BITS16_SIZE :
		  {
   	  /* write to the fast and slow strobe domains with 16 bits access*/
   	  *(UWORD16*) (Strobe0Address) = strobe0_value_16bits;  
   	  *(UWORD16*) (Strobe1Address) = strobe1_value_16bits;

   	  /* Check that data transfered into strobe 0 & 1 are correct */
   	  if (( *(UWORD16*) (Strobe0Address) != strobe0_value_16bits ) ||
      		( *(UWORD16*) (Strobe1Address) != strobe1_value_16bits ))
				ok=False;
		  // increment test values so that next test is perform on different values
   	  strobe0_value_16bits++;  
   	  strobe1_value_16bits++;
		  break;
		  }

	  case RHEA_BITS32_SIZE :
		  {
   	  /* write to the fast and slow strobe domains with 32 bits access*/
   	  *(UWORD32*) (Strobe0Address) = strobe0_value_32bits;  
   	  *(UWORD32*) (Strobe1Address) = strobe1_value_32bits;

   	  /* Check that data transfered into strobe 0 & 1 are correct */
   	  if (( *(UWORD32*) (Strobe0Address) != strobe0_value_32bits ) ||
      		( *(UWORD32*) (Strobe1Address) != strobe1_value_32bits ) )
				ok=False;
		  // increment test values so that next test is perform on different values
   	  strobe0_value_32bits++;  
   	  strobe1_value_32bits++;
		  break;
		  }
	  }
if (ok)
  return RES_OK;
else
  return RES_BAD;
}




//-------------------------------------------------------------------
//     RHEATEST_multiple_store_load
//-------------------------------------------------------------------
UWORD16 RHEATST_MultipleStoreLoad32Bits (UWORD32 Strobe0Address,
                                                UWORD32 Strobe1Address) 
{

UWORD16 ResultStrobe0;
UWORD16 ResultStrobe1;
  /* Set access factors and timeout */
  /// FH 
  RHEA_InitCtrolReg(RHEA_FACTOR2_STROBE,RHEA_FACTOR2_STROBE, TIMEOUT_RHEA);
  /* Disable Write Buffer on fast and slow strobes: Not Posted Write */
  RHEA_SetPostedWrite(RHEA_DISABLE_WRITE_BUFFER_STROBE0, 
                    RHEA_DISABLE_WRITE_BUFFER_STROBE1);

  ResultStrobe0 = multiple(Strobe0Address);
  ResultStrobe1 = multiple(Strobe1Address);

  if ( (ResultStrobe0 == RES_OK) && (ResultStrobe1 == RES_OK) )
       return RES_OK;
  else return RES_BAD;
}


//-------------------------------------------------------------------
//               RHEATST_AccessFactor
//-------------------------------------------------------------------
UWORD16 RHEATST_AccessFactor(UWORD32 Strobe0Address,
                               UWORD32 Strobe1Address,
		  								 const RHEA_Access_Size_t MemoryWidth) 
{
UWORD16 result = RES_OK;

// disable write buffer on strobe 0, disable on strobe 1
RHEA_SetPostedWrite(RHEA_DISABLE_WRITE_BUFFER_STROBE0,
                    RHEA_DISABLE_WRITE_BUFFER_STROBE1);

/* Set access factors and timeout */
RHEA_InitCtrolReg(RHEA_FACTOR2_STROBE,RHEA_FACTOR2_STROBE, TIMEOUT_RHEA);
if (rheatest_access(Strobe0Address, Strobe1Address,MemoryWidth)== RES_BAD)
	result = RES_BAD;						 

/* Set access factors and timeout */
RHEA_InitCtrolReg(RHEA_FACTOR5_STROBE,RHEA_FACTOR10_STROBE, TIMEOUT_RHEA);
if (rheatest_access(Strobe0Address, Strobe1Address,MemoryWidth)== RES_BAD)
	result = RES_BAD;						 

/* Set access factors and timeout */
RHEA_InitCtrolReg(RHEA_FACTOR15_STROBE,RHEA_FACTOR15_STROBE,TIMEOUT_RHEA);
if (rheatest_access(Strobe0Address, Strobe1Address,MemoryWidth)== RES_BAD)
	result = RES_BAD;						 

return (result);	
}



//-------------------------------------------------------------------
//  RHEATST_WriteBuffer
//-------------------------------------------------------------------
UWORD16 RHEATST_WriteBuffer (UWORD32 Strobe0Address,
                              UWORD32 Strobe1Address,
		  								const RHEA_Access_Size_t MemoryWidth) 

{
#define VALUE_8BITS   0x12
#define VALUE_16BITS  0x67AD
#define VALUE_32BITS  0x6f7cA7D1


/* status of the posted write operation on strobe 0 and 1 */
UWORD16 Strobe0Status= RES_OK;
UWORD16 Strobe1Status= RES_OK;

  /* Set access factors and timeout */
  RHEA_InitCtrolReg(RHEA_FACTOR2_STROBE, 
                    RHEA_FACTOR2_STROBE, TIMEOUT_RHEA);
  RHEA_SetPostedWrite(RHEA_ENABLE_WRITE_BUFFER_STROBE0, 
                      RHEA_ENABLE_WRITE_BUFFER_STROBE1);
  /* Return to User mode after Register Update done */
  //INT_SetUser();

// do access according to kind of memory
switch (MemoryWidth)
	{
	case (RHEA_BITS8_SIZE):
   // Test strobe 0              
   *(UWORD8*)Strobe0Address = VALUE_8BITS;
   // Blocking Read: Check the read value matches the written value 
   if ( *(UWORD8*) Strobe0Address != VALUE_8BITS)
	   Strobe0Status = RES_BAD;

	// Test strobe 1             
   *(UWORD8*)Strobe1Address = VALUE_8BITS;
   // Blocking Read: Check the read value matches the written value 
   if ( *(UWORD8*)Strobe1Address != VALUE_8BITS)
	   Strobe1Status = RES_BAD;
	break;

	case (RHEA_BITS16_SIZE):
   // Test strobe 0             
   *(UWORD16*)Strobe0Address = VALUE_16BITS;
   // Blocking Read: Check the read value matches the written value 
   if ( *(UWORD16*)Strobe0Address != VALUE_16BITS)
	   Strobe0Status = RES_BAD;

	// Test strobe 1             
   *(UWORD16*)Strobe1Address = VALUE_16BITS;
   // Blocking Read: Check the read value matches the written value 
   if ( *(UWORD16 *)Strobe1Address != VALUE_16BITS)
	   Strobe1Status = RES_BAD;
	break;

	case (RHEA_BITS32_SIZE):
   // Test strobe 0             
   *(UWORD32*)Strobe0Address = VALUE_32BITS;
   // Blocking Read: Check the read value matches the written value 
   if ( *(UWORD32*)Strobe0Address != VALUE_32BITS)
	   Strobe0Status = RES_BAD;
 
 	// Test strobe 1             
   *(UWORD32*)Strobe1Address = VALUE_32BITS;
   // Blocking Read: Check the read value matches the written value 
   if ( *(UWORD32*)Strobe1Address != VALUE_32BITS)
	   Strobe1Status = RES_BAD;
	break;
	}

if  ((Strobe1Status == RES_OK) && (Strobe0Status == RES_OK) )
    return RES_OK;
else 
    return RES_BAD;

}


//-------------------------------------------------------------------
// RHEATST_LowFrequency
//-------------------------------------------------------------------
UWORD16 RHEATST_LowFrequency(UWORD32 Strobe0Address,
                               UWORD32 Strobe1Address,
		  								 const RHEA_Access_Size_t MemoryWidth) 

{
UWORD16 result = RES_OK;

// Set access factors and timeout 
RHEA_InitCtrolReg(RHEA_FACTOR0_STROBE, 
                  RHEA_FACTOR0_STROBE, TIMEOUT_RHEA);
RHEA_SetPostedWrite(RHEA_ENABLE_WRITE_BUFFER_STROBE0, 
                   RHEA_ENABLE_WRITE_BUFFER_STROBE1);

RHEA_SetLowFrequency();
// perform test R/W
if (rheatest_access(Strobe0Address, Strobe1Address,MemoryWidth)== RES_BAD)
    result = RES_BAD;