clkmarm.c

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

UWORD32 IdleReg=0;

//IDLTIM_MCU
//----------
     if (TimState==SET_IN_IDLE)
       SetBit(IdleReg,MCU_IDLECT1_IDLTIM_MCU_MASK);
     else
       ClearBit(IdleReg,MCU_IDLECT1_IDLTIM_MCU_MASK);

//IDLDPLL_MCU
//----------
     if (DpllState==SET_IN_IDLE)
       SetBit(IdleReg,MCU_IDLECT1_IDLDPLL_MCU_MASK);
     else
       ClearBit(IdleReg,MCU_IDLECT1_IDLDPLL_MCU_MASK);


//IDLLIF_MCU
//----------
     if (IntMemState==SET_IN_IDLE)
       SetBit(IdleReg,MCU_IDLECT1_IDLIF_MCU_MASK);
     else
       ClearBit(IdleReg,MCU_IDLECT1_IDLIF_MCU_MASK);

//IDLLCD_MCU
//----------
     if (LcdState==SET_IN_IDLE)
       SetBit(IdleReg,MCU_IDLECT1_IDLLCD_MCU_MASK);
     else
       ClearBit(IdleReg,MCU_IDLECT1_IDLLCD_MCU_MASK);

//IDLPER_MCU
//----------
     if (PerState==SET_IN_IDLE)
       SetBit(IdleReg,MCU_IDLECT1_IDLPER_MCU_MASK);
     else
       ClearBit(IdleReg,MCU_IDLECT1_IDLPER_MCU_MASK);

//IDLXOR_MCU
//----------
     if (XorpState==SET_IN_IDLE)
       SetBit(IdleReg,MCU_IDLECT1_IDLXORP_MCU_MASK);
     else
       ClearBit(IdleReg,MCU_IDLECT1_IDLXORP_MCU_MASK);

//IDLWDT_MCU
//----------
     if (WdtState==SET_IN_IDLE)
       SetBit(IdleReg,MCU_IDLECT1_IDLWDT_MCU_MASK);
     else
       ClearBit(IdleReg,MCU_IDLECT1_IDLWDT_MCU_MASK);

    MCU_IDLECT1=IdleReg;
}

//-----------------------------------------------------------------------------
// NAME         : CLKA_IsModuleIdle                                                --
// DESCRIPTION  : read the module mode                                        --
// PARAMETERS   : module (name of module x_MODULE)
//                                                   MCU_MODULE
//                                                   TIM_MODULE
//                                                   DPLL_MODULE
//                                                   LIF_MODULE
//                                                   LCD_MODULE
//                                                   PER_MODULE
//                                                   XORP_MODULE
//                                                   WDT_MODULE
//
// RETURN VALUE : SET_IN_IDLE or SET_NOT_IDLE                                   --
// LIMITATIONS  : None                                                      --
//-----------------------------------------------------------------------------
BOOL CLKA_IsModuleIdle(MODULE_NAME_t module)
{
switch (module)
  {
  case MCU_MODULE :
    {
    if (TestBit(MCU_IDLECT1,MCU_IDLECT1_SETMCU_IDLE_MASK))
      return((BOOL)SET_IN_IDLE);
    else
      return((BOOL)SET_NOT_IDLE);
    //break;
    }

  case TIM_MODULE :
    {
    if (TestBit(MCU_IDLECT1,MCU_IDLECT1_IDLTIM_MCU_MASK))
      return((BOOL)SET_IN_IDLE);
    else
      return((BOOL)SET_NOT_IDLE);
    //break;
    }

  case DPLL_MODULE :
    {
    if (TestBit(MCU_IDLECT1,MCU_IDLECT1_IDLDPLL_MCU_MASK))
      return((BOOL)SET_IN_IDLE);
    else
      return((BOOL)SET_NOT_IDLE);
    //break;
    }

  case LIF_MODULE :
    {
    if (TestBit(MCU_IDLECT1,MCU_IDLECT1_IDLIF_MCU_MASK))
      return((BOOL)SET_IN_IDLE);
    else
      return((BOOL)SET_NOT_IDLE);
    //break;
    }

  case LCD_MODULE :
    {
    if (TestBit(MCU_IDLECT1,MCU_IDLECT1_IDLLCD_MCU_MASK))
      return((BOOL)SET_IN_IDLE);
    else
      return((BOOL)SET_NOT_IDLE);
    //break;
    }

  case PER_MODULE :
    {
    if (TestBit(MCU_IDLECT1,MCU_IDLECT1_IDLPER_MCU_MASK))
      return((BOOL)SET_IN_IDLE);
    else
      return((BOOL)SET_NOT_IDLE);
    //break;
    }

  case XORP_MODULE :
    {
    if (TestBit(MCU_IDLECT1,MCU_IDLECT1_IDLXORP_MCU_MASK))
      return((BOOL)SET_IN_IDLE);
    else
      return((BOOL)SET_NOT_IDLE);
    //break;
    }

  case WDT_MODULE :
    {
    if (TestBit(MCU_IDLECT1,MCU_IDLECT1_IDLWDT_MCU_MASK))
      return((BOOL)SET_IN_IDLE);
    else
      return((BOOL)SET_NOT_IDLE);
    //break;
    }

  default :
    {
    return False;
    //break;
    }
  }
}


