clkmarm.c

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

//                              CLKOUT__MGS_CK_CTS      
//                              CLKOUT__MIFLB_CK_CTS    
//                              CLKOUT__MCU_CK_CTS      
//                              CLKOUT__INTH_CK_CTS     
//                              CLKOUT__RHEA_CK_CTS     
//                              CLKOUT__DMA_CK_CTS      
//                              CLKOUT__SPI_CK_CTS      
//                              CLKOUT__LCD_CK_CTS      
//                              CLKOUT__TIM_CK_CTS      
//                              CLKOUT__MGSPER_CK_CTS   
//                              CLKOUT__MCUPER_CK_CTS   
//                              CLKOUT__MGSXOR_CK_CTS   
//                              CLKOUT__MCUXOR_CK_CTS   
//                              CLKOUT__MGSWDT_CK_CTS   
//                              CLKOUT__MCUWDT_CK_CTS   
//
// RETURN VALUE: YES if correct
//               NO if not      -
//  LIMITATIONS : None                                      -
// ----------------------------------------------------------

BOOL CLKA_SetClkoutRefflect(CLKOUT_OPTIONS_t ClkoutOption)
{
  SetGroupBits(MCU_CKOUT1,MCU_CKOUT1_CKOUT_POS,MCU_CKOUT1_CKOUT_WIDTH,ClkoutOption);
  return True;
}

//----------------------------------------------------------
// NAME        : CLKA_ReadClkoutRefflect 
// DESCRIPTION : Read the signal reflected by clkout or 
//               if CLKOUT pin is in I/O mode
//
// PARAMETERS  : NONE
//
// RETURN VALUE: CLKOUT_OPTIONS_t 
//                              CLKOUT__IO              
//                              CLKOUT__CK_GEN          
//                              CLKOUT__CK_MCUDOM       
//                              CLKOUT__CK_VTCXO14      
//                              CLKOUT__MGS_CK_CTS      
//                              CLKOUT__MIFLB_CK_CTS    
//                              CLKOUT__MCU_CK_CTS      
//                              CLKOUT__INTH_CK_CTS     
//                              CLKOUT__RHEA_CK_CTS     
//                              CLKOUT__DMA_CK_CTS      
//                              CLKOUT__SPI_CK_CTS      
//                              CLKOUT__LCD_CK_CTS      
//                              CLKOUT__TIM_CK_CTS      
//                              CLKOUT__MGSPER_CK_CTS   
//                              CLKOUT__MCUPER_CK_CTS   
//                              CLKOUT__MGSXOR_CK_CTS   
//                              CLKOUT__MCUXOR_CK_CTS   
//                              CLKOUT__MGSWDT_CK_CTS   
//                              CLKOUT__MCUWDT_CK_CTS   
//
//  LIMITATIONS : None                                      -
// ----------------------------------------------------------

CLKOUT_OPTIONS_t CLKA_ReadClkoutRefflect(void)
{
  return((CLKOUT_OPTIONS_t)GetGroupBits(MCU_CKOUT1,MCU_CKOUT1_CKOUT_POS,MCU_CKOUT1_CKOUT_WIDTH));
}

//----------------------------------------------------------
// NAME        : CLKA_SetClkoutIoDirection 
// DESCRIPTION : Set the direction of CLKOUT when in IO mode
//               
//
// PARAMETERS  : BOOL      INPUT or OUTPUT
//
// RETURN VALUE: YES if correct
//               NO if not      -
//  LIMITATIONS : None                                      -
// ----------------------------------------------------------

BOOL CLKA_SetClkoutIoDirection(BOOL Direction)
{
  if (Direction==INPUT)
    SetBit(MCU_CKOUT1,MCU_CKOUT1_GPDIR_MASK);
  else
    ClearBit(MCU_CKOUT1,MCU_CKOUT1_GPDIR_MASK);

  return True;
}

