gr55xx_ll_clk_cal.h
Go to the documentation of this file.
1 /**
2  ****************************************************************************************
3  *
4  * @file gr55xx_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 __GR55XX_LL_CLK_CAL_H_
53 #define __GR55XX_LL_CLK_CAL_H_
54 
55 #ifdef __cplusplus
56 extern "C" {
57 #endif
58 
59 /* Includes ------------------------------------------------------------------*/
60 #include "gr55xx_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  * @brief Enable the clock calibration done interrupt
228  *
229  * Register|BitsName
230  * --------|--------
231  * SL_CLK_INT_EN | DONE
232  *
233  */
234 __STATIC_INLINE void ll_sl_clk_cal_enable_done_it(void)
235 {
236  SET_BITS(CLK_CAL->SL_CLK_INT_EN, CLK_CAL_SL_CLK_INT_EN_DONE);
237 }
238 
239 /**
240  * @brief Disable the clock calibration done interrupt
241  *
242  * Register|BitsName
243  * --------|--------
244  * SL_CLK_INT_EN | DONE
245  *
246  */
247 __STATIC_INLINE void ll_sl_clk_cal_disable_done_it(void)
248 {
249  CLEAR_BITS(CLK_CAL->SL_CLK_INT_EN, CLK_CAL_SL_CLK_INT_EN_DONE);
250 }
251 
252 /**
253  * @brief Enable the clock calibration overflow interrupt
254  *
255  * Register|BitsName
256  * --------|--------
257  * SL_CLK_INT_EN | OVER
258  *
259  */
260 __STATIC_INLINE void ll_sl_clk_cal_enable_over_it(void)
261 {
262  SET_BITS(CLK_CAL->SL_CLK_INT_EN, CLK_CAL_SL_CLK_INT_EN_OVER);
263 }
264 
265 /**
266  * @brief Disable the clock calibration overflow interrupt
267  *
268  * Register|BitsName
269  * --------|--------
270  * SL_CLK_INT_EN | OVER
271  *
272  */
273 __STATIC_INLINE void ll_sl_clk_cal_disable_over_it(void)
274 {
275  CLEAR_BITS(CLK_CAL->SL_CLK_INT_EN, CLK_CAL_SL_CLK_INT_EN_OVER);
276 }
277 
278 /**
279  * @brief Clear the clock calibration done interrupt
280  *
281  * Register|BitsName
282  * --------|--------
283  * SL_CLK_INT_EN | DONE
284  *
285  */
286 __STATIC_INLINE void ll_sl_clk_cal_clear_done_it(void)
287 {
288  SET_BITS(CLK_CAL->SL_CLK_INT_CLR, CLK_CAL_SL_CLK_INT_CLR_DONE);
289 }
290 
291 /**
292  * @brief Clear the clock calibration over interrupt
293  *
294  * Register|BitsName
295  * --------|--------
296  * SL_CLK_INT_EN | DONE
297  *
298  */
299 __STATIC_INLINE void ll_sl_clk_cal_clear_over_it(void)
300 {
301  SET_BITS(CLK_CAL->SL_CLK_INT_CLR, CLK_CAL_SL_CLK_INT_CLR_OVER);
302 }
303 
304 /**
305  * @brief Enable the clock calibration block
306  *
307  * Register|BitsName
308  * --------|--------
309  * HS_CLK_CTRL | EN
310  */
311 __STATIC_INLINE void ll_hs_clk_cal_enable(void)
312 {
313  SET_BITS(CLK_CAL->HS_CLK_CTRL, CLK_CAL_HS_CLK_CTRL_EN);
314 }
315 
316 /**
317  * @brief Disable the clock calibration block
318  *
319  * Register|BitsName
320  * --------|--------
321  * HS_CLK_CTRL | EN
322  *
323  */
324 __STATIC_INLINE void ll_hs_clk_cal_disable(void)
325 {
326  CLEAR_BITS(CLK_CAL->HS_CLK_CTRL, CLK_CAL_HS_CLK_CTRL_EN);
327 }
328 
329 /**
330  * @brief Is the clock calibration block
331  *
332  * Register|BitsName
333  * --------|--------
334  * HS_CLK_CTRL | EN
335  *
336  */
337 
338 __STATIC_INLINE uint32_t ll_hs_clk_cal_is_enable(void)
339 {
340  return (READ_BITS(CLK_CAL->HS_CLK_CTRL, CLK_CAL_HS_CLK_CTRL_EN) == CLK_CAL_HS_CLK_CTRL_EN);
341 }
342 
343 /**
344  * @brief Set the slow clock calibration count
345  *
346  * Register|BitsName
347  * --------|--------
348  * HS_CLK_CNT | CNT_COUNT
349  * @param count: 0x0 ~ 0xFFF.
350  */
351 __STATIC_INLINE void ll_hs_clk_cal_set_slow_count(uint32_t count)
352 {
353  MODIFY_REG(CLK_CAL->HS_CLK_CNT, CLK_CAL_HS_CLK_CNT_COUNT, (count << CLK_CAL_HS_CLK_CNT_COUNT_POS));
354 }
355 
356 /**
357  * @brief Get the slow clock setting count
358  *
359  * Register|BitsName
360  * --------|--------
361  * HS_CLK_CNT | CNT_COUNT
362  *
363  * @retval 0x0 ~ 0xFFF.
364  */
365 __STATIC_INLINE uint32_t ll_hs_clk_cal_get_slow_count(void)
366 {
367  return READ_BITS(CLK_CAL->HS_CLK_CNT, CLK_CAL_HS_CLK_CNT_COUNT);
368 }
369 
370 /**
371  * @brief Get the clock calibration done status
372  *
373  * Register|BitsName
374  * --------|--------
375  * HS_CLK_STAT | READY
376  *
377  * @retval 0x0 ~ 0x1.
378  */
379 __STATIC_INLINE uint32_t ll_hs_clk_cal_is_done(void)
380 {
381  return (READ_BITS(CLK_CAL->HS_CLK_STAT, CLK_CAL_HS_CLK_STAT_DONE) == CLK_CAL_HS_CLK_STAT_DONE);
382 }
383 
384 /**
385  * @brief Get the clock calibration overflow status
386  *
387  * Register|BitsName
388  * --------|--------
389  * SL_CLK_STAT | OVERFLOW
390  *
391  * @retval 0x0 ~ 0x1.
392  */
393 __STATIC_INLINE uint32_t ll_hs_clk_cal_is_overflow(void)
394 {
395  return (READ_BITS(CLK_CAL->HS_CLK_STAT, CLK_CAL_HS_CLK_STAT_OVER) == CLK_CAL_HS_CLK_STAT_OVER);
396 }
397 
398 /**
399  * @brief Get the fast clock calibration count value
400  *
401  * Register|BitsName
402  * --------|--------
403  * HS_CLK_CNT0 | CNT0
404  *
405  * @retval 0x0 ~ 0xFFFFFF.
406  */
407 __STATIC_INLINE uint32_t ll_hs_clk_cal_get_fast_count(void)
408 {
409  return READ_BITS(CLK_CAL->HS_CLK_CNT0, CLK_CAL_HS_CLK_CNT0_VAL);
410 }
411 
412 /**
413  * @brief Get the slow clock calibration current count value
414  *
415  * Register|BitsName
416  * --------|--------
417  * HS_CLK_CNT1 | CNT1
418  *
419  * @retval 0x0 ~ 0xFFF.
420  */
421 __STATIC_INLINE uint32_t ll_hs_clk_cal_get_slow_cur_count(void)
422 {
423  return READ_BITS(CLK_CAL->HS_CLK_CNT1, CLK_CAL_HS_CLK_CNT1_VAL);
424 }
425 
426 /**
427  * @brief Set the clock calibration clock source
428  *
429  * Register|BitsName
430  * --------|--------
431  * HS_CLK_CNT | CLK_SOURCE
432  * @param clk_source: 0x0 ~ 0x2.
433  */
434 __STATIC_INLINE void ll_hs_clk_cal_set_clk_source(uint32_t clk_source)
435 {
436  MODIFY_REG(CLK_CAL->HS_CLK_SEL, CLK_CAL_HS_CLK_SEL_VAL, clk_source);
437 }
438 
439 /**
440  * @brief Get the clock calibration clock source
441  *
442  * Register|BitsName
443  * --------|--------
444  * HS_CLK_CNT | CLK_SOURCE
445  *
446  * @retval 0x0 ~ 0x2.
447  */
448 __STATIC_INLINE uint32_t ll_hs_clk_cal_get_clk_source(void)
449 {
450  return READ_BITS(CLK_CAL->HS_CLK_SEL, CLK_CAL_HS_CLK_SEL_VAL);
451 }
452 
453 /**
454  * @brief Enable the clock calibration done interrupt
455  *
456  * Register|BitsName
457  * --------|--------
458  * HS_CLK_INT_EN | DONE
459  *
460  */
461 __STATIC_INLINE void ll_hs_clk_cal_enable_done_it(void)
462 {
463  SET_BITS(CLK_CAL->HS_CLK_INT_EN, CLK_CAL_HS_CLK_INT_EN_DONE);
464 }
465 
466 /**
467  * @brief Disable the clock calibration done interrupt
468  *
469  * Register|BitsName
470  * --------|--------
471  * HS_CLK_INT_EN | DONE
472  *
473  */
474 __STATIC_INLINE void ll_hs_clk_cal_disable_done_it(void)
475 {
476  CLEAR_BITS(CLK_CAL->HS_CLK_INT_EN, CLK_CAL_HS_CLK_INT_EN_DONE);
477 }
478 
479 /**
480  * @brief Enable the clock calibration overflow interrupt
481  *
482  * Register|BitsName
483  * --------|--------
484  * HS_CLK_INT_EN | OVER
485  *
486  */
487 __STATIC_INLINE void ll_hs_clk_cal_enable_over_it(void)
488 {
489  SET_BITS(CLK_CAL->HS_CLK_INT_EN, CLK_CAL_HS_CLK_INT_EN_OVER);
490 }
491 
492 /**
493  * @brief Disable the clock calibration overflow interrupt
494  *
495  * Register|BitsName
496  * --------|--------
497  * HS_CLK_INT_EN | OVER
498  *
499  */
500 __STATIC_INLINE void ll_hs_clk_cal_disable_over_it(void)
501 {
502  CLEAR_BITS(CLK_CAL->HS_CLK_INT_EN, CLK_CAL_HS_CLK_INT_EN_OVER);
503 }
504 
505 /**
506  * @brief Clear the clock calibration done interrupt
507  *
508  * Register|BitsName
509  * --------|--------
510  * HS_CLK_INT_EN | DONE
511  *
512  */
513 __STATIC_INLINE void ll_hs_clk_cal_clear_done_it(void)
514 {
515  SET_BITS(CLK_CAL->HS_CLK_INT_CLR, CLK_CAL_HS_CLK_INT_CLR_DONE);
516 }
517 
518 /**
519  * @brief Clear the clock calibration over interrupt
520  *
521  * Register|BitsName
522  * --------|--------
523  * HS_CLK_INT_EN | DONE
524  *
525  */
526 __STATIC_INLINE void ll_hs_clk_cal_clear_over_it(void)
527 {
528  SET_BITS(CLK_CAL->HS_CLK_INT_CLR, CLK_CAL_HS_CLK_INT_CLR_OVER);
529 }
530 /** @} */
531 
532 #endif
533 /** @} */
534 
535 /** @} */
536 
537 /** @} */
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: gr55xx_ll_clk_cal.h:299
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: gr55xx_ll_clk_cal.h:234
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: gr55xx_ll_clk_cal.h:526
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: gr55xx_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: gr55xx_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: gr55xx_ll_clk_cal.h:461
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: gr55xx_ll_clk_cal.h:273
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: gr55xx_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: gr55xx_ll_clk_cal.h:247
ll_hs_clk_cal_enable
__STATIC_INLINE void ll_hs_clk_cal_enable(void)
Enable the clock calibration block.
Definition: gr55xx_ll_clk_cal.h:311
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: gr55xx_ll_clk_cal.h:434
ll_hs_clk_cal_is_overflow
__STATIC_INLINE uint32_t ll_hs_clk_cal_is_overflow(void)
Get the clock calibration overflow status.
Definition: gr55xx_ll_clk_cal.h:393
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: gr55xx_ll_clk_cal.h:407
ll_sl_clk_cal_enable
__STATIC_INLINE void ll_sl_clk_cal_enable(void)
Enable the clock calibration block.
Definition: gr55xx_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: gr55xx_ll_clk_cal.h:260
gr55xx_hal.h
This file contains all the functions prototypes for the HAL module driver.
ll_hs_clk_cal_disable
__STATIC_INLINE void ll_hs_clk_cal_disable(void)
Disable the clock calibration block.
Definition: gr55xx_ll_clk_cal.h:324
ll_hs_clk_cal_is_enable
__STATIC_INLINE uint32_t ll_hs_clk_cal_is_enable(void)
Is the clock calibration block.
Definition: gr55xx_ll_clk_cal.h:338
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: gr55xx_ll_clk_cal.h:474
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: gr55xx_ll_clk_cal.h:487
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: gr55xx_ll_clk_cal.h:513
ll_sl_clk_cal_is_overflow
__STATIC_INLINE uint32_t ll_sl_clk_cal_is_overflow(void)
Get the clock calibration overflow status.
Definition: gr55xx_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: gr55xx_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: gr55xx_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: gr55xx_ll_clk_cal.h:365
ll_hs_clk_cal_is_done
__STATIC_INLINE uint32_t ll_hs_clk_cal_is_done(void)
Get the clock calibration done status.
Definition: gr55xx_ll_clk_cal.h:379
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: gr55xx_ll_clk_cal.h:421
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: gr55xx_ll_clk_cal.h:448
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: gr55xx_ll_clk_cal.h:500
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: gr55xx_ll_clk_cal.h:286
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: gr55xx_ll_clk_cal.h:351
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: gr55xx_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: gr55xx_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: gr55xx_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: gr55xx_ll_clk_cal.h:98