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#include <linux/bitops.h>
 
 13#include <linux/errno.h>
 14#include <linux/fs.h>
 15#include <linux/init.h>
 16#include <linux/io.h>
 17#include <linux/kernel.h>
 
 
 18#include <linux/miscdevice.h>
 19#include <linux/module.h>
 20#include <linux/moduleparam.h>
 21#include <linux/platform_device.h>
 
 
 22#include <linux/types.h>
 23#include <linux/watchdog.h>
 24#include <linux/uaccess.h>
 25#include <mach/at91_st.h>
 
 26
 27#define WDT_DEFAULT_TIME	5	/* seconds */
 28#define WDT_MAX_TIME		256	/* seconds */
 29
 30static int wdt_time = WDT_DEFAULT_TIME;
 31static int nowayout = WATCHDOG_NOWAYOUT;
 
 32
 33module_param(wdt_time, int, 0);
 34MODULE_PARM_DESC(wdt_time, "Watchdog time in seconds. (default="
 35				__MODULE_STRING(WDT_DEFAULT_TIME) ")");
 36
 37#ifdef CONFIG_WATCHDOG_NOWAYOUT
 38module_param(nowayout, int, 0);
 39MODULE_PARM_DESC(nowayout,
 40		"Watchdog cannot be stopped once started (default="
 41				__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 42#endif
 43
 44
 45static unsigned long at91wdt_busy;
 46
 47/* ......................................................................... */
 48
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 49/*
 50 * Disable the watchdog.
 51 */
 52static inline void at91_wdt_stop(void)
 53{
 54	at91_sys_write(AT91_ST_WDMR, AT91_ST_EXTEN);
 55}
 56
 57/*
 58 * Enable and reset the watchdog.
 59 */
 60static inline void at91_wdt_start(void)
 61{
 62	at91_sys_write(AT91_ST_WDMR, AT91_ST_EXTEN | AT91_ST_RSTEN |
 63				(((65536 * wdt_time) >> 8) & AT91_ST_WDV));
 64	at91_sys_write(AT91_ST_CR, AT91_ST_WDRST);
 65}
 66
 67/*
 68 * Reload the watchdog timer.  (ie, pat the watchdog)
 69 */
 70static inline void at91_wdt_reload(void)
 71{
 72	at91_sys_write(AT91_ST_CR, AT91_ST_WDRST);
 73}
 74
 75/* ......................................................................... */
 76
 77/*
 78 * Watchdog device is opened, and watchdog starts running.
 79 */
 80static int at91_wdt_open(struct inode *inode, struct file *file)
 81{
 82	if (test_and_set_bit(0, &at91wdt_busy))
 83		return -EBUSY;
 84
 85	at91_wdt_start();
 86	return nonseekable_open(inode, file);
 87}
 88
 89/*
 90 * Close the watchdog device.
 91 * If CONFIG_WATCHDOG_NOWAYOUT is NOT defined then the watchdog is also
 92 *  disabled.
 93 */
 94static int at91_wdt_close(struct inode *inode, struct file *file)
 95{
 96	/* Disable the watchdog when file is closed */
 97	if (!nowayout)
 98		at91_wdt_stop();
 99
100	clear_bit(0, &at91wdt_busy);
101	return 0;
102}
103
104/*
105 * Change the watchdog time interval.
106 */
107static int at91_wdt_settimeout(int new_time)
108{
109	/*
110	 * All counting occurs at SLOW_CLOCK / 128 = 256 Hz
111	 *
112	 * Since WDV is a 16-bit counter, the maximum period is
113	 * 65536 / 256 = 256 seconds.
114	 */
115	if ((new_time <= 0) || (new_time > WDT_MAX_TIME))
116		return -EINVAL;
117
118	/* Set new watchdog time. It will be used when
119	   at91_wdt_start() is called. */
120	wdt_time = new_time;
121	return 0;
122}
123
124static const struct watchdog_info at91_wdt_info = {
125	.identity	= "at91 watchdog",
126	.options	= WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
127};
128
129/*
130 * Handle commands from user-space.
131 */
132static long at91_wdt_ioctl(struct file *file,
133					unsigned int cmd, unsigned long arg)
134{
135	void __user *argp = (void __user *)arg;
136	int __user *p = argp;
137	int new_value;
138
139	switch (cmd) {
140	case WDIOC_GETSUPPORT:
141		return copy_to_user(argp, &at91_wdt_info,
142				sizeof(at91_wdt_info)) ? -EFAULT : 0;
143	case WDIOC_GETSTATUS:
144	case WDIOC_GETBOOTSTATUS:
145		return put_user(0, p);
146	case WDIOC_SETOPTIONS:
147		if (get_user(new_value, p))
148			return -EFAULT;
149		if (new_value & WDIOS_DISABLECARD)
150			at91_wdt_stop();
151		if (new_value & WDIOS_ENABLECARD)
152			at91_wdt_start();
153		return 0;
154	case WDIOC_KEEPALIVE:
155		at91_wdt_reload();	/* pat the watchdog */
156		return 0;
157	case WDIOC_SETTIMEOUT:
158		if (get_user(new_value, p))
159			return -EFAULT;
160		if (at91_wdt_settimeout(new_value))
161			return -EINVAL;
162		/* Enable new time value */
163		at91_wdt_start();
164		/* Return current value */
165		return put_user(wdt_time, p);
166	case WDIOC_GETTIMEOUT:
167		return put_user(wdt_time, p);
168	default:
169		return -ENOTTY;
170	}
171}
172
173/*
174 * Pat the watchdog whenever device is written to.
175 */
176static ssize_t at91_wdt_write(struct file *file, const char *data,
177						size_t len, loff_t *ppos)
178{
179	at91_wdt_reload();		/* pat the watchdog */
180	return len;
181}
182
183/* ......................................................................... */
184
185static const struct file_operations at91wdt_fops = {
186	.owner		= THIS_MODULE,
187	.llseek		= no_llseek,
188	.unlocked_ioctl	= at91_wdt_ioctl,
189	.open		= at91_wdt_open,
190	.release	= at91_wdt_close,
191	.write		= at91_wdt_write,
192};
193
194static struct miscdevice at91wdt_miscdev = {
195	.minor		= WATCHDOG_MINOR,
196	.name		= "watchdog",
197	.fops		= &at91wdt_fops,
198};
199
200static int __devinit at91wdt_probe(struct platform_device *pdev)
201{
 
 
202	int res;
203
204	if (at91wdt_miscdev.parent)
205		return -EBUSY;
206	at91wdt_miscdev.parent = &pdev->dev;
207
 
 
 
 
 
 
 
 
 
 
208	res = misc_register(&at91wdt_miscdev);
209	if (res)
210		return res;
211
212	printk(KERN_INFO "AT91 Watchdog Timer enabled (%d seconds%s)\n",
213				wdt_time, nowayout ? ", nowayout" : "");
 
 
 
 
214	return 0;
215}
216
217static int __devexit at91wdt_remove(struct platform_device *pdev)
218{
 
219	int res;
220
221	res = misc_deregister(&at91wdt_miscdev);
222	if (!res)
223		at91wdt_miscdev.parent = NULL;
 
 
 
224
225	return res;
226}
227
228static void at91wdt_shutdown(struct platform_device *pdev)
229{
230	at91_wdt_stop();
231}
232
233#ifdef CONFIG_PM
234
235static int at91wdt_suspend(struct platform_device *pdev, pm_message_t message)
236{
237	at91_wdt_stop();
238	return 0;
239}
240
241static int at91wdt_resume(struct platform_device *pdev)
242{
243	if (at91wdt_busy)
244		at91_wdt_start();
245	return 0;
246}
247
248#else
249#define at91wdt_suspend NULL
250#define at91wdt_resume	NULL
251#endif
252
 
 
 
 
 
 
253static struct platform_driver at91wdt_driver = {
254	.probe		= at91wdt_probe,
255	.remove		= __devexit_p(at91wdt_remove),
256	.shutdown	= at91wdt_shutdown,
257	.suspend	= at91wdt_suspend,
258	.resume		= at91wdt_resume,
259	.driver		= {
260		.name	= "at91_wdt",
261		.owner	= THIS_MODULE,
262	},
263};
264
265static int __init at91_wdt_init(void)
266{
267	/* Check that the heartbeat value is within range;
268	   if not reset to the default */
269	if (at91_wdt_settimeout(wdt_time)) {
270		at91_wdt_settimeout(WDT_DEFAULT_TIME);
271		pr_info("at91_wdt: wdt_time value must be 1 <= wdt_time <= 256"
272						", using %d\n", wdt_time);
273	}
274
275	return platform_driver_register(&at91wdt_driver);
276}
277
278static void __exit at91_wdt_exit(void)
279{
280	platform_driver_unregister(&at91wdt_driver);
281}
282
283module_init(at91_wdt_init);
284module_exit(at91_wdt_exit);
285
286MODULE_AUTHOR("Andrew Victor");
287MODULE_DESCRIPTION("Watchdog driver for Atmel AT91RM9200");
288MODULE_LICENSE("GPL");
289MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
290MODULE_ALIAS("platform:at91_wdt");

  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 (IS_ERR(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	misc_deregister(&at91wdt_miscdev);
273	at91wdt_miscdev.parent = NULL;
274
275	return res;
276}
277
278static void at91wdt_shutdown(struct platform_device *pdev)
279{
280	at91_wdt_stop();
281}
282
283#ifdef CONFIG_PM
284
285static int at91wdt_suspend(struct platform_device *pdev, pm_message_t message)
286{
287	at91_wdt_stop();
288	return 0;
289}
290
291static int at91wdt_resume(struct platform_device *pdev)
292{
293	if (at91wdt_busy)
294		at91_wdt_start();
295	return 0;
296}
297
298#else
299#define at91wdt_suspend NULL
300#define at91wdt_resume	NULL
301#endif
302
303static const struct of_device_id at91_wdt_dt_ids[] = {
304	{ .compatible = "atmel,at91rm9200-wdt" },
305	{ /* sentinel */ }
306};
307MODULE_DEVICE_TABLE(of, at91_wdt_dt_ids);
308
309static struct platform_driver at91wdt_driver = {
310	.probe		= at91wdt_probe,
311	.remove		= at91wdt_remove,
312	.shutdown	= at91wdt_shutdown,
313	.suspend	= at91wdt_suspend,
314	.resume		= at91wdt_resume,
315	.driver		= {
316		.name	= "atmel_st_watchdog",
317		.of_match_table = at91_wdt_dt_ids,
318	},
319};
320
321static int __init at91_wdt_init(void)
322{
323	/* Check that the heartbeat value is within range;
324	   if not reset to the default */
325	if (at91_wdt_settimeout(wdt_time)) {
326		at91_wdt_settimeout(WDT_DEFAULT_TIME);
327		pr_info("wdt_time value must be 1 <= wdt_time <= 256, using %d\n",
328			wdt_time);
329	}
330
331	return platform_driver_register(&at91wdt_driver);
332}
333
334static void __exit at91_wdt_exit(void)
335{
336	platform_driver_unregister(&at91wdt_driver);
337}
338
339module_init(at91_wdt_init);
340module_exit(at91_wdt_exit);
341
342MODULE_AUTHOR("Andrew Victor");
343MODULE_DESCRIPTION("Watchdog driver for Atmel AT91RM9200");
344MODULE_LICENSE("GPL");
345MODULE_ALIAS("platform:atmel_st_watchdog");