1 /*
2 * Copyright (c) 2018 blik GmbH
3 * Copyright (c) 2018,2024 NXP
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 */
7
8 #define DT_DRV_COMPAT nxp_rtc
9
10 #include <zephyr/drivers/counter.h>
11 #include <zephyr/irq.h>
12 #include <zephyr/kernel.h>
13 #include <zephyr/sys_clock.h>
14 #include <fsl_rtc.h>
15 #include <zephyr/logging/log.h>
16
17 /*
18 * FSL_FEATURE_* is defined with paranethesis
19 * which is not acceptable when using the IS_ENABLED() macro
20 */
21 #if (defined(FSL_FEATURE_RTC_HAS_LPO_ADJUST) && FSL_FEATURE_RTC_HAS_LPO_ADJUST)
22 #define NXP_RTC_HAS_LPO_ADJUST 1
23 #else
24 #define NXP_RTC_HAS_LPO_ADJUST 0
25 #endif
26
27 LOG_MODULE_REGISTER(mcux_rtc, CONFIG_COUNTER_LOG_LEVEL);
28
29 struct mcux_rtc_data {
30 counter_alarm_callback_t alarm_callback;
31 counter_top_callback_t top_callback;
32 void *alarm_user_data;
33 void *top_user_data;
34 };
35
36 struct mcux_rtc_config {
37 struct counter_config_info info;
38 RTC_Type *base;
39 void (*irq_config_func)(const struct device *dev);
40 };
41
mcux_rtc_start(const struct device * dev)42 static int mcux_rtc_start(const struct device *dev)
43 {
44 const struct counter_config_info *info = dev->config;
45 const struct mcux_rtc_config *config =
46 CONTAINER_OF(info, struct mcux_rtc_config, info);
47
48 RTC_StartTimer(config->base);
49 RTC_EnableInterrupts(config->base,
50 kRTC_AlarmInterruptEnable |
51 kRTC_TimeOverflowInterruptEnable |
52 kRTC_TimeInvalidInterruptEnable);
53
54 return 0;
55 }
56
mcux_rtc_stop(const struct device * dev)57 static int mcux_rtc_stop(const struct device *dev)
58 {
59 const struct counter_config_info *info = dev->config;
60 const struct mcux_rtc_config *config =
61 CONTAINER_OF(info, struct mcux_rtc_config, info);
62
63 RTC_DisableInterrupts(config->base,
64 kRTC_AlarmInterruptEnable |
65 kRTC_TimeOverflowInterruptEnable |
66 kRTC_TimeInvalidInterruptEnable);
67 RTC_StopTimer(config->base);
68
69 /* clear out any set alarms */
70 config->base->TAR = 0;
71
72 return 0;
73 }
74
mcux_rtc_read(const struct device * dev)75 static uint32_t mcux_rtc_read(const struct device *dev)
76 {
77 const struct counter_config_info *info = dev->config;
78 const struct mcux_rtc_config *config =
79 CONTAINER_OF(info, struct mcux_rtc_config, info);
80
81 uint32_t ticks = config->base->TSR;
82
83 /*
84 * Read TSR seconds twice in case it glitches during an update.
85 * This can happen when a read occurs at the time the register is
86 * incrementing.
87 */
88 if (config->base->TSR == ticks) {
89 return ticks;
90 }
91
92 ticks = config->base->TSR;
93
94 return ticks;
95 }
96
mcux_rtc_get_value(const struct device * dev,uint32_t * ticks)97 static int mcux_rtc_get_value(const struct device *dev, uint32_t *ticks)
98 {
99 *ticks = mcux_rtc_read(dev);
100 return 0;
101 }
102
mcux_rtc_set_alarm(const struct device * dev,uint8_t chan_id,const struct counter_alarm_cfg * alarm_cfg)103 static int mcux_rtc_set_alarm(const struct device *dev, uint8_t chan_id,
104 const struct counter_alarm_cfg *alarm_cfg)
105 {
106 const struct counter_config_info *info = dev->config;
107 const struct mcux_rtc_config *config =
108 CONTAINER_OF(info, struct mcux_rtc_config, info);
109 struct mcux_rtc_data *data = dev->data;
110
111 uint32_t ticks = alarm_cfg->ticks;
112 uint32_t current = mcux_rtc_read(dev);
113
114 LOG_DBG("Current time is %d ticks", current);
115
116 if (chan_id != 0U) {
117 LOG_ERR("Invalid channel id");
118 return -EINVAL;
119 }
120
121 if (data->alarm_callback != NULL) {
122 return -EBUSY;
123 }
124
125 if ((alarm_cfg->flags & COUNTER_ALARM_CFG_ABSOLUTE) == 0) {
126 ticks += current;
127 }
128
129 if (ticks < current) {
130 LOG_ERR("Alarm cannot be earlier than current time");
131 return -EINVAL;
132 }
133
134 data->alarm_callback = alarm_cfg->callback;
135 data->alarm_user_data = alarm_cfg->user_data;
136
137 config->base->TAR = ticks;
138 LOG_DBG("Alarm set to %d ticks", ticks);
139
140 return 0;
141 }
142
mcux_rtc_cancel_alarm(const struct device * dev,uint8_t chan_id)143 static int mcux_rtc_cancel_alarm(const struct device *dev, uint8_t chan_id)
144 {
145 struct mcux_rtc_data *data = dev->data;
146
147 if (chan_id != 0U) {
148 LOG_ERR("Invalid channel id");
149 return -EINVAL;
150 }
151
152 data->alarm_callback = NULL;
153
154 return 0;
155 }
156
mcux_rtc_set_top_value(const struct device * dev,const struct counter_top_cfg * cfg)157 static int mcux_rtc_set_top_value(const struct device *dev,
158 const struct counter_top_cfg *cfg)
159 {
160 const struct counter_config_info *info = dev->config;
161 const struct mcux_rtc_config *config =
162 CONTAINER_OF(info, struct mcux_rtc_config, info);
163 struct mcux_rtc_data *data = dev->data;
164
165 if (cfg->ticks != info->max_top_value) {
166 LOG_ERR("Wrap can only be set to 0x%x.", info->max_top_value);
167 return -ENOTSUP;
168 }
169
170 if (!(cfg->flags & COUNTER_TOP_CFG_DONT_RESET)) {
171 RTC_StopTimer(config->base);
172 config->base->TSR = 0;
173 RTC_StartTimer(config->base);
174 }
175
176 data->top_callback = cfg->callback;
177 data->top_user_data = cfg->user_data;
178
179 return 0;
180 }
181
mcux_rtc_get_pending_int(const struct device * dev)182 static uint32_t mcux_rtc_get_pending_int(const struct device *dev)
183 {
184 const struct counter_config_info *info = dev->config;
185 const struct mcux_rtc_config *config =
186 CONTAINER_OF(info, struct mcux_rtc_config, info);
187
188 return RTC_GetStatusFlags(config->base) & RTC_SR_TAF_MASK;
189 }
190
mcux_rtc_get_top_value(const struct device * dev)191 static uint32_t mcux_rtc_get_top_value(const struct device *dev)
192 {
193 const struct counter_config_info *info = dev->config;
194
195 return info->max_top_value;
196 }
197
mcux_rtc_isr(const struct device * dev)198 static void mcux_rtc_isr(const struct device *dev)
199 {
200 const struct counter_config_info *info = dev->config;
201 const struct mcux_rtc_config *config =
202 CONTAINER_OF(info, struct mcux_rtc_config, info);
203 struct mcux_rtc_data *data = dev->data;
204 counter_alarm_callback_t cb;
205 uint32_t current = mcux_rtc_read(dev);
206
207
208 LOG_DBG("Current time is %d ticks", current);
209
210 if ((RTC_GetStatusFlags(config->base) & RTC_SR_TAF_MASK) &&
211 (data->alarm_callback)) {
212 cb = data->alarm_callback;
213 data->alarm_callback = NULL;
214 cb(dev, 0, current, data->alarm_user_data);
215 }
216
217 if ((RTC_GetStatusFlags(config->base) & RTC_SR_TOF_MASK) &&
218 (data->top_callback)) {
219 data->top_callback(dev, data->top_user_data);
220 }
221
222 /*
223 * Clear any conditions to ack the IRQ
224 *
225 * callback may have already reset the alarm flag if a new
226 * alarm value was programmed to the TAR
227 */
228 RTC_StopTimer(config->base);
229 if (RTC_GetStatusFlags(config->base) & RTC_SR_TAF_MASK) {
230 RTC_ClearStatusFlags(config->base, kRTC_AlarmFlag);
231 } else if (RTC_GetStatusFlags(config->base) & RTC_SR_TIF_MASK) {
232 RTC_ClearStatusFlags(config->base, kRTC_TimeInvalidFlag);
233 } else if (RTC_GetStatusFlags(config->base) & RTC_SR_TOF_MASK) {
234 RTC_ClearStatusFlags(config->base, kRTC_TimeOverflowFlag);
235 }
236 RTC_StartTimer(config->base);
237 }
238
mcux_rtc_init(const struct device * dev)239 static int mcux_rtc_init(const struct device *dev)
240 {
241 const struct counter_config_info *info = dev->config;
242 const struct mcux_rtc_config *config =
243 CONTAINER_OF(info, struct mcux_rtc_config, info);
244 rtc_config_t rtc_config;
245
246 RTC_GetDefaultConfig(&rtc_config);
247 RTC_Init(config->base, &rtc_config);
248
249 /* DT_ENUM_IDX(DT_NODELABEL(rtc), clock_source):
250 * "RTC": 0
251 * "LPO": 1
252 */
253 BUILD_ASSERT((((DT_INST_ENUM_IDX(0, clock_source) == 1) &&
254 NXP_RTC_HAS_LPO_ADJUST) ||
255 DT_INST_ENUM_IDX(0, clock_source) == 0),
256 "Cannot choose the LPO clock for that instance of the RTC");
257
258 #if (defined(FSL_FEATURE_RTC_HAS_LPO_ADJUST) && FSL_FEATURE_RTC_HAS_LPO_ADJUST)
259 /* The RTC prescaler increments using the LPO 1 kHz clock
260 * instead of the RTC clock
261 */
262 RTC_EnableLPOClock(config->base, DT_INST_ENUM_IDX(0, clock_source));
263 #endif
264
265 #if !(defined(FSL_FEATURE_RTC_HAS_NO_CR_OSCE) && FSL_FEATURE_RTC_HAS_NO_CR_OSCE)
266 /* Enable 32kHz oscillator and wait for 1ms to settle */
267 RTC_SetClockSource(config->base);
268 k_busy_wait(USEC_PER_MSEC);
269 #endif /* !FSL_FEATURE_RTC_HAS_NO_CR_OSCE */
270
271 config->irq_config_func(dev);
272
273 return 0;
274 }
275
276 static DEVICE_API(counter, mcux_rtc_driver_api) = {
277 .start = mcux_rtc_start,
278 .stop = mcux_rtc_stop,
279 .get_value = mcux_rtc_get_value,
280 .set_alarm = mcux_rtc_set_alarm,
281 .cancel_alarm = mcux_rtc_cancel_alarm,
282 .set_top_value = mcux_rtc_set_top_value,
283 .get_pending_int = mcux_rtc_get_pending_int,
284 .get_top_value = mcux_rtc_get_top_value,
285 };
286
287 static struct mcux_rtc_data mcux_rtc_data_0;
288
289 static void mcux_rtc_irq_config_0(const struct device *dev);
290
291 static struct mcux_rtc_config mcux_rtc_config_0 = {
292 .base = (RTC_Type *)DT_INST_REG_ADDR(0),
293 .irq_config_func = mcux_rtc_irq_config_0,
294 .info = {
295 .max_top_value = UINT32_MAX,
296 .freq = DT_INST_PROP(0, clock_frequency) /
297 DT_INST_PROP(0, prescaler),
298 .flags = COUNTER_CONFIG_INFO_COUNT_UP,
299 .channels = 1,
300 },
301 };
302
303 DEVICE_DT_INST_DEFINE(0, &mcux_rtc_init, NULL,
304 &mcux_rtc_data_0, &mcux_rtc_config_0.info,
305 POST_KERNEL, CONFIG_COUNTER_INIT_PRIORITY,
306 &mcux_rtc_driver_api);
307
mcux_rtc_irq_config_0(const struct device * dev)308 static void mcux_rtc_irq_config_0(const struct device *dev)
309 {
310 IRQ_CONNECT(DT_INST_IRQN(0),
311 DT_INST_IRQ(0, priority),
312 mcux_rtc_isr, DEVICE_DT_INST_GET(0), 0);
313 irq_enable(DT_INST_IRQN(0));
314 }
315