//-----------------------------------------------------------------------------
// NAME         : CLKA_SetExtWakeUpPinMode                                 --
// DESCRIPTION  : Enable the external Wakeup mode 
// PARAMETERS   : State = ENABLE or DISABLE
// RETURN VALUE : None.                                                      --
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
void CLKA_SetExtWakeUpPinMode(BOOL State)
{
   if (State==ENABLE)
     ClearBit(MCU_EWUPCT,MCU_EWUPCT_REPWR_EN_MASK);
   else
     SetBit(MCU_EWUPCT,MCU_EWUPCT_REPWR_EN_MASK);
     
}


//-----------------------------------------------------------------------------
// NAME         : CLKA_ReadExtWakeUpPinMode                                 --
// DESCRIPTION  : Enable the external Wakeup mode 
// PARAMETERS   : None
// RETURN VALUE : State = ENABLE or DISABLE.                                                      --
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
BOOL CLKA_ReadExtWakeUpPinMode(void)
{
  if (TestBit(MCU_EWUPCT,MCU_EWUPCT_REPWR_EN_MASK))
     return((BOOL)DISABLE);
  else
     return((BOOL)ENABLE);
   
}


//-----------------------------------------------------------------------------
// NAME         : ReadExtWakeUpMode                                 --
// DESCRIPTION  : Enable the external Wakeup mode 
// PARAMETERS   : State = ENABLE or DISABLE
// RETURN VALUE : None.                                                      --
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
void CLKA_SetExtWakeUpPinDelay(UCHAR delay)
{
  SetGroupBits(MCU_EWUPCT,0,5, ((UWORD16)delay) );  
}

//-----------------------------------------------------------------------------
// NAME         : SetDMAclock                                              --
// DESCRIPTION  : Stop the dma clock by default or enable it 
// PARAMETERS   : State = STOP_BY_DEFAULT or ONLY_WHEN_IDLE
// RETURN VALUE : None.                                                      --
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
void CLKA_SetDmaClockMode(BOOL State)
{
  if (State==STOP_BY_DEFAULT)
    SetBit(MCU_IDLECT2,MCU_IDLECT2_DMACK_REQ_MASK);  
  else
    ClearBit(MCU_IDLECT2,MCU_IDLECT2_DMACK_REQ_MASK);  

}

//-----------------------------------------------------------------------------
// NAME         : CLKA_ReadDmaClockMode                                              --
// DESCRIPTION  : Read the dma clock mode
// PARAMETERS   : None 
// RETURN VALUE :  STOP_BY_DEFAULT or ONLY_WHEN_IDLE      --
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
BOOL CLKA_ReadDmaClockMode(void)
{
   
  if (TestBit(MCU_IDLECT2,MCU_IDLECT2_DMACK_REQ_MASK))
    return((BOOL)STOP_BY_DEFAULT);
  else
    return((BOOL)ONLY_WHEN_IDLE);
}


//-----------------------------------------------------------------------------
// NAME         : GenerateMCUReset                                              --
// DESCRIPTION  : Reset the MCU
// PARAMETERS   : GLOBAL_RESET or MCU_RESET
// RETURN VALUE : None 
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
void CLKA_GenerateReset(BOOL Domain)
{
  if (Domain==GLOBAL_RESET)
    {
    ClearBit(MCU_RSTCT1,MCU_RSTCT1_MGS_EN_MASK);
    SetBit(MCU_RSTCT1,MCU_RSTCT1_MCU_RST_MASK);
    }
  else
    {// MCU_RESET
    SetBit(MCU_RSTCT1,MCU_RSTCT1_MGS_EN_MASK);
    SetBit(MCU_RSTCT1,MCU_RSTCT1_MCU_RST_MASK);
    }
}

//-----------------------------------------------------------------------------
// NAME         : CLKA_TogglePeripheralResetPin       
// DESCRIPTION  : Toggle the pin which manage the peripheral reset :MCUPER_nRST
// PARAMETERS   : LOW_LEVEL or HIGH_LEVEL
// RETURN VALUE : None 
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
void CLKA_TogglePeripheralResetPin(BOOL State)
{
  if (State==LOW_LEVEL)
    ClearBit(MCU_RSTCT2,MCU_RSTCT2_PER_EN_MASK);
  else
    SetBit(MCU_RSTCT2,MCU_RSTCT2_PER_EN_MASK);
}



