sim.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 1987, (C) Copyright 1997 Texas Instruments.  All 
//   rights reserved.                                                            
//                                                                             
//  Filename    : sim.c
//  Description : set of functions for SIM module 
//  Project     : Samson
//  Author      : [e-mail]  Patrice Monteil
//                Adapted for Samsom by Francois Reygagne [e-mail]
//-----------------------------------------------------------------------------

#include  "sim.h"
#include  "global_types.h"
#include  "mapping.h"
#include  "result.h"


//------------------------------------------
//  SIM_Error_t
//------------------------------------------
typedef enum 
{
  SIM_CMD_RESET_ERROR     = 0x03,
  SIM_STAT_RESET_ERROR    = 0x04,
  SIM_CONF1_RESET_ERROR   = 0x05,
  SIM_CONF2_RESET_ERROR   = 0x06,
  SIM_IT_RESET_ERROR      = 0x07,
  SIM_DRX_RESET_ERROR     = 0x08,
  SIM_DTX_RESET_ERROR     = 0x09,
  SIM_MASKIT_RESET_ERROR  = 0x0A, 
      
 //Write & Read back => read value mistmatch written value
  SIM_CMD_ACCESS_ERROR    = 0x0B,
  SIM_CONF1_ACCESS_ERROR  = 0x0C,
  SIM_CONF2_ACCESS_ERROR  = 0x0D,
  SIM_DTX_ACCESS_ERROR    = 0x0E,
  SIM_MASKIT_ACCESS_ERROR = 0x0F
} SIM_Error_t; 


//---------------------------------------------
//   SIM_TestRegisters
//---------------------------------------------
UWORD16 SIM_TestRegisters(void)
{
UWORD16 val;
UWORD16 res = RES_OK;

//-----------------------------------
// Check Reset Default values
//-----------------------------------

  //Check Control register reset value
  val = (SIM_CMD_REG & SIM_CMD_REG_MASK);
  if ( val != SIM_CMD_RESET_VALUE )
  {
     RES_Set(SIM_CMD_RESET_ERROR);
     RES_Set(val);
     res = RES_BAD;
  }

  //Check Status register reset value  
  val = (SIM_STAT_REG & SIM_STAT_REG_MASK);
  if ( val != SIM_STAT_RESET_VALUE )
  {
     RES_Set(SIM_STAT_RESET_ERROR);
     RES_Set(val);
     res = RES_BAD;
  }

  //Check Configuration register reset value     
  val = (SIM_CONF1_REG & SIM_CONF1_REG_MASK);
  if ( val != SIM_CONF1_RESET_VALUE )
  {
     RES_Set(SIM_CONF1_RESET_ERROR);
     RES_Set(val);
     res = RES_BAD;
  }

  //Check time-delay paremeters register reset value     
  val = (SIM_CONF2_REG & SIM_CONF2_REG_MASK);
  if ( val != SIM_CONF2_RESET_VALUE )
  {
     RES_Set(SIM_CONF2_RESET_ERROR);
     RES_Set(val);
     res = RES_BAD;
  }

  //Check Interrupt status register reset value  
  val = (SIM_IT_REG & SIM_IT_REG_MASK);
  if ( val != SIM_IT_RESET_VALUE )
  {
     RES_Set(SIM_IT_RESET_ERROR);
     RES_Set(val);
     res = RES_BAD;
  }	

  //Check Interrupt CD status register reset value  
  val = (SIM_IT_CD_REG & SIM_IT_CD_REG_MASK);
  if ( val != SIM_IT_CD_RESET_VALUE )
  {
     RES_Set(SIM_IT_RESET_ERROR);
     RES_Set(val);
     res = RES_BAD;
  }	
 
  //Check Receive byte register reset value  
  //No check because values are undefined at reset
//  val = (SIM_DRX_REG & SIM_DRX_REG_MASK); 
//  if ( val != SIM_DRX_RESET_VALUE ) 
//  { 
//     RES_Set(SIM_DRX_RESET_ERROR);
//  }	 

  //Check Transmit byte register reset value  
  val = (SIM_DTX_REG & SIM_DTX_REG_MASK); 
  if ( val != SIM_DTX_RESET_VALUE ) 
  { 
     RES_Set(SIM_DTX_RESET_ERROR);
     RES_Set(val);
     res = RES_BAD;
  }	 
  
  //Check Interrupt Mask register reset value  
  val = (SIM_MASKIT_REG & SIM_MASKIT_REG_MASK); 
  if ( val != SIM_MASKIT_RESET_VALUE ) 
  { 
     RES_Set(SIM_MASKIT_RESET_ERROR);
     RES_Set(val);
     res = RES_BAD;
  }	 
  
 
  return res;

}


//-----------------------------------------------------------------------
//   SIM_WriteCmd  
//-----------------------------------------------------------------------
void SIM_WriteCmd (UWORD8 cmd)
{
  SIM_CMD_REG = (cmd & SIM_CMD_REG_MASK);
}

//-----------------------------------------------------------------------
//   SIM_ResetInterface 
//-----------------------------------------------------------------------
void SIM_ResetInterface (void)
{
  SIM_CMD_REG = (SIM_CMD_IFRST_MASK |  SIM_CMD_CLKEN_MASK);
}

