uartirda.c

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

  //Restore registers old value 
  UIRD_RestoreEfr(efrold);
  UARTIRDA_LCR_REG=lcrold;
}






//--------------------------------------------------------------
//	UIRD_InitIer 
//--------------------------------------------------------------
UWORD8 UIRD_InitIer(const UARTIRDA_RhrItToggle_t      RhrIt, 
                        const UARTIRDA_ThrItToggle_t      ThrIt, 
                        const UARTIRDA_LineStsItToggle_t  ReceiverLineStatusIt,
                        const UARTIRDA_ModemStsItToggle_t ModemStatusIt, 
                        const UARTIRDA_SleepModeToggle_t  SleepMode, 
                        const UARTIRDA_XoffItToggle_t     XoffIt, 
                        const UARTIRDA_RtsItToggle_t      RtsIt, 
                        const UARTIRDA_CtsItToggle_t      CtsIt)
{
UWORD8 ier_value, efrold, lcrold;
 //Set registers to access MCR 
 efrold = UIRD_SetEfr4();
 lcrold = UIRD_ClearLcr7();

 
  UARTIRDA_IER_REG = ( RhrIt | 
                       ThrIt << 1 | 
                       ReceiverLineStatusIt << 2 | 
                       ModemStatusIt        << 3 |
		       SleepMode            << 4 | 
                       XoffIt               << 5 | 
                       RtsIt                << 6 | 
                       CtsIt                << 7);

  ier_value=UARTIRDA_IER_REG;

  //Restore registers old value 
  UIRD_RestoreEfr(efrold);
  UARTIRDA_LCR_REG=lcrold;

  return ier_value;
}

//--------------------------------------------------------------------------------
//	UARTIRDA_IER_MaskAllIt
//--------------------------------------------------------------------------------
UWORD8 UIRD_IerMaskAllIt(void)
{
UWORD8 ier_value, efrold, lcrold;
 //Set registers to access MCR 
 efrold = UIRD_SetEfr4();
 lcrold = UIRD_ClearLcr7();
 
  UARTIRDA_IER_REG = 0x00;
  ier_value=UARTIRDA_IER_REG;
   
  //Restore registers old value 
  UIRD_RestoreEfr(efrold);
  UARTIRDA_LCR_REG=lcrold;

  return ier_value;
}


//------------------------------------------------------------------------
//                      UIRD_InitEfr
//------------------------------------------------------------------------
UWORD8 UIRD_InitEfr(const UARTIRDA_RxSwflowCtr_t       RxSwFlowCtrol, 
                        const UARTIRDA_TxSwflowCtr_t       TxSwFlowCtrol, 
                        const UARTIRDA_EnhancedEnable_t    EnhEnable, 
                        const UARTIRDA_SpecialCharDetect_t SpecialCharDetect, 
                        const UARTIRDA_AutoRtsEnable_t     AutoRtsEnable, 
                        const UARTIRDA_AutoCtsEnable_t     AutoCtsEnable)
{
UWORD8 efr_value, lcr_old;
  //Set LCR=0xBF to grant access to EFR
  lcr_old=UIRD_SetBfToLcr();
  //Set and read back EFR
  UARTIRDA_EFR_REG = ( RxSwFlowCtrol          | 
                       TxSwFlowCtrol     << 2 |
                       EnhEnable         << 4 | 
                       SpecialCharDetect << 5 | 
                       AutoRtsEnable     << 6 | 
                       AutoCtsEnable     << 7);
  efr_value = UARTIRDA_EFR_REG;
  //Restore LCR
  UARTIRDA_LCR_REG=lcr_old;
  //Return previous EFR value
  return efr_value;
}



//--------------------------------------------------------------
// UIRD_InitDivLatch: Setup Divisor Latches
//--------------------------------------------------------------
void UIRD_InitDivLatch(const UWORD8 dll, const UWORD8 dlh)
{
UWORD8 lcr_old;
  //Set LCR=0xBF to grant access to Div Latch
  lcr_old=UIRD_SetBfToLcr();

  UARTIRDA_DLL_REG = dll;
  UARTIRDA_DLH_REG = dlh; 
  
  //Restore LCR
  UARTIRDA_LCR_REG=lcr_old;
}

//------------------------------------------------------
// UIRD_ReadUIR
//------------------------------------------------------
//FOR SAMSON ONLY UWORD8 UIRD_ReadUIR(void)
//FOR SAMSON ONLY {
//FOR SAMSON ONLY   return UARTIRDA_UIR_REG; 
//FOR SAMSON ONLY }

//-----------------------------------------
//         UIRD_ReadIer
//-----------------------------------------
UWORD8 UIRD_ReadIer(void)
{
UWORD8 ier_value;
UWORD8 efrold, lcrold;
  //Set registers access
  efrold = UIRD_SetEfr4();
  lcrold = UIRD_ClearLcr7();

  ier_value = UARTIRDA_IER_REG;

 //Restore registers access
 UIRD_RestoreEfr(efrold);
 UARTIRDA_LCR_REG=lcrold;

 return ier_value;
}


