blob: c88312ec721887f464120e5b69bd6d25f29cd266 [file] [log] [blame]
Tom Rini10e47792018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
maxims@google.comdaea6d42017-04-17 12:00:21 -07002/*
3 * Copyright 2017 Google, Inc
maxims@google.comdaea6d42017-04-17 12:00:21 -07004 */
5
Patrick Delaunay81313352021-04-27 11:02:19 +02006#define LOG_CATEGORY UCLASS_WDT
7
Stefan Roesecce24722022-08-18 13:22:46 +02008#include <cyclic.h>
Chanho Parkdfd30122023-12-03 17:30:40 +09009#include <div64.h>
maxims@google.comdaea6d42017-04-17 12:00:21 -070010#include <dm.h>
11#include <errno.h>
Simon Glassf11478f2019-12-28 10:45:07 -070012#include <hang.h>
Simon Glass0f2af882020-05-10 11:40:05 -060013#include <log.h>
Samuel Holland3a8713a2021-11-03 22:55:14 -050014#include <sysreset.h>
Chris Packham32a234f2020-02-24 13:20:33 +130015#include <time.h>
maxims@google.comdaea6d42017-04-17 12:00:21 -070016#include <wdt.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060017#include <asm/global_data.h>
maxims@google.comdaea6d42017-04-17 12:00:21 -070018#include <dm/device-internal.h>
19#include <dm/lists.h>
20
Stefan Roese502acb02019-04-11 15:58:44 +020021DECLARE_GLOBAL_DATA_PTR;
22
Rasmus Villemoesf7c2e9f2020-03-13 17:04:57 +010023#define WATCHDOG_TIMEOUT_SECS (CONFIG_WATCHDOG_TIMEOUT_MSECS / 1000)
24
Rasmus Villemoes635f9242021-08-19 11:56:56 +020025struct wdt_priv {
26 /* Timeout, in seconds, to configure this device to. */
27 u32 timeout;
28 /*
29 * Time, in milliseconds, between calling the device's ->reset()
30 * method from watchdog_reset().
31 */
32 ulong reset_period;
33 /*
34 * Next time (as returned by get_timer(0)) to call
35 * ->reset().
36 */
37 ulong next_reset;
Rasmus Villemoes85fb8222021-08-19 11:56:59 +020038 /* Whether watchdog_start() has been called on the device. */
39 bool running;
Rasmus Villemoesce66f192022-09-27 11:54:03 +020040 /* autostart */
41 bool autostart;
Stefan Roesecce24722022-08-18 13:22:46 +020042
43 struct cyclic_info *cyclic;
Rasmus Villemoes635f9242021-08-19 11:56:56 +020044};
Rasmus Villemoes2ba843d2020-03-13 17:04:58 +010045
Stefan Roesecce24722022-08-18 13:22:46 +020046static void wdt_cyclic(void *ctx)
47{
48 struct udevice *dev = ctx;
49 struct wdt_priv *priv;
50
51 if (!device_active(dev))
52 return;
53
54 priv = dev_get_uclass_priv(dev);
55 if (!priv->running)
56 return;
57
58 wdt_reset(dev);
59}
60
Rasmus Villemoesc2453182021-08-19 11:56:58 +020061static void init_watchdog_dev(struct udevice *dev)
Rasmus Villemoesf7c2e9f2020-03-13 17:04:57 +010062{
Rasmus Villemoes635f9242021-08-19 11:56:56 +020063 struct wdt_priv *priv;
Pali Rohárc80b8212021-03-09 14:26:55 +010064 int ret;
Rasmus Villemoesf7c2e9f2020-03-13 17:04:57 +010065
Rasmus Villemoesc2453182021-08-19 11:56:58 +020066 priv = dev_get_uclass_priv(dev);
67
Samuel Holland3a8713a2021-11-03 22:55:14 -050068 if (IS_ENABLED(CONFIG_SYSRESET_WATCHDOG_AUTO)) {
69 ret = sysreset_register_wdt(dev);
70 if (ret)
71 printf("WDT: Failed to register %s for sysreset\n",
72 dev->name);
73 }
74
Rasmus Villemoesce66f192022-09-27 11:54:03 +020075 if (!priv->autostart) {
Rasmus Villemoesc2453182021-08-19 11:56:58 +020076 printf("WDT: Not starting %s\n", dev->name);
77 return;
78 }
79
80 ret = wdt_start(dev, priv->timeout * 1000, 0);
81 if (ret != 0) {
82 printf("WDT: Failed to start %s\n", dev->name);
83 return;
84 }
Rasmus Villemoesc2453182021-08-19 11:56:58 +020085}
86
87int initr_watchdog(void)
88{
Rasmus Villemoes3be6a352021-08-19 11:57:03 +020089 struct udevice *dev;
90 struct uclass *uc;
91 int ret;
92
93 ret = uclass_get(UCLASS_WDT, &uc);
94 if (ret) {
95 log_debug("Error getting UCLASS_WDT: %d\n", ret);
96 return 0;
97 }
98
99 uclass_foreach_dev(dev, uc) {
100 ret = device_probe(dev);
101 if (ret) {
102 log_debug("Error probing %s: %d\n", dev->name, ret);
103 continue;
Rasmus Villemoesf7c2e9f2020-03-13 17:04:57 +0100104 }
Rasmus Villemoes3be6a352021-08-19 11:57:03 +0200105 init_watchdog_dev(dev);
Rasmus Villemoesf7c2e9f2020-03-13 17:04:57 +0100106 }
Rasmus Villemoesf7c2e9f2020-03-13 17:04:57 +0100107
108 return 0;
109}
110
Andy Shevchenko2befb4b2017-08-04 15:48:28 -0600111int wdt_start(struct udevice *dev, u64 timeout_ms, ulong flags)
maxims@google.comdaea6d42017-04-17 12:00:21 -0700112{
113 const struct wdt_ops *ops = device_get_ops(dev);
Pali Rohár8a8a5ad2021-03-09 14:26:54 +0100114 int ret;
maxims@google.comdaea6d42017-04-17 12:00:21 -0700115
116 if (!ops->start)
117 return -ENOSYS;
118
Pali Rohár8a8a5ad2021-03-09 14:26:54 +0100119 ret = ops->start(dev, timeout_ms, flags);
Rasmus Villemoes85fb8222021-08-19 11:56:59 +0200120 if (ret == 0) {
121 struct wdt_priv *priv = dev_get_uclass_priv(dev);
Stefan Roesecce24722022-08-18 13:22:46 +0200122 char str[16];
Rasmus Villemoes85fb8222021-08-19 11:56:59 +0200123
124 priv->running = true;
Stefan Roesecce24722022-08-18 13:22:46 +0200125
126 memset(str, 0, 16);
127 if (IS_ENABLED(CONFIG_WATCHDOG)) {
128 /* Register the watchdog driver as a cyclic function */
129 priv->cyclic = cyclic_register(wdt_cyclic,
130 priv->reset_period * 1000,
131 dev->name, dev);
132 if (!priv->cyclic) {
133 printf("cyclic_register for %s failed\n",
134 dev->name);
135 return -ENODEV;
136 } else {
137 snprintf(str, 16, "every %ldms",
138 priv->reset_period);
139 }
140 }
141
142 printf("WDT: Started %s with%s servicing %s (%ds timeout)\n",
143 dev->name, IS_ENABLED(CONFIG_WATCHDOG) ? "" : "out",
Chanho Parkdfd30122023-12-03 17:30:40 +0900144 str, (u32)lldiv(timeout_ms, 1000));
Rasmus Villemoes85fb8222021-08-19 11:56:59 +0200145 }
Pali Rohár8a8a5ad2021-03-09 14:26:54 +0100146
147 return ret;
maxims@google.comdaea6d42017-04-17 12:00:21 -0700148}
149
150int wdt_stop(struct udevice *dev)
151{
152 const struct wdt_ops *ops = device_get_ops(dev);
Pali Rohár8a8a5ad2021-03-09 14:26:54 +0100153 int ret;
maxims@google.comdaea6d42017-04-17 12:00:21 -0700154
155 if (!ops->stop)
156 return -ENOSYS;
157
Pali Rohár8a8a5ad2021-03-09 14:26:54 +0100158 ret = ops->stop(dev);
Rasmus Villemoes85fb8222021-08-19 11:56:59 +0200159 if (ret == 0) {
160 struct wdt_priv *priv = dev_get_uclass_priv(dev);
161
162 priv->running = false;
163 }
Pali Rohár8a8a5ad2021-03-09 14:26:54 +0100164
165 return ret;
maxims@google.comdaea6d42017-04-17 12:00:21 -0700166}
167
Rasmus Villemoesbeb8c2f2021-08-19 11:57:01 +0200168int wdt_stop_all(void)
169{
170 struct wdt_priv *priv;
171 struct udevice *dev;
172 struct uclass *uc;
173 int ret, err;
174
175 ret = uclass_get(UCLASS_WDT, &uc);
176 if (ret)
177 return ret;
178
179 uclass_foreach_dev(dev, uc) {
180 if (!device_active(dev))
181 continue;
182 priv = dev_get_uclass_priv(dev);
183 if (!priv->running)
184 continue;
185 err = wdt_stop(dev);
186 if (!ret)
187 ret = err;
188 }
189
190 return ret;
191}
192
maxims@google.comdaea6d42017-04-17 12:00:21 -0700193int wdt_reset(struct udevice *dev)
194{
195 const struct wdt_ops *ops = device_get_ops(dev);
196
197 if (!ops->reset)
198 return -ENOSYS;
199
200 return ops->reset(dev);
201}
202
203int wdt_expire_now(struct udevice *dev, ulong flags)
204{
205 int ret = 0;
206 const struct wdt_ops *ops;
207
Andy Shevchenkof047be42017-07-05 20:44:06 +0300208 debug("WDT Resetting: %lu\n", flags);
maxims@google.comdaea6d42017-04-17 12:00:21 -0700209 ops = device_get_ops(dev);
210 if (ops->expire_now) {
211 return ops->expire_now(dev, flags);
212 } else {
Rasmus Villemoesf008c302021-08-19 11:56:55 +0200213 ret = wdt_start(dev, 1, flags);
maxims@google.comdaea6d42017-04-17 12:00:21 -0700214
maxims@google.comdaea6d42017-04-17 12:00:21 -0700215 if (ret < 0)
216 return ret;
217
218 hang();
219 }
220
221 return ret;
222}
Stefan Roese502acb02019-04-11 15:58:44 +0200223
224#if defined(CONFIG_WATCHDOG)
225/*
226 * Called by macro WATCHDOG_RESET. This function be called *very* early,
227 * so we need to make sure, that the watchdog driver is ready before using
228 * it in this function.
229 */
230void watchdog_reset(void)
231{
Rasmus Villemoes3be6a352021-08-19 11:57:03 +0200232 /*
Stefan Roesecce24722022-08-18 13:22:46 +0200233 * Empty function for now. The actual WDT handling is now done in
234 * the cyclic function instead.
Rasmus Villemoes3be6a352021-08-19 11:57:03 +0200235 */
Stefan Roese502acb02019-04-11 15:58:44 +0200236}
237#endif
maxims@google.comdaea6d42017-04-17 12:00:21 -0700238
Rasmus Villemoes635f9242021-08-19 11:56:56 +0200239static int wdt_pre_probe(struct udevice *dev)
240{
241 u32 timeout = WATCHDOG_TIMEOUT_SECS;
242 /*
243 * Reset every 1000ms, or however often is required as
244 * indicated by a hw_margin_ms property.
245 */
246 ulong reset_period = 1000;
Rasmus Villemoesce66f192022-09-27 11:54:03 +0200247 bool autostart = IS_ENABLED(CONFIG_WATCHDOG_AUTOSTART);
Rasmus Villemoes635f9242021-08-19 11:56:56 +0200248 struct wdt_priv *priv;
249
250 if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
251 timeout = dev_read_u32_default(dev, "timeout-sec", timeout);
252 reset_period = dev_read_u32_default(dev, "hw_margin_ms",
253 4 * reset_period) / 4;
Rasmus Villemoesce66f192022-09-27 11:54:03 +0200254 if (dev_read_bool(dev, "u-boot,noautostart"))
255 autostart = false;
256 else if (dev_read_bool(dev, "u-boot,autostart"))
257 autostart = true;
Rasmus Villemoes635f9242021-08-19 11:56:56 +0200258 }
259 priv = dev_get_uclass_priv(dev);
260 priv->timeout = timeout;
261 priv->reset_period = reset_period;
Rasmus Villemoesce66f192022-09-27 11:54:03 +0200262 priv->autostart = autostart;
Rasmus Villemoes635f9242021-08-19 11:56:56 +0200263 /*
264 * Pretend this device was last reset "long" ago so the first
265 * watchdog_reset will actually call its ->reset method.
266 */
267 priv->next_reset = get_timer(0);
268
269 return 0;
270}
271
maxims@google.comdaea6d42017-04-17 12:00:21 -0700272UCLASS_DRIVER(wdt) = {
Rasmus Villemoes1e42d372021-08-19 11:56:57 +0200273 .id = UCLASS_WDT,
274 .name = "watchdog",
275 .flags = DM_UC_FLAG_SEQ_ALIAS,
Rasmus Villemoes635f9242021-08-19 11:56:56 +0200276 .pre_probe = wdt_pre_probe,
277 .per_device_auto = sizeof(struct wdt_priv),
maxims@google.comdaea6d42017-04-17 12:00:21 -0700278};