//----------------------------------------------------------
// NAME        : CLKA_ReadClkoutIoDirection 
// DESCRIPTION : Read the direction of CLKOUT when in IO mode
//               
//
// PARAMETERS  : None  
//
// RETURN VALUE: BOOL      INPUT or OUTPUT
//              
//  LIMITATIONS : None                                      -
// ----------------------------------------------------------
BOOL CLKA_ReadClkoutIoDirection(void)
{
  if (TestBit(MCU_CKOUT1,MCU_CKOUT1_GPDIR_MASK))
    return((BOOL)INPUT);
  else
    return((BOOL)OUTPUT);
}

//----------------------------------------------------------
// NAME        : CLKA_OutputClkoutIO
// DESCRIPTION : Set the data of CLKOUT when in IO mode
//               
//
// PARAMETERS  : BOOL      LOW_LEVEL or HIGH_LEVEL
//
// RETURN VALUE: YES if correct
//               NO if not      -
//  LIMITATIONS : None                                      -
// ----------------------------------------------------------
BOOL CLKA_OutputClkoutIO(BOOL Level)
{
  if (Level==HIGH_LEVEL)
    SetBit(MCU_CKOUT2,MCU_CKOUT2_GPOUT_MASK);
  else
    ClearBit(MCU_CKOUT2,MCU_CKOUT2_GPOUT_MASK);

  return True;
}

//----------------------------------------------------------
// NAME        : CLKA_InputClkoutIO
// DESCRIPTION : Get the data of CLKOUT when in IO mode
//               
//
// PARAMETERS  : None 
//
// RETURN VALUE: BOOL      LOW_LEVEL or HIGH_LEVEL
//               
//  LIMITATIONS : None                                      -
// ----------------------------------------------------------
BOOL CLKA_InputClkoutIO(void)
{
  if (TestBit(MCU_CKOUT2,MCU_CKOUT2_GPIN_MASK))
    return((BOOL)HIGH_LEVEL);
 else
    return((BOOL)LOW_LEVEL);
}

//---------------------------------------------------------------------
// NAME        : CLKA_DpllSetClockAndLock
//               
// DESCRIPTION : Modify the value output from dpll
//               
// SYNOPSYS    : BOOL CLKA_DpllSetClockAndLock( UWORD8 multiplier , UWORD8 divider)
//                
//               
// PARAMETERS  : multiplier       a value which belong  : 1-31
//               
//               divider          a value which belong  : 1-4
//               
// RETURN VALUE: IS_OK if correct NOT_OK if not
//               
// LIMITATIONS : None
//               
//---------------------------------------------------------------------
BOOL CLKA_DpllSetClockAndLock( UWORD8 multiplier , UWORD8 divider)
{
UWORD32 i=0;
UWORD16 temp=0;

 if ((divider<1) OR (divider>4))
     return((BOOL)NOT_OK);

 if ((multiplier<1) OR (divider>31))
     return((BOOL)NOT_OK);

//Correct the value to set in the register
  divider--; 

  // the dpll synthetyser is required only when multiplier is more than one
  if ((multiplier != 0) AND (multiplier != 1))
    {
    //Get the register
    temp = MCU_DPLLCTL;
    
    //clear the bits of multiplier and divider
    temp &=~((0xFFFF>>(16-MCU_DPLLCTL_PLLMULT_WIDTH))<<MCU_DPLLCTL_PLLMULT_POS);
    temp &=~((0xFFFF>>(16-MCU_DPLLCTL_PLLDIV_WIDTH))<<MCU_DPLLCTL_PLLDIV_POS);

    //Set the divider and the multiplier
    temp |= (multiplier<<MCU_DPLLCTL_PLLMULT_POS);
    temp |= (divider<<MCU_DPLLCTL_PLLDIV_POS);

    //Enable the dpll
    temp |= MCU_DPLLCTL_PLLEN_MASK;

    //Enable the dpll synthetiser 
    MCU_DPLLCTL=temp;

    // The lock action takes in the worst case less than 61472 cycles (refer to dpll012)
    do
      {
      i++;
      }
    while( (!TestBit(MCU_DPLLCTL,MCU_DPLLCTL_LOCK_MASK)) AND (i<31000));

    if (i>=31000)
      return((BOOL)NOT_OK);
    else
      return((BOOL)IS_OK);
    }
  else
    { // multiplier is 1, so we are in bypass mode
    //Get the register
    temp = MCU_DPLLCTL;

    //Disable the dpll
    temp &=~ MCU_DPLLCTL_PLLEN_MASK;

    //Set the bypass divider
    temp |= (divider<<MCU_DPLLCTL_BYPASSDIV_POS);
    
    //Enable the changes
    MCU_DPLLCTL=temp;
    return((BOOL)IS_OK);
    }


}

