uartcommon.c

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

  mcr6old = UMOD_SetMcr6(UartType);

  UARTMOD_TCR_REG(UartType) = ( trighalt | trigstart  << 4 );	  
  tcr_modem       = UARTMOD_TCR_REG(UartType) ;
 
  //Restore old value
  UARTMOD_MCR_REG(UartType) = mcr6old;	
  UARTMOD_EFR_REG(UartType) = efr4old;
  UARTMOD_LCR_REG(UartType) = lcrold;
  
  return tcr_modem;		  
}





//---------------------------------------
//          UMOD_InitTlr
//---------------------------------------
UWORD8 UMOD_InitTlr(const UARTMOD_TxFifoTrigDma_t txtrigdma, 
                       const UARTMOD_RxFifoTrigDma_t rxtrigdma,
                       UARTMOD_UartType_t            UartType)
{ 
  UWORD8 tlr_modem;
  UWORD8 efr4,efr4old,mcr6old,lcrold;
  
  //Store current value LCR and set it to 0xBF to access EFR
  lcrold = UMOD_SetBfToLcr(UartType);
 
  //Store old value EFR register
  efr4old = UARTMOD_EFR_REG(UartType); 
  
  //Set bit EFR[4] =1
  efr4 = efr4old | 0x10;	      
  UARTMOD_EFR_REG(UartType) = efr4;
 
  mcr6old = UMOD_SetMcr6(UartType);
  
  //Set TLR
  UARTMOD_TLR_REG(UartType) = ( txtrigdma |  rxtrigdma << 4 );
  
  //Read TLR
  tlr_modem = UARTMOD_TLR_REG(UartType) ; 
  
  //Restore old value
  UARTMOD_MCR_REG(UartType) = mcr6old;
  UARTMOD_EFR_REG(UartType) = efr4old;
  UARTMOD_LCR_REG(UartType) = lcrold;
  
  return tlr_modem;
}




//----------------------------------
//     UARTMOD_InitSSR
//----------------------------------
UWORD8 UMOD_ReadSsr(UARTMOD_UartType_t UartType)
{
  UWORD8 ssr_modem;
  
  ssr_modem = UARTMOD_SSR_REG(UartType) ;
  
  return ssr_modem;

}


//-----------------------------------
//         UMOD_ReadIir *****
//-----------------------------------
UWORD8 UMOD_ReadIir(UARTMOD_UartType_t UartType)
{
  UWORD8 iirmodem;
//lcrold = UMOD_ClearLcr7(UartType);

  //Grant access to IIR thanks to LCR
//FH UMOD_CheckLcr7Is0(UartType);
  
  //Get IIR value
  iirmodem = UARTMOD_IIR_REG(UartType);
  
//UARTMOD_LCR_REG(UartType) = lcrold;
  return iirmodem;
}




//----------------------------------------------------
//           UMOD_ReadUasr
//----------------------------------------------------
UWORD8 UMOD_ReadUasr(UARTMOD_UartType_t UartType)
{ 
volatile UWORD8 lcrold, uasr;
 //Store current value LCR and set it to 0xBF to access UASR
 lcrold = UMOD_SetBfToLcr(UartType);
 //Get UASR register value
 uasr = UARTMOD_UASR_ST_REG(UartType);
 //Restore LCR
 UARTMOD_LCR_REG(UartType) = lcrold;

 return uasr;
}

//----------------------------------------------------
//  UMOD_IsTransmitAndHoldRegNotEmpty          -
//----------------------------------------------------
UWORD8 UMOD_IsTransmitAndHoldRegNotEmpty(UARTMOD_UartType_t UartType)
{
UWORD8 not_empty;
UWORD8 current_lcr = UARTMOD_LCR_REG(UartType);
  //set LCR[7]=0 to access LSR Register
  UARTMOD_LCR_REG(UartType) &= 0x7F; 
      
  not_empty = ! ( (UARTMOD_LSR_REG(UartType) & UARTMOD_LSR_EMPTY1) >> 6 );

  //Restore LCR
  UARTMOD_LCR_REG(UartType) = current_lcr;       
  return not_empty; 
}


//---------------------------------------
//  UMOD_RxFifoIsNotEmpty            -
//---------------------------------------
boolean_t UMOD_RxFifoIsNotEmpty(UARTMOD_UartType_t UartType)
{
  return (boolean_t) (UARTMOD_LSR_REG(UartType) & 0x01 );
}

//  UMOD_TxFifoIsFull            -
//---------------------------------------
boolean_t UMOD_TxFifoIsFull(UARTMOD_UartType_t UartType)
{
  return (boolean_t) (UARTMOD_SSR_REG(UartType) & UARTMOD_SSR_TXFIFOFULL_NUMB );
}



// added from  irda lib

//------------------------------------------
//  UIRD_InitTxfll  (Length)
//-------------------------------------------
void UMOD_InitTxfll(const UWORD8 txfll,UARTMOD_UartType_t UartType)
{
   UARTMOD_TXFLL_REG(UartType) = txfll;		  
}


//------------------------------------------
//  UIRD_InitTxflh  (Length)
//-------------------------------------------
void UMOD_InitTxflh(const UWORD8 txflh,UARTMOD_UartType_t UartType)
{
 UARTMOD_TXFLH_REG(UartType) = txflh;		  
}


//------------------------------------------
//  UIRD_InitRxfll  (Length)
//-------------------------------------------
void UMOD_InitRxfll(const UWORD8 rxfll,UARTMOD_UartType_t UartType)
{
  UARTMOD_RXFLL_REG(UartType) = rxfll;		  
}

