www.pudn.com > bq26100SHA1c_files.rar > 91x_scu.c, change:2006-05-25,size:26649b


/******************** (C) COPYRIGHT 2006 STMicroelectronics ******************** 
* File Name          : 91x_scu.c 
* Author             : MCD Application Team 
* Date First Issued  : 05/18/2006 : Version 1.0 
* Description        : This file provides the SCU library software functions 
******************************************************************************** 
* History: 
* 05/24/2006 : Version 1.1 
* 05/18/2006 : Version 1.0 
******************************************************************************** 
* THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH 
* CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS 
* A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT 
* OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT 
* OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION 
* CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. 
*******************************************************************************/ 
 
/* Includes ------------------------------------------------------------------*/ 
#include "91x_scu.h" 
 
/* Include of other module interface headers ---------------------------------*/ 
/* Local includes ------------------------------------------------------------*/ 
/* Private typedef -----------------------------------------------------------*/ 
/* Private define ------------------------------------------------------------*/ 
#define SCU_PLLEN 0x80000 
/* Private macro -------------------------------------------------------------*/ 
/* Private variables ---------------------------------------------------------*/ 
/* Private function prototypes -----------------------------------------------*/ 
/* Interface functions -------------------------------------------------------*/ 
/* Private functions ---------------------------------------------------------*/ 
 
/******************************************************************************* 
* Function Name  : SCU_MCLKSourceConfig 
* Description    : Configures the MCLK source clock 
* Input          : MCLK_Source = SCU_MCLK_OSC, SCU_MCLK_PLL or SCU_MCLK_RTC 
* Output         : None 
* Return         : ErrorStatus: SUCCESS or ERROR 
* Note           : this function returns ERROR if trying to select the PLL as 
*                  clock source while the PLL is disabled or not locked. 
*******************************************************************************/ 
ErrorStatus SCU_MCLKSourceConfig(u32 MCLK_Source) 
{ 
  u32 CLKCNTR_Value; 
 
  CLKCNTR_Value = SCU->CLKCNTR;         /*get CLKCNTR register value*/ 
  CLKCNTR_Value &=~0x3;                 /*clear field MCLKSEL*/ 
  if (MCLK_Source == SCU_MCLK_PLL)      /*PLL selected as clock source*/ 
  { 
    /*check if PLL enabled & locked*/ 
    if (!((SCU->PLLCONF&SCU_PLLEN)&&(SCU->SYSSTATUS&SCU_FLAG_LOCK))) 
    return ERROR; 
  } 
  else CLKCNTR_Value |=MCLK_Source;     /*OSC or RTC selected as clock source*/ 
  SCU->CLKCNTR = CLKCNTR_Value;         /*Update CLKCNTR register value*/ 
  return SUCCESS; 
} 
 
/******************************************************************************* 
* Function Name  : SCU_PLLFactorsConfig 
* Description    : Sets the PLL factors 
* Input          : PLLN, PLLM and PLLP 
* Output         : None 
* Return         : ErrorStatus: ERROR or SUCCESS 
* Notes          : -The PLL factors must respect the PLL specification requirements 
*                  -The function returns ERROR if trying to change PLL 
*                   factors while PLL is selected as Main Clock source (MCLK) 
*                  -This function disables the PLL, to enable the PLL use 
*                   function" SCU_PLLCmd(ENABLE)" after setting the PLL factors 
******************************************************************************/ 
ErrorStatus SCU_PLLFactorsConfig(u8 PLLN, u8 PLLM, u8 PLLP) 
{ 
  if (SCU_PLLCmd(DISABLE)==SUCCESS)      /*Disable PLL*/ 
  { 
    SCU->PLLCONF =0;                     /*clear PLLCONF register*/ 
    SCU->PLLCONF |=(PLLN<<8);            /*update PLLN field*/ 
    SCU->PLLCONF |=PLLM;                 /*update PLLM field*/ 
    SCU->PLLCONF |=PLLP<<16;             /*update PLLP field*/ 
    return SUCCESS; 
  } 
  return ERROR; 
} 
 
