mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents:   Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32F0/device/stm32f0xx_hal_rcc_ex.c@149:156823d33999, 2016-10-28 (annotated)

Committer:
<>
Date:
Fri Oct 28 11:17:30 2016 +0100
Revision:
149:156823d33999
Parent:
targets/cmsis/TARGET_STM/TARGET_STM32F0/stm32f0xx_hal_rcc_ex.c@144:ef7eb2e8f9f7
Child:
156:95d6b41a828b
This updates the lib to the mbed lib v128



NOTE: This release includes a restructuring of the file and directory locations and thus some

include paths in your code may need updating accordingly.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f0xx_hal_rcc_ex.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @version V1.4.0
<> 144:ef7eb2e8f9f7 6 * @date 27-May-2016
<> 144:ef7eb2e8f9f7 7 * @brief Extended RCC HAL module driver.
<> 144:ef7eb2e8f9f7 8 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 9 * functionalities RCC extension peripheral:
<> 144:ef7eb2e8f9f7 10 * + Extended Peripheral Control functions
<> 144:ef7eb2e8f9f7 11 * + Extended Clock Recovery System Control functions
<> 144:ef7eb2e8f9f7 12 *
<> 144:ef7eb2e8f9f7 13 ******************************************************************************
<> 144:ef7eb2e8f9f7 14 * @attention
<> 144:ef7eb2e8f9f7 15 *
<> 144:ef7eb2e8f9f7 16 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 17 *
<> 144:ef7eb2e8f9f7 18 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 19 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 20 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 21 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 22 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 23 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 24 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 25 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 26 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 27 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 28 *
<> 144:ef7eb2e8f9f7 29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 30 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 31 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 32 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 33 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 34 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 35 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 36 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 37 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 39 *
<> 144:ef7eb2e8f9f7 40 ******************************************************************************
<> 144:ef7eb2e8f9f7 41 */
<> 144:ef7eb2e8f9f7 42
<> 144:ef7eb2e8f9f7 43 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 44 #include "stm32f0xx_hal.h"
<> 144:ef7eb2e8f9f7 45
<> 144:ef7eb2e8f9f7 46 /** @addtogroup STM32F0xx_HAL_Driver
<> 144:ef7eb2e8f9f7 47 * @{
<> 144:ef7eb2e8f9f7 48 */
<> 144:ef7eb2e8f9f7 49
<> 144:ef7eb2e8f9f7 50 #ifdef HAL_RCC_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 51
<> 144:ef7eb2e8f9f7 52 /** @defgroup RCCEx RCCEx
<> 144:ef7eb2e8f9f7 53 * @brief RCC Extension HAL module driver.
<> 144:ef7eb2e8f9f7 54 * @{
<> 144:ef7eb2e8f9f7 55 */
<> 144:ef7eb2e8f9f7 56
<> 144:ef7eb2e8f9f7 57 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 58 /* Private define ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 59 #if defined(CRS)
<> 144:ef7eb2e8f9f7 60 /** @defgroup RCCEx_Private_Constants RCCEx Private Constants
<> 144:ef7eb2e8f9f7 61 * @{
<> 144:ef7eb2e8f9f7 62 */
<> 144:ef7eb2e8f9f7 63 /* Bit position in register */
<> 144:ef7eb2e8f9f7 64 #define CRS_CFGR_FELIM_BITNUMBER 16
<> 144:ef7eb2e8f9f7 65 #define CRS_CR_TRIM_BITNUMBER 8
<> 144:ef7eb2e8f9f7 66 #define CRS_ISR_FECAP_BITNUMBER 16
<> 144:ef7eb2e8f9f7 67 /**
<> 144:ef7eb2e8f9f7 68 * @}
<> 144:ef7eb2e8f9f7 69 */
<> 144:ef7eb2e8f9f7 70 #endif /* CRS */
<> 144:ef7eb2e8f9f7 71
<> 144:ef7eb2e8f9f7 72 /* Private macro -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 73 /** @defgroup RCCEx_Private_Macros RCCEx Private Macros
<> 144:ef7eb2e8f9f7 74 * @{
<> 144:ef7eb2e8f9f7 75 */
<> 144:ef7eb2e8f9f7 76 /**
<> 144:ef7eb2e8f9f7 77 * @}
<> 144:ef7eb2e8f9f7 78 */
<> 144:ef7eb2e8f9f7 79
<> 144:ef7eb2e8f9f7 80 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 81 /* Private function prototypes -----------------------------------------------*/
<> 144:ef7eb2e8f9f7 82 /* Private functions ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 83
<> 144:ef7eb2e8f9f7 84 /** @defgroup RCCEx_Exported_Functions RCCEx Exported Functions
<> 144:ef7eb2e8f9f7 85 * @{
<> 144:ef7eb2e8f9f7 86 */
<> 144:ef7eb2e8f9f7 87
<> 144:ef7eb2e8f9f7 88 /** @defgroup RCCEx_Exported_Functions_Group1 Extended Peripheral Control functions
<> 144:ef7eb2e8f9f7 89 * @brief Extended Peripheral Control functions
<> 144:ef7eb2e8f9f7 90 *
<> 144:ef7eb2e8f9f7 91 @verbatim
<> 144:ef7eb2e8f9f7 92 ===============================================================================
<> 144:ef7eb2e8f9f7 93 ##### Extended Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 94 ===============================================================================
<> 144:ef7eb2e8f9f7 95 [..]
<> 144:ef7eb2e8f9f7 96 This subsection provides a set of functions allowing to control the RCC Clocks
<> 144:ef7eb2e8f9f7 97 frequencies.
<> 144:ef7eb2e8f9f7 98 [..]
<> 144:ef7eb2e8f9f7 99 (@) Important note: Care must be taken when HAL_RCCEx_PeriphCLKConfig() is used to
<> 144:ef7eb2e8f9f7 100 select the RTC clock source; in this case the Backup domain will be reset in
<> 144:ef7eb2e8f9f7 101 order to modify the RTC Clock source, as consequence RTC registers (including
<> 144:ef7eb2e8f9f7 102 the backup registers) are set to their reset values.
<> 144:ef7eb2e8f9f7 103
<> 144:ef7eb2e8f9f7 104 @endverbatim
<> 144:ef7eb2e8f9f7 105 * @{
<> 144:ef7eb2e8f9f7 106 */
<> 144:ef7eb2e8f9f7 107
<> 144:ef7eb2e8f9f7 108 /**
<> 144:ef7eb2e8f9f7 109 * @brief Initializes the RCC extended peripherals clocks according to the specified
<> 144:ef7eb2e8f9f7 110 * parameters in the RCC_PeriphCLKInitTypeDef.
<> 144:ef7eb2e8f9f7 111 * @param PeriphClkInit pointer to an RCC_PeriphCLKInitTypeDef structure that
<> 144:ef7eb2e8f9f7 112 * contains the configuration information for the Extended Peripherals clocks
<> 144:ef7eb2e8f9f7 113 * (USART, RTC, I2C, CEC and USB).
<> 144:ef7eb2e8f9f7 114 *
<> 144:ef7eb2e8f9f7 115 * @note Care must be taken when @ref HAL_RCCEx_PeriphCLKConfig() is used to select
<> 144:ef7eb2e8f9f7 116 * the RTC clock source; in this case the Backup domain will be reset in
<> 144:ef7eb2e8f9f7 117 * order to modify the RTC Clock source, as consequence RTC registers (including
<> 144:ef7eb2e8f9f7 118 * the backup registers) and RCC_BDCR register are set to their reset values.
<> 144:ef7eb2e8f9f7 119 *
<> 144:ef7eb2e8f9f7 120 * @retval HAL status
<> 144:ef7eb2e8f9f7 121 */
<> 144:ef7eb2e8f9f7 122 HAL_StatusTypeDef HAL_RCCEx_PeriphCLKConfig(RCC_PeriphCLKInitTypeDef *PeriphClkInit)
<> 144:ef7eb2e8f9f7 123 {
<> 144:ef7eb2e8f9f7 124 uint32_t tickstart = 0;
<> 144:ef7eb2e8f9f7 125 uint32_t temp_reg = 0;
<> 144:ef7eb2e8f9f7 126
<> 144:ef7eb2e8f9f7 127 /* Check the parameters */
<> 144:ef7eb2e8f9f7 128 assert_param(IS_RCC_PERIPHCLOCK(PeriphClkInit->PeriphClockSelection));
<> 144:ef7eb2e8f9f7 129
<> 144:ef7eb2e8f9f7 130 /*---------------------------- RTC configuration -------------------------------*/
<> 144:ef7eb2e8f9f7 131 if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_RTC) == (RCC_PERIPHCLK_RTC))
<> 144:ef7eb2e8f9f7 132 {
<> 144:ef7eb2e8f9f7 133 /* check for RTC Parameters used to output RTCCLK */
<> 144:ef7eb2e8f9f7 134 assert_param(IS_RCC_RTCCLKSOURCE(PeriphClkInit->RTCClockSelection));
<> 144:ef7eb2e8f9f7 135
<> 144:ef7eb2e8f9f7 136 FlagStatus pwrclkchanged = RESET;
<> 144:ef7eb2e8f9f7 137
<> 144:ef7eb2e8f9f7 138 /* As soon as function is called to change RTC clock source, activation of the
<> 144:ef7eb2e8f9f7 139 power domain is done. */
<> 144:ef7eb2e8f9f7 140 /* Requires to enable write access to Backup Domain of necessary */
<> 144:ef7eb2e8f9f7 141 if(__HAL_RCC_PWR_IS_CLK_DISABLED())
<> 144:ef7eb2e8f9f7 142 {
<> 144:ef7eb2e8f9f7 143 __HAL_RCC_PWR_CLK_ENABLE();
<> 144:ef7eb2e8f9f7 144 pwrclkchanged = SET;
<> 144:ef7eb2e8f9f7 145 }
<> 144:ef7eb2e8f9f7 146
<> 144:ef7eb2e8f9f7 147 if(HAL_IS_BIT_CLR(PWR->CR, PWR_CR_DBP))
<> 144:ef7eb2e8f9f7 148 {
<> 144:ef7eb2e8f9f7 149 /* Enable write access to Backup domain */
<> 144:ef7eb2e8f9f7 150 SET_BIT(PWR->CR, PWR_CR_DBP);
<> 144:ef7eb2e8f9f7 151
<> 144:ef7eb2e8f9f7 152 /* Wait for Backup domain Write protection disable */
<> 144:ef7eb2e8f9f7 153 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 154
<> 144:ef7eb2e8f9f7 155 while(HAL_IS_BIT_CLR(PWR->CR, PWR_CR_DBP))
<> 144:ef7eb2e8f9f7 156 {
<> 144:ef7eb2e8f9f7 157 if((HAL_GetTick() - tickstart) > RCC_DBP_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 158 {
<> 144:ef7eb2e8f9f7 159 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 160 }
<> 144:ef7eb2e8f9f7 161 }
<> 144:ef7eb2e8f9f7 162 }
<> 144:ef7eb2e8f9f7 163
<> 144:ef7eb2e8f9f7 164 /* Reset the Backup domain only if the RTC Clock source selection is modified from reset value */
<> 144:ef7eb2e8f9f7 165 temp_reg = (RCC->BDCR & RCC_BDCR_RTCSEL);
<> 144:ef7eb2e8f9f7 166 if((temp_reg != 0x00000000U) && (temp_reg != (PeriphClkInit->RTCClockSelection & RCC_BDCR_RTCSEL)))
<> 144:ef7eb2e8f9f7 167 {
<> 144:ef7eb2e8f9f7 168 /* Store the content of BDCR register before the reset of Backup Domain */
<> 144:ef7eb2e8f9f7 169 temp_reg = (RCC->BDCR & ~(RCC_BDCR_RTCSEL));
<> 144:ef7eb2e8f9f7 170 /* RTC Clock selection can be changed only if the Backup Domain is reset */
<> 144:ef7eb2e8f9f7 171 __HAL_RCC_BACKUPRESET_FORCE();
<> 144:ef7eb2e8f9f7 172 __HAL_RCC_BACKUPRESET_RELEASE();
<> 144:ef7eb2e8f9f7 173 /* Restore the Content of BDCR register */
<> 144:ef7eb2e8f9f7 174 RCC->BDCR = temp_reg;
<> 144:ef7eb2e8f9f7 175
<> 144:ef7eb2e8f9f7 176 /* Wait for LSERDY if LSE was enabled */
<> 144:ef7eb2e8f9f7 177 if (HAL_IS_BIT_SET(temp_reg, RCC_BDCR_LSEON))
<> 144:ef7eb2e8f9f7 178 {
<> 144:ef7eb2e8f9f7 179 /* Get Start Tick */
<> 144:ef7eb2e8f9f7 180 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 181
<> 144:ef7eb2e8f9f7 182 /* Wait till LSE is ready */
<> 144:ef7eb2e8f9f7 183 while(__HAL_RCC_GET_FLAG(RCC_FLAG_LSERDY) == RESET)
<> 144:ef7eb2e8f9f7 184 {
<> 144:ef7eb2e8f9f7 185 if((HAL_GetTick() - tickstart) > RCC_LSE_TIMEOUT_VALUE)
<> 144:ef7eb2e8f9f7 186 {
<> 144:ef7eb2e8f9f7 187 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 188 }
<> 144:ef7eb2e8f9f7 189 }
<> 144:ef7eb2e8f9f7 190 }
<> 144:ef7eb2e8f9f7 191 }
<> 144:ef7eb2e8f9f7 192 __HAL_RCC_RTC_CONFIG(PeriphClkInit->RTCClockSelection);
<> 144:ef7eb2e8f9f7 193
<> 144:ef7eb2e8f9f7 194 /* Require to disable power clock if necessary */
<> 144:ef7eb2e8f9f7 195 if(pwrclkchanged == SET)
<> 144:ef7eb2e8f9f7 196 {
<> 144:ef7eb2e8f9f7 197 __HAL_RCC_PWR_CLK_DISABLE();
<> 144:ef7eb2e8f9f7 198 }
<> 144:ef7eb2e8f9f7 199 }
<> 144:ef7eb2e8f9f7 200
<> 144:ef7eb2e8f9f7 201 /*------------------------------- USART1 Configuration ------------------------*/
<> 144:ef7eb2e8f9f7 202 if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART1) == RCC_PERIPHCLK_USART1)
<> 144:ef7eb2e8f9f7 203 {
<> 144:ef7eb2e8f9f7 204 /* Check the parameters */
<> 144:ef7eb2e8f9f7 205 assert_param(IS_RCC_USART1CLKSOURCE(PeriphClkInit->Usart1ClockSelection));
<> 144:ef7eb2e8f9f7 206
<> 144:ef7eb2e8f9f7 207 /* Configure the USART1 clock source */
<> 144:ef7eb2e8f9f7 208 __HAL_RCC_USART1_CONFIG(PeriphClkInit->Usart1ClockSelection);
<> 144:ef7eb2e8f9f7 209 }
<> 144:ef7eb2e8f9f7 210
<> 144:ef7eb2e8f9f7 211 #if defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx)\
<> 144:ef7eb2e8f9f7 212 || defined(STM32F091xC) || defined(STM32F098xx)
<> 144:ef7eb2e8f9f7 213 /*----------------------------- USART2 Configuration --------------------------*/
<> 144:ef7eb2e8f9f7 214 if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART2) == RCC_PERIPHCLK_USART2)
<> 144:ef7eb2e8f9f7 215 {
<> 144:ef7eb2e8f9f7 216 /* Check the parameters */
<> 144:ef7eb2e8f9f7 217 assert_param(IS_RCC_USART2CLKSOURCE(PeriphClkInit->Usart2ClockSelection));
<> 144:ef7eb2e8f9f7 218
<> 144:ef7eb2e8f9f7 219 /* Configure the USART2 clock source */
<> 144:ef7eb2e8f9f7 220 __HAL_RCC_USART2_CONFIG(PeriphClkInit->Usart2ClockSelection);
<> 144:ef7eb2e8f9f7 221 }
<> 144:ef7eb2e8f9f7 222 #endif /* STM32F071xB || STM32F072xB || STM32F078xx || */
<> 144:ef7eb2e8f9f7 223 /* STM32F091xC || STM32F098xx */
<> 144:ef7eb2e8f9f7 224
<> 144:ef7eb2e8f9f7 225 #if defined(STM32F091xC) || defined(STM32F098xx)
<> 144:ef7eb2e8f9f7 226 /*----------------------------- USART3 Configuration --------------------------*/
<> 144:ef7eb2e8f9f7 227 if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USART3) == RCC_PERIPHCLK_USART3)
<> 144:ef7eb2e8f9f7 228 {
<> 144:ef7eb2e8f9f7 229 /* Check the parameters */
<> 144:ef7eb2e8f9f7 230 assert_param(IS_RCC_USART3CLKSOURCE(PeriphClkInit->Usart3ClockSelection));
<> 144:ef7eb2e8f9f7 231
<> 144:ef7eb2e8f9f7 232 /* Configure the USART3 clock source */
<> 144:ef7eb2e8f9f7 233 __HAL_RCC_USART3_CONFIG(PeriphClkInit->Usart3ClockSelection);
<> 144:ef7eb2e8f9f7 234 }
<> 144:ef7eb2e8f9f7 235 #endif /* STM32F091xC || STM32F098xx */
<> 144:ef7eb2e8f9f7 236
<> 144:ef7eb2e8f9f7 237 /*------------------------------ I2C1 Configuration ------------------------*/
<> 144:ef7eb2e8f9f7 238 if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_I2C1) == RCC_PERIPHCLK_I2C1)
<> 144:ef7eb2e8f9f7 239 {
<> 144:ef7eb2e8f9f7 240 /* Check the parameters */
<> 144:ef7eb2e8f9f7 241 assert_param(IS_RCC_I2C1CLKSOURCE(PeriphClkInit->I2c1ClockSelection));
<> 144:ef7eb2e8f9f7 242
<> 144:ef7eb2e8f9f7 243 /* Configure the I2C1 clock source */
<> 144:ef7eb2e8f9f7 244 __HAL_RCC_I2C1_CONFIG(PeriphClkInit->I2c1ClockSelection);
<> 144:ef7eb2e8f9f7 245 }
<> 144:ef7eb2e8f9f7 246
<> 144:ef7eb2e8f9f7 247 #if defined(STM32F042x6) || defined(STM32F048xx) || defined(STM32F072xB) || defined(STM32F078xx) || defined(STM32F070xB) || defined(STM32F070x6)
<> 144:ef7eb2e8f9f7 248 /*------------------------------ USB Configuration ------------------------*/
<> 144:ef7eb2e8f9f7 249 if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_USB) == RCC_PERIPHCLK_USB)
<> 144:ef7eb2e8f9f7 250 {
<> 144:ef7eb2e8f9f7 251 /* Check the parameters */
<> 144:ef7eb2e8f9f7 252 assert_param(IS_RCC_USBCLKSOURCE(PeriphClkInit->UsbClockSelection));
<> 144:ef7eb2e8f9f7 253
<> 144:ef7eb2e8f9f7 254 /* Configure the USB clock source */
<> 144:ef7eb2e8f9f7 255 __HAL_RCC_USB_CONFIG(PeriphClkInit->UsbClockSelection);
<> 144:ef7eb2e8f9f7 256 }
<> 144:ef7eb2e8f9f7 257 #endif /* STM32F042x6 || STM32F048xx || STM32F072xB || STM32F078xx || STM32F070xB || STM32F070x6 */
<> 144:ef7eb2e8f9f7 258
<> 144:ef7eb2e8f9f7 259 #if defined(STM32F042x6) || defined(STM32F048xx)\
<> 144:ef7eb2e8f9f7 260 || defined(STM32F051x8) || defined(STM32F058xx)\
<> 144:ef7eb2e8f9f7 261 || defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx)\
<> 144:ef7eb2e8f9f7 262 || defined(STM32F091xC) || defined(STM32F098xx)
<> 144:ef7eb2e8f9f7 263 /*------------------------------ CEC clock Configuration -------------------*/
<> 144:ef7eb2e8f9f7 264 if(((PeriphClkInit->PeriphClockSelection) & RCC_PERIPHCLK_CEC) == RCC_PERIPHCLK_CEC)
<> 144:ef7eb2e8f9f7 265 {
<> 144:ef7eb2e8f9f7 266 /* Check the parameters */
<> 144:ef7eb2e8f9f7 267 assert_param(IS_RCC_CECCLKSOURCE(PeriphClkInit->CecClockSelection));
<> 144:ef7eb2e8f9f7 268
<> 144:ef7eb2e8f9f7 269 /* Configure the CEC clock source */
<> 144:ef7eb2e8f9f7 270 __HAL_RCC_CEC_CONFIG(PeriphClkInit->CecClockSelection);
<> 144:ef7eb2e8f9f7 271 }
<> 144:ef7eb2e8f9f7 272 #endif /* STM32F042x6 || STM32F048xx || */
<> 144:ef7eb2e8f9f7 273 /* STM32F051x8 || STM32F058xx || */
<> 144:ef7eb2e8f9f7 274 /* STM32F071xB || STM32F072xB || STM32F078xx || */
<> 144:ef7eb2e8f9f7 275 /* STM32F091xC || STM32F098xx */
<> 144:ef7eb2e8f9f7 276
<> 144:ef7eb2e8f9f7 277 return HAL_OK;
<> 144:ef7eb2e8f9f7 278 }
<> 144:ef7eb2e8f9f7 279
<> 144:ef7eb2e8f9f7 280 /**
<> 144:ef7eb2e8f9f7 281 * @brief Get the RCC_ClkInitStruct according to the internal
<> 144:ef7eb2e8f9f7 282 * RCC configuration registers.
<> 144:ef7eb2e8f9f7 283 * @param PeriphClkInit pointer to an RCC_PeriphCLKInitTypeDef structure that
<> 144:ef7eb2e8f9f7 284 * returns the configuration information for the Extended Peripherals clocks
<> 144:ef7eb2e8f9f7 285 * (USART, RTC, I2C, CEC and USB).
<> 144:ef7eb2e8f9f7 286 * @retval None
<> 144:ef7eb2e8f9f7 287 */
<> 144:ef7eb2e8f9f7 288 void HAL_RCCEx_GetPeriphCLKConfig(RCC_PeriphCLKInitTypeDef *PeriphClkInit)
<> 144:ef7eb2e8f9f7 289 {
<> 144:ef7eb2e8f9f7 290 /* Set all possible values for the extended clock type parameter------------*/
<> 144:ef7eb2e8f9f7 291 /* Common part first */
<> 144:ef7eb2e8f9f7 292 PeriphClkInit->PeriphClockSelection = RCC_PERIPHCLK_USART1 | RCC_PERIPHCLK_I2C1 | RCC_PERIPHCLK_RTC;
<> 144:ef7eb2e8f9f7 293 /* Get the RTC configuration --------------------------------------------*/
<> 144:ef7eb2e8f9f7 294 PeriphClkInit->RTCClockSelection = __HAL_RCC_GET_RTC_SOURCE();
<> 144:ef7eb2e8f9f7 295 /* Get the USART1 clock configuration --------------------------------------------*/
<> 144:ef7eb2e8f9f7 296 PeriphClkInit->Usart1ClockSelection = __HAL_RCC_GET_USART1_SOURCE();
<> 144:ef7eb2e8f9f7 297 /* Get the I2C1 clock source -----------------------------------------------*/
<> 144:ef7eb2e8f9f7 298 PeriphClkInit->I2c1ClockSelection = __HAL_RCC_GET_I2C1_SOURCE();
<> 144:ef7eb2e8f9f7 299
<> 144:ef7eb2e8f9f7 300 #if defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx)\
<> 144:ef7eb2e8f9f7 301 || defined(STM32F091xC) || defined(STM32F098xx)
<> 144:ef7eb2e8f9f7 302 PeriphClkInit->PeriphClockSelection |= RCC_PERIPHCLK_USART2;
<> 144:ef7eb2e8f9f7 303 /* Get the USART2 clock source ---------------------------------------------*/
<> 144:ef7eb2e8f9f7 304 PeriphClkInit->Usart2ClockSelection = __HAL_RCC_GET_USART2_SOURCE();
<> 144:ef7eb2e8f9f7 305 #endif /* STM32F071xB || STM32F072xB || STM32F078xx || */
<> 144:ef7eb2e8f9f7 306 /* STM32F091xC || STM32F098xx */
<> 144:ef7eb2e8f9f7 307
<> 144:ef7eb2e8f9f7 308 #if defined(STM32F091xC) || defined(STM32F098xx)
<> 144:ef7eb2e8f9f7 309 PeriphClkInit->PeriphClockSelection |= RCC_PERIPHCLK_USART3;
<> 144:ef7eb2e8f9f7 310 /* Get the USART3 clock source ---------------------------------------------*/
<> 144:ef7eb2e8f9f7 311 PeriphClkInit->Usart3ClockSelection = __HAL_RCC_GET_USART3_SOURCE();
<> 144:ef7eb2e8f9f7 312 #endif /* STM32F091xC || STM32F098xx */
<> 144:ef7eb2e8f9f7 313
<> 144:ef7eb2e8f9f7 314 #if defined(STM32F042x6) || defined(STM32F048xx) || defined(STM32F072xB) || defined(STM32F078xx) || defined(STM32F070xB) || defined(STM32F070x6)
<> 144:ef7eb2e8f9f7 315 PeriphClkInit->PeriphClockSelection |= RCC_PERIPHCLK_USB;
<> 144:ef7eb2e8f9f7 316 /* Get the USB clock source ---------------------------------------------*/
<> 144:ef7eb2e8f9f7 317 PeriphClkInit->UsbClockSelection = __HAL_RCC_GET_USB_SOURCE();
<> 144:ef7eb2e8f9f7 318 #endif /* STM32F042x6 || STM32F048xx || STM32F072xB || STM32F078xx || STM32F070xB || STM32F070x6 */
<> 144:ef7eb2e8f9f7 319
<> 144:ef7eb2e8f9f7 320 #if defined(STM32F042x6) || defined(STM32F048xx)\
<> 144:ef7eb2e8f9f7 321 || defined(STM32F051x8) || defined(STM32F058xx)\
<> 144:ef7eb2e8f9f7 322 || defined(STM32F071xB) || defined(STM32F072xB) || defined(STM32F078xx)\
<> 144:ef7eb2e8f9f7 323 || defined(STM32F091xC) || defined(STM32F098xx)
<> 144:ef7eb2e8f9f7 324 PeriphClkInit->PeriphClockSelection |= RCC_PERIPHCLK_CEC;
<> 144:ef7eb2e8f9f7 325 /* Get the CEC clock source ------------------------------------------------*/
<> 144:ef7eb2e8f9f7 326 PeriphClkInit->CecClockSelection = __HAL_RCC_GET_CEC_SOURCE();
<> 144:ef7eb2e8f9f7 327 #endif /* STM32F042x6 || STM32F048xx || */
<> 144:ef7eb2e8f9f7 328 /* STM32F051x8 || STM32F058xx || */
<> 144:ef7eb2e8f9f7 329 /* STM32F071xB || STM32F072xB || STM32F078xx || */
<> 144:ef7eb2e8f9f7 330 /* STM32F091xC || STM32F098xx */
<> 144:ef7eb2e8f9f7 331
<> 144:ef7eb2e8f9f7 332 }
<> 144:ef7eb2e8f9f7 333
<> 144:ef7eb2e8f9f7 334 /**
<> 144:ef7eb2e8f9f7 335 * @brief Returns the peripheral clock frequency
<> 144:ef7eb2e8f9f7 336 * @note Returns 0 if peripheral clock is unknown
<> 144:ef7eb2e8f9f7 337 * @param PeriphClk Peripheral clock identifier
<> 144:ef7eb2e8f9f7 338 * This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 339 * @arg @ref RCC_PERIPHCLK_RTC RTC peripheral clock
<> 144:ef7eb2e8f9f7 340 * @arg @ref RCC_PERIPHCLK_USART1 USART1 peripheral clock
<> 144:ef7eb2e8f9f7 341 * @arg @ref RCC_PERIPHCLK_I2C1 I2C1 peripheral clock
<> 144:ef7eb2e8f9f7 342 @if STM32F042x6
<> 144:ef7eb2e8f9f7 343 * @arg @ref RCC_PERIPHCLK_USB USB peripheral clock
<> 144:ef7eb2e8f9f7 344 * @arg @ref RCC_PERIPHCLK_CEC CEC peripheral clock
<> 144:ef7eb2e8f9f7 345 @endif
<> 144:ef7eb2e8f9f7 346 @if STM32F048xx
<> 144:ef7eb2e8f9f7 347 * @arg @ref RCC_PERIPHCLK_USB USB peripheral clock
<> 144:ef7eb2e8f9f7 348 * @arg @ref RCC_PERIPHCLK_CEC CEC peripheral clock
<> 144:ef7eb2e8f9f7 349 @endif
<> 144:ef7eb2e8f9f7 350 @if STM32F051x8
<> 144:ef7eb2e8f9f7 351 * @arg @ref RCC_PERIPHCLK_CEC CEC peripheral clock
<> 144:ef7eb2e8f9f7 352 @endif
<> 144:ef7eb2e8f9f7 353 @if STM32F058xx
<> 144:ef7eb2e8f9f7 354 * @arg @ref RCC_PERIPHCLK_CEC CEC peripheral clock
<> 144:ef7eb2e8f9f7 355 @endif
<> 144:ef7eb2e8f9f7 356 @if STM32F070x6
<> 144:ef7eb2e8f9f7 357 * @arg @ref RCC_PERIPHCLK_USB USB peripheral clock
<> 144:ef7eb2e8f9f7 358 @endif
<> 144:ef7eb2e8f9f7 359 @if STM32F070xB
<> 144:ef7eb2e8f9f7 360 * @arg @ref RCC_PERIPHCLK_USB USB peripheral clock
<> 144:ef7eb2e8f9f7 361 @endif
<> 144:ef7eb2e8f9f7 362 @if STM32F071xB
<> 144:ef7eb2e8f9f7 363 * @arg @ref RCC_PERIPHCLK_USART2 USART2 peripheral clock
<> 144:ef7eb2e8f9f7 364 * @arg @ref RCC_PERIPHCLK_CEC CEC peripheral clock
<> 144:ef7eb2e8f9f7 365 @endif
<> 144:ef7eb2e8f9f7 366 @if STM32F072xB
<> 144:ef7eb2e8f9f7 367 * @arg @ref RCC_PERIPHCLK_USART2 USART2 peripheral clock
<> 144:ef7eb2e8f9f7 368 * @arg @ref RCC_PERIPHCLK_USB USB peripheral clock
<> 144:ef7eb2e8f9f7 369 * @arg @ref RCC_PERIPHCLK_CEC CEC peripheral clock
<> 144:ef7eb2e8f9f7 370 @endif
<> 144:ef7eb2e8f9f7 371 @if STM32F078xx
<> 144:ef7eb2e8f9f7 372 * @arg @ref RCC_PERIPHCLK_USART2 USART2 peripheral clock
<> 144:ef7eb2e8f9f7 373 * @arg @ref RCC_PERIPHCLK_USB USB peripheral clock
<> 144:ef7eb2e8f9f7 374 * @arg @ref RCC_PERIPHCLK_CEC CEC peripheral clock
<> 144:ef7eb2e8f9f7 375 @endif
<> 144:ef7eb2e8f9f7 376 @if STM32F091xC
<> 144:ef7eb2e8f9f7 377 * @arg @ref RCC_PERIPHCLK_USART2 USART2 peripheral clock
<> 144:ef7eb2e8f9f7 378 * @arg @ref RCC_PERIPHCLK_USART3 USART2 peripheral clock
<> 144:ef7eb2e8f9f7 379 * @arg @ref RCC_PERIPHCLK_CEC CEC peripheral clock
<> 144:ef7eb2e8f9f7 380 @endif
<> 144:ef7eb2e8f9f7 381 @if STM32F098xx
<> 144:ef7eb2e8f9f7 382 * @arg @ref RCC_PERIPHCLK_USART2 USART2 peripheral clock
<> 144:ef7eb2e8f9f7 383 * @arg @ref RCC_PERIPHCLK_USART3 USART2 peripheral clock
<> 144:ef7eb2e8f9f7 384 * @arg @ref RCC_PERIPHCLK_CEC CEC peripheral clock
<> 144:ef7eb2e8f9f7 385 @endif
<> 144:ef7eb2e8f9f7 386 * @retval Frequency in Hz (0: means that no available frequency for the peripheral)
<> 144:ef7eb2e8f9f7 387 */
<> 144:ef7eb2e8f9f7 388 uint32_t HAL_RCCEx_GetPeriphCLKFreq(uint32_t PeriphClk)
<> 144:ef7eb2e8f9f7 389 {
<> 144:ef7eb2e8f9f7 390 uint32_t frequency = 0;
<> 144:ef7eb2e8f9f7 391 uint32_t srcclk = 0;
<> 144:ef7eb2e8f9f7 392 #if defined(USB)
<> 144:ef7eb2e8f9f7 393 uint32_t pllmull = 0, pllsource = 0, predivfactor = 0;
<> 144:ef7eb2e8f9f7 394 #endif /* USB */
<> 144:ef7eb2e8f9f7 395
<> 144:ef7eb2e8f9f7 396 /* Check the parameters */
<> 144:ef7eb2e8f9f7 397 assert_param(IS_RCC_PERIPHCLOCK(PeriphClk));
<> 144:ef7eb2e8f9f7 398
<> 144:ef7eb2e8f9f7 399 switch (PeriphClk)
<> 144:ef7eb2e8f9f7 400 {
<> 144:ef7eb2e8f9f7 401 case RCC_PERIPHCLK_RTC:
<> 144:ef7eb2e8f9f7 402 {
<> 144:ef7eb2e8f9f7 403 /* Get the current RTC source */
<> 144:ef7eb2e8f9f7 404 srcclk = __HAL_RCC_GET_RTC_SOURCE();
<> 144:ef7eb2e8f9f7 405
<> 144:ef7eb2e8f9f7 406 /* Check if LSE is ready and if RTC clock selection is LSE */
<> 144:ef7eb2e8f9f7 407 if ((srcclk == RCC_RTCCLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<> 144:ef7eb2e8f9f7 408 {
<> 144:ef7eb2e8f9f7 409 frequency = LSE_VALUE;
<> 144:ef7eb2e8f9f7 410 }
<> 144:ef7eb2e8f9f7 411 /* Check if LSI is ready and if RTC clock selection is LSI */
<> 144:ef7eb2e8f9f7 412 else if ((srcclk == RCC_RTCCLKSOURCE_LSI) && (HAL_IS_BIT_SET(RCC->CSR, RCC_CSR_LSIRDY)))
<> 144:ef7eb2e8f9f7 413 {
<> 144:ef7eb2e8f9f7 414 frequency = LSI_VALUE;
<> 144:ef7eb2e8f9f7 415 }
<> 144:ef7eb2e8f9f7 416 /* Check if HSE is ready and if RTC clock selection is HSI_DIV32*/
<> 144:ef7eb2e8f9f7 417 else if ((srcclk == RCC_RTCCLKSOURCE_HSE_DIV32) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSERDY)))
<> 144:ef7eb2e8f9f7 418 {
<> 144:ef7eb2e8f9f7 419 frequency = HSE_VALUE / 32;
<> 144:ef7eb2e8f9f7 420 }
<> 144:ef7eb2e8f9f7 421 /* Clock not enabled for RTC*/
<> 144:ef7eb2e8f9f7 422 else
<> 144:ef7eb2e8f9f7 423 {
<> 144:ef7eb2e8f9f7 424 frequency = 0;
<> 144:ef7eb2e8f9f7 425 }
<> 144:ef7eb2e8f9f7 426 break;
<> 144:ef7eb2e8f9f7 427 }
<> 144:ef7eb2e8f9f7 428 case RCC_PERIPHCLK_USART1:
<> 144:ef7eb2e8f9f7 429 {
<> 144:ef7eb2e8f9f7 430 /* Get the current USART1 source */
<> 144:ef7eb2e8f9f7 431 srcclk = __HAL_RCC_GET_USART1_SOURCE();
<> 144:ef7eb2e8f9f7 432
<> 144:ef7eb2e8f9f7 433 /* Check if USART1 clock selection is PCLK1 */
<> 144:ef7eb2e8f9f7 434 if (srcclk == RCC_USART1CLKSOURCE_PCLK1)
<> 144:ef7eb2e8f9f7 435 {
<> 144:ef7eb2e8f9f7 436 frequency = HAL_RCC_GetPCLK1Freq();
<> 144:ef7eb2e8f9f7 437 }
<> 144:ef7eb2e8f9f7 438 /* Check if HSI is ready and if USART1 clock selection is HSI */
<> 144:ef7eb2e8f9f7 439 else if ((srcclk == RCC_USART1CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<> 144:ef7eb2e8f9f7 440 {
<> 144:ef7eb2e8f9f7 441 frequency = HSI_VALUE;
<> 144:ef7eb2e8f9f7 442 }
<> 144:ef7eb2e8f9f7 443 /* Check if USART1 clock selection is SYSCLK */
<> 144:ef7eb2e8f9f7 444 else if (srcclk == RCC_USART1CLKSOURCE_SYSCLK)
<> 144:ef7eb2e8f9f7 445 {
<> 144:ef7eb2e8f9f7 446 frequency = HAL_RCC_GetSysClockFreq();
<> 144:ef7eb2e8f9f7 447 }
<> 144:ef7eb2e8f9f7 448 /* Check if LSE is ready and if USART1 clock selection is LSE */
<> 144:ef7eb2e8f9f7 449 else if ((srcclk == RCC_USART1CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<> 144:ef7eb2e8f9f7 450 {
<> 144:ef7eb2e8f9f7 451 frequency = LSE_VALUE;
<> 144:ef7eb2e8f9f7 452 }
<> 144:ef7eb2e8f9f7 453 /* Clock not enabled for USART1*/
<> 144:ef7eb2e8f9f7 454 else
<> 144:ef7eb2e8f9f7 455 {
<> 144:ef7eb2e8f9f7 456 frequency = 0;
<> 144:ef7eb2e8f9f7 457 }
<> 144:ef7eb2e8f9f7 458 break;
<> 144:ef7eb2e8f9f7 459 }
<> 144:ef7eb2e8f9f7 460 #if defined(RCC_CFGR3_USART2SW)
<> 144:ef7eb2e8f9f7 461 case RCC_PERIPHCLK_USART2:
<> 144:ef7eb2e8f9f7 462 {
<> 144:ef7eb2e8f9f7 463 /* Get the current USART2 source */
<> 144:ef7eb2e8f9f7 464 srcclk = __HAL_RCC_GET_USART2_SOURCE();
<> 144:ef7eb2e8f9f7 465
<> 144:ef7eb2e8f9f7 466 /* Check if USART2 clock selection is PCLK1 */
<> 144:ef7eb2e8f9f7 467 if (srcclk == RCC_USART2CLKSOURCE_PCLK1)
<> 144:ef7eb2e8f9f7 468 {
<> 144:ef7eb2e8f9f7 469 frequency = HAL_RCC_GetPCLK1Freq();
<> 144:ef7eb2e8f9f7 470 }
<> 144:ef7eb2e8f9f7 471 /* Check if HSI is ready and if USART2 clock selection is HSI */
<> 144:ef7eb2e8f9f7 472 else if ((srcclk == RCC_USART2CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<> 144:ef7eb2e8f9f7 473 {
<> 144:ef7eb2e8f9f7 474 frequency = HSI_VALUE;
<> 144:ef7eb2e8f9f7 475 }
<> 144:ef7eb2e8f9f7 476 /* Check if USART2 clock selection is SYSCLK */
<> 144:ef7eb2e8f9f7 477 else if (srcclk == RCC_USART2CLKSOURCE_SYSCLK)
<> 144:ef7eb2e8f9f7 478 {
<> 144:ef7eb2e8f9f7 479 frequency = HAL_RCC_GetSysClockFreq();
<> 144:ef7eb2e8f9f7 480 }
<> 144:ef7eb2e8f9f7 481 /* Check if LSE is ready and if USART2 clock selection is LSE */
<> 144:ef7eb2e8f9f7 482 else if ((srcclk == RCC_USART2CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<> 144:ef7eb2e8f9f7 483 {
<> 144:ef7eb2e8f9f7 484 frequency = LSE_VALUE;
<> 144:ef7eb2e8f9f7 485 }
<> 144:ef7eb2e8f9f7 486 /* Clock not enabled for USART2*/
<> 144:ef7eb2e8f9f7 487 else
<> 144:ef7eb2e8f9f7 488 {
<> 144:ef7eb2e8f9f7 489 frequency = 0;
<> 144:ef7eb2e8f9f7 490 }
<> 144:ef7eb2e8f9f7 491 break;
<> 144:ef7eb2e8f9f7 492 }
<> 144:ef7eb2e8f9f7 493 #endif /* RCC_CFGR3_USART2SW */
<> 144:ef7eb2e8f9f7 494 #if defined(RCC_CFGR3_USART3SW)
<> 144:ef7eb2e8f9f7 495 case RCC_PERIPHCLK_USART3:
<> 144:ef7eb2e8f9f7 496 {
<> 144:ef7eb2e8f9f7 497 /* Get the current USART3 source */
<> 144:ef7eb2e8f9f7 498 srcclk = __HAL_RCC_GET_USART3_SOURCE();
<> 144:ef7eb2e8f9f7 499
<> 144:ef7eb2e8f9f7 500 /* Check if USART3 clock selection is PCLK1 */
<> 144:ef7eb2e8f9f7 501 if (srcclk == RCC_USART3CLKSOURCE_PCLK1)
<> 144:ef7eb2e8f9f7 502 {
<> 144:ef7eb2e8f9f7 503 frequency = HAL_RCC_GetPCLK1Freq();
<> 144:ef7eb2e8f9f7 504 }
<> 144:ef7eb2e8f9f7 505 /* Check if HSI is ready and if USART3 clock selection is HSI */
<> 144:ef7eb2e8f9f7 506 else if ((srcclk == RCC_USART3CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<> 144:ef7eb2e8f9f7 507 {
<> 144:ef7eb2e8f9f7 508 frequency = HSI_VALUE;
<> 144:ef7eb2e8f9f7 509 }
<> 144:ef7eb2e8f9f7 510 /* Check if USART3 clock selection is SYSCLK */
<> 144:ef7eb2e8f9f7 511 else if (srcclk == RCC_USART3CLKSOURCE_SYSCLK)
<> 144:ef7eb2e8f9f7 512 {
<> 144:ef7eb2e8f9f7 513 frequency = HAL_RCC_GetSysClockFreq();
<> 144:ef7eb2e8f9f7 514 }
<> 144:ef7eb2e8f9f7 515 /* Check if LSE is ready and if USART3 clock selection is LSE */
<> 144:ef7eb2e8f9f7 516 else if ((srcclk == RCC_USART3CLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<> 144:ef7eb2e8f9f7 517 {
<> 144:ef7eb2e8f9f7 518 frequency = LSE_VALUE;
<> 144:ef7eb2e8f9f7 519 }
<> 144:ef7eb2e8f9f7 520 /* Clock not enabled for USART3*/
<> 144:ef7eb2e8f9f7 521 else
<> 144:ef7eb2e8f9f7 522 {
<> 144:ef7eb2e8f9f7 523 frequency = 0;
<> 144:ef7eb2e8f9f7 524 }
<> 144:ef7eb2e8f9f7 525 break;
<> 144:ef7eb2e8f9f7 526 }
<> 144:ef7eb2e8f9f7 527 #endif /* RCC_CFGR3_USART3SW */
<> 144:ef7eb2e8f9f7 528 case RCC_PERIPHCLK_I2C1:
<> 144:ef7eb2e8f9f7 529 {
<> 144:ef7eb2e8f9f7 530 /* Get the current I2C1 source */
<> 144:ef7eb2e8f9f7 531 srcclk = __HAL_RCC_GET_I2C1_SOURCE();
<> 144:ef7eb2e8f9f7 532
<> 144:ef7eb2e8f9f7 533 /* Check if HSI is ready and if I2C1 clock selection is HSI */
<> 144:ef7eb2e8f9f7 534 if ((srcclk == RCC_I2C1CLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<> 144:ef7eb2e8f9f7 535 {
<> 144:ef7eb2e8f9f7 536 frequency = HSI_VALUE;
<> 144:ef7eb2e8f9f7 537 }
<> 144:ef7eb2e8f9f7 538 /* Check if I2C1 clock selection is SYSCLK */
<> 144:ef7eb2e8f9f7 539 else if (srcclk == RCC_I2C1CLKSOURCE_SYSCLK)
<> 144:ef7eb2e8f9f7 540 {
<> 144:ef7eb2e8f9f7 541 frequency = HAL_RCC_GetSysClockFreq();
<> 144:ef7eb2e8f9f7 542 }
<> 144:ef7eb2e8f9f7 543 /* Clock not enabled for I2C1*/
<> 144:ef7eb2e8f9f7 544 else
<> 144:ef7eb2e8f9f7 545 {
<> 144:ef7eb2e8f9f7 546 frequency = 0;
<> 144:ef7eb2e8f9f7 547 }
<> 144:ef7eb2e8f9f7 548 break;
<> 144:ef7eb2e8f9f7 549 }
<> 144:ef7eb2e8f9f7 550 #if defined(USB)
<> 144:ef7eb2e8f9f7 551 case RCC_PERIPHCLK_USB:
<> 144:ef7eb2e8f9f7 552 {
<> 144:ef7eb2e8f9f7 553 /* Get the current USB source */
<> 144:ef7eb2e8f9f7 554 srcclk = __HAL_RCC_GET_USB_SOURCE();
<> 144:ef7eb2e8f9f7 555
<> 144:ef7eb2e8f9f7 556 /* Check if PLL is ready and if USB clock selection is PLL */
<> 144:ef7eb2e8f9f7 557 if ((srcclk == RCC_USBCLKSOURCE_PLL) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_PLLRDY)))
<> 144:ef7eb2e8f9f7 558 {
<> 144:ef7eb2e8f9f7 559 /* Get PLL clock source and multiplication factor ----------------------*/
<> 144:ef7eb2e8f9f7 560 pllmull = RCC->CFGR & RCC_CFGR_PLLMUL;
<> 144:ef7eb2e8f9f7 561 pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;
<> 144:ef7eb2e8f9f7 562 pllmull = (pllmull >> RCC_CFGR_PLLMUL_BITNUMBER) + 2;
<> 144:ef7eb2e8f9f7 563 predivfactor = (RCC->CFGR2 & RCC_CFGR2_PREDIV) + 1;
<> 144:ef7eb2e8f9f7 564
<> 144:ef7eb2e8f9f7 565 if (pllsource == RCC_CFGR_PLLSRC_HSE_PREDIV)
<> 144:ef7eb2e8f9f7 566 {
<> 144:ef7eb2e8f9f7 567 /* HSE used as PLL clock source : frequency = HSE/PREDIV * PLLMUL */
<> 144:ef7eb2e8f9f7 568 frequency = (HSE_VALUE/predivfactor) * pllmull;
<> 144:ef7eb2e8f9f7 569 }
<> 144:ef7eb2e8f9f7 570 #if defined(RCC_CR2_HSI48ON)
<> 144:ef7eb2e8f9f7 571 else if (pllsource == RCC_CFGR_PLLSRC_HSI48_PREDIV)
<> 144:ef7eb2e8f9f7 572 {
<> 144:ef7eb2e8f9f7 573 /* HSI48 used as PLL clock source : frequency = HSI48/PREDIV * PLLMUL */
<> 144:ef7eb2e8f9f7 574 frequency = (HSI48_VALUE / predivfactor) * pllmull;
<> 144:ef7eb2e8f9f7 575 }
<> 144:ef7eb2e8f9f7 576 #endif /* RCC_CR2_HSI48ON */
<> 144:ef7eb2e8f9f7 577 else
<> 144:ef7eb2e8f9f7 578 {
<> 144:ef7eb2e8f9f7 579 #if defined(STM32F042x6) || defined(STM32F048xx) || defined(STM32F078xx) || defined(STM32F072xB) || defined(STM32F070xB)
<> 144:ef7eb2e8f9f7 580 /* HSI used as PLL clock source : frequency = HSI/PREDIV * PLLMUL */
<> 144:ef7eb2e8f9f7 581 frequency = (HSI_VALUE / predivfactor) * pllmull;
<> 144:ef7eb2e8f9f7 582 #else
<> 144:ef7eb2e8f9f7 583 /* HSI used as PLL clock source : frequency = HSI/2 * PLLMUL */
<> 144:ef7eb2e8f9f7 584 frequency = (HSI_VALUE >> 1) * pllmull;
<> 144:ef7eb2e8f9f7 585 #endif /* STM32F042x6 || STM32F048xx || STM32F072xB || STM32F078xx || STM32F070xB */
<> 144:ef7eb2e8f9f7 586 }
<> 144:ef7eb2e8f9f7 587 }
<> 144:ef7eb2e8f9f7 588 #if defined(RCC_CR2_HSI48ON)
<> 144:ef7eb2e8f9f7 589 /* Check if HSI48 is ready and if USB clock selection is HSI48 */
<> 144:ef7eb2e8f9f7 590 else if ((srcclk == RCC_USBCLKSOURCE_HSI48) && (HAL_IS_BIT_SET(RCC->CR2, RCC_CR2_HSI48RDY)))
<> 144:ef7eb2e8f9f7 591 {
<> 144:ef7eb2e8f9f7 592 frequency = HSI48_VALUE;
<> 144:ef7eb2e8f9f7 593 }
<> 144:ef7eb2e8f9f7 594 #endif /* RCC_CR2_HSI48ON */
<> 144:ef7eb2e8f9f7 595 /* Clock not enabled for USB*/
<> 144:ef7eb2e8f9f7 596 else
<> 144:ef7eb2e8f9f7 597 {
<> 144:ef7eb2e8f9f7 598 frequency = 0;
<> 144:ef7eb2e8f9f7 599 }
<> 144:ef7eb2e8f9f7 600 break;
<> 144:ef7eb2e8f9f7 601 }
<> 144:ef7eb2e8f9f7 602 #endif /* USB */
<> 144:ef7eb2e8f9f7 603 #if defined(CEC)
<> 144:ef7eb2e8f9f7 604 case RCC_PERIPHCLK_CEC:
<> 144:ef7eb2e8f9f7 605 {
<> 144:ef7eb2e8f9f7 606 /* Get the current CEC source */
<> 144:ef7eb2e8f9f7 607 srcclk = __HAL_RCC_GET_CEC_SOURCE();
<> 144:ef7eb2e8f9f7 608
<> 144:ef7eb2e8f9f7 609 /* Check if HSI is ready and if CEC clock selection is HSI */
<> 144:ef7eb2e8f9f7 610 if ((srcclk == RCC_CECCLKSOURCE_HSI) && (HAL_IS_BIT_SET(RCC->CR, RCC_CR_HSIRDY)))
<> 144:ef7eb2e8f9f7 611 {
<> 144:ef7eb2e8f9f7 612 frequency = HSI_VALUE;
<> 144:ef7eb2e8f9f7 613 }
<> 144:ef7eb2e8f9f7 614 /* Check if LSE is ready and if CEC clock selection is LSE */
<> 144:ef7eb2e8f9f7 615 else if ((srcclk == RCC_CECCLKSOURCE_LSE) && (HAL_IS_BIT_SET(RCC->BDCR, RCC_BDCR_LSERDY)))
<> 144:ef7eb2e8f9f7 616 {
<> 144:ef7eb2e8f9f7 617 frequency = LSE_VALUE;
<> 144:ef7eb2e8f9f7 618 }
<> 144:ef7eb2e8f9f7 619 /* Clock not enabled for CEC */
<> 144:ef7eb2e8f9f7 620 else
<> 144:ef7eb2e8f9f7 621 {
<> 144:ef7eb2e8f9f7 622 frequency = 0;
<> 144:ef7eb2e8f9f7 623 }
<> 144:ef7eb2e8f9f7 624 break;
<> 144:ef7eb2e8f9f7 625 }
<> 144:ef7eb2e8f9f7 626 #endif /* CEC */
<> 144:ef7eb2e8f9f7 627 default:
<> 144:ef7eb2e8f9f7 628 {
<> 144:ef7eb2e8f9f7 629 break;
<> 144:ef7eb2e8f9f7 630 }
<> 144:ef7eb2e8f9f7 631 }
<> 144:ef7eb2e8f9f7 632 return(frequency);
<> 144:ef7eb2e8f9f7 633 }
<> 144:ef7eb2e8f9f7 634
<> 144:ef7eb2e8f9f7 635 /**
<> 144:ef7eb2e8f9f7 636 * @}
<> 144:ef7eb2e8f9f7 637 */
<> 144:ef7eb2e8f9f7 638
<> 144:ef7eb2e8f9f7 639 #if defined(CRS)
<> 144:ef7eb2e8f9f7 640
<> 144:ef7eb2e8f9f7 641 /** @defgroup RCCEx_Exported_Functions_Group3 Extended Clock Recovery System Control functions
<> 144:ef7eb2e8f9f7 642 * @brief Extended Clock Recovery System Control functions
<> 144:ef7eb2e8f9f7 643 *
<> 144:ef7eb2e8f9f7 644 @verbatim
<> 144:ef7eb2e8f9f7 645 ===============================================================================
<> 144:ef7eb2e8f9f7 646 ##### Extended Clock Recovery System Control functions #####
<> 144:ef7eb2e8f9f7 647 ===============================================================================
<> 144:ef7eb2e8f9f7 648 [..]
<> 144:ef7eb2e8f9f7 649 For devices with Clock Recovery System feature (CRS), RCC Extention HAL driver can be used as follows:
<> 144:ef7eb2e8f9f7 650
<> 144:ef7eb2e8f9f7 651 (#) In System clock config, HSI48 needs to be enabled
<> 144:ef7eb2e8f9f7 652
<> 144:ef7eb2e8f9f7 653 (#) Enable CRS clock in IP MSP init which will use CRS functions
<> 144:ef7eb2e8f9f7 654
<> 144:ef7eb2e8f9f7 655 (#) Call CRS functions as follows:
<> 144:ef7eb2e8f9f7 656 (##) Prepare synchronization configuration necessary for HSI48 calibration
<> 144:ef7eb2e8f9f7 657 (+++) Default values can be set for frequency Error Measurement (reload and error limit)
<> 144:ef7eb2e8f9f7 658 and also HSI48 oscillator smooth trimming.
<> 144:ef7eb2e8f9f7 659 (+++) Macro @ref __HAL_RCC_CRS_RELOADVALUE_CALCULATE can be also used to calculate
<> 144:ef7eb2e8f9f7 660 directly reload value with target and synchronization frequencies values
<> 144:ef7eb2e8f9f7 661 (##) Call function @ref HAL_RCCEx_CRSConfig which
<> 144:ef7eb2e8f9f7 662 (+++) Reset CRS registers to their default values.
<> 144:ef7eb2e8f9f7 663 (+++) Configure CRS registers with synchronization configuration
<> 144:ef7eb2e8f9f7 664 (+++) Enable automatic calibration and frequency error counter feature
<> 144:ef7eb2e8f9f7 665 Note: When using USB LPM (Link Power Management) and the device is in Sleep mode, the
<> 144:ef7eb2e8f9f7 666 periodic USB SOF will not be generated by the host. No SYNC signal will therefore be
<> 144:ef7eb2e8f9f7 667 provided to the CRS to calibrate the HSI48 on the run. To guarantee the required clock
<> 144:ef7eb2e8f9f7 668 precision after waking up from Sleep mode, the LSE or reference clock on the GPIOs
<> 144:ef7eb2e8f9f7 669 should be used as SYNC signal.
<> 144:ef7eb2e8f9f7 670
<> 144:ef7eb2e8f9f7 671 (##) A polling function is provided to wait for complete synchronization
<> 144:ef7eb2e8f9f7 672 (+++) Call function @ref HAL_RCCEx_CRSWaitSynchronization()
<> 144:ef7eb2e8f9f7 673 (+++) According to CRS status, user can decide to adjust again the calibration or continue
<> 144:ef7eb2e8f9f7 674 application if synchronization is OK
<> 144:ef7eb2e8f9f7 675
<> 144:ef7eb2e8f9f7 676 (#) User can retrieve information related to synchronization in calling function
<> 144:ef7eb2e8f9f7 677 @ref HAL_RCCEx_CRSGetSynchronizationInfo()
<> 144:ef7eb2e8f9f7 678
<> 144:ef7eb2e8f9f7 679 (#) Regarding synchronization status and synchronization information, user can try a new calibration
<> 144:ef7eb2e8f9f7 680 in changing synchronization configuration and call again HAL_RCCEx_CRSConfig.
<> 144:ef7eb2e8f9f7 681 Note: When the SYNC event is detected during the downcounting phase (before reaching the zero value),
<> 144:ef7eb2e8f9f7 682 it means that the actual frequency is lower than the target (and so, that the TRIM value should be
<> 144:ef7eb2e8f9f7 683 incremented), while when it is detected during the upcounting phase it means that the actual frequency
<> 144:ef7eb2e8f9f7 684 is higher (and that the TRIM value should be decremented).
<> 144:ef7eb2e8f9f7 685
<> 144:ef7eb2e8f9f7 686 (#) In interrupt mode, user can resort to the available macros (__HAL_RCC_CRS_XXX_IT). Interrupts will go
<> 144:ef7eb2e8f9f7 687 through CRS Handler (RCC_IRQn/RCC_IRQHandler)
<> 144:ef7eb2e8f9f7 688 (++) Call function @ref HAL_RCCEx_CRSConfig()
<> 144:ef7eb2e8f9f7 689 (++) Enable RCC_IRQn (thanks to NVIC functions)
<> 144:ef7eb2e8f9f7 690 (++) Enable CRS interrupt (@ref __HAL_RCC_CRS_ENABLE_IT)
<> 144:ef7eb2e8f9f7 691 (++) Implement CRS status management in the following user callbacks called from
<> 144:ef7eb2e8f9f7 692 HAL_RCCEx_CRS_IRQHandler():
<> 144:ef7eb2e8f9f7 693 (+++) @ref HAL_RCCEx_CRS_SyncOkCallback()
<> 144:ef7eb2e8f9f7 694 (+++) @ref HAL_RCCEx_CRS_SyncWarnCallback()
<> 144:ef7eb2e8f9f7 695 (+++) @ref HAL_RCCEx_CRS_ExpectedSyncCallback()
<> 144:ef7eb2e8f9f7 696 (+++) @ref HAL_RCCEx_CRS_ErrorCallback()
<> 144:ef7eb2e8f9f7 697
<> 144:ef7eb2e8f9f7 698 (#) To force a SYNC EVENT, user can use the function @ref HAL_RCCEx_CRSSoftwareSynchronizationGenerate().
<> 144:ef7eb2e8f9f7 699 This function can be called before calling @ref HAL_RCCEx_CRSConfig (for instance in Systick handler)
<> 144:ef7eb2e8f9f7 700
<> 144:ef7eb2e8f9f7 701 @endverbatim
<> 144:ef7eb2e8f9f7 702 * @{
<> 144:ef7eb2e8f9f7 703 */
<> 144:ef7eb2e8f9f7 704
<> 144:ef7eb2e8f9f7 705 /**
<> 144:ef7eb2e8f9f7 706 * @brief Start automatic synchronization for polling mode
<> 144:ef7eb2e8f9f7 707 * @param pInit Pointer on RCC_CRSInitTypeDef structure
<> 144:ef7eb2e8f9f7 708 * @retval None
<> 144:ef7eb2e8f9f7 709 */
<> 144:ef7eb2e8f9f7 710 void HAL_RCCEx_CRSConfig(RCC_CRSInitTypeDef *pInit)
<> 144:ef7eb2e8f9f7 711 {
<> 144:ef7eb2e8f9f7 712 uint32_t value = 0;
<> 144:ef7eb2e8f9f7 713
<> 144:ef7eb2e8f9f7 714 /* Check the parameters */
<> 144:ef7eb2e8f9f7 715 assert_param(IS_RCC_CRS_SYNC_DIV(pInit->Prescaler));
<> 144:ef7eb2e8f9f7 716 assert_param(IS_RCC_CRS_SYNC_SOURCE(pInit->Source));
<> 144:ef7eb2e8f9f7 717 assert_param(IS_RCC_CRS_SYNC_POLARITY(pInit->Polarity));
<> 144:ef7eb2e8f9f7 718 assert_param(IS_RCC_CRS_RELOADVALUE(pInit->ReloadValue));
<> 144:ef7eb2e8f9f7 719 assert_param(IS_RCC_CRS_ERRORLIMIT(pInit->ErrorLimitValue));
<> 144:ef7eb2e8f9f7 720 assert_param(IS_RCC_CRS_HSI48CALIBRATION(pInit->HSI48CalibrationValue));
<> 144:ef7eb2e8f9f7 721
<> 144:ef7eb2e8f9f7 722 /* CONFIGURATION */
<> 144:ef7eb2e8f9f7 723
<> 144:ef7eb2e8f9f7 724 /* Before configuration, reset CRS registers to their default values*/
<> 144:ef7eb2e8f9f7 725 __HAL_RCC_CRS_FORCE_RESET();
<> 144:ef7eb2e8f9f7 726 __HAL_RCC_CRS_RELEASE_RESET();
<> 144:ef7eb2e8f9f7 727
<> 144:ef7eb2e8f9f7 728 /* Set the SYNCDIV[2:0] bits according to Prescaler value */
<> 144:ef7eb2e8f9f7 729 /* Set the SYNCSRC[1:0] bits according to Source value */
<> 144:ef7eb2e8f9f7 730 /* Set the SYNCSPOL bit according to Polarity value */
<> 144:ef7eb2e8f9f7 731 value = (pInit->Prescaler | pInit->Source | pInit->Polarity);
<> 144:ef7eb2e8f9f7 732 /* Set the RELOAD[15:0] bits according to ReloadValue value */
<> 144:ef7eb2e8f9f7 733 value |= pInit->ReloadValue;
<> 144:ef7eb2e8f9f7 734 /* Set the FELIM[7:0] bits according to ErrorLimitValue value */
<> 144:ef7eb2e8f9f7 735 value |= (pInit->ErrorLimitValue << CRS_CFGR_FELIM_BITNUMBER);
<> 144:ef7eb2e8f9f7 736 WRITE_REG(CRS->CFGR, value);
<> 144:ef7eb2e8f9f7 737
<> 144:ef7eb2e8f9f7 738 /* Adjust HSI48 oscillator smooth trimming */
<> 144:ef7eb2e8f9f7 739 /* Set the TRIM[5:0] bits according to RCC_CRS_HSI48CalibrationValue value */
<> 144:ef7eb2e8f9f7 740 MODIFY_REG(CRS->CR, CRS_CR_TRIM, (pInit->HSI48CalibrationValue << CRS_CR_TRIM_BITNUMBER));
<> 144:ef7eb2e8f9f7 741
<> 144:ef7eb2e8f9f7 742 /* START AUTOMATIC SYNCHRONIZATION*/
<> 144:ef7eb2e8f9f7 743
<> 144:ef7eb2e8f9f7 744 /* Enable Automatic trimming & Frequency error counter */
<> 144:ef7eb2e8f9f7 745 SET_BIT(CRS->CR, CRS_CR_AUTOTRIMEN | CRS_CR_CEN);
<> 144:ef7eb2e8f9f7 746 }
<> 144:ef7eb2e8f9f7 747
<> 144:ef7eb2e8f9f7 748 /**
<> 144:ef7eb2e8f9f7 749 * @brief Generate the software synchronization event
<> 144:ef7eb2e8f9f7 750 * @retval None
<> 144:ef7eb2e8f9f7 751 */
<> 144:ef7eb2e8f9f7 752 void HAL_RCCEx_CRSSoftwareSynchronizationGenerate(void)
<> 144:ef7eb2e8f9f7 753 {
<> 144:ef7eb2e8f9f7 754 SET_BIT(CRS->CR, CRS_CR_SWSYNC);
<> 144:ef7eb2e8f9f7 755 }
<> 144:ef7eb2e8f9f7 756
<> 144:ef7eb2e8f9f7 757 /**
<> 144:ef7eb2e8f9f7 758 * @brief Return synchronization info
<> 144:ef7eb2e8f9f7 759 * @param pSynchroInfo Pointer on RCC_CRSSynchroInfoTypeDef structure
<> 144:ef7eb2e8f9f7 760 * @retval None
<> 144:ef7eb2e8f9f7 761 */
<> 144:ef7eb2e8f9f7 762 void HAL_RCCEx_CRSGetSynchronizationInfo(RCC_CRSSynchroInfoTypeDef *pSynchroInfo)
<> 144:ef7eb2e8f9f7 763 {
<> 144:ef7eb2e8f9f7 764 /* Check the parameter */
<> 144:ef7eb2e8f9f7 765 assert_param(pSynchroInfo != NULL);
<> 144:ef7eb2e8f9f7 766
<> 144:ef7eb2e8f9f7 767 /* Get the reload value */
<> 144:ef7eb2e8f9f7 768 pSynchroInfo->ReloadValue = (uint32_t)(READ_BIT(CRS->CFGR, CRS_CFGR_RELOAD));
<> 144:ef7eb2e8f9f7 769
<> 144:ef7eb2e8f9f7 770 /* Get HSI48 oscillator smooth trimming */
<> 144:ef7eb2e8f9f7 771 pSynchroInfo->HSI48CalibrationValue = (uint32_t)(READ_BIT(CRS->CR, CRS_CR_TRIM) >> CRS_CR_TRIM_BITNUMBER);
<> 144:ef7eb2e8f9f7 772
<> 144:ef7eb2e8f9f7 773 /* Get Frequency error capture */
<> 144:ef7eb2e8f9f7 774 pSynchroInfo->FreqErrorCapture = (uint32_t)(READ_BIT(CRS->ISR, CRS_ISR_FECAP) >> CRS_ISR_FECAP_BITNUMBER);
<> 144:ef7eb2e8f9f7 775
<> 144:ef7eb2e8f9f7 776 /* Get Frequency error direction */
<> 144:ef7eb2e8f9f7 777 pSynchroInfo->FreqErrorDirection = (uint32_t)(READ_BIT(CRS->ISR, CRS_ISR_FEDIR));
<> 144:ef7eb2e8f9f7 778 }
<> 144:ef7eb2e8f9f7 779
<> 144:ef7eb2e8f9f7 780 /**
<> 144:ef7eb2e8f9f7 781 * @brief Wait for CRS Synchronization status.
<> 144:ef7eb2e8f9f7 782 * @param Timeout Duration of the timeout
<> 144:ef7eb2e8f9f7 783 * @note Timeout is based on the maximum time to receive a SYNC event based on synchronization
<> 144:ef7eb2e8f9f7 784 * frequency.
<> 144:ef7eb2e8f9f7 785 * @note If Timeout set to HAL_MAX_DELAY, HAL_TIMEOUT will be never returned.
<> 144:ef7eb2e8f9f7 786 * @retval Combination of Synchronization status
<> 144:ef7eb2e8f9f7 787 * This parameter can be a combination of the following values:
<> 144:ef7eb2e8f9f7 788 * @arg @ref RCC_CRS_TIMEOUT
<> 144:ef7eb2e8f9f7 789 * @arg @ref RCC_CRS_SYNCOK
<> 144:ef7eb2e8f9f7 790 * @arg @ref RCC_CRS_SYNCWARN
<> 144:ef7eb2e8f9f7 791 * @arg @ref RCC_CRS_SYNCERR
<> 144:ef7eb2e8f9f7 792 * @arg @ref RCC_CRS_SYNCMISS
<> 144:ef7eb2e8f9f7 793 * @arg @ref RCC_CRS_TRIMOVF
<> 144:ef7eb2e8f9f7 794 */
<> 144:ef7eb2e8f9f7 795 uint32_t HAL_RCCEx_CRSWaitSynchronization(uint32_t Timeout)
<> 144:ef7eb2e8f9f7 796 {
<> 144:ef7eb2e8f9f7 797 uint32_t crsstatus = RCC_CRS_NONE;
<> 144:ef7eb2e8f9f7 798 uint32_t tickstart = 0U;
<> 144:ef7eb2e8f9f7 799
<> 144:ef7eb2e8f9f7 800 /* Get timeout */
<> 144:ef7eb2e8f9f7 801 tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 802
<> 144:ef7eb2e8f9f7 803 /* Wait for CRS flag or timeout detection */
<> 144:ef7eb2e8f9f7 804 do
<> 144:ef7eb2e8f9f7 805 {
<> 144:ef7eb2e8f9f7 806 if(Timeout != HAL_MAX_DELAY)
<> 144:ef7eb2e8f9f7 807 {
<> 144:ef7eb2e8f9f7 808 if((Timeout == 0U) || ((HAL_GetTick() - tickstart) > Timeout))
<> 144:ef7eb2e8f9f7 809 {
<> 144:ef7eb2e8f9f7 810 crsstatus = RCC_CRS_TIMEOUT;
<> 144:ef7eb2e8f9f7 811 }
<> 144:ef7eb2e8f9f7 812 }
<> 144:ef7eb2e8f9f7 813 /* Check CRS SYNCOK flag */
<> 144:ef7eb2e8f9f7 814 if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_SYNCOK))
<> 144:ef7eb2e8f9f7 815 {
<> 144:ef7eb2e8f9f7 816 /* CRS SYNC event OK */
<> 144:ef7eb2e8f9f7 817 crsstatus |= RCC_CRS_SYNCOK;
<> 144:ef7eb2e8f9f7 818
<> 144:ef7eb2e8f9f7 819 /* Clear CRS SYNC event OK bit */
<> 144:ef7eb2e8f9f7 820 __HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_SYNCOK);
<> 144:ef7eb2e8f9f7 821 }
<> 144:ef7eb2e8f9f7 822
<> 144:ef7eb2e8f9f7 823 /* Check CRS SYNCWARN flag */
<> 144:ef7eb2e8f9f7 824 if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_SYNCWARN))
<> 144:ef7eb2e8f9f7 825 {
<> 144:ef7eb2e8f9f7 826 /* CRS SYNC warning */
<> 144:ef7eb2e8f9f7 827 crsstatus |= RCC_CRS_SYNCWARN;
<> 144:ef7eb2e8f9f7 828
<> 144:ef7eb2e8f9f7 829 /* Clear CRS SYNCWARN bit */
<> 144:ef7eb2e8f9f7 830 __HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_SYNCWARN);
<> 144:ef7eb2e8f9f7 831 }
<> 144:ef7eb2e8f9f7 832
<> 144:ef7eb2e8f9f7 833 /* Check CRS TRIM overflow flag */
<> 144:ef7eb2e8f9f7 834 if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_TRIMOVF))
<> 144:ef7eb2e8f9f7 835 {
<> 144:ef7eb2e8f9f7 836 /* CRS SYNC Error */
<> 144:ef7eb2e8f9f7 837 crsstatus |= RCC_CRS_TRIMOVF;
<> 144:ef7eb2e8f9f7 838
<> 144:ef7eb2e8f9f7 839 /* Clear CRS Error bit */
<> 144:ef7eb2e8f9f7 840 __HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_TRIMOVF);
<> 144:ef7eb2e8f9f7 841 }
<> 144:ef7eb2e8f9f7 842
<> 144:ef7eb2e8f9f7 843 /* Check CRS Error flag */
<> 144:ef7eb2e8f9f7 844 if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_SYNCERR))
<> 144:ef7eb2e8f9f7 845 {
<> 144:ef7eb2e8f9f7 846 /* CRS SYNC Error */
<> 144:ef7eb2e8f9f7 847 crsstatus |= RCC_CRS_SYNCERR;
<> 144:ef7eb2e8f9f7 848
<> 144:ef7eb2e8f9f7 849 /* Clear CRS Error bit */
<> 144:ef7eb2e8f9f7 850 __HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_SYNCERR);
<> 144:ef7eb2e8f9f7 851 }
<> 144:ef7eb2e8f9f7 852
<> 144:ef7eb2e8f9f7 853 /* Check CRS SYNC Missed flag */
<> 144:ef7eb2e8f9f7 854 if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_SYNCMISS))
<> 144:ef7eb2e8f9f7 855 {
<> 144:ef7eb2e8f9f7 856 /* CRS SYNC Missed */
<> 144:ef7eb2e8f9f7 857 crsstatus |= RCC_CRS_SYNCMISS;
<> 144:ef7eb2e8f9f7 858
<> 144:ef7eb2e8f9f7 859 /* Clear CRS SYNC Missed bit */
<> 144:ef7eb2e8f9f7 860 __HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_SYNCMISS);
<> 144:ef7eb2e8f9f7 861 }
<> 144:ef7eb2e8f9f7 862
<> 144:ef7eb2e8f9f7 863 /* Check CRS Expected SYNC flag */
<> 144:ef7eb2e8f9f7 864 if(__HAL_RCC_CRS_GET_FLAG(RCC_CRS_FLAG_ESYNC))
<> 144:ef7eb2e8f9f7 865 {
<> 144:ef7eb2e8f9f7 866 /* frequency error counter reached a zero value */
<> 144:ef7eb2e8f9f7 867 __HAL_RCC_CRS_CLEAR_FLAG(RCC_CRS_FLAG_ESYNC);
<> 144:ef7eb2e8f9f7 868 }
<> 144:ef7eb2e8f9f7 869 } while(RCC_CRS_NONE == crsstatus);
<> 144:ef7eb2e8f9f7 870
<> 144:ef7eb2e8f9f7 871 return crsstatus;
<> 144:ef7eb2e8f9f7 872 }
<> 144:ef7eb2e8f9f7 873
<> 144:ef7eb2e8f9f7 874 /**
<> 144:ef7eb2e8f9f7 875 * @brief Handle the Clock Recovery System interrupt request.
<> 144:ef7eb2e8f9f7 876 * @retval None
<> 144:ef7eb2e8f9f7 877 */
<> 144:ef7eb2e8f9f7 878 void HAL_RCCEx_CRS_IRQHandler(void)
<> 144:ef7eb2e8f9f7 879 {
<> 144:ef7eb2e8f9f7 880 uint32_t crserror = RCC_CRS_NONE;
<> 144:ef7eb2e8f9f7 881 /* Get current IT flags and IT sources values */
<> 144:ef7eb2e8f9f7 882 uint32_t itflags = READ_REG(CRS->ISR);
<> 144:ef7eb2e8f9f7 883 uint32_t itsources = READ_REG(CRS->CR);
<> 144:ef7eb2e8f9f7 884
<> 144:ef7eb2e8f9f7 885 /* Check CRS SYNCOK flag */
<> 144:ef7eb2e8f9f7 886 if(((itflags & RCC_CRS_FLAG_SYNCOK) != RESET) && ((itsources & RCC_CRS_IT_SYNCOK) != RESET))
<> 144:ef7eb2e8f9f7 887 {
<> 144:ef7eb2e8f9f7 888 /* Clear CRS SYNC event OK flag */
<> 144:ef7eb2e8f9f7 889 WRITE_REG(CRS->ICR, CRS_ICR_SYNCOKC);
<> 144:ef7eb2e8f9f7 890
<> 144:ef7eb2e8f9f7 891 /* user callback */
<> 144:ef7eb2e8f9f7 892 HAL_RCCEx_CRS_SyncOkCallback();
<> 144:ef7eb2e8f9f7 893 }
<> 144:ef7eb2e8f9f7 894 /* Check CRS SYNCWARN flag */
<> 144:ef7eb2e8f9f7 895 else if(((itflags & RCC_CRS_FLAG_SYNCWARN) != RESET) && ((itsources & RCC_CRS_IT_SYNCWARN) != RESET))
<> 144:ef7eb2e8f9f7 896 {
<> 144:ef7eb2e8f9f7 897 /* Clear CRS SYNCWARN flag */
<> 144:ef7eb2e8f9f7 898 WRITE_REG(CRS->ICR, CRS_ICR_SYNCWARNC);
<> 144:ef7eb2e8f9f7 899
<> 144:ef7eb2e8f9f7 900 /* user callback */
<> 144:ef7eb2e8f9f7 901 HAL_RCCEx_CRS_SyncWarnCallback();
<> 144:ef7eb2e8f9f7 902 }
<> 144:ef7eb2e8f9f7 903 /* Check CRS Expected SYNC flag */
<> 144:ef7eb2e8f9f7 904 else if(((itflags & RCC_CRS_FLAG_ESYNC) != RESET) && ((itsources & RCC_CRS_IT_ESYNC) != RESET))
<> 144:ef7eb2e8f9f7 905 {
<> 144:ef7eb2e8f9f7 906 /* frequency error counter reached a zero value */
<> 144:ef7eb2e8f9f7 907 WRITE_REG(CRS->ICR, CRS_ICR_ESYNCC);
<> 144:ef7eb2e8f9f7 908
<> 144:ef7eb2e8f9f7 909 /* user callback */
<> 144:ef7eb2e8f9f7 910 HAL_RCCEx_CRS_ExpectedSyncCallback();
<> 144:ef7eb2e8f9f7 911 }
<> 144:ef7eb2e8f9f7 912 /* Check CRS Error flags */
<> 144:ef7eb2e8f9f7 913 else
<> 144:ef7eb2e8f9f7 914 {
<> 144:ef7eb2e8f9f7 915 if(((itflags & RCC_CRS_FLAG_ERR) != RESET) && ((itsources & RCC_CRS_IT_ERR) != RESET))
<> 144:ef7eb2e8f9f7 916 {
<> 144:ef7eb2e8f9f7 917 if((itflags & RCC_CRS_FLAG_SYNCERR) != RESET)
<> 144:ef7eb2e8f9f7 918 {
<> 144:ef7eb2e8f9f7 919 crserror |= RCC_CRS_SYNCERR;
<> 144:ef7eb2e8f9f7 920 }
<> 144:ef7eb2e8f9f7 921 if((itflags & RCC_CRS_FLAG_SYNCMISS) != RESET)
<> 144:ef7eb2e8f9f7 922 {
<> 144:ef7eb2e8f9f7 923 crserror |= RCC_CRS_SYNCMISS;
<> 144:ef7eb2e8f9f7 924 }
<> 144:ef7eb2e8f9f7 925 if((itflags & RCC_CRS_FLAG_TRIMOVF) != RESET)
<> 144:ef7eb2e8f9f7 926 {
<> 144:ef7eb2e8f9f7 927 crserror |= RCC_CRS_TRIMOVF;
<> 144:ef7eb2e8f9f7 928 }
<> 144:ef7eb2e8f9f7 929
<> 144:ef7eb2e8f9f7 930 /* Clear CRS Error flags */
<> 144:ef7eb2e8f9f7 931 WRITE_REG(CRS->ICR, CRS_ICR_ERRC);
<> 144:ef7eb2e8f9f7 932
<> 144:ef7eb2e8f9f7 933 /* user error callback */
<> 144:ef7eb2e8f9f7 934 HAL_RCCEx_CRS_ErrorCallback(crserror);
<> 144:ef7eb2e8f9f7 935 }
<> 144:ef7eb2e8f9f7 936 }
<> 144:ef7eb2e8f9f7 937 }
<> 144:ef7eb2e8f9f7 938
<> 144:ef7eb2e8f9f7 939 /**
<> 144:ef7eb2e8f9f7 940 * @brief RCCEx Clock Recovery System SYNCOK interrupt callback.
<> 144:ef7eb2e8f9f7 941 * @retval none
<> 144:ef7eb2e8f9f7 942 */
<> 144:ef7eb2e8f9f7 943 __weak void HAL_RCCEx_CRS_SyncOkCallback(void)
<> 144:ef7eb2e8f9f7 944 {
<> 144:ef7eb2e8f9f7 945 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 946 the @ref HAL_RCCEx_CRS_SyncOkCallback should be implemented in the user file
<> 144:ef7eb2e8f9f7 947 */
<> 144:ef7eb2e8f9f7 948 }
<> 144:ef7eb2e8f9f7 949
<> 144:ef7eb2e8f9f7 950 /**
<> 144:ef7eb2e8f9f7 951 * @brief RCCEx Clock Recovery System SYNCWARN interrupt callback.
<> 144:ef7eb2e8f9f7 952 * @retval none
<> 144:ef7eb2e8f9f7 953 */
<> 144:ef7eb2e8f9f7 954 __weak void HAL_RCCEx_CRS_SyncWarnCallback(void)
<> 144:ef7eb2e8f9f7 955 {
<> 144:ef7eb2e8f9f7 956 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 957 the @ref HAL_RCCEx_CRS_SyncWarnCallback should be implemented in the user file
<> 144:ef7eb2e8f9f7 958 */
<> 144:ef7eb2e8f9f7 959 }
<> 144:ef7eb2e8f9f7 960
<> 144:ef7eb2e8f9f7 961 /**
<> 144:ef7eb2e8f9f7 962 * @brief RCCEx Clock Recovery System Expected SYNC interrupt callback.
<> 144:ef7eb2e8f9f7 963 * @retval none
<> 144:ef7eb2e8f9f7 964 */
<> 144:ef7eb2e8f9f7 965 __weak void HAL_RCCEx_CRS_ExpectedSyncCallback(void)
<> 144:ef7eb2e8f9f7 966 {
<> 144:ef7eb2e8f9f7 967 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 968 the @ref HAL_RCCEx_CRS_ExpectedSyncCallback should be implemented in the user file
<> 144:ef7eb2e8f9f7 969 */
<> 144:ef7eb2e8f9f7 970 }
<> 144:ef7eb2e8f9f7 971
<> 144:ef7eb2e8f9f7 972 /**
<> 144:ef7eb2e8f9f7 973 * @brief RCCEx Clock Recovery System Error interrupt callback.
<> 144:ef7eb2e8f9f7 974 * @param Error Combination of Error status.
<> 144:ef7eb2e8f9f7 975 * This parameter can be a combination of the following values:
<> 144:ef7eb2e8f9f7 976 * @arg @ref RCC_CRS_SYNCERR
<> 144:ef7eb2e8f9f7 977 * @arg @ref RCC_CRS_SYNCMISS
<> 144:ef7eb2e8f9f7 978 * @arg @ref RCC_CRS_TRIMOVF
<> 144:ef7eb2e8f9f7 979 * @retval none
<> 144:ef7eb2e8f9f7 980 */
<> 144:ef7eb2e8f9f7 981 __weak void HAL_RCCEx_CRS_ErrorCallback(uint32_t Error)
<> 144:ef7eb2e8f9f7 982 {
<> 144:ef7eb2e8f9f7 983 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 984 UNUSED(Error);
<> 144:ef7eb2e8f9f7 985
<> 144:ef7eb2e8f9f7 986 /* NOTE : This function should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 987 the @ref HAL_RCCEx_CRS_ErrorCallback should be implemented in the user file
<> 144:ef7eb2e8f9f7 988 */
<> 144:ef7eb2e8f9f7 989 }
<> 144:ef7eb2e8f9f7 990
<> 144:ef7eb2e8f9f7 991 /**
<> 144:ef7eb2e8f9f7 992 * @}
<> 144:ef7eb2e8f9f7 993 */
<> 144:ef7eb2e8f9f7 994
<> 144:ef7eb2e8f9f7 995 #endif /* CRS */
<> 144:ef7eb2e8f9f7 996
<> 144:ef7eb2e8f9f7 997 /**
<> 144:ef7eb2e8f9f7 998 * @}
<> 144:ef7eb2e8f9f7 999 */
<> 144:ef7eb2e8f9f7 1000
<> 144:ef7eb2e8f9f7 1001 /**
<> 144:ef7eb2e8f9f7 1002 * @}
<> 144:ef7eb2e8f9f7 1003 */
<> 144:ef7eb2e8f9f7 1004
<> 144:ef7eb2e8f9f7 1005 /**
<> 144:ef7eb2e8f9f7 1006 * @}
<> 144:ef7eb2e8f9f7 1007 */
<> 144:ef7eb2e8f9f7 1008
<> 144:ef7eb2e8f9f7 1009 #endif /* HAL_RCC_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 1010
<> 144:ef7eb2e8f9f7 1011 /**
<> 144:ef7eb2e8f9f7 1012 * @}
<> 144:ef7eb2e8f9f7 1013 */
<> 144:ef7eb2e8f9f7 1014
<> 144:ef7eb2e8f9f7 1015 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/