ll_clk_cal.h
Go to the documentation of this file.
1 /**
2  ****************************************************************************************
3  *
4  * @file ll_clk_cal.h
5  * @author BLE Driver Team
6  * @brief Header file containing functions prototypes of CLOCK LL library.
7  *
8  ****************************************************************************************
9  * @attention
10  #####Copyright (c) 2019 GOODIX
11  All rights reserved.
12 
13  Redistribution and use in source and binary forms, with or without
14  modification, are permitted provided that the following conditions are met:
15  * Redistributions of source code must retain the above copyright
16  notice, this list of conditions and the following disclaimer.
17  * Redistributions in binary form must reproduce the above copyright
18  notice, this list of conditions and the following disclaimer in the
19  documentation and/or other materials provided with the distribution.
20  * Neither the name of GOODIX nor the names of its contributors may be used
21  to endorse or promote products derived from this software without
22  specific prior written permission.
23 
24  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
28  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34  POSSIBILITY OF SUCH DAMAGE.
35  ****************************************************************************************
36  */
37 
38 /** @addtogroup PERIPHERAL Peripheral Driver
39  * @{
40  */
41 
42 /** @addtogroup LL_DRIVER LL Driver
43  * @{
44  */
45 
46 /** @defgroup LL_CLK_CAL LL Clock Calibration
47  * @brief CLOCK CALIBRATION LL module driver.
48  * @{
49  */
50 
51 /* Define to prevent recursive inclusion -------------------------------------*/
52 #ifndef _LL_CLK_CAL_H_
53 #define _LL_CLK_CAL_H_
54 
55 #ifdef __cplusplus
56 extern "C" {
57 #endif
58 
59 /* Includes ------------------------------------------------------------------*/
60 #include "hal.h"
61 
62 /**
63  * @defgroup CLK_CAL_LL_MACRO Defines
64  * @{
65  */
66 /** @defgroup CLK_CAL_CLK_SOURCE Clock Calibration Source
67  * @{
68  */
69 #define LL_CLK_CAL_CLK_SOURCE_RTC_32K (0 << CLK_CAL_SL_CLK_SEL_VAL_POS) /**< slow clock source RTC */
70 #define LL_CLK_CAL_CLK_SOURCE_RNG_40K (1 << CLK_CAL_SL_CLK_SEL_VAL_POS) /**< slow clock source RTC */
71 #define LL_CLK_CAL_CLK_SOURCE_RNG_32K (2 << CLK_CAL_SL_CLK_SEL_VAL_POS) /**< slow clock source RTC */
72 /** @} */
73 /** @} */
74 
75 /** @defgroup CLK_CAL_LL_DRIVER_FUNCTIONS Functions
76  * @{
77  */
78 /**
79  * @brief Enable the clock calibration block
80  *
81  * Register|BitsName
82  * --------|--------
83  * SL_CLK_CTRL | EN
84  */
85 __STATIC_INLINE void ll_sl_clk_cal_enable(void)
86 {
87  SET_BITS(CLK_CAL->SL_CLK_CTRL, CLK_CAL_SL_CLK_CTRL_EN);
88 }
89 
90 /**
91  * @brief Disable the clock calibration block
92  *
93  * Register|BitsName
94  * --------|--------
95  * SL_CLK_CTRL | EN
96  *
97  */
98 __STATIC_INLINE void ll_sl_clk_cal_disable(void)
99 {
100  CLEAR_BITS(CLK_CAL->SL_CLK_CTRL, CLK_CAL_SL_CLK_CTRL_EN);
101 }
102 
103 /**
104  * @brief Is the clock calibration block
105  *
106  * Register|BitsName
107  * --------|--------
108  * SL_CLK_CTRL | EN
109  *
110  */
111 __STATIC_INLINE uint32_t ll_sl_clk_cal_is_enable(void)
112 {
113  return (READ_BITS(CLK_CAL->SL_CLK_CTRL, CLK_CAL_SL_CLK_CTRL_EN) == CLK_CAL_SL_CLK_CTRL_EN);
114 }
115 
116 /**
117  * @brief Set the slow clock calibration count
118  *
119  * Register|BitsName
120  * --------|--------
121  * SL_CLK_CNT | CNT_COUNT
122  * @param count: 0x0 ~ 0xFFF.
123  */
124 __STATIC_INLINE void ll_sl_clk_cal_set_slow_count(uint32_t count)
125 {
126  MODIFY_REG(CLK_CAL->SL_CLK_CNT, CLK_CAL_SL_CLK_CNT_COUNT, (count << CLK_CAL_SL_CLK_CNT_COUNT_POS));
127 }
128 
129 /**
130  * @brief Get the slow clock calibration setting count
131  *
132  * Register|BitsName
133  * --------|--------
134  * SL_CLK_CNT | CNT_COUNT
135  *
136  * @retval 0x0 ~ 0xFFF.
137  */
138 __STATIC_INLINE uint32_t ll_sl_clk_cal_get_slow_count(void)
139 {
140  return READ_BITS(CLK_CAL->SL_CLK_CNT, CLK_CAL_SL_CLK_CNT_COUNT);
141 }
142 
143 /**
144  * @brief Get the clock calibration done status
145  *
146  * Register|BitsName
147  * --------|--------
148  * SL_CLK_STAT | READY
149  *
150  * @retval 0x0 ~ 0x1.
151  */
152 __STATIC_INLINE uint32_t ll_sl_clk_cal_is_done(void)
153 {
154  return (READ_BITS(CLK_CAL->SL_CLK_STAT, CLK_CAL_SL_CLK_STAT_DONE) == CLK_CAL_SL_CLK_STAT_DONE);
155 }
156 
157 /**
158  * @brief Get the clock calibration overflow status
159  *
160  * Register|BitsName
161  * --------|--------
162  * SL_CLK_STAT | OVERFLOW
163  *
164  * @retval 0x0 ~ 0x1.
165  */
166 __STATIC_INLINE uint32_t ll_sl_clk_cal_is_overflow(void)
167 {
168  return (READ_BITS(CLK_CAL->SL_CLK_STAT, CLK_CAL_SL_CLK_STAT_OVER) == CLK_CAL_SL_CLK_STAT_OVER);
169 }
170 
171 /**
172  * @brief Get the fast clock calibration count value
173  *
174  * Register|BitsName
175  * --------|--------
176  * SL_CLK_CNT0 | CNT0
177  *
178  * @retval 0x0 ~ 0xFFFFFF.
179  */
180 __STATIC_INLINE uint32_t ll_sl_clk_cal_get_fast_count(void)
181 {
182  return READ_BITS(CLK_CAL->SL_CLK_CNT0, CLK_CAL_SL_CLK_CNT0_VAL);
183 }
184 
185 /**
186  * @brief Get the slow clock calibration current count value
187  *
188  * Register|BitsName
189  * --------|--------
190  * SL_CLK_CNT1 | CNT1
191  *
192  * @retval 0x0 ~ 0xFFF.
193  */
194 __STATIC_INLINE uint32_t ll_sl_clk_cal_get_slow_cur_count(void)
195 {
196  return READ_BITS(CLK_CAL->SL_CLK_CNT1, CLK_CAL_SL_CLK_CNT1_VAL);
197 }
198 
199 /**
200  * @brief Set the clock calibration clock source
201  *
202  * Register|BitsName
203  * --------|--------
204  * SL_CLK_CNT | CLK_SOURCE
205  * @param clk_source: 0x0 ~ 0x2.
206  */
207 __STATIC_INLINE void ll_sl_clk_cal_set_clk_source(uint32_t clk_source)
208 {
209  MODIFY_REG(CLK_CAL->SL_CLK_SEL, CLK_CAL_SL_CLK_SEL_VAL, clk_source);
210 }
211 
212 /**
213  * @brief Get the clock calibration clock source
214  *
215  * Register|BitsName
216  * --------|--------
217  * SL_CLK_CNT | CLK_SOURCE
218  *
219  * @retval 0x0 ~ 0x2.
220  */
221 __STATIC_INLINE uint32_t ll_sl_clk_cal_get_clk_source(void)
222 {
223  return READ_BITS(CLK_CAL->SL_CLK_SEL, CLK_CAL_SL_CLK_SEL_VAL);
224 }
225 
226 
227 /**
228  * @brief Enable the clock calibration done interrupt
229  *
230  * Register|BitsName
231  * --------|--------
232  * SL_CLK_INT_EN | DONE
233  *
234  */
235 __STATIC_INLINE void ll_sl_clk_cal_enable_done_it(void)
236 {
237  SET_BITS(CLK_CAL->SL_CLK_INT_EN, CLK_CAL_SL_CLK_INT_EN_DONE);
238 }
239 
240 /**
241  * @brief Disable the clock calibration done interrupt
242  *
243  * Register|BitsName
244  * --------|--------
245  * SL_CLK_INT_EN | DONE
246  *
247  */
248 __STATIC_INLINE void ll_sl_clk_cal_disable_done_it(void)
249 {
250  CLEAR_BITS(CLK_CAL->SL_CLK_INT_EN, CLK_CAL_SL_CLK_INT_EN_DONE);
251 }
252 
253 /**
254  * @brief Enable the clock calibration overflow interrupt
255  *
256  * Register|BitsName
257  * --------|--------
258  * SL_CLK_INT_EN | OVER
259  *
260  */
261 __STATIC_INLINE void ll_sl_clk_cal_enable_over_it(void)
262 {
263  SET_BITS(CLK_CAL->SL_CLK_INT_EN, CLK_CAL_SL_CLK_INT_EN_OVER);
264 }
265 
266 /**
267  * @brief Disable the clock calibration overflow interrupt
268  *
269  * Register|BitsName
270  * --------|--------
271  * SL_CLK_INT_EN | OVER
272  *
273  */
274 __STATIC_INLINE void ll_sl_clk_cal_disable_over_it(void)
275 {
276  CLEAR_BITS(CLK_CAL->SL_CLK_INT_EN, CLK_CAL_SL_CLK_INT_EN_OVER);
277 }
278 
279 /**
280  * @brief Clear the clock calibration done interrupt
281  *
282  * Register|BitsName
283  * --------|--------
284  * SL_CLK_INT_EN | DONE
285  *
286  */
287 __STATIC_INLINE void ll_sl_clk_cal_clear_done_it(void)
288 {
289  SET_BITS(CLK_CAL->SL_CLK_INT_CLR, CLK_CAL_SL_CLK_INT_CLR_DONE);
290 }
291 
292 /**
293  * @brief Clear the clock calibration over interrupt
294  *
295  * Register|BitsName
296  * --------|--------
297  * SL_CLK_INT_EN | DONE
298  *
299  */
300 __STATIC_INLINE void ll_sl_clk_cal_clear_over_it(void)
301 {
302  SET_BITS(CLK_CAL->SL_CLK_INT_CLR, CLK_CAL_SL_CLK_INT_CLR_OVER);
303 }
304 
305 /**
306  * @brief Enable the clock calibration block
307  *
308  * Register|BitsName
309  * --------|--------
310  * HS_CLK_CTRL | EN
311  */
312 __STATIC_INLINE void ll_hs_clk_cal_enable(void)
313 {
314  SET_BITS(CLK_CAL->HS_CLK_CTRL, CLK_CAL_HS_CLK_CTRL_EN);
315 }
316 
317 /**
318  * @brief Disable the clock calibration block
319  *
320  * Register|BitsName
321  * --------|--------
322  * HS_CLK_CTRL | EN
323  *
324  */
325 __STATIC_INLINE void ll_hs_clk_cal_disable(void)
326 {
327  CLEAR_BITS(CLK_CAL->HS_CLK_CTRL, CLK_CAL_HS_CLK_CTRL_EN);
328 }
329 
330 /**
331  * @brief Is the clock calibration block
332  *
333  * Register|BitsName
334  * --------|--------
335  * HS_CLK_CTRL | EN
336  *
337  */
338 
339 __STATIC_INLINE uint32_t ll_hs_clk_cal_is_enable(void)
340 {
341  return (READ_BITS(CLK_CAL->HS_CLK_CTRL, CLK_CAL_HS_CLK_CTRL_EN) == CLK_CAL_HS_CLK_CTRL_EN);
342 }
343 
344 /**
345  * @brief Set the slow clock calibration count
346  *
347  * Register|BitsName
348  * --------|--------
349  * HS_CLK_CNT | CNT_COUNT
350  * @param count: 0x0 ~ 0xFFF.
351  */
352 __STATIC_INLINE void ll_hs_clk_cal_set_slow_count(uint32_t count)
353 {
354  MODIFY_REG(CLK_CAL->HS_CLK_CNT, CLK_CAL_HS_CLK_CNT_COUNT, (count << CLK_CAL_HS_CLK_CNT_COUNT_POS));
355 }
356 
357 /**
358  * @brief Get the slow clock setting count
359  *
360  * Register|BitsName
361  * --------|--------
362  * HS_CLK_CNT | CNT_COUNT
363  *
364  * @retval 0x0 ~ 0xFFF.
365  */
366 __STATIC_INLINE uint32_t ll_hs_clk_cal_get_slow_count(void)
367 {
368  return READ_BITS(CLK_CAL->HS_CLK_CNT, CLK_CAL_HS_CLK_CNT_COUNT);
369 }
370 
371 /**
372  * @brief Get the clock calibration done status
373  *
374  * Register|BitsName
375  * --------|--------
376  * HS_CLK_STAT | READY
377  *
378  * @retval 0x0 ~ 0x1.
379  */
380 __STATIC_INLINE uint32_t ll_hs_clk_cal_is_done(void)
381 {
382  return (READ_BITS(CLK_CAL->HS_CLK_STAT, CLK_CAL_HS_CLK_STAT_DONE) == CLK_CAL_HS_CLK_STAT_DONE);
383 }
384 
385 /**
386  * @brief Get the clock calibration overflow status
387  *
388  * Register|BitsName
389  * --------|--------
390  * SL_CLK_STAT | OVERFLOW
391  *
392  * @retval 0x0 ~ 0x1.
393  */
394 __STATIC_INLINE uint32_t ll_hs_clk_cal_is_overflow(void)
395 {
396  return (READ_BITS(CLK_CAL->HS_CLK_STAT, CLK_CAL_HS_CLK_STAT_OVER) == CLK_CAL_HS_CLK_STAT_OVER);
397 }
398 
399 /**
400  * @brief Get the fast clock calibration count value
401  *
402  * Register|BitsName
403  * --------|--------
404  * HS_CLK_CNT0 | CNT0
405  *
406  * @retval 0x0 ~ 0xFFFFFF.
407  */
408 __STATIC_INLINE uint32_t ll_hs_clk_cal_get_fast_count(void)
409 {
410  return READ_BITS(CLK_CAL->HS_CLK_CNT0, CLK_CAL_HS_CLK_CNT0_VAL);
411 }
412 
413 /**
414  * @brief Get the slow clock calibration current count value
415  *
416  * Register|BitsName
417  * --------|--------
418  * HS_CLK_CNT1 | CNT1
419  *
420  * @retval 0x0 ~ 0xFFF.
421  */
422 __STATIC_INLINE uint32_t ll_hs_clk_cal_get_slow_cur_count(void)
423 {
424  return READ_BITS(CLK_CAL->HS_CLK_CNT1, CLK_CAL_HS_CLK_CNT1_VAL);
425 }
426 
427 /**
428  * @brief Set the clock calibration clock source
429  *
430  * Register|BitsName
431  * --------|--------
432  * HS_CLK_CNT | CLK_SOURCE
433  * @param clk_source: 0x0 ~ 0x2.
434  */
435 __STATIC_INLINE void ll_hs_clk_cal_set_clk_source(uint32_t clk_source)
436 {
437  MODIFY_REG(CLK_CAL->HS_CLK_SEL, CLK_CAL_HS_CLK_SEL_VAL, clk_source);
438 }
439 
440 /**
441  * @brief Get the clock calibration clock source
442  *
443  * Register|BitsName
444  * --------|--------
445  * HS_CLK_CNT | CLK_SOURCE
446  *
447  * @retval 0x0 ~ 0x2.
448  */
449 __STATIC_INLINE uint32_t ll_hs_clk_cal_get_clk_source(void)
450 {
451  return READ_BITS(CLK_CAL->HS_CLK_SEL, CLK_CAL_HS_CLK_SEL_VAL);
452 }
453 
454 
455 /**
456  * @brief Enable the clock calibration done interrupt
457  *
458  * Register|BitsName
459  * --------|--------
460  * HS_CLK_INT_EN | DONE
461  *
462  */
463 __STATIC_INLINE void ll_hs_clk_cal_enable_done_it(void)
464 {
465  SET_BITS(CLK_CAL->HS_CLK_INT_EN, CLK_CAL_HS_CLK_INT_EN_DONE);
466 }
467 
468 /**
469  * @brief Disable the clock calibration done interrupt
470  *
471  * Register|BitsName
472  * --------|--------
473  * HS_CLK_INT_EN | DONE
474  *
475  */
476 __STATIC_INLINE void ll_hs_clk_cal_disable_done_it(void)
477 {
478  CLEAR_BITS(CLK_CAL->HS_CLK_INT_EN, CLK_CAL_HS_CLK_INT_EN_DONE);
479 }
480 
481 /**
482  * @brief Enable the clock calibration overflow interrupt
483  *
484  * Register|BitsName
485  * --------|--------
486  * HS_CLK_INT_EN | OVER
487  *
488  */
489 __STATIC_INLINE void ll_hs_clk_cal_enable_over_it(void)
490 {
491  SET_BITS(CLK_CAL->HS_CLK_INT_EN, CLK_CAL_HS_CLK_INT_EN_OVER);
492 }
493 
494 /**
495  * @brief Disable the clock calibration overflow interrupt
496  *
497  * Register|BitsName
498  * --------|--------
499  * HS_CLK_INT_EN | OVER
500  *
501  */
502 __STATIC_INLINE void ll_hs_clk_cal_disable_over_it(void)
503 {
504  CLEAR_BITS(CLK_CAL->HS_CLK_INT_EN, CLK_CAL_HS_CLK_INT_EN_OVER);
505 }
506 
507 /**
508  * @brief Clear the clock calibration done interrupt
509  *
510  * Register|BitsName
511  * --------|--------
512  * HS_CLK_INT_EN | DONE
513  *
514  */
515 __STATIC_INLINE void ll_hs_clk_cal_clear_done_it(void)
516 {
517  SET_BITS(CLK_CAL->HS_CLK_INT_CLR, CLK_CAL_HS_CLK_INT_CLR_DONE);
518 }
519 
520 /**
521  * @brief Clear the clock calibration over interrupt
522  *
523  * Register|BitsName
524  * --------|--------
525  * HS_CLK_INT_EN | DONE
526  *
527  */
528 __STATIC_INLINE void ll_hs_clk_cal_clear_over_it(void)
529 {
530  SET_BITS(CLK_CAL->HS_CLK_INT_CLR, CLK_CAL_HS_CLK_INT_CLR_OVER);
531 }
532 
533 /** @} */
534 
535 #ifdef __cplusplus
536 }
537 #endif
538 
539 #endif
540 /** @} */
541 
542 /** @} */
543 
544 /** @} */
ll_sl_clk_cal_clear_over_it
__STATIC_INLINE void ll_sl_clk_cal_clear_over_it(void)
Clear the clock calibration over interrupt.
Definition: ll_clk_cal.h:300
ll_sl_clk_cal_enable_done_it
__STATIC_INLINE void ll_sl_clk_cal_enable_done_it(void)
Enable the clock calibration done interrupt.
Definition: ll_clk_cal.h:235
ll_hs_clk_cal_clear_over_it
__STATIC_INLINE void ll_hs_clk_cal_clear_over_it(void)
Clear the clock calibration over interrupt.
Definition: ll_clk_cal.h:528
ll_sl_clk_cal_get_slow_cur_count
__STATIC_INLINE uint32_t ll_sl_clk_cal_get_slow_cur_count(void)
Get the slow clock calibration current count value.
Definition: ll_clk_cal.h:194
ll_sl_clk_cal_is_done
__STATIC_INLINE uint32_t ll_sl_clk_cal_is_done(void)
Get the clock calibration done status.
Definition: ll_clk_cal.h:152
ll_hs_clk_cal_enable_done_it
__STATIC_INLINE void ll_hs_clk_cal_enable_done_it(void)
Enable the clock calibration done interrupt.
Definition: ll_clk_cal.h:463
hal.h
This file contains all the functions prototypes for the HAL module driver.
ll_sl_clk_cal_disable_over_it
__STATIC_INLINE void ll_sl_clk_cal_disable_over_it(void)
Disable the clock calibration overflow interrupt.
Definition: ll_clk_cal.h:274
ll_sl_clk_cal_set_slow_count
__STATIC_INLINE void ll_sl_clk_cal_set_slow_count(uint32_t count)
Set the slow clock calibration count.
Definition: ll_clk_cal.h:124
ll_sl_clk_cal_disable_done_it
__STATIC_INLINE void ll_sl_clk_cal_disable_done_it(void)
Disable the clock calibration done interrupt.
Definition: ll_clk_cal.h:248
ll_hs_clk_cal_enable
__STATIC_INLINE void ll_hs_clk_cal_enable(void)
Enable the clock calibration block.
Definition: ll_clk_cal.h:312
ll_hs_clk_cal_set_clk_source
__STATIC_INLINE void ll_hs_clk_cal_set_clk_source(uint32_t clk_source)
Set the clock calibration clock source.
Definition: ll_clk_cal.h:435
ll_hs_clk_cal_is_overflow
__STATIC_INLINE uint32_t ll_hs_clk_cal_is_overflow(void)
Get the clock calibration overflow status.
Definition: ll_clk_cal.h:394
ll_hs_clk_cal_get_fast_count
__STATIC_INLINE uint32_t ll_hs_clk_cal_get_fast_count(void)
Get the fast clock calibration count value.
Definition: ll_clk_cal.h:408
ll_sl_clk_cal_enable
__STATIC_INLINE void ll_sl_clk_cal_enable(void)
Enable the clock calibration block.
Definition: ll_clk_cal.h:85
ll_sl_clk_cal_enable_over_it
__STATIC_INLINE void ll_sl_clk_cal_enable_over_it(void)
Enable the clock calibration overflow interrupt.
Definition: ll_clk_cal.h:261
ll_hs_clk_cal_disable
__STATIC_INLINE void ll_hs_clk_cal_disable(void)
Disable the clock calibration block.
Definition: ll_clk_cal.h:325
ll_hs_clk_cal_is_enable
__STATIC_INLINE uint32_t ll_hs_clk_cal_is_enable(void)
Is the clock calibration block.
Definition: ll_clk_cal.h:339
ll_hs_clk_cal_disable_done_it
__STATIC_INLINE void ll_hs_clk_cal_disable_done_it(void)
Disable the clock calibration done interrupt.
Definition: ll_clk_cal.h:476
ll_hs_clk_cal_enable_over_it
__STATIC_INLINE void ll_hs_clk_cal_enable_over_it(void)
Enable the clock calibration overflow interrupt.
Definition: ll_clk_cal.h:489
ll_hs_clk_cal_clear_done_it
__STATIC_INLINE void ll_hs_clk_cal_clear_done_it(void)
Clear the clock calibration done interrupt.
Definition: ll_clk_cal.h:515
ll_sl_clk_cal_is_overflow
__STATIC_INLINE uint32_t ll_sl_clk_cal_is_overflow(void)
Get the clock calibration overflow status.
Definition: ll_clk_cal.h:166
ll_sl_clk_cal_get_slow_count
__STATIC_INLINE uint32_t ll_sl_clk_cal_get_slow_count(void)
Get the slow clock calibration setting count.
Definition: ll_clk_cal.h:138
ll_sl_clk_cal_set_clk_source
__STATIC_INLINE void ll_sl_clk_cal_set_clk_source(uint32_t clk_source)
Set the clock calibration clock source.
Definition: ll_clk_cal.h:207
ll_hs_clk_cal_get_slow_count
__STATIC_INLINE uint32_t ll_hs_clk_cal_get_slow_count(void)
Get the slow clock setting count.
Definition: ll_clk_cal.h:366
ll_hs_clk_cal_is_done
__STATIC_INLINE uint32_t ll_hs_clk_cal_is_done(void)
Get the clock calibration done status.
Definition: ll_clk_cal.h:380
ll_hs_clk_cal_get_slow_cur_count
__STATIC_INLINE uint32_t ll_hs_clk_cal_get_slow_cur_count(void)
Get the slow clock calibration current count value.
Definition: ll_clk_cal.h:422
ll_hs_clk_cal_get_clk_source
__STATIC_INLINE uint32_t ll_hs_clk_cal_get_clk_source(void)
Get the clock calibration clock source.
Definition: ll_clk_cal.h:449
ll_hs_clk_cal_disable_over_it
__STATIC_INLINE void ll_hs_clk_cal_disable_over_it(void)
Disable the clock calibration overflow interrupt.
Definition: ll_clk_cal.h:502
ll_sl_clk_cal_clear_done_it
__STATIC_INLINE void ll_sl_clk_cal_clear_done_it(void)
Clear the clock calibration done interrupt.
Definition: ll_clk_cal.h:287
ll_hs_clk_cal_set_slow_count
__STATIC_INLINE void ll_hs_clk_cal_set_slow_count(uint32_t count)
Set the slow clock calibration count.
Definition: ll_clk_cal.h:352
ll_sl_clk_cal_get_clk_source
__STATIC_INLINE uint32_t ll_sl_clk_cal_get_clk_source(void)
Get the clock calibration clock source.
Definition: ll_clk_cal.h:221
ll_sl_clk_cal_get_fast_count
__STATIC_INLINE uint32_t ll_sl_clk_cal_get_fast_count(void)
Get the fast clock calibration count value.
Definition: ll_clk_cal.h:180
ll_sl_clk_cal_is_enable
__STATIC_INLINE uint32_t ll_sl_clk_cal_is_enable(void)
Is the clock calibration block.
Definition: ll_clk_cal.h:111
ll_sl_clk_cal_disable
__STATIC_INLINE void ll_sl_clk_cal_disable(void)
Disable the clock calibration block.
Definition: ll_clk_cal.h:98