/******************************************************************************* 
* Function Name  : SCU_PLLCmd 
* Description    : Enable or Disable the PLL 
* Input          : NewState = ENABLE or DISABLE 
* Output         : None 
* Return         : ErrorStatus: SUCCESS or ERROR 
* Note           : -The function returns ERROR if: 
*                   *trying to disable the PLL while it is selected as the MCLK 
*                   *trying to enable the PLL while it is already enabled and 
*                    locked 
*******************************************************************************/ 
ErrorStatus SCU_PLLCmd(FunctionalState NewState) 
{ 
  vu32 i; 
  if (NewState==ENABLE) 
  { 
    if (!((SCU->PLLCONF&SCU_PLLEN)&&(SCU->SYSSTATUS&SCU_FLAG_LOCK))) 
    { 
      SCU->SYSSTATUS|=SCU_FLAG_LOCK;               /*clear LOCK bit*/ 
      SCU->PLLCONF |=SCU_PLLEN;                    /*PLL Enable*/ 
      while(!SCU->SYSSTATUS&SCU_FLAG_LOCK);        /*Wait PLL to lock*/ 
      return SUCCESS; 
    } 
    else return ERROR; 
  } 
  else /*NewState = DISABLE*/ 
  { 
    if(SCU->CLKCNTR&0x3)                /*check if PLL not sys CLK*/ 
    { 
      for(i=10;i>0;i--);                /*delay before PLL disabling*/ 
      SCU->PLLCONF &=~SCU_PLLEN;        /*PLL Disable*/ 
      return SUCCESS; 
    } 
    else return ERROR; 
  } 
} 
 