//---------------------------------------------------------------------
// NAME        : CLKA_DpllSetState
//               
// DESCRIPTION : Set the state of the dpll activ or not activ
//               
// SYNOPSYS    : void CLKA_DpllSetState(BOOL state)
//               
// PARAMETERS  : state       ENABLE or DISABLE
//               
// RETURN VALUE: None
//               
// LIMITATIONS : None
//               
//---------------------------------------------------------------------
void CLKA_DpllSetState(BOOL state)
{
  if (state==ENABLE)
    {
    //Enable the dpll synthetiser 
    SetBit(MCU_DPLLCTL,MCU_DPLLCTL_PLLEN_MASK);
    }
  else
    {
    //Disable the dpll synthetiser 
    ClearBit(MCU_DPLLCTL,MCU_DPLLCTL_PLLEN_MASK);
    }
}

//---------------------------------------------------------------------
// NAME        : CLKA_DpllSetInitialize
//               
// DESCRIPTION : Set the initialize mode
//               
// SYNOPSYS    : UWORD16 CLKA_DpllSetInitialize(BOOL Iar, BOOL Iob)
//               
// PARAMETERS  : WhichIniBit        IAI_BIT or IOB_BIT
//               state              ENABLE or DISABLE None
//
// RETURN VALUE: None
//               
// LIMITATIONS : None
//               
//---------------------------------------------------------------------
void CLKA_DpllSetInitialize(BOOL WhichIniBit, BOOL state)
{
  if (WhichIniBit==IAI_BIT)
    {
    if (state==ENABLE)
        SetBit(MCU_DPLLCTL,MCU_DPLLCTL_IAI_MASK);
    else
        ClearBit(MCU_DPLLCTL,MCU_DPLLCTL_IAI_MASK);
    }
  else
    {
    if (state==ENABLE)
        SetBit(MCU_DPLLCTL,MCU_DPLLCTL_IOB_MASK);
    else
        ClearBit(MCU_DPLLCTL,MCU_DPLLCTL_IOB_MASK);
    }
}

//---------------------------------------------------------------------
// NAME        : CLKA_DpllGetInitialize
//               
// DESCRIPTION : Set the initialize mode
//               
// SYNOPSYS    : BOOL CLKA_DpllGetInitialize(BOOL WhichIniBit)
//               
// PARAMETERS  : WhichIniBit        IAR_BIT or IOB_BIT
//               
//
// RETURN VALUE: ENABLE or DISABLE
//               
// LIMITATIONS : None
//               
//---------------------------------------------------------------------
BOOL CLKA_DpllGetInitialize(BOOL WhichIniBit)
{
  if (WhichIniBit==IAI_BIT)
    {
    if (TestBit(MCU_DPLLCTL,MCU_DPLLCTL_IAI_MASK))
      return((BOOL)ENABLE);
    else
      return((BOOL)DISABLE);
    }
  else
    {
    if (TestBit(MCU_DPLLCTL,MCU_DPLLCTL_IOB_MASK))
      return((BOOL)ENABLE);
    else
      return((BOOL)DISABLE);
    }
}

