1/*
2 * Watchdog driver for Atmel AT91RM9200 (Thunder)
3 *
4 *  Copyright (C) 2003 SAN People (Pty) Ltd
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14#include <linux/bitops.h>
15#include <linux/delay.h>
16#include <linux/errno.h>
17#include <linux/fs.h>
18#include <linux/init.h>
19#include <linux/io.h>
20#include <linux/kernel.h>
21#include <linux/mfd/syscon.h>
22#include <linux/mfd/syscon/atmel-st.h>
23#include <linux/miscdevice.h>
24#include <linux/module.h>
25#include <linux/moduleparam.h>
26#include <linux/platform_device.h>
27#include <linux/reboot.h>
28#include <linux/regmap.h>
29#include <linux/types.h>
30#include <linux/watchdog.h>
31#include <linux/uaccess.h>
32#include <linux/of.h>
33#include <linux/of_device.h>
34
35#define WDT_DEFAULT_TIME	5	/* seconds */
36#define WDT_MAX_TIME		256	/* seconds */
37
38static int wdt_time = WDT_DEFAULT_TIME;
39static bool nowayout = WATCHDOG_NOWAYOUT;
40static struct regmap *regmap_st;
41
42module_param(wdt_time, int, 0);
43MODULE_PARM_DESC(wdt_time, "Watchdog time in seconds. (default="
44				__MODULE_STRING(WDT_DEFAULT_TIME) ")");
45
46#ifdef CONFIG_WATCHDOG_NOWAYOUT
47module_param(nowayout, bool, 0);
48MODULE_PARM_DESC(nowayout,
49		"Watchdog cannot be stopped once started (default="
50				__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
51#endif
52
53
54static unsigned long at91wdt_busy;
55
56/* ......................................................................... */
57
58static int at91rm9200_restart(struct notifier_block *this,
59					unsigned long mode, void *cmd)
60{
61	/*
62	 * Perform a hardware reset with the use of the Watchdog timer.
63	 */
64	regmap_write(regmap_st, AT91_ST_WDMR,
65		     AT91_ST_RSTEN | AT91_ST_EXTEN | 1);
66	regmap_write(regmap_st, AT91_ST_CR, AT91_ST_WDRST);
67
68	mdelay(2000);
69
70	pr_emerg("Unable to restart system\n");
71	return NOTIFY_DONE;
72}
73
74static struct notifier_block at91rm9200_restart_nb = {
75	.notifier_call = at91rm9200_restart,
76	.priority = 192,
77};
78
79/*
80 * Disable the watchdog.
81 */
82static inline void at91_wdt_stop(void)
83{
84	regmap_write(regmap_st, AT91_ST_WDMR, AT91_ST_EXTEN);
85}
86
87/*
88 * Enable and reset the watchdog.
89 */
90static inline void at91_wdt_start(void)
91{
92	regmap_write(regmap_st, AT91_ST_WDMR, AT91_ST_EXTEN | AT91_ST_RSTEN |
93				(((65536 * wdt_time) >> 8) & AT91_ST_WDV));
94	regmap_write(regmap_st, AT91_ST_CR, AT91_ST_WDRST);
95}
96
97/*
98 * Reload the watchdog timer.  (ie, pat the watchdog)
99 */
100static inline void at91_wdt_reload(void)
101{
102	regmap_write(regmap_st, AT91_ST_CR, AT91_ST_WDRST);
103}
104
105/* ......................................................................... */
106
107/*
108 * Watchdog device is opened, and watchdog starts running.
109 */
110static int at91_wdt_open(struct inode *inode, struct file *file)
111{
112	if (test_and_set_bit(0, &at91wdt_busy))
113		return -EBUSY;
114
115	at91_wdt_start();
116	return nonseekable_open(inode, file);
117}
118
119/*
120 * Close the watchdog device.
121 * If CONFIG_WATCHDOG_NOWAYOUT is NOT defined then the watchdog is also
122 *  disabled.
123 */
124static int at91_wdt_close(struct inode *inode, struct file *file)
125{
126	/* Disable the watchdog when file is closed */
127	if (!nowayout)
128		at91_wdt_stop();
129
130	clear_bit(0, &at91wdt_busy);
131	return 0;
132}
133
134/*
135 * Change the watchdog time interval.
136 */
137static int at91_wdt_settimeout(int new_time)
138{
139	/*
140	 * All counting occurs at SLOW_CLOCK / 128 = 256 Hz
141	 *
142	 * Since WDV is a 16-bit counter, the maximum period is
143	 * 65536 / 256 = 256 seconds.
144	 */
145	if ((new_time <= 0) || (new_time > WDT_MAX_TIME))
146		return -EINVAL;
147
148	/* Set new watchdog time. It will be used when
149	   at91_wdt_start() is called. */
150	wdt_time = new_time;
151	return 0;
152}
153
154static const struct watchdog_info at91_wdt_info = {
155	.identity	= "at91 watchdog",
156	.options	= WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
157};
158
159/*
160 * Handle commands from user-space.
161 */
162static long at91_wdt_ioctl(struct file *file,
163					unsigned int cmd, unsigned long arg)
164{
165	void __user *argp = (void __user *)arg;
166	int __user *p = argp;
167	int new_value;
168
169	switch (cmd) {
170	case WDIOC_GETSUPPORT:
171		return copy_to_user(argp, &at91_wdt_info,
172				sizeof(at91_wdt_info)) ? -EFAULT : 0;
173	case WDIOC_GETSTATUS:
174	case WDIOC_GETBOOTSTATUS:
175		return put_user(0, p);
176	case WDIOC_SETOPTIONS:
177		if (get_user(new_value, p))
178			return -EFAULT;
179		if (new_value & WDIOS_DISABLECARD)
180			at91_wdt_stop();
181		if (new_value & WDIOS_ENABLECARD)
182			at91_wdt_start();
183		return 0;
184	case WDIOC_KEEPALIVE:
185		at91_wdt_reload();	/* pat the watchdog */
186		return 0;
187	case WDIOC_SETTIMEOUT:
188		if (get_user(new_value, p))
189			return -EFAULT;
190		if (at91_wdt_settimeout(new_value))
191			return -EINVAL;
192		/* Enable new time value */
193		at91_wdt_start();
194		/* Return current value */
195		return put_user(wdt_time, p);
196	case WDIOC_GETTIMEOUT:
197		return put_user(wdt_time, p);
198	default:
199		return -ENOTTY;
200	}
201}
202
203/*
204 * Pat the watchdog whenever device is written to.
205 */
206static ssize_t at91_wdt_write(struct file *file, const char *data,
207						size_t len, loff_t *ppos)
208{
209	at91_wdt_reload();		/* pat the watchdog */
210	return len;
211}
212
213/* ......................................................................... */
214
215static const struct file_operations at91wdt_fops = {
216	.owner		= THIS_MODULE,
217	.llseek		= no_llseek,
218	.unlocked_ioctl	= at91_wdt_ioctl,
219	.open		= at91_wdt_open,
220	.release	= at91_wdt_close,
221	.write		= at91_wdt_write,
222};
223
224static struct miscdevice at91wdt_miscdev = {
225	.minor		= WATCHDOG_MINOR,
226	.name		= "watchdog",
227	.fops		= &at91wdt_fops,
228};
229
230static int at91wdt_probe(struct platform_device *pdev)
231{
232	struct device *dev = &pdev->dev;
233	struct device *parent;
234	int res;
235
236	if (at91wdt_miscdev.parent)
237		return -EBUSY;
238	at91wdt_miscdev.parent = &pdev->dev;
239
240	parent = dev->parent;
241	if (!parent) {
242		dev_err(dev, "no parent\n");
243		return -ENODEV;
244	}
245
246	regmap_st = syscon_node_to_regmap(parent->of_node);
247	if (!regmap_st)
248		return -ENODEV;
249
250	res = misc_register(&at91wdt_miscdev);
251	if (res)
252		return res;
253
254	res = register_restart_handler(&at91rm9200_restart_nb);
255	if (res)
256		dev_warn(dev, "failed to register restart handler\n");
257
258	pr_info("AT91 Watchdog Timer enabled (%d seconds%s)\n",
259		wdt_time, nowayout ? ", nowayout" : "");
260	return 0;
261}
262
263static int at91wdt_remove(struct platform_device *pdev)
264{
265	struct device *dev = &pdev->dev;
266	int res;
267
268	res = unregister_restart_handler(&at91rm9200_restart_nb);
269	if (res)
270		dev_warn(dev, "failed to unregister restart handler\n");
271
272	res = misc_deregister(&at91wdt_miscdev);
273	if (!res)
274		at91wdt_miscdev.parent = NULL;
275
276	return res;
277}
278
279static void at91wdt_shutdown(struct platform_device *pdev)
280{
281	at91_wdt_stop();
282}
283
284#ifdef CONFIG_PM
285
286static int at91wdt_suspend(struct platform_device *pdev, pm_message_t message)
287{
288	at91_wdt_stop();
289	return 0;
290}
291
292static int at91wdt_resume(struct platform_device *pdev)
293{
294	if (at91wdt_busy)
295		at91_wdt_start();
296	return 0;
297}
298
299#else
300#define at91wdt_suspend NULL
301#define at91wdt_resume	NULL
302#endif
303
304static const struct of_device_id at91_wdt_dt_ids[] = {
305	{ .compatible = "atmel,at91rm9200-wdt" },
306	{ /* sentinel */ }
307};
308MODULE_DEVICE_TABLE(of, at91_wdt_dt_ids);
309
310static struct platform_driver at91wdt_driver = {
311	.probe		= at91wdt_probe,
312	.remove		= at91wdt_remove,
313	.shutdown	= at91wdt_shutdown,
314	.suspend	= at91wdt_suspend,
315	.resume		= at91wdt_resume,
316	.driver		= {
317		.name	= "atmel_st_watchdog",
318		.of_match_table = at91_wdt_dt_ids,
319	},
320};
321
322static int __init at91_wdt_init(void)
323{
324	/* Check that the heartbeat value is within range;
325	   if not reset to the default */
326	if (at91_wdt_settimeout(wdt_time)) {
327		at91_wdt_settimeout(WDT_DEFAULT_TIME);
328		pr_info("wdt_time value must be 1 <= wdt_time <= 256, using %d\n",
329			wdt_time);
330	}
331
332	return platform_driver_register(&at91wdt_driver);
333}
334
335static void __exit at91_wdt_exit(void)
336{
337	platform_driver_unregister(&at91wdt_driver);
338}
339
340module_init(at91_wdt_init);
341module_exit(at91_wdt_exit);
342
343MODULE_AUTHOR("Andrew Victor");
344MODULE_DESCRIPTION("Watchdog driver for Atmel AT91RM9200");
345MODULE_LICENSE("GPL");
346MODULE_ALIAS("platform:atmel_st_watchdog");
347