git.sur5r.net Git - freertos/blob - Demo/ARM7_STR75x_IAR/STLibrary/src/75x_mrcc.c

   1 /******************** (C) COPYRIGHT 2006 STMicroelectronics ********************\r
   2 * File Name          : 75x_mrcc.c\r
   3 * Author             : MCD Application Team\r
   4 * Date First Issued  : 03/10/2006\r
   5 * Description        : This file provides all the MRCC software functions.\r
   6 ********************************************************************************\r
   7 * History:\r
   8 * 07/17/2006 : V1.0\r
   9 * 03/10/2006 : V0.1\r
  10 ********************************************************************************\r
  11 * THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS\r
  12 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.\r
  13 * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,\r
  14 * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE\r
  15 * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING\r
  16 * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.\r
  17 *******************************************************************************/\r
  18 \r
  19 /* Includes ------------------------------------------------------------------*/\r
  20 #include "75x_mrcc.h"\r
  21 \r
  22 /* Private typedef -----------------------------------------------------------*/\r
  23 /* Private define ------------------------------------------------------------*/\r
  24 #define MRCC_FLAG_Mask    0x1F    /* MRCC Flag Mask */\r
  25 \r
  26 /* MRCC_PWRCTRL mask bits */\r
  27 #define MRCC_LP_Set_Mask             0x00000001\r
  28 #define MRCC_LP_Reset_Mask           0xFFFFFFFE\r
  29 #define MRCC_SWRESET_Mask            0x00000002\r
  30 #define MRCC_WFI_Mask                0x00000004\r
  31 #define MRCC_STANDBY_Mask            0x00000006\r
  32 #define MRCC_LPMC_Reset_Mask         0xFFFFFFF9\r
  33 #define MRCC_LPDONE_Reset_Mask       0xFFFFFF7F\r
  34 #define MRCC_LPPARAM_Reset_Mask      0xFFFF1FFF\r
  35 #define MRCC_WFIParam_Reset_Mask     0xFFFF1FEF\r
  36 #define MRCC_CKRTCSEL_Set_Mask       0x03000000\r
  37 #define MRCC_CKRTCSEL_Reset_Mask     0xFCFFFFFF\r
  38 #define MRCC_CKRTCOK_Mask            0x08000000\r
  39 #define MRCC_LPOSCEN_Mask            0x10000000\r
  40 #define MRCC_OSC32KEN_Mask           0x20000000\r
  41             \r
  42 /* MRCC_CLKCTL mask bits */\r
  43 #define MRCC_PPRESC_Set_Mask        0x00000003\r
  44 #define MRCC_PPRESC_Reset_Mask      0xFFFFFFFC\r
  45 #define MRCC_PPRESC2_Mask           0x00000004\r
  46 #define MRCC_HPRESC_Set_Mask        0x00000018\r
  47 #define MRCC_HPRESC_Reset_Mask      0xFFFFFFE7\r
  48 #define MRCC_MCOS_Reset_Mask        0xFFFFFF3F\r
  49 #define MRCC_XTDIV2_Set_Mask        0x00008000\r
  50 #define MRCC_XTDIV2_Reset_Mask      0xFFFF7FFF\r
  51 #define MRCC_OSC4MBYP_Set_Mask      0x00010000\r
  52 #define MRCC_OSC4MBYP_Reset_Mask    0xFFFEFFFF\r
  53 #define MRCC_OSC4MOFF_Set_Mask      0x00020000  \r
  54 #define MRCC_OSC4MOFF_Reset_Mask    0xFFFDFFFF\r
  55 #define MRCC_NCKDF_Set_Mask         0x00040000\r
  56 #define MRCC_NCKDF_Reset_Mask       0xFFFBFFFF\r
  57 #define MRCC_CKOSCSEL_Set_Mask      0x00200000\r
  58 #define MRCC_CKOSCSEL_Reset_Mask    0xFFDFFFFF\r
  59 #define MRCC_CKUSBSEL_Mask          0x00400000\r
  60 #define MRCC_CKSEL_Set_Mask         0x00800000\r
  61 #define MRCC_CKSEL_Reset_Mask       0xFF7FFFFF\r
  62 #define MRCC_CKSEL_CKOSCSEL_Mask    0x00A00000\r
  63 #define MRCC_PLLEN_Set_Mask         0x01000000\r
  64 #define MRCC_PLLEN_Reset_Mask       0xFEFFFFFF\r
  65 #define MRCC_PLL2EN_Set_Mask        0x02000000\r
  66 #define MRCC_PLL2EN_Reset_Mask      0xFDFFFFFF\r
  67 #define MRCC_MX_Set_Mask            0x18000000\r
  68 #define MRCC_MX_Reset_Mask          0xE7FFFFFF\r
  69 #define MRCC_LOCK_Mask              0x80000000\r
  70 #define MRCC_PLLEN_LOCK_Mask        0x81000000\r
  71 \r
  72 /* Typical Value of the OSC4M in Hz */\r
  73 #define OSC4M_Value    4000000   \r
  74 \r
  75 /* Typical Value of the OSC4M divided by 128 (used to clock the RTC) in Hz */\r
  76 #define OSC4M_Div128_Value    31250\r
  77    \r
  78 /* Typical Value of the OS32K Oscillator Frequency in Hz */\r
  79 #define OSC32K_Value    32768     \r
  80 \r
  81 /* Typical Reset Value of the Internal LPOSC Oscillator Frequency in Hz */\r
  82 #define LPOSC_Value    245000   \r
  83 \r
  84 /* Typical Reset Value of the Internal FREEOSC Oscillator Frequency in Hz */\r
  85 #define FREEOSC_Value    5000000 \r
  86 \r
  87 /* Time out for OSC4M start up */\r
  88 #define OSC4MStartUp_TimeOut   0xFE\r
  89 \r
  90 /* Private macro -------------------------------------------------------------*/\r
  91 /* Private variables ---------------------------------------------------------*/\r
  92 /* Private function prototypes -----------------------------------------------*/\r
  93 static ErrorStatus SetCKSYS_FREEOSC(void);\r
  94 static ErrorStatus SetCKSYS_OSC4M(u32 PLL_State);\r
  95 static ErrorStatus SetCKSYS_OSC4MPLL(u32 PLL_Mul);\r
  96 static ErrorStatus SetCKSYS_RTC(u32 PLL_State);\r
  97 static void WriteLPBit(void);\r
  98 static void WriteCKOSCSELBit(void);\r
  99 \r
 100 /* Private functions ---------------------------------------------------------*/\r
 101 \r
 102 /*******************************************************************************\r
 103 * Function Name  : MRCC_DeInit\r
 104 * Description    : Deinitializes the MRCC peripheral registers to their default\r
 105 *                  reset values. \r
 106 *                   - Depending on the system clock state, some bits in MRCC_CLKCTL\r
 107 *                     register can\92t be reset.\r
 108 *                   - The OSC32K, LPOSC and RTC clock selection configuration \r
 109 *                     bits in MRCC_PWRCTRL register are not cleared by this  \r
 110 *                     function. To reset those bits, use the dedicated functions \r
 111 *                     available within this driver.\r
 112 *                   - The MRCC_RFSR, MRCC_BKP0 and MRCC_BKP1 registers are not\r
 113 *                     reset by this function.\r
 114 * Input          : None\r
 115 * Output         : None\r
 116 * Return         : None\r
 117 *******************************************************************************/\r
 118 void MRCC_DeInit(void)\r
 119 {\r
 120   /* Try to clear NCKDF bit */\r
 121   MRCC->CLKCTL &= MRCC_NCKDF_Reset_Mask;\r
 122 \r
 123   if((MRCC->CLKCTL & MRCC_NCKDF_Set_Mask) != RESET)\r
 124   {/* No clock detected on OSC4M */\r
 125 \r
 126     /* Reset LOCKIE, LOCKIF, CKUSBSEL, NCKDIE, OSC4MOFF, OSC4MBYP, MCOS[1:0], \r
 127        MCOP, HPRESC[1:0], PPRES[2:0] bits */\r
 128     MRCC->CLKCTL &= 0x9FB40000;\r
 129      \r
 130     if((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET)\r
 131     { \r
 132       /* Clear CKOSCSEL bit --------------------------------------------------*/         \r
 133       /* Execute CKOSCSEL bit writing sequence */\r
 134       WriteCKOSCSELBit();\r
 135     }\r
 136   }\r
 137   else\r
 138   {/* Clock present on OSC4M */\r
 139 \r
 140     if((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET)\r
 141     { \r
 142       /* Reset CKSEL bit */\r
 143       MRCC->CLKCTL &= MRCC_CKSEL_Reset_Mask;\r
 144 \r
 145       /* Clear CKOSCSEL bit --------------------------------------------------*/\r
 146       /* Execute CKOSCSEL bit writing sequence */\r
 147       WriteCKOSCSELBit();\r
 148     }\r
 149 \r
 150     if((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) == RESET)\r
 151     {\r
 152       /* Set CKSEL bit */\r
 153       MRCC->CLKCTL |= MRCC_CKSEL_Set_Mask;  \r
 154     }\r
 155 \r
 156     /* Disable PLL */\r
 157     MRCC->CLKCTL &= MRCC_PLLEN_Reset_Mask;\r
 158 \r
 159     /* Reset LOCKIE, LOCKIF, MX[1:0], CKUSBSEL, NCKDIE, MCOS[1:0], MCOP,\r
 160        HPRESC[1:0], PPRES[2:0] bits */\r
 161     MRCC->CLKCTL &= 0x87B70000;\r
 162 \r
 163     /* Reset CKSEL bit */\r
 164     MRCC->CLKCTL &= MRCC_CKSEL_Reset_Mask;\r
 165 \r
 166     /* Reset OSC4MOFF and OSC4MBYP bits */\r
 167     MRCC->CLKCTL &= 0xFFFCFFFF;   \r
 168   }\r
 169 \r
 170   /* Reset RTCM, EN33V, LP_PARAM[15:13], WFI_FLASH_EN, LPMC_DBG and LPMC[1:0] bits */\r
 171   MRCC->PWRCTRL &= 0xFBFE1FE1;\r
 172   \r
 173   /* Reset PCLKEN register bits */\r
 174   MRCC->PCLKEN = 0x00;\r
 175   \r
 176   /* Reset PSWRES register bits */\r
 177   MRCC->PSWRES = 0x00;  \r
 178 \r
 179   /* Clear NCKDF bit */\r
 180   MRCC->CLKCTL &= MRCC_NCKDF_Reset_Mask; \r
 181 }\r
 182 \r
 183 /*******************************************************************************\r
 184 * Function Name  : MRCC_XTDIV2Config\r
 185 * Description    : Enables or disables the oscillator divider by 2. This function\r
 186 *                  must not be used when the PLL is enabled.\r
 187 * Input          : - MRCC_XTDIV2: specifies the new state of the oscillator \r
 188 *                    divider by 2.\r
 189 *                    This parameter can be one of the following values:\r
 190 *                          - MRCC_XTDIV2_Disable: oscillator divider by 2 disbaled\r
 191 *                          - MRCC_XTDIV2_Enable: oscillator divider by 2 enbaled\r
 192 * Output         : None\r
 193 * Return         : None\r
 194 *******************************************************************************/\r
 195 void MRCC_XTDIV2Config(u32 MRCC_XTDIV2)\r
 196 {\r
 197   if(MRCC_XTDIV2 == MRCC_XTDIV2_Enable)\r
 198   {\r
 199     MRCC->CLKCTL |= MRCC_XTDIV2_Enable;\r
 200   }\r
 201   else\r
 202   {\r
 203     MRCC->CLKCTL &= MRCC_XTDIV2_Disable;\r
 204   }  \r
 205 }\r
 206 \r
 207 /*******************************************************************************\r
 208 * Function Name  : MRCC_CKSYSConfig\r
 209 * Description    : Configures the system clock (CK_SYS).\r
 210 * Input          : - MRCC_CKSYS: specifies the clock source used as system clock.\r
 211 *                    This parameter can be one of the following values:\r
 212 *                          - MRCC_CKSYS_FREEOSC\r
 213 *                          - MRCC_CKSYS_OSC4M\r
 214 *                          - MRCC_CKSYS_OSC4MPLL\r
 215 *                          - MRCC_CKSYS_RTC (RTC clock source must be previously\r
 216 *                            configured using MRCC_CKRTCConfig() function)\r
 217 *                : - MRCC_PLL: specifies the PLL configuration.\r
 218 *                    This parameter can be one of the following values:\r
 219 *                          - MRCC_PLL_Disabled: PLL disabled\r
 220 *                          - MRCC_PLL_NoChange: No change on PLL configuration\r
 221 *                          - MRCC_PLL_Mul_12: Multiplication by 12\r
 222 *                          - MRCC_PLL_Mul_14: Multiplication by 14\r
 223 *                          - MRCC_PLL_Mul_15: Multiplication by 15\r
 224 *                          - MRCC_PLL_Mul_16: Multiplication by 16\r
 225 * Output         : None\r
 226 * Return         : An ErrorStatus enumuration value:\r
 227 *                         - SUCCESS: Clock configuration succeeded\r
 228 *                         - ERROR: Clock configuration failed\r
 229 *******************************************************************************/\r
 230 ErrorStatus MRCC_CKSYSConfig(u32 MRCC_CKSYS, u32 MRCC_PLL)\r
 231 {\r
 232   ErrorStatus Status = ERROR;\r
 233 \r
 234   switch(MRCC_CKSYS)\r
 235   {\r
 236     case MRCC_CKSYS_FREEOSC:\r
 237       if((MRCC_PLL == MRCC_PLL_Disabled) || (MRCC_PLL == MRCC_PLL_NoChange))\r
 238       {\r
 239         Status = SetCKSYS_FREEOSC();\r
 240       }\r
 241       break;\r
 242 \r
 243     case MRCC_CKSYS_OSC4M:\r
 244       if((MRCC_PLL == MRCC_PLL_Disabled) || (MRCC_PLL == MRCC_PLL_NoChange))\r
 245       {\r
 246         Status = SetCKSYS_OSC4M(MRCC_PLL);\r
 247       }\r
 248       break;\r
 249 \r
 250     case MRCC_CKSYS_OSC4MPLL:\r
 251       if((MRCC_PLL == MRCC_PLL_Mul_12) || (MRCC_PLL == MRCC_PLL_Mul_14) ||\r
 252          (MRCC_PLL == MRCC_PLL_Mul_15) || (MRCC_PLL == MRCC_PLL_Mul_16))\r
 253       {\r
 254         Status = SetCKSYS_OSC4MPLL(MRCC_PLL);\r
 255       }\r
 256       break;\r
 257 \r
 258     case MRCC_CKSYS_RTC:\r
 259       if((MRCC_PLL == MRCC_PLL_Disabled) || (MRCC_PLL == MRCC_PLL_NoChange))\r
 260       {    \r
 261         Status = SetCKSYS_RTC(MRCC_PLL);\r
 262       }\r
 263       break;\r
 264 \r
 265     default:\r
 266       Status = ERROR;\r
 267       break;\r
 268   }\r
 269   return Status;\r
 270 }\r
 271 \r
 272 /*******************************************************************************\r
 273 * Function Name  : MRCC_HCLKConfig\r
 274 * Description    : Configures the AHB clock (HCLK).\r
 275 * Input          : - MRCC_HCLK: defines the AHB clock. This clock is derived\r
 276 *                    from the system clock(CK_SYS).\r
 277 *                    This parameter can be one of the following values:\r
 278 *                          - MRCC_CKSYS_Div1: AHB clock = CK_SYS\r
 279 *                          - MRCC_CKSYS_Div2: AHB clock = CK_SYS/2\r
 280 *                          - MRCC_CKSYS_Div4: AHB clock = CK_SYS/4\r
 281 *                          - MRCC_CKSYS_Div8: AHB clock = CK_SYS/8\r
 282 * Output         : None\r
 283 * Return         : None\r
 284 *******************************************************************************/\r
 285 void MRCC_HCLKConfig(u32 MRCC_HCLK)\r
 286 {\r
 287   u32 Temp = 0;\r
 288   \r
 289   /* Clear HPRESC[1:0] bits */\r
 290   Temp = MRCC->CLKCTL & MRCC_HPRESC_Reset_Mask;\r
 291   \r
 292   /* Set HPRESC[1:0] bits according to MRCC_HCLK value */\r
 293   Temp |= MRCC_HCLK;\r
 294   \r
 295   /* Store the new value */\r
 296   MRCC->CLKCTL = Temp;  \r
 297 }\r
 298 \r
 299 /*******************************************************************************\r
 300 * Function Name  : MRCC_CKTIMConfig\r
 301 * Description    : Configures the TIM clock (CK_TIM).\r
 302 * Input          : - MRCC_CKTIM: defines the TIM clock. This clock is derived\r
 303 *                    from the AHB clock(HCLK).\r
 304 *                    This parameter can be one of the following values:\r
 305 *                          - MRCC_HCLK_Div1: TIM clock = HCLK\r
 306 *                          - MRCC_HCLK_Div2: TIM clock = HCLK/2\r
 307 *                          - MRCC_HCLK_Div4: TIM clock = HCLK/4\r
 308 *                          - MRCC_HCLK_Div8: TIM clock = HCLK/8\r
 309 * Output         : None\r
 310 * Return         : None\r
 311 *******************************************************************************/\r
 312 void MRCC_CKTIMConfig(u32 MRCC_CKTIM)\r
 313 {\r
 314   u32 Temp = 0;\r
 315   \r
 316   /* Clear PPRESC[1:0] bits */\r
 317   Temp = MRCC->CLKCTL & MRCC_PPRESC_Reset_Mask;\r
 318   \r
 319   /* Set PPRESC[1:0] bits according to MRCC_CKTIM value */\r
 320   Temp |= MRCC_CKTIM;\r
 321   \r
 322   /* Store the new value */\r
 323   MRCC->CLKCTL = Temp;\r
 324 }\r
 325 \r
 326 /*******************************************************************************\r
 327 * Function Name  : MRCC_PCLKConfig\r
 328 * Description    : Configures the APB clock (PCLK).\r
 329 * Input          : - MRCC_PCLK: defines the APB clock. This clock is derived \r
 330 *                    from the TIM clock(CK_TIM).\r
 331 *                    This parameter can be one of the following values:\r
 332 *                          - MRCC_CKTIM_Div1: APB clock = CKTIM\r
 333 *                          - MRCC_CKTIM_Div2: APB clock = CKTIM/2\r
 334 * Output         : None\r
 335 * Return         : None\r
 336 *******************************************************************************/\r
 337 void MRCC_PCLKConfig(u32 MRCC_PCLK)\r
 338 {\r
 339   if(MRCC_PCLK == MRCC_CKTIM_Div2)\r
 340   {\r
 341     MRCC->CLKCTL |= MRCC_CKTIM_Div2;\r
 342   }\r
 343   else\r
 344   {\r
 345     MRCC->CLKCTL &= MRCC_CKTIM_Div1;\r
 346   }\r
 347 }\r
 348 \r
 349 /*******************************************************************************\r
 350 * Function Name  : MRCC_CKRTCConfig\r
 351 * Description    : Configures the RTC clock (CK_RTC).\r
 352 * Input          : - MRCC_CKRTC: specifies the clock source to be used as RTC\r
 353 *                    clock.\r
 354 *                    This parameter can be one of the following values:\r
 355 *                          - MRCC_CKRTC_OSC4M_Div128\r
 356 *                          - MRCC_CKRTC_OSC32K (OSC32K must be previously enabled\r
 357 *                            using MRCC_OSC32KConfig() function)\r
 358 *                          - MRCC_CKRTC_LPOSC (LPOSC must be previously enabled\r
 359 *                            using MRCC_LPOSCConfig() function)\r
 360 * Output         : None\r
 361 * Return         : An ErrorStatus enumuration value:\r
 362 *                         - SUCCESS: Clock configuration succeeded\r
 363 *                         - ERROR: Clock configuration failed\r
 364 *******************************************************************************/\r
 365 ErrorStatus MRCC_CKRTCConfig(u32 MRCC_CKRTC)\r
 366 {\r
 367   u32 Tmp = 0;\r
 368 \r
 369   if(((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET) &&\r
 370      ((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) != RESET))\r
 371   { \r
 372     /* CK_RTC used as CK_SYS clock source */\r
 373     return ERROR;\r
 374   }\r
 375   else\r
 376   {    \r
 377     /* Clear CKRTCSEL[1:0] bits */\r
 378     Tmp = MRCC->PWRCTRL & MRCC_CKRTCSEL_Reset_Mask;\r
 379 \r
 380     /* Set CKRTCSEL[1:0] bits according to MRCC_CKRTC value */\r
 381     Tmp |= MRCC_CKRTC;\r
 382 \r
 383     /* Store the new value */\r
 384     MRCC->PWRCTRL = Tmp;       \r
 385   }\r
 386 \r
 387   return SUCCESS;\r
 388 }\r
 389 \r
 390 /*******************************************************************************\r
 391 * Function Name  : MRCC_CKUSBConfig\r
 392 * Description    : Configures the USB clock(CK_USB).\r
 393 * Input          : - MRCC_CKUSB: specifies the clock source to be used as USB\r
 394 *                    clock.\r
 395 *                    This parameter can be one of the following values:\r
 396 *                          - MRCC_CKUSB_Internal(CK_PLL2 enabled)\r
 397 *                          - MRCC_CKUSB_External(CK_PLL2 disabled)\r
 398 * Output         : None\r
 399 * Return         : An ErrorStatus enumuration value:\r
 400 *                         - SUCCESS: Clock configuration succeeded\r
 401 *                         - ERROR: Clock configuration failed\r
 402 *******************************************************************************/\r
 403 ErrorStatus MRCC_CKUSBConfig(u32 MRCC_CKUSB)\r
 404 {\r
 405   if(MRCC_CKUSB == MRCC_CKUSB_External)\r
 406   {\r
 407     /* Disable CK_PLL2 */\r
 408     MRCC->CLKCTL &= MRCC_PLL2EN_Reset_Mask;\r
 409 \r
 410     /* External USB clock selected */\r
 411     MRCC->CLKCTL |= MRCC_CKUSB_External;\r
 412   }\r
 413   else\r
 414   {\r
 415     if((MRCC->CLKCTL & MRCC_PLLEN_LOCK_Mask) != RESET)\r
 416     { /* PLL enabled and locked */\r
 417       \r
 418       /* Enable CK_PLL2 */\r
 419       MRCC->CLKCTL |= MRCC_PLL2EN_Set_Mask;\r
 420 \r
 421       /* Internal USB clock selected */\r
 422       MRCC->CLKCTL &= MRCC_CKUSB_Internal;\r
 423     }\r
 424     else\r
 425     {\r
 426       /* PLL not enabled */\r
 427       return ERROR;\r
 428     }\r
 429   }\r
 430 \r
 431   return SUCCESS;  \r
 432 }\r
 433 \r
 434 /*******************************************************************************\r
 435 * Function Name  : MRCC_ITConfig\r
 436 * Description    : Enables or disables the specified MRCC interrupts.\r
 437 * Input          : - MRCC_IT: specifies the MRCC interrupts sources to be\r
 438 *                    enabled or disabled. This parameter can be any combination\r
 439 *                    of the following values:\r
 440 *                          - MRCC_IT_LOCK: PLL lock interrupt\r
 441 *                          - MRCC_IT_NCKD: No Clock detected interrupt\r
 442 *                  - NewState: new state of the MRCC interrupts.\r
 443 *                    This parameter can be: ENABLE or DISABLE.\r
 444 * Output         : None\r
 445 * Return         : None\r
 446 *******************************************************************************/\r
 447 void MRCC_ITConfig(u32 MRCC_IT, FunctionalState NewState)\r
 448 {\r
 449   if(NewState == ENABLE)\r
 450   {\r
 451     MRCC->CLKCTL |= MRCC_IT;\r
 452   }\r
 453   else\r
 454   {\r
 455     MRCC->CLKCTL &= ~MRCC_IT;\r
 456   }\r
 457 }\r
 458 \r
 459 /*******************************************************************************\r
 460 * Function Name  : MRCC_PeripheralClockConfig\r
 461 * Description    : Enables or disables the specified peripheral clock.\r
 462 * Input          : - MRCC_Peripheral: specifies the peripheral to gates its\r
 463 *                    clock. More than one peripheral can be selected using\r
 464 *                    the \93|\94 operator.\r
 465 *                  - NewState: new state of the specified peripheral clock.\r
 466 *                    This parameter can be one of the following values:\r
 467 *                          - ENABLE: the selected peripheral clock is enabled\r
 468 *                          - DISABLE: the selected peripheral clock is disabled\r
 469 * Output         : None\r
 470 * Return         : None\r
 471 *******************************************************************************/\r
 472 void MRCC_PeripheralClockConfig(u32 MRCC_Peripheral, FunctionalState NewState)\r
 473 {\r
 474   if(NewState == ENABLE)\r
 475   {\r
 476     MRCC->PCLKEN |= MRCC_Peripheral;\r
 477   }\r
 478   else\r
 479   {\r
 480     MRCC->PCLKEN &= ~MRCC_Peripheral;\r
 481   }\r
 482 }\r
 483 \r
 484 /*******************************************************************************\r
 485 * Function Name  : MRCC_PeripheralSWResetConfig\r
 486 * Description    : Forces or releases peripheral software reset.\r
 487 * Input          : - MRCC_Peripheral: specifies the peripheral to reset. More\r
 488 *                    than one peripheral can be selected using the \93|\94 operator.\r
 489 *                  - NewState: new state of the specified peripheral software\r
 490 *                    reset. This parameter can be one of the following values:\r
 491 *                          - ENABLE: the selected peripheral is kept under reset\r
 492 *                          - DISABLE: the selected peripheral exits from reset\r
 493 * Output         : None\r
 494 * Return         : None\r
 495 *******************************************************************************/\r
 496 void MRCC_PeripheralSWResetConfig(u32 MRCC_Peripheral, FunctionalState NewState)\r
 497 {\r
 498   if(NewState == ENABLE)\r
 499   {\r
 500     MRCC->PSWRES |= MRCC_Peripheral;\r
 501   }\r
 502   else\r
 503   {\r
 504     MRCC->PSWRES &= ~MRCC_Peripheral;\r
 505   }\r
 506 }\r
 507 \r
 508 /*******************************************************************************\r
 509 * Function Name  : MRCC_GetClocksStatus\r
 510 * Description    : Returns the status and frequencies of different on chip clocks.\r
 511 *                  Don\92t use this function when CK_SYS is clocked by an external\r
 512 *                  clock source (OSC4M bypassed).\r
 513 * Input          : - MRCC_ClocksStatus: pointer to a MRCC_ClocksTypeDef structure\r
 514 *                    which will hold the clocks information.\r
 515 * Output         : None\r
 516 * Return         : None\r
 517 *******************************************************************************/\r
 518 void MRCC_GetClocksStatus(MRCC_ClocksTypeDef*  MRCC_ClocksStatus)\r
 519 {\r
 520   u32 PLLMul = 0;\r
 521   u32 Temp = 0;\r
 522   u32 Presc = 0;\r
 523 \r
 524   /* Get the Status of PLL */\r
 525   if((MRCC->CLKCTL & MRCC_PLLEN_Set_Mask) == RESET)  \r
 526   {\r
 527     MRCC_ClocksStatus->PLL_Status = OFF;\r
 528   }\r
 529   else\r
 530   {\r
 531     MRCC_ClocksStatus->PLL_Status = ON;\r
 532   }\r
 533   \r
 534   /* Get the Status of OSC4M */\r
 535   if((MRCC->CLKCTL & MRCC_OSC4MOFF_Set_Mask) == RESET)  \r
 536   {\r
 537     MRCC_ClocksStatus->OSC4M_Status = ON;\r
 538   }\r
 539   else\r
 540   {\r
 541     MRCC_ClocksStatus->OSC4M_Status = OFF;\r
 542   }  \r
 543   \r
 544   /* Get the Status of LPOSC */\r
 545   if((MRCC->PWRCTRL & MRCC_LPOSCEN_Mask) == RESET)  \r
 546   {\r
 547     MRCC_ClocksStatus->LPOSC_Status = OFF;\r
 548   }\r
 549   else\r
 550   {\r
 551     MRCC_ClocksStatus->LPOSC_Status = ON;\r
 552   }  \r
 553   \r
 554   /* Get the Status of OSC32K */\r
 555   if((MRCC->PWRCTRL & MRCC_OSC32KEN_Mask) == RESET)  \r
 556   {\r
 557     MRCC_ClocksStatus->OSC32K_Status = OFF;\r
 558   }\r
 559   else\r
 560   {\r
 561     MRCC_ClocksStatus->OSC32K_Status = ON;\r
 562   } \r
 563     \r
 564 /* Get CKU_SB source ---------------------------------------------------------*/  \r
 565   if((MRCC->CLKCTL & MRCC_CKUSBSEL_Mask) != RESET)\r
 566   {\r
 567     MRCC_ClocksStatus->CKUSB_Source = External;    \r
 568   }\r
 569   else\r
 570   {  \r
 571     if((MRCC->CLKCTL & MRCC_PLL2EN_Set_Mask) != RESET)\r
 572     {\r
 573       MRCC_ClocksStatus->CKUSB_Source = Internal;\r
 574     \r
 575     }\r
 576     else \r
 577     {\r
 578       MRCC_ClocksStatus->CKUSB_Source = Disabled;    \r
 579     }\r
 580   }\r
 581 \r
 582 /* Get CK_RTC source ---------------------------------------------------------*/ \r
 583   Temp = MRCC->PWRCTRL & MRCC_CKRTCSEL_Set_Mask;\r
 584   Temp = Temp >> 24;\r
 585     \r
 586   switch(Temp)\r
 587   {\r
 588     case 0x00:\r
 589       MRCC_ClocksStatus->CKRTC_Source = Disabled;\r
 590       break;\r
 591 \r
 592     case 0x01:\r
 593       MRCC_ClocksStatus->CKRTC_Source = OSC4M_Div128;\r
 594       break;\r
 595 \r
 596     case 0x02:\r
 597       MRCC_ClocksStatus->CKRTC_Source = OSC32K;\r
 598       break;\r
 599         \r
 600     case 0x03:\r
 601       MRCC_ClocksStatus->CKRTC_Source = LPOSC;              \r
 602       break;\r
 603         \r
 604     default:\r
 605       MRCC_ClocksStatus->CKRTC_Source = Disabled;\r
 606       break;          \r
 607   }\r
 608       \r
 609 /* Get CK_SYS source ---------------------------------------------------------*/   \r
 610   if((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) != RESET)\r
 611   {/* CK_OSC used as CK_SYS clock source */\r
 612     \r
 613     if((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET)\r
 614     { /* CK_RTC used as CK_OSC clock source */\r
 615       MRCC_ClocksStatus->CKSYS_Source = CKRTC;\r
 616       \r
 617       if(MRCC_ClocksStatus->CKRTC_Source == OSC32K)\r
 618       {\r
 619         /* CK_SYS clock frequency */\r
 620         MRCC_ClocksStatus->CKSYS_Frequency = OSC32K_Value;         \r
 621       }         \r
 622       else if(MRCC_ClocksStatus->CKRTC_Source == LPOSC)\r
 623 \r
 624       {\r
 625         /* CK_SYS clock frequency */\r
 626         MRCC_ClocksStatus->CKSYS_Frequency = LPOSC_Value;             \r
 627       }\r
 628       else if(MRCC_ClocksStatus->CKRTC_Source == OSC4M_Div128)\r
 629 \r
 630       {\r
 631         /* CK_SYS clock frequency */\r
 632         MRCC_ClocksStatus->CKSYS_Frequency = OSC4M_Div128_Value;             \r
 633       }\r
 634     }\r
 635     else\r
 636     { /* OSC4M used as CK_OSC clock source */\r
 637       MRCC_ClocksStatus->CKSYS_Source = OSC4M; \r
 638     \r
 639       if((MRCC->CLKCTL & MRCC_XTDIV2_Set_Mask) != RESET)\r
 640       {\r
 641         /* CK_SYS clock frequency */\r
 642         MRCC_ClocksStatus->CKSYS_Frequency = Main_Oscillator >> 1;\r
 643       }\r
 644       else\r
 645       {\r
 646         /* CK_SYS clock frequency */\r
 647         MRCC_ClocksStatus->CKSYS_Frequency = Main_Oscillator;\r
 648       }          \r
 649     }\r
 650   }     \r
 651   else\r
 652   {/* CK_PLL1 used as CK_SYS clock */\r
 653     \r
 654     if(MRCC_ClocksStatus->PLL_Status == OFF)\r
 655     { /* FREEOSC used as CK_PLL1 clock source */\r
 656       MRCC_ClocksStatus->CKSYS_Source = FREEOSC; \r
 657       \r
 658       /* CK_SYS clock frequency */\r
 659       MRCC_ClocksStatus->CKSYS_Frequency = FREEOSC_Value;               \r
 660     }\r
 661     else\r
 662     { /* OSC4M followed by PLL used as CK_PLL1 clock source */\r
 663       MRCC_ClocksStatus->CKSYS_Source = OSC4MPLL;\r
 664                     \r
 665       /* Get PLL factor ------------------------------------------------------*/\r
 666       Temp = MRCC->CLKCTL & MRCC_MX_Set_Mask;\r
 667       Temp = Temp >> 27;\r
 668     \r
 669       switch(Temp)\r
 670       {\r
 671         case 0x00:\r
 672           PLLMul = 16;\r
 673           break;\r
 674 \r
 675         case 0x01:\r
 676           PLLMul = 15;\r
 677           break;\r
 678 \r
 679         case 0x02:\r
 680           PLLMul = 14;\r
 681           break;\r
 682         \r
 683         case 0x03:\r
 684           PLLMul = 12;\r
 685           break;\r
 686         \r
 687         default:\r
 688           PLLMul = 16;\r
 689           break;          \r
 690       } \r
 691       \r
 692       /* CK_SYS clock frequency */\r
 693       MRCC_ClocksStatus->CKSYS_Frequency = OSC4M_Value * PLLMul;     \r
 694     }\r
 695   }\r
 696 \r
 697 /* Compute HCLK, CKTIM and PCLK clocks frequencies ---------------------------*/    \r
 698   /* Get HCLK prescaler */\r
 699   Presc = MRCC->CLKCTL & MRCC_HPRESC_Set_Mask;\r
 700   Presc = Presc >> 3;\r
 701   /* HCLK clock frequency */\r
 702   MRCC_ClocksStatus->HCLK_Frequency = MRCC_ClocksStatus->CKSYS_Frequency >> Presc;\r
 703 \r
 704   /* Get CK_TIM prescaler */\r
 705   Presc = MRCC->CLKCTL & MRCC_PPRESC_Set_Mask;\r
 706   /* CK_TIM clock frequency */\r
 707   MRCC_ClocksStatus->CKTIM_Frequency = MRCC_ClocksStatus->HCLK_Frequency >> Presc;\r
 708  \r
 709   /* Get PCLK prescaler */\r
 710   Presc = MRCC->CLKCTL & MRCC_PPRESC2_Mask;\r
 711   Presc = Presc >> 2;\r
 712   /* PCLK clock frequency */\r
 713   MRCC_ClocksStatus->PCLK_Frequency = MRCC_ClocksStatus->CKTIM_Frequency >> Presc;\r
 714 }\r
 715 \r
 716 /*******************************************************************************\r
 717 * Function Name  : MRCC_LPMC_DBGonfig\r
 718 * Description    : Enables or disables the Low Power Debug Mode.\r
 719 * Input          : - MRCC_LPDM: specifies the LPDM new state value.\r
 720 *                    This parameter can be one of the following values:\r
 721 *                          - MRCC_LPDM_Disable\r
 722 *                          - MRCC_LPDM_Enable\r
 723 * Output         : None\r
 724 * Return         : None\r
 725 *******************************************************************************/\r
 726 void MRCC_LPMC_DBGConfig(u32 MRCC_LPDM)\r
 727 {\r
 728   if(MRCC_LPDM == MRCC_LPDM_Enable)\r
 729   {\r
 730     MRCC->PWRCTRL |= MRCC_LPDM_Enable;\r
 731   }\r
 732   else\r
 733   {\r
 734     MRCC->PWRCTRL &= MRCC_LPDM_Disable;\r
 735   }\r
 736 }\r
 737 \r
 738 /*******************************************************************************\r
 739 * Function Name  : MRCC_EnterWFIMode\r
 740 * Description    : Enters WFI mode.\r
 741 *                  If the Flash is used in Burst mode, it must be kept enabled\r
 742 *                  in WFI mode(use MRCC_WFIParam_FLASHOn as parameter)\r
 743 * Input          : - MRCC_WFIParam: specifies the WFI mode control parameters.\r
 744 *                    This parameter can be one of the following values:\r
 745 *                          - MRCC_WFIParam_FLASHPowerDown(DMA not allowed during WFI)\r
 746 *                          - MRCC_WFIParam_FLASHOn(DMA allowed during WFI)\r
 747 *                          - MRCC_WFIParam_FLASHOff(DMA not allowed during WFI)\r
 748 * Output         : None\r
 749 * Return         : None\r
 750 *******************************************************************************/\r
 751 void MRCC_EnterWFIMode(u32 MRCC_WFIParam)\r
 752 {\r
 753 /* Low Power mode configuration ----------------------------------------------*/\r
 754   /* Clear LPMC[1:0] bits */\r
 755    MRCC->PWRCTRL &= MRCC_LPMC_Reset_Mask;\r
 756 \r
 757   /* Select WFI mode */\r
 758   MRCC->PWRCTRL |= MRCC_WFI_Mask;\r
 759 \r
 760 /* Low Power mode control parameters configuration ---------------------------*/\r
 761   /* Clear LP_PARAM[15:13] and WFI_FLASH_EN bits */\r
 762   MRCC->PWRCTRL &= MRCC_WFIParam_Reset_Mask;\r
 763   \r
 764   if(MRCC_WFIParam != MRCC_WFIParam_FLASHPowerDown)\r
 765   {\r
 766     /* Set LP_PARAM[15:13] and WFI_FLASH_EN bits according to MRCC_WFIParam value */\r
 767     MRCC->PWRCTRL |= MRCC_WFIParam;\r
 768   }\r
 769     \r
 770 /* Execute the Low Power bit writing sequence --------------------------------*/\r
 771   WriteLPBit();\r
 772 }\r
 773 \r
 774 /*******************************************************************************\r
 775 * Function Name  : MRCC_EnterSTOPMode\r
 776 * Description    : Enters STOP mode.\r
 777 * Input          : - MRCC_STOPParam: specifies the STOP mode control parameters.\r
 778 *                    This parameter can be one of the following values:\r
 779 *                          - MRCC_STOPParam_Default (OSC4M On, FLASH On, MVREG On)\r
 780 *                          - MRCC_STOPParam_OSC4MOff\r
 781 *                          - MRCC_STOPParam_FLASHOff\r
 782 *                          - MRCC_STOPParam_MVREGOff\r
 783 * Output         : None\r
 784 * Return         : None\r
 785 *******************************************************************************/\r
 786 void MRCC_EnterSTOPMode(u32 MRCC_STOPParam)\r
 787 {\r
 788 /* Low Power mode configuration ----------------------------------------------*/\r
 789   /* Clear LPMC[1:0] bits (STOP mode is selected) */\r
 790    MRCC->PWRCTRL &= MRCC_LPMC_Reset_Mask;\r
 791 \r
 792 /* Low Power mode control parameters configuration ---------------------------*/\r
 793   /* Clear LP_PARAM[15:13] bits */\r
 794   MRCC->PWRCTRL &= MRCC_LPPARAM_Reset_Mask;\r
 795   \r
 796   if(MRCC_STOPParam != MRCC_STOPParam_Default)\r
 797   {\r
 798     /* Set LP_PARAM[15:13] bits according to MRCC_STOPParam value */\r
 799     MRCC->PWRCTRL |= MRCC_STOPParam;\r
 800   }\r
 801 \r
 802 /* Execute the Low Power bit writing sequence --------------------------------*/\r
 803   WriteLPBit();\r
 804 }\r
 805 \r
 806 /*******************************************************************************\r
 807 * Function Name  : MRCC_EnterSTANDBYMode\r
 808 * Description    : Enters STANDBY mode.\r
 809 *                  Make sure that WKPF flag is cleared before using this function.\r
 810 * Input          : None\r
 811 * Output         : None\r
 812 * Return         : None\r
 813 *******************************************************************************/\r
 814 void MRCC_EnterSTANDBYMode(void)\r
 815 {\r
 816 /* Low Power mode configuration ----------------------------------------------*/\r
 817   /* Clear LPMC[1:0] bits */\r
 818    MRCC->PWRCTRL &= MRCC_LPMC_Reset_Mask;\r
 819 \r
 820   /* Select STANDBY mode */\r
 821   MRCC->PWRCTRL |= MRCC_STANDBY_Mask;\r
 822 \r
 823 /* Execute the Low Power bit writing sequence --------------------------------*/\r
 824   WriteLPBit();\r
 825 }\r
 826 \r
 827 /*******************************************************************************\r
 828 * Function Name  : MRCC_GenerateSWReset\r
 829 * Description    : Generates a system software reset.\r
 830 * Input          : None\r
 831 * Output         : None\r
 832 * Return         : None\r
 833 *******************************************************************************/\r
 834 void MRCC_GenerateSWReset(void)\r
 835 {\r
 836 /* Low Power mode configuration ----------------------------------------------*/\r
 837   /* Clear LPMC[1:0] bits */\r
 838   MRCC->PWRCTRL &= MRCC_LPMC_Reset_Mask;\r
 839 \r
 840   /* Select software reset */\r
 841   MRCC->PWRCTRL |= MRCC_SWRESET_Mask;\r
 842 \r
 843 /* Execute the Low Power bit writing sequence --------------------------------*/\r
 844   WriteLPBit();\r
 845 }\r
 846 \r
 847 /*******************************************************************************\r
 848 * Function Name  : MRCC_WriteBackupRegister\r
 849 * Description    : Writes user data to the specified backup register.\r
 850 * Input          : - MRCC_BKP: specifies the backup register.\r
 851 *                    This parameter can be one of the following values:\r
 852 *                          - MRCC_BKP0\r
 853 *                          - MRCC_BKP1\r
 854 *                  - Data: data to write.\r
 855 * Output         : None\r
 856 * Return         : None\r
 857 *******************************************************************************/\r
 858 void MRCC_WriteBackupRegister(MRCC_BKPReg MRCC_BKP, u32 Data)\r
 859 {\r
 860   if(MRCC_BKP == MRCC_BKP0)\r
 861   {\r
 862     MRCC->BKP0 = Data;\r
 863   }\r
 864   else\r
 865   {\r
 866     MRCC->BKP1 = Data;\r
 867   }\r
 868 }\r
 869 \r
 870 /*******************************************************************************\r
 871 * Function Name  : MRCC_ReadBackupRegister\r
 872 * Description    : Reads data from the specified backup register.\r
 873 * Input          : - MRCC_BKP: specifies the backup register.\r
 874 *                    This parameter can be one of the following values:\r
 875 *                          - MRCC_BKP0\r
 876 *                          - MRCC_BKP1\r
 877 * Output         : None\r
 878 * Return         : The content of the specified backup register.\r
 879 *******************************************************************************/\r
 880 u32 MRCC_ReadBackupRegister(MRCC_BKPReg MRCC_BKP)\r
 881 {\r
 882   if(MRCC_BKP == MRCC_BKP0)\r
 883   {\r
 884     return(MRCC->BKP0);\r
 885   }\r
 886   else\r
 887   {\r
 888     return(MRCC->BKP1);\r
 889   }\r
 890 }\r
 891 \r
 892 /*******************************************************************************\r
 893 * Function Name  : MRCC_IOVoltageRangeConfig\r
 894 * Description    : Configures the I/O pins voltage range.\r
 895 * Input          : - MRCC_IOVoltageRange: specifies the I/O pins voltage range.\r
 896 *                    This parameter can be one of the following values:\r
 897 *                          - MRCC_IOVoltageRange_5V\r
 898 *                          - MRCC_IOVoltageRange_3V3\r
 899 * Output         : None\r
 900 * Return         : None\r
 901 *******************************************************************************/\r
 902 void MRCC_IOVoltageRangeConfig(u32 MRCC_IOVoltageRange)\r
 903 {\r
 904   if(MRCC_IOVoltageRange == MRCC_IOVoltageRange_3V3)\r
 905   {\r
 906     MRCC->PWRCTRL |= MRCC_IOVoltageRange_3V3;\r
 907   }\r
 908   else\r
 909   {\r
 910     MRCC->PWRCTRL &= MRCC_IOVoltageRange_5V;\r
 911   }\r
 912 }\r
 913 \r
 914 /*******************************************************************************\r
 915 * Function Name  : MRCC_MCOConfig\r
 916 * Description    : Selects the clock source to output on MCO pin (P0.1).\r
 917 *                  To output the clock, the associated alternate function must\r
 918 *                  be enabled in the I/O port controller.\r
 919 * Input          : - MRCC_MCO: specifies the clock source to output.\r
 920 *                    This parameter can be one of the following values:\r
 921 *                          - MRCC_MCO_HCLK\r
 922 *                          - MRCC_MCO_PCLK\r
 923 *                          - MRCC_MCO_OSC4M\r
 924 *                          - MRCC_MCO_CKPLL2\r
 925 *                  - MRCC_MCOPrescaler: specifies if prescaler, divide by 1 or 2,\r
 926 *                    is applied to this clock before outputting it to MCO pin.\r
 927 *                    This parameter can be one of the following values:\r
 928 *                          - MRCC_MCOPrescaler_1\r
 929 *                          - MRCC_MCOPrescaler_2\r
 930 * Output         : None\r
 931 * Return         : None\r
 932 *******************************************************************************/\r
 933 void MRCC_MCOConfig(u32 MRCC_MCO, u32 MCO_MCOPrescaler)\r
 934 {\r
 935   u32 Temp = 0;\r
 936 /* MCO prescaler configuration -----------------------------------------------*/\r
 937   if(MCO_MCOPrescaler == MRCC_MCOPrescaler_2)\r
 938   {\r
 939     MRCC->CLKCTL |= MRCC_MCOPrescaler_2;\r
 940   }\r
 941   else\r
 942   {\r
 943     MRCC->CLKCTL &= MRCC_MCOPrescaler_1;\r
 944   }\r
 945 \r
 946 /* MCO selection configuration -----------------------------------------------*/\r
 947 \r
 948   /* Clear MCOS[1:0] bits */\r
 949   Temp = MRCC->CLKCTL & MRCC_MCOS_Reset_Mask;\r
 950 \r
 951   /* Set MCOS[1:0] bits according to MRCC_MCO value */\r
 952   Temp |= MRCC_MCO;\r
 953   \r
 954   /* Store the new value */\r
 955   MRCC->CLKCTL = Temp;\r
 956 }\r
 957 \r
 958 /*******************************************************************************\r
 959 * Function Name  : MRCC_OSC4MConfig\r
 960 * Description    : Configures the 4MHz main oscillator (OSC4M).\r
 961 *                  This function must be used when the CK_SYS is not clocked\r
 962 *                  by the OSC4M and the PLL is not enabled.\r
 963 * Input          : - MRCC_OSC4M: specifies the new state of the OSC4M oscillator.\r
 964 *                    This parameter can be one of the following values:\r
 965 *                          - MRCC_OSC4M_Default: OSC4M enabled, bypass disabled\r
 966 *                          - MRCC_OSC4M_Disable: OSC4M disabled\r
 967 *                          - MRCC_OSC4M_Bypass:  OSC4M bypassed\r
 968 * Output         : None\r
 969 * Return         : An ErrorStatus enumuration value:\r
 970 *                         - SUCCESS: Clock configuration succeeded\r
 971 *                         - ERROR: Clock configuration failed\r
 972 *******************************************************************************/\r
 973 ErrorStatus MRCC_OSC4MConfig(u32 MRCC_OSC4M)\r
 974 {\r
 975   ErrorStatus Status = SUCCESS;\r
 976 \r
 977 /* If CK_SYS is driven by OSC4M or the PLL is enabled, exit ------------------*/           \r
 978   if(((MRCC->CLKCTL & MRCC_CKSEL_CKOSCSEL_Mask) == MRCC_CKSEL_Set_Mask) ||    \r
 979      (((MRCC->CLKCTL & MRCC_CKSEL_CKOSCSEL_Mask) == MRCC_CKSEL_CKOSCSEL_Mask) &&\r
 980      ((MRCC->PWRCTRL & MRCC_CKRTCSEL_Reset_Mask) != RESET))||\r
 981      ((MRCC->CLKCTL & MRCC_PLLEN_Set_Mask) != RESET))\r
 982   {\r
 983     Status = ERROR;\r
 984   }\r
 985 /* Else configure the OSC4MOFF and OSC4MBYP bits -----------------------------*/   \r
 986   else\r
 987   {  \r
 988     switch(MRCC_OSC4M)\r
 989     {\r
 990       case MRCC_OSC4M_Default:\r
 991         MRCC->CLKCTL &= MRCC_OSC4MOFF_Reset_Mask & MRCC_OSC4MBYP_Reset_Mask;\r
 992         break;\r
 993       \r
 994       case MRCC_OSC4M_Disable:\r
 995         MRCC->CLKCTL &= MRCC_OSC4MBYP_Reset_Mask;\r
 996         MRCC->CLKCTL |= MRCC_OSC4MOFF_Set_Mask;\r
 997         break;\r
 998         \r
 999       case MRCC_OSC4M_Bypass:\r
1000         MRCC->CLKCTL &= MRCC_OSC4MOFF_Reset_Mask;\r
1001         MRCC->CLKCTL |= MRCC_OSC4MBYP_Set_Mask;\r
1002         break;        \r
1003       \r
1004       default:\r
1005         Status =  ERROR;\r
1006         break;      \r
1007     }\r
1008   }  \r
1009   \r
1010   return Status; \r
1011 }\r
1012 \r
1013 /*******************************************************************************\r
1014 * Function Name  : MRCC_OSC32KConfig\r
1015 * Description    : Configures the OSC32K oscillator.\r
1016 *                  This function must be used when the CK_SYS is not clocked by\r
1017 *                  the CK_RTC.\r
1018 * Input          : - MRCC_OSC32K: specifies the new state of the OSC32K oscillator.\r
1019 *                    This parameter can be one of the following values:\r
1020 *                          - MRCC_OSC32K_Disable: OSC32K disabled\r
1021 *                          - MRCC_OSC32K_Enable: OSC32K enabled\r
1022 *                  - MRCC_OSC32KBypass: specifies if the OSC32K oscillator is\r
1023 *                    bypassed or not.\r
1024 *                    This parameter can be one of the following values:\r
1025 *                          - MRCC_OSC32KBypass_Disable: OSC32K selected\r
1026 *                          - MRCC_OSC32KBypass_Enable: OSC32K bypassed                          \r
1027 * Output         : None\r
1028 * Return         : An ErrorStatus enumuration value:\r
1029 *                         - SUCCESS: Clock configuration succeeded\r
1030 *                         - ERROR: Clock configuration failed\r
1031 *******************************************************************************/\r
1032 ErrorStatus MRCC_OSC32KConfig(u32 MRCC_OSC32K, u32 MRCC_OSC32KBypass)\r
1033 { \r
1034 /* If CK_SYS is driven by CK_RTC, exit ---------------------------------------*/     \r
1035   if(((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) != RESET) &&\r
1036       ((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET))\r
1037   {\r
1038     return ERROR;\r
1039   }\r
1040 /* Else configure the OSC32KEN and OSC32KBYP bits ----------------------------*/ \r
1041   else\r
1042   { \r
1043     /* Configure OSC32KEN bit */\r
1044     if(MRCC_OSC32K == MRCC_OSC32K_Enable)\r
1045     {\r
1046       MRCC->PWRCTRL |= MRCC_OSC32K_Enable;\r
1047     }\r
1048     else\r
1049     {\r
1050       MRCC->PWRCTRL &= MRCC_OSC32K_Disable;\r
1051     }\r
1052     \r
1053     /* Configure OSC32KBYP bit */\r
1054     if(MRCC_OSC32KBypass == MRCC_OSC32KBypass_Enable)\r
1055     {\r
1056       MRCC->PWRCTRL |= MRCC_OSC32KBypass_Enable;\r
1057     }\r
1058     else\r
1059     {\r
1060       MRCC->PWRCTRL &= MRCC_OSC32KBypass_Disable;\r
1061     }   \r
1062      \r
1063     return SUCCESS;   \r
1064   }\r
1065 }\r
1066 \r
1067 /*******************************************************************************\r
1068 * Function Name  : MRCC_LPOSCConfig\r
1069 * Description    : Enables or disables the LPOSC oscillator.\r
1070 *                  This function must be used when the CK_SYS is not clocked by\r
1071 *                  the CK_RTC.\r
1072 * Input          : - MRCC_LPOSC: specifies the new state of the LPOSC oscillator.\r
1073 *                    This parameter can be one of the following values:\r
1074 *                          - MRCC_LPOSC_Disable: LPOSC disabled\r
1075 *                          - MRCC_LPOSC_Enable: LPOSC enabled\r
1076 * Output         : None\r
1077 * Return         : An ErrorStatus enumuration value:\r
1078 *                         - SUCCESS: Clock configuration succeeded\r
1079 *                         - ERROR: Clock configuration failed\r
1080 *******************************************************************************/\r
1081 ErrorStatus MRCC_LPOSCConfig(u32 MRCC_LPOSC)\r
1082 {\r
1083 /* If CK_SYS is driven by CK_RTC or LPOSC is used as CK_RTC clock source, exit*/      \r
1084   if((((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) != RESET) &&\r
1085      ((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET)) ||\r
1086      ((MRCC->PWRCTRL & MRCC_CKRTCSEL_Set_Mask) == MRCC_CKRTC_LPOSC)) \r
1087   {\r
1088     return ERROR;\r
1089   }\r
1090 /* Else configure the LPOSCEN bit --------------------------------------------*/  \r
1091   else\r
1092   {   \r
1093     if(MRCC_LPOSC == MRCC_LPOSC_Enable)\r
1094     {\r
1095       MRCC->PWRCTRL |= MRCC_LPOSC_Enable;\r
1096     }\r
1097     else\r
1098     {\r
1099       MRCC->PWRCTRL &= MRCC_LPOSC_Disable;\r
1100     }\r
1101 \r
1102     return SUCCESS;\r
1103   }     \r
1104 }\r
1105 \r
1106 /*******************************************************************************\r
1107 * Function Name  : MRCC_RTCMConfig\r
1108 * Description    : Enables or disables RTC clock measurement.\r
1109 * Input          : - MRCC_RTCM: specifies whether CK_RTC is connected to TB \r
1110 *                    timer IC1 or not.\r
1111 *                    This parameter can be one of the following values:\r
1112 *                          - MRCC_RTCM_Disable: CK_RTC not connected to TB timer IC1\r
1113 *                          - MRCC_RTCM_Enable: CK_RTC connected to TB timer IC1\r
1114 * Output         : None\r
1115 * Return         : None\r
1116 *******************************************************************************/\r
1117 void MRCC_RTCMConfig(u32 MRCC_RTCM)\r
1118 {\r
1119   if(MRCC_RTCM == MRCC_RTCM_Enable)\r
1120   {\r
1121     MRCC->PWRCTRL |= MRCC_RTCM_Enable;\r
1122   }\r
1123   else\r
1124   {\r
1125     MRCC->PWRCTRL &= MRCC_RTCM_Disable;\r
1126   }  \r
1127 }\r
1128 \r
1129 /*******************************************************************************\r
1130 * Function Name  : MRCC_SetBuilderCounter\r
1131 * Description    : Sets the builder counter value which defines the delay for\r
1132 *                  the 4MHz main oscillator (OSC4M) clock to be stabilized.\r
1133 * Input          : - BuilderCounter: defines the delay for the OSC4M oscillator\r
1134 *                    clock to be stabilized.\r
1135 * Output         : None\r
1136 * Return         : None\r
1137 *******************************************************************************/\r
1138 void MRCC_SetBuilderCounter(u8 BuilderCounter)\r
1139 { \r
1140   *(u8 *) 0x60000026 = BuilderCounter;\r
1141 }\r
1142 \r
1143 /*******************************************************************************\r
1144 * Function Name  : MRCC_GetCKSYSCounter\r
1145 * Description    : Gets the result of the delay applied to CK_SYS before\r
1146 *                  starting the CPU.\r
1147 * Input          : None\r
1148 * Output         : None\r
1149 * Return         : SCOUNT value.\r
1150 *******************************************************************************/\r
1151 u16 MRCC_GetCKSYSCounter(void)\r
1152 {\r
1153   return((u16)(MRCC->RFSR & 0x0FFF));\r
1154 }\r
1155 \r
1156 /*******************************************************************************\r
1157 * Function Name  : MRCC_GetFlagStatus\r
1158 * Description    : Checks whether the specified MRCC flag is set or not.\r
1159 * Input          : - MRCC_FLAG: specifies the flag to check.\r
1160 *                    This parameter can be one of the following values:\r
1161 *                          - MRCC_FLAG_LOCK: PLL Locked flag\r
1162 *                          - MRCC_FLAG_LOCKIF: PLL Lock Interrupt status flag\r
1163 *                          - MRCC_FLAG_CKSEL: CK_SYS source staus flag\r
1164 *                          - MRCC_FLAG_CKOSCSEL: CK_OSC clock source staus flag\r
1165 *                          - MRCC_FLAG_NCKD: No Clock Detected flag\r
1166 *                          - MRCC_FLAG_SWR: Software Reset flag\r
1167 *                          - MRCC_FLAG_WDGR: Watchdog Reset flag\r
1168 *                          - MRCC_FLAG_EXTR: External Reset flag\r
1169 *                          - MRCC_FLAG_WKP: Wake-Up flag\r
1170 *                          - MRCC_FLAG_STDB: STANDBY flag\r
1171 *                          - MRCC_FLAG_BCOUNT:   Builder Counter Flag\r
1172 *                          - MRCC_FLAG_OSC32KRDY: Oscillator 32K Ready\r
1173 *                          - MRCC_FLAG_CKRTCOK: CK_RTC OK\r
1174 *                          - MRCC_FLAG_LPDONE: Low Power Bit Sequence has been performed\r
1175 *                          - MRCC_FLAG_LP: Low Power Mode Entry\r
1176 * Output         : None\r
1177 * Return         : The new state of MRCC_FLAG (SET or RESET).\r
1178 *******************************************************************************/\r
1179 FlagStatus MRCC_GetFlagStatus(u8 MRCC_FLAG)\r
1180 {\r
1181   u32 MRCCReg = 0, FlagPos = 0;\r
1182   u32 StatusReg = 0;\r
1183 \r
1184   /* Get the MRCC register index */\r
1185   MRCCReg = MRCC_FLAG >> 5;\r
1186 \r
1187   /* Get the flag position */\r
1188   FlagPos = MRCC_FLAG & MRCC_FLAG_Mask;\r
1189 \r
1190   if(MRCCReg == 1) /* The flag to check is in CLKCTL register */\r
1191   {\r
1192     StatusReg = MRCC->CLKCTL;\r
1193   }\r
1194   else if (MRCCReg == 2) /* The flag to check is in RFSR register */\r
1195   {\r
1196     StatusReg = MRCC->RFSR;\r
1197   }\r
1198   else if(MRCCReg == 3) /* The flag to check is in PWRCTRL register */\r
1199   {\r
1200     StatusReg = MRCC->PWRCTRL;\r
1201   }\r
1202   \r
1203   if((StatusReg & (1 << FlagPos))!= RESET)\r
1204   {\r
1205     return SET;\r
1206   }\r
1207   else\r
1208   {\r
1209     return RESET;\r
1210   }\r
1211 }\r
1212 \r
1213 /*******************************************************************************\r
1214 * Function Name  : MRCC_ClearFlag\r
1215 * Description    : Clears the MRCC\92s pending flags.\r
1216 * Input          : - MRCC_FLAG: specifies the flag to clear.\r
1217 *                    This parameter can be one of the following values:\r
1218 *                          - MRCC_FLAG_NCKD: No Clock Detected flag\r
1219 *                          - MRCC_FLAG_SWR: Software Reset flag\r
1220 *                          - MRCC_FLAG_WDGR: Watchdog Reset flag\r
1221 *                          - MRCC_FLAG_EXTR: External Reset flag\r
1222 *                          - MRCC_FLAG_WKP: Wake-Up flag\r
1223 *                          - MRCC_FLAG_STDB: STANDBY flag\r
1224 *                          - MRCC_FLAG_LPDONE: Low Power Bit Sequence has been performed\r
1225 * Output         : None\r
1226 * Return         : None\r
1227 *******************************************************************************/\r
1228 void MRCC_ClearFlag(u8 MRCC_FLAG)\r
1229 {\r
1230   u32 MRCCReg = 0, FlagPos = 0;\r
1231 \r
1232   /* Get the MRCC register index */\r
1233   MRCCReg = MRCC_FLAG >> 5;\r
1234 \r
1235   /* Get the flag position */\r
1236   FlagPos = MRCC_FLAG & MRCC_FLAG_Mask;\r
1237 \r
1238   if(MRCCReg == 1) /* The flag to clear is in CLKCTL register */\r
1239   {\r
1240     MRCC->CLKCTL &= ~(1 << FlagPos);\r
1241   }\r
1242   else if (MRCCReg == 2) /* The flag to clear is in RFSR register */\r
1243   {\r
1244     MRCC->RFSR &= ~(1 << FlagPos);\r
1245   }\r
1246   else if(MRCCReg == 3) /* The flag to clear is in PWRCTRL register */\r
1247   {\r
1248     MRCC->PWRCTRL &= ~(1 << FlagPos);\r
1249   }\r
1250 }\r
1251 \r
1252 /*******************************************************************************\r
1253 * Function Name  : MRCC_GetITStatus\r
1254 * Description    : Checks whether the specified MRCC interrupt has occurred or not.\r
1255 * Input          : - MRCC_IT: specifies the MRCC interrupt source to check.\r
1256 *                    This parameter can be one of the following values:\r
1257 *                          - MRCC_IT_LOCK: PLL lock interrupt\r
1258 *                          - MRCC_IT_NCKD: No Clock detected interrupt\r
1259 * Output         : None\r
1260 * Return         : The new state of MRCC_IT (SET or RESET).\r
1261 *******************************************************************************/\r
1262 ITStatus MRCC_GetITStatus(u32 MRCC_IT)\r
1263 {\r
1264   /* Check the specified interrupt pending bit */\r
1265   if((MRCC->CLKCTL & (MRCC_IT >> 1)) != RESET)\r
1266   {\r
1267     return SET;\r
1268   }\r
1269   else\r
1270   {\r
1271     return RESET;\r
1272   }\r
1273 }\r
1274 \r
1275 /*******************************************************************************\r
1276 * Function Name  : MRCC_ClearITPendingBit\r
1277 * Description    : Clears the MRCC\92s interrupt pending bits.\r
1278 * Input          : - MRCC_IT: specifies the interrupt pending bit to clear.\r
1279 *                    This parameter can be any combination of the following\r
1280 *                    values:\r
1281 *                          - MRCC_IT_LOCK: PLL lock interrupt\r
1282 *                          - MRCC_IT_NCKD: No Clock detected interrupt\r
1283 * Output         : None\r
1284 * Return         : None\r
1285 *******************************************************************************/\r
1286 void MRCC_ClearITPendingBit(u32 MRCC_IT)\r
1287 {\r
1288   /* Clear the specified interrupt pending bit */\r
1289   MRCC->CLKCTL &= ~(MRCC_IT >> 1);\r
1290 }\r
1291 \r
1292 /*******************************************************************************\r
1293 * Function Name  : MRCC_WaitForOSC4MStartUp\r
1294 * Description    : Waits for OSC4M start-up.\r
1295 * Input          : None\r
1296 * Output         : None\r
1297 * Return         : An ErrorStatus enumuration value:\r
1298 *                         - SUCCESS: OSC4M oscillator is stable and ready to use\r
1299 *                         - ERROR: no clock is detected on OSC4M\r
1300 *******************************************************************************/\r
1301 ErrorStatus MRCC_WaitForOSC4MStartUp(void)\r
1302 {\r
1303   u32 StartUpCounter = 0;\r
1304 \r
1305   do\r
1306   {\r
1307     /* Clear No Clock Detected flag */\r
1308     if(MRCC_GetFlagStatus(MRCC_FLAG_NCKD) != RESET)\r
1309     {\r
1310       MRCC_ClearFlag(MRCC_FLAG_NCKD);\r
1311     }\r
1312 \r
1313     StartUpCounter++;\r
1314 \r
1315   }while((MRCC_GetFlagStatus(MRCC_FLAG_BCOUNT) == RESET)&&\r
1316          (StartUpCounter != OSC4MStartUp_TimeOut));\r
1317   \r
1318   if(MRCC_GetFlagStatus(MRCC_FLAG_BCOUNT) != RESET)\r
1319   {\r
1320     return SUCCESS;\r
1321   }\r
1322   else\r
1323   {\r
1324     return ERROR;\r
1325   }  \r
1326 }\r
1327 \r
1328 /*******************************************************************************\r
1329 * Function Name  : SetCKSYS_FREEOSC\r
1330 * Description    : Selects FREEOSC as CK_SYS clock source.\r
1331 * Input          : None\r
1332 * Output         : None\r
1333 * Return         : An ErrorStatus enumuration value:\r
1334 *                         - SUCCESS: Clock configuration succeeded\r
1335 *                         - ERROR: Clock configuration failed\r
1336 *******************************************************************************/\r
1337 static ErrorStatus SetCKSYS_FREEOSC(void)\r
1338 {\r
1339   /* Check if the PLL is enabled */\r
1340   if((MRCC->CLKCTL & MRCC_PLLEN_Set_Mask) != RESET)\r
1341   {  \r
1342     if((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) == RESET)\r
1343     { /* CK_PLL1 used as Ck_SYS clock source*/\r
1344 \r
1345       if((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET)\r
1346       {/* Check if CK_RTC source clock is present*/ \r
1347         if((MRCC->PWRCTRL & MRCC_CKRTCSEL_Set_Mask) == RESET) \r
1348         {\r
1349           /* CK_RTC disabled*/\r
1350           return ERROR;\r
1351         }\r
1352       }\r
1353       \r
1354       /* Select CK_OSC as CK_SYS clock source */\r
1355       MRCC->CLKCTL |= MRCC_CKSEL_Set_Mask;\r
1356     }  \r
1357     \r
1358     /* Disable PLL */\r
1359     MRCC->CLKCTL &= MRCC_PLLEN_Reset_Mask;\r
1360   }\r
1361 \r
1362   /* Select CK_PLL1 as CK_SYS clock source */\r
1363   MRCC->CLKCTL &= MRCC_CKSEL_Reset_Mask;\r
1364 \r
1365   if((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) == RESET)\r
1366   {\r
1367     return SUCCESS;\r
1368   }\r
1369   else\r
1370   {\r
1371     return ERROR;\r
1372   }\r
1373 }\r
1374 \r
1375 /*******************************************************************************\r
1376 * Function Name  : SetCKSYS_OSC4M\r
1377 * Description    : Selects 4MHz main oscillator (OSC4M) as CK_SYS clock source.\r
1378 * Input          : PLL_State: specifies the PLL state.\r
1379 * Output         : None\r
1380 * Return         : An ErrorStatus enumuration value:\r
1381 *                         - SUCCESS: Clock configuration succeeded\r
1382 *                         - ERROR: Clock configuration failed\r
1383 *******************************************************************************/\r
1384 static ErrorStatus SetCKSYS_OSC4M(u32 PLL_State)\r
1385 {\r
1386 /* If OSC4M is not present, exit ---------------------------------------------*/      \r
1387   if(((MRCC->CLKCTL & MRCC_NCKDF_Set_Mask) != RESET) || \r
1388      ((MRCC->CLKCTL & MRCC_OSC4MOFF_Set_Mask) != RESET) ) \r
1389   {\r
1390     /* OSC4M disabled or OSC4M clock is not present*/\r
1391     return ERROR;\r
1392   }\r
1393 \r
1394 /* Else configure CKSEL and CKOSCSEL bits ------------------------------------*/          \r
1395   if((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET)\r
1396   { /* CK_RTC used as CK_OSC clock */   \r
1397   \r
1398     if((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) != RESET) \r
1399     {\r
1400       /* Select CK_PLL1 as CK_SYS clock source */\r
1401       MRCC->CLKCTL &= MRCC_CKSEL_Reset_Mask;\r
1402     }\r
1403     \r
1404     /* Clear CKOSCSEL bit ----------------------------------------------------*/\r
1405     /* Execute CKOSCSEL bit writing sequence */\r
1406     WriteCKOSCSELBit();\r
1407 \r
1408     /* Check if CKOSCSEL is set to 0 */\r
1409     if((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET)\r
1410     {\r
1411       return ERROR;\r
1412     }\r
1413   }  \r
1414  \r
1415   /* Select CK_OSC as CK_SYS clock source */\r
1416   MRCC->CLKCTL |= MRCC_CKSEL_Set_Mask;\r
1417 \r
1418   if((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) != RESET)\r
1419   {\r
1420     if(PLL_State == MRCC_PLL_Disabled)\r
1421     {\r
1422       /* Disable PLL */\r
1423       MRCC->CLKCTL &= MRCC_PLLEN_Reset_Mask;\r
1424     }\r
1425     \r
1426     return SUCCESS;\r
1427   }\r
1428   else\r
1429   {\r
1430     return ERROR;\r
1431   }  \r
1432 }\r
1433 \r
1434 /*******************************************************************************\r
1435 * Function Name  : SetCKSYS_OSC4MPLL\r
1436 * Description    : Selects 4MHz main oscillator (OSC4M) followed by PLL as\r
1437 *                  CK_SYS clock source.\r
1438 * Input          : PLL_Mul: specifies the PLL factor.\r
1439 * Output         : None\r
1440 * Return         : An ErrorStatus enumuration value:\r
1441 *                         - SUCCESS: Clock configuration succeeded\r
1442 *                         - ERROR: Clock configuration failed\r
1443 *******************************************************************************/\r
1444 static ErrorStatus SetCKSYS_OSC4MPLL(u32 PLL_Mul)\r
1445 {\r
1446   /* Check if 4MHz main oscillator clock is present */\r
1447   if(((MRCC->CLKCTL & MRCC_NCKDF_Set_Mask) == RESET) && \r
1448      ((MRCC->CLKCTL & MRCC_OSC4MOFF_Set_Mask) == RESET)) \r
1449   {    \r
1450     if(((MRCC->CLKCTL & MRCC_PLLEN_Set_Mask) != RESET) &&\r
1451        ((MRCC->CLKCTL & MRCC_MX_Set_Mask) == PLL_Mul))\r
1452     {\r
1453       /* Select CK_PLL1 as CK_SYS clock source */\r
1454       MRCC->CLKCTL &= MRCC_CKSEL_Reset_Mask;\r
1455 \r
1456       if((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) == RESET)\r
1457       {\r
1458         return SUCCESS;\r
1459       }\r
1460       else\r
1461       {\r
1462         return ERROR;\r
1463       }\r
1464     }\r
1465     else\r
1466     {\r
1467       /* If CK_RTC is selected as CK_OSC clock source */\r
1468       if((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET)\r
1469       {\r
1470         if((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) != RESET)\r
1471         {\r
1472           /* Clear CKSEL bit */\r
1473           MRCC->CLKCTL &= MRCC_CKSEL_Reset_Mask;\r
1474         }\r
1475 \r
1476         /* Clear CKOSCSEL bit ------------------------------------------------*/\r
1477         /* Execute CKOSCSEL bit writing sequence */\r
1478         WriteCKOSCSELBit();\r
1479       \r
1480         /* Check if CKOSCSEL is set to 0 */\r
1481         if((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) != RESET)\r
1482         {\r
1483           return ERROR;\r
1484         }\r
1485       }\r
1486 \r
1487       /* Select CK_OSC as CK_SYS clock source */\r
1488       MRCC->CLKCTL |= MRCC_CKSEL_Set_Mask;\r
1489 \r
1490       /* Disable PLL */\r
1491       MRCC->CLKCTL &= MRCC_PLLEN_Reset_Mask;\r
1492 \r
1493       /* Configure PLL factor */\r
1494       if(PLL_Mul == MRCC_PLL_Mul_16)\r
1495       {\r
1496         MRCC->CLKCTL &= MRCC_MX_Reset_Mask;\r
1497       }\r
1498       else if((PLL_Mul == MRCC_PLL_Mul_15) || (PLL_Mul == MRCC_PLL_Mul_14) ||\r
1499             (PLL_Mul == MRCC_PLL_Mul_12))\r
1500       {\r
1501         /* Clear MX[1:0] bits */\r
1502         MRCC->CLKCTL &= MRCC_MX_Reset_Mask;\r
1503         /* Set MX[1:0] bits according to PLL_Mul value */\r
1504         MRCC->CLKCTL |= PLL_Mul;\r
1505       }\r
1506        \r
1507       if(Main_Oscillator == 4000000)\r
1508       {/* 4 MHz external Quartz oscillator used as main oscillator */\r
1509         /* Disable Oscillator Divider by 2 */\r
1510         MRCC->CLKCTL &= MRCC_XTDIV2_Reset_Mask;\r
1511       }\r
1512       else if(Main_Oscillator == 8000000)\r
1513       {/* 8 MHz external Quartz oscillator used as main oscillator */\r
1514         /* Enable Oscillator Divider by 2 */\r
1515         MRCC->CLKCTL |= MRCC_XTDIV2_Set_Mask;\r
1516       }\r
1517 \r
1518       /* Enable PLL */\r
1519       MRCC->CLKCTL |= MRCC_PLLEN_Set_Mask;\r
1520    \r
1521       /* Wait until the PLL is locked */\r
1522       while((MRCC->CLKCTL & MRCC_LOCK_Mask) == RESET)\r
1523       {\r
1524         /* If OSC4M clock disapear or the PLL is disabled, exit */\r
1525         if(((MRCC->CLKCTL & MRCC_NCKDF_Set_Mask) != RESET) ||\r
1526            ((MRCC->CLKCTL & MRCC_PLLEN_Set_Mask) == RESET))       \r
1527         {\r
1528           return ERROR;\r
1529         }\r
1530       }\r
1531 \r
1532       /* Select CK_PLL1 as CK_SYS clock source */\r
1533       MRCC->CLKCTL &= MRCC_CKSEL_Reset_Mask;\r
1534 \r
1535       if((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) == RESET)\r
1536       {\r
1537         return SUCCESS;\r
1538       }\r
1539       else\r
1540       {\r
1541         return ERROR;\r
1542       }\r
1543     }\r
1544   }\r
1545   else \r
1546   {\r
1547     /* OSC4M disabled or OSC4M clock is not present*/\r
1548     return ERROR;\r
1549   }\r
1550 }\r
1551 \r
1552 /*******************************************************************************\r
1553 * Function Name  : SetCKSYS_RTC\r
1554 * Description    : Selects RTC clock (CK_RTC) as CK_SYS clock source.\r
1555 * Input          : PLL_State: specifies the PLL state.\r
1556 * Output         : None\r
1557 * Return         : An ErrorStatus enumuration value:\r
1558 *                         - SUCCESS: Clock configuration succeeded\r
1559 *                         - ERROR: Clock configuration failed\r
1560 *******************************************************************************/\r
1561 static ErrorStatus SetCKSYS_RTC(u32 PLL_State)\r
1562 {\r
1563   /* Check if CK_RTC clock is enabled and ready to use */\r
1564   if(((MRCC->PWRCTRL & MRCC_CKRTCSEL_Set_Mask) != RESET)||\r
1565      ((MRCC->CLKCTL & MRCC_CKRTCOK_Mask) == RESET))\r
1566   {\r
1567 /* Configure CK_RTC as Ck_SYS clock source -----------------------------------*/\r
1568     if((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) == RESET)\r
1569     { \r
1570       /* Select CK_PLL1 as CK_SYS clock source */\r
1571       MRCC->CLKCTL &= MRCC_CKSEL_Reset_Mask;\r
1572     \r
1573       /* Set CKOSCSEL bit ----------------------------------------------------*/\r
1574       /* Execute CKOSCSEL bit writing sequence */\r
1575       WriteCKOSCSELBit();\r
1576       \r
1577       /* Check if CKOSCSEL is set to 1 */\r
1578       if((MRCC->CLKCTL & MRCC_CKOSCSEL_Set_Mask) == RESET)\r
1579       {\r
1580          return ERROR;\r
1581       }\r
1582     }\r
1583     \r
1584     /* Select CK_OSC as CK_SYS clock source */\r
1585     MRCC->CLKCTL |= MRCC_CKSEL_Set_Mask;          \r
1586     \r
1587     if((MRCC->CLKCTL & MRCC_CKSEL_Set_Mask) != RESET)\r
1588     {\r
1589       if(PLL_State == MRCC_PLL_Disabled)\r
1590       {\r
1591         /* Disable PLL */\r
1592         MRCC->CLKCTL &= MRCC_PLLEN_Reset_Mask;\r
1593       }\r
1594     \r
1595       return SUCCESS;\r
1596     }\r
1597     else\r
1598     {\r
1599       return ERROR;\r
1600     }    \r
1601   }\r
1602   else\r
1603   {      \r
1604     /* CK_RTC disabled */\r
1605     return ERROR;\r
1606   }  \r
1607 }\r
1608 \r
1609 /*******************************************************************************\r
1610 * Function Name  : WriteLPBit\r
1611 * Description    : Executes the Low Power bit writing sequence.\r
1612 * Input          : None\r
1613 * Output         : None\r
1614 * Return         : None\r
1615 *******************************************************************************/\r
1616 static void WriteLPBit(void)\r
1617 {\r
1618   u32 Tmp = 0, Tmp1 = 0, Tmp2 = 0;\r
1619 \r
1620   /* Clear LP_DONE flag */\r
1621   MRCC->PWRCTRL &= MRCC_LPDONE_Reset_Mask;\r
1622 \r
1623   Tmp = MRCC->PWRCTRL;\r
1624   Tmp1 = Tmp | MRCC_LP_Set_Mask;\r
1625   Tmp2 = Tmp & MRCC_LP_Reset_Mask;\r
1626 \r
1627   /* Set LP bit */\r
1628   MRCC->PWRCTRL = Tmp1;\r
1629 \r
1630   /* Set LP bit */\r
1631   MRCC->PWRCTRL = Tmp1;\r
1632 \r
1633   /* Reset LP bit */\r
1634   MRCC->PWRCTRL = Tmp2;\r
1635 \r
1636   /* Set LP bit */\r
1637   MRCC->PWRCTRL = Tmp1;\r
1638 \r
1639   /* Read LP bit*/\r
1640   Tmp = MRCC->PWRCTRL;  \r
1641 }\r
1642 \r
1643 /*******************************************************************************\r
1644 * Function Name  : WriteCKOSCSELBit\r
1645 * Description    : Executes the CKOSCSEL bit writing sequence.\r
1646 * Input          : None\r
1647 * Output         : None\r
1648 * Return         : None\r
1649 *******************************************************************************/\r
1650 static void WriteCKOSCSELBit(void)\r
1651 {\r
1652   u32 Tmp = 0, Tmp1 = 0, Tmp2 = 0;\r
1653 \r
1654   Tmp = MRCC->CLKCTL;\r
1655   Tmp1 = Tmp | MRCC_CKOSCSEL_Set_Mask;\r
1656   Tmp2 = Tmp & MRCC_CKOSCSEL_Reset_Mask;\r
1657 \r
1658   /* Set CKOSCSEL bit */\r
1659   MRCC->CLKCTL = Tmp1;\r
1660 \r
1661   /* Set CKOSCSEL bit */\r
1662   MRCC->CLKCTL = Tmp1;\r
1663 \r
1664   /* Reset CKOSCSEL bit */\r
1665   MRCC->CLKCTL = Tmp2;\r
1666 \r
1667   /* Set CKOSCSEL bit */\r
1668   MRCC->CLKCTL = Tmp1;\r
1669   \r
1670   /* Read CKOSCSEL bit */\r
1671   Tmp = MRCC->CLKCTL;\r
1672 }\r
1673 /******************* (C) COPYRIGHT 2006 STMicroelectronics *****END OF FILE****/\r