clkmarm.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       	: clkm_arm.c
//
//   Description    	: Body file to access to CKL Module registers
//
//   Project        	: arm925st
//
//   Author         	: Daniel BLANC
//=======================================================================================


#include "clkmarm.h"
#include "result.h"
#include "test.h"

//----------------------------------------------------------
// NAME        : CLKA_SetPeripheralClockEnable 
// DESCRIPTION : Enable/Disable the selected peripheral clock
//               
// PARAMETERS  : PerifName
//                         TIM
//                         LCD
//                         PER
//                         XORPC
//                         WDGTIM
//
//                and State=ENABLE or DISABLE
// RETURN VALUE: IS_OK if the operation succeed
//               NOT_OK if not      -
//  LIMITATIONS : None                                      -
// ----------------------------------------------------------

BOOL CLKA_SetPeripheralClockEnable(PERIPH_NAME_t PerifName, BOOL State)
{
switch (PerifName)
  {
  case TIM ://os timer
    {
    if (State==ENABLE)
      SetBit(MCU_IDLECT2,MCU_IDLECT2_EN_TIMCK_MASK);
    else
      ClearBit(MCU_IDLECT2,MCU_IDLECT2_EN_TIMCK_MASK);
    return True;
    }

  case LCD ://lcd 
    {
    if (State==ENABLE)
      SetBit(MCU_IDLECT2,MCU_IDLECT2_EN_LCDCK_MASK);
    else
      ClearBit(MCU_IDLECT2,MCU_IDLECT2_EN_LCDCK_MASK);
    return True;
    }

  case PER ://external peripheral
    {
    if (State==ENABLE)
      SetBit(MCU_IDLECT2,MCU_IDLECT2_EN_PERCK_MASK);
    else
      ClearBit(MCU_IDLECT2,MCU_IDLECT2_EN_PERCK_MASK);
    return True;
    }

  case XORPC ://vtcxo reference peripheral
    {
    if (State==ENABLE)
      SetBit(MCU_IDLECT2,MCU_IDLECT2_EN_XORPCK_MASK);
    else
      ClearBit(MCU_IDLECT2,MCU_IDLECT2_EN_XORPCK_MASK);
    return True;
    }

  case WDGTIM ://watchdog timer clock
    {
    if (State==ENABLE)
      SetBit(MCU_IDLECT2,MCU_IDLECT2_EN_WDTCK_MASK);
    else
      ClearBit(MCU_IDLECT2,MCU_IDLECT2_EN_WDTCK_MASK);
    return True;
    }

  default :
    {
    return False;
    }
  }
}


//----------------------------------------------------------
// NAME        : CLKA_IsPeripheralClockEnabled 
// DESCRIPTION : Test if the peripheral clock is enabled
//               
// PARAMETERS  : PerifName
//                         TIM
//                         LCD
//                         PER
//                         XORPC
//                         WDGTIM
//
// RETURN VALUE: YES if enabled
//               NO if not      -
//  LIMITATIONS : None                                      -
// ----------------------------------------------------------

BOOL CLKA_IsPeripheralClockEnabled(PERIPH_NAME_t PerifName)
{
switch (PerifName)
  {
  case TIM ://os timer
    {
    return((BOOL)TestBit(MCU_IDLECT2,MCU_IDLECT2_EN_TIMCK_MASK));
    }

  case LCD ://lcd 
    {
    return((BOOL)TestBit(MCU_IDLECT2,MCU_IDLECT2_EN_LCDCK_MASK));
    }

  case PER ://external peripheral
    {
    return((BOOL)TestBit(MCU_IDLECT2,MCU_IDLECT2_EN_PERCK_MASK));
    }

  case XORPC ://vtcxo reference peripheral
    {
    return((BOOL)TestBit(MCU_IDLECT2,MCU_IDLECT2_EN_XORPCK_MASK));
    }

  case WDGTIM ://watchdog timer clock
    {
    return((BOOL)TestBit(MCU_IDLECT2,MCU_IDLECT2_EN_WDTCK_MASK));
    }

  default :
    {
    return False;
    }
  }
}

