| /******************** (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****/ |