git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_STM32L4_Discovery_GCC_IAR_Keil/ST_Code/Drivers/STM32L4xx_HAL_Driver/Src/stm32l4xx_hal_rcc.c

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32l4xx_hal_rcc.c\r
   4   * @author  MCD Application Team\r
   5   * @brief   RCC HAL module driver.\r
   6   *          This file provides firmware functions to manage the following\r
   7   *          functionalities of the Reset and Clock Control (RCC) peripheral:\r
   8   *           + Initialization and de-initialization functions\r
   9   *           + Peripheral Control functions\r
  10   *\r
  11   @verbatim\r
  12   ==============================================================================\r
  13                       ##### RCC specific features #####\r
  14   ==============================================================================\r
  15     [..]\r
  16       After reset the device is running from Multiple Speed Internal oscillator\r
  17       (4 MHz) with Flash 0 wait state. Flash prefetch buffer, D-Cache\r
  18       and I-Cache are disabled, and all peripherals are off except internal\r
  19       SRAM, Flash and JTAG.\r
  20 \r
  21       (+) There is no prescaler on High speed (AHBs) and Low speed (APBs) busses:\r
  22           all peripherals mapped on these busses are running at MSI speed.\r
  23       (+) The clock for all peripherals is switched off, except the SRAM and FLASH.\r
  24       (+) All GPIOs are in analog mode, except the JTAG pins which\r
  25           are assigned to be used for debug purpose.\r
  26 \r
  27     [..]\r
  28       Once the device started from reset, the user application has to:\r
  29       (+) Configure the clock source to be used to drive the System clock\r
  30           (if the application needs higher frequency/performance)\r
  31       (+) Configure the System clock frequency and Flash settings\r
  32       (+) Configure the AHB and APB busses prescalers\r
  33       (+) Enable the clock for the peripheral(s) to be used\r
  34       (+) Configure the clock source(s) for peripherals which clocks are not\r
  35           derived from the System clock (SAIx, RTC, ADC, USB OTG FS/SDMMC1/RNG)\r
  36 \r
  37   @endverbatim\r
  38   ******************************************************************************\r
  39   * @attention\r
  40   *\r
  41   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.\r
  42   * All rights reserved.</center></h2>\r
  43   *\r
  44   * This software component is licensed by ST under BSD 3-Clause license,\r
  45   * the "License"; You may not use this file except in compliance with the\r
  46   * License. You may obtain a copy of the License at:\r
  47   *                        opensource.org/licenses/BSD-3-Clause\r
  48   *\r
  49   ******************************************************************************\r
  50   */\r
  51 \r
  52 /* Includes ------------------------------------------------------------------*/\r
  53 #include "stm32l4xx_hal.h"\r
  54 \r
  55 /** @addtogroup STM32L4xx_HAL_Driver\r
  56   * @{\r
  57   */\r
  58 \r
  59 /** @defgroup RCC RCC\r
  60   * @brief RCC HAL module driver\r
  61   * @{\r
  62   */\r
  63 \r
  64 #ifdef HAL_RCC_MODULE_ENABLED\r
  65 \r
  66 /* Private typedef -----------------------------------------------------------*/\r
  67 /* Private define ------------------------------------------------------------*/\r
  68 /** @defgroup RCC_Private_Constants RCC Private Constants\r
  69  * @{\r
  70  */\r
  71 #define HSE_TIMEOUT_VALUE          HSE_STARTUP_TIMEOUT\r
  72 #define HSI_TIMEOUT_VALUE          2U    /* 2 ms (minimum Tick + 1) */\r
  73 #define MSI_TIMEOUT_VALUE          2U    /* 2 ms (minimum Tick + 1) */\r
  74 #if defined(RCC_CSR_LSIPREDIV)\r
  75 #define LSI_TIMEOUT_VALUE          17U   /* 17 ms (16 ms starting time + 1) */\r
  76 #else\r
  77 #define LSI_TIMEOUT_VALUE          2U    /* 2 ms (minimum Tick + 1) */\r
  78 #endif /* RCC_CSR_LSIPREDIV */\r
  79 #define HSI48_TIMEOUT_VALUE        2U    /* 2 ms (minimum Tick + 1) */\r
  80 #define PLL_TIMEOUT_VALUE          2U    /* 2 ms (minimum Tick + 1) */\r
  81 #define CLOCKSWITCH_TIMEOUT_VALUE  5000U /* 5 s    */\r
  82 /**\r
  83   * @}\r
  84   */\r
  85 \r
  86 /* Private macro -------------------------------------------------------------*/\r
  87 /** @defgroup RCC_Private_Macros RCC Private Macros\r
  88   * @{\r
  89   */\r
  90 #define __MCO1_CLK_ENABLE()   __HAL_RCC_GPIOA_CLK_ENABLE()\r
  91 #define MCO1_GPIO_PORT        GPIOA\r
  92 #define MCO1_PIN              GPIO_PIN_8\r
  93 \r
  94 #define RCC_PLL_OSCSOURCE_CONFIG(__HAL_RCC_PLLSOURCE__) \\r
  95             (MODIFY_REG(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC, (__HAL_RCC_PLLSOURCE__)))\r
  96 /**\r
  97   * @}\r
  98   */\r
  99 \r
 100 /* Private variables ---------------------------------------------------------*/\r
 101 \r
 102 /* Private function prototypes -----------------------------------------------*/\r
 103 /** @defgroup RCC_Private_Functions RCC Private Functions\r
 104   * @{\r
 105   */\r
 106 static HAL_StatusTypeDef RCC_SetFlashLatencyFromMSIRange(uint32_t msirange);\r
 107 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)\r
 108 static uint32_t          RCC_GetSysClockFreqFromPLLSource(void);\r
 109 #endif\r
 110 /**\r
 111   * @}\r
 112   */\r
 113 \r
 114 /* Exported functions --------------------------------------------------------*/\r
 115 \r
 116 /** @defgroup RCC_Exported_Functions RCC Exported Functions\r
 117   * @{\r
 118   */\r
 119 \r
 120 /** @defgroup RCC_Exported_Functions_Group1 Initialization and de-initialization functions\r
 121   *  @brief    Initialization and Configuration functions\r
 122   *\r
 123   @verbatim\r
 124  ===============================================================================\r
 125            ##### Initialization and de-initialization functions #####\r
 126  ===============================================================================\r
 127     [..]\r
 128       This section provides functions allowing to configure the internal and external oscillators\r
 129       (HSE, HSI, LSE, MSI, LSI, PLL, CSS and MCO) and the System busses clocks (SYSCLK, AHB, APB1\r
 130        and APB2).\r
 131 \r
 132     [..] Internal/external clock and PLL configuration\r
 133          (+) HSI (high-speed internal): 16 MHz factory-trimmed RC used directly or through\r
 134              the PLL as System clock source.\r
 135 \r
 136          (+) MSI (Mutiple Speed Internal): Its frequency is software trimmable from 100KHZ to 48MHZ.\r
 137              It can be used to generate the clock for the USB OTG FS (48 MHz).\r
 138              The number of flash wait states is automatically adjusted when MSI range is updated with\r
 139              HAL_RCC_OscConfig() and the MSI is used as System clock source.\r
 140 \r
 141          (+) LSI (low-speed internal): 32 KHz low consumption RC used as IWDG and/or RTC\r
 142              clock source.\r
 143 \r
 144          (+) HSE (high-speed external): 4 to 48 MHz crystal oscillator used directly or\r
 145              through the PLL as System clock source. Can be used also optionally as RTC clock source.\r
 146 \r
 147          (+) LSE (low-speed external): 32.768 KHz oscillator used optionally as RTC clock source.\r
 148 \r
 149          (+) PLL (clocked by HSI, HSE or MSI) providing up to three independent output clocks:\r
 150            (++) The first output is used to generate the high speed system clock (up to 80MHz).\r
 151            (++) The second output is used to generate the clock for the USB OTG FS (48 MHz),\r
 152                 the random analog generator (<=48 MHz) and the SDMMC1 (<= 48 MHz).\r
 153            (++) The third output is used to generate an accurate clock to achieve\r
 154                 high-quality audio performance on SAI interface.\r
 155 \r
 156          (+) PLLSAI1 (clocked by HSI, HSE or MSI) providing up to three independent output clocks:\r
 157            (++) The first output is used to generate SAR ADC1 clock.\r
 158            (++) The second output is used to generate the clock for the USB OTG FS (48 MHz),\r
 159                 the random analog generator (<=48 MHz) and the SDMMC1 (<= 48 MHz).\r
 160            (++) The Third output is used to generate an accurate clock to achieve\r
 161                 high-quality audio performance on SAI interface.\r
 162 \r
 163          (+) PLLSAI2 (clocked by HSI, HSE or MSI) providing up to two independent output clocks:\r
 164            (++) The first output is used to generate SAR ADC2 clock.\r
 165            (++) The second  output is used to generate an accurate clock to achieve\r
 166                 high-quality audio performance on SAI interface.\r
 167 \r
 168          (+) CSS (Clock security system): once enabled, if a HSE clock failure occurs\r
 169             (HSE used directly or through PLL as System clock source), the System clock\r
 170              is automatically switched to HSI and an interrupt is generated if enabled.\r
 171              The interrupt is linked to the Cortex-M4 NMI (Non-Maskable Interrupt)\r
 172              exception vector.\r
 173 \r
 174          (+) MCO (microcontroller clock output): used to output MSI, LSI, HSI, LSE, HSE or\r
 175              main PLL clock (through a configurable prescaler) on PA8 pin.\r
 176 \r
 177     [..] System, AHB and APB busses clocks configuration\r
 178          (+) Several clock sources can be used to drive the System clock (SYSCLK): MSI, HSI,\r
 179              HSE and main PLL.\r
 180              The AHB clock (HCLK) is derived from System clock through configurable\r
 181              prescaler and used to clock the CPU, memory and peripherals mapped\r
 182              on AHB bus (DMA, GPIO...). APB1 (PCLK1) and APB2 (PCLK2) clocks are derived\r
 183              from AHB clock through configurable prescalers and used to clock\r
 184              the peripherals mapped on these busses. You can use\r
 185              "HAL_RCC_GetSysClockFreq()" function to retrieve the frequencies of these clocks.\r
 186 \r
 187          -@- All the peripheral clocks are derived from the System clock (SYSCLK) except:\r
 188 \r
 189            (+@) SAI: the SAI clock can be derived either from a specific PLL (PLLSAI1) or (PLLSAI2) or\r
 190                 from an external clock mapped on the SAI_CKIN pin.\r
 191                 You have to use HAL_RCCEx_PeriphCLKConfig() function to configure this clock.\r
 192            (+@) RTC: the RTC clock can be derived either from the LSI, LSE or HSE clock\r
 193                 divided by 2 to 31.\r
 194                 You have to use __HAL_RCC_RTC_ENABLE() and HAL_RCCEx_PeriphCLKConfig() function\r
 195                 to configure this clock.\r
 196            (+@) USB OTG FS, SDMMC1 and RNG: USB OTG FS requires a frequency equal to 48 MHz\r
 197                 to work correctly, while the SDMMC1 and RNG peripherals require a frequency\r
 198                 equal or lower than to 48 MHz. This clock is derived of the main PLL or PLLSAI1\r
 199                 through PLLQ divider. You have to enable the peripheral clock and use\r
 200                 HAL_RCCEx_PeriphCLKConfig() function to configure this clock.\r
 201            (+@) IWDG clock which is always the LSI clock.\r
 202 \r
 203 \r
 204          (+) The maximum frequency of the SYSCLK, HCLK, PCLK1 and PCLK2 is 80 MHz.\r
 205              The clock source frequency should be adapted depending on the device voltage range\r
 206              as listed in the Reference Manual "Clock source frequency versus voltage scaling" chapter.\r
 207 \r
 208   @endverbatim\r
 209 \r
 210            Table 1. HCLK clock frequency for STM32L4Rx/STM32L4Sx devices\r
 211            +--------------------------------------------------------+\r
 212            | Latency         |     HCLK clock frequency (MHz)       |\r
 213            |                 |--------------------------------------|\r
 214            |                 |  voltage range 1  | voltage range 2  |\r
 215            |                 |       1.2 V       |     1.0 V        |\r
 216            |-----------------|-------------------|------------------|\r
 217            |0WS(1 CPU cycles)|   0 < HCLK <= 20  |  0 < HCLK <= 8   |\r
 218            |-----------------|-------------------|------------------|\r
 219            |1WS(2 CPU cycles)|  20 < HCLK <= 40  |  8 < HCLK <= 16  |\r
 220            |-----------------|-------------------|------------------|\r
 221            |2WS(3 CPU cycles)|  40 < HCLK <= 60  | 16 < HCLK <= 26  |\r
 222            |-----------------|-------------------|------------------|\r
 223            |3WS(4 CPU cycles)|  60 < HCLK <= 80  | 16 < HCLK <= 26  |\r
 224            |-----------------|-------------------|------------------|\r
 225            |4WS(5 CPU cycles)|  80 < HCLK <= 100 | 16 < HCLK <= 26  |\r
 226            |-----------------|-------------------|------------------|\r
 227            |5WS(6 CPU cycles)| 100 < HCLK <= 120 | 16 < HCLK <= 26  |\r
 228            +--------------------------------------------------------+\r
 229 \r
 230            Table 2. HCLK clock frequency for other STM32L4 devices\r
 231            +-------------------------------------------------------+\r
 232            | Latency         |    HCLK clock frequency (MHz)       |\r
 233            |                 |-------------------------------------|\r
 234            |                 | voltage range 1  | voltage range 2  |\r
 235            |                 |      1.2 V       |     1.0 V        |\r
 236            |-----------------|------------------|------------------|\r
 237            |0WS(1 CPU cycles)|  0 < HCLK <= 16  |  0 < HCLK <= 6   |\r
 238            |-----------------|------------------|------------------|\r
 239            |1WS(2 CPU cycles)| 16 < HCLK <= 32  |  6 < HCLK <= 12  |\r
 240            |-----------------|------------------|------------------|\r
 241            |2WS(3 CPU cycles)| 32 < HCLK <= 48  | 12 < HCLK <= 18  |\r
 242            |-----------------|------------------|------------------|\r
 243            |3WS(4 CPU cycles)| 48 < HCLK <= 64  | 18 < HCLK <= 26  |\r
 244            |-----------------|------------------|------------------|\r
 245            |4WS(5 CPU cycles)| 64 < HCLK <= 80  | 18 < HCLK <= 26  |\r
 246            +-------------------------------------------------------+\r
 247   * @{\r
 248   */\r
 249 \r
 250 /**\r
 251   * @brief  Reset the RCC clock configuration to the default reset state.\r
 252   * @note   The default reset state of the clock configuration is given below:\r
 253   *            - MSI ON and used as system clock source\r
 254   *            - HSE, HSI, PLL, PLLSAI1 and PLLSAI2 OFF\r
 255   *            - AHB, APB1 and APB2 prescalers set to 1.\r
 256   *            - CSS, MCO1 OFF\r
 257   *            - All interrupts disabled\r
 258   *            - All interrupt and reset flags cleared\r
 259   * @note   This function does not modify the configuration of the\r
 260   *            - Peripheral clock sources\r
 261   *            - LSI, LSE and RTC clocks (Backup domain)\r
 262   * @retval HAL status\r
 263   */\r
 264 HAL_StatusTypeDef HAL_RCC_DeInit(void)\r
 265 {\r
 266   uint32_t tickstart;\r
 267 \r
 268   /* Reset to default System clock */\r
 269   /* Set MSION bit */\r
 270   SET_BIT(RCC->CR, RCC_CR_MSION);\r
 271 \r
 272   /* Insure MSIRDY bit is set before writing default MSIRANGE value */\r
 273   /* Get start tick */\r
 274   tickstart = HAL_GetTick();\r
 275 \r
 276   /* Wait till MSI is ready */\r
 277   while(READ_BIT(RCC->CR, RCC_CR_MSIRDY) == 0U)\r
 278   {\r
 279     if((HAL_GetTick() - tickstart) > MSI_TIMEOUT_VALUE)\r
 280     {\r
 281       return HAL_TIMEOUT;\r
 282     }\r
 283   }\r
 284 \r
 285   /* Set MSIRANGE default value */\r
 286   MODIFY_REG(RCC->CR, RCC_CR_MSIRANGE, RCC_MSIRANGE_6);\r
 287 \r
 288   /* Reset CFGR register (MSI is selected as system clock source) */\r
 289   CLEAR_REG(RCC->CFGR);\r
 290 \r
 291   /* Update the SystemCoreClock global variable for MSI as system clock source */\r
 292   SystemCoreClock = MSI_VALUE;\r
 293 \r
 294   /* Configure the source of time base considering new system clock settings  */\r
 295   if(HAL_InitTick(uwTickPrio) != HAL_OK)\r
 296   {\r
 297     return HAL_ERROR;\r
 298   }\r
 299 \r
 300   /* Insure MSI selected as system clock source */\r
 301   /* Get start tick */\r
 302   tickstart = HAL_GetTick();\r
 303 \r
 304   /* Wait till system clock source is ready */\r
 305   while(READ_BIT(RCC->CFGR, RCC_CFGR_SWS) != RCC_CFGR_SWS_MSI)\r
 306   {\r
 307     if((HAL_GetTick() - tickstart) > CLOCKSWITCH_TIMEOUT_VALUE)\r
 308     {\r
 309       return HAL_TIMEOUT;\r
 310     }\r
 311   }\r
 312 \r
 313   /* Reset HSION, HSIKERON, HSIASFS, HSEON, HSECSSON, PLLON, PLLSAIxON bits */\r
 314 #if defined(RCC_PLLSAI2_SUPPORT)\r
 315 \r
 316   CLEAR_BIT(RCC->CR, RCC_CR_HSEON | RCC_CR_HSION | RCC_CR_HSIKERON| RCC_CR_HSIASFS | RCC_CR_PLLON | RCC_CR_PLLSAI1ON | RCC_CR_PLLSAI2ON);\r
 317 \r
 318 #elif defined(RCC_PLLSAI1_SUPPORT)\r
 319 \r
 320   CLEAR_BIT(RCC->CR, RCC_CR_HSEON | RCC_CR_HSION | RCC_CR_HSIKERON| RCC_CR_HSIASFS | RCC_CR_PLLON | RCC_CR_PLLSAI1ON);\r
 321 \r
 322 #else\r
 323 \r
 324   CLEAR_BIT(RCC->CR, RCC_CR_HSEON | RCC_CR_HSION | RCC_CR_HSIKERON| RCC_CR_HSIASFS | RCC_CR_PLLON);\r
 325 \r
 326 #endif /* RCC_PLLSAI2_SUPPORT */\r
 327 \r
 328   /* Insure PLLRDY, PLLSAI1RDY and PLLSAI2RDY (if present) are reset */\r
 329   /* Get start tick */\r
 330   tickstart = HAL_GetTick();\r
 331 \r
 332 #if defined(RCC_PLLSAI2_SUPPORT)\r
 333 \r
 334   while(READ_BIT(RCC->CR, RCC_CR_PLLRDY | RCC_CR_PLLSAI1RDY | RCC_CR_PLLSAI2RDY) != 0U)\r
 335 \r
 336 #elif defined(RCC_PLLSAI1_SUPPORT)\r
 337 \r
 338   while(READ_BIT(RCC->CR, RCC_CR_PLLRDY | RCC_CR_PLLSAI1RDY) != 0U)\r
 339 \r
 340 #else\r
 341 \r
 342   while(READ_BIT(RCC->CR, RCC_CR_PLLRDY) != 0U)\r
 343 \r
 344 #endif\r
 345   {\r
 346     if((HAL_GetTick() - tickstart) > PLL_TIMEOUT_VALUE)\r
 347     {\r
 348       return HAL_TIMEOUT;\r
 349     }\r
 350   }\r
 351 \r
 352   /* Reset PLLCFGR register */\r
 353   CLEAR_REG(RCC->PLLCFGR);\r
 354   SET_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLN_4 );\r
 355 \r
 356 #if defined(RCC_PLLSAI1_SUPPORT)\r
 357 \r
 358   /* Reset PLLSAI1CFGR register */\r
 359   CLEAR_REG(RCC->PLLSAI1CFGR);\r
 360   SET_BIT(RCC->PLLSAI1CFGR,  RCC_PLLSAI1CFGR_PLLSAI1N_4 );\r
 361 \r
 362 #endif /* RCC_PLLSAI1_SUPPORT */\r
 363 \r
 364 #if defined(RCC_PLLSAI2_SUPPORT)\r
 365 \r
 366   /* Reset PLLSAI2CFGR register */\r
 367   CLEAR_REG(RCC->PLLSAI2CFGR);\r
 368   SET_BIT(RCC->PLLSAI2CFGR,  RCC_PLLSAI2CFGR_PLLSAI2N_4 );\r
 369 \r
 370 #endif /* RCC_PLLSAI2_SUPPORT */\r
 371 \r
 372   /* Reset HSEBYP bit */\r
 373   CLEAR_BIT(RCC->CR, RCC_CR_HSEBYP);\r
 374 \r
 375   /* Disable all interrupts */\r
 376   CLEAR_REG(RCC->CIER);\r
 377 \r
 378   /* Clear all interrupt flags */\r
 379   WRITE_REG(RCC->CICR, 0xFFFFFFFFU);\r
 380 \r
 381   /* Clear all reset flags */\r
 382   SET_BIT(RCC->CSR, RCC_CSR_RMVF);\r
 383 \r
 384   return HAL_OK;\r
 385 }\r
 386 \r
 387 /**\r
 388   * @brief  Initialize the RCC Oscillators according to the specified parameters in the\r
 389   *         RCC_OscInitTypeDef.\r
 390   * @param  RCC_OscInitStruct  pointer to an RCC_OscInitTypeDef structure that\r
 391   *         contains the configuration information for the RCC Oscillators.\r
 392   * @note   The PLL is not disabled when used as system clock.\r
 393   * @note   Transitions LSE Bypass to LSE On and LSE On to LSE Bypass are not\r
 394   *         supported by this macro. User should request a transition to LSE Off\r
 395   *         first and then LSE On or LSE Bypass.\r
 396   * @note   Transition HSE Bypass to HSE On and HSE On to HSE Bypass are not\r
 397   *         supported by this macro. User should request a transition to HSE Off\r
 398   *         first and then HSE On or HSE Bypass.\r
 399   * @retval HAL status\r
 400   */\r
 401 HAL_StatusTypeDef HAL_RCC_OscConfig(RCC_OscInitTypeDef  *RCC_OscInitStruct)\r
 402 {\r
 403   uint32_t tickstart;\r
 404   HAL_StatusTypeDef status;\r
 405   uint32_t sysclk_source, pll_config;\r
 406 \r
 407   /* Check Null pointer */\r
 408   if(RCC_OscInitStruct == NULL)\r
 409   {\r
 410     return HAL_ERROR;\r
 411   }\r
 412 \r
 413   /* Check the parameters */\r
 414   assert_param(IS_RCC_OSCILLATORTYPE(RCC_OscInitStruct->OscillatorType));\r
 415 \r
 416   sysclk_source = __HAL_RCC_GET_SYSCLK_SOURCE();\r
 417   pll_config = __HAL_RCC_GET_PLL_OSCSOURCE();\r
 418 \r
 419   /*----------------------------- MSI Configuration --------------------------*/\r
 420   if(((RCC_OscInitStruct->OscillatorType) & RCC_OSCILLATORTYPE_MSI) == RCC_OSCILLATORTYPE_MSI)\r
 421   {\r
 422     /* Check the parameters */\r
 423     assert_param(IS_RCC_MSI(RCC_OscInitStruct->MSIState));\r
 424     assert_param(IS_RCC_MSICALIBRATION_VALUE(RCC_OscInitStruct->MSICalibrationValue));\r
 425     assert_param(IS_RCC_MSI_CLOCK_RANGE(RCC_OscInitStruct->MSIClockRange));\r
 426 \r
 427     /* Check if MSI is used as system clock or as PLL source when PLL is selected as system clock */\r
 428     if((sysclk_source == RCC_CFGR_SWS_MSI) ||\r
 429        ((sysclk_source == RCC_CFGR_SWS_PLL) && (pll_config == RCC_PLLSOURCE_MSI)))\r
 430     {\r
 431       if((READ_BIT(RCC->CR, RCC_CR_MSIRDY) != 0U) && (RCC_OscInitStruct->MSIState == RCC_MSI_OFF))\r
 432       {\r
 433         return HAL_ERROR;\r
 434       }\r
 435 \r
 436        /* Otherwise, just the calibration and MSI range change are allowed */\r
 437       else\r
 438       {\r
 439         /* To correctly read data from FLASH memory, the number of wait states (LATENCY)\r
 440            must be correctly programmed according to the frequency of the CPU clock\r
 441            (HCLK) and the supply voltage of the device. */\r
 442         if(RCC_OscInitStruct->MSIClockRange > __HAL_RCC_GET_MSI_RANGE())\r
 443         {\r
 444           /* First increase number of wait states update if necessary */\r
 445           if(RCC_SetFlashLatencyFromMSIRange(RCC_OscInitStruct->MSIClockRange) != HAL_OK)\r
 446           {\r
 447             return HAL_ERROR;\r
 448           }\r
 449 \r
 450           /* Selects the Multiple Speed oscillator (MSI) clock range .*/\r
 451           __HAL_RCC_MSI_RANGE_CONFIG(RCC_OscInitStruct->MSIClockRange);\r
 452           /* Adjusts the Multiple Speed oscillator (MSI) calibration value.*/\r
 453           __HAL_RCC_MSI_CALIBRATIONVALUE_ADJUST(RCC_OscInitStruct->MSICalibrationValue);\r
 454         }\r
 455         else\r
 456         {\r
 457           /* Else, keep current flash latency while decreasing applies */\r
 458           /* Selects the Multiple Speed oscillator (MSI) clock range .*/\r
 459           __HAL_RCC_MSI_RANGE_CONFIG(RCC_OscInitStruct->MSIClockRange);\r
 460           /* Adjusts the Multiple Speed oscillator (MSI) calibration value.*/\r
 461           __HAL_RCC_MSI_CALIBRATIONVALUE_ADJUST(RCC_OscInitStruct->MSICalibrationValue);\r
 462 \r
 463           /* Decrease number of wait states update if necessary */\r
 464           if(RCC_SetFlashLatencyFromMSIRange(RCC_OscInitStruct->MSIClockRange) != HAL_OK)\r
 465           {\r
 466             return HAL_ERROR;\r
 467           }\r
 468         }\r
 469 \r
 470         /* Update the SystemCoreClock global variable */\r
 471         SystemCoreClock = HAL_RCC_GetSysClockFreq() >> (AHBPrescTable[READ_BIT(RCC->CFGR, RCC_CFGR_HPRE) >> RCC_CFGR_HPRE_Pos] & 0x1FU);\r
 472 \r
 473         /* Configure the source of time base considering new system clocks settings*/\r
 474         status = HAL_InitTick(uwTickPrio);\r
 475         if(status != HAL_OK)\r
 476         {\r
 477           return status;\r
 478         }\r
 479       }\r
 480     }\r
 481     else\r
 482     {\r
 483       /* Check the MSI State */\r
 484       if(RCC_OscInitStruct->MSIState != RCC_MSI_OFF)\r
 485       {\r
 486         /* Enable the Internal High Speed oscillator (MSI). */\r
 487         __HAL_RCC_MSI_ENABLE();\r
 488 \r
 489         /* Get timeout */\r
 490         tickstart = HAL_GetTick();\r
 491 \r
 492         /* Wait till MSI is ready */\r
 493         while(READ_BIT(RCC->CR, RCC_CR_MSIRDY) == 0U)\r
 494         {\r
 495           if((HAL_GetTick() - tickstart) > MSI_TIMEOUT_VALUE)\r
 496           {\r
 497             return HAL_TIMEOUT;\r
 498           }\r
 499         }\r
 500          /* Selects the Multiple Speed oscillator (MSI) clock range .*/\r
 501         __HAL_RCC_MSI_RANGE_CONFIG(RCC_OscInitStruct->MSIClockRange);\r
 502          /* Adjusts the Multiple Speed oscillator (MSI) calibration value.*/\r
 503         __HAL_RCC_MSI_CALIBRATIONVALUE_ADJUST(RCC_OscInitStruct->MSICalibrationValue);\r
 504 \r
 505       }\r
 506       else\r
 507       {\r
 508         /* Disable the Internal High Speed oscillator (MSI). */\r
 509         __HAL_RCC_MSI_DISABLE();\r
 510 \r
 511         /* Get timeout */\r
 512         tickstart = HAL_GetTick();\r
 513 \r
 514         /* Wait till MSI is ready */\r
 515         while(READ_BIT(RCC->CR, RCC_CR_MSIRDY) != 0U)\r
 516         {\r
 517           if((HAL_GetTick() - tickstart) > MSI_TIMEOUT_VALUE)\r
 518           {\r
 519             return HAL_TIMEOUT;\r
 520           }\r
 521         }\r
 522       }\r
 523     }\r
 524   }\r
 525   /*------------------------------- HSE Configuration ------------------------*/\r
 526   if(((RCC_OscInitStruct->OscillatorType) & RCC_OSCILLATORTYPE_HSE) == RCC_OSCILLATORTYPE_HSE)\r
 527   {\r
 528     /* Check the parameters */\r
 529     assert_param(IS_RCC_HSE(RCC_OscInitStruct->HSEState));\r
 530 \r
 531     /* When the HSE is used as system clock or clock source for PLL in these cases it is not allowed to be disabled */\r
 532     if((sysclk_source == RCC_CFGR_SWS_HSE) ||\r
 533        ((sysclk_source == RCC_CFGR_SWS_PLL) && (pll_config == RCC_PLLSOURCE_HSE)))\r
 534     {\r
 535       if((READ_BIT(RCC->CR, RCC_CR_HSERDY) != 0U) && (RCC_OscInitStruct->HSEState == RCC_HSE_OFF))\r
 536       {\r
 537         return HAL_ERROR;\r
 538       }\r
 539     }\r
 540     else\r
 541     {\r
 542       /* Set the new HSE configuration ---------------------------------------*/\r
 543       __HAL_RCC_HSE_CONFIG(RCC_OscInitStruct->HSEState);\r
 544 \r
 545       /* Check the HSE State */\r
 546       if(RCC_OscInitStruct->HSEState != RCC_HSE_OFF)\r
 547       {\r
 548         /* Get Start Tick*/\r
 549         tickstart = HAL_GetTick();\r
 550 \r
 551         /* Wait till HSE is ready */\r
 552         while(READ_BIT(RCC->CR, RCC_CR_HSERDY) == 0U)\r
 553         {\r
 554           if((HAL_GetTick() - tickstart) > HSE_TIMEOUT_VALUE)\r
 555           {\r
 556             return HAL_TIMEOUT;\r
 557           }\r
 558         }\r
 559       }\r
 560       else\r
 561       {\r
 562         /* Get Start Tick*/\r
 563         tickstart = HAL_GetTick();\r
 564 \r
 565         /* Wait till HSE is disabled */\r
 566         while(READ_BIT(RCC->CR, RCC_CR_HSERDY) != 0U)\r
 567         {\r
 568           if((HAL_GetTick() - tickstart) > HSE_TIMEOUT_VALUE)\r
 569           {\r
 570             return HAL_TIMEOUT;\r
 571           }\r
 572         }\r
 573       }\r
 574     }\r
 575   }\r
 576   /*----------------------------- HSI Configuration --------------------------*/\r
 577   if(((RCC_OscInitStruct->OscillatorType) & RCC_OSCILLATORTYPE_HSI) == RCC_OSCILLATORTYPE_HSI)\r
 578   {\r
 579     /* Check the parameters */\r
 580     assert_param(IS_RCC_HSI(RCC_OscInitStruct->HSIState));\r
 581     assert_param(IS_RCC_HSI_CALIBRATION_VALUE(RCC_OscInitStruct->HSICalibrationValue));\r
 582 \r
 583     /* Check if HSI is used as system clock or as PLL source when PLL is selected as system clock */\r
 584     if((sysclk_source == RCC_CFGR_SWS_HSI) ||\r
 585        ((sysclk_source == RCC_CFGR_SWS_PLL) && (pll_config == RCC_PLLSOURCE_HSI)))\r
 586     {\r
 587       /* When HSI is used as system clock it will not be disabled */\r
 588       if((READ_BIT(RCC->CR, RCC_CR_HSIRDY) != 0U) && (RCC_OscInitStruct->HSIState == RCC_HSI_OFF))\r
 589       {\r
 590         return HAL_ERROR;\r
 591       }\r
 592       /* Otherwise, just the calibration is allowed */\r
 593       else\r
 594       {\r
 595         /* Adjusts the Internal High Speed oscillator (HSI) calibration value.*/\r
 596         __HAL_RCC_HSI_CALIBRATIONVALUE_ADJUST(RCC_OscInitStruct->HSICalibrationValue);\r
 597       }\r
 598     }\r
 599     else\r
 600     {\r
 601       /* Check the HSI State */\r
 602       if(RCC_OscInitStruct->HSIState != RCC_HSI_OFF)\r
 603       {\r
 604         /* Enable the Internal High Speed oscillator (HSI). */\r
 605         __HAL_RCC_HSI_ENABLE();\r
 606 \r
 607         /* Get Start Tick*/\r
 608         tickstart = HAL_GetTick();\r
 609 \r
 610         /* Wait till HSI is ready */\r
 611         while(READ_BIT(RCC->CR, RCC_CR_HSIRDY) == 0U)\r
 612         {\r
 613           if((HAL_GetTick() - tickstart) > HSI_TIMEOUT_VALUE)\r
 614           {\r
 615             return HAL_TIMEOUT;\r
 616           }\r
 617         }\r
 618 \r
 619         /* Adjusts the Internal High Speed oscillator (HSI) calibration value.*/\r
 620         __HAL_RCC_HSI_CALIBRATIONVALUE_ADJUST(RCC_OscInitStruct->HSICalibrationValue);\r
 621       }\r
 622       else\r
 623       {\r
 624         /* Disable the Internal High Speed oscillator (HSI). */\r
 625         __HAL_RCC_HSI_DISABLE();\r
 626 \r
 627         /* Get Start Tick*/\r
 628         tickstart = HAL_GetTick();\r
 629 \r
 630         /* Wait till HSI is disabled */\r
 631         while(READ_BIT(RCC->CR, RCC_CR_HSIRDY) != 0U)\r
 632         {\r
 633           if((HAL_GetTick() - tickstart) > HSI_TIMEOUT_VALUE)\r
 634           {\r
 635             return HAL_TIMEOUT;\r
 636           }\r
 637         }\r
 638       }\r
 639     }\r
 640   }\r
 641   /*------------------------------ LSI Configuration -------------------------*/\r
 642   if(((RCC_OscInitStruct->OscillatorType) & RCC_OSCILLATORTYPE_LSI) == RCC_OSCILLATORTYPE_LSI)\r
 643   {\r
 644     /* Check the parameters */\r
 645     assert_param(IS_RCC_LSI(RCC_OscInitStruct->LSIState));\r
 646 \r
 647     /* Check the LSI State */\r
 648     if(RCC_OscInitStruct->LSIState != RCC_LSI_OFF)\r
 649     {\r
 650 #if defined(RCC_CSR_LSIPREDIV)\r
 651       uint32_t csr_temp = RCC->CSR;\r
 652 \r
 653       /* Check LSI division factor */\r
 654       assert_param(IS_RCC_LSIDIV(RCC_OscInitStruct->LSIDiv));\r
 655 \r
 656       if (RCC_OscInitStruct->LSIDiv != (csr_temp & RCC_CSR_LSIPREDIV))\r
 657       {\r
 658         if (((csr_temp & RCC_CSR_LSIRDY) == RCC_CSR_LSIRDY) && \\r
 659             ((csr_temp & RCC_CSR_LSION) != RCC_CSR_LSION))\r
 660         {\r
 661            /* If LSIRDY is set while LSION is not enabled,\r
 662               LSIPREDIV can't be updated  */\r
 663           return HAL_ERROR;\r
 664         }\r
 665 \r
 666         /* Turn off LSI before changing RCC_CSR_LSIPREDIV */\r
 667         if ((csr_temp & RCC_CSR_LSION) == RCC_CSR_LSION)\r
 668         {\r
 669           __HAL_RCC_LSI_DISABLE();\r
 670 \r
 671           /* Get Start Tick*/\r
 672           tickstart = HAL_GetTick();\r
 673 \r
 674           /* Wait till LSI is disabled */\r
 675           while(READ_BIT(RCC->CSR, RCC_CSR_LSIRDY) != 0U)\r
 676           {\r
 677             if((HAL_GetTick() - tickstart) > LSI_TIMEOUT_VALUE)\r
 678             {\r
 679               return HAL_TIMEOUT;\r
 680             }\r
 681           }\r
 682         }\r
 683 \r
 684         /* Set LSI division factor */\r
 685         MODIFY_REG(RCC->CSR, RCC_CSR_LSIPREDIV, RCC_OscInitStruct->LSIDiv);\r
 686       }\r
 687 #endif /* RCC_CSR_LSIPREDIV */\r
 688 \r
 689       /* Enable the Internal Low Speed oscillator (LSI). */\r
 690       __HAL_RCC_LSI_ENABLE();\r
 691 \r
 692       /* Get Start Tick*/\r
 693       tickstart = HAL_GetTick();\r
 694 \r
 695       /* Wait till LSI is ready */\r
 696       while(READ_BIT(RCC->CSR, RCC_CSR_LSIRDY) == 0U)\r
 697       {\r
 698         if((HAL_GetTick() - tickstart) > LSI_TIMEOUT_VALUE)\r
 699         {\r
 700           return HAL_TIMEOUT;\r
 701         }\r
 702       }\r
 703     }\r
 704     else\r
 705     {\r
 706       /* Disable the Internal Low Speed oscillator (LSI). */\r
 707       __HAL_RCC_LSI_DISABLE();\r
 708 \r
 709       /* Get Start Tick*/\r
 710       tickstart = HAL_GetTick();\r
 711 \r
 712       /* Wait till LSI is disabled */\r
 713       while(READ_BIT(RCC->CSR, RCC_CSR_LSIRDY) != 0U)\r
 714       {\r
 715         if((HAL_GetTick() - tickstart) > LSI_TIMEOUT_VALUE)\r
 716         {\r
 717           return HAL_TIMEOUT;\r
 718         }\r
 719       }\r
 720     }\r
 721   }\r
 722   /*------------------------------ LSE Configuration -------------------------*/\r
 723   if(((RCC_OscInitStruct->OscillatorType) & RCC_OSCILLATORTYPE_LSE) == RCC_OSCILLATORTYPE_LSE)\r
 724   {\r
 725     FlagStatus       pwrclkchanged = RESET;\r
 726 \r
 727     /* Check the parameters */\r
 728     assert_param(IS_RCC_LSE(RCC_OscInitStruct->LSEState));\r
 729 \r
 730     /* Update LSE configuration in Backup Domain control register    */\r
 731     /* Requires to enable write access to Backup Domain of necessary */\r
 732     if(HAL_IS_BIT_CLR(RCC->APB1ENR1, RCC_APB1ENR1_PWREN))\r
 733     {\r
 734       __HAL_RCC_PWR_CLK_ENABLE();\r
 735       pwrclkchanged = SET;\r
 736     }\r
 737 \r
 738     if(HAL_IS_BIT_CLR(PWR->CR1, PWR_CR1_DBP))\r
 739     {\r
 740       /* Enable write access to Backup domain */\r
 741       SET_BIT(PWR->CR1, PWR_CR1_DBP);\r
 742 \r
 743       /* Wait for Backup domain Write protection disable */\r
 744       tickstart = HAL_GetTick();\r
 745 \r
 746       while(HAL_IS_BIT_CLR(PWR->CR1, PWR_CR1_DBP))\r
 747       {\r
 748         if((HAL_GetTick() - tickstart) > RCC_DBP_TIMEOUT_VALUE)\r
 749         {\r
 750           return HAL_TIMEOUT;\r
 751         }\r
 752       }\r
 753     }\r
 754 \r
 755     /* Set the new LSE configuration -----------------------------------------*/\r
 756 #if defined(RCC_BDCR_LSESYSDIS)\r
 757     if((RCC_OscInitStruct->LSEState & RCC_BDCR_LSEON) != 0U)\r
 758     {\r
 759       /* Set LSESYSDIS bit according to LSE propagation option (enabled or disabled) */\r
 760       MODIFY_REG(RCC->BDCR, RCC_BDCR_LSESYSDIS, (RCC_OscInitStruct->LSEState & RCC_BDCR_LSESYSDIS));\r
 761 \r
 762       if((RCC_OscInitStruct->LSEState & RCC_BDCR_LSEBYP) != 0U)\r
 763       {\r
 764         /* LSE oscillator bypass enable */\r
 765         SET_BIT(RCC->BDCR, RCC_BDCR_LSEBYP);\r
 766         SET_BIT(RCC->BDCR, RCC_BDCR_LSEON);\r
 767       }\r
 768       else\r
 769       {\r
 770         /* LSE oscillator enable */\r
 771         SET_BIT(RCC->BDCR, RCC_BDCR_LSEON);\r
 772       }\r
 773     }\r
 774     else\r
 775     {\r
 776       CLEAR_BIT(RCC->BDCR, RCC_BDCR_LSEON);\r
 777       CLEAR_BIT(RCC->BDCR, RCC_BDCR_LSEBYP);\r
 778     }\r
 779 #else\r
 780     __HAL_RCC_LSE_CONFIG(RCC_OscInitStruct->LSEState);\r
 781 #endif /* RCC_BDCR_LSESYSDIS */\r
 782 \r
 783     /* Check the LSE State */\r
 784     if(RCC_OscInitStruct->LSEState != RCC_LSE_OFF)\r
 785     {\r
 786       /* Get Start Tick*/\r
 787       tickstart = HAL_GetTick();\r
 788 \r
 789       /* Wait till LSE is ready */\r
 790       while(READ_BIT(RCC->BDCR, RCC_BDCR_LSERDY) == 0U)\r
 791       {\r
 792         if((HAL_GetTick() - tickstart) > RCC_LSE_TIMEOUT_VALUE)\r
 793         {\r
 794           return HAL_TIMEOUT;\r
 795         }\r
 796       }\r
 797     }\r
 798     else\r
 799     {\r
 800       /* Get Start Tick*/\r
 801       tickstart = HAL_GetTick();\r
 802 \r
 803       /* Wait till LSE is disabled */\r
 804       while(READ_BIT(RCC->BDCR, RCC_BDCR_LSERDY) != 0U)\r
 805       {\r
 806         if((HAL_GetTick() - tickstart) > RCC_LSE_TIMEOUT_VALUE)\r
 807         {\r
 808           return HAL_TIMEOUT;\r
 809         }\r
 810       }\r
 811 \r
 812 #if defined(RCC_BDCR_LSESYSDIS)\r
 813       /* By default, stop disabling LSE propagation */\r
 814       CLEAR_BIT(RCC->BDCR, RCC_BDCR_LSESYSDIS);\r
 815 #endif /* RCC_BDCR_LSESYSDIS */\r
 816     }\r
 817 \r
 818     /* Restore clock configuration if changed */\r
 819     if(pwrclkchanged == SET)\r
 820     {\r
 821       __HAL_RCC_PWR_CLK_DISABLE();\r
 822     }\r
 823   }\r
 824 #if defined(RCC_HSI48_SUPPORT)\r
 825   /*------------------------------ HSI48 Configuration -----------------------*/\r
 826   if(((RCC_OscInitStruct->OscillatorType) & RCC_OSCILLATORTYPE_HSI48) == RCC_OSCILLATORTYPE_HSI48)\r
 827   {\r
 828     /* Check the parameters */\r
 829     assert_param(IS_RCC_HSI48(RCC_OscInitStruct->HSI48State));\r
 830 \r
 831     /* Check the LSI State */\r
 832     if(RCC_OscInitStruct->HSI48State != RCC_HSI48_OFF)\r
 833     {\r
 834       /* Enable the Internal Low Speed oscillator (HSI48). */\r
 835       __HAL_RCC_HSI48_ENABLE();\r
 836 \r
 837       /* Get Start Tick*/\r
 838       tickstart = HAL_GetTick();\r
 839 \r
 840       /* Wait till HSI48 is ready */\r
 841       while(READ_BIT(RCC->CRRCR, RCC_CRRCR_HSI48RDY) == 0U)\r
 842       {\r
 843         if((HAL_GetTick() - tickstart) > HSI48_TIMEOUT_VALUE)\r
 844         {\r
 845           return HAL_TIMEOUT;\r
 846         }\r
 847       }\r
 848     }\r
 849     else\r
 850     {\r
 851       /* Disable the Internal Low Speed oscillator (HSI48). */\r
 852       __HAL_RCC_HSI48_DISABLE();\r
 853 \r
 854       /* Get Start Tick*/\r
 855       tickstart = HAL_GetTick();\r
 856 \r
 857       /* Wait till HSI48 is disabled */\r
 858       while(READ_BIT(RCC->CRRCR, RCC_CRRCR_HSI48RDY) != 0U)\r
 859       {\r
 860         if((HAL_GetTick() - tickstart) > HSI48_TIMEOUT_VALUE)\r
 861         {\r
 862           return HAL_TIMEOUT;\r
 863         }\r
 864       }\r
 865     }\r
 866   }\r
 867 #endif /* RCC_HSI48_SUPPORT */\r
 868   /*-------------------------------- PLL Configuration -----------------------*/\r
 869   /* Check the parameters */\r
 870   assert_param(IS_RCC_PLL(RCC_OscInitStruct->PLL.PLLState));\r
 871 \r
 872   if(RCC_OscInitStruct->PLL.PLLState != RCC_PLL_NONE)\r
 873   {\r
 874     /* Check if the PLL is used as system clock or not */\r
 875     if(sysclk_source != RCC_CFGR_SWS_PLL)\r
 876     {\r
 877       if(RCC_OscInitStruct->PLL.PLLState == RCC_PLL_ON)\r
 878       {\r
 879         /* Check the parameters */\r
 880         assert_param(IS_RCC_PLLSOURCE(RCC_OscInitStruct->PLL.PLLSource));\r
 881         assert_param(IS_RCC_PLLM_VALUE(RCC_OscInitStruct->PLL.PLLM));\r
 882         assert_param(IS_RCC_PLLN_VALUE(RCC_OscInitStruct->PLL.PLLN));\r
 883 #if defined(RCC_PLLP_SUPPORT)\r
 884         assert_param(IS_RCC_PLLP_VALUE(RCC_OscInitStruct->PLL.PLLP));\r
 885 #endif /* RCC_PLLP_SUPPORT */\r
 886         assert_param(IS_RCC_PLLQ_VALUE(RCC_OscInitStruct->PLL.PLLQ));\r
 887         assert_param(IS_RCC_PLLR_VALUE(RCC_OscInitStruct->PLL.PLLR));\r
 888 \r
 889         /* Disable the main PLL. */\r
 890         __HAL_RCC_PLL_DISABLE();\r
 891 \r
 892         /* Get Start Tick*/\r
 893         tickstart = HAL_GetTick();\r
 894 \r
 895         /* Wait till PLL is ready */\r
 896         while(READ_BIT(RCC->CR, RCC_CR_PLLRDY) != 0U)\r
 897         {\r
 898           if((HAL_GetTick() - tickstart) > PLL_TIMEOUT_VALUE)\r
 899           {\r
 900             return HAL_TIMEOUT;\r
 901           }\r
 902         }\r
 903 \r
 904         /* Configure the main PLL clock source, multiplication and division factors. */\r
 905         __HAL_RCC_PLL_CONFIG(RCC_OscInitStruct->PLL.PLLSource,\r
 906                              RCC_OscInitStruct->PLL.PLLM,\r
 907                              RCC_OscInitStruct->PLL.PLLN,\r
 908 #if defined(RCC_PLLP_SUPPORT)\r
 909                              RCC_OscInitStruct->PLL.PLLP,\r
 910 #endif\r
 911                              RCC_OscInitStruct->PLL.PLLQ,\r
 912                              RCC_OscInitStruct->PLL.PLLR);\r
 913 \r
 914         /* Enable the main PLL. */\r
 915         __HAL_RCC_PLL_ENABLE();\r
 916 \r
 917         /* Enable PLL System Clock output. */\r
 918         __HAL_RCC_PLLCLKOUT_ENABLE(RCC_PLL_SYSCLK);\r
 919 \r
 920         /* Get Start Tick*/\r
 921         tickstart = HAL_GetTick();\r
 922 \r
 923         /* Wait till PLL is ready */\r
 924         while(READ_BIT(RCC->CR, RCC_CR_PLLRDY) == 0U)\r
 925         {\r
 926           if((HAL_GetTick() - tickstart) > PLL_TIMEOUT_VALUE)\r
 927           {\r
 928             return HAL_TIMEOUT;\r
 929           }\r
 930         }\r
 931       }\r
 932       else\r
 933       {\r
 934         /* Disable the main PLL. */\r
 935         __HAL_RCC_PLL_DISABLE();\r
 936 \r
 937         /* Disable all PLL outputs to save power if no PLLs on */\r
 938 #if defined(RCC_PLLSAI1_SUPPORT) && defined(RCC_CR_PLLSAI2RDY)\r
 939         if(READ_BIT(RCC->CR, (RCC_CR_PLLSAI1RDY | RCC_CR_PLLSAI2RDY)) == 0U)\r
 940         {\r
 941           MODIFY_REG(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC, RCC_PLLSOURCE_NONE);\r
 942         }\r
 943 #elif defined(RCC_PLLSAI1_SUPPORT)\r
 944         if(READ_BIT(RCC->CR, RCC_CR_PLLSAI1RDY) == 0U)\r
 945         {\r
 946           MODIFY_REG(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC, RCC_PLLSOURCE_NONE);\r
 947         }\r
 948 #else\r
 949         MODIFY_REG(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC, RCC_PLLSOURCE_NONE);\r
 950 #endif /* RCC_PLLSAI1_SUPPORT && RCC_CR_PLLSAI2RDY */\r
 951 \r
 952 #if defined(RCC_PLLSAI2_SUPPORT)\r
 953         __HAL_RCC_PLLCLKOUT_DISABLE(RCC_PLL_SYSCLK | RCC_PLL_48M1CLK | RCC_PLL_SAI3CLK);\r
 954 #elif defined(RCC_PLLSAI1_SUPPORT)\r
 955         __HAL_RCC_PLLCLKOUT_DISABLE(RCC_PLL_SYSCLK | RCC_PLL_48M1CLK | RCC_PLL_SAI2CLK);\r
 956 #else\r
 957         __HAL_RCC_PLLCLKOUT_DISABLE(RCC_PLL_SYSCLK | RCC_PLL_48M1CLK);\r
 958 #endif /* RCC_PLLSAI2_SUPPORT */\r
 959 \r
 960         /* Get Start Tick*/\r
 961         tickstart = HAL_GetTick();\r
 962 \r
 963         /* Wait till PLL is disabled */\r
 964         while(READ_BIT(RCC->CR, RCC_CR_PLLRDY) != 0U)\r
 965         {\r
 966           if((HAL_GetTick() - tickstart) > PLL_TIMEOUT_VALUE)\r
 967           {\r
 968             return HAL_TIMEOUT;\r
 969           }\r
 970         }\r
 971       }\r
 972     }\r
 973     else\r
 974     {\r
 975       /* Check if there is a request to disable the PLL used as System clock source */\r
 976       if((RCC_OscInitStruct->PLL.PLLState) == RCC_PLL_OFF)\r
 977       {\r
 978         return HAL_ERROR;\r
 979       }\r
 980       else\r
 981       {\r
 982         pll_config = RCC->PLLCFGR;\r
 983         /* Do not return HAL_ERROR if request repeats the current configuration */\r
 984         if((READ_BIT(pll_config, RCC_PLLCFGR_PLLSRC)  != RCC_OscInitStruct->PLL.PLLSource) ||\r
 985            (READ_BIT(pll_config, RCC_PLLCFGR_PLLM)    != ((RCC_OscInitStruct->PLL.PLLM - 1U) << RCC_PLLCFGR_PLLM_Pos)) ||\r
 986            (READ_BIT(pll_config, RCC_PLLCFGR_PLLN)    != (RCC_OscInitStruct->PLL.PLLN << RCC_PLLCFGR_PLLN_Pos)) ||\r
 987 #if defined(RCC_PLLP_SUPPORT)\r
 988 #if defined(RCC_PLLP_DIV_2_31_SUPPORT)\r
 989            (READ_BIT(pll_config, RCC_PLLCFGR_PLLPDIV) != (RCC_OscInitStruct->PLL.PLLP << RCC_PLLCFGR_PLLPDIV_Pos)) ||\r
 990 #else\r
 991            (READ_BIT(pll_config, RCC_PLLCFGR_PLLP)    != ((RCC_OscInitStruct->PLL.PLLP == RCC_PLLP_DIV7) ? 0U : 1U)) ||\r
 992 #endif\r
 993 #endif\r
 994            (READ_BIT(pll_config, RCC_PLLCFGR_PLLQ)    != ((((RCC_OscInitStruct->PLL.PLLQ) >> 1U) - 1U) << RCC_PLLCFGR_PLLQ_Pos)) ||\r
 995            (READ_BIT(pll_config, RCC_PLLCFGR_PLLR)    != ((((RCC_OscInitStruct->PLL.PLLR) >> 1U) - 1U) << RCC_PLLCFGR_PLLR_Pos)))\r
 996         {\r
 997           return HAL_ERROR;\r
 998         }\r
 999       }\r
1000     }\r
1001   }\r
1002   return HAL_OK;\r
1003 }\r
1004 \r
1005 /**\r
1006   * @brief  Initialize the CPU, AHB and APB busses clocks according to the specified\r
1007   *         parameters in the RCC_ClkInitStruct.\r
1008   * @param  RCC_ClkInitStruct  pointer to an RCC_OscInitTypeDef structure that\r
1009   *         contains the configuration information for the RCC peripheral.\r
1010   * @param  FLatency  FLASH Latency\r
1011   *          This parameter can be one of the following values:\r
1012   *            @arg FLASH_LATENCY_0   FLASH 0 Latency cycle\r
1013   *            @arg FLASH_LATENCY_1   FLASH 1 Latency cycle\r
1014   *            @arg FLASH_LATENCY_2   FLASH 2 Latency cycles\r
1015   *            @arg FLASH_LATENCY_3   FLASH 3 Latency cycles\r
1016   *            @arg FLASH_LATENCY_4   FLASH 4 Latency cycles\r
1017   @if STM32L4S9xx\r
1018   *            @arg FLASH_LATENCY_5   FLASH 5 Latency cycles\r
1019   *            @arg FLASH_LATENCY_6   FLASH 6 Latency cycles\r
1020   *            @arg FLASH_LATENCY_7   FLASH 7 Latency cycles\r
1021   *            @arg FLASH_LATENCY_8   FLASH 8 Latency cycles\r
1022   *            @arg FLASH_LATENCY_9   FLASH 9 Latency cycles\r
1023   *            @arg FLASH_LATENCY_10  FLASH 10 Latency cycles\r
1024   *            @arg FLASH_LATENCY_11  FLASH 11 Latency cycles\r
1025   *            @arg FLASH_LATENCY_12  FLASH 12 Latency cycles\r
1026   *            @arg FLASH_LATENCY_13  FLASH 13 Latency cycles\r
1027   *            @arg FLASH_LATENCY_14  FLASH 14 Latency cycles\r
1028   *            @arg FLASH_LATENCY_15  FLASH 15 Latency cycles\r
1029   @endif\r
1030   *\r
1031   * @note   The SystemCoreClock CMSIS variable is used to store System Clock Frequency\r
1032   *         and updated by HAL_RCC_GetHCLKFreq() function called within this function\r
1033   *\r
1034   * @note   The MSI is used by default as system clock source after\r
1035   *         startup from Reset, wake-up from STANDBY mode. After restart from Reset,\r
1036   *         the MSI frequency is set to its default value 4 MHz.\r
1037   *\r
1038   * @note   The HSI can be selected as system clock source after\r
1039   *         from STOP modes or in case of failure of the HSE used directly or indirectly\r
1040   *         as system clock (if the Clock Security System CSS is enabled).\r
1041   *\r
1042   * @note   A switch from one clock source to another occurs only if the target\r
1043   *         clock source is ready (clock stable after startup delay or PLL locked).\r
1044   *         If a clock source which is not yet ready is selected, the switch will\r
1045   *         occur when the clock source is ready.\r
1046   *\r
1047   * @note   You can use HAL_RCC_GetClockConfig() function to know which clock is\r
1048   *         currently used as system clock source.\r
1049   *\r
1050   * @note   Depending on the device voltage range, the software has to set correctly\r
1051   *         HPRE[3:0] bits to ensure that HCLK not exceed the maximum allowed frequency\r
1052   *         (for more details refer to section above "Initialization/de-initialization functions")\r
1053   * @retval None\r
1054   */\r
1055 HAL_StatusTypeDef HAL_RCC_ClockConfig(RCC_ClkInitTypeDef  *RCC_ClkInitStruct, uint32_t FLatency)\r
1056 {\r
1057   uint32_t tickstart;\r
1058 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)\r
1059   uint32_t hpre = RCC_SYSCLK_DIV1;\r
1060 #endif\r
1061   HAL_StatusTypeDef status;\r
1062 \r
1063   /* Check Null pointer */\r
1064   if(RCC_ClkInitStruct == NULL)\r
1065   {\r
1066     return HAL_ERROR;\r
1067   }\r
1068 \r
1069   /* Check the parameters */\r
1070   assert_param(IS_RCC_CLOCKTYPE(RCC_ClkInitStruct->ClockType));\r
1071   assert_param(IS_FLASH_LATENCY(FLatency));\r
1072 \r
1073   /* To correctly read data from FLASH memory, the number of wait states (LATENCY)\r
1074     must be correctly programmed according to the frequency of the CPU clock\r
1075     (HCLK) and the supply voltage of the device. */\r
1076 \r
1077   /* Increasing the number of wait states because of higher CPU frequency */\r
1078   if(FLatency > __HAL_FLASH_GET_LATENCY())\r
1079   {\r
1080     /* Program the new number of wait states to the LATENCY bits in the FLASH_ACR register */\r
1081     __HAL_FLASH_SET_LATENCY(FLatency);\r
1082 \r
1083     /* Check that the new number of wait states is taken into account to access the Flash\r
1084     memory by reading the FLASH_ACR register */\r
1085     if(__HAL_FLASH_GET_LATENCY() != FLatency)\r
1086     {\r
1087       return HAL_ERROR;\r
1088     }\r
1089   }\r
1090 \r
1091   /*------------------------- SYSCLK Configuration ---------------------------*/\r
1092   if(((RCC_ClkInitStruct->ClockType) & RCC_CLOCKTYPE_SYSCLK) == RCC_CLOCKTYPE_SYSCLK)\r
1093   {\r
1094     assert_param(IS_RCC_SYSCLKSOURCE(RCC_ClkInitStruct->SYSCLKSource));\r
1095 \r
1096     /* PLL is selected as System Clock Source */\r
1097     if(RCC_ClkInitStruct->SYSCLKSource == RCC_SYSCLKSOURCE_PLLCLK)\r
1098     {\r
1099       /* Check the PLL ready flag */\r
1100       if(READ_BIT(RCC->CR, RCC_CR_PLLRDY) == 0U)\r
1101       {\r
1102         return HAL_ERROR;\r
1103       }\r
1104 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)\r
1105       /* Undershoot management when selection PLL as SYSCLK source and frequency above 80Mhz */\r
1106       /* Compute target PLL output frequency */\r
1107       if(RCC_GetSysClockFreqFromPLLSource() > 80000000U)\r
1108       {\r
1109         if(READ_BIT(RCC->CFGR, RCC_CFGR_HPRE) == RCC_SYSCLK_DIV1)\r
1110         {\r
1111           /* Intermediate step with HCLK prescaler 2 necessary before to go over 80Mhz */\r
1112           MODIFY_REG(RCC->CFGR, RCC_CFGR_HPRE, RCC_SYSCLK_DIV2);\r
1113           hpre = RCC_SYSCLK_DIV2;\r
1114         }\r
1115         else if((((RCC_ClkInitStruct->ClockType) & RCC_CLOCKTYPE_HCLK) == RCC_CLOCKTYPE_HCLK) && (RCC_ClkInitStruct->AHBCLKDivider == RCC_SYSCLK_DIV1))\r
1116         {\r
1117           /* Intermediate step with HCLK prescaler 2 necessary before to go over 80Mhz */\r
1118           MODIFY_REG(RCC->CFGR, RCC_CFGR_HPRE, RCC_SYSCLK_DIV2);\r
1119           hpre = RCC_SYSCLK_DIV2;\r
1120         }\r
1121         else\r
1122         {\r
1123           /* nothing to do */\r
1124         }\r
1125       }\r
1126 #endif\r
1127     }\r
1128     else\r
1129     {\r
1130       /* HSE is selected as System Clock Source */\r
1131       if(RCC_ClkInitStruct->SYSCLKSource == RCC_SYSCLKSOURCE_HSE)\r
1132       {\r
1133         /* Check the HSE ready flag */\r
1134         if(READ_BIT(RCC->CR, RCC_CR_HSERDY) == 0U)\r
1135         {\r
1136           return HAL_ERROR;\r
1137         }\r
1138       }\r
1139       /* MSI is selected as System Clock Source */\r
1140       else if(RCC_ClkInitStruct->SYSCLKSource == RCC_SYSCLKSOURCE_MSI)\r
1141       {\r
1142         /* Check the MSI ready flag */\r
1143         if(READ_BIT(RCC->CR, RCC_CR_MSIRDY) == 0U)\r
1144         {\r
1145           return HAL_ERROR;\r
1146         }\r
1147       }\r
1148       /* HSI is selected as System Clock Source */\r
1149       else\r
1150       {\r
1151         /* Check the HSI ready flag */\r
1152         if(READ_BIT(RCC->CR, RCC_CR_HSIRDY) == 0U)\r
1153         {\r
1154           return HAL_ERROR;\r
1155         }\r
1156       }\r
1157 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)\r
1158       /* Overshoot management when going down from PLL as SYSCLK source and frequency above 80Mhz */\r
1159       if(HAL_RCC_GetSysClockFreq() > 80000000U)\r
1160       {\r
1161         /* Intermediate step with HCLK prescaler 2 necessary before to go under 80Mhz */\r
1162         MODIFY_REG(RCC->CFGR, RCC_CFGR_HPRE, RCC_SYSCLK_DIV2);\r
1163         hpre = RCC_SYSCLK_DIV2;\r
1164       }\r
1165 #endif\r
1166 \r
1167     }\r
1168 \r
1169     MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_ClkInitStruct->SYSCLKSource);\r
1170 \r
1171     /* Get Start Tick*/\r
1172     tickstart = HAL_GetTick();\r
1173 \r
1174     while(__HAL_RCC_GET_SYSCLK_SOURCE() != (RCC_ClkInitStruct->SYSCLKSource << RCC_CFGR_SWS_Pos))\r
1175     {\r
1176       if((HAL_GetTick() - tickstart) > CLOCKSWITCH_TIMEOUT_VALUE)\r
1177       {\r
1178         return HAL_TIMEOUT;\r
1179       }\r
1180     }\r
1181   }\r
1182 \r
1183   /*-------------------------- HCLK Configuration --------------------------*/\r
1184   if(((RCC_ClkInitStruct->ClockType) & RCC_CLOCKTYPE_HCLK) == RCC_CLOCKTYPE_HCLK)\r
1185   {\r
1186     assert_param(IS_RCC_HCLK(RCC_ClkInitStruct->AHBCLKDivider));\r
1187     MODIFY_REG(RCC->CFGR, RCC_CFGR_HPRE, RCC_ClkInitStruct->AHBCLKDivider);\r
1188   }\r
1189 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)\r
1190   else\r
1191   {\r
1192     /* Is intermediate HCLK prescaler 2 applied internally, complete with HCLK prescaler 1 */\r
1193     if(hpre == RCC_SYSCLK_DIV2)\r
1194     {\r
1195       MODIFY_REG(RCC->CFGR, RCC_CFGR_HPRE, RCC_SYSCLK_DIV1);\r
1196     }\r
1197   }\r
1198 #endif\r
1199 \r
1200   /* Decreasing the number of wait states because of lower CPU frequency */\r
1201   if(FLatency < __HAL_FLASH_GET_LATENCY())\r
1202   {\r
1203     /* Program the new number of wait states to the LATENCY bits in the FLASH_ACR register */\r
1204     __HAL_FLASH_SET_LATENCY(FLatency);\r
1205 \r
1206     /* Check that the new number of wait states is taken into account to access the Flash\r
1207     memory by reading the FLASH_ACR register */\r
1208     if(__HAL_FLASH_GET_LATENCY() != FLatency)\r
1209     {\r
1210       return HAL_ERROR;\r
1211     }\r
1212   }\r
1213 \r
1214   /*-------------------------- PCLK1 Configuration ---------------------------*/\r
1215   if(((RCC_ClkInitStruct->ClockType) & RCC_CLOCKTYPE_PCLK1) == RCC_CLOCKTYPE_PCLK1)\r
1216   {\r
1217     assert_param(IS_RCC_PCLK(RCC_ClkInitStruct->APB1CLKDivider));\r
1218     MODIFY_REG(RCC->CFGR, RCC_CFGR_PPRE1, RCC_ClkInitStruct->APB1CLKDivider);\r
1219   }\r
1220 \r
1221   /*-------------------------- PCLK2 Configuration ---------------------------*/\r
1222   if(((RCC_ClkInitStruct->ClockType) & RCC_CLOCKTYPE_PCLK2) == RCC_CLOCKTYPE_PCLK2)\r
1223   {\r
1224     assert_param(IS_RCC_PCLK(RCC_ClkInitStruct->APB2CLKDivider));\r
1225     MODIFY_REG(RCC->CFGR, RCC_CFGR_PPRE2, ((RCC_ClkInitStruct->APB2CLKDivider) << 3U));\r
1226   }\r
1227 \r
1228   /* Update the SystemCoreClock global variable */\r
1229   SystemCoreClock = HAL_RCC_GetSysClockFreq() >> (AHBPrescTable[READ_BIT(RCC->CFGR, RCC_CFGR_HPRE) >> RCC_CFGR_HPRE_Pos] & 0x1FU);\r
1230 \r
1231   /* Configure the source of time base considering new system clocks settings*/\r
1232   status = HAL_InitTick(uwTickPrio);\r
1233 \r
1234   return status;\r
1235 }\r
1236 \r
1237 /**\r
1238   * @}\r
1239   */\r
1240 \r
1241 /** @defgroup RCC_Exported_Functions_Group2 Peripheral Control functions\r
1242  *  @brief   RCC clocks control functions\r
1243  *\r
1244 @verbatim\r
1245  ===============================================================================\r
1246                       ##### Peripheral Control functions #####\r
1247  ===============================================================================\r
1248     [..]\r
1249     This subsection provides a set of functions allowing to:\r
1250 \r
1251     (+) Ouput clock to MCO pin.\r
1252     (+) Retrieve current clock frequencies.\r
1253     (+) Enable the Clock Security System.\r
1254 \r
1255 @endverbatim\r
1256   * @{\r
1257   */\r
1258 \r
1259 /**\r
1260   * @brief  Select the clock source to output on MCO pin(PA8).\r
1261   * @note   PA8 should be configured in alternate function mode.\r
1262   * @param  RCC_MCOx  specifies the output direction for the clock source.\r
1263   *          For STM32L4xx family this parameter can have only one value:\r
1264   *            @arg @ref RCC_MCO1  Clock source to output on MCO1 pin(PA8).\r
1265   * @param  RCC_MCOSource  specifies the clock source to output.\r
1266   *          This parameter can be one of the following values:\r
1267   *            @arg @ref RCC_MCO1SOURCE_NOCLOCK  MCO output disabled, no clock on MCO\r
1268   *            @arg @ref RCC_MCO1SOURCE_SYSCLK  system  clock selected as MCO source\r
1269   *            @arg @ref RCC_MCO1SOURCE_MSI  MSI clock selected as MCO source\r
1270   *            @arg @ref RCC_MCO1SOURCE_HSI  HSI clock selected as MCO source\r
1271   *            @arg @ref RCC_MCO1SOURCE_HSE  HSE clock selected as MCO sourcee\r
1272   *            @arg @ref RCC_MCO1SOURCE_PLLCLK  main PLL clock selected as MCO source\r
1273   *            @arg @ref RCC_MCO1SOURCE_LSI  LSI clock selected as MCO source\r
1274   *            @arg @ref RCC_MCO1SOURCE_LSE  LSE clock selected as MCO source\r
1275   @if STM32L443xx\r
1276   *            @arg @ref RCC_MCO1SOURCE_HSI48  HSI48 clock selected as MCO source for devices with HSI48\r
1277   @endif\r
1278   * @param  RCC_MCODiv  specifies the MCO prescaler.\r
1279   *          This parameter can be one of the following values:\r
1280   *            @arg @ref RCC_MCODIV_1  no division applied to MCO clock\r
1281   *            @arg @ref RCC_MCODIV_2  division by 2 applied to MCO clock\r
1282   *            @arg @ref RCC_MCODIV_4  division by 4 applied to MCO clock\r
1283   *            @arg @ref RCC_MCODIV_8  division by 8 applied to MCO clock\r
1284   *            @arg @ref RCC_MCODIV_16  division by 16 applied to MCO clock\r
1285   * @retval None\r
1286   */\r
1287 void HAL_RCC_MCOConfig( uint32_t RCC_MCOx, uint32_t RCC_MCOSource, uint32_t RCC_MCODiv)\r
1288 {\r
1289   GPIO_InitTypeDef GPIO_InitStruct;\r
1290 \r
1291   /* Check the parameters */\r
1292   assert_param(IS_RCC_MCO(RCC_MCOx));\r
1293   assert_param(IS_RCC_MCODIV(RCC_MCODiv));\r
1294   assert_param(IS_RCC_MCO1SOURCE(RCC_MCOSource));\r
1295 \r
1296   /* Prevent unused argument(s) compilation warning if no assert_param check */\r
1297   UNUSED(RCC_MCOx);\r
1298 \r
1299   /* MCO Clock Enable */\r
1300   __MCO1_CLK_ENABLE();\r
1301 \r
1302   /* Configue the MCO1 pin in alternate function mode */\r
1303   GPIO_InitStruct.Pin = MCO1_PIN;\r
1304   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;\r
1305   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;\r
1306   GPIO_InitStruct.Pull = GPIO_NOPULL;\r
1307   GPIO_InitStruct.Alternate = GPIO_AF0_MCO;\r
1308   HAL_GPIO_Init(MCO1_GPIO_PORT, &GPIO_InitStruct);\r
1309 \r
1310   /* Mask MCOSEL[] and MCOPRE[] bits then set MCO1 clock source and prescaler */\r
1311   MODIFY_REG(RCC->CFGR, (RCC_CFGR_MCOSEL | RCC_CFGR_MCOPRE), (RCC_MCOSource | RCC_MCODiv ));\r
1312 }\r
1313 \r
1314 /**\r
1315   * @brief  Return the SYSCLK frequency.\r
1316   *\r
1317   * @note   The system frequency computed by this function is not the real\r
1318   *         frequency in the chip. It is calculated based on the predefined\r
1319   *         constant and the selected clock source:\r
1320   * @note     If SYSCLK source is MSI, function returns values based on MSI\r
1321   *             Value as defined by the MSI range.\r
1322   * @note     If SYSCLK source is HSI, function returns values based on HSI_VALUE(*)\r
1323   * @note     If SYSCLK source is HSE, function returns values based on HSE_VALUE(**)\r
1324   * @note     If SYSCLK source is PLL, function returns values based on HSE_VALUE(**),\r
1325   *           HSI_VALUE(*) or MSI Value multiplied/divided by the PLL factors.\r
1326   * @note     (*) HSI_VALUE is a constant defined in stm32l4xx_hal_conf.h file (default value\r
1327   *               16 MHz) but the real value may vary depending on the variations\r
1328   *               in voltage and temperature.\r
1329   * @note     (**) HSE_VALUE is a constant defined in stm32l4xx_hal_conf.h file (default value\r
1330   *                8 MHz), user has to ensure that HSE_VALUE is same as the real\r
1331   *                frequency of the crystal used. Otherwise, this function may\r
1332   *                have wrong result.\r
1333   *\r
1334   * @note   The result of this function could be not correct when using fractional\r
1335   *         value for HSE crystal.\r
1336   *\r
1337   * @note   This function can be used by the user application to compute the\r
1338   *         baudrate for the communication peripherals or configure other parameters.\r
1339   *\r
1340   * @note   Each time SYSCLK changes, this function must be called to update the\r
1341   *         right SYSCLK value. Otherwise, any configuration based on this function will be incorrect.\r
1342   *\r
1343   *\r
1344   * @retval SYSCLK frequency\r
1345   */\r
1346 uint32_t HAL_RCC_GetSysClockFreq(void)\r
1347 {\r
1348   uint32_t msirange = 0U, sysclockfreq = 0U;\r
1349   uint32_t pllvco, pllsource, pllr, pllm;    /* no init needed */\r
1350   uint32_t sysclk_source, pll_oscsource;\r
1351 \r
1352   sysclk_source = __HAL_RCC_GET_SYSCLK_SOURCE();\r
1353   pll_oscsource = __HAL_RCC_GET_PLL_OSCSOURCE();\r
1354 \r
1355   if((sysclk_source == RCC_CFGR_SWS_MSI) ||\r
1356      ((sysclk_source == RCC_CFGR_SWS_PLL) && (pll_oscsource == RCC_PLLSOURCE_MSI)))\r
1357   {\r
1358     /* MSI or PLL with MSI source used as system clock source */\r
1359 \r
1360     /* Get SYSCLK source */\r
1361     if(READ_BIT(RCC->CR, RCC_CR_MSIRGSEL) == 0U)\r
1362     { /* MSISRANGE from RCC_CSR applies */\r
1363       msirange = READ_BIT(RCC->CSR, RCC_CSR_MSISRANGE) >> RCC_CSR_MSISRANGE_Pos;\r
1364     }\r
1365     else\r
1366     { /* MSIRANGE from RCC_CR applies */\r
1367       msirange = READ_BIT(RCC->CR, RCC_CR_MSIRANGE) >> RCC_CR_MSIRANGE_Pos;\r
1368     }\r
1369     /*MSI frequency range in HZ*/\r
1370     msirange = MSIRangeTable[msirange];\r
1371 \r
1372     if(sysclk_source == RCC_CFGR_SWS_MSI)\r
1373     {\r
1374       /* MSI used as system clock source */\r
1375       sysclockfreq = msirange;\r
1376     }\r
1377   }\r
1378   else if(sysclk_source == RCC_CFGR_SWS_HSI)\r
1379   {\r
1380     /* HSI used as system clock source */\r
1381     sysclockfreq = HSI_VALUE;\r
1382   }\r
1383   else if(sysclk_source == RCC_CFGR_SWS_HSE)\r
1384   {\r
1385     /* HSE used as system clock source */\r
1386     sysclockfreq = HSE_VALUE;\r
1387   }\r
1388   else\r
1389   {\r
1390     /* unexpected case: sysclockfreq at 0 */\r
1391   }\r
1392 \r
1393   if(sysclk_source == RCC_CFGR_SWS_PLL)\r
1394   {\r
1395     /* PLL used as system clock  source */\r
1396 \r
1397     /* PLL_VCO = (HSE_VALUE or HSI_VALUE or MSI_VALUE) * PLLN / PLLM\r
1398     SYSCLK = PLL_VCO / PLLR\r
1399     */\r
1400     pllsource = READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC);\r
1401 \r
1402     switch (pllsource)\r
1403     {\r
1404     case RCC_PLLSOURCE_HSI:  /* HSI used as PLL clock source */\r
1405       pllvco = HSI_VALUE;\r
1406       break;\r
1407 \r
1408     case RCC_PLLSOURCE_HSE:  /* HSE used as PLL clock source */\r
1409       pllvco = HSE_VALUE;\r
1410       break;\r
1411 \r
1412     case RCC_PLLSOURCE_MSI:  /* MSI used as PLL clock source */\r
1413     default:\r
1414       pllvco = msirange;\r
1415       break;\r
1416     }\r
1417     pllm = (READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLM) >> RCC_PLLCFGR_PLLM_Pos) + 1U ;\r
1418     pllvco = (pllvco * (READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLN) >> RCC_PLLCFGR_PLLN_Pos)) / pllm;\r
1419     pllr = ((READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLR) >> RCC_PLLCFGR_PLLR_Pos) + 1U ) * 2U;\r
1420     sysclockfreq = pllvco / pllr;\r
1421   }\r
1422 \r
1423   return sysclockfreq;\r
1424 }\r
1425 \r
1426 /**\r
1427   * @brief  Return the HCLK frequency.\r
1428   * @note   Each time HCLK changes, this function must be called to update the\r
1429   *         right HCLK value. Otherwise, any configuration based on this function will be incorrect.\r
1430   *\r
1431   * @note   The SystemCoreClock CMSIS variable is used to store System Clock Frequency.\r
1432   * @retval HCLK frequency in Hz\r
1433   */\r
1434 uint32_t HAL_RCC_GetHCLKFreq(void)\r
1435 {\r
1436   return SystemCoreClock;\r
1437 }\r
1438 \r
1439 /**\r
1440   * @brief  Return the PCLK1 frequency.\r
1441   * @note   Each time PCLK1 changes, this function must be called to update the\r
1442   *         right PCLK1 value. Otherwise, any configuration based on this function will be incorrect.\r
1443   * @retval PCLK1 frequency in Hz\r
1444   */\r
1445 uint32_t HAL_RCC_GetPCLK1Freq(void)\r
1446 {\r
1447   /* Get HCLK source and Compute PCLK1 frequency ---------------------------*/\r
1448   return (HAL_RCC_GetHCLKFreq() >> (APBPrescTable[READ_BIT(RCC->CFGR, RCC_CFGR_PPRE1) >> RCC_CFGR_PPRE1_Pos] & 0x1FU));\r
1449 }\r
1450 \r
1451 /**\r
1452   * @brief  Return the PCLK2 frequency.\r
1453   * @note   Each time PCLK2 changes, this function must be called to update the\r
1454   *         right PCLK2 value. Otherwise, any configuration based on this function will be incorrect.\r
1455   * @retval PCLK2 frequency in Hz\r
1456   */\r
1457 uint32_t HAL_RCC_GetPCLK2Freq(void)\r
1458 {\r
1459   /* Get HCLK source and Compute PCLK2 frequency ---------------------------*/\r
1460   return (HAL_RCC_GetHCLKFreq()>> (APBPrescTable[READ_BIT(RCC->CFGR, RCC_CFGR_PPRE2) >> RCC_CFGR_PPRE2_Pos] & 0x1FU));\r
1461 }\r
1462 \r
1463 /**\r
1464   * @brief  Configure the RCC_OscInitStruct according to the internal\r
1465   *         RCC configuration registers.\r
1466   * @param  RCC_OscInitStruct  pointer to an RCC_OscInitTypeDef structure that\r
1467   *         will be configured.\r
1468   * @retval None\r
1469   */\r
1470 void HAL_RCC_GetOscConfig(RCC_OscInitTypeDef  *RCC_OscInitStruct)\r
1471 {\r
1472   /* Check the parameters */\r
1473   assert_param(RCC_OscInitStruct != (void *)NULL);\r
1474 \r
1475   /* Set all possible values for the Oscillator type parameter ---------------*/\r
1476 #if defined(RCC_HSI48_SUPPORT)\r
1477   RCC_OscInitStruct->OscillatorType = RCC_OSCILLATORTYPE_HSE | RCC_OSCILLATORTYPE_HSI | RCC_OSCILLATORTYPE_MSI | \\r
1478                                       RCC_OSCILLATORTYPE_LSE | RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_HSI48;\r
1479 #else\r
1480   RCC_OscInitStruct->OscillatorType = RCC_OSCILLATORTYPE_HSE | RCC_OSCILLATORTYPE_HSI | RCC_OSCILLATORTYPE_MSI | \\r
1481                                       RCC_OSCILLATORTYPE_LSE | RCC_OSCILLATORTYPE_LSI;\r
1482 #endif /* RCC_HSI48_SUPPORT */\r
1483 \r
1484   /* Get the HSE configuration -----------------------------------------------*/\r
1485   if(READ_BIT(RCC->CR, RCC_CR_HSEBYP) == RCC_CR_HSEBYP)\r
1486   {\r
1487     RCC_OscInitStruct->HSEState = RCC_HSE_BYPASS;\r
1488   }\r
1489   else if(READ_BIT(RCC->CR, RCC_CR_HSEON) == RCC_CR_HSEON)\r
1490   {\r
1491     RCC_OscInitStruct->HSEState = RCC_HSE_ON;\r
1492   }\r
1493   else\r
1494   {\r
1495     RCC_OscInitStruct->HSEState = RCC_HSE_OFF;\r
1496   }\r
1497 \r
1498    /* Get the MSI configuration -----------------------------------------------*/\r
1499   if(READ_BIT(RCC->CR, RCC_CR_MSION) == RCC_CR_MSION)\r
1500   {\r
1501     RCC_OscInitStruct->MSIState = RCC_MSI_ON;\r
1502   }\r
1503   else\r
1504   {\r
1505     RCC_OscInitStruct->MSIState = RCC_MSI_OFF;\r
1506   }\r
1507 \r
1508   RCC_OscInitStruct->MSICalibrationValue = READ_BIT(RCC->ICSCR, RCC_ICSCR_MSITRIM) >> RCC_ICSCR_MSITRIM_Pos;\r
1509   RCC_OscInitStruct->MSIClockRange = READ_BIT(RCC->CR, RCC_CR_MSIRANGE);\r
1510 \r
1511   /* Get the HSI configuration -----------------------------------------------*/\r
1512   if(READ_BIT(RCC->CR, RCC_CR_HSION) == RCC_CR_HSION)\r
1513   {\r
1514     RCC_OscInitStruct->HSIState = RCC_HSI_ON;\r
1515   }\r
1516   else\r
1517   {\r
1518     RCC_OscInitStruct->HSIState = RCC_HSI_OFF;\r
1519   }\r
1520 \r
1521   RCC_OscInitStruct->HSICalibrationValue = READ_BIT(RCC->ICSCR, RCC_ICSCR_HSITRIM) >> RCC_ICSCR_HSITRIM_Pos;\r
1522 \r
1523   /* Get the LSE configuration -----------------------------------------------*/\r
1524   if(READ_BIT(RCC->BDCR, RCC_BDCR_LSEBYP) == RCC_BDCR_LSEBYP)\r
1525   {\r
1526 #if defined(RCC_BDCR_LSESYSDIS)\r
1527     if((RCC->BDCR & RCC_BDCR_LSESYSDIS) == RCC_BDCR_LSESYSDIS)\r
1528     {\r
1529       RCC_OscInitStruct->LSEState = RCC_LSE_BYPASS_RTC_ONLY;\r
1530     }\r
1531     else\r
1532 #endif /* RCC_BDCR_LSESYSDIS */\r
1533     {\r
1534       RCC_OscInitStruct->LSEState = RCC_LSE_BYPASS;\r
1535     }\r
1536   }\r
1537   else if(READ_BIT(RCC->BDCR, RCC_BDCR_LSEON) == RCC_BDCR_LSEON)\r
1538   {\r
1539 #if defined(RCC_BDCR_LSESYSDIS)\r
1540     if((RCC->BDCR & RCC_BDCR_LSESYSDIS) == RCC_BDCR_LSESYSDIS)\r
1541     {\r
1542       RCC_OscInitStruct->LSEState = RCC_LSE_ON_RTC_ONLY;\r
1543     }\r
1544     else\r
1545 #endif /* RCC_BDCR_LSESYSDIS */\r
1546     {\r
1547       RCC_OscInitStruct->LSEState = RCC_LSE_ON;\r
1548     }\r
1549   }\r
1550   else\r
1551   {\r
1552     RCC_OscInitStruct->LSEState = RCC_LSE_OFF;\r
1553   }\r
1554 \r
1555   /* Get the LSI configuration -----------------------------------------------*/\r
1556   if(READ_BIT(RCC->CSR, RCC_CSR_LSION) == RCC_CSR_LSION)\r
1557   {\r
1558     RCC_OscInitStruct->LSIState = RCC_LSI_ON;\r
1559   }\r
1560   else\r
1561   {\r
1562     RCC_OscInitStruct->LSIState = RCC_LSI_OFF;\r
1563   }\r
1564 #if defined(RCC_CSR_LSIPREDIV)\r
1565 \r
1566   /* Get the LSI configuration -----------------------------------------------*/\r
1567   if((RCC->CSR & RCC_CSR_LSIPREDIV) == RCC_CSR_LSIPREDIV)\r
1568   {\r
1569     RCC_OscInitStruct->LSIDiv = RCC_LSI_DIV128;\r
1570   }\r
1571   else\r
1572   {\r
1573     RCC_OscInitStruct->LSIDiv = RCC_LSI_DIV1;\r
1574   }\r
1575 #endif /* RCC_CSR_LSIPREDIV */\r
1576 \r
1577 #if defined(RCC_HSI48_SUPPORT)\r
1578   /* Get the HSI48 configuration ---------------------------------------------*/\r
1579   if(READ_BIT(RCC->CRRCR, RCC_CRRCR_HSI48ON) == RCC_CRRCR_HSI48ON)\r
1580   {\r
1581     RCC_OscInitStruct->HSI48State = RCC_HSI48_ON;\r
1582   }\r
1583   else\r
1584   {\r
1585     RCC_OscInitStruct->HSI48State = RCC_HSI48_OFF;\r
1586   }\r
1587 #else\r
1588   RCC_OscInitStruct->HSI48State = RCC_HSI48_OFF;\r
1589 #endif /* RCC_HSI48_SUPPORT */\r
1590 \r
1591   /* Get the PLL configuration -----------------------------------------------*/\r
1592   if(READ_BIT(RCC->CR, RCC_CR_PLLON) == RCC_CR_PLLON)\r
1593   {\r
1594     RCC_OscInitStruct->PLL.PLLState = RCC_PLL_ON;\r
1595   }\r
1596   else\r
1597   {\r
1598     RCC_OscInitStruct->PLL.PLLState = RCC_PLL_OFF;\r
1599   }\r
1600   RCC_OscInitStruct->PLL.PLLSource = READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC);\r
1601   RCC_OscInitStruct->PLL.PLLM = (READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLM) >> RCC_PLLCFGR_PLLM_Pos) + 1U;\r
1602   RCC_OscInitStruct->PLL.PLLN = READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLN) >> RCC_PLLCFGR_PLLN_Pos;\r
1603   RCC_OscInitStruct->PLL.PLLQ = (((READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLQ) >> RCC_PLLCFGR_PLLQ_Pos) + 1U) << 1U);\r
1604   RCC_OscInitStruct->PLL.PLLR = (((READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLR) >> RCC_PLLCFGR_PLLR_Pos) + 1U) << 1U);\r
1605 #if defined(RCC_PLLP_SUPPORT)\r
1606 #if defined(RCC_PLLP_DIV_2_31_SUPPORT)\r
1607   RCC_OscInitStruct->PLL.PLLP = READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLPDIV) >> RCC_PLLCFGR_PLLPDIV_Pos;\r
1608 #else\r
1609   if(READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLP) != 0U)\r
1610   {\r
1611     RCC_OscInitStruct->PLL.PLLP = RCC_PLLP_DIV17;\r
1612   }\r
1613   else\r
1614   {\r
1615     RCC_OscInitStruct->PLL.PLLP = RCC_PLLP_DIV7;\r
1616   }\r
1617 #endif /* RCC_PLLP_DIV_2_31_SUPPORT */\r
1618 #endif /* RCC_PLLP_SUPPORT */\r
1619 }\r
1620 \r
1621 /**\r
1622   * @brief  Configure the RCC_ClkInitStruct according to the internal\r
1623   *         RCC configuration registers.\r
1624   * @param  RCC_ClkInitStruct  pointer to an RCC_ClkInitTypeDef structure that\r
1625   *         will be configured.\r
1626   * @param  pFLatency  Pointer on the Flash Latency.\r
1627   * @retval None\r
1628   */\r
1629 void HAL_RCC_GetClockConfig(RCC_ClkInitTypeDef  *RCC_ClkInitStruct, uint32_t *pFLatency)\r
1630 {\r
1631   /* Check the parameters */\r
1632   assert_param(RCC_ClkInitStruct != (void  *)NULL);\r
1633   assert_param(pFLatency != (void *)NULL);\r
1634 \r
1635   /* Set all possible values for the Clock type parameter --------------------*/\r
1636   RCC_ClkInitStruct->ClockType = RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;\r
1637 \r
1638   /* Get the SYSCLK configuration --------------------------------------------*/\r
1639   RCC_ClkInitStruct->SYSCLKSource = READ_BIT(RCC->CFGR, RCC_CFGR_SW);\r
1640 \r
1641   /* Get the HCLK configuration ----------------------------------------------*/\r
1642   RCC_ClkInitStruct->AHBCLKDivider = READ_BIT(RCC->CFGR, RCC_CFGR_HPRE);\r
1643 \r
1644   /* Get the APB1 configuration ----------------------------------------------*/\r
1645   RCC_ClkInitStruct->APB1CLKDivider = READ_BIT(RCC->CFGR, RCC_CFGR_PPRE1);\r
1646 \r
1647   /* Get the APB2 configuration ----------------------------------------------*/\r
1648   RCC_ClkInitStruct->APB2CLKDivider = (READ_BIT(RCC->CFGR, RCC_CFGR_PPRE2) >> 3U);\r
1649 \r
1650   /* Get the Flash Wait State (Latency) configuration ------------------------*/\r
1651   *pFLatency = __HAL_FLASH_GET_LATENCY();\r
1652 }\r
1653 \r
1654 /**\r
1655   * @brief  Enable the Clock Security System.\r
1656   * @note   If a failure is detected on the HSE oscillator clock, this oscillator\r
1657   *         is automatically disabled and an interrupt is generated to inform the\r
1658   *         software about the failure (Clock Security System Interrupt, CSSI),\r
1659   *         allowing the MCU to perform rescue operations. The CSSI is linked to\r
1660   *         the Cortex-M4 NMI (Non-Maskable Interrupt) exception vector.\r
1661   * @note   The Clock Security System can only be cleared by reset.\r
1662   * @retval None\r
1663   */\r
1664 void HAL_RCC_EnableCSS(void)\r
1665 {\r
1666   SET_BIT(RCC->CR, RCC_CR_CSSON) ;\r
1667 }\r
1668 \r
1669 /**\r
1670   * @brief Handle the RCC Clock Security System interrupt request.\r
1671   * @note This API should be called under the NMI_Handler().\r
1672   * @retval None\r
1673   */\r
1674 void HAL_RCC_NMI_IRQHandler(void)\r
1675 {\r
1676   /* Check RCC CSSF interrupt flag  */\r
1677   if(__HAL_RCC_GET_IT(RCC_IT_CSS))\r
1678   {\r
1679     /* RCC Clock Security System interrupt user callback */\r
1680     HAL_RCC_CSSCallback();\r
1681 \r
1682     /* Clear RCC CSS pending bit */\r
1683     __HAL_RCC_CLEAR_IT(RCC_IT_CSS);\r
1684   }\r
1685 }\r
1686 \r
1687 /**\r
1688   * @brief  RCC Clock Security System interrupt callback.\r
1689   * @retval none\r
1690   */\r
1691 __weak void HAL_RCC_CSSCallback(void)\r
1692 {\r
1693   /* NOTE : This function should not be modified, when the callback is needed,\r
1694             the HAL_RCC_CSSCallback should be implemented in the user file\r
1695    */\r
1696 }\r
1697 \r
1698 /**\r
1699   * @}\r
1700   */\r
1701 \r
1702 /**\r
1703   * @}\r
1704   */\r
1705 \r
1706 /* Private function prototypes -----------------------------------------------*/\r
1707 /** @addtogroup RCC_Private_Functions\r
1708   * @{\r
1709   */\r
1710 /**\r
1711   * @brief  Update number of Flash wait states in line with MSI range and current\r
1712             voltage range.\r
1713   * @param  msirange  MSI range value from RCC_MSIRANGE_0 to RCC_MSIRANGE_11\r
1714   * @retval HAL status\r
1715   */\r
1716 static HAL_StatusTypeDef RCC_SetFlashLatencyFromMSIRange(uint32_t msirange)\r
1717 {\r
1718   uint32_t vos;\r
1719   uint32_t latency = FLASH_LATENCY_0;  /* default value 0WS */\r
1720 \r
1721   if(__HAL_RCC_PWR_IS_CLK_ENABLED())\r
1722   {\r
1723     vos = HAL_PWREx_GetVoltageRange();\r
1724   }\r
1725   else\r
1726   {\r
1727     __HAL_RCC_PWR_CLK_ENABLE();\r
1728     vos = HAL_PWREx_GetVoltageRange();\r
1729     __HAL_RCC_PWR_CLK_DISABLE();\r
1730   }\r
1731 \r
1732   if(vos == PWR_REGULATOR_VOLTAGE_SCALE1)\r
1733   {\r
1734     if(msirange > RCC_MSIRANGE_8)\r
1735     {\r
1736       /* MSI > 16Mhz */\r
1737       if(msirange > RCC_MSIRANGE_10)\r
1738       {\r
1739         /* MSI 48Mhz */\r
1740         latency = FLASH_LATENCY_2; /* 2WS */\r
1741       }\r
1742       else\r
1743       {\r
1744         /* MSI 24Mhz or 32Mhz */\r
1745         latency = FLASH_LATENCY_1; /* 1WS */\r
1746       }\r
1747     }\r
1748     /* else MSI <= 16Mhz default FLASH_LATENCY_0 0WS */\r
1749   }\r
1750   else\r
1751   {\r
1752 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)\r
1753     if(msirange >= RCC_MSIRANGE_8)\r
1754     {\r
1755       /* MSI >= 16Mhz */\r
1756       latency = FLASH_LATENCY_2; /* 2WS */\r
1757     }\r
1758     else\r
1759     {\r
1760       if(msirange == RCC_MSIRANGE_7)\r
1761       {\r
1762         /* MSI 8Mhz */\r
1763         latency = FLASH_LATENCY_1; /* 1WS */\r
1764       }\r
1765       /* else MSI < 8Mhz default FLASH_LATENCY_0 0WS */\r
1766     }\r
1767 #else\r
1768     if(msirange > RCC_MSIRANGE_8)\r
1769     {\r
1770       /* MSI > 16Mhz */\r
1771       latency = FLASH_LATENCY_3; /* 3WS */\r
1772     }\r
1773     else\r
1774     {\r
1775       if(msirange == RCC_MSIRANGE_8)\r
1776       {\r
1777         /* MSI 16Mhz */\r
1778         latency = FLASH_LATENCY_2; /* 2WS */\r
1779       }\r
1780       else if(msirange == RCC_MSIRANGE_7)\r
1781       {\r
1782         /* MSI 8Mhz */\r
1783         latency = FLASH_LATENCY_1; /* 1WS */\r
1784       }\r
1785       /* else MSI < 8Mhz default FLASH_LATENCY_0 0WS */\r
1786     }\r
1787 #endif\r
1788   }\r
1789 \r
1790   __HAL_FLASH_SET_LATENCY(latency);\r
1791 \r
1792   /* Check that the new number of wait states is taken into account to access the Flash\r
1793      memory by reading the FLASH_ACR register */\r
1794   if(__HAL_FLASH_GET_LATENCY() != latency)\r
1795   {\r
1796     return HAL_ERROR;\r
1797   }\r
1798 \r
1799   return HAL_OK;\r
1800 }\r
1801 \r
1802 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)\r
1803 /**\r
1804   * @brief  Compute SYSCLK frequency based on PLL SYSCLK source.\r
1805   * @retval SYSCLK frequency\r
1806   */\r
1807 static uint32_t RCC_GetSysClockFreqFromPLLSource(void)\r
1808 {\r
1809   uint32_t msirange = 0U;\r
1810   uint32_t pllvco, pllsource, pllr, pllm, sysclockfreq;  /* no init needed */\r
1811 \r
1812   if(__HAL_RCC_GET_PLL_OSCSOURCE() == RCC_PLLSOURCE_MSI)\r
1813   {\r
1814     /* Get MSI range source */\r
1815     if(READ_BIT(RCC->CR, RCC_CR_MSIRGSEL) == 0U)\r
1816     { /* MSISRANGE from RCC_CSR applies */\r
1817       msirange = READ_BIT(RCC->CSR, RCC_CSR_MSISRANGE) >> RCC_CSR_MSISRANGE_Pos;\r
1818     }\r
1819     else\r
1820     { /* MSIRANGE from RCC_CR applies */\r
1821       msirange = READ_BIT(RCC->CR, RCC_CR_MSIRANGE) >> RCC_CR_MSIRANGE_Pos;\r
1822     }\r
1823     /*MSI frequency range in HZ*/\r
1824     msirange = MSIRangeTable[msirange];\r
1825   }\r
1826 \r
1827   /* PLL_VCO = (HSE_VALUE or HSI_VALUE or MSI_VALUE) * PLLN / PLLM\r
1828      SYSCLK = PLL_VCO / PLLR\r
1829    */\r
1830   pllsource = READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLSRC);\r
1831 \r
1832   switch (pllsource)\r
1833   {\r
1834   case RCC_PLLSOURCE_HSI:  /* HSI used as PLL clock source */\r
1835     pllvco = HSI_VALUE;\r
1836     break;\r
1837 \r
1838   case RCC_PLLSOURCE_HSE:  /* HSE used as PLL clock source */\r
1839     pllvco = HSE_VALUE;\r
1840     break;\r
1841 \r
1842   case RCC_PLLSOURCE_MSI:  /* MSI used as PLL clock source */\r
1843   default:\r
1844     pllvco = msirange;\r
1845     break;\r
1846   }\r
1847   pllm = (READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLM) >> RCC_PLLCFGR_PLLM_Pos) + 1U ;\r
1848   pllvco = (pllvco * (READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLN) >> RCC_PLLCFGR_PLLN_Pos)) / pllm;\r
1849   pllr = ((READ_BIT(RCC->PLLCFGR, RCC_PLLCFGR_PLLR) >> RCC_PLLCFGR_PLLR_Pos) + 1U ) * 2U;\r
1850   sysclockfreq = pllvco / pllr;\r
1851 \r
1852   return sysclockfreq;\r
1853 }\r
1854 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */\r
1855 \r
1856 /**\r
1857   * @}\r
1858   */\r
1859 \r
1860 #endif /* HAL_RCC_MODULE_ENABLED */\r
1861 /**\r
1862   * @}\r
1863   */\r
1864 \r
1865 /**\r
1866   * @}\r
1867   */\r
1868 \r
1869 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r