/*
//----------------------------------------------------------
// NAME        : ReaClkMCUReg 
// DESCRIPTION : Read the CLKM registers
//               
// PARAMETERS  : RegName 
// RETURN VALUE: IS_OK if the operation succeed
//               NOT_OK if not      -
//  LIMITATIONS : None                                      -
// ----------------------------------------------------------

 UWORD16 ReadClkMCUReg(CLKM_MCU_REG_NAME_t RegName)
{
switch (RegName)
  {
  case CKCTL :
    {
    return(MCU_CKCTL);
    }

  case IDLECT1 :
    {
    return(MCU_IDLECT1);
    }

  case IDLECT2 :
    {
    return(MCU_IDLECT2);
    }

  case EWUPCT :
    {
    return(MCU_EWUPCT);
    }

  case RSTCT1 :
    {
    return(MCU_RSTCT1);
    }

  case RSTCT2 :
    {
    return(MCU_RSTCT2);
    }

  case SYSST :
    {
    return(MCU_SYSST);
    }

  case CKOUT1 :
    {
    return(MCU_CKOUT1);
    }

  case CKOUT2 :
    {
    return(MCU_CKOUT2);
    }

  default :
    {
    return(FALSE);
    }
  }
}

*/

//-----------------------------------------------------------------------------
// NAME         : CLKA_SetMcuRefClock                                 --
// DESCRIPTION  : defines the frequency for MCU, LCD and MCU_PER Clocks and the ref clock      --
// PARAMETERS   : refclock (VTCXO or CLIN)
// RETURN VALUE : None.                                                      --
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
void CLKA_SetMcuRefClock(REF_CLOCK_t refclock)
{
  if (refclock==VTCXO)
    SetBit(MCU_CKCTL,MCU_CKCTL_TIMXO_MASK);
  else
    ClearBit(MCU_CKCTL,MCU_CKCTL_TIMXO_MASK);
}

//-----------------------------------------------------------------------------
// NAME         : SetMCU_WakupMode                                 --
// DESCRIPTION  : Set the wake up mode
// PARAMETERS   : LOWLEV_EXT_CHIP_nWKUP or MCU_INT_WKUP
// RETURN VALUE : None.                                                      --
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
void CLKA_SetMcuWakeUpMode(BOOL whowakeup)
{
  if (whowakeup==MCU_INT_WKUP)
    SetBit(MCU_IDLECT1,MCU_IDLECT1_WKUP_MODE_MASK);
  else
    ClearBit(MCU_IDLECT1,MCU_IDLECT1_WKUP_MODE_MASK);
}

//-----------------------------------------------------------------------------
// NAME         : SetMCU_WakupMode                                 --
// DESCRIPTION  : Set the wake up mode
// PARAMETERS   : LOWLEV_EXT_CHIP_nWKUP or MCU_INT_WKUP
// RETURN VALUE : None.                                                      --
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
BOOL CLKA_ReadMcuWakeUpMode(void)
{
  if (TestBit(MCU_IDLECT1,MCU_IDLECT1_WKUP_MODE_MASK))
     return((BOOL)MCU_INT_WKUP);
  else
     return((BOOL)LOWLEV_EXT_CHIP_nWKUP);
}

//-----------------------------------------------------------------------------
// NAME         : CLKA_SetClockDivider                                 --
// DESCRIPTION  : defines the frequency for MCU, LCD and MCU_PER Clocks and the ref clock      --
// PARAMETERS   : CLOCK_DIV values of peripherals              --
//                   MCU_DIVIDER,
//                   TIM_DIVIDER,
//                   LCD_DIVIDER,
//                   MCUPER_DIVIDER  
//
//                    CK_DIV_BY_1
//                    CK_DIV_BY_2
//                    CK_DIV_BY_4
//                    CK_DIV_BY_8       
//
// RETURN VALUE : None.                                                      --
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
void CLKA_SetClockDivider(DIVIDER_NAME_t DivName,  MCU_CKCTL_DIV_t divval)
{
//UWORD16 refclock;
#define CLEAN 0x3

switch (DivName)
  {
  case MCU_DIVIDER :
    {
    ClearBit(MCU_CKCTL,  (CLEAN << CKCTL_MCUDIV_POS)); 
    SetBit(MCU_CKCTL, (divval << CKCTL_MCUDIV_POS));
    break;
    }

  case TIM_DIVIDER :
    {
    ClearBit(MCU_CKCTL,  (CLEAN << CKCTL_MCU_TIMDIV_POS)); 
    SetBit(MCU_CKCTL, (divval << CKCTL_MCU_TIMDIV_POS));
    break;
    }

  case LCD_DIVIDER :
    {
    ClearBit(MCU_CKCTL,  (CLEAN << CKCTL_MCU_LCDDIV_POS)); 
    SetBit(MCU_CKCTL, (divval << CKCTL_MCU_LCDDIV_POS));
    break;
    }

  case MCUPER_DIVIDER :
    {
    ClearBit(MCU_CKCTL,  CLEAN ); 
    SetBit(MCU_CKCTL, divval );
    break;
    }

  default :
    {
    break;
    }
  }

}


