Tux Leon / mbed-dev

mbed library sources. Supersedes mbed-src.

Fork of mbed-dev by mbed official

targets/TARGET_STM/TARGET_STM32L4/device/stm32l4xx_ll_crs.h@181:96ed750bd169, 2018-01-17 (annotated)

Committer:
Anna Bridge
Date:
Wed Jan 17 15:23:54 2018 +0000
Revision:
181:96ed750bd169
Parent:
167:e84263d55307 
mbed-dev libray. Release version 158

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