/******************************************************************************* 
* Function Name  : SCU_RCLKDivisorConfig 
* Description    : Sets the RCLK divisor value 
* Input          : RCLK_Divisor 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_RCLKDivisorConfig(u32 RCLK_Divisor) 
{ 
  SCU->CLKCNTR &=SCU_RCLK_Div1;              /*clear RCLKDIV[2:0] field*/ 
  if (RCLK_Divisor!=SCU_RCLK_Div1) 
  SCU->CLKCNTR |= RCLK_Divisor;              /*update field with RCLK divisor*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_HCLKDivisorConfig 
* Description    : Sets the HCLK divisor value 
* Input          : HCLK_Divisor 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_HCLKDivisorConfig(u32 HCLK_Divisor) 
{ 
  SCU->CLKCNTR &=SCU_HCLK_Div1;              /*clear AHBDIV[1:0] field*/ 
  if (HCLK_Divisor!=SCU_HCLK_Div1) 
  SCU->CLKCNTR |= HCLK_Divisor;              /*update field with HCLK divisor*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_PCLKDivisorConfig 
* Description    : Sets the PCLK divisor value 
* Input          : PCLK_Divisor 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_PCLKDivisorConfig(u32 PCLK_Divisor) 
{ 
  SCU->CLKCNTR &=SCU_PCLK_Div1;              /*clear APBDIV[1:0] field*/ 
  if (PCLK_Divisor!=SCU_PCLK_Div1) 
  SCU->CLKCNTR |= PCLK_Divisor;              /*update field with PCLK Divisor*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_APBPeriphClockConfig 
* Description    : Enable the clock for an APB peripheral 
* Input          : -APBPerip : APB peripherals(__RTC, __ADC ,...) 
*                  -NewState : ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_APBPeriphClockConfig(u32 APBPeriph, FunctionalState NewState) 
{ 
  if (NewState==ENABLE)                     /*Enable clock for APB peripheral*/ 
  SCU->PCGR1 |=APBPeriph; 
  else 
  SCU->PCGR1 &=~APBPeriph;                  /*Disable clock for APB peripheral*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_AHBPeriphClockConfig 
* Description    : Enable the clock for an AHB peripheral 
* Input          : -AHBPerip: AHB peripherals(__USB, __DMA,...) 
*                  -NewState : ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_AHBPeriphClockConfig(u32 AHBPeriph, FunctionalState NewState) 
{ 
  if (NewState==ENABLE)                     /*Enable clock for AHB peripheral*/ 
  SCU->PCGRO |=AHBPeriph; 
  else 
  SCU->PCGRO &=~AHBPeriph;                  /*Disable clock for AHB peripheral*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_APBPeriphReset 
* Description    : Assert or deassert Reset on APB peripheral 
* Input          : -APBPeriph: APB peripherals(__RTC, __ADC,...) 
                   -NewState : ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_APBPeriphReset(u32 APBPeriph, FunctionalState NewState) 
{ 
  if (NewState==DISABLE)                    /*APB peripheral not held in Reset*/ 
  SCU->PRR1 |=APBPeriph; 
  else 
  SCU->PRR1 &=~APBPeriph;                   /*APB peripheral held in Reset*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_AHBPeriphReset 
* Description    : Assert or deassert Reset on AHB peripheral 
* Input          : -AHBPeriph: AHB peripherals(__USB, __DMA,...) 
                   -NewState : ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_AHBPeriphReset(u32 AHBPeriph, FunctionalState NewState) 
{ 
  if (NewState==DISABLE) 
  SCU->PRR0 |=AHBPeriph;                    /*AHB peripheral not held in Reset*/ 
  else 
  SCU->PRR0 &=~AHBPeriph;                   /*AHB peripheral held in Reset*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_APBPeriphIdleConfig 
* Description    : Enable or Disable Periph Clock during Idle mode 
* Input          : -APBPeriph: APB peripherals(__RTC, __ADC,...) 
                   -NewState : ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_APBPeriphIdleConfig(u32 APBPeriph, FunctionalState NewState) 
{ 
  if (NewState==ENABLE) 
  SCU->MGR1 |=APBPeriph;      /*APB peripheral clock enabled during Idle mode*/ 
  else 
  SCU->MGR1 &=~APBPeriph;     /*APB peripheral clock disabled during Idle mode*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_AHBPeriphIdleConfig 
* Description    : Enable or Disable Periph Clock during Idle mode 
* Input          : -AHBPeriph: AHB peripherals(__USB, __DMA,...) 
                   -NewState : ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_AHBPeriphIdleConfig(u32 AHBPeriph, FunctionalState NewState) 
{ 
  if (NewState==ENABLE) 
  SCU->MGR0 |=AHBPeriph;      /*AHB peripheral clock enabled during Idle mode*/ 
  else 
  SCU->MGR0 &=~AHBPeriph;     /*AHB peripheral clock disabled during Idle mode*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_APBPeriphDebugConfig 
* Description    : Enable or Disable Periph Clock during ARM debug state 
* Input          : -APBPeriph: APB peripherals(__RTC, __ADC,...) 
                   -NewState : ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_APBPeriphDebugConfig(u32 APBPeriph, FunctionalState NewState) 
{ 
  if (NewState==ENABLE) 
  SCU->PECGR1 |=APBPeriph;    /*APB peripheral clock enabled during ARM debug state*/ 
  else 
  SCU->PECGR1 &=~APBPeriph;   /*APB peripheral clock disabled during ARM debug state*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_AHBPeriphDebugConfig 
* Description    : Enable or Disable Periph Clock during ARM debug state 
* Input          : -AHBPeriph: AHB peripherals(__USB, __DMA,...) 
                   -NewState : ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_AHBPeriphDebugConfig(u32 AHBPeriph, FunctionalState NewState) 
{ 
  if (NewState==ENABLE) 
  SCU->PECGR0 |=AHBPeriph;    /*AHB peripheral clock enabled during ARM debug state*/ 
  else 
  SCU->PECGR0 &=~AHBPeriph;   /*AHB peripheral clock disabled during ARM debug state*/ 
} 
/******************************************************************************* 
* Function Name  : SCU_BRCLKDivisorConfig 
* Description    : Sets the BRCLK divisor value 
* Input          : BRCLK_Divisor 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_BRCLKDivisorConfig(u32 BRCLK_Divisor) 
{ 
  SCU->CLKCNTR &=SCU_BRCLK_Div1;              /*Clear BRSEL bit*/ 
  if (BRCLK_Divisor!=SCU_BRCLK_Div1) 
  SCU->CLKCNTR |= SCU_BRCLK_Div2;             /*set bit BRSEL*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_TIMCLKSourceConfig 
* Description    : Sets the TIMx clock source 
* Input          : - TIMx : SCU_TIM01 or SCU_TIM23 
*                  - TIMCLK_Source = SCU_TIMCLK_EXT or SCU_TIMCLK_INT 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_TIMCLKSourceConfig(u8 TIMx, u32 TIMCLK_Source) 
{ 
  if (TIMx== SCU_TIM01)                     /*TIM01 clock source configuration*/ 
  { 
    SCU->CLKCNTR &=0xFFFFDFFF; 
    if (TIMCLK_Source == SCU_TIMCLK_EXT) 
    SCU->CLKCNTR |=0x2000; 
  } 
  else 
  { 
    SCU->CLKCNTR &=0xFFFFBFFF;            /*TIM23 clock source configuration*/ 
    if (TIMCLK_Source == SCU_TIMCLK_EXT) 
    SCU->CLKCNTR |=0x4000; 
  } 
} 
 