//------------------------------------------
//  UIRD_InitRxflh  (Length)
//-------------------------------------------
void UMOD_InitRxflh(const UWORD8 rxflh,UARTMOD_UartType_t UartType)
{
  UARTMOD_RXFLH_REG(UartType) = rxflh;		  
}


//--------------------------------------
//          UIRD_ReadSfregl
//---------------------------------------
UWORD8 UMOD_ReadSFREGL(UARTMOD_UartType_t UartType)
{
  return  UARTMOD_SFREGL_REG(UartType);
}
 
 
//--------------------------------------
//          UIRD_ReadSfregh
//--------------------------------------- 
UWORD8 UMOD_ReadSFREGH(UARTMOD_UartType_t UartType)
{
  return  UARTMOD_SFREGH_REG(UartType);
}


 
//-------------------------------
//    UIRD_InitResume 
//-------------------------------
UWORD8 UMOD_InitResume(UARTMOD_UartType_t UartType)
{
  return UARTMOD_RESUME_REG(UartType);
}


//--------------------------------------------------------------
//NAME        : UIRD_InitBlr
//--------------------------------------------------------------
UWORD8 UMOD_InitBlr( const UARTMOD_XbofType_t        typebof, 
                         const UARTMOD_StatusFifoReset_t stsfifo ,
								 UARTMOD_UartType_t UartType)
{
UWORD8 old_lcr, blr_value;
 //Clear LCR[7] to grant access to BLR
 old_lcr =   UMOD_ClearLcr7(UartType);
 //Setup BLR register
 UARTMOD_BLR_REG(UartType) = typebof << 6 | stsfifo <<7 ;
 blr_value        = UARTMOD_BLR_REG(UartType) ;
 //Restore LCR
 UARTMOD_LCR_REG(UartType) = old_lcr;

 return blr_value;		  
}
		  

//----------------------------------------------
//             UIRD_InitEblr
// WARNING: This register is programmed for
//          future use but is not specified
//          to the customer
//          Its use to provide a max of 6x XBOF 
//----------------------------------------------
UWORD8 UMOD_InitEblr(const UWORD8 nbxbof ,
								 UARTMOD_UartType_t UartType)
{
UWORD8 eblr_value, old_lcr;

 old_lcr =   UMOD_ClearLcr7(UartType);
 //Set EBLR register
 UARTMOD_EBLR_REG(UartType) = nbxbof;	  
 eblr_value     = UARTMOD_EBLR_REG(UartType);
  //Restore LCR
 UARTMOD_LCR_REG(UartType) = old_lcr;
 
 return eblr_value;		  
}





//-------------------------------------------------
//             UIRD_InitAdr1
//-------------------------------------------------
UWORD8 UMOD_InitAdr1(const UWORD8 adr1,
								 UARTMOD_UartType_t UartType)
{
UWORD8 adr1_value, lcrold;

  //Store current value LCR and set it to 0xBF to access EFR
  lcrold = UMOD_SetBfToLcr(UartType);

  //Initialize adr1/xon1 and read it back
  UARTMOD_ADR1_REG(UartType) = adr1;  
  adr1_value =  UARTMOD_ADR1_REG(UartType) ;
 
  //Restore LCR value
  UARTMOD_LCR_REG(UartType) = lcrold;
 
  return adr1_value;		  
}


//--------------------------------------------
//  UIRD_InitAdr2
//--------------------------------------------
UWORD8 UMOD_InitAdr2(const UWORD8 adr2,
								 UARTMOD_UartType_t UartType)

{ 
UWORD8 adr2_value, lcr_old;

  //Set LCR to grant access to ADR2
  lcr_old = UMOD_SetBfToLcr(UartType);

  //Initialize adr2/xon2 and read it back
  UARTMOD_ADR2_REG(UartType) = adr2;
  adr2_value        = UARTMOD_ADR2_REG(UartType);
                             
  //Restore LCR value
  UARTMOD_LCR_REG(UartType) = lcr_old;
 
  return adr2_value;		  
}



//---------------------------------------------------------------------
//   Initialise  Auxiliary Control Register
//-----------------------------------------------------------------
UWORD8 UMOD_InitAcreg(const UARTMOD_EotEn_t      eot, 
                          const UARTMOD_AbortEn_t    abort, 
                          const UARTMOD_SctxEn_t     sctx ,
                          const UMOD_SendSip_t	sip,
                          const UARTMOD_LongStop_t   longstop,
                          const UARTMOD_rxir_input_t duplexmode,
                          const UARTMOD_SdMod_t      sdmode, 
                          const UARTMOD_PulseType_t  pulse,
								  UARTMOD_UartType_t UartType)
{
UWORD8  old_lcr;
UWORD8  acreg_value;
 
  //Set LCR to granmt access to ACREG
  old_lcr =  UMOD_ClearLcr7(UartType);  

  UARTMOD_ACREG_REG(UartType) = (   eot 
                         | abort      << 1 
                         | sctx       << 2 
                         | sip        << 3
                         | longstop   << 4 
                         | duplexmode << 5 
                         | sdmode     << 6 
                         | pulse      << 7);	  
  acreg_value = UARTMOD_ACREG_REG(UartType);

 //Restore old value of LCR
 UARTMOD_LCR_REG(UartType) = old_lcr;

 return acreg_value;		  		  
}