Commit | Line | Data |
---|---|---|
09c434b8 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
f7a94db4 | 2 | /* |
646f919e | 3 | * Watchdog driver for z/VM and LPAR using the diag 288 interface. |
f7a94db4 PH |
4 | * |
5 | * Under z/VM, expiration of the watchdog will send a "system restart" command | |
6 | * to CP. | |
7 | * | |
646f919e PH |
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. | |
10 | * | |
11 | * On LPAR, the watchdog will always trigger a system restart. the module | |
12 | * paramter cmd is meaningless here. | |
13 | * | |
f7a94db4 PH |
14 | * |
15 | * Copyright IBM Corp. 2004, 2013 | |
16 | * Author(s): Arnd Bergmann (arndb@de.ibm.com) | |
17 | * Philipp Hachtmann (phacht@de.ibm.com) | |
18 | * | |
19 | */ | |
20 | ||
21 | #define KMSG_COMPONENT "diag288_wdt" | |
22 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | |
23 | ||
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> | |
1ec2772e | 33 | #include <asm/diag.h> |
f7a94db4 PH |
34 | #include <linux/io.h> |
35 | #include <linux/uaccess.h> | |
36 | ||
37 | #define MAX_CMDLEN 240 | |
38 | #define DEFAULT_CMD "SYSTEM RESTART" | |
39 | ||
40 | #define MIN_INTERVAL 15 /* Minimal time supported by diag88 */ | |
41 | #define MAX_INTERVAL 3600 /* One hour should be enough - pure estimation */ | |
42 | ||
43 | #define WDT_DEFAULT_TIMEOUT 30 | |
44 | ||
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 | |
50 | ||
646f919e PH |
51 | /* Action codes for LPAR watchdog */ |
52 | #define LPARWDT_RESTART 0 | |
53 | ||
f7a94db4 PH |
54 | static char wdt_cmd[MAX_CMDLEN] = DEFAULT_CMD; |
55 | static bool conceal_on; | |
56 | static bool nowayout_info = WATCHDOG_NOWAYOUT; | |
57 | ||
58 | MODULE_LICENSE("GPL"); | |
59 | MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>"); | |
60 | MODULE_AUTHOR("Philipp Hachtmann <phacht@de.ibm.com>"); | |
61 | ||
62 | MODULE_DESCRIPTION("System z diag288 Watchdog Timer"); | |
63 | ||
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)"); | |
66 | ||
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)"); | |
69 | ||
70 | module_param_named(nowayout, nowayout_info, bool, 0444); | |
71 | MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default = CONFIG_WATCHDOG_NOWAYOUT)"); | |
72 | ||
73 | MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); | |
74 | MODULE_ALIAS("vmwatchdog"); | |
75 | ||
76 | static int __diag288(unsigned int func, unsigned int timeout, | |
77 | unsigned long action, unsigned int len) | |
78 | { | |
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; | |
83 | int err; | |
84 | ||
85 | err = -EINVAL; | |
86 | asm volatile( | |
87 | " diag %1, %3, 0x288\n" | |
88 | "0: la %0, 0\n" | |
89 | "1:\n" | |
90 | EX_TABLE(0b, 1b) | |
91 | : "+d" (err) : "d"(__func), "d"(__timeout), | |
92 | "d"(__action), "d"(__len) : "1", "cc"); | |
93 | return err; | |
94 | } | |
95 | ||
96 | static int __diag288_vm(unsigned int func, unsigned int timeout, | |
97 | char *cmd, size_t len) | |
98 | { | |
1ec2772e | 99 | diag_stat_inc(DIAG_STAT_X288); |
f7a94db4 PH |
100 | return __diag288(func, timeout, virt_to_phys(cmd), len); |
101 | } | |
102 | ||
646f919e PH |
103 | static int __diag288_lpar(unsigned int func, unsigned int timeout, |
104 | unsigned long action) | |
105 | { | |
1ec2772e | 106 | diag_stat_inc(DIAG_STAT_X288); |
646f919e PH |
107 | return __diag288(func, timeout, action, 0); |
108 | } | |
109 | ||
e7d162fa GR |
110 | static unsigned long wdt_status; |
111 | ||
112 | #define DIAG_WDOG_BUSY 0 | |
113 | ||
f7a94db4 PH |
114 | static int wdt_start(struct watchdog_device *dev) |
115 | { | |
116 | char *ebc_cmd; | |
117 | size_t len; | |
118 | int ret; | |
119 | unsigned int func; | |
120 | ||
e7d162fa GR |
121 | if (test_and_set_bit(DIAG_WDOG_BUSY, &wdt_status)) |
122 | return -EBUSY; | |
123 | ||
f7a94db4 PH |
124 | ret = -ENODEV; |
125 | ||
126 | if (MACHINE_IS_VM) { | |
127 | ebc_cmd = kmalloc(MAX_CMDLEN, GFP_KERNEL); | |
e7d162fa GR |
128 | if (!ebc_cmd) { |
129 | clear_bit(DIAG_WDOG_BUSY, &wdt_status); | |
f7a94db4 | 130 | return -ENOMEM; |
e7d162fa | 131 | } |
f7a94db4 PH |
132 | len = strlcpy(ebc_cmd, wdt_cmd, MAX_CMDLEN); |
133 | ASCEBC(ebc_cmd, MAX_CMDLEN); | |
134 | EBC_TOUPPER(ebc_cmd, MAX_CMDLEN); | |
135 | ||
136 | func = conceal_on ? (WDT_FUNC_INIT | WDT_FUNC_CONCEAL) | |
137 | : WDT_FUNC_INIT; | |
138 | ret = __diag288_vm(func, dev->timeout, ebc_cmd, len); | |
139 | WARN_ON(ret != 0); | |
140 | kfree(ebc_cmd); | |
b2527d20 | 141 | } else { |
646f919e PH |
142 | ret = __diag288_lpar(WDT_FUNC_INIT, |
143 | dev->timeout, LPARWDT_RESTART); | |
144 | } | |
145 | ||
f7a94db4 PH |
146 | if (ret) { |
147 | pr_err("The watchdog cannot be activated\n"); | |
e7d162fa | 148 | clear_bit(DIAG_WDOG_BUSY, &wdt_status); |
f7a94db4 PH |
149 | return ret; |
150 | } | |
f7a94db4 PH |
151 | return 0; |
152 | } | |
153 | ||
154 | static int wdt_stop(struct watchdog_device *dev) | |
155 | { | |
156 | int ret; | |
157 | ||
1ec2772e | 158 | diag_stat_inc(DIAG_STAT_X288); |
f7a94db4 | 159 | ret = __diag288(WDT_FUNC_CANCEL, 0, 0, 0); |
e7d162fa GR |
160 | |
161 | clear_bit(DIAG_WDOG_BUSY, &wdt_status); | |
162 | ||
f7a94db4 PH |
163 | return ret; |
164 | } | |
165 | ||
166 | static int wdt_ping(struct watchdog_device *dev) | |
167 | { | |
168 | char *ebc_cmd; | |
169 | size_t len; | |
170 | int ret; | |
171 | unsigned int func; | |
172 | ||
173 | ret = -ENODEV; | |
174 | ||
175 | if (MACHINE_IS_VM) { | |
176 | ebc_cmd = kmalloc(MAX_CMDLEN, GFP_KERNEL); | |
177 | if (!ebc_cmd) | |
178 | return -ENOMEM; | |
179 | len = strlcpy(ebc_cmd, wdt_cmd, MAX_CMDLEN); | |
180 | ASCEBC(ebc_cmd, MAX_CMDLEN); | |
181 | EBC_TOUPPER(ebc_cmd, MAX_CMDLEN); | |
182 | ||
183 | /* | |
184 | * It seems to be ok to z/VM to use the init function to | |
646f919e PH |
185 | * retrigger the watchdog. On LPAR WDT_FUNC_CHANGE must |
186 | * be used when the watchdog is running. | |
f7a94db4 PH |
187 | */ |
188 | func = conceal_on ? (WDT_FUNC_INIT | WDT_FUNC_CONCEAL) | |
189 | : WDT_FUNC_INIT; | |
190 | ||
191 | ret = __diag288_vm(func, dev->timeout, ebc_cmd, len); | |
192 | WARN_ON(ret != 0); | |
193 | kfree(ebc_cmd); | |
b2527d20 | 194 | } else { |
646f919e | 195 | ret = __diag288_lpar(WDT_FUNC_CHANGE, dev->timeout, 0); |
b2527d20 | 196 | } |
646f919e | 197 | |
f7a94db4 PH |
198 | if (ret) |
199 | pr_err("The watchdog timer cannot be started or reset\n"); | |
200 | return ret; | |
201 | } | |
202 | ||
203 | static int wdt_set_timeout(struct watchdog_device * dev, unsigned int new_to) | |
204 | { | |
205 | dev->timeout = new_to; | |
206 | return wdt_ping(dev); | |
207 | } | |
208 | ||
b893e344 | 209 | static const struct watchdog_ops wdt_ops = { |
f7a94db4 PH |
210 | .owner = THIS_MODULE, |
211 | .start = wdt_start, | |
212 | .stop = wdt_stop, | |
213 | .ping = wdt_ping, | |
214 | .set_timeout = wdt_set_timeout, | |
215 | }; | |
216 | ||
323edb2e | 217 | static const struct watchdog_info wdt_info = { |
9ec6cb80 | 218 | .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, |
f7a94db4 PH |
219 | .firmware_version = 0, |
220 | .identity = "z Watchdog", | |
221 | }; | |
222 | ||
223 | static struct watchdog_device wdt_dev = { | |
224 | .parent = NULL, | |
225 | .info = &wdt_info, | |
226 | .ops = &wdt_ops, | |
227 | .bootstatus = 0, | |
228 | .timeout = WDT_DEFAULT_TIMEOUT, | |
229 | .min_timeout = MIN_INTERVAL, | |
230 | .max_timeout = MAX_INTERVAL, | |
231 | }; | |
232 | ||
233 | /* | |
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. | |
f7a94db4 PH |
237 | */ |
238 | static int wdt_suspend(void) | |
239 | { | |
e7d162fa | 240 | if (test_and_set_bit(DIAG_WDOG_BUSY, &wdt_status)) { |
f7a94db4 PH |
241 | pr_err("Linux cannot be suspended while the watchdog is in use\n"); |
242 | return notifier_from_errno(-EBUSY); | |
243 | } | |
244 | return NOTIFY_DONE; | |
245 | } | |
246 | ||
247 | static int wdt_resume(void) | |
248 | { | |
e7d162fa | 249 | clear_bit(DIAG_WDOG_BUSY, &wdt_status); |
f7a94db4 PH |
250 | return NOTIFY_DONE; |
251 | } | |
252 | ||
253 | static int wdt_power_event(struct notifier_block *this, unsigned long event, | |
254 | void *ptr) | |
255 | { | |
256 | switch (event) { | |
257 | case PM_POST_HIBERNATION: | |
258 | case PM_POST_SUSPEND: | |
259 | return wdt_resume(); | |
260 | case PM_HIBERNATION_PREPARE: | |
261 | case PM_SUSPEND_PREPARE: | |
262 | return wdt_suspend(); | |
263 | default: | |
264 | return NOTIFY_DONE; | |
265 | } | |
266 | } | |
267 | ||
268 | static struct notifier_block wdt_power_notifier = { | |
269 | .notifier_call = wdt_power_event, | |
270 | }; | |
271 | ||
272 | static int __init diag288_init(void) | |
273 | { | |
274 | int ret; | |
275 | char ebc_begin[] = { | |
276 | 194, 197, 199, 201, 213 | |
277 | }; | |
278 | ||
279 | watchdog_set_nowayout(&wdt_dev, nowayout_info); | |
280 | ||
281 | if (MACHINE_IS_VM) { | |
f7a94db4 PH |
282 | if (__diag288_vm(WDT_FUNC_INIT, 15, |
283 | ebc_begin, sizeof(ebc_begin)) != 0) { | |
284 | pr_err("The watchdog cannot be initialized\n"); | |
285 | return -EINVAL; | |
286 | } | |
b2527d20 | 287 | } else { |
646f919e PH |
288 | if (__diag288_lpar(WDT_FUNC_INIT, 30, LPARWDT_RESTART)) { |
289 | pr_err("The watchdog cannot be initialized\n"); | |
290 | return -EINVAL; | |
291 | } | |
f7a94db4 PH |
292 | } |
293 | ||
646f919e | 294 | if (__diag288_lpar(WDT_FUNC_CANCEL, 0, 0)) { |
f7a94db4 PH |
295 | pr_err("The watchdog cannot be deactivated\n"); |
296 | return -EINVAL; | |
297 | } | |
298 | ||
299 | ret = register_pm_notifier(&wdt_power_notifier); | |
300 | if (ret) | |
301 | return ret; | |
302 | ||
303 | ret = watchdog_register_device(&wdt_dev); | |
304 | if (ret) | |
305 | unregister_pm_notifier(&wdt_power_notifier); | |
306 | ||
307 | return ret; | |
308 | } | |
309 | ||
310 | static void __exit diag288_exit(void) | |
311 | { | |
312 | watchdog_unregister_device(&wdt_dev); | |
313 | unregister_pm_notifier(&wdt_power_notifier); | |
314 | } | |
315 | ||
316 | module_init(diag288_init); | |
317 | module_exit(diag288_exit); |