//-----------------------------------------------------------------------------
// NAME         : CLKA_ReadPeripheralResetPin       
// DESCRIPTION  : Read the state of MCUPER_nRST pin
// PARAMETERS   : None
// RETURN VALUE : LOW_LEVEL or HIGH_LEVEL 
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
BOOL CLKA_ReadPeripheralResetPin(void)
{
  if (TestBit(MCU_RSTCT2,MCU_RSTCT2_PER_EN_MASK))
    return((BOOL)HIGH_LEVEL);
  else
    return((BOOL)LOW_LEVEL);
}


//-----------------------------------------------------------------------------
// NAME         : CLKA_GetResetOrigin       
// DESCRIPTION  : Retrieve the reset origin and clear the flag associated when 
//                read. Only the DID_RESET_OCCURED label do not clear any flags
//
// PARAMETERS   : one of the following value
//                MCU_POWER_ON_RESET
//                MCU_EXTERN_RESET
//                MCU_SELF_RESET
//                MCU_WDG_RESET
//                MCU_GLOBAL_SOFT_RESET
//                DID_RESET_OCCURED
//
// RETURN VALUE : Return TRUE if the notified module has reset
//                When the DID_RESET_OCCURED parameter is passed
//                all the module are tested
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
BOOL CLKA_GetResetOrigin(RESET_ORIGIN_t resetTrack)
{
switch (resetTrack)
  {
  case MCU_POWER_ON_RESET :
    {
    if (TestBit(MCU_SYSST,MCU_SYSST_POR_MASK))
      {
      ClearBit(MCU_SYSST,MCU_SYSST_POR_MASK);
      return True;
      }
    else
      return False;
    //break;
    }

  case MCU_EXTERN_RESET :
    {
    if (TestBit(MCU_SYSST,MCU_SYSST_EXT_RST_MASK))
      {
      ClearBit(MCU_SYSST,MCU_SYSST_EXT_RST_MASK);
      return True;
      }
    else
      return False;
    //break;
    }

  case MCU_SELF_RESET :
    {
    if (TestBit(MCU_SYSST,MCU_SYSST_MCU_RST_MASK))
      {
      ClearBit(MCU_SYSST,MCU_SYSST_MCU_RST_MASK);
      return True;
      }
    else
      return False;
    //break;
    }

  case MCU_WDG_RESET :
    {
    if (TestBit(MCU_SYSST,MCU_SYSST_MCU_WDRST_MASK))
      {
      ClearBit(MCU_SYSST,MCU_SYSST_MCU_WDRST_MASK);
      return True;
      }
    else
      return False;
    //break;
    }

  case MCU_GLOBAL_SOFT_RESET :
    {
    if (TestBit(MCU_SYSST,MCU_SYSST_GLOB_SWRST_MASK))
      {
      ClearBit(MCU_SYSST,MCU_SYSST_GLOB_SWRST_MASK);
      return True;
      }
    else
      return False;
    //break;
    }

  case DID_RESET_OCCURED :
    {
    if (TestBit(MCU_SYSST,MCU_SYSST_POR_MASK)       OR
        TestBit(MCU_SYSST,MCU_SYSST_EXT_RST_MASK)   OR
        TestBit(MCU_SYSST,MCU_SYSST_MCU_RST_MASK)   OR
        TestBit(MCU_SYSST,MCU_SYSST_MCU_WDRST_MASK) OR
        TestBit(MCU_SYSST,MCU_SYSST_GLOB_SWRST_MASK) )
      return True;
    else
      return False;
    //break;
    }

  default :
    {
    return False;
    //break;
    }
  }
}

//-----------------------------------------------------------------------------
// NAME         : CLKA_ReadPeripheralResetPin       
// DESCRIPTION  : Read the state of MCUPER_nRST pin
// PARAMETERS   : None
// RETURN VALUE : 
//                  FUNCTIONNAL_MODE  
//                  ARM925ST_DEBUG_MODE
//                  MEGASTAR_DEBUG_MODE
//                  IDDQ_TEST
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
CONFIG_t CLKA_GetChipConfig(void)
{
  return((CONFIG_t)GetGroupBits(MCU_SYSST,MCU_SYSST_CONFIG_POS,MCU_SYSST_CONFIG_WIDTH));
}


//----------------------------------------------------------
// NAME        : CLKA_SetClkoutRefflect 
// DESCRIPTION : Set the signal reflected by clkout or 
//               put CLKOUT pin in I/O mode
//
// PARAMETERS  : CLKOUT_OPTIONS_t ClkoutOption
//                              CLKOUT__IO              
//                              CLKOUT__CK_GEN          
//                              CLKOUT__CK_MCUDOM       
//                              CLKOUT__CK_VTCXO14