/******************************************************************************* 
* Function Name  : SCU_TIMPresConfig 
* Description    : Sets the TIMx Prescaler Value 
* Input          : - TIMx : SCU_TIM01 or SCU_TIM23 
*                  - Prescaler (16 bit value) 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_TIMPresConfig(u8 TIMx, u16 Prescaler) 
{ 
  if (TIMx==SCU_TIM01)                     /*TIM01 Prescaler configuration*/ 
  SCU->SCR1 = Prescaler&0xFFFF; 
  else 
  SCU->SCR2 = Prescaler&0xFFFF;            /*TIM23 Prescaler configuration*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_USBCLKConfig 
* Description    : Configures the clock source for the 48MHz USBCLK 
* Input          : USBCLK_Source: SCU_USBCLK_MCLK,SCU_USBCLK_MCLK2 or SCU_USBCLK_EXT 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_USBCLKConfig(u32 USBCLK_Source) 
{ 
  SCU->CLKCNTR &=SCU_USBCLK_MCLK;            /*clear USBSEL[1:0] field*/ 
  if (USBCLK_Source!=SCU_USBCLK_MCLK) 
  SCU->CLKCNTR |= USBCLK_Source;             /*update field with USBCLK_Source*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_PHYCLKConfig 
* Description    : Enable or Disable PHY clock output 
* Input          : NewState : ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_PHYCLKConfig(FunctionalState NewState) 
{ 
  if (NewState==ENABLE) 
  SCU->CLKCNTR |= 0x1000;                    /*enable MIIPHY clock*/ 
  else 
  SCU->CLKCNTR &=~0x1000;                    /*disable MIIPHY clock*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_FMICLKDivisorConfig 
* Description    : Set the FMI clock divisor 
* Input          : FMICLK_Divisor: SCU_FMICLK_Div1 or SCU_FMICLK_DIV2 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_FMICLKDivisorConfig(u32 FMICLK_Divisor) 
{ 
  SCU->CLKCNTR &=SCU_FMICLK_Div1;            /*FMICLK = RCLK*/ 
  if (FMICLK_Divisor!=SCU_FMICLK_Div1) 
  SCU->CLKCNTR |=SCU_FMICLK_Div2;            /*FMICLK = RCLK/2 */ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_EMIBCLKDivisorConfig 
* Description    : Set the EMI Bus clock divisor: EMIBCLK = HCLK or HCLK/2 
* Input          : SCU_EMICLK: SCU_EMIBCLK_Div1 , SCU_EMIBCLK_Div2 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_EMIBCLKDivisorConfig(u32 SCU_EMIBCLK) 
{ 
  SCU->CLKCNTR &=SCU_EMIBCLK_Div1;          /*EMIBCLK = HCLK */ 
  if (SCU_EMIBCLK!=SCU_EMIBCLK_Div1) 
  SCU->CLKCNTR |= SCU_EMIBCLK_Div2;         /*EMIBCLK = HCLK/2 */ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_EMIModeConfig 
* Description    : Configure the EMI as Multiplexed or Demultiplexed 
* Input          : SCU_EMIMODE : SCU_EMI_MUX or SCU_EMI_DEMUX 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_EMIModeConfig(u32 SCU_EMIMODE) 
{ 
  SCU->SCR0 &=SCU_EMI_MUX;                 /*EMI mode = Multiplexed*/ 
  if (SCU_EMIMODE!=SCU_EMI_MUX) 
  SCU->SCR0 |= SCU_EMI_DEMUX;                /*EMI mode = Demultiplexed*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_EMIALEConfig 
* Description    : Configure the ALE signal (length & polarity) 
* Input          : -SCU_EMIALE_LEN : SCU_EMIALE_LEN1 or SCU_EMIALE_LEN2 
*                  -SCU_EMIALE_POL : SCU_EMIALE_POLLow or SCU_EMI_POLHigh 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_EMIALEConfig(u32 SCU_EMIALE_LEN, u32 SCU_EMIALE_POL) 
{ 
  /*Configure EMI ALE Length*/ 
  SCU->SCR0 &=SCU_EMIALE_LEN1; 
  if (SCU_EMIALE_LEN!=SCU_EMIALE_LEN1) 
  SCU->SCR0 |= SCU_EMIALE_LEN2; 
 
  /*Configure EMI ALE POL*/ 
  SCU->SCR0 &=SCU_EMIALE_POLLow; 
  if (SCU_EMIALE_POL!=SCU_EMIALE_POLLow) 
  SCU->SCR0 |= SCU_EMIALE_POLHigh; 
} 
 
/******************************************************************************* 
* Function Name  : SCU_ITConfig 
* Description    : ENBALE or DISABLE an SCU interrupt 
* Input          : -SCU_IT:   interrupt mask 
*                  -NewState: ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_ITConfig(u32 SCU_IT, FunctionalState NewState) 
{ 
  if (NewState==ENABLE) 
  SCU->ITCMSK&=~SCU_IT;                    /*IT enable */ 
  else 
  SCU->ITCMSK|=SCU_IT;                     /*IT disable( mask)*/ 
} 
 
