vspi.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             : vspi.c

   Description          : Voice Serial Port Interface

   Project              : Perseus

   Author               : Vincent Bour

===============================================================================

*/

#include "vspi.h"
#include "result.h"


/*
-------------------------------------------------------------------------
	VSPI_TestRegisters						-
-------------------------------------------------------------------------
*/
UWORD16 VSPI_TestRegisters(void)
{
UWORD16 val;
UWORD16 result = RES_OK;
  
  //RESET VALUE ON SET1 REGISTER
  val = *(REGISTER_UWORD16*)VSPI_SET1_ADDR & VSPI_SET1_REG_MASK;
  if ( val != VSPI_SET1_REG_RESET_VALUE )
  {
      RES_Set(VSPI_SET1_REG_RESET_ERROR);
      RES_Set(val);
      result = RES_BAD;
  }
  else  RES_Set(RES_OK);

  //RESET VALUE ON SET2 REGISTER  
  val = *(REGISTER_UWORD16*)VSPI_SET2_ADDR & VSPI_SET2_REG_MASK;
  if ( val != VSPI_SET2_REG_RESET_VALUE )
  {
      RES_Set(VSPI_SET2_REG_RESET_ERROR);
      RES_Set(val);
      result = RES_BAD;
  }
  else  RES_Set(RES_OK);  

  //RESET VALUE ON CTRL REGISTER  
  val = *(REGISTER_UWORD16*)VSPI_CTRL_ADDR & VSPI_CTRL_REG_MASK;
  if ( val != VSPI_CTRL_REG_RESET_VALUE )
  {
      RES_Set(VSPI_CTRL_REG_RESET_ERROR);
      RES_Set(val);
      result = RES_BAD;
  }
  else  RES_Set(RES_OK);  

  //RESET VALUE ON STATUS REGISTER
  //To read Status register the internal clock must be running
  VSPI_StartClock();
  val = *(REGISTER_UWORD16*)VSPI_STATUS_ADDR & VSPI_STATUS_REG_MASK;
  if ( val != VSPI_STATUS_REG_RESET_VALUE )
  {
      RES_Set(VSPI_STATUS_REG_RESET_ERROR);
      RES_Set(val);
      result = RES_BAD;
  }
  else  RES_Set(RES_OK);    

  //RESET VALUE ON TX_LSB REGISTER     
  val = *(REGISTER_UWORD16*)VSPI_TX_LSB_ADDR;
  if ( val != VSPI_TX_LSB_REG_RESET_VALUE )
  {
      RES_Set(VSPI_TX_LSB_REG_RESET_ERROR);
      RES_Set(val);
      result = RES_BAD;
  }
  else  RES_Set(RES_OK);     

  //RESET VALUE ON TX_MSB REGISTER     
  val = *(REGISTER_UWORD16*)VSPI_TX_MSB_ADDR;
  if ( val != VSPI_TX_MSB_REG_RESET_VALUE )
  {
      RES_Set(VSPI_TX_MSB_REG_RESET_ERROR);
      RES_Set(val);
      result = RES_BAD;
  }
  else  RES_Set(RES_OK);     

  //RESET VALUE ON RX_LSB REGISTER     
  val = *(REGISTER_UWORD16*)VSPI_RX_LSB_ADDR;
  if ( val != VSPI_RX_LSB_REG_RESET_VALUE )
  {
      RES_Set(VSPI_RX_LSB_REG_RESET_ERROR);
      RES_Set(val);
      result = RES_BAD;
  }
  else  RES_Set(RES_OK);     

  //RESET VALUE ON RX_MSB REGISTER     
  val = *(REGISTER_UWORD16*)VSPI_RX_MSB_ADDR;
  if ( val != VSPI_RX_MSB_REG_RESET_VALUE )
  {
      RES_Set(VSPI_RX_MSB_REG_RESET_ERROR);
      RES_Set(val);
      result = RES_BAD;
  }
  else  RES_Set(RES_OK);     
  
  //ACCESS TO SET1
  *(REGISTER_UWORD16*)VSPI_SET1_ADDR = 0x07;
  val = *(REGISTER_UWORD16*)VSPI_SET1_ADDR  & VSPI_SET1_REG_MASK;
  if ( val != 0x07 ) 
  { 
      RES_Set(VSPI_SET1_REG_ACCESS_ERROR); 
      RES_Set(val); 
      result = RES_BAD; 
  }
  else  RES_Set(RES_OK);	 
  
  //ACCESS TO SET2  
  *(REGISTER_UWORD16*)VSPI_SET2_ADDR = 0x7FFF;
  val = *(REGISTER_UWORD16*)VSPI_SET2_ADDR & VSPI_SET2_REG_MASK;
  if ( val != 0x7FFF ) 
  { 
      RES_Set(VSPI_SET2_REG_ACCESS_ERROR);
      RES_Set(val);
      result = RES_BAD; 
  }	
  else  RES_Set(RES_OK);   

  //ACCESS TO CTRL
  *(REGISTER_UWORD16*)VSPI_CTRL_ADDR = 0x07FF;
  val = *(REGISTER_UWORD16*)VSPI_CTRL_ADDR & VSPI_CTRL_REG_MASK;
  if ( val != 0x07FF ) 
  { 
      RES_Set(VSPI_CTRL_REG_ACCESS_ERROR);
      RES_Set(val);  
      result = RES_BAD; 
  }
  else  RES_Set(RES_OK);    
  
  //ACCESS TO TX LSB
  *(REGISTER_UWORD16*)VSPI_TX_LSB_ADDR  = 0xFFFF;
  val = *(REGISTER_UWORD16*)VSPI_TX_LSB_ADDR;
  if ( val != 0xFFFF ) 
  { 
      RES_Set(VSPI_TX_LSB_REG_ACCESS_ERROR);
      RES_Set(val); 
      result = RES_BAD; 
  }
  else  RES_Set(RES_OK);   	 

  //ACCESS TO TX MSB  
  *(REGISTER_UWORD16*)VSPI_TX_MSB_ADDR = 0xFFFF;
  val = *(REGISTER_UWORD16*)VSPI_TX_MSB_ADDR;
  if ( val != 0xFFFF ) 
  { 
      RES_Set(VSPI_TX_MSB_REG_ACCESS_ERROR);
      RES_Set(val);  
      result = RES_BAD; 
  }
  else  RES_Set(RES_OK);   	 
	 
  return result;
}