//------------------------------------------------
//         UIRD_ReadEfr
//------------------------------------------------
UWORD8 UIRD_ReadEfr(void)
{
UWORD8 efr_value, old_lcr;
  //Store LCR and set it to 0xBF to access EFR
  old_lcr =  UIRD_SetBfToLcr(); 
 
  efr_value = UARTIRDA_EFR_REG;

  //Restore LCR
  UARTIRDA_LCR_REG = old_lcr;

  return efr_value;
}

//-----------------------------------------------------------------
//                   UIRD_ReadLcr
//-----------------------------------------------------------------
UWORD8 UIRD_ReadLcr(void)
{ 
 return UARTIRDA_LCR_REG;
}

//--------------------------------------------------
//    UIRD_ReadMcr
//--------------------------------------------------
UWORD8 UIRD_ReadMcr(void)
{
UWORD8 mcr_value;
UWORD8  efrold, lcrold;
 //Set registers access
 efrold = UIRD_SetEfr4();
 lcrold  = UIRD_ClearLcr7();

 //Read MCR 
 mcr_value = UARTIRDA_MCR_REG;

 //Restore registers access
 UIRD_RestoreEfr(efrold);
 UARTIRDA_LCR_REG=lcrold;

 return mcr_value;
}

//--------------------------------
//       UIRD_ReadTcr
//--------------------------------
UWORD8 UIRD_ReadTcr(void)
{
UWORD8 tcr_value, efrold,  mcrold;
 efrold = UIRD_SetEfr4();
 mcrold = UIRD_SetMcr6();

 tcr_value = UARTIRDA_TCR_REG; 
 
 //Restore old value	
 UIRD_RestoreEfr(efrold);
 UIRD_RestoreMcr(mcrold);
  
 return tcr_value;		  
}

//-------------------------------------
//         UIRD_ReadTlr
//-------------------------------------
UWORD8 UIRD_ReadTlr(void)
{ 
UWORD8 tlr_value, efrold,  mcrold;
 efrold = UIRD_SetEfr4();
 mcrold = UIRD_SetMcr6();
 
 //Read TLR
 tlr_value = UARTIRDA_TLR_REG;
  
 //Restore old value	
 UIRD_RestoreEfr(efrold);
 UIRD_RestoreMcr(mcrold);
  
 return tlr_value;
}


//----------------------------------
//     UIRD_ReadSsr
//----------------------------------
UWORD8 UIRD_ReadSsr( void)
{
  return (UARTIRDA_SSR_REG & 0x03) ;
}


//-----------------------------------
//         UIRD_ReadIir
//-----------------------------------
UWORD8 UIRD_ReadIir(void)
{
UWORD8 lcrold, iir_value;
 //Grant access to IIR thanks to LCR
 lcrold = UIRD_ClearLcr7();
 //Get IIR value
 iir_value = UARTIRDA_IIR_REG;
 //Restore register LCR
 UARTIRDA_LCR_REG = lcrold;

 return iir_value;
}

//--------------------------------------------
//          UIRD_ReadMdr1
//--------------------------------------------
UWORD8 UIRD_ReadMdr1(void)
{
  return UARTIRDA_MDR1_REG;
}

//--------------------------------------------
//          UIRD_ReadMdr2
//--------------------------------------------
UWORD8 UIRD_ReadMdr2(void)
{
  return UARTIRDA_MDR2_REG;
}
 


//--------------------------------
//   UIRD_ReadScr
//--------------------------------
UWORD8 UIRD_ReadScr(void)
{
  return UARTIRDA_SCR_REG;		  
}
				


//---------------------------------------
//  UIRD_ReadDll                    -
//---------------------------------------
UWORD8 UIRD_ReadDll(void)
{
UWORD8 lcr_old, dll;
  //Set LCR=0xBF to grant access to Div Latch
  lcr_old=UIRD_SetBfToLcr();
  //Get DLL value
  dll = UARTIRDA_DLL_REG;
  //Restore LCR
  UARTIRDA_LCR_REG=lcr_old;
  //Return read DLL value
  return dll;
}


//---------------------------------------
//  UIRD_ReadDlh                    -
//---------------------------------------
UWORD8 UIRD_ReadDlh(void)
{
UWORD8 lcr_old, dlh;
  //Set LCR=0xBF to grant access to Div Latch
  lcr_old=UIRD_SetBfToLcr();
  //Get DLH value  
  dlh =  UARTIRDA_DLH_REG;
  //Restore LCR
  UARTIRDA_LCR_REG = lcr_old;
  //Return read DLH value
  return dlh;
}
 
 

