VSF Documented
rtc_template.inc
Go to the documentation of this file.
1/*****************************************************************************
2 * Copyright(C)2009-2022 by VSF Team *
3 * *
4 * Licensed under the Apache License, Version 2.0 (the "License"); *
5 * you may not use this file except in compliance with the License. *
6 * You may obtain a copy of the License at *
7 * *
8 * http://www.apache.org/licenses/LICENSE-2.0 *
9 * *
10 * Unless required by applicable law or agreed to in writing, software *
11 * distributed under the License is distributed on an "AS IS" BASIS, *
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
13 * See the License for the specific language governing permissions and *
14 * limitations under the License. *
15 * *
16 ****************************************************************************/
17
18#if VSF_HAL_USE_RTC == ENABLED
19
20/*============================ INCLUDES ======================================*/
21/*============================ MACROS ========================================*/
22
23#if VSF_RTC_CFG_GET_API_TEMPLATE == ENABLED && VSF_RTC_CFG_GET_TIME_API_TEMPLATE == ENABLED
24# error "VSF_RTC_CFG_GET_API_TEMPLATE and VSF_RTC_CFG_GET_TIME_API_TEMPLATE Only one can be defined at a time"
25#endif
26
27#if VSF_RTC_CFG_SET_API_TEMPLATE == ENABLED && VSF_RTC_CFG_SET_TIME_API_TEMPLATE == ENABLED
28# error "VSF_RTC_CFG_SET_API_TEMPLATE and VSF_RTC_CFG_SET_TIME_API_TEMPLATE Only one can be defined at a time"
29#endif
30
31#ifndef VSF_RTC_CFG_REIMPLEMENT_API_GET_CONFIGURATION
32# define VSF_RTC_CFG_REIMPLEMENT_API_GET_CONFIGURATION DISABLED
33#endif
34
35#ifndef VSF_RTC_CFG_REIMPLEMENT_API_CAPABILITY
36# define VSF_RTC_CFG_REIMPLEMENT_API_CAPABILITY DISABLED
37#endif
38
39#ifndef VSF_RTC_CFG_REIMPLEMENT_API_CTRL
40# define VSF_RTC_CFG_REIMPLEMENT_API_CTRL DISABLED
41#endif
42
43#ifdef VSF_RTC_CFG_IMP_REMAP_PREFIX
44# undef VSF_RTC_CFG_REIMPLEMENT_API_CAPABILITY
45# define VSF_RTC_CFG_REIMPLEMENT_API_CAPABILITY ENABLED
46# undef VSF_RTC_CFG_REIMPLEMENT_API_GET_CONFIGURATION
47# define VSF_RTC_CFG_REIMPLEMENT_API_GET_CONFIGURATION ENABLED
48# undef VSF_RTC_CFG_REIMPLEMENT_API_CTRL
49# define VSF_RTC_CFG_REIMPLEMENT_API_CTRL ENABLED
50#endif
51
52#if VSF_RTC_CFG_REIMPLEMENT_API_CAPABILITY == DISABLED
53# ifndef VSF_RTC_CFG_CAPABILITY_T_IRQ_MASK
54# define VSF_RTC_CFG_CAPABILITY_T_IRQ_MASK VSF_RTC_IRQ_ALL_BITS_MASK
55# endif
56#endif
57
58#if defined(VSF_RTC_CFG_IMP_RENAME_DEVICE_PREFIX) && (VSF_RTC_CFG_IMP_RENAME_DEVICE_PREFIX == ENABLED)
59# define vsf_real_rtc_t VSF_MCONNECT(VSF_RTC_CFG_IMP_DEVICE_PREFIX, _t)
60# define vsf_real_rtc_capability VSF_MCONNECT(VSF_RTC_CFG_IMP_DEVICE_PREFIX, _capability)
61# define vsf_real_rtc_ctrl VSF_MCONNECT(VSF_RTC_CFG_IMP_DEVICE_PREFIX, _ctrl)
62# define vsf_real_rtc_get_configuration VSF_MCONNECT(VSF_RTC_CFG_IMP_DEVICE_PREFIX, _get_configuration)
63# define vsf_real_rtc_get VSF_MCONNECT(VSF_RTC_CFG_IMP_DEVICE_PREFIX, _get)
64# define vsf_real_rtc_set VSF_MCONNECT(VSF_RTC_CFG_IMP_DEVICE_PREFIX, _set)
65# define vsf_real_rtc_get_time VSF_MCONNECT(VSF_RTC_CFG_IMP_DEVICE_PREFIX, _get_time)
66# define vsf_real_rtc_set_time VSF_MCONNECT(VSF_RTC_CFG_IMP_DEVICE_PREFIX, _set_time)
67#else
68# define vsf_real_rtc_t VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_t)
69# define vsf_real_rtc_capability VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_capability)
70# define vsf_real_rtc_ctrl VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_ctrl)
71# define vsf_real_rtc_get_configuration VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_get_configuration)
72# define vsf_real_rtc_get VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_get)
73# define vsf_real_rtc_set VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_set)
74# define vsf_real_rtc_get_time VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_get_time)
75# define vsf_real_rtc_set_time VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_set_time)
76#endif
77
78/*============================ MACROFIED FUNCTIONS ===========================*/
79/*============================ TYPES =========================================*/
80/*============================ GLOBAL VARIABLES ==============================*/
81/*============================ LOCAL VARIABLES ===============================*/
82/*============================ PROTOTYPES ====================================*/
83/*============================ IMPLEMENTATION ================================*/
84
85#if VSF_RTC_CFG_GET_API_TEMPLATE == ENABLED
86vsf_err_t vsf_real_rtc_get(vsf_real_rtc_t *rtc_ptr, vsf_rtc_tm_t *rtc_tm)
87{
88 VSF_HAL_ASSERT(rtc_ptr != NULL);
89 VSF_HAL_ASSERT(rtc_tm != NULL);
90
91 time_t second, milliseconds;
92 vsf_err_t result = vsf_real_rtc_get_time(rtc_ptr, &second, &milliseconds);
93 if (result != VSF_ERR_NONE) {
94 return result;
95 }
96
97 struct tm *t = gmtime(&second);
98 if (t == NULL) {
99 return VSF_ERR_FAIL;
100 }
101
102 rtc_tm->tm_sec = t->tm_sec;
103 rtc_tm->tm_min = t->tm_min;
104 rtc_tm->tm_hour = t->tm_hour;
105 rtc_tm->tm_mday = t->tm_mday;
106 rtc_tm->tm_wday = t->tm_wday + 1;
107 rtc_tm->tm_mon = t->tm_mon + 1;
108 rtc_tm->tm_year = t->tm_year + 1900;
109 rtc_tm->tm_ms = milliseconds;
110
111 return VSF_ERR_NONE;
112}
113#endif
114
115#if VSF_RTC_CFG_SET_API_TEMPLATE == ENABLED
116vsf_err_t vsf_real_rtc_set(vsf_real_rtc_t *rtc_ptr, const vsf_rtc_tm_t *rtc_tm)
117{
118 VSF_HAL_ASSERT(rtc_ptr != NULL);
119 VSF_HAL_ASSERT(rtc_tm != NULL);
120
121 struct tm t = {
122 .tm_sec = rtc_tm->tm_sec,
123 .tm_min = rtc_tm->tm_min,
124 .tm_hour = rtc_tm->tm_hour,
125 .tm_mday = rtc_tm->tm_mday,
126 .tm_mon = rtc_tm->tm_mon - 1,
127 .tm_year = rtc_tm->tm_year - 1900,
128 };
129
130 time_t second = mktime(&t);
131 return vsf_real_rtc_set_time(rtc_ptr, second, rtc_tm->tm_ms);
132}
133#endif
134
135#if VSF_RTC_CFG_REIMPLEMENT_API_CTRL == DISABLED
136vsf_err_t vsf_real_rtc_ctrl(vsf_real_rtc_t *rtc_ptr, vsf_rtc_ctrl_t ctrl, void *param)
137{
138 VSF_HAL_ASSERT(NULL != rtc_ptr);
139
140 // Default implementation: not supported, trigger assertion
141 VSF_HAL_ASSERT(0);
142
143 return VSF_ERR_NOT_SUPPORT;
144}
145#endif
146
147#if VSF_RTC_CFG_GET_TIME_API_TEMPLATE == ENABLED
148vsf_err_t vsf_real_rtc_get_time(vsf_real_rtc_t *rtc_ptr, vsf_rtc_time_t *second_ptr, vsf_rtc_time_t *milliseconds_ptr)
149{
150 VSF_HAL_ASSERT(rtc_ptr != NULL);
151 VSF_HAL_ASSERT((second_ptr != NULL) || (milliseconds_ptr != NULL));
152
153 vsf_rtc_tm_t rtc_tm;
154 vsf_err_t result = vsf_real_rtc_get(rtc_ptr, &rtc_tm);
155 if (result != VSF_ERR_NONE) {
156 return result;
157 }
158
159 if (second_ptr != NULL) {
160 struct tm t = {
161 .tm_sec = rtc_tm.tm_sec,
162 .tm_min = rtc_tm.tm_min,
163 .tm_hour = rtc_tm.tm_hour,
164 .tm_mday = rtc_tm.tm_mday,
165 .tm_mon = rtc_tm.tm_mon - 1,
166 .tm_year = rtc_tm.tm_year - 1900,
167 };
168 *second_ptr = mktime(&t);
169 }
170
171 if (milliseconds_ptr != NULL) {
172 *milliseconds_ptr = rtc_tm.tm_ms;
173 }
174
175 return VSF_ERR_NONE;
176}
177#endif
178
179#if VSF_RTC_CFG_SET_TIME_API_TEMPLATE == ENABLED
180vsf_err_t vsf_real_rtc_set_time(vsf_real_rtc_t *rtc_ptr, vsf_rtc_time_t second, vsf_rtc_time_t milliseconds)
181{
182 VSF_HAL_ASSERT(rtc_ptr != NULL);
183
184 struct tm *t = gmtime((const time_t *)&second);
185 if (NULL == t) {
186 return VSF_ERR_FAIL;
187 }
188
189 vsf_rtc_tm_t rtc_tm = {
190 .tm_sec = t->tm_sec,
191 .tm_min = t->tm_min,
192 .tm_hour = t->tm_hour,
193 .tm_mday = t->tm_mday,
194 .tm_mon = t->tm_mon + 1,
195 .tm_year = t->tm_year + 1900,
196 .tm_ms = milliseconds,
197 };
198
199 return vsf_real_rtc_set(rtc_ptr, &rtc_tm);
200}
201#endif
202
203#if VSF_RTC_CFG_REIMPLEMENT_API_CAPABILITY == DISABLED
204vsf_rtc_capability_t vsf_real_rtc_capability(vsf_real_rtc_t *rtc_ptr)
205{
206 vsf_rtc_capability_t rtc_capability = {
207 .irq_mask = VSF_RTC_CFG_CAPABILITY_IRQ_MASK,
208 };
209
210 return rtc_capability;
211}
212#endif
213
214#if VSF_RTC_CFG_REIMPLEMENT_API_GET_CONFIGURATION == DISABLED
215vsf_err_t vsf_real_rtc_get_configuration(vsf_real_rtc_t *rtc_ptr, vsf_rtc_cfg_t *cfg_ptr)
216{
217 VSF_HAL_ASSERT(NULL != rtc_ptr);
218 VSF_HAL_ASSERT(NULL != cfg_ptr);
219 VSF_HAL_ASSERT(0); // Default implementation: not supported, trigger assertion
220 return VSF_ERR_NOT_SUPPORT;
221}
222#endif
223
224/*============================ MACROS ========================================*/
225
226#undef VSF_RTC_CFG_REIMPLEMENT_TYPE_CAPABILITY
227#undef VSF_RTC_CFG_REIMPLEMENT_TYPE_CFG
228#undef VSF_RTC_CFG_REIMPLEMENT_TYPE_IRQ_MASK
229#undef VSF_RTC_CFG_REIMPLEMENT_TYPE_CTRL
230#undef VSF_RTC_CFG_REIMPLEMENT_API_CAPABILITY
231#undef VSF_RTC_CFG_REIMPLEMENT_API_CTRL
232#undef VSF_RTC_CFG_REIMPLEMENT_API_GET_CONFIGURATION
233#undef VSF_RTC_CFG_CAPABILITY_T_IRQ_MASK
234#undef vsf_real_rtc_t
235#undef vsf_real_rtc_capability
236#undef vsf_real_rtc_ctrl
237#undef vsf_real_rtc_get_configuration
238#undef vsf_real_rtc_get
239#undef vsf_real_rtc_set
240#undef vsf_real_rtc_get_time
241#undef vsf_real_rtc_set_time
242
243/*============================ MACROS ========================================*/
244
245#ifdef VSF_RTC_CFG_IMP_REMAP_PREFIX
246
247# define vsf_imp_rtc_t VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_t)
248# define vsf_imp_rtc_init VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_init)
249# define vsf_imp_rtc_enable VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_enable)
250# define vsf_imp_rtc_disable VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_disable)
251# define vsf_imp_rtc_capability VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_capability)
252# define vsf_imp_rtc_get VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_get)
253# define vsf_imp_rtc_set VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_set)
254# define vsf_imp_rtc_get_time VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_get_time)
255# define vsf_imp_rtc_set_time VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_set_time)
256# define vsf_imp_rtc_get_configuration VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_get_configuration)
257# define vsf_imp_rtc_ctrl VSF_MCONNECT(VSF_RTC_CFG_IMP_PREFIX, _rtc_ctrl)
258
259# define vsf_remap_rtc_t VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_t)
260# define vsf_remap_rtc_init VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_init)
261# define vsf_remap_rtc_fini VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_fini)
262# define vsf_remap_rtc_enable VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_enable)
263# define vsf_remap_rtc_disable VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_disable)
264# define vsf_remap_rtc_capability VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_capability)
265# define vsf_remap_rtc_get VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_get)
266# define vsf_remap_rtc_set VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_set)
267# define vsf_remap_rtc_get_time VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_get_time)
268# define vsf_remap_rtc_set_time VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_set_time)
269# define vsf_remap_rtc_get_configuration VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_get_configuration)
270# define vsf_remap_rtc_ctrl VSF_MCONNECT(VSF_RTC_CFG_IMP_REMAP_PREFIX, _rtc_ctrl)
271
272# define VSF_RTC_CFG_IMP_REMAP_FUNCTIONS \
273 vsf_err_t vsf_imp_rtc_init(vsf_imp_rtc_t *rtc_ptr, vsf_rtc_cfg_t *cfg_ptr) \
274 { \
275 VSF_HAL_ASSERT(rtc_ptr != NULL); \
276 return vsf_remap_rtc_init(rtc_ptr, cfg_ptr); \
277 } \
278 void vsf_imp_rtc_fini(vsf_imp_rtc_t *rtc_ptr) \
279 { \
280 VSF_HAL_ASSERT(rtc_ptr != NULL); \
281 vsf_remap_rtc_fini(rtc_ptr); \
282 } \
283 fsm_rt_t vsf_imp_rtc_enable(vsf_imp_rtc_t *rtc_ptr) \
284 { \
285 VSF_HAL_ASSERT(rtc_ptr != NULL); \
286 return vsf_remap_rtc_enable(rtc_ptr); \
287 } \
288 fsm_rt_t vsf_imp_rtc_disable(vsf_imp_rtc_t *rtc_ptr) \
289 { \
290 VSF_HAL_ASSERT(rtc_ptr != NULL); \
291 return vsf_remap_rtc_disable(rtc_ptr); \
292 } \
293 vsf_err_t vsf_imp_rtc_get(vsf_imp_rtc_t *rtc_ptr, vsf_rtc_tm_t *rtc_tm) \
294 { \
295 VSF_HAL_ASSERT(rtc_ptr != NULL); \
296 return vsf_remap_rtc_get(rtc_ptr, rtc_tm); \
297 } \
298 vsf_err_t vsf_imp_rtc_set(vsf_imp_rtc_t *rtc_ptr, const vsf_rtc_tm_t *rtc_tm) \
299 { \
300 VSF_HAL_ASSERT(rtc_ptr != NULL); \
301 return vsf_remap_rtc_set(rtc_ptr, rtc_tm); \
302 } \
303 vsf_err_t vsf_imp_rtc_get_time(vsf_imp_rtc_t *rtc_ptr, vsf_rtc_time_t *second_ptr, \
304 vsf_rtc_time_t *millisecond_ptr) \
305 { \
306 VSF_HAL_ASSERT(rtc_ptr != NULL); \
307 return vsf_remap_rtc_get_time(rtc_ptr, second_ptr, millisecond_ptr); \
308 } \
309 vsf_err_t vsf_imp_rtc_set_time(vsf_imp_rtc_t *rtc_ptr, vsf_rtc_time_t second, \
310 vsf_rtc_time_t millisecond) \
311 { \
312 VSF_HAL_ASSERT(rtc_ptr != NULL); \
313 return vsf_remap_rtc_set_time(rtc_ptr, second, millisecond); \
314 } \
315 vsf_rtc_capability_t vsf_imp_rtc_capability(vsf_imp_rtc_t *rtc_ptr) \
316 { \
317 VSF_HAL_ASSERT(rtc_ptr != NULL); \
318 return vsf_remap_rtc_capability(rtc_ptr); \
319 } \
320 \
321 vsf_err_t vsf_imp_rtc_get_configuration(vsf_imp_rtc_t *rtc_ptr, vsf_rtc_cfg_t *cfg_ptr) \
322 { \
323 VSF_HAL_ASSERT(rtc_ptr != NULL); \
324 return vsf_remap_rtc_get_configuration(rtc_ptr, cfg_ptr); \
325 } \
326 vsf_err_t vsf_imp_rtc_ctrl(vsf_imp_rtc_t *rtc_ptr, vsf_rtc_ctrl_t ctrl, void *param) \
327 { \
328 VSF_HAL_ASSERT(rtc_ptr != NULL); \
329 return vsf_remap_rtc_ctrl(rtc_ptr, ctrl, param); \
330 }
331#endif
332
333/*============================ GLOBAL VARIABLES ==============================*/
334
335#define VSF_HAL_TEMPLATE_IMP_NAME _rtc
336#define VSF_HAL_TEMPLATE_IMP_UPCASE_NAME _RTC
337
338#if !defined(VSF_RTC_CFG_IMP_PREFIX) && !defined(VSF_RTC_CFG_IMP_DEVICE_PREFIX)
339# error "Please define VSF_RTC_CFG_IMP_PREFIX in rtc driver"
340#endif
341
342#if !defined(VSF_RTC_CFG_IMP_UPCASE_PREFIX) && !defined(VSF_RTC_CFG_IMP_DEVICE_UPCASE_PREFIX)
343# error "Please define VSF_RTC_CFG_IMP_UPCASE_PREFIX in rtc driver"
344#endif
345
346#ifndef VSF_RTC_CFG_IMP_COUNT_MASK_PREFIX
347# define VSF_RTC_CFG_IMP_COUNT_MASK_PREFIX VSF_RTC_CFG_IMP_UPCASE_PREFIX
348#endif
349
350#ifdef VSF_RTC_CFG_IMP_REMAP_FUNCTIONS
351# define VSF_HAL_CFG_IMP_REMAP_FUNCTIONS VSF_RTC_CFG_IMP_REMAP_FUNCTIONS
352#endif
353
354#include "hal/driver/common/template/vsf_template_instance_implementation.h"
355
356#undef VSF_RTC_CFG_IMP_PREFIX
357#undef VSF_RTC_CFG_IMP_COUNT_MASK_PREFIX
358#undef VSF_RTC_CFG_IMP_UPCASE_PREFIX
359#undef VSF_RTC_CFG_IMP_DEVICE_PREFIX
360#undef VSF_RTC_CFG_IMP_DEVICE_UPCASE_PREFIX
361#undef VSF_RTC_CFG_IMP_LV0
362#undef VSF_RTC_CFG_IMP_REMAP_FUNCTIONS
363#undef VSF_RTC_CFG_IMP_HAS_OP
364#undef VSF_RTC_CFG_IMP_EXTERN_OP
365#undef VSF_RTC_CFG_IMP_RENAME_DEVICE_PREFIX
366
367#undef vsf_imp_rtc_t
368#undef vsf_imp_rtc_init
369#undef vsf_imp_rtc_enable
370#undef vsf_imp_rtc_disable
371#undef vsf_imp_rtc_capability
372#undef vsf_imp_rtc_get
373#undef vsf_imp_rtc_set
374#undef vsf_imp_rtc_get_time
375#undef vsf_imp_rtc_set_time
376#undef vsf_imp_rtc_get_configuration
377#undef vsf_imp_rtc_ctrl
378
379#undef vsf_remap_rtc_t
380#undef vsf_remap_rtc_init
381#undef vsf_remap_rtc_enable
382#undef vsf_remap_rtc_disable
383#undef vsf_remap_rtc_capability
384#undef vsf_remap_rtc_get
385#undef vsf_remap_rtc_set
386#undef vsf_remap_rtc_get_time
387#undef vsf_remap_rtc_set_time
388#undef vsf_remap_rtc_get_configuration
389#undef vsf_remap_rtc_ctrl
390
391#undef VSF_HAL_TEMPLATE_IMP_NAME
392#undef VSF_HAL_TEMPLATE_IMP_UPCASE_NAME
393
394/*============================ STATIC ASSERTIONS ==============================*/
395
396/* User-extensible macros for custom mode and IRQ mask values
397 * Users can define these macros before including this template to append
398 * their custom enum values to the uniqueness checks.
399 *
400 * Check modes for custom values:
401 * VSF_RTC_CFG_MODE_CHECK_UNIQUE - Check mode for custom mode values
402 * Default: VSF_HAL_CHECK_MODE_LOOSE (loose mode, no overlapping bits)
403 * Can be set to: VSF_HAL_CHECK_MODE_STRICT (strict mode, no overlapping bits)
404 * VSF_RTC_CFG_IRQ_MASK_CHECK_UNIQUE - Check mode for custom IRQ mask values
405 * Default: VSF_HAL_CHECK_MODE_STRICT (strict mode, no overlapping bits)
406 * Can be set to: VSF_HAL_CHECK_MODE_LOOSE (loose mode, no overlapping bits)
407 *
408 * Example usage in vendor driver:
409 * #define VSF_RTC_CUSTOM_MODE_VALUES MY_CUSTOM_MODE1, MY_CUSTOM_MODE2
410 * #define VSF_RTC_CFG_MODE_CHECK_UNIQUE VSF_HAL_CHECK_MODE_LOOSE
411 * #define VSF_RTC_CUSTOM_IRQ_MASK_VALUES MY_CUSTOM_IRQ1, MY_CUSTOM_IRQ2
412 * #define VSF_RTC_CFG_IRQ_MASK_CHECK_UNIQUE VSF_HAL_CHECK_MODE_STRICT
413 * #include "hal/driver/common/rtc/rtc_template.inc"
414 */
415
416
417#ifdef VSF_RTC_CFG_MODE_CHECK_UNIQUE
418/* Default mode lists - can be redefined by users before including this file */
419/* Note: RTC typically doesn't have mode enums, but custom modes can be added */
420
421#ifdef VSF_RTC_CUSTOM_MODE_VALUES
422/* Check uniqueness among custom mode values using user-specified check mode */
423VSF_HAL_CHECK_UNIQUE_CUSTOM(VSF_RTC_CFG_MODE_CHECK_UNIQUE, VSF_RTC_CUSTOM_MODE_VALUES);
424#endif
425#endif /* VSF_RTC_CFG_MODE_CHECK_UNIQUE */
426
427/* ==================== IRQ MASK UNIQUENESS CHECKS ==================== */
428
429#ifdef VSF_RTC_CFG_IRQ_MASK_CHECK_UNIQUE
430
431#ifdef VSF_RTC_CUSTOM_IRQ_MASK_VALUES
432/* Check uniqueness among custom IRQ mask values using user-specified check mode */
433VSF_HAL_CHECK_UNIQUE_CUSTOM(VSF_RTC_CFG_IRQ_MASK_CHECK_UNIQUE, VSF_RTC_CUSTOM_IRQ_MASK_VALUES);
434#endif
435
436/* Check uniqueness within vsf_rtc_irq_mask_t enum */
437
438/* Check IRQ mask uniqueness - all IRQ mask bits should have different values
439 * Mandatory: VSF_RTC_IRQ_MASK_ALARM
440 */
441VSF_HAL_CHECK_UNIQUE_CUSTOM(
442 VSF_RTC_CFG_IRQ_MASK_CHECK_UNIQUE,
443 /* Mandatory IRQ masks - always included */
444 VSF_RTC_IRQ_MASK_ALARM
445 /* User-defined IRQ masks - appended by user configuration */
446#ifdef VSF_RTC_CUSTOM_IRQ_MASK_VALUES
447 , VSF_RTC_CUSTOM_IRQ_MASK_VALUES
448#endif
449);
450#endif /* VSF_RTC_CFG_IRQ_MASK_CHECK_UNIQUE */
451
452#undef VSF_RTC_CFG_MODE_CHECK_UNIQUE
453#undef VSF_RTC_CFG_IRQ_MASK_CHECK_UNIQUE
454#undef VSF_RTC_CUSTOM_MODE_VALUES
455#undef VSF_RTC_CUSTOM_IRQ_MASK_VALUES
456
457#endif /* VSF_HAL_USE_RTC */
458
vsf_err_t
vsf_err_t
Definition __type.h:42
VSF_ERR_NOT_SUPPORT
@ VSF_ERR_NOT_SUPPORT
function not supported
Definition __type.h:46
VSF_ERR_NONE
@ VSF_ERR_NONE
none error
Definition __type.h:44
VSF_ERR_FAIL
@ VSF_ERR_FAIL
failed
Definition __type.h:51
VSF_RTC_CFG_CAPABILITY_IRQ_MASK
#define VSF_RTC_CFG_CAPABILITY_IRQ_MASK
Definition rtc.c:148
time_t
__TIME_T time_t
Definition types.h:132
NULL
#define NULL
Definition lvgl.h:26
gmtime
struct tm * gmtime(const time_t *t)
Definition vsf_linux_glibc_time.c:366
mktime
time_t mktime(struct tm *tm)
Definition vsf_linux_glibc_time.c:86
tm
Definition time.h:53
tm::tm_mon
int tm_mon
Definition time.h:58
tm::tm_year
int tm_year
Definition time.h:59
tm::tm_hour
int tm_hour
Definition time.h:56
tm::tm_sec
int tm_sec
Definition time.h:54
tm::tm_mday
int tm_mday
Definition time.h:57
tm::tm_min
int tm_min
Definition time.h:55
tm::tm_wday
int tm_wday
Definition time.h:60
vsf_rtc_capability_t
RTC capability structure. Describes the features and capabilities supported by the RTC hardware.
Definition vsf_template_rtc.h:379
vsf_rtc_cfg_t
RTC configuration structure.
Definition vsf_template_rtc.h:365
vsf_rtc_tm_t
Time structure for RTC operations. Used to represent date and time information in a standardized form...
Definition vsf_template_rtc.h:255
vsf_rtc_tm_t::tm_ms
uint16_t tm_ms
Milliseconds component of time [0-999]. Provides sub-second precision.
Definition vsf_template_rtc.h:326
vsf_rtc_tm_t::tm_sec
uint8_t tm_sec
Seconds component of time [0-59].
Definition vsf_template_rtc.h:262
vsf_rtc_tm_t::tm_year
uint16_t tm_year
Year value [0-65535].
Definition vsf_template_rtc.h:316
vsf_rtc_tm_t::tm_mon
uint8_t tm_mon
Month [1-12]. January=1, February=2, ..., December=12.
Definition vsf_template_rtc.h:308
vsf_rtc_tm_t::tm_wday
uint8_t tm_wday
Day of week [1-7]. Sunday=1, Monday=2, ..., Saturday=7.
Definition vsf_template_rtc.h:298
vsf_rtc_tm_t::tm_mday
uint8_t tm_mday
Day of month [1-31].
Definition vsf_template_rtc.h:288
vsf_rtc_tm_t::tm_hour
uint8_t tm_hour
Hours component of time [0-23]. Uses 24-hour format.
Definition vsf_template_rtc.h:280
vsf_rtc_tm_t::tm_min
uint8_t tm_min
Minutes component of time [0-59].
Definition vsf_template_rtc.h:270
VSF_RTC_CFG_IRQ_MASK_CHECK_UNIQUE
#define VSF_RTC_CFG_IRQ_MASK_CHECK_UNIQUE
Definition rtc.c:225
VSF_RTC_CFG_MODE_CHECK_UNIQUE
#define VSF_RTC_CFG_MODE_CHECK_UNIQUE
Definition rtc.c:224
VSF_HAL_ASSERT
#define VSF_HAL_ASSERT(__CON)
all hal modules use this configuration file
Definition vsf_hal_cfg.h:36
vsf_template_instance_implementation.h
vsf_rtc_ctrl_t
vsf_rtc_ctrl_t
RTC control commands for hardware-specific operations.
Definition vsf_template_rtc.h:413
vsf_rtc_time_t
VSF_RTC_CFG_TIME_TYPE vsf_rtc_time_t
RTC time type definition.
Definition vsf_template_rtc.h:245
VSF_RTC_IRQ_MASK_ALARM
@ VSF_RTC_IRQ_MASK_ALARM
Alarm interrupt mask. Triggers when the RTC time matches the configured alarm time.
Definition vsf_template_rtc.h:211
VSF_HAL_CHECK_UNIQUE_CUSTOM
#define VSF_HAL_CHECK_UNIQUE_CUSTOM(__CHECK_FUNC,...)
Definition vsf_template_static_assert_unique.h:2426
Generated from commit: vsfteam/vsf@b2e9e8a