/*
-------------------------------------------------------------------------
	VSPI_InitSet1							-
-------------------------------------------------------------------------
*/
void VSPI_InitSet1 (VSPI_EnableClock_t enClk, 
                   VSPI_Ptv_t         Pscale, 
                   VSPI_MaskIntWr_t   IntWr, 
                   VSPI_MaskIntRdWr_t IntRdWr)
{
  *(REGISTER_UWORD16*)VSPI_SET1_ADDR = (  enClk
                  | Pscale  << VSPI_SET1_PTV_POSBIT 
                  | IntWr   << VSPI_SET1_MSK0_POSBIT
                  | IntRdWr << VSPI_SET1_MSK1_POSBIT);
}			


/*
-------------------------------------------------------------------------
	VSPI_InitSet2							-
-------------------------------------------------------------------------
*/
void VSPI_InitSet2 (VSPI_EdgeClock_t AcedgDevi, 
                   VSPI_Ptspen_t    Ptspen,  
                   VSPI_Ltspen_t    Ltspen)
{
  *(REGISTER_UWORD16*)VSPI_SET2_ADDR = (   AcedgDevi 
                   | Ptspen << VSPI_SET2_P_POSBIT 
                   | Ltspen << VSPI_SET2_L_POSBIT );
}


/*
-------------------------------------------------------------------------
	VSPI_InitCtrl							-
-------------------------------------------------------------------------
*/
void VSPI_InitCtrl (VSPI_CtrlRd_t      Rdproc, 
                   VSPI_CtrlWr_t      Wrproc,  
                   VSPI_TrxLength_t   Nbsize,
                   VSPI_DeviceIndex_t DeviceNumber,
		   VSPI_dma_en_t      Dma_en)
{
  *(REGISTER_UWORD16*)VSPI_CTRL_ADDR = (  Rdproc 
                  | Wrproc       << VSPI_CTRL_WR_POSBIT 
                  | Nbsize       << VSPI_CTRL_NB_POSBIT 
                  | DeviceNumber << VSPI_CTRL_AD_POSBIT
		  | Dma_en	 << VSPI_DMA_EN_POSBIT);
}