//---------------------------------------------------------------------
// NAME        : CLKA_IsDpllLocked
//               
// DESCRIPTION : Test if Dpll is locked 
//               
// SYNOPSYS    : BOOL CLKA_IsDpllLocked(void)
//               
// PARAMETERS  : None
//               
// RETURN VALUE: LOCKED or UNLOCKED
//               
// LIMITATIONS : None
//               
//---------------------------------------------------------------------
BOOL CLKA_IsDpllLocked(void)
{
   if (TestBit(MCU_DPLLCTL,MCU_DPLLCTL_LOCK_MASK))
      return((BOOL)LOCKED);
    else
      return((BOOL)UNLOCKED);
}

//---------------------------------------------------------------------
// NAME        : CLKA_IsDpllBroken
//               
// DESCRIPTION : Test if Dpll is has broken 
//               
// SYNOPSYS    : BOOL CLKA_IsDpllBroken(void)
//               
// PARAMETERS  : None
//               
// RETURN VALUE: BROKEN or NOT_BROKEN
//               
// LIMITATIONS : None
//               
//---------------------------------------------------------------------
BOOL CLKA_IsDpllBroken(void)
{
   if (TestBit(MCU_DPLLCTL,MCU_DPLLCTL_BREAKLN_MASK))
      return((BOOL)NOT_BROKEN);
    else
      return((BOOL)BROKEN);
}



void CLKA_TestRegisterResetValue(void)
{

if ((MCU_CKCTL  & MCU_CKCTL_MSK     ) ==  MCU_CKCTL_RST_VALUE)
	RES_Set(TEST_OK);
else
	RES_Set( ERR_MCU_CKCTL_RST_VALUE);

if ((MCU_IDLECT1 & MCU_IDLECT1_MSK  ) ==  MCU_IDLECT1_RST_VALUE)
	RES_Set(TEST_OK);
else
	RES_Set( ERR_MCU_IDLECT1_RST_VALUE);
if ((MCU_IDLECT2 & MCU_IDLECT2_MSK  ) ==  MCU_IDLECT2_RST_VALUE)
	RES_Set(TEST_OK);
else
	RES_Set( ERR_MCU_IDLECT2_RST_VALUE);
if ((MCU_EWUPCT & MCU_EWUPCT_MSK	  ) ==  MCU_EWUPCT_RST_VALUE)
	RES_Set(TEST_OK);
else
	RES_Set( ERR_MCU_EWUPCT_RST_VALUE);
if ((MCU_RSTCT1 & MCU_RSTCT1_MSK	  ) ==  MCU_RSTCT1_RST_VALUE)
	RES_Set(TEST_OK);
else
	RES_Set( ERR_MCU_RSTCT1_RST_VALUE);
if ((MCU_RSTCT2 & MCU_RSTCT2_MSK	  ) ==  MCU_RSTCT2_RST_VALUE)
	RES_Set(TEST_OK);
else
	RES_Set( ERR_MCU_RSTCT2_RST_VALUE);
if ((MCU_SYSST  & MCU_SYSST_MSK	  ) ==  MCU_SYSST_RST_VALUE)
	RES_Set(TEST_OK);
else
	RES_Set( ERR_MCU_SYSST_RST_VALUE);
if ((MCU_CKOUT1 & MCU_CKOUT1_MSK	  ) ==  MCU_CKOUT1_RST_VALUE)
	RES_Set(TEST_OK);
else
	RES_Set( ERR_MCU_CKOUT1_RST_VALUE);
if ((MCU_CKOUT2 & MCU_CKOUT2_MSK	  ) ==  MCU_CKOUT2_RST_VALUE)
	RES_Set(TEST_OK);
else
	RES_Set( ERR_MCU_CKOUT2_RST_VALUE);
if ((MCU_DPLLCTL & MCU_DPLLCTL_MSK  ) ==  MCU_DPLLCTL_RST_VALUE)
	RES_Set(TEST_OK);
else
	RES_Set( ERR_MCU_DPLLCTL_RST_VALUE);

}