1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * watchdog_core.c
4 *
5 * (c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>,
6 * All Rights Reserved.
7 *
8 * (c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>.
9 *
10 * This source code is part of the generic code that can be used
11 * by all the watchdog timer drivers.
12 *
13 * Based on source code of the following authors:
14 * Matt Domsch <Matt_Domsch@dell.com>,
15 * Rob Radez <rob@osinvestor.com>,
16 * Rusty Lynch <rusty@linux.co.intel.com>
17 * Satyam Sharma <satyam@infradead.org>
18 * Randy Dunlap <randy.dunlap@oracle.com>
19 *
20 * Neither Alan Cox, CymruNet Ltd., Wim Van Sebroeck nor Iguana vzw.
21 * admit liability nor provide warranty for any of this software.
22 * This material is provided "AS-IS" and at no charge.
23 */
24
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26
27 #include <linux/module.h> /* For EXPORT_SYMBOL/module stuff/... */
28 #include <linux/types.h> /* For standard types */
29 #include <linux/errno.h> /* For the -ENODEV/... values */
30 #include <linux/kernel.h> /* For printk/panic/... */
31 #include <linux/reboot.h> /* For restart handler */
32 #include <linux/watchdog.h> /* For watchdog specific items */
33 #include <linux/init.h> /* For __init/__exit/... */
34 #include <linux/idr.h> /* For ida_* macros */
35 #include <linux/err.h> /* For IS_ERR macros */
36 #include <linux/of.h> /* For of_get_timeout_sec */
37
38 #include "watchdog_core.h" /* For watchdog_dev_register/... */
39
40 static DEFINE_IDA(watchdog_ida);
41
42 /*
43 * Deferred Registration infrastructure.
44 *
45 * Sometimes watchdog drivers needs to be loaded as soon as possible,
46 * for example when it's impossible to disable it. To do so,
47 * raising the initcall level of the watchdog driver is a solution.
48 * But in such case, the miscdev is maybe not ready (subsys_initcall), and
49 * watchdog_core need miscdev to register the watchdog as a char device.
50 *
51 * The deferred registration infrastructure offer a way for the watchdog
52 * subsystem to register a watchdog properly, even before miscdev is ready.
53 */
54
55 static DEFINE_MUTEX(wtd_deferred_reg_mutex);
56 static LIST_HEAD(wtd_deferred_reg_list);
57 static bool wtd_deferred_reg_done;
58
watchdog_deferred_registration_add(struct watchdog_device * wdd)59 static void watchdog_deferred_registration_add(struct watchdog_device *wdd)
60 {
61 list_add_tail(&wdd->deferred,
62 &wtd_deferred_reg_list);
63 }
64
watchdog_deferred_registration_del(struct watchdog_device * wdd)65 static void watchdog_deferred_registration_del(struct watchdog_device *wdd)
66 {
67 struct list_head *p, *n;
68 struct watchdog_device *wdd_tmp;
69
70 list_for_each_safe(p, n, &wtd_deferred_reg_list) {
71 wdd_tmp = list_entry(p, struct watchdog_device,
72 deferred);
73 if (wdd_tmp == wdd) {
74 list_del(&wdd_tmp->deferred);
75 break;
76 }
77 }
78 }
79
watchdog_check_min_max_timeout(struct watchdog_device * wdd)80 static void watchdog_check_min_max_timeout(struct watchdog_device *wdd)
81 {
82 /*
83 * Check that we have valid min and max timeout values, if
84 * not reset them both to 0 (=not used or unknown)
85 */
86 if (!wdd->max_hw_heartbeat_ms && wdd->min_timeout > wdd->max_timeout) {
87 pr_info("Invalid min and max timeout values, resetting to 0!\n");
88 wdd->min_timeout = 0;
89 wdd->max_timeout = 0;
90 }
91 }
92
93 /**
94 * watchdog_init_timeout() - initialize the timeout field
95 * @wdd: watchdog device
96 * @timeout_parm: timeout module parameter
97 * @dev: Device that stores the timeout-sec property
98 *
99 * Initialize the timeout field of the watchdog_device struct with either the
100 * timeout module parameter (if it is valid value) or the timeout-sec property
101 * (only if it is a valid value and the timeout_parm is out of bounds).
102 * If none of them are valid then we keep the old value (which should normally
103 * be the default timeout value). Note that for the module parameter, '0' means
104 * 'use default' while it is an invalid value for the timeout-sec property.
105 * It should simply be dropped if you want to use the default value then.
106 *
107 * A zero is returned on success or -EINVAL if all provided values are out of
108 * bounds.
109 */
watchdog_init_timeout(struct watchdog_device * wdd,unsigned int timeout_parm,struct device * dev)110 int watchdog_init_timeout(struct watchdog_device *wdd,
111 unsigned int timeout_parm, struct device *dev)
112 {
113 const char *dev_str = wdd->parent ? dev_name(wdd->parent) :
114 (const char *)wdd->info->identity;
115 unsigned int t = 0;
116 int ret = 0;
117
118 watchdog_check_min_max_timeout(wdd);
119
120 /* check the driver supplied value (likely a module parameter) first */
121 if (timeout_parm) {
122 if (!watchdog_timeout_invalid(wdd, timeout_parm)) {
123 wdd->timeout = timeout_parm;
124 return 0;
125 }
126 pr_err("%s: driver supplied timeout (%u) out of range\n",
127 dev_str, timeout_parm);
128 ret = -EINVAL;
129 }
130
131 /* try to get the timeout_sec property */
132 if (dev && dev->of_node &&
133 of_property_read_u32(dev->of_node, "timeout-sec", &t) == 0) {
134 if (t && !watchdog_timeout_invalid(wdd, t)) {
135 wdd->timeout = t;
136 return 0;
137 }
138 pr_err("%s: DT supplied timeout (%u) out of range\n", dev_str, t);
139 ret = -EINVAL;
140 }
141
142 if (ret < 0 && wdd->timeout)
143 pr_warn("%s: falling back to default timeout (%u)\n", dev_str,
144 wdd->timeout);
145
146 return ret;
147 }
148 EXPORT_SYMBOL_GPL(watchdog_init_timeout);
149
watchdog_restart_notifier(struct notifier_block * nb,unsigned long action,void * data)150 static int watchdog_restart_notifier(struct notifier_block *nb,
151 unsigned long action, void *data)
152 {
153 struct watchdog_device *wdd = container_of(nb, struct watchdog_device,
154 restart_nb);
155
156 int ret;
157
158 ret = wdd->ops->restart(wdd, action, data);
159 if (ret)
160 return NOTIFY_BAD;
161
162 return NOTIFY_DONE;
163 }
164
165 /**
166 * watchdog_set_restart_priority - Change priority of restart handler
167 * @wdd: watchdog device
168 * @priority: priority of the restart handler, should follow these guidelines:
169 * 0: use watchdog's restart function as last resort, has limited restart
170 * capabilies
171 * 128: default restart handler, use if no other handler is expected to be
172 * available and/or if restart is sufficient to restart the entire system
173 * 255: preempt all other handlers
174 *
175 * If a wdd->ops->restart function is provided when watchdog_register_device is
176 * called, it will be registered as a restart handler with the priority given
177 * here.
178 */
watchdog_set_restart_priority(struct watchdog_device * wdd,int priority)179 void watchdog_set_restart_priority(struct watchdog_device *wdd, int priority)
180 {
181 wdd->restart_nb.priority = priority;
182 }
183 EXPORT_SYMBOL_GPL(watchdog_set_restart_priority);
184
__watchdog_register_device(struct watchdog_device * wdd)185 static int __watchdog_register_device(struct watchdog_device *wdd)
186 {
187 int ret, id = -1;
188
189 if (wdd == NULL || wdd->info == NULL || wdd->ops == NULL)
190 return -EINVAL;
191
192 /* Mandatory operations need to be supported */
193 if (!wdd->ops->start || (!wdd->ops->stop && !wdd->max_hw_heartbeat_ms))
194 return -EINVAL;
195
196 watchdog_check_min_max_timeout(wdd);
197
198 /*
199 * Note: now that all watchdog_device data has been verified, we
200 * will not check this anymore in other functions. If data gets
201 * corrupted in a later stage then we expect a kernel panic!
202 */
203
204 /* Use alias for watchdog id if possible */
205 if (wdd->parent) {
206 ret = of_alias_get_id(wdd->parent->of_node, "watchdog");
207 if (ret >= 0)
208 id = ida_simple_get(&watchdog_ida, ret,
209 ret + 1, GFP_KERNEL);
210 }
211
212 if (id < 0)
213 id = ida_simple_get(&watchdog_ida, 0, MAX_DOGS, GFP_KERNEL);
214
215 if (id < 0)
216 return id;
217 wdd->id = id;
218
219 ret = watchdog_dev_register(wdd);
220 if (ret) {
221 ida_simple_remove(&watchdog_ida, id);
222 if (!(id == 0 && ret == -EBUSY))
223 return ret;
224
225 /* Retry in case a legacy watchdog module exists */
226 id = ida_simple_get(&watchdog_ida, 1, MAX_DOGS, GFP_KERNEL);
227 if (id < 0)
228 return id;
229 wdd->id = id;
230
231 ret = watchdog_dev_register(wdd);
232 if (ret) {
233 ida_simple_remove(&watchdog_ida, id);
234 return ret;
235 }
236 }
237
238 if (wdd->ops->restart) {
239 wdd->restart_nb.notifier_call = watchdog_restart_notifier;
240
241 ret = register_restart_handler(&wdd->restart_nb);
242 if (ret)
243 pr_warn("watchdog%d: Cannot register restart handler (%d)\n",
244 wdd->id, ret);
245 }
246
247 return 0;
248 }
249
250 /**
251 * watchdog_register_device() - register a watchdog device
252 * @wdd: watchdog device
253 *
254 * Register a watchdog device with the kernel so that the
255 * watchdog timer can be accessed from userspace.
256 *
257 * A zero is returned on success and a negative errno code for
258 * failure.
259 */
260
watchdog_register_device(struct watchdog_device * wdd)261 int watchdog_register_device(struct watchdog_device *wdd)
262 {
263 const char *dev_str;
264 int ret = 0;
265
266 mutex_lock(&wtd_deferred_reg_mutex);
267 if (wtd_deferred_reg_done)
268 ret = __watchdog_register_device(wdd);
269 else
270 watchdog_deferred_registration_add(wdd);
271 mutex_unlock(&wtd_deferred_reg_mutex);
272
273 if (ret) {
274 dev_str = wdd->parent ? dev_name(wdd->parent) :
275 (const char *)wdd->info->identity;
276 pr_err("%s: failed to register watchdog device (err = %d)\n",
277 dev_str, ret);
278 }
279
280 return ret;
281 }
282 EXPORT_SYMBOL_GPL(watchdog_register_device);
283
__watchdog_unregister_device(struct watchdog_device * wdd)284 static void __watchdog_unregister_device(struct watchdog_device *wdd)
285 {
286 if (wdd == NULL)
287 return;
288
289 if (wdd->ops->restart)
290 unregister_restart_handler(&wdd->restart_nb);
291
292 watchdog_dev_unregister(wdd);
293 ida_simple_remove(&watchdog_ida, wdd->id);
294 }
295
296 /**
297 * watchdog_unregister_device() - unregister a watchdog device
298 * @wdd: watchdog device to unregister
299 *
300 * Unregister a watchdog device that was previously successfully
301 * registered with watchdog_register_device().
302 */
303
watchdog_unregister_device(struct watchdog_device * wdd)304 void watchdog_unregister_device(struct watchdog_device *wdd)
305 {
306 mutex_lock(&wtd_deferred_reg_mutex);
307 if (wtd_deferred_reg_done)
308 __watchdog_unregister_device(wdd);
309 else
310 watchdog_deferred_registration_del(wdd);
311 mutex_unlock(&wtd_deferred_reg_mutex);
312 }
313
314 EXPORT_SYMBOL_GPL(watchdog_unregister_device);
315
devm_watchdog_unregister_device(struct device * dev,void * res)316 static void devm_watchdog_unregister_device(struct device *dev, void *res)
317 {
318 watchdog_unregister_device(*(struct watchdog_device **)res);
319 }
320
321 /**
322 * devm_watchdog_register_device() - resource managed watchdog_register_device()
323 * @dev: device that is registering this watchdog device
324 * @wdd: watchdog device
325 *
326 * Managed watchdog_register_device(). For watchdog device registered by this
327 * function, watchdog_unregister_device() is automatically called on driver
328 * detach. See watchdog_register_device() for more information.
329 */
devm_watchdog_register_device(struct device * dev,struct watchdog_device * wdd)330 int devm_watchdog_register_device(struct device *dev,
331 struct watchdog_device *wdd)
332 {
333 struct watchdog_device **rcwdd;
334 int ret;
335
336 rcwdd = devres_alloc(devm_watchdog_unregister_device, sizeof(*rcwdd),
337 GFP_KERNEL);
338 if (!rcwdd)
339 return -ENOMEM;
340
341 ret = watchdog_register_device(wdd);
342 if (!ret) {
343 *rcwdd = wdd;
344 devres_add(dev, rcwdd);
345 } else {
346 devres_free(rcwdd);
347 }
348
349 return ret;
350 }
351 EXPORT_SYMBOL_GPL(devm_watchdog_register_device);
352
watchdog_deferred_registration(void)353 static int __init watchdog_deferred_registration(void)
354 {
355 mutex_lock(&wtd_deferred_reg_mutex);
356 wtd_deferred_reg_done = true;
357 while (!list_empty(&wtd_deferred_reg_list)) {
358 struct watchdog_device *wdd;
359
360 wdd = list_first_entry(&wtd_deferred_reg_list,
361 struct watchdog_device, deferred);
362 list_del(&wdd->deferred);
363 __watchdog_register_device(wdd);
364 }
365 mutex_unlock(&wtd_deferred_reg_mutex);
366 return 0;
367 }
368
watchdog_init(void)369 static int __init watchdog_init(void)
370 {
371 int err;
372
373 err = watchdog_dev_init();
374 if (err < 0)
375 return err;
376
377 watchdog_deferred_registration();
378 return 0;
379 }
380
watchdog_exit(void)381 static void __exit watchdog_exit(void)
382 {
383 watchdog_dev_exit();
384 ida_destroy(&watchdog_ida);
385 }
386
387 subsys_initcall_sync(watchdog_init);
388 module_exit(watchdog_exit);
389
390 MODULE_AUTHOR("Alan Cox <alan@lxorguk.ukuu.org.uk>");
391 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
392 MODULE_DESCRIPTION("WatchDog Timer Driver Core");
393 MODULE_LICENSE("GPL");
394