/******************************************************************************* 
* Function Name  : SCU_GetFlagStatus 
* Description    : Returns flag status 
* Input          : SCU_Flag 
* Output         : NONE 
* Return         : SET or RESET 
*******************************************************************************/ 
FlagStatus SCU_GetFlagStatus(u32 SCU_Flag) 
{ 
  if (SCU->SYSSTATUS&SCU_Flag) 
  return SET; 
  else return RESET; 
} 
 
/******************************************************************************* 
* Function Name  : SCU_ClearFlag 
* Description    : Clears a SYSTATUS Flag 
* Input          : SCU_Flag 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_ClearFlag(u32 SCU_Flag) 
{ 
  SCU->SYSSTATUS = SCU_Flag; 
} 
/******************************************************************************* 
* Function Name  : SCU_GetPLLfreqValue 
* Description    : Gets the current PLL frequency 
* Input          : None 
* Output         : None 
* Return         : PLL frequency (KHz) 
*******************************************************************************/ 
u32 SCU_GetPLLFreqValue(void) 
{ 
  u8 PLL_M; 
  u8 PLL_N; 
  u8 PLL_P; 
 
  PLL_M = SCU->PLLCONF&0xFF; 
  PLL_N = (SCU->PLLCONF&0xFF00)>>8; 
  PLL_P = (SCU->PLLCONF&0x70000)>>16; 
 
  if ((PLL_M>0)&&(PLL_N>0)) 
  return (u32)(((_Main_Crystal*2)*PLL_N)/(PLL_M<<PLL_P)); 
 
  else return 0; 
} 
/******************************************************************************* 
* Function Name  : SCU_GetMCLKFreqValue 
* Description    : Gets the current MCLK frequency 
* Input          : None 
* Output         : None 
* Return         : MCLK frequency (KHz) 
*******************************************************************************/ 
u32 SCU_GetMCLKFreqValue(void) 
{ 
  if ((SCU->CLKCNTR&0x3) == 0x2) return (u32)(_Main_Crystal); 
  if ((SCU->CLKCNTR&0x3) == 0x1) return (u32)(32); 
  else return (SCU_GetPLLFreqValue()); 
} 
 
/******************************************************************************* 
* Function Name  : SCU_GetRCLKFreqValue 
* Description    : Gets the current RCLK frequency 
* Input          : None 
* Output         : None 
* Return         : RCLK frequency (KHz) 
*******************************************************************************/ 
u32 SCU_GetRCLKFreqValue(void) 
{ 
  u8 RCLK_Div; 
  RCLK_Div = (SCU->CLKCNTR&0x1C)>>2; 
  if (RCLK_Div==0x5) RCLK_Div=10; 
  return (u32)(SCU_GetMCLKFreqValue() >>RCLK_Div); 
} 
 
