Steven Wray / mbed-dev

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-dev by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32L4/stm32l4xx_ll_crs.h@144:ef7eb2e8f9f7, 2016-09-02 (annotated)

Committer:
<>
Date:
Fri Sep 02 15:07:44 2016 +0100
Revision:
144:ef7eb2e8f9f7
This updates the lib to the mbed lib v125

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32l4xx_ll_crs.h
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @version V1.5.1
<> 144:ef7eb2e8f9f7 6 * @date 31-May-2016
<> 144:ef7eb2e8f9f7 7 * @brief Header file of CRS LL module.
<> 144:ef7eb2e8f9f7 8 ******************************************************************************
<> 144:ef7eb2e8f9f7 9 * @attention
<> 144:ef7eb2e8f9f7 10 *
<> 144:ef7eb2e8f9f7 11 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 12 *
<> 144:ef7eb2e8f9f7 13 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 14 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 15 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 16 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 17 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 18 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 19 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 20 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 21 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 22 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 23 *
<> 144:ef7eb2e8f9f7 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 27 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 30 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 31 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 32 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 34 *
<> 144:ef7eb2e8f9f7 35 ******************************************************************************
<> 144:ef7eb2e8f9f7 36 */
<> 144:ef7eb2e8f9f7 37
<> 144:ef7eb2e8f9f7 38 /* Define to prevent recursive inclusion -------------------------------------*/
<> 144:ef7eb2e8f9f7 39 #ifndef __STM32L4xx_LL_CRS_H
<> 144:ef7eb2e8f9f7 40 #define __STM32L4xx_LL_CRS_H
<> 144:ef7eb2e8f9f7 41
<> 144:ef7eb2e8f9f7 42 #ifdef __cplusplus
<> 144:ef7eb2e8f9f7 43 extern "C" {
<> 144:ef7eb2e8f9f7 44 #endif
<> 144:ef7eb2e8f9f7 45
<> 144:ef7eb2e8f9f7 46 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 47 #include "stm32l4xx.h"
<> 144:ef7eb2e8f9f7 48
<> 144:ef7eb2e8f9f7 49 /** @addtogroup STM32L4xx_LL_Driver
<> 144:ef7eb2e8f9f7 50 * @{
<> 144:ef7eb2e8f9f7 51 */
<> 144:ef7eb2e8f9f7 52
<> 144:ef7eb2e8f9f7 53 #if defined(CRS)
<> 144:ef7eb2e8f9f7 54
<> 144:ef7eb2e8f9f7 55 /** @defgroup CRS_LL CRS
<> 144:ef7eb2e8f9f7 56 * @{
<> 144:ef7eb2e8f9f7 57 */
<> 144:ef7eb2e8f9f7 58
<> 144:ef7eb2e8f9f7 59 /* Private types -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 60 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 61
<> 144:ef7eb2e8f9f7 62 /* Private constants ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 63 /** @defgroup CRS_LL_Private_Constants CRS Private Constants
<> 144:ef7eb2e8f9f7 64 * @{
<> 144:ef7eb2e8f9f7 65 */
<> 144:ef7eb2e8f9f7 66
<> 144:ef7eb2e8f9f7 67 /* Defines used for the bit position in the register and perform offsets*/
<> 144:ef7eb2e8f9f7 68 #define CRS_POSITION_TRIM (uint32_t)POSITION_VAL(CRS_CR_TRIM) /* bit position in CR reg */
<> 144:ef7eb2e8f9f7 69 #define CRS_POSITION_FECAP (uint32_t)POSITION_VAL(CRS_ISR_FECAP) /* bit position in ISR reg */
<> 144:ef7eb2e8f9f7 70 #define CRS_POSITION_FELIM (uint32_t)POSITION_VAL(CRS_CFGR_FELIM) /* bit position in CFGR reg */
<> 144:ef7eb2e8f9f7 71
<> 144:ef7eb2e8f9f7 72
<> 144:ef7eb2e8f9f7 73 /**
<> 144:ef7eb2e8f9f7 74 * @}
<> 144:ef7eb2e8f9f7 75 */
<> 144:ef7eb2e8f9f7 76
<> 144:ef7eb2e8f9f7 77 /* Private macros ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 78
<> 144:ef7eb2e8f9f7 79 /* Exported types ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 80 /* Exported constants --------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 81 /** @defgroup CRS_LL_Exported_Constants CRS Exported Constants
<> 144:ef7eb2e8f9f7 82 * @{
<> 144:ef7eb2e8f9f7 83 */
<> 144:ef7eb2e8f9f7 84
<> 144:ef7eb2e8f9f7 85 /** @defgroup CRS_LL_EC_GET_FLAG Get Flags Defines
<> 144:ef7eb2e8f9f7 86 * @brief Flags defines which can be used with LL_CRS_ReadReg function
<> 144:ef7eb2e8f9f7 87 * @{
<> 144:ef7eb2e8f9f7 88 */
<> 144:ef7eb2e8f9f7 89 #define LL_CRS_ISR_SYNCOKF CRS_ISR_SYNCOKF
<> 144:ef7eb2e8f9f7 90 #define LL_CRS_ISR_SYNCWARNF CRS_ISR_SYNCWARNF
<> 144:ef7eb2e8f9f7 91 #define LL_CRS_ISR_ERRF CRS_ISR_ERRF
<> 144:ef7eb2e8f9f7 92 #define LL_CRS_ISR_ESYNCF CRS_ISR_ESYNCF
<> 144:ef7eb2e8f9f7 93 #define LL_CRS_ISR_SYNCERR CRS_ISR_SYNCERR
<> 144:ef7eb2e8f9f7 94 #define LL_CRS_ISR_SYNCMISS CRS_ISR_SYNCMISS
<> 144:ef7eb2e8f9f7 95 #define LL_CRS_ISR_TRIMOVF CRS_ISR_TRIMOVF
<> 144:ef7eb2e8f9f7 96 /**
<> 144:ef7eb2e8f9f7 97 * @}
<> 144:ef7eb2e8f9f7 98 */
<> 144:ef7eb2e8f9f7 99
<> 144:ef7eb2e8f9f7 100 /** @defgroup CRS_LL_EC_IT IT Defines
<> 144:ef7eb2e8f9f7 101 * @brief IT defines which can be used with LL_CRS_ReadReg and LL_CRS_WriteReg functions
<> 144:ef7eb2e8f9f7 102 * @{
<> 144:ef7eb2e8f9f7 103 */
<> 144:ef7eb2e8f9f7 104 #define LL_CRS_CR_SYNCOKIE CRS_CR_SYNCOKIE
<> 144:ef7eb2e8f9f7 105 #define LL_CRS_CR_SYNCWARNIE CRS_CR_SYNCWARNIE
<> 144:ef7eb2e8f9f7 106 #define LL_CRS_CR_ERRIE CRS_CR_ERRIE
<> 144:ef7eb2e8f9f7 107 #define LL_CRS_CR_ESYNCIE CRS_CR_ESYNCIE
<> 144:ef7eb2e8f9f7 108 /**
<> 144:ef7eb2e8f9f7 109 * @}
<> 144:ef7eb2e8f9f7 110 */
<> 144:ef7eb2e8f9f7 111
<> 144:ef7eb2e8f9f7 112 /** @defgroup CRS_LL_EC_SYNC_DIV Synchronization Signal Divider
<> 144:ef7eb2e8f9f7 113 * @{
<> 144:ef7eb2e8f9f7 114 */
<> 144:ef7eb2e8f9f7 115 #define LL_CRS_SYNC_DIV_1 ((uint32_t)0x00U) /*!< Synchro Signal not divided (default) */
<> 144:ef7eb2e8f9f7 116 #define LL_CRS_SYNC_DIV_2 CRS_CFGR_SYNCDIV_0 /*!< Synchro Signal divided by 2 */
<> 144:ef7eb2e8f9f7 117 #define LL_CRS_SYNC_DIV_4 CRS_CFGR_SYNCDIV_1 /*!< Synchro Signal divided by 4 */
<> 144:ef7eb2e8f9f7 118 #define LL_CRS_SYNC_DIV_8 (CRS_CFGR_SYNCDIV_1 | CRS_CFGR_SYNCDIV_0) /*!< Synchro Signal divided by 8 */
<> 144:ef7eb2e8f9f7 119 #define LL_CRS_SYNC_DIV_16 CRS_CFGR_SYNCDIV_2 /*!< Synchro Signal divided by 16 */
<> 144:ef7eb2e8f9f7 120 #define LL_CRS_SYNC_DIV_32 (CRS_CFGR_SYNCDIV_2 | CRS_CFGR_SYNCDIV_0) /*!< Synchro Signal divided by 32 */
<> 144:ef7eb2e8f9f7 121 #define LL_CRS_SYNC_DIV_64 (CRS_CFGR_SYNCDIV_2 | CRS_CFGR_SYNCDIV_1) /*!< Synchro Signal divided by 64 */
<> 144:ef7eb2e8f9f7 122 #define LL_CRS_SYNC_DIV_128 CRS_CFGR_SYNCDIV /*!< Synchro Signal divided by 128 */
<> 144:ef7eb2e8f9f7 123 /**
<> 144:ef7eb2e8f9f7 124 * @}
<> 144:ef7eb2e8f9f7 125 */
<> 144:ef7eb2e8f9f7 126
<> 144:ef7eb2e8f9f7 127 /** @defgroup CRS_LL_EC_SYNC_SOURCE Synchronization Signal Source
<> 144:ef7eb2e8f9f7 128 * @{
<> 144:ef7eb2e8f9f7 129 */
<> 144:ef7eb2e8f9f7 130 #define LL_CRS_SYNC_SOURCE_GPIO ((uint32_t)0x00U) /*!< Synchro Signal soucre GPIO */
<> 144:ef7eb2e8f9f7 131 #define LL_CRS_SYNC_SOURCE_LSE CRS_CFGR_SYNCSRC_0 /*!< Synchro Signal source LSE */
<> 144:ef7eb2e8f9f7 132 #define LL_CRS_SYNC_SOURCE_USB CRS_CFGR_SYNCSRC_1 /*!< Synchro Signal source USB SOF (default)*/
<> 144:ef7eb2e8f9f7 133 /**
<> 144:ef7eb2e8f9f7 134 * @}
<> 144:ef7eb2e8f9f7 135 */
<> 144:ef7eb2e8f9f7 136
<> 144:ef7eb2e8f9f7 137 /** @defgroup CRS_LL_EC_SYNC_POLARITY Synchronization Signal Polarity
<> 144:ef7eb2e8f9f7 138 * @{
<> 144:ef7eb2e8f9f7 139 */
<> 144:ef7eb2e8f9f7 140 #define LL_CRS_SYNC_POLARITY_RISING ((uint32_t)0x00U) /*!< Synchro Active on rising edge (default) */
<> 144:ef7eb2e8f9f7 141 #define LL_CRS_SYNC_POLARITY_FALLING CRS_CFGR_SYNCPOL /*!< Synchro Active on falling edge */
<> 144:ef7eb2e8f9f7 142 /**
<> 144:ef7eb2e8f9f7 143 * @}
<> 144:ef7eb2e8f9f7 144 */
<> 144:ef7eb2e8f9f7 145
<> 144:ef7eb2e8f9f7 146 /** @defgroup CRS_LL_EC_FREQERRORDIR Frequency Error Direction
<> 144:ef7eb2e8f9f7 147 * @{
<> 144:ef7eb2e8f9f7 148 */
<> 144:ef7eb2e8f9f7 149 #define LL_CRS_FREQ_ERROR_DIR_UP ((uint32_t)0x00U) /*!< Upcounting direction, the actual frequency is above the target */
<> 144:ef7eb2e8f9f7 150 #define LL_CRS_FREQ_ERROR_DIR_DOWN ((uint32_t)CRS_ISR_FEDIR) /*!< Downcounting direction, the actual frequency is below the target */
<> 144:ef7eb2e8f9f7 151 /**
<> 144:ef7eb2e8f9f7 152 * @}
<> 144:ef7eb2e8f9f7 153 */
<> 144:ef7eb2e8f9f7 154
<> 144:ef7eb2e8f9f7 155 /** @defgroup CRS_LL_EC_DEFAULTVALUES Default Values
<> 144:ef7eb2e8f9f7 156 * @{
<> 144:ef7eb2e8f9f7 157 */
<> 144:ef7eb2e8f9f7 158 /**
<> 144:ef7eb2e8f9f7 159 * @brief Reset value of the RELOAD field
<> 144:ef7eb2e8f9f7 160 * @note The reset value of the RELOAD field corresponds to a target frequency of 48 MHz
<> 144:ef7eb2e8f9f7 161 * and a synchronization signal frequency of 1 kHz (SOF signal from USB)
<> 144:ef7eb2e8f9f7 162 */
<> 144:ef7eb2e8f9f7 163 #define LL_CRS_RELOADVALUE_DEFAULT ((uint32_t)0xBB7FU)
<> 144:ef7eb2e8f9f7 164
<> 144:ef7eb2e8f9f7 165 /**
<> 144:ef7eb2e8f9f7 166 * @brief Reset value of Frequency error limit.
<> 144:ef7eb2e8f9f7 167 */
<> 144:ef7eb2e8f9f7 168 #define LL_CRS_ERRORLIMIT_DEFAULT ((uint32_t)0x22U)
<> 144:ef7eb2e8f9f7 169
<> 144:ef7eb2e8f9f7 170 /**
<> 144:ef7eb2e8f9f7 171 * @brief Reset value of the HSI48 Calibration field
<> 144:ef7eb2e8f9f7 172 * @note The default value is 32, which corresponds to the middle of the trimming interval.
<> 144:ef7eb2e8f9f7 173 * The trimming step is around 67 kHz between two consecutive TRIM steps.
<> 144:ef7eb2e8f9f7 174 * A higher TRIM value corresponds to a higher output frequency
<> 144:ef7eb2e8f9f7 175 */
<> 144:ef7eb2e8f9f7 176 #define LL_CRS_HSI48CALIBRATION_DEFAULT ((uint32_t)0x20U)
<> 144:ef7eb2e8f9f7 177 /**
<> 144:ef7eb2e8f9f7 178 * @}
<> 144:ef7eb2e8f9f7 179 */
<> 144:ef7eb2e8f9f7 180
<> 144:ef7eb2e8f9f7 181 /**
<> 144:ef7eb2e8f9f7 182 * @}
<> 144:ef7eb2e8f9f7 183 */
<> 144:ef7eb2e8f9f7 184
<> 144:ef7eb2e8f9f7 185 /* Exported macro ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 186 /** @defgroup CRS_LL_Exported_Macros CRS Exported Macros
<> 144:ef7eb2e8f9f7 187 * @{
<> 144:ef7eb2e8f9f7 188 */
<> 144:ef7eb2e8f9f7 189
<> 144:ef7eb2e8f9f7 190 /** @defgroup CRS_LL_EM_WRITE_READ Common Write and read registers Macros
<> 144:ef7eb2e8f9f7 191 * @{
<> 144:ef7eb2e8f9f7 192 */
<> 144:ef7eb2e8f9f7 193
<> 144:ef7eb2e8f9f7 194 /**
<> 144:ef7eb2e8f9f7 195 * @brief Write a value in CRS register
<> 144:ef7eb2e8f9f7 196 * @param __INSTANCE__ CRS Instance
<> 144:ef7eb2e8f9f7 197 * @param __REG__ Register to be written
<> 144:ef7eb2e8f9f7 198 * @param __VALUE__ Value to be written in the register
<> 144:ef7eb2e8f9f7 199 * @retval None
<> 144:ef7eb2e8f9f7 200 */
<> 144:ef7eb2e8f9f7 201 #define LL_CRS_WriteReg(__INSTANCE__, __REG__, __VALUE__) WRITE_REG(__INSTANCE__->__REG__, (__VALUE__))
<> 144:ef7eb2e8f9f7 202
<> 144:ef7eb2e8f9f7 203 /**
<> 144:ef7eb2e8f9f7 204 * @brief Read a value in CRS register
<> 144:ef7eb2e8f9f7 205 * @param __INSTANCE__ CRS Instance
<> 144:ef7eb2e8f9f7 206 * @param __REG__ Register to be read
<> 144:ef7eb2e8f9f7 207 * @retval Register value
<> 144:ef7eb2e8f9f7 208 */
<> 144:ef7eb2e8f9f7 209 #define LL_CRS_ReadReg(__INSTANCE__, __REG__) READ_REG(__INSTANCE__->__REG__)
<> 144:ef7eb2e8f9f7 210 /**
<> 144:ef7eb2e8f9f7 211 * @}
<> 144:ef7eb2e8f9f7 212 */
<> 144:ef7eb2e8f9f7 213
<> 144:ef7eb2e8f9f7 214 /** @defgroup CRS_LL_EM_Exported_Macros_Calculate_Reload Exported_Macros_Calculate_Reload
<> 144:ef7eb2e8f9f7 215 * @{
<> 144:ef7eb2e8f9f7 216 */
<> 144:ef7eb2e8f9f7 217
<> 144:ef7eb2e8f9f7 218 /**
<> 144:ef7eb2e8f9f7 219 * @brief Macro to calculate reload value to be set in CRS register according to target and sync frequencies
<> 144:ef7eb2e8f9f7 220 * @note The RELOAD value should be selected according to the ratio between
<> 144:ef7eb2e8f9f7 221 * the target frequency and the frequency of the synchronization source after
<> 144:ef7eb2e8f9f7 222 * prescaling. It is then decreased by one in order to reach the expected
<> 144:ef7eb2e8f9f7 223 * synchronization on the zero value. The formula is the following:
<> 144:ef7eb2e8f9f7 224 * RELOAD = (fTARGET / fSYNC) -1
<> 144:ef7eb2e8f9f7 225 * @param __FTARGET__ Target frequency (value in Hz)
<> 144:ef7eb2e8f9f7 226 * @param __FSYNC__ Synchronization signal frequency (value in Hz)
<> 144:ef7eb2e8f9f7 227 * @retval Reload value (in Hz)
<> 144:ef7eb2e8f9f7 228 */
<> 144:ef7eb2e8f9f7 229 #define __LL_CRS_CALC_CALCULATE_RELOADVALUE(__FTARGET__, __FSYNC__) (((__FTARGET__) / (__FSYNC__)) - 1U)
<> 144:ef7eb2e8f9f7 230
<> 144:ef7eb2e8f9f7 231 /**
<> 144:ef7eb2e8f9f7 232 * @}
<> 144:ef7eb2e8f9f7 233 */
<> 144:ef7eb2e8f9f7 234
<> 144:ef7eb2e8f9f7 235 /**
<> 144:ef7eb2e8f9f7 236 * @}
<> 144:ef7eb2e8f9f7 237 */
<> 144:ef7eb2e8f9f7 238
<> 144:ef7eb2e8f9f7 239 /* Exported functions --------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 240 /** @defgroup CRS_LL_Exported_Functions CRS Exported Functions
<> 144:ef7eb2e8f9f7 241 * @{
<> 144:ef7eb2e8f9f7 242 */
<> 144:ef7eb2e8f9f7 243
<> 144:ef7eb2e8f9f7 244 /** @defgroup CRS_LL_EF_Configuration Configuration
<> 144:ef7eb2e8f9f7 245 * @{
<> 144:ef7eb2e8f9f7 246 */
<> 144:ef7eb2e8f9f7 247
<> 144:ef7eb2e8f9f7 248 /**
<> 144:ef7eb2e8f9f7 249 * @brief Enable Frequency error counter
<> 144:ef7eb2e8f9f7 250 * @note When this bit is set, the CRS_CFGR register is write-protected and cannot be modified
<> 144:ef7eb2e8f9f7 251 * @rmtoll CR CEN LL_CRS_EnableFreqErrorCounter
<> 144:ef7eb2e8f9f7 252 * @retval None
<> 144:ef7eb2e8f9f7 253 */
<> 144:ef7eb2e8f9f7 254 __STATIC_INLINE void LL_CRS_EnableFreqErrorCounter(void)
<> 144:ef7eb2e8f9f7 255 {
<> 144:ef7eb2e8f9f7 256 SET_BIT(CRS->CR, CRS_CR_CEN);
<> 144:ef7eb2e8f9f7 257 }
<> 144:ef7eb2e8f9f7 258
<> 144:ef7eb2e8f9f7 259 /**
<> 144:ef7eb2e8f9f7 260 * @brief Disable Frequency error counter
<> 144:ef7eb2e8f9f7 261 * @rmtoll CR CEN LL_CRS_DisableFreqErrorCounter
<> 144:ef7eb2e8f9f7 262 * @retval None
<> 144:ef7eb2e8f9f7 263 */
<> 144:ef7eb2e8f9f7 264 __STATIC_INLINE void LL_CRS_DisableFreqErrorCounter(void)
<> 144:ef7eb2e8f9f7 265 {
<> 144:ef7eb2e8f9f7 266 CLEAR_BIT(CRS->CR, CRS_CR_CEN);
<> 144:ef7eb2e8f9f7 267 }
<> 144:ef7eb2e8f9f7 268
<> 144:ef7eb2e8f9f7 269 /**
<> 144:ef7eb2e8f9f7 270 * @brief Check if Frequency error counter is enabled or not
<> 144:ef7eb2e8f9f7 271 * @rmtoll CR CEN LL_CRS_IsEnabledFreqErrorCounter
<> 144:ef7eb2e8f9f7 272 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 273 */
<> 144:ef7eb2e8f9f7 274 __STATIC_INLINE uint32_t LL_CRS_IsEnabledFreqErrorCounter(void)
<> 144:ef7eb2e8f9f7 275 {
<> 144:ef7eb2e8f9f7 276 return (READ_BIT(CRS->CR, CRS_CR_CEN) == (CRS_CR_CEN));
<> 144:ef7eb2e8f9f7 277 }
<> 144:ef7eb2e8f9f7 278
<> 144:ef7eb2e8f9f7 279 /**
<> 144:ef7eb2e8f9f7 280 * @brief Enable Automatic trimming counter
<> 144:ef7eb2e8f9f7 281 * @rmtoll CR AUTOTRIMEN LL_CRS_EnableAutoTrimming
<> 144:ef7eb2e8f9f7 282 * @retval None
<> 144:ef7eb2e8f9f7 283 */
<> 144:ef7eb2e8f9f7 284 __STATIC_INLINE void LL_CRS_EnableAutoTrimming(void)
<> 144:ef7eb2e8f9f7 285 {
<> 144:ef7eb2e8f9f7 286 SET_BIT(CRS->CR, CRS_CR_AUTOTRIMEN);
<> 144:ef7eb2e8f9f7 287 }
<> 144:ef7eb2e8f9f7 288
<> 144:ef7eb2e8f9f7 289 /**
<> 144:ef7eb2e8f9f7 290 * @brief Disable Automatic trimming counter
<> 144:ef7eb2e8f9f7 291 * @rmtoll CR AUTOTRIMEN LL_CRS_DisableAutoTrimming
<> 144:ef7eb2e8f9f7 292 * @retval None
<> 144:ef7eb2e8f9f7 293 */
<> 144:ef7eb2e8f9f7 294 __STATIC_INLINE void LL_CRS_DisableAutoTrimming(void)
<> 144:ef7eb2e8f9f7 295 {
<> 144:ef7eb2e8f9f7 296 CLEAR_BIT(CRS->CR, CRS_CR_AUTOTRIMEN);
<> 144:ef7eb2e8f9f7 297 }
<> 144:ef7eb2e8f9f7 298
<> 144:ef7eb2e8f9f7 299 /**
<> 144:ef7eb2e8f9f7 300 * @brief Check if Automatic trimming is enabled or not
<> 144:ef7eb2e8f9f7 301 * @rmtoll CR AUTOTRIMEN LL_CRS_IsEnabledAutoTrimming
<> 144:ef7eb2e8f9f7 302 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 303 */
<> 144:ef7eb2e8f9f7 304 __STATIC_INLINE uint32_t LL_CRS_IsEnabledAutoTrimming(void)
<> 144:ef7eb2e8f9f7 305 {
<> 144:ef7eb2e8f9f7 306 return (READ_BIT(CRS->CR, CRS_CR_AUTOTRIMEN) == (CRS_CR_AUTOTRIMEN));
<> 144:ef7eb2e8f9f7 307 }
<> 144:ef7eb2e8f9f7 308
<> 144:ef7eb2e8f9f7 309 /**
<> 144:ef7eb2e8f9f7 310 * @brief Set HSI48 oscillator smooth trimming
<> 144:ef7eb2e8f9f7 311 * @note When the AUTOTRIMEN bit is set, this field is controlled by hardware and is read-only
<> 144:ef7eb2e8f9f7 312 * @rmtoll CR TRIM LL_CRS_SetHSI48SmoothTrimming
<> 144:ef7eb2e8f9f7 313 * @param Value a number between Min_Data = 0 and Max_Data = 63
<> 144:ef7eb2e8f9f7 314 * @note Default value can be set thanks to @ref LL_CRS_HSI48CALIBRATION_DEFAULT
<> 144:ef7eb2e8f9f7 315 * @retval None
<> 144:ef7eb2e8f9f7 316 */
<> 144:ef7eb2e8f9f7 317 __STATIC_INLINE void LL_CRS_SetHSI48SmoothTrimming(uint32_t Value)
<> 144:ef7eb2e8f9f7 318 {
<> 144:ef7eb2e8f9f7 319 MODIFY_REG(CRS->CR, CRS_CR_TRIM, Value << CRS_POSITION_TRIM);
<> 144:ef7eb2e8f9f7 320 }
<> 144:ef7eb2e8f9f7 321
<> 144:ef7eb2e8f9f7 322 /**
<> 144:ef7eb2e8f9f7 323 * @brief Get HSI48 oscillator smooth trimming
<> 144:ef7eb2e8f9f7 324 * @rmtoll CR TRIM LL_CRS_GetHSI48SmoothTrimming
<> 144:ef7eb2e8f9f7 325 * @retval a number between Min_Data = 0 and Max_Data = 63
<> 144:ef7eb2e8f9f7 326 */
<> 144:ef7eb2e8f9f7 327 __STATIC_INLINE uint32_t LL_CRS_GetHSI48SmoothTrimming(void)
<> 144:ef7eb2e8f9f7 328 {
<> 144:ef7eb2e8f9f7 329 return (uint32_t)(READ_BIT(CRS->CR, CRS_CR_TRIM) >> CRS_POSITION_TRIM);
<> 144:ef7eb2e8f9f7 330 }
<> 144:ef7eb2e8f9f7 331
<> 144:ef7eb2e8f9f7 332 /**
<> 144:ef7eb2e8f9f7 333 * @brief Set counter reload value
<> 144:ef7eb2e8f9f7 334 * @rmtoll CFGR RELOAD LL_CRS_SetReloadCounter
<> 144:ef7eb2e8f9f7 335 * @param Value a number between Min_Data = 0 and Max_Data = 0xFFFF
<> 144:ef7eb2e8f9f7 336 * @note Default value can be set thanks to @ref LL_CRS_RELOADVALUE_DEFAULT
<> 144:ef7eb2e8f9f7 337 * Otherwise it can be calculated in using macro @ref __LL_CRS_CALC_CALCULATE_RELOADVALUE (_FTARGET_, _FSYNC_)
<> 144:ef7eb2e8f9f7 338 * @retval None
<> 144:ef7eb2e8f9f7 339 */
<> 144:ef7eb2e8f9f7 340 __STATIC_INLINE void LL_CRS_SetReloadCounter(uint32_t Value)
<> 144:ef7eb2e8f9f7 341 {
<> 144:ef7eb2e8f9f7 342 MODIFY_REG(CRS->CFGR, CRS_CFGR_RELOAD, Value);
<> 144:ef7eb2e8f9f7 343 }
<> 144:ef7eb2e8f9f7 344
<> 144:ef7eb2e8f9f7 345 /**
<> 144:ef7eb2e8f9f7 346 * @brief Get counter reload value
<> 144:ef7eb2e8f9f7 347 * @rmtoll CFGR RELOAD LL_CRS_GetReloadCounter
<> 144:ef7eb2e8f9f7 348 * @retval a number between Min_Data = 0 and Max_Data = 0xFFFF
<> 144:ef7eb2e8f9f7 349 */
<> 144:ef7eb2e8f9f7 350 __STATIC_INLINE uint32_t LL_CRS_GetReloadCounter(void)
<> 144:ef7eb2e8f9f7 351 {
<> 144:ef7eb2e8f9f7 352 return (uint32_t)(READ_BIT(CRS->CFGR, CRS_CFGR_RELOAD));
<> 144:ef7eb2e8f9f7 353 }
<> 144:ef7eb2e8f9f7 354
<> 144:ef7eb2e8f9f7 355 /**
<> 144:ef7eb2e8f9f7 356 * @brief Set frequency error limit
<> 144:ef7eb2e8f9f7 357 * @rmtoll CFGR FELIM LL_CRS_SetFreqErrorLimit
<> 144:ef7eb2e8f9f7 358 * @param Value a number between Min_Data = 0 and Max_Data = 255
<> 144:ef7eb2e8f9f7 359 * @note Default value can be set thanks to @ref LL_CRS_ERRORLIMIT_DEFAULT
<> 144:ef7eb2e8f9f7 360 * @retval None
<> 144:ef7eb2e8f9f7 361 */
<> 144:ef7eb2e8f9f7 362 __STATIC_INLINE void LL_CRS_SetFreqErrorLimit(uint32_t Value)
<> 144:ef7eb2e8f9f7 363 {
<> 144:ef7eb2e8f9f7 364 MODIFY_REG(CRS->CFGR, CRS_CFGR_FELIM, Value << CRS_POSITION_FELIM);
<> 144:ef7eb2e8f9f7 365 }
<> 144:ef7eb2e8f9f7 366
<> 144:ef7eb2e8f9f7 367 /**
<> 144:ef7eb2e8f9f7 368 * @brief Get frequency error limit
<> 144:ef7eb2e8f9f7 369 * @rmtoll CFGR FELIM LL_CRS_GetFreqErrorLimit
<> 144:ef7eb2e8f9f7 370 * @retval A number between Min_Data = 0 and Max_Data = 255
<> 144:ef7eb2e8f9f7 371 */
<> 144:ef7eb2e8f9f7 372 __STATIC_INLINE uint32_t LL_CRS_GetFreqErrorLimit(void)
<> 144:ef7eb2e8f9f7 373 {
<> 144:ef7eb2e8f9f7 374 return (uint32_t)(READ_BIT(CRS->CFGR, CRS_CFGR_FELIM) >> CRS_POSITION_FELIM);
<> 144:ef7eb2e8f9f7 375 }
<> 144:ef7eb2e8f9f7 376
<> 144:ef7eb2e8f9f7 377 /**
<> 144:ef7eb2e8f9f7 378 * @brief Set division factor for SYNC signal
<> 144:ef7eb2e8f9f7 379 * @rmtoll CFGR SYNCDIV LL_CRS_SetSyncDivider
<> 144:ef7eb2e8f9f7 380 * @param Divider This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 381 * @arg @ref LL_CRS_SYNC_DIV_1
<> 144:ef7eb2e8f9f7 382 * @arg @ref LL_CRS_SYNC_DIV_2
<> 144:ef7eb2e8f9f7 383 * @arg @ref LL_CRS_SYNC_DIV_4
<> 144:ef7eb2e8f9f7 384 * @arg @ref LL_CRS_SYNC_DIV_8
<> 144:ef7eb2e8f9f7 385 * @arg @ref LL_CRS_SYNC_DIV_16
<> 144:ef7eb2e8f9f7 386 * @arg @ref LL_CRS_SYNC_DIV_32
<> 144:ef7eb2e8f9f7 387 * @arg @ref LL_CRS_SYNC_DIV_64
<> 144:ef7eb2e8f9f7 388 * @arg @ref LL_CRS_SYNC_DIV_128
<> 144:ef7eb2e8f9f7 389 * @retval None
<> 144:ef7eb2e8f9f7 390 */
<> 144:ef7eb2e8f9f7 391 __STATIC_INLINE void LL_CRS_SetSyncDivider(uint32_t Divider)
<> 144:ef7eb2e8f9f7 392 {
<> 144:ef7eb2e8f9f7 393 MODIFY_REG(CRS->CFGR, CRS_CFGR_SYNCDIV, Divider);
<> 144:ef7eb2e8f9f7 394 }
<> 144:ef7eb2e8f9f7 395
<> 144:ef7eb2e8f9f7 396 /**
<> 144:ef7eb2e8f9f7 397 * @brief Get division factor for SYNC signal
<> 144:ef7eb2e8f9f7 398 * @rmtoll CFGR SYNCDIV LL_CRS_GetSyncDivider
<> 144:ef7eb2e8f9f7 399 * @retval Returned value can be one of the following values:
<> 144:ef7eb2e8f9f7 400 * @arg @ref LL_CRS_SYNC_DIV_1
<> 144:ef7eb2e8f9f7 401 * @arg @ref LL_CRS_SYNC_DIV_2
<> 144:ef7eb2e8f9f7 402 * @arg @ref LL_CRS_SYNC_DIV_4
<> 144:ef7eb2e8f9f7 403 * @arg @ref LL_CRS_SYNC_DIV_8
<> 144:ef7eb2e8f9f7 404 * @arg @ref LL_CRS_SYNC_DIV_16
<> 144:ef7eb2e8f9f7 405 * @arg @ref LL_CRS_SYNC_DIV_32
<> 144:ef7eb2e8f9f7 406 * @arg @ref LL_CRS_SYNC_DIV_64
<> 144:ef7eb2e8f9f7 407 * @arg @ref LL_CRS_SYNC_DIV_128
<> 144:ef7eb2e8f9f7 408 */
<> 144:ef7eb2e8f9f7 409 __STATIC_INLINE uint32_t LL_CRS_GetSyncDivider(void)
<> 144:ef7eb2e8f9f7 410 {
<> 144:ef7eb2e8f9f7 411 return (uint32_t)(READ_BIT(CRS->CFGR, CRS_CFGR_SYNCDIV));
<> 144:ef7eb2e8f9f7 412 }
<> 144:ef7eb2e8f9f7 413
<> 144:ef7eb2e8f9f7 414 /**
<> 144:ef7eb2e8f9f7 415 * @brief Set SYNC signal source
<> 144:ef7eb2e8f9f7 416 * @rmtoll CFGR SYNCSRC LL_CRS_SetSyncSignalSource
<> 144:ef7eb2e8f9f7 417 * @param Source This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 418 * @arg @ref LL_CRS_SYNC_SOURCE_GPIO
<> 144:ef7eb2e8f9f7 419 * @arg @ref LL_CRS_SYNC_SOURCE_LSE
<> 144:ef7eb2e8f9f7 420 * @arg @ref LL_CRS_SYNC_SOURCE_USB
<> 144:ef7eb2e8f9f7 421 * @retval None
<> 144:ef7eb2e8f9f7 422 */
<> 144:ef7eb2e8f9f7 423 __STATIC_INLINE void LL_CRS_SetSyncSignalSource(uint32_t Source)
<> 144:ef7eb2e8f9f7 424 {
<> 144:ef7eb2e8f9f7 425 MODIFY_REG(CRS->CFGR, CRS_CFGR_SYNCSRC, Source);
<> 144:ef7eb2e8f9f7 426 }
<> 144:ef7eb2e8f9f7 427
<> 144:ef7eb2e8f9f7 428 /**
<> 144:ef7eb2e8f9f7 429 * @brief Get SYNC signal source
<> 144:ef7eb2e8f9f7 430 * @rmtoll CFGR SYNCSRC LL_CRS_GetSyncSignalSource
<> 144:ef7eb2e8f9f7 431 * @retval Returned value can be one of the following values:
<> 144:ef7eb2e8f9f7 432 * @arg @ref LL_CRS_SYNC_SOURCE_GPIO
<> 144:ef7eb2e8f9f7 433 * @arg @ref LL_CRS_SYNC_SOURCE_LSE
<> 144:ef7eb2e8f9f7 434 * @arg @ref LL_CRS_SYNC_SOURCE_USB
<> 144:ef7eb2e8f9f7 435 */
<> 144:ef7eb2e8f9f7 436 __STATIC_INLINE uint32_t LL_CRS_GetSyncSignalSource(void)
<> 144:ef7eb2e8f9f7 437 {
<> 144:ef7eb2e8f9f7 438 return (uint32_t)(READ_BIT(CRS->CFGR, CRS_CFGR_SYNCSRC));
<> 144:ef7eb2e8f9f7 439 }
<> 144:ef7eb2e8f9f7 440
<> 144:ef7eb2e8f9f7 441 /**
<> 144:ef7eb2e8f9f7 442 * @brief Set input polarity for the SYNC signal source
<> 144:ef7eb2e8f9f7 443 * @rmtoll CFGR SYNCPOL LL_CRS_SetSyncPolarity
<> 144:ef7eb2e8f9f7 444 * @param Polarity This parameter can be one of the following values:
<> 144:ef7eb2e8f9f7 445 * @arg @ref LL_CRS_SYNC_POLARITY_RISING
<> 144:ef7eb2e8f9f7 446 * @arg @ref LL_CRS_SYNC_POLARITY_FALLING
<> 144:ef7eb2e8f9f7 447 * @retval None
<> 144:ef7eb2e8f9f7 448 */
<> 144:ef7eb2e8f9f7 449 __STATIC_INLINE void LL_CRS_SetSyncPolarity(uint32_t Polarity)
<> 144:ef7eb2e8f9f7 450 {
<> 144:ef7eb2e8f9f7 451 MODIFY_REG(CRS->CFGR, CRS_CFGR_SYNCPOL, Polarity);
<> 144:ef7eb2e8f9f7 452 }
<> 144:ef7eb2e8f9f7 453
<> 144:ef7eb2e8f9f7 454 /**
<> 144:ef7eb2e8f9f7 455 * @brief Get input polarity for the SYNC signal source
<> 144:ef7eb2e8f9f7 456 * @rmtoll CFGR SYNCPOL LL_CRS_GetSyncPolarity
<> 144:ef7eb2e8f9f7 457 * @retval Returned value can be one of the following values:
<> 144:ef7eb2e8f9f7 458 * @arg @ref LL_CRS_SYNC_POLARITY_RISING
<> 144:ef7eb2e8f9f7 459 * @arg @ref LL_CRS_SYNC_POLARITY_FALLING
<> 144:ef7eb2e8f9f7 460 */
<> 144:ef7eb2e8f9f7 461 __STATIC_INLINE uint32_t LL_CRS_GetSyncPolarity(void)
<> 144:ef7eb2e8f9f7 462 {
<> 144:ef7eb2e8f9f7 463 return (uint32_t)(READ_BIT(CRS->CFGR, CRS_CFGR_SYNCPOL));
<> 144:ef7eb2e8f9f7 464 }
<> 144:ef7eb2e8f9f7 465
<> 144:ef7eb2e8f9f7 466 /**
<> 144:ef7eb2e8f9f7 467 * @brief Configure CRS for the synchronization
<> 144:ef7eb2e8f9f7 468 * @rmtoll CR TRIM LL_CRS_ConfigSynchronization\n
<> 144:ef7eb2e8f9f7 469 * CFGR RELOAD LL_CRS_ConfigSynchronization\n
<> 144:ef7eb2e8f9f7 470 * CFGR FELIM LL_CRS_ConfigSynchronization\n
<> 144:ef7eb2e8f9f7 471 * CFGR SYNCDIV LL_CRS_ConfigSynchronization\n
<> 144:ef7eb2e8f9f7 472 * CFGR SYNCSRC LL_CRS_ConfigSynchronization\n
<> 144:ef7eb2e8f9f7 473 * CFGR SYNCPOL LL_CRS_ConfigSynchronization
<> 144:ef7eb2e8f9f7 474 * @param HSI48CalibrationValue a number between Min_Data = 0 and Max_Data = 63
<> 144:ef7eb2e8f9f7 475 * @param ErrorLimitValue a number between Min_Data = 0 and Max_Data = 0xFFFF
<> 144:ef7eb2e8f9f7 476 * @param ReloadValue a number between Min_Data = 0 and Max_Data = 255
<> 144:ef7eb2e8f9f7 477 * @param Settings This parameter can be a combination of the following values:
<> 144:ef7eb2e8f9f7 478 * @arg @ref LL_CRS_SYNC_DIV_1 or @ref LL_CRS_SYNC_DIV_2 or @ref LL_CRS_SYNC_DIV_4 or @ref LL_CRS_SYNC_DIV_8
<> 144:ef7eb2e8f9f7 479 * or @ref LL_CRS_SYNC_DIV_16 or @ref LL_CRS_SYNC_DIV_32 or @ref LL_CRS_SYNC_DIV_64 or @ref LL_CRS_SYNC_DIV_128
<> 144:ef7eb2e8f9f7 480 * @arg @ref LL_CRS_SYNC_SOURCE_GPIO or @ref LL_CRS_SYNC_SOURCE_LSE or @ref LL_CRS_SYNC_SOURCE_USB
<> 144:ef7eb2e8f9f7 481 * @arg @ref LL_CRS_SYNC_POLARITY_RISING or @ref LL_CRS_SYNC_POLARITY_FALLING
<> 144:ef7eb2e8f9f7 482 * @retval None
<> 144:ef7eb2e8f9f7 483 */
<> 144:ef7eb2e8f9f7 484 __STATIC_INLINE void LL_CRS_ConfigSynchronization(uint32_t HSI48CalibrationValue, uint32_t ErrorLimitValue, uint32_t ReloadValue, uint32_t Settings)
<> 144:ef7eb2e8f9f7 485 {
<> 144:ef7eb2e8f9f7 486 MODIFY_REG(CRS->CR, CRS_CR_TRIM, HSI48CalibrationValue);
<> 144:ef7eb2e8f9f7 487 MODIFY_REG(CRS->CFGR,
<> 144:ef7eb2e8f9f7 488 CRS_CFGR_RELOAD | CRS_CFGR_FELIM | CRS_CFGR_SYNCDIV | CRS_CFGR_SYNCSRC | CRS_CFGR_SYNCPOL,
<> 144:ef7eb2e8f9f7 489 ReloadValue | (ErrorLimitValue << CRS_POSITION_FELIM) | Settings);
<> 144:ef7eb2e8f9f7 490 }
<> 144:ef7eb2e8f9f7 491
<> 144:ef7eb2e8f9f7 492 /**
<> 144:ef7eb2e8f9f7 493 * @}
<> 144:ef7eb2e8f9f7 494 */
<> 144:ef7eb2e8f9f7 495
<> 144:ef7eb2e8f9f7 496 /** @defgroup CRS_LL_EF_CRS_Management CRS_Management
<> 144:ef7eb2e8f9f7 497 * @{
<> 144:ef7eb2e8f9f7 498 */
<> 144:ef7eb2e8f9f7 499
<> 144:ef7eb2e8f9f7 500 /**
<> 144:ef7eb2e8f9f7 501 * @brief Generate software SYNC event
<> 144:ef7eb2e8f9f7 502 * @rmtoll CR SWSYNC LL_CRS_GenerateEvent_SWSYNC
<> 144:ef7eb2e8f9f7 503 * @retval None
<> 144:ef7eb2e8f9f7 504 */
<> 144:ef7eb2e8f9f7 505 __STATIC_INLINE void LL_CRS_GenerateEvent_SWSYNC(void)
<> 144:ef7eb2e8f9f7 506 {
<> 144:ef7eb2e8f9f7 507 SET_BIT(CRS->CR, CRS_CR_SWSYNC);
<> 144:ef7eb2e8f9f7 508 }
<> 144:ef7eb2e8f9f7 509
<> 144:ef7eb2e8f9f7 510 /**
<> 144:ef7eb2e8f9f7 511 * @brief Get the frequency error direction latched in the time of the last
<> 144:ef7eb2e8f9f7 512 * SYNC event
<> 144:ef7eb2e8f9f7 513 * @rmtoll ISR FEDIR LL_CRS_GetFreqErrorDirection
<> 144:ef7eb2e8f9f7 514 * @retval Returned value can be one of the following values:
<> 144:ef7eb2e8f9f7 515 * @arg @ref LL_CRS_FREQ_ERROR_DIR_UP
<> 144:ef7eb2e8f9f7 516 * @arg @ref LL_CRS_FREQ_ERROR_DIR_DOWN
<> 144:ef7eb2e8f9f7 517 */
<> 144:ef7eb2e8f9f7 518 __STATIC_INLINE uint32_t LL_CRS_GetFreqErrorDirection(void)
<> 144:ef7eb2e8f9f7 519 {
<> 144:ef7eb2e8f9f7 520 return (uint32_t)(READ_BIT(CRS->ISR, CRS_ISR_FEDIR));
<> 144:ef7eb2e8f9f7 521 }
<> 144:ef7eb2e8f9f7 522
<> 144:ef7eb2e8f9f7 523 /**
<> 144:ef7eb2e8f9f7 524 * @brief Get the frequency error counter value latched in the time of the last SYNC event
<> 144:ef7eb2e8f9f7 525 * @rmtoll ISR FECAP LL_CRS_GetFreqErrorCapture
<> 144:ef7eb2e8f9f7 526 * @retval A number between Min_Data = 0x0000 and Max_Data = 0xFFFF
<> 144:ef7eb2e8f9f7 527 */
<> 144:ef7eb2e8f9f7 528 __STATIC_INLINE uint32_t LL_CRS_GetFreqErrorCapture(void)
<> 144:ef7eb2e8f9f7 529 {
<> 144:ef7eb2e8f9f7 530 return (uint32_t)(READ_BIT(CRS->ISR, CRS_ISR_FECAP) >> CRS_POSITION_FECAP);
<> 144:ef7eb2e8f9f7 531 }
<> 144:ef7eb2e8f9f7 532
<> 144:ef7eb2e8f9f7 533 /**
<> 144:ef7eb2e8f9f7 534 * @}
<> 144:ef7eb2e8f9f7 535 */
<> 144:ef7eb2e8f9f7 536
<> 144:ef7eb2e8f9f7 537 /** @defgroup CRS_LL_EF_FLAG_Management FLAG_Management
<> 144:ef7eb2e8f9f7 538 * @{
<> 144:ef7eb2e8f9f7 539 */
<> 144:ef7eb2e8f9f7 540
<> 144:ef7eb2e8f9f7 541 /**
<> 144:ef7eb2e8f9f7 542 * @brief Check if SYNC event OK signal occurred or not
<> 144:ef7eb2e8f9f7 543 * @rmtoll ISR SYNCOKF LL_CRS_IsActiveFlag_SYNCOK
<> 144:ef7eb2e8f9f7 544 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 545 */
<> 144:ef7eb2e8f9f7 546 __STATIC_INLINE uint32_t LL_CRS_IsActiveFlag_SYNCOK(void)
<> 144:ef7eb2e8f9f7 547 {
<> 144:ef7eb2e8f9f7 548 return (READ_BIT(CRS->ISR, CRS_ISR_SYNCOKF) == (CRS_ISR_SYNCOKF));
<> 144:ef7eb2e8f9f7 549 }
<> 144:ef7eb2e8f9f7 550
<> 144:ef7eb2e8f9f7 551 /**
<> 144:ef7eb2e8f9f7 552 * @brief Check if SYNC warning signal occurred or not
<> 144:ef7eb2e8f9f7 553 * @rmtoll ISR SYNCWARNF LL_CRS_IsActiveFlag_SYNCWARN
<> 144:ef7eb2e8f9f7 554 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 555 */
<> 144:ef7eb2e8f9f7 556 __STATIC_INLINE uint32_t LL_CRS_IsActiveFlag_SYNCWARN(void)
<> 144:ef7eb2e8f9f7 557 {
<> 144:ef7eb2e8f9f7 558 return (READ_BIT(CRS->ISR, CRS_ISR_SYNCWARNF) == (CRS_ISR_SYNCWARNF));
<> 144:ef7eb2e8f9f7 559 }
<> 144:ef7eb2e8f9f7 560
<> 144:ef7eb2e8f9f7 561 /**
<> 144:ef7eb2e8f9f7 562 * @brief Check if Synchronization or trimming error signal occurred or not
<> 144:ef7eb2e8f9f7 563 * @rmtoll ISR ERRF LL_CRS_IsActiveFlag_ERR
<> 144:ef7eb2e8f9f7 564 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 565 */
<> 144:ef7eb2e8f9f7 566 __STATIC_INLINE uint32_t LL_CRS_IsActiveFlag_ERR(void)
<> 144:ef7eb2e8f9f7 567 {
<> 144:ef7eb2e8f9f7 568 return (READ_BIT(CRS->ISR, CRS_ISR_ERRF) == (CRS_ISR_ERRF));
<> 144:ef7eb2e8f9f7 569 }
<> 144:ef7eb2e8f9f7 570
<> 144:ef7eb2e8f9f7 571 /**
<> 144:ef7eb2e8f9f7 572 * @brief Check if Expected SYNC signal occurred or not
<> 144:ef7eb2e8f9f7 573 * @rmtoll ISR ESYNCF LL_CRS_IsActiveFlag_ESYNC
<> 144:ef7eb2e8f9f7 574 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 575 */
<> 144:ef7eb2e8f9f7 576 __STATIC_INLINE uint32_t LL_CRS_IsActiveFlag_ESYNC(void)
<> 144:ef7eb2e8f9f7 577 {
<> 144:ef7eb2e8f9f7 578 return (READ_BIT(CRS->ISR, CRS_ISR_ESYNCF) == (CRS_ISR_ESYNCF));
<> 144:ef7eb2e8f9f7 579 }
<> 144:ef7eb2e8f9f7 580
<> 144:ef7eb2e8f9f7 581 /**
<> 144:ef7eb2e8f9f7 582 * @brief Check if SYNC error signal occurred or not
<> 144:ef7eb2e8f9f7 583 * @rmtoll ISR SYNCERR LL_CRS_IsActiveFlag_SYNCERR
<> 144:ef7eb2e8f9f7 584 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 585 */
<> 144:ef7eb2e8f9f7 586 __STATIC_INLINE uint32_t LL_CRS_IsActiveFlag_SYNCERR(void)
<> 144:ef7eb2e8f9f7 587 {
<> 144:ef7eb2e8f9f7 588 return (READ_BIT(CRS->ISR, CRS_ISR_SYNCERR) == (CRS_ISR_SYNCERR));
<> 144:ef7eb2e8f9f7 589 }
<> 144:ef7eb2e8f9f7 590
<> 144:ef7eb2e8f9f7 591 /**
<> 144:ef7eb2e8f9f7 592 * @brief Check if SYNC missed error signal occurred or not
<> 144:ef7eb2e8f9f7 593 * @rmtoll ISR SYNCMISS LL_CRS_IsActiveFlag_SYNCMISS
<> 144:ef7eb2e8f9f7 594 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 595 */
<> 144:ef7eb2e8f9f7 596 __STATIC_INLINE uint32_t LL_CRS_IsActiveFlag_SYNCMISS(void)
<> 144:ef7eb2e8f9f7 597 {
<> 144:ef7eb2e8f9f7 598 return (READ_BIT(CRS->ISR, CRS_ISR_SYNCMISS) == (CRS_ISR_SYNCMISS));
<> 144:ef7eb2e8f9f7 599 }
<> 144:ef7eb2e8f9f7 600
<> 144:ef7eb2e8f9f7 601 /**
<> 144:ef7eb2e8f9f7 602 * @brief Check if Trimming overflow or underflow occurred or not
<> 144:ef7eb2e8f9f7 603 * @rmtoll ISR TRIMOVF LL_CRS_IsActiveFlag_TRIMOVF
<> 144:ef7eb2e8f9f7 604 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 605 */
<> 144:ef7eb2e8f9f7 606 __STATIC_INLINE uint32_t LL_CRS_IsActiveFlag_TRIMOVF(void)
<> 144:ef7eb2e8f9f7 607 {
<> 144:ef7eb2e8f9f7 608 return (READ_BIT(CRS->ISR, CRS_ISR_TRIMOVF) == (CRS_ISR_TRIMOVF));
<> 144:ef7eb2e8f9f7 609 }
<> 144:ef7eb2e8f9f7 610
<> 144:ef7eb2e8f9f7 611 /**
<> 144:ef7eb2e8f9f7 612 * @brief Clear the SYNC event OK flag
<> 144:ef7eb2e8f9f7 613 * @rmtoll ICR SYNCOKC LL_CRS_ClearFlag_SYNCOK
<> 144:ef7eb2e8f9f7 614 * @retval None
<> 144:ef7eb2e8f9f7 615 */
<> 144:ef7eb2e8f9f7 616 __STATIC_INLINE void LL_CRS_ClearFlag_SYNCOK(void)
<> 144:ef7eb2e8f9f7 617 {
<> 144:ef7eb2e8f9f7 618 WRITE_REG(CRS->ICR, CRS_ICR_SYNCOKC);
<> 144:ef7eb2e8f9f7 619 }
<> 144:ef7eb2e8f9f7 620
<> 144:ef7eb2e8f9f7 621 /**
<> 144:ef7eb2e8f9f7 622 * @brief Clear the SYNC warning flag
<> 144:ef7eb2e8f9f7 623 * @rmtoll ICR SYNCWARNC LL_CRS_ClearFlag_SYNCWARN
<> 144:ef7eb2e8f9f7 624 * @retval None
<> 144:ef7eb2e8f9f7 625 */
<> 144:ef7eb2e8f9f7 626 __STATIC_INLINE void LL_CRS_ClearFlag_SYNCWARN(void)
<> 144:ef7eb2e8f9f7 627 {
<> 144:ef7eb2e8f9f7 628 WRITE_REG(CRS->ICR, CRS_ICR_SYNCWARNC);
<> 144:ef7eb2e8f9f7 629 }
<> 144:ef7eb2e8f9f7 630
<> 144:ef7eb2e8f9f7 631 /**
<> 144:ef7eb2e8f9f7 632 * @brief Clear TRIMOVF, SYNCMISS and SYNCERR bits and consequently also
<> 144:ef7eb2e8f9f7 633 * the ERR flag
<> 144:ef7eb2e8f9f7 634 * @rmtoll ICR ERRC LL_CRS_ClearFlag_ERR
<> 144:ef7eb2e8f9f7 635 * @retval None
<> 144:ef7eb2e8f9f7 636 */
<> 144:ef7eb2e8f9f7 637 __STATIC_INLINE void LL_CRS_ClearFlag_ERR(void)
<> 144:ef7eb2e8f9f7 638 {
<> 144:ef7eb2e8f9f7 639 WRITE_REG(CRS->ICR, CRS_ICR_ERRC);
<> 144:ef7eb2e8f9f7 640 }
<> 144:ef7eb2e8f9f7 641
<> 144:ef7eb2e8f9f7 642 /**
<> 144:ef7eb2e8f9f7 643 * @brief Clear Expected SYNC flag
<> 144:ef7eb2e8f9f7 644 * @rmtoll ICR ESYNCC LL_CRS_ClearFlag_ESYNC
<> 144:ef7eb2e8f9f7 645 * @retval None
<> 144:ef7eb2e8f9f7 646 */
<> 144:ef7eb2e8f9f7 647 __STATIC_INLINE void LL_CRS_ClearFlag_ESYNC(void)
<> 144:ef7eb2e8f9f7 648 {
<> 144:ef7eb2e8f9f7 649 WRITE_REG(CRS->ICR, CRS_ICR_ESYNCC);
<> 144:ef7eb2e8f9f7 650 }
<> 144:ef7eb2e8f9f7 651
<> 144:ef7eb2e8f9f7 652 /**
<> 144:ef7eb2e8f9f7 653 * @}
<> 144:ef7eb2e8f9f7 654 */
<> 144:ef7eb2e8f9f7 655
<> 144:ef7eb2e8f9f7 656 /** @defgroup CRS_LL_EF_IT_Management IT_Management
<> 144:ef7eb2e8f9f7 657 * @{
<> 144:ef7eb2e8f9f7 658 */
<> 144:ef7eb2e8f9f7 659
<> 144:ef7eb2e8f9f7 660 /**
<> 144:ef7eb2e8f9f7 661 * @brief Enable SYNC event OK interrupt
<> 144:ef7eb2e8f9f7 662 * @rmtoll CR SYNCOKIE LL_CRS_EnableIT_SYNCOK
<> 144:ef7eb2e8f9f7 663 * @retval None
<> 144:ef7eb2e8f9f7 664 */
<> 144:ef7eb2e8f9f7 665 __STATIC_INLINE void LL_CRS_EnableIT_SYNCOK(void)
<> 144:ef7eb2e8f9f7 666 {
<> 144:ef7eb2e8f9f7 667 SET_BIT(CRS->CR, CRS_CR_SYNCOKIE);
<> 144:ef7eb2e8f9f7 668 }
<> 144:ef7eb2e8f9f7 669
<> 144:ef7eb2e8f9f7 670 /**
<> 144:ef7eb2e8f9f7 671 * @brief Disable SYNC event OK interrupt
<> 144:ef7eb2e8f9f7 672 * @rmtoll CR SYNCOKIE LL_CRS_DisableIT_SYNCOK
<> 144:ef7eb2e8f9f7 673 * @retval None
<> 144:ef7eb2e8f9f7 674 */
<> 144:ef7eb2e8f9f7 675 __STATIC_INLINE void LL_CRS_DisableIT_SYNCOK(void)
<> 144:ef7eb2e8f9f7 676 {
<> 144:ef7eb2e8f9f7 677 CLEAR_BIT(CRS->CR, CRS_CR_SYNCOKIE);
<> 144:ef7eb2e8f9f7 678 }
<> 144:ef7eb2e8f9f7 679
<> 144:ef7eb2e8f9f7 680 /**
<> 144:ef7eb2e8f9f7 681 * @brief Check if SYNC event OK interrupt is enabled or not
<> 144:ef7eb2e8f9f7 682 * @rmtoll CR SYNCOKIE LL_CRS_IsEnabledIT_SYNCOK
<> 144:ef7eb2e8f9f7 683 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 684 */
<> 144:ef7eb2e8f9f7 685 __STATIC_INLINE uint32_t LL_CRS_IsEnabledIT_SYNCOK(void)
<> 144:ef7eb2e8f9f7 686 {
<> 144:ef7eb2e8f9f7 687 return (READ_BIT(CRS->CR, CRS_CR_SYNCOKIE) == (CRS_CR_SYNCOKIE));
<> 144:ef7eb2e8f9f7 688 }
<> 144:ef7eb2e8f9f7 689
<> 144:ef7eb2e8f9f7 690 /**
<> 144:ef7eb2e8f9f7 691 * @brief Enable SYNC warning interrupt
<> 144:ef7eb2e8f9f7 692 * @rmtoll CR SYNCWARNIE LL_CRS_EnableIT_SYNCWARN
<> 144:ef7eb2e8f9f7 693 * @retval None
<> 144:ef7eb2e8f9f7 694 */
<> 144:ef7eb2e8f9f7 695 __STATIC_INLINE void LL_CRS_EnableIT_SYNCWARN(void)
<> 144:ef7eb2e8f9f7 696 {
<> 144:ef7eb2e8f9f7 697 SET_BIT(CRS->CR, CRS_CR_SYNCWARNIE);
<> 144:ef7eb2e8f9f7 698 }
<> 144:ef7eb2e8f9f7 699
<> 144:ef7eb2e8f9f7 700 /**
<> 144:ef7eb2e8f9f7 701 * @brief Disable SYNC warning interrupt
<> 144:ef7eb2e8f9f7 702 * @rmtoll CR SYNCWARNIE LL_CRS_DisableIT_SYNCWARN
<> 144:ef7eb2e8f9f7 703 * @retval None
<> 144:ef7eb2e8f9f7 704 */
<> 144:ef7eb2e8f9f7 705 __STATIC_INLINE void LL_CRS_DisableIT_SYNCWARN(void)
<> 144:ef7eb2e8f9f7 706 {
<> 144:ef7eb2e8f9f7 707 CLEAR_BIT(CRS->CR, CRS_CR_SYNCWARNIE);
<> 144:ef7eb2e8f9f7 708 }
<> 144:ef7eb2e8f9f7 709
<> 144:ef7eb2e8f9f7 710 /**
<> 144:ef7eb2e8f9f7 711 * @brief Check if SYNC warning interrupt is enabled or not
<> 144:ef7eb2e8f9f7 712 * @rmtoll CR SYNCWARNIE LL_CRS_IsEnabledIT_SYNCWARN
<> 144:ef7eb2e8f9f7 713 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 714 */
<> 144:ef7eb2e8f9f7 715 __STATIC_INLINE uint32_t LL_CRS_IsEnabledIT_SYNCWARN(void)
<> 144:ef7eb2e8f9f7 716 {
<> 144:ef7eb2e8f9f7 717 return (READ_BIT(CRS->CR, CRS_CR_SYNCWARNIE) == (CRS_CR_SYNCWARNIE));
<> 144:ef7eb2e8f9f7 718 }
<> 144:ef7eb2e8f9f7 719
<> 144:ef7eb2e8f9f7 720 /**
<> 144:ef7eb2e8f9f7 721 * @brief Enable Synchronization or trimming error interrupt
<> 144:ef7eb2e8f9f7 722 * @rmtoll CR ERRIE LL_CRS_EnableIT_ERR
<> 144:ef7eb2e8f9f7 723 * @retval None
<> 144:ef7eb2e8f9f7 724 */
<> 144:ef7eb2e8f9f7 725 __STATIC_INLINE void LL_CRS_EnableIT_ERR(void)
<> 144:ef7eb2e8f9f7 726 {
<> 144:ef7eb2e8f9f7 727 SET_BIT(CRS->CR, CRS_CR_ERRIE);
<> 144:ef7eb2e8f9f7 728 }
<> 144:ef7eb2e8f9f7 729
<> 144:ef7eb2e8f9f7 730 /**
<> 144:ef7eb2e8f9f7 731 * @brief Disable Synchronization or trimming error interrupt
<> 144:ef7eb2e8f9f7 732 * @rmtoll CR ERRIE LL_CRS_DisableIT_ERR
<> 144:ef7eb2e8f9f7 733 * @retval None
<> 144:ef7eb2e8f9f7 734 */
<> 144:ef7eb2e8f9f7 735 __STATIC_INLINE void LL_CRS_DisableIT_ERR(void)
<> 144:ef7eb2e8f9f7 736 {
<> 144:ef7eb2e8f9f7 737 CLEAR_BIT(CRS->CR, CRS_CR_ERRIE);
<> 144:ef7eb2e8f9f7 738 }
<> 144:ef7eb2e8f9f7 739
<> 144:ef7eb2e8f9f7 740 /**
<> 144:ef7eb2e8f9f7 741 * @brief Check if Synchronization or trimming error interrupt is enabled or not
<> 144:ef7eb2e8f9f7 742 * @rmtoll CR ERRIE LL_CRS_IsEnabledIT_ERR
<> 144:ef7eb2e8f9f7 743 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 744 */
<> 144:ef7eb2e8f9f7 745 __STATIC_INLINE uint32_t LL_CRS_IsEnabledIT_ERR(void)
<> 144:ef7eb2e8f9f7 746 {
<> 144:ef7eb2e8f9f7 747 return (READ_BIT(CRS->CR, CRS_CR_ERRIE) == (CRS_CR_ERRIE));
<> 144:ef7eb2e8f9f7 748 }
<> 144:ef7eb2e8f9f7 749
<> 144:ef7eb2e8f9f7 750 /**
<> 144:ef7eb2e8f9f7 751 * @brief Enable Expected SYNC interrupt
<> 144:ef7eb2e8f9f7 752 * @rmtoll CR ESYNCIE LL_CRS_EnableIT_ESYNC
<> 144:ef7eb2e8f9f7 753 * @retval None
<> 144:ef7eb2e8f9f7 754 */
<> 144:ef7eb2e8f9f7 755 __STATIC_INLINE void LL_CRS_EnableIT_ESYNC(void)
<> 144:ef7eb2e8f9f7 756 {
<> 144:ef7eb2e8f9f7 757 SET_BIT(CRS->CR, CRS_CR_ESYNCIE);
<> 144:ef7eb2e8f9f7 758 }
<> 144:ef7eb2e8f9f7 759
<> 144:ef7eb2e8f9f7 760 /**
<> 144:ef7eb2e8f9f7 761 * @brief Disable Expected SYNC interrupt
<> 144:ef7eb2e8f9f7 762 * @rmtoll CR ESYNCIE LL_CRS_DisableIT_ESYNC
<> 144:ef7eb2e8f9f7 763 * @retval None
<> 144:ef7eb2e8f9f7 764 */
<> 144:ef7eb2e8f9f7 765 __STATIC_INLINE void LL_CRS_DisableIT_ESYNC(void)
<> 144:ef7eb2e8f9f7 766 {
<> 144:ef7eb2e8f9f7 767 CLEAR_BIT(CRS->CR, CRS_CR_ESYNCIE);
<> 144:ef7eb2e8f9f7 768 }
<> 144:ef7eb2e8f9f7 769
<> 144:ef7eb2e8f9f7 770 /**
<> 144:ef7eb2e8f9f7 771 * @brief Check if Expected SYNC interrupt is enabled or not
<> 144:ef7eb2e8f9f7 772 * @rmtoll CR ESYNCIE LL_CRS_IsEnabledIT_ESYNC
<> 144:ef7eb2e8f9f7 773 * @retval State of bit (1 or 0).
<> 144:ef7eb2e8f9f7 774 */
<> 144:ef7eb2e8f9f7 775 __STATIC_INLINE uint32_t LL_CRS_IsEnabledIT_ESYNC(void)
<> 144:ef7eb2e8f9f7 776 {
<> 144:ef7eb2e8f9f7 777 return (READ_BIT(CRS->CR, CRS_CR_ESYNCIE) == (CRS_CR_ESYNCIE));
<> 144:ef7eb2e8f9f7 778 }
<> 144:ef7eb2e8f9f7 779
<> 144:ef7eb2e8f9f7 780 /**
<> 144:ef7eb2e8f9f7 781 * @}
<> 144:ef7eb2e8f9f7 782 */
<> 144:ef7eb2e8f9f7 783
<> 144:ef7eb2e8f9f7 784 #if defined(USE_FULL_LL_DRIVER)
<> 144:ef7eb2e8f9f7 785 /** @defgroup CRS_LL_EF_Init Initialization and de-initialization functions
<> 144:ef7eb2e8f9f7 786 * @{
<> 144:ef7eb2e8f9f7 787 */
<> 144:ef7eb2e8f9f7 788
<> 144:ef7eb2e8f9f7 789 ErrorStatus LL_CRS_DeInit(void);
<> 144:ef7eb2e8f9f7 790
<> 144:ef7eb2e8f9f7 791 /**
<> 144:ef7eb2e8f9f7 792 * @}
<> 144:ef7eb2e8f9f7 793 */
<> 144:ef7eb2e8f9f7 794 #endif /* USE_FULL_LL_DRIVER */
<> 144:ef7eb2e8f9f7 795
<> 144:ef7eb2e8f9f7 796 /**
<> 144:ef7eb2e8f9f7 797 * @}
<> 144:ef7eb2e8f9f7 798 */
<> 144:ef7eb2e8f9f7 799
<> 144:ef7eb2e8f9f7 800 /**
<> 144:ef7eb2e8f9f7 801 * @}
<> 144:ef7eb2e8f9f7 802 */
<> 144:ef7eb2e8f9f7 803
<> 144:ef7eb2e8f9f7 804 #endif /* defined(CRS) */
<> 144:ef7eb2e8f9f7 805
<> 144:ef7eb2e8f9f7 806 /**
<> 144:ef7eb2e8f9f7 807 * @}
<> 144:ef7eb2e8f9f7 808 */
<> 144:ef7eb2e8f9f7 809
<> 144:ef7eb2e8f9f7 810 #ifdef __cplusplus
<> 144:ef7eb2e8f9f7 811 }
<> 144:ef7eb2e8f9f7 812 #endif
<> 144:ef7eb2e8f9f7 813
<> 144:ef7eb2e8f9f7 814 #endif /* __STM32L4xx_LL_CRS_H */
<> 144:ef7eb2e8f9f7 815
<> 144:ef7eb2e8f9f7 816 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/