//-----------------------------------------------------------------------------
// NAME         : CLKA_ReadClockDivider                                 --
// DESCRIPTION  : defines the frequency for MCU, LCD and MCU_PER Clocks and the ref clock      --
// PARAMETERS   : DivName 
//                        MCU_DIVIDER
//                        TIM_DIVIDER
//                        LCD_DIVIDER
//                        MCUPER_DIVIDER
/// RETURN VALUE : 
//                        CK_DIV_BY_1
//                        CK_DIV_BY_2
//                        CK_DIV_BY_4
//                        CK_DIV_BY_8
//
// LIMITATIONS  : None                                    --
//-----------------------------------------------------------------------------
MCU_CKCTL_DIV_t CLKA_ReadClockDivider(DIVIDER_NAME_t DivName)
{
//UWORD16 refclock;
#define CLEAN 0x3

switch (DivName)
  {
  case MCU_DIVIDER :
    {
    return((MCU_CKCTL_DIV_t)GetGroupBits(MCU_CKCTL, CKCTL_MCUDIV_POS, DIV_SIZE));
    //break;
    }

  case TIM_DIVIDER :
    {
    return((MCU_CKCTL_DIV_t)GetGroupBits(MCU_CKCTL, CKCTL_MCU_TIMDIV_POS, DIV_SIZE));
    //break;
    }

  case LCD_DIVIDER :
    {
    return((MCU_CKCTL_DIV_t)GetGroupBits(MCU_CKCTL, CKCTL_MCU_LCDDIV_POS, DIV_SIZE));
    //break;
    }

  case MCUPER_DIVIDER :
    {
    return((MCU_CKCTL_DIV_t)GetGroupBits(MCU_CKCTL, CKCTL_MCU_MCUPPER_POS, DIV_SIZE));
    //break;
    }

  default :
    {
    return((MCU_CKCTL_DIV_t)0);
    //break;
    }
  }

}



//-----------------------------------------------------------------------------
// NAME         : CLKA_SetIdle               
// DESCRIPTION  : Launch the idle mode                  
// PARAMETERS   : IdleMode         IDLE_WAITFOR_PIN_WKUP or IDLE_WAITFOR_INT_WKUP 
//
// RETURN VALUE : None.                                                      --
// LIMITATIONS  : None                                                      --
//-----------------------------------------------------------------------------
void CLKA_SetIdle(BOOL IdleMode)
{
    if (IdleMode==IDLE_WAITFOR_INT_WKUP)
       SetBit(MCU_IDLECT1,MCU_IDLECT1_WKUP_MODE_MASK);
    else
       ClearBit(MCU_IDLECT1,MCU_IDLECT1_WKUP_MODE_MASK);

   SetBit(MCU_IDLECT1,MCU_IDLECT1_SETMCU_IDLE_MASK);
}

//-----------------------------------------------------------------------------
// NAME         : CLKA_ConfigIdleModule                                                --
// DESCRIPTION  : put or remove a module from idle mode                     --
// PARAMETERS   :
//                      State=SET_IN_IDLE or SET_NOT_IDLE for each module
// RETURN VALUE : None.                                                      --
// LIMITATIONS  : None                                                      --
//-----------------------------------------------------------------------------
void CLKA_ConfigIdleModule( BOOL TimState,
                       BOOL DpllState,
                       BOOL IntMemState,
                       BOOL LcdState,
                       BOOL PerState,
                       BOOL XorpState,
                       BOOL WdtState)
{