91x_scu.c

STR912 arm9实现的以太网通信程序

* 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          : - SCU_UARTx :x=0,1 or 2
*                  - UART_IrDA_Mode : SCU_UARTMode_IrDA or SCU_UARTMode_UART
* Output         :  None
* Return         :  None
*******************************************************************************/
void SCU_UARTIrDASelect(u8 SCU_UARTx, u8 UART_IrDA_Mode)
{
  if (UART_IrDA_Mode == SCU_UARTMode_IrDA)
  {
    if (SCU_UARTx== SCU_UART0) SCU->SCR0 |=0x400;
    else if (SCU_UARTx== SCU_UART1) SCU->SCR0 |=0x800;
    else SCU->SCR0 |=0x1000;
  }
  else
  {
    if (SCU_UARTx== SCU_UART0) SCU->SCR0 &=~0x400;
    else if (SCU_UARTx== SCU_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;
}


/*******************************************************************************
* Function Name  : SCU_EMIByte_Select_Pinconfig
* Description    : Enable or Disable the Byte selection pins behaviour(LFBGA only)
* Input          : NewState : ENABLE or DISABLE
* Output         : None
* Return         : None
*******************************************************************************/
void SCU_EMIByte_Select_Pinconfig(FunctionalState NewState)
{
 if (NewState==ENABLE)
  SCU->GPIOEMI |= 0x04;                    
  else
  SCU->GPIOEMI &=~0x04;  
 
 }
 
/*******************************************************************************
* Function Name  : SCU_EMIclock_Pinconfig
* Description    : Enable or Disable the BCLK pin clock driving (LFBGA only)
* Input          : NewState : ENABLE or DISABLE
* Output         : None
* Return         : None
*******************************************************************************/

void SCU_EMIclock_Pinconfig(FunctionalState NewState)
{
 if (NewState==DISABLE)
  SCU->GPIOEMI |= 0x02;                    
  else
  SCU->GPIOEMI &=~0x02;  
 
 }


/******************* (C) COPYRIGHT 2007 STMicroelectronics *****END OF FILE****/