//-----------------------------------------------------------------------
//  SIM_ResetCard : Reset the SIM card 
//-----------------------------------------------------------------------
void SIM_ResetCard (void)
{
  SIM_CMD_REG = (SIM_CMD_CARDRST_MASK |  SIM_CMD_CLKEN_MASK);
}

//-----------------------------------------------------------------------
//  SIM_UnResetCard : Suppress the Reset of the SIM card 
//-----------------------------------------------------------------------
void SIM_UnResetCard (void)
{
  SIM_CMD_REG  = (SIM_CMD_CLKEN_MASK);
  SIM_CMD_REG &= (~SIM_CMD_CARDRST_MASK);
}

//-----------------------------------------------------------------------
//   SIM_Start  
//-----------------------------------------------------------------------
void SIM_Start (void)
{
  SIM_CMD_REG = (SIM_CMD_START_MASK | SIM_CMD_CLKEN_MASK);
}

//-----------------------------------------------------------------------
//   SIM_Stop  
//-----------------------------------------------------------------------
void SIM_Stop (void)
{
  SIM_CMD_REG = (SIM_CMD_STOP_MASK |  SIM_CMD_CLKEN_MASK);
}

//-----------------------------------------------------------------------
//   SIM_EnableClock 
//-----------------------------------------------------------------------
void SIM_EnableClock (void)
{
  SIM_CMD_REG = (SIM_CMD_CLKEN_MASK);
}

//-----------------------------------------------------------------------
//   SIM_GetStatus  
//-----------------------------------------------------------------------
UWORD8 SIM_GetStatus (void)
{
  return (SIM_STAT_REG & SIM_STAT_REG_MASK);
}


//-----------------------------------------------------------------------
//   SIM_ReadConf1  
//-----------------------------------------------------------------------
UWORD16 SIM_ReadConf1 (void)
{
  return (SIM_CONF1_REG);
}

//-----------------------------------------------------------------------
//   SIM_WriteConf1  
//-----------------------------------------------------------------------
void SIM_WriteConf1 (UWORD16 conf)
{
  SIM_CONF1_REG = (conf & SIM_CONF1_REG_MASK);
}


//-----------------------------------------------------------------------
//   SIM_SetFifoSize  
//-----------------------------------------------------------------------
void SIM_SetFifoSize (UWORD8 size)
{
UWORD16 reg = SIM_CONF1_REG;
  reg &= ~SIM_CONF1_TRIG_MASK;
  reg |= (size << SIM_CONF1_TRIG_POSBIT);
  SIM_CONF1_REG = reg;
}

//-----------------------------------------------
//  SIM_ReadConf2  
//-----------------------------------------------
UWORD16 SIM_ReadConf2 (void)
{
  return (SIM_CONF2_REG);
}

//----------------------------------------------
//   SIM_WriteConf2  
//----------------------------------------------
void SIM_WriteConf2 (UWORD16 conf)
{
  SIM_CONF2_REG = (conf & SIM_CONF2_REG_MASK);
}

//-----------------------------------------------------------------------
//   SIM_GetIt  
//-----------------------------------------------------------------------
UWORD8 SIM_GetIt (void)
{
  return (SIM_IT_REG & SIM_IT_REG_MASK);
}

//-----------------------------------------------------------------------
//   SIM_GetItCD  
//-----------------------------------------------------------------------
UWORD8 SIM_GetItCD (void)
{
  return (SIM_IT_CD_REG & SIM_IT_CD_REG_MASK);
}


//-----------------------------------------------------------------------
//   SIM_Read 
//-----------------------------------------------------------------------
UWORD16 SIM_Read (void)
{
  return (SIM_DRX_REG & SIM_DRX_REG_MASK);
}

//-----------------------------------------------------------------------
//   SIM_ReadChar  
//-----------------------------------------------------------------------
UWORD16 SIM_ReadChar (void)
{
  return (SIM_DRX_REG & SIM_DRX_DATA_MASK);
}

//-----------------------------------------------------------------------
//   SIM_IsParityOk 
//-----------------------------------------------------------------------
boolean_t SIM_IsParityOk (void)
{
   return (SIM_DRX_REG & SIM_DRX_PAR_MASK);
}

//-----------------------------------------------------------------------
//   SIM_Write  
//-----------------------------------------------------------------------
void SIM_Write (UWORD16 data)
{
  SIM_DTX_REG = (data & SIM_DTX_REG_MASK);
}

//-----------------------------------------------------------------------
//   SIM_WrCnf1Write  
//-----------------------------------------------------------------------
void SIM_WrCnf1Write (UWORD16 data, UWORD16 conf)
{
  SIM_DTX_REG   = (data & SIM_DTX_REG_MASK);
  SIM_CONF1_REG = (conf & SIM_CONF1_REG_MASK);
}

//-----------------------------------------------------------------------
//   SIM_ReadMaskIt
//-----------------------------------------------------------------------
UWORD8 SIM_ReadMaskIt (void)
{
  return (SIM_MASKIT_REG & SIM_MASKIT_REG_MASK);
}

//-----------------------------------------------------------------------
//   SIM_WriteMaskIt 
//-----------------------------------------------------------------------
void SIM_WriteMaskIt (UWORD8 mask)
{
  SIM_MASKIT_REG = (mask & SIM_MASKIT_REG_MASK);
}