/******************************************************************************* 
* Function Name  : SCU_GetHCLKFreqValue 
* Description    : Gets the current PCLK frequency 
* Input          : None 
* Output         : None 
* Return         : HCLK frequency (KHz) 
*******************************************************************************/ 
u32 SCU_GetHCLKFreqValue(void) 
{ 
  u8 HCLK_Div; 
  HCLK_Div = (SCU->CLKCNTR&0x60)>>5; 
  return (u32)(SCU_GetRCLKFreqValue() >>HCLK_Div); 
} 
 
/******************************************************************************* 
* Function Name  : SCU_GetPCLKFreqValue 
* Description    : Gets the current HCLK frequency 
* Input          : None 
* Output         : None 
* Return         : PCLK frequency (KHz) 
*******************************************************************************/ 
u32 SCU_GetPCLKFreqValue(void) 
{ 
  u8 PCLK_Div; 
  PCLK_Div = (SCU->CLKCNTR&0x180)>>7; 
  return (u32)(SCU_GetRCLKFreqValue() >>PCLK_Div); 
} 
 
/******************************************************************************* 
* Function Name  : SCU_WakeUpLineConfig 
* Description    : Configures an External interrupt as WakeUp line 
* Input          : EXTint : 0 -> 31 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_WakeUpLineConfig(u8 EXTint) 
{ 
  if (EXTint < 8) 
  { 
    SCU->WKUPSEL&=~0x7; 
    SCU->WKUPSEL|=EXTint; 
  } 
  else if (EXTint<16) 
  { 
    SCU->WKUPSEL&=~0x38; 
    SCU->WKUPSEL|=(EXTint-8)<<3; 
  } 
  else if (EXTint<24) 
  { 
    SCU->WKUPSEL&=~0x1C0; 
    SCU->WKUPSEL|=(EXTint-16)<<6; 
  } 
  else 
  { 
    SCU->WKUPSEL&=~0xE00; 
    SCU->WKUPSEL|=(EXTint-24)<<9; 
  } 
} 
 
/******************************************************************************* 
* Function Name  : SCU_SpecIntRunModeConfig 
* Description    : Enables or Disables the Special Run mode 
* Input          : newstate = ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_SpecIntRunModeConfig(FunctionalState NewState) 
{ 
  if (NewState == ENABLE) 
  SCU->PWRMNG |=0x8; 
  else 
  SCU->PWRMNG &=~0x8; 
} 
/******************************************************************************* 
* Function Name  : SCU_EnterIdleMode 
* Description    : Enters in Idle mode 
* Input          : None 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_EnterIdleMode(void) 
{ 
  SCU->PWRMNG |=0x1; 
} 
/******************************************************************************* 
* Function Name  : SCU_EnterSleepMode 
* Description    : Enters in Sleep mode 
* Input          : None 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_EnterSleepMode(void) 
{ 
  SCU->PWRMNG |=0x2; 
} 
 
/******************************************************************************* 
* Function Name  : SCU_UARTIrDAConfig 
* Description    : Enable or Disable the Irda mode for UARTx 
* Input          : - UARTx :x=0,1 or 2 
*                  - UART_IrDA_Mode : SCU_UARTMode_IrDA or SCU_UARTMode_UART 
* Output         :  None 
* Return         :  None 
*******************************************************************************/ 
void SCU_UARTIrDASelect(UART_TypeDef * UARTx, u8 UART_IrDA_Mode) 
{ 
  if (UART_IrDA_Mode == SCU_UARTMode_IrDA) 
  { 
    if (UARTx== UART0) SCU->SCR0 |=0x400; 
    else if (UARTx==UART1) SCU->SCR0 |=0x800; 
    else SCU->SCR0 |=0x1000; 
  } 
  else 
  { 
    if (UARTx== UART0) SCU->SCR0 &=~0x400; 
    else if (UARTx==UART1) SCU->SCR0 &=~0x800; 
    else SCU->SCR0 &=~0x1000; 
  } 
} 
/******************************************************************************* 
* Function Name  : SCU_PFQBCCmd 
* Description    : Enable or Disable PFQBC 
* Input          : NewState : ENABLE or DISABLE 
* Output         : None 
* Return         : None 
*******************************************************************************/ 
void SCU_PFQBCCmd(FunctionalState NewState) 
{ 
  if (NewState==ENABLE) 
  SCU->SCR0 |=0x1; 
  else SCU->SCR0 &=~0x1; 
} 
 
/******************* (C) COPYRIGHT 2006 STMicroelectronics *****END OF FILE****/