//------------------------------------------
//             UIRD_Readlsr
//------------------------------------------
UWORD8 UIRD_Readlsr(void)
{
UWORD8 lcrold, lsr_value;
  //Clear LCR[7] to grant access to LSR
  lcrold = UIRD_ClearLcr7();
  //Get LSR value
  lsr_value = UARTIRDA_LSR_REG;
  //Restore LCR
  UARTIRDA_LCR_REG = lcrold;
  //Return read LSR value
  return lsr_value;
}
 
 
 
 
//------------------------------------------------
//            UIRD_ReadMsr
//------------------------------------------------ 
UWORD8 UIRD_ReadMsr(void)
{
UWORD8 lcrold, stored_efr, msr;
 //Clear LCR[7] & EFR[4] to Grant access to LSR
 lcrold     = UIRD_ClearLcr7();
 stored_efr = UIRD_ClearEfr4();

 //Read msr
 msr = UARTIRDA_MSR_REG;

 //Restore LCR & EFR
 UARTIRDA_LCR_REG = lcrold;
 UIRD_RestoreEfr(stored_efr);

 //Return read msr value
 return msr;
} 



//------------------------------------------------
//      UIRD_Read
//------------------------------------------------
UWORD8 UIRD_Read(void)
{   
UWORD8 lcrold, rhr_value;
  //Clear LCR[7] to grant access to RHR
  lcrold = UIRD_ClearLcr7();
  //Read RHR register
  rhr_value = UARTIRDA_RHR_REG;
  //Restore LCR
  UARTIRDA_LCR_REG = lcrold;
  return rhr_value ;
}



//---------------------------------------------
//         UIRD_Send
//---------------------------------------------
void UIRD_Send(const UWORD8 Value)
{
UWORD8 lcrold;
  //Clear LCR[7] to grant access to THR
  lcrold = UIRD_ClearLcr7();
  //Write value into THR register
  UARTIRDA_THR_REG = Value;
  //Restore LCR
  UARTIRDA_LCR_REG = lcrold;
}


 
//------------------------------------------
//  UIRD_InitMdr1
//------------------------------------------
UWORD8 UIRD_InitMdr1(const UARTIRDA_SelectMode_t       SelectMode, 
                         const UARTIRDA_SleepMode_t        IrSleep, 
                         const UARTIRDA_StartControlTrx_t  StartCtrolTrx, 
                         const UARTIRDA_FrameEndMode_t     FrameEndMode )
{
UWORD8 mdr1_irda; 
 
 UARTIRDA_MDR1_REG = ( SelectMode         | 
                       IrSleep       << 3 | 
                       StartCtrolTrx << 5 | 
                       FrameEndMode  << 7 );
 
 mdr1_irda=   UARTIRDA_MDR1_REG;
 
 return mdr1_irda;
}


//------------------------------------
// UIRD_Mdr1ResetMode
//------------------------------------
void UIRD_Mdr1ResetMode(void)
{
 //We just reset the mode and keep unchanged
 //the parameters IR_SLEEP, SCT, FRAME_END_MODE
  UARTIRDA_MDR1_REG |= 0x07;
}
 


//---------------------------------------------------------------
//   UIRD_InitMdr2
//---------------------------------------------------------------
UWORD8 UIRD_InitMdr2(const UARTIRDA_Sts_Fifo_trig_t stfifotrig,
                         const UWORD8 div16m)
{
UWORD8 mdr2_irda; 
 
 UARTIRDA_MDR2_REG = (  stfifotrig << 1 |  div16m << 3 );
 
 mdr2_irda = UARTIRDA_MDR2_REG;
 
 return mdr2_irda;
}
             


//--------------------------------------------------
//              UIRD_ReadSflsr
//--------------------------------------------------
UWORD8 UIRD_ReadSflsr(void)
{
  return  UARTIRDA_SFLSR_REG;
}
 






//-------------------------------------------------------------------
//                UIRD_Inittcr
//-------------------------------------------------------------------
UWORD8 UIRD_Inittcr(const UARTIRDA_RxFifoTrigHalt_t   trighalt, 
                        const UARTIRDA_RxFifoTrigStart_t  trigstart)
{
UWORD8 old_efr, old_mcr, old_lcr, tcr_value;
  //Set register to grant access to TCR
  old_efr = UIRD_SetEfr4();
  old_mcr = UIRD_SetMcr6();
  old_lcr = UIRD_ClearLcr7();

  //Write into TCR and Read it back
  UARTIRDA_TCR_REG = trighalt | trigstart  << 4 ;	  
  tcr_value = UARTIRDA_TCR_REG ;

  //Restore access registers
  UIRD_RestoreEfr(old_efr);
  UIRD_RestoreMcr(old_mcr);
  UARTIRDA_LCR_REG = old_lcr;
 
  return tcr_value;		  
}






//---------------------------------------------------------------------