1 // SPDX-License-Identifier: GPL-2.0-only
3 * Watchdog driver for z/VM and LPAR using the diag 288 interface.
5 * Under z/VM, expiration of the watchdog will send a "system restart" command
8 * The command can be altered using the module parameter "cmd". This is
9 * not recommended because it's only supported on z/VM but not whith LPAR.
11 * On LPAR, the watchdog will always trigger a system restart. the module
12 * paramter cmd is meaningless here.
15 * Copyright IBM Corp. 2004, 2013
16 * Author(s): Arnd Bergmann (arndb@de.ibm.com)
17 * Philipp Hachtmann (phacht@de.ibm.com)
21 #define KMSG_COMPONENT "diag288_wdt"
22 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
24 #include <linux/init.h>
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/slab.h>
29 #include <linux/miscdevice.h>
30 #include <linux/watchdog.h>
31 #include <linux/suspend.h>
32 #include <asm/ebcdic.h>
35 #include <linux/uaccess.h>
37 #define MAX_CMDLEN 240
38 #define DEFAULT_CMD "SYSTEM RESTART"
40 #define MIN_INTERVAL 15 /* Minimal time supported by diag88 */
41 #define MAX_INTERVAL 3600 /* One hour should be enough - pure estimation */
43 #define WDT_DEFAULT_TIMEOUT 30
45 /* Function codes - init, change, cancel */
46 #define WDT_FUNC_INIT 0
47 #define WDT_FUNC_CHANGE 1
48 #define WDT_FUNC_CANCEL 2
49 #define WDT_FUNC_CONCEAL 0x80000000
51 /* Action codes for LPAR watchdog */
52 #define LPARWDT_RESTART 0
54 static char wdt_cmd[MAX_CMDLEN] = DEFAULT_CMD;
55 static bool conceal_on;
56 static bool nowayout_info = WATCHDOG_NOWAYOUT;
58 MODULE_LICENSE("GPL");
59 MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");
60 MODULE_AUTHOR("Philipp Hachtmann <phacht@de.ibm.com>");
62 MODULE_DESCRIPTION("System z diag288 Watchdog Timer");
64 module_param_string(cmd, wdt_cmd, MAX_CMDLEN, 0644);
65 MODULE_PARM_DESC(cmd, "CP command that is run when the watchdog triggers (z/VM only)");
67 module_param_named(conceal, conceal_on, bool, 0644);
68 MODULE_PARM_DESC(conceal, "Enable the CONCEAL CP option while the watchdog is active (z/VM only)");
70 module_param_named(nowayout, nowayout_info, bool, 0444);
71 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default = CONFIG_WATCHDOG_NOWAYOUT)");
73 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
74 MODULE_ALIAS("vmwatchdog");
76 static int __diag288(unsigned int func, unsigned int timeout,
77 unsigned long action, unsigned int len)
79 register unsigned long __func asm("2") = func;
80 register unsigned long __timeout asm("3") = timeout;
81 register unsigned long __action asm("4") = action;
82 register unsigned long __len asm("5") = len;
87 " diag %1, %3, 0x288\n"
91 : "+d" (err) : "d"(__func), "d"(__timeout),
92 "d"(__action), "d"(__len) : "1", "cc");
96 static int __diag288_vm(unsigned int func, unsigned int timeout,
97 char *cmd, size_t len)
99 diag_stat_inc(DIAG_STAT_X288);
100 return __diag288(func, timeout, virt_to_phys(cmd), len);
103 static int __diag288_lpar(unsigned int func, unsigned int timeout,
104 unsigned long action)
106 diag_stat_inc(DIAG_STAT_X288);
107 return __diag288(func, timeout, action, 0);
110 static unsigned long wdt_status;
112 #define DIAG_WDOG_BUSY 0
114 static int wdt_start(struct watchdog_device *dev)
121 if (test_and_set_bit(DIAG_WDOG_BUSY, &wdt_status))
127 ebc_cmd = kmalloc(MAX_CMDLEN, GFP_KERNEL);
129 clear_bit(DIAG_WDOG_BUSY, &wdt_status);
132 len = strlcpy(ebc_cmd, wdt_cmd, MAX_CMDLEN);
133 ASCEBC(ebc_cmd, MAX_CMDLEN);
134 EBC_TOUPPER(ebc_cmd, MAX_CMDLEN);
136 func = conceal_on ? (WDT_FUNC_INIT | WDT_FUNC_CONCEAL)
138 ret = __diag288_vm(func, dev->timeout, ebc_cmd, len);
142 ret = __diag288_lpar(WDT_FUNC_INIT,
143 dev->timeout, LPARWDT_RESTART);
147 pr_err("The watchdog cannot be activated\n");
148 clear_bit(DIAG_WDOG_BUSY, &wdt_status);
154 static int wdt_stop(struct watchdog_device *dev)
158 diag_stat_inc(DIAG_STAT_X288);
159 ret = __diag288(WDT_FUNC_CANCEL, 0, 0, 0);
161 clear_bit(DIAG_WDOG_BUSY, &wdt_status);
166 static int wdt_ping(struct watchdog_device *dev)
176 ebc_cmd = kmalloc(MAX_CMDLEN, GFP_KERNEL);
179 len = strlcpy(ebc_cmd, wdt_cmd, MAX_CMDLEN);
180 ASCEBC(ebc_cmd, MAX_CMDLEN);
181 EBC_TOUPPER(ebc_cmd, MAX_CMDLEN);
184 * It seems to be ok to z/VM to use the init function to
185 * retrigger the watchdog. On LPAR WDT_FUNC_CHANGE must
186 * be used when the watchdog is running.
188 func = conceal_on ? (WDT_FUNC_INIT | WDT_FUNC_CONCEAL)
191 ret = __diag288_vm(func, dev->timeout, ebc_cmd, len);
195 ret = __diag288_lpar(WDT_FUNC_CHANGE, dev->timeout, 0);
199 pr_err("The watchdog timer cannot be started or reset\n");
203 static int wdt_set_timeout(struct watchdog_device * dev, unsigned int new_to)
205 dev->timeout = new_to;
206 return wdt_ping(dev);
209 static const struct watchdog_ops wdt_ops = {
210 .owner = THIS_MODULE,
214 .set_timeout = wdt_set_timeout,
217 static const struct watchdog_info wdt_info = {
218 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
219 .firmware_version = 0,
220 .identity = "z Watchdog",
223 static struct watchdog_device wdt_dev = {
228 .timeout = WDT_DEFAULT_TIMEOUT,
229 .min_timeout = MIN_INTERVAL,
230 .max_timeout = MAX_INTERVAL,
234 * It makes no sense to go into suspend while the watchdog is running.
235 * Depending on the memory size, the watchdog might trigger, while we
236 * are still saving the memory.
238 static int wdt_suspend(void)
240 if (test_and_set_bit(DIAG_WDOG_BUSY, &wdt_status)) {
241 pr_err("Linux cannot be suspended while the watchdog is in use\n");
242 return notifier_from_errno(-EBUSY);
247 static int wdt_resume(void)
249 clear_bit(DIAG_WDOG_BUSY, &wdt_status);
253 static int wdt_power_event(struct notifier_block *this, unsigned long event,
257 case PM_POST_HIBERNATION:
258 case PM_POST_SUSPEND:
260 case PM_HIBERNATION_PREPARE:
261 case PM_SUSPEND_PREPARE:
262 return wdt_suspend();
268 static struct notifier_block wdt_power_notifier = {
269 .notifier_call = wdt_power_event,
272 static int __init diag288_init(void)
276 194, 197, 199, 201, 213
279 watchdog_set_nowayout(&wdt_dev, nowayout_info);
282 if (__diag288_vm(WDT_FUNC_INIT, 15,
283 ebc_begin, sizeof(ebc_begin)) != 0) {
284 pr_err("The watchdog cannot be initialized\n");
288 if (__diag288_lpar(WDT_FUNC_INIT, 30, LPARWDT_RESTART)) {
289 pr_err("The watchdog cannot be initialized\n");
294 if (__diag288_lpar(WDT_FUNC_CANCEL, 0, 0)) {
295 pr_err("The watchdog cannot be deactivated\n");
299 ret = register_pm_notifier(&wdt_power_notifier);
303 ret = watchdog_register_device(&wdt_dev);
305 unregister_pm_notifier(&wdt_power_notifier);
310 static void __exit diag288_exit(void)
312 watchdog_unregister_device(&wdt_dev);
313 unregister_pm_notifier(&wdt_power_notifier);
316 module_init(diag288_init);
317 module_exit(diag288_exit);