/*
-------------------------------------------------------------------------
	VSPI_ReadStatus							-
-------------------------------------------------------------------------
*/
VSPI_Status_t VSPI_ReadStatus(void)
{
UWORD16 value = *(REGISTER_UWORD16*)VSPI_STATUS_ADDR & VSPI_STATUS_REG_MASK;
  if ( value == VSPI_STATUS_BUSY_VALUE)
    return VSPI_BUSY; //Neither READ_END nor WRITE_END reached
  else   
    return VSPI_FREE; //Either Received registers are loaded   (READ_END)
                      //or the serialization write is finished (WRITE_END)
}


/*
-------------------------------------------------------------------------
	VSPI_IsReadEnd							-
-------------------------------------------------------------------------
*/
boolean_t VSPI_IsReadEnd(void)
{
  if ( (*(REGISTER_UWORD16*)VSPI_STATUS_ADDR & VSPI_STATUS_RE_MASK) == VSPI_STATUS_RE_MASK )
       return True;
  else return False;
}


/*
-------------------------------------------------------------------------
	VSPI_IsWriteEnd							-
-------------------------------------------------------------------------
*/
boolean_t VSPI_IsWriteEnd(void)
{
  if ( (*(REGISTER_UWORD16*)VSPI_STATUS_ADDR & VSPI_STATUS_WE_MASK) == VSPI_STATUS_WE_MASK )
       return True;
  else return False;
}


/*
-------------------------------------------------------------------------
	VSPI_writeTxLsb							-
-------------------------------------------------------------------------
*/
void VSPI_writeTxLsb (UWORD16 Txlsb)
{
  *(REGISTER_UWORD16*)VSPI_TX_LSB_ADDR = Txlsb;
}


/*
-------------------------------------------------------------------------
	VSPI_writeTxMsb							-
-------------------------------------------------------------------------
*/
void VSPI_writeTxMsb (UWORD16 Txmsb)
{
  *(REGISTER_UWORD16*)VSPI_TX_MSB_ADDR = Txmsb;
} 


/*
-------------------------------------------------------------------------
	VSPI_readRxLsb							-
-------------------------------------------------------------------------
*/
UWORD16 VSPI_readRxLsb (void)
{
  return *(REGISTER_UWORD16*)VSPI_RX_LSB_ADDR;
}


/*
-------------------------------------------------------------------------
	VSPI_readRxMsb							-
-------------------------------------------------------------------------
*/
UWORD16 VSPI_readRxMsb (void)
{ 
  return *(REGISTER_UWORD16*)VSPI_RX_MSB_ADDR;
}


/*
-------------------------------------------------------------------------
	VSPI_StartClock							-
-------------------------------------------------------------------------
*/
void VSPI_StartClock(void)
{
  SetBit(*(REGISTER_UWORD16*)VSPI_SET1_ADDR, VSPI_SET1_EN_CLK_MASK);
}


/*
-------------------------------------------------------------------------
	VSPI_StopClock							-
-------------------------------------------------------------------------
*/
void VSPI_StopClock(void)
{
  ClearBit(*(REGISTER_UWORD16*)VSPI_SET1_ADDR, VSPI_SET1_EN_CLK_MASK);
}