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