You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
662 lines
26 KiB
C
662 lines
26 KiB
C
19 years ago
|
/******************** (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****/
|