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