1 // SPDX-License-Identifier: GPL-2.0+
5 * (c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>,
8 * (c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>.
10 * This source code is part of the generic code that can be used
11 * by all the watchdog timer drivers.
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>
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.
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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 #include <linux/suspend.h>
39 #include "watchdog_core.h" /* For watchdog_dev_register/... */
41 static DEFINE_IDA(watchdog_ida
);
43 static int stop_on_reboot
= -1;
44 module_param(stop_on_reboot
, int, 0444);
45 MODULE_PARM_DESC(stop_on_reboot
, "Stop watchdogs on reboot (0=keep watching, 1=stop)");
48 * Deferred Registration infrastructure.
50 * Sometimes watchdog drivers needs to be loaded as soon as possible,
51 * for example when it's impossible to disable it. To do so,
52 * raising the initcall level of the watchdog driver is a solution.
53 * But in such case, the miscdev is maybe not ready (subsys_initcall), and
54 * watchdog_core need miscdev to register the watchdog as a char device.
56 * The deferred registration infrastructure offer a way for the watchdog
57 * subsystem to register a watchdog properly, even before miscdev is ready.
60 static DEFINE_MUTEX(wtd_deferred_reg_mutex
);
61 static LIST_HEAD(wtd_deferred_reg_list
);
62 static bool wtd_deferred_reg_done
;
64 static void watchdog_deferred_registration_add(struct watchdog_device
*wdd
)
66 list_add_tail(&wdd
->deferred
,
67 &wtd_deferred_reg_list
);
70 static void watchdog_deferred_registration_del(struct watchdog_device
*wdd
)
72 struct list_head
*p
, *n
;
73 struct watchdog_device
*wdd_tmp
;
75 list_for_each_safe(p
, n
, &wtd_deferred_reg_list
) {
76 wdd_tmp
= list_entry(p
, struct watchdog_device
,
79 list_del(&wdd_tmp
->deferred
);
85 static void watchdog_check_min_max_timeout(struct watchdog_device
*wdd
)
88 * Check that we have valid min and max timeout values, if
89 * not reset them both to 0 (=not used or unknown)
91 if (!wdd
->max_hw_heartbeat_ms
&& wdd
->min_timeout
> wdd
->max_timeout
) {
92 pr_info("Invalid min and max timeout values, resetting to 0!\n");
99 * watchdog_init_timeout() - initialize the timeout field
100 * @wdd: watchdog device
101 * @timeout_parm: timeout module parameter
102 * @dev: Device that stores the timeout-sec property
104 * Initialize the timeout field of the watchdog_device struct with either the
105 * timeout module parameter (if it is valid value) or the timeout-sec property
106 * (only if it is a valid value and the timeout_parm is out of bounds).
107 * If none of them are valid then we keep the old value (which should normally
108 * be the default timeout value). Note that for the module parameter, '0' means
109 * 'use default' while it is an invalid value for the timeout-sec property.
110 * It should simply be dropped if you want to use the default value then.
112 * A zero is returned on success or -EINVAL if all provided values are out of
115 int watchdog_init_timeout(struct watchdog_device
*wdd
,
116 unsigned int timeout_parm
, struct device
*dev
)
118 const char *dev_str
= wdd
->parent
? dev_name(wdd
->parent
) :
119 (const char *)wdd
->info
->identity
;
123 watchdog_check_min_max_timeout(wdd
);
125 /* check the driver supplied value (likely a module parameter) first */
127 if (!watchdog_timeout_invalid(wdd
, timeout_parm
)) {
128 wdd
->timeout
= timeout_parm
;
131 pr_err("%s: driver supplied timeout (%u) out of range\n",
132 dev_str
, timeout_parm
);
136 /* try to get the timeout_sec property */
137 if (dev
&& dev
->of_node
&&
138 of_property_read_u32(dev
->of_node
, "timeout-sec", &t
) == 0) {
139 if (t
&& !watchdog_timeout_invalid(wdd
, t
)) {
143 pr_err("%s: DT supplied timeout (%u) out of range\n", dev_str
, t
);
147 if (ret
< 0 && wdd
->timeout
)
148 pr_warn("%s: falling back to default timeout (%u)\n", dev_str
,
153 EXPORT_SYMBOL_GPL(watchdog_init_timeout
);
155 static int watchdog_reboot_notifier(struct notifier_block
*nb
,
156 unsigned long code
, void *data
)
158 struct watchdog_device
*wdd
;
160 wdd
= container_of(nb
, struct watchdog_device
, reboot_nb
);
161 if (code
== SYS_DOWN
|| code
== SYS_HALT
) {
162 if (watchdog_active(wdd
) || watchdog_hw_running(wdd
)) {
165 ret
= wdd
->ops
->stop(wdd
);
174 static int watchdog_restart_notifier(struct notifier_block
*nb
,
175 unsigned long action
, void *data
)
177 struct watchdog_device
*wdd
= container_of(nb
, struct watchdog_device
,
182 ret
= wdd
->ops
->restart(wdd
, action
, data
);
189 static int watchdog_pm_notifier(struct notifier_block
*nb
, unsigned long mode
,
192 struct watchdog_device
*wdd
;
195 wdd
= container_of(nb
, struct watchdog_device
, pm_nb
);
198 case PM_HIBERNATION_PREPARE
:
199 case PM_RESTORE_PREPARE
:
200 case PM_SUSPEND_PREPARE
:
201 ret
= watchdog_dev_suspend(wdd
);
203 case PM_POST_HIBERNATION
:
204 case PM_POST_RESTORE
:
205 case PM_POST_SUSPEND
:
206 ret
= watchdog_dev_resume(wdd
);
217 * watchdog_set_restart_priority - Change priority of restart handler
218 * @wdd: watchdog device
219 * @priority: priority of the restart handler, should follow these guidelines:
220 * 0: use watchdog's restart function as last resort, has limited restart
222 * 128: default restart handler, use if no other handler is expected to be
223 * available and/or if restart is sufficient to restart the entire system
224 * 255: preempt all other handlers
226 * If a wdd->ops->restart function is provided when watchdog_register_device is
227 * called, it will be registered as a restart handler with the priority given
230 void watchdog_set_restart_priority(struct watchdog_device
*wdd
, int priority
)
232 wdd
->restart_nb
.priority
= priority
;
234 EXPORT_SYMBOL_GPL(watchdog_set_restart_priority
);
236 static int __watchdog_register_device(struct watchdog_device
*wdd
)
240 if (wdd
== NULL
|| wdd
->info
== NULL
|| wdd
->ops
== NULL
)
243 /* Mandatory operations need to be supported */
244 if (!wdd
->ops
->start
|| (!wdd
->ops
->stop
&& !wdd
->max_hw_heartbeat_ms
))
247 watchdog_check_min_max_timeout(wdd
);
250 * Note: now that all watchdog_device data has been verified, we
251 * will not check this anymore in other functions. If data gets
252 * corrupted in a later stage then we expect a kernel panic!
255 /* Use alias for watchdog id if possible */
257 ret
= of_alias_get_id(wdd
->parent
->of_node
, "watchdog");
259 id
= ida_simple_get(&watchdog_ida
, ret
,
260 ret
+ 1, GFP_KERNEL
);
264 id
= ida_simple_get(&watchdog_ida
, 0, MAX_DOGS
, GFP_KERNEL
);
270 ret
= watchdog_dev_register(wdd
);
272 ida_simple_remove(&watchdog_ida
, id
);
273 if (!(id
== 0 && ret
== -EBUSY
))
276 /* Retry in case a legacy watchdog module exists */
277 id
= ida_simple_get(&watchdog_ida
, 1, MAX_DOGS
, GFP_KERNEL
);
282 ret
= watchdog_dev_register(wdd
);
284 ida_simple_remove(&watchdog_ida
, id
);
289 /* Module parameter to force watchdog policy on reboot. */
290 if (stop_on_reboot
!= -1) {
292 set_bit(WDOG_STOP_ON_REBOOT
, &wdd
->status
);
294 clear_bit(WDOG_STOP_ON_REBOOT
, &wdd
->status
);
297 if (test_bit(WDOG_STOP_ON_REBOOT
, &wdd
->status
)) {
299 pr_warn("watchdog%d: stop_on_reboot not supported\n", wdd
->id
);
301 wdd
->reboot_nb
.notifier_call
= watchdog_reboot_notifier
;
303 ret
= register_reboot_notifier(&wdd
->reboot_nb
);
305 pr_err("watchdog%d: Cannot register reboot notifier (%d)\n",
307 watchdog_dev_unregister(wdd
);
308 ida_simple_remove(&watchdog_ida
, id
);
314 if (wdd
->ops
->restart
) {
315 wdd
->restart_nb
.notifier_call
= watchdog_restart_notifier
;
317 ret
= register_restart_handler(&wdd
->restart_nb
);
319 pr_warn("watchdog%d: Cannot register restart handler (%d)\n",
323 if (test_bit(WDOG_NO_PING_ON_SUSPEND
, &wdd
->status
)) {
324 wdd
->pm_nb
.notifier_call
= watchdog_pm_notifier
;
326 ret
= register_pm_notifier(&wdd
->pm_nb
);
328 pr_warn("watchdog%d: Cannot register pm handler (%d)\n",
336 * watchdog_register_device() - register a watchdog device
337 * @wdd: watchdog device
339 * Register a watchdog device with the kernel so that the
340 * watchdog timer can be accessed from userspace.
342 * A zero is returned on success and a negative errno code for
346 int watchdog_register_device(struct watchdog_device
*wdd
)
351 mutex_lock(&wtd_deferred_reg_mutex
);
352 if (wtd_deferred_reg_done
)
353 ret
= __watchdog_register_device(wdd
);
355 watchdog_deferred_registration_add(wdd
);
356 mutex_unlock(&wtd_deferred_reg_mutex
);
359 dev_str
= wdd
->parent
? dev_name(wdd
->parent
) :
360 (const char *)wdd
->info
->identity
;
361 pr_err("%s: failed to register watchdog device (err = %d)\n",
367 EXPORT_SYMBOL_GPL(watchdog_register_device
);
369 static void __watchdog_unregister_device(struct watchdog_device
*wdd
)
374 if (wdd
->ops
->restart
)
375 unregister_restart_handler(&wdd
->restart_nb
);
377 if (test_bit(WDOG_STOP_ON_REBOOT
, &wdd
->status
))
378 unregister_reboot_notifier(&wdd
->reboot_nb
);
380 watchdog_dev_unregister(wdd
);
381 ida_simple_remove(&watchdog_ida
, wdd
->id
);
385 * watchdog_unregister_device() - unregister a watchdog device
386 * @wdd: watchdog device to unregister
388 * Unregister a watchdog device that was previously successfully
389 * registered with watchdog_register_device().
392 void watchdog_unregister_device(struct watchdog_device
*wdd
)
394 mutex_lock(&wtd_deferred_reg_mutex
);
395 if (wtd_deferred_reg_done
)
396 __watchdog_unregister_device(wdd
);
398 watchdog_deferred_registration_del(wdd
);
399 mutex_unlock(&wtd_deferred_reg_mutex
);
402 EXPORT_SYMBOL_GPL(watchdog_unregister_device
);
404 static void devm_watchdog_unregister_device(struct device
*dev
, void *res
)
406 watchdog_unregister_device(*(struct watchdog_device
**)res
);
410 * devm_watchdog_register_device() - resource managed watchdog_register_device()
411 * @dev: device that is registering this watchdog device
412 * @wdd: watchdog device
414 * Managed watchdog_register_device(). For watchdog device registered by this
415 * function, watchdog_unregister_device() is automatically called on driver
416 * detach. See watchdog_register_device() for more information.
418 int devm_watchdog_register_device(struct device
*dev
,
419 struct watchdog_device
*wdd
)
421 struct watchdog_device
**rcwdd
;
424 rcwdd
= devres_alloc(devm_watchdog_unregister_device
, sizeof(*rcwdd
),
429 ret
= watchdog_register_device(wdd
);
432 devres_add(dev
, rcwdd
);
439 EXPORT_SYMBOL_GPL(devm_watchdog_register_device
);
441 static int __init
watchdog_deferred_registration(void)
443 mutex_lock(&wtd_deferred_reg_mutex
);
444 wtd_deferred_reg_done
= true;
445 while (!list_empty(&wtd_deferred_reg_list
)) {
446 struct watchdog_device
*wdd
;
448 wdd
= list_first_entry(&wtd_deferred_reg_list
,
449 struct watchdog_device
, deferred
);
450 list_del(&wdd
->deferred
);
451 __watchdog_register_device(wdd
);
453 mutex_unlock(&wtd_deferred_reg_mutex
);
457 static int __init
watchdog_init(void)
461 err
= watchdog_dev_init();
465 watchdog_deferred_registration();
469 static void __exit
watchdog_exit(void)
472 ida_destroy(&watchdog_ida
);
475 subsys_initcall_sync(watchdog_init
);
476 module_exit(watchdog_exit
);
478 MODULE_AUTHOR("Alan Cox <alan@lxorguk.ukuu.org.uk>");
479 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
480 MODULE_DESCRIPTION("WatchDog Timer Driver Core");
481 MODULE_LICENSE("GPL");