1 /*
2 * Copyright (c) 2006-2023, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2019-04-20 tyustli the first version.
9 *
10 */
11 #include <rtthread.h>
12
13 #ifdef BSP_USING_WDT
14
15 #if !defined(BSP_USING_WDT1) && !defined(BSP_USING_WDT3)
16 #error "Please define at least one BSP_USING_WDOGx"
17 #endif
18
19 #define LOG_TAG "drv.wdt"
20 #include <drv_log.h>
21
22 #include "drv_wdt.h"
23 #include <rthw.h>
24 #include "rtdevice.h"
25
26 #if defined(BSP_USING_WDT3)
27 #include "fsl_rtwdog.h"
28
29 static rt_watchdog_t imxrt_watchdog3;
30 static rtwdog_config_t rtwdog_config_t_value;
31
imxrt_hp_wdog3_close(rt_watchdog_t * wdt)32 static rt_err_t imxrt_hp_wdog3_close(rt_watchdog_t *wdt)
33 {
34 rt_uint32_t level;
35 RTWDOG_Type *base;
36 base = (RTWDOG_Type *)wdt->parent.user_data;
37
38 level = rt_hw_interrupt_disable();
39 RTWDOG_Unlock(base);
40 RTWDOG_Disable(base);
41 rt_hw_interrupt_enable(level);
42
43 return RT_EOK;
44 }
45
imxrt_hp_wdog3_open(rt_watchdog_t * wdt,rt_uint16_t oflag)46 static rt_err_t imxrt_hp_wdog3_open(rt_watchdog_t *wdt, rt_uint16_t oflag)
47 {
48 RTWDOG_Type *base;
49 base = (RTWDOG_Type *)wdt->parent.user_data;
50
51 rt_uint32_t level;
52
53 level = rt_hw_interrupt_disable();
54 RTWDOG_Unlock(base);
55 RTWDOG_Enable(base);
56 rt_hw_interrupt_enable(level);
57
58 return RT_EOK;
59 }
60
imxrt_hp_wdog3_init(rt_watchdog_t * wdt)61 static rt_err_t imxrt_hp_wdog3_init(rt_watchdog_t *wdt)
62 {
63 RTWDOG_Type *base;
64 base = (RTWDOG_Type *)wdt->parent.user_data;
65
66 RTWDOG_GetDefaultConfig(&rtwdog_config_t_value);
67 RTWDOG_Init(base, &rtwdog_config_t_value);
68 imxrt_hp_wdog3_close(wdt);
69
70 return RT_EOK;
71 }
72
imxrt_hp_wdog3_refresh(rt_watchdog_t * wdt)73 static rt_err_t imxrt_hp_wdog3_refresh(rt_watchdog_t *wdt)
74 {
75 RTWDOG_Type *base;
76 base = (RTWDOG_Type *)wdt->parent.user_data;
77
78 rt_uint32_t level;
79
80 level = rt_hw_interrupt_disable();
81 RTWDOG_Refresh(base);
82 rt_hw_interrupt_enable(level);
83
84 return RT_EOK;
85 }
86
87 /**
88 * @function control rtwdog
89 *
90 * @param
91 * wdt whick wdog used
92 * cmd control wdog options
93 * args argument of conrtol
94 * @retval rt_err_t the status of control result
95 *
96 * @attention rtwdog unit is not seconds because seconds for system is to inaccurate
97 *
98 */
imxrt_hp_wdog3_control(rt_watchdog_t * wdt,int cmd,void * args)99 static rt_err_t imxrt_hp_wdog3_control(rt_watchdog_t *wdt, int cmd, void *args)
100 {
101 RT_ASSERT(wdt != NULL);
102
103 RTWDOG_Type *base;
104 base = (RTWDOG_Type *)wdt->parent.user_data;
105
106 switch(cmd)
107 {
108 case RT_DEVICE_CTRL_WDT_GET_TIMEOUT:
109 {
110 *(uint16_t *)args = base->TOVAL;
111 }
112 break;
113 case RT_DEVICE_CTRL_WDT_SET_TIMEOUT:
114 {
115 RT_ASSERT(*(uint16_t *)args != 0);
116 RTWDOG_Unlock(base);
117 RTWDOG_SetTimeoutValue(base, *(uint16_t *)args);
118 imxrt_hp_wdog3_close(wdt);
119 }
120 break;
121 case RT_DEVICE_CTRL_WDT_GET_TIMELEFT:
122 {
123 *(uint16_t *)args = base->TOVAL - base->CNT;
124 }
125 break;
126 case RT_DEVICE_CTRL_WDT_KEEPALIVE:
127 {
128 imxrt_hp_wdog3_refresh(wdt);
129 }
130 break;
131 case RT_DEVICE_CTRL_WDT_START:
132 {
133 imxrt_hp_wdog3_open(wdt, *(rt_uint32_t *)args);
134 }
135 break;
136 case RT_DEVICE_CTRL_WDT_STOP:
137 {
138 imxrt_hp_wdog3_close(wdt);
139 }
140 break;
141 default:
142 return -RT_EINVAL;
143 }
144
145 return RT_EOK;
146 }
147
148 static struct rt_watchdog_ops imxrt_wdog3_ops =
149 {
150 .init = imxrt_hp_wdog3_init,
151 .control = imxrt_hp_wdog3_control,
152 };
153
154 #endif /* BSP_USING_WDT3 */
155
156 #if defined(BSP_USING_WDT1)
157 #include "fsl_wdog.h"
158
159 static rt_watchdog_t imxrt_watchdog;
160 static wdog_config_t WDOG_1_config =
161 {
162 .timeoutValue = 10,
163 .enablePowerDown = false,
164 .softwareResetExtension = false,
165 .enableTimeOutAssert = false,
166 .enableWdog = true,
167 .workMode =
168 {
169 .enableWait = false,
170 .enableStop = false,
171 .enableDebug = false,
172 },
173 .enableInterrupt = false,
174 .interruptTimeValue = 0,
175 };
176
imxrt_hp_wdog_close(rt_watchdog_t * wdt)177 static rt_err_t imxrt_hp_wdog_close(rt_watchdog_t *wdt)
178 {
179 rt_uint32_t level;
180 WDOG_Type *base;
181 base = (WDOG_Type *)wdt->parent.user_data;
182
183 level = rt_hw_interrupt_disable();
184 WDOG_Disable(base);
185 rt_hw_interrupt_enable(level);
186
187 return RT_EOK;
188 }
189
imxrt_hp_wdog_open(rt_watchdog_t * wdt,rt_uint16_t oflag)190 static rt_err_t imxrt_hp_wdog_open(rt_watchdog_t *wdt, rt_uint16_t oflag)
191 {
192 WDOG_Type *base;
193 base = (WDOG_Type *)wdt->parent.user_data;
194 rt_uint32_t level;
195
196 level = rt_hw_interrupt_disable();
197 WDOG_Enable(base);
198 rt_hw_interrupt_enable(level);
199
200 return RT_EOK;
201 }
202
imxrt_hp_wdog_init(rt_watchdog_t * wdt)203 static rt_err_t imxrt_hp_wdog_init(rt_watchdog_t *wdt)
204 {
205 WDOG_Type *base;
206 base = (WDOG_Type *)wdt->parent.user_data;
207
208 WDOG_Init(base, &WDOG_1_config);
209 imxrt_hp_wdog_close(wdt);
210
211 return RT_EOK;
212 }
213
imxrt_hp_wdog_refresh(rt_watchdog_t * wdt)214 static rt_err_t imxrt_hp_wdog_refresh(rt_watchdog_t *wdt)
215 {
216 WDOG_Type *base;
217 base = (WDOG_Type *)wdt->parent.user_data;
218
219 rt_uint32_t level;
220
221 level = rt_hw_interrupt_disable();
222 WDOG_Refresh(base);
223 rt_hw_interrupt_enable(level);
224
225 return RT_EOK;
226 }
227
228 /**
229 * @function control wdog
230 *
231 * @param
232 * wdt whick wdog used
233 * cmd control wdog options
234 * args argument of conrtol
235 * @retval rt_err_t the status of control result
236 *
237 * @attention wdog1/wdog2 is can not get left time(register not exist) and wdogs unit is seconds
238 *
239 */
imxrt_hp_wdog_control(rt_watchdog_t * wdt,int cmd,void * args)240 static rt_err_t imxrt_hp_wdog_control(rt_watchdog_t *wdt, int cmd, void *args)
241 {
242 RT_ASSERT(wdt != NULL);
243
244 WDOG_Type *base;
245 base = (WDOG_Type *)wdt->parent.user_data;
246
247 switch(cmd)
248 {
249 case RT_DEVICE_CTRL_WDT_GET_TIMEOUT:
250 {
251 *(uint16_t *)args = (base->WCR >> 8) / 2;
252 }
253 break;
254 case RT_DEVICE_CTRL_WDT_SET_TIMEOUT:
255 {
256 RT_ASSERT(*(uint16_t *)args != 0);
257 WDOG_SetTimeoutValue(base, (*(uint16_t *)args) * 2);
258 imxrt_hp_wdog_close(wdt);
259 }
260 break;
261 case RT_DEVICE_CTRL_WDT_KEEPALIVE:
262 {
263 imxrt_hp_wdog_refresh(wdt);
264 }
265 break;
266 case RT_DEVICE_CTRL_WDT_START:
267 {
268 imxrt_hp_wdog_open(wdt, *(rt_uint32_t *)args);
269 }
270 break;
271 case RT_DEVICE_CTRL_WDT_STOP:
272 {
273 imxrt_hp_wdog_close(wdt);
274 }
275 break;
276 default:
277 return -RT_EINVAL;
278 }
279
280 return RT_EOK;
281 }
282
283 static struct rt_watchdog_ops imxrt_wdog_ops =
284 {
285 .init = imxrt_hp_wdog_init,
286 .control = imxrt_hp_wdog_control,
287 };
288
289 #endif /* BSP_USING_WDT1 */
290
rt_hw_wdt_init(void)291 int rt_hw_wdt_init(void)
292 {
293 rt_err_t ret = RT_EOK;
294
295 #if defined (BSP_USING_WDT1)
296 imxrt_watchdog.ops = &imxrt_wdog_ops;
297
298 ret = rt_hw_watchdog_register(&imxrt_watchdog, "wdog1", RT_DEVICE_FLAG_RDWR, WDOG1);
299
300 if (ret != RT_EOK)
301 {
302 LOG_E("rt device register failed %d\n", ret);
303 }
304 #endif /* BSP_USING_WDT1 */
305
306 #if defined(BSP_USING_WDT3)
307 imxrt_watchdog3.ops = &imxrt_wdog3_ops;
308
309 ret = rt_hw_watchdog_register(&imxrt_watchdog3, "wdog3", RT_DEVICE_FLAG_RDWR, RTWDOG);
310
311 if (ret != RT_EOK)
312 {
313 LOG_E("rt device register failed %d\n", ret);
314 }
315 #endif /* BSP_USING_WDT3 */
316
317 return ret;
318 }
319
320 INIT_DEVICE_EXPORT(rt_hw_wdt_init);
321
322 #endif /* BSP_USING_WDT */
323