PageRenderTime 40ms CodeModel.GetById 15ms app.highlight 10ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/watchdog/at91sam9_wdt.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 311 lines | 196 code | 58 blank | 57 comment | 17 complexity | f2357280700e0eee9261762100203b4f MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
  1/*
  2 * Watchdog driver for Atmel AT91SAM9x processors.
  3 *
  4 * Copyright (C) 2008 Renaud CERRATO r.cerrato@til-technologies.fr
  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/*
 13 * The Watchdog Timer Mode Register can be only written to once. If the
 14 * timeout need to be set from Linux, be sure that the bootstrap or the
 15 * bootloader doesn't write to this register.
 16 */
 17
 18#include <linux/errno.h>
 19#include <linux/fs.h>
 20#include <linux/init.h>
 21#include <linux/io.h>
 22#include <linux/kernel.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/types.h>
 28#include <linux/watchdog.h>
 29#include <linux/jiffies.h>
 30#include <linux/timer.h>
 31#include <linux/bitops.h>
 32#include <linux/uaccess.h>
 33
 34#include "at91sam9_wdt.h"
 35
 36#define DRV_NAME "AT91SAM9 Watchdog"
 37
 38/* AT91SAM9 watchdog runs a 12bit counter @ 256Hz,
 39 * use this to convert a watchdog
 40 * value from/to milliseconds.
 41 */
 42#define ms_to_ticks(t)	(((t << 8) / 1000) - 1)
 43#define ticks_to_ms(t)	(((t + 1) * 1000) >> 8)
 44
 45/* Hardware timeout in seconds */
 46#define WDT_HW_TIMEOUT 2
 47
 48/* Timer heartbeat (500ms) */
 49#define WDT_TIMEOUT	(HZ/2)
 50
 51/* User land timeout */
 52#define WDT_HEARTBEAT 15
 53static int heartbeat = WDT_HEARTBEAT;
 54module_param(heartbeat, int, 0);
 55MODULE_PARM_DESC(heartbeat, "Watchdog heartbeats in seconds. "
 56	"(default = " __MODULE_STRING(WDT_HEARTBEAT) ")");
 57
 58static int nowayout = WATCHDOG_NOWAYOUT;
 59module_param(nowayout, int, 0);
 60MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
 61	"(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 62
 63static void at91_ping(unsigned long data);
 64
 65static struct {
 66	unsigned long next_heartbeat;	/* the next_heartbeat for the timer */
 67	unsigned long open;
 68	char expect_close;
 69	struct timer_list timer;	/* The timer that pings the watchdog */
 70} at91wdt_private;
 71
 72/* ......................................................................... */
 73
 74
 75/*
 76 * Reload the watchdog timer.  (ie, pat the watchdog)
 77 */
 78static inline void at91_wdt_reset(void)
 79{
 80	at91_sys_write(AT91_WDT_CR, AT91_WDT_KEY | AT91_WDT_WDRSTT);
 81}
 82
 83/*
 84 * Timer tick
 85 */
 86static void at91_ping(unsigned long data)
 87{
 88	if (time_before(jiffies, at91wdt_private.next_heartbeat) ||
 89			(!nowayout && !at91wdt_private.open)) {
 90		at91_wdt_reset();
 91		mod_timer(&at91wdt_private.timer, jiffies + WDT_TIMEOUT);
 92	} else
 93		printk(KERN_CRIT DRV_NAME": I will reset your machine !\n");
 94}
 95
 96/*
 97 * Watchdog device is opened, and watchdog starts running.
 98 */
 99static int at91_wdt_open(struct inode *inode, struct file *file)
100{
101	if (test_and_set_bit(0, &at91wdt_private.open))
102		return -EBUSY;
103
104	at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ;
105	mod_timer(&at91wdt_private.timer, jiffies + WDT_TIMEOUT);
106
107	return nonseekable_open(inode, file);
108}
109
110/*
111 * Close the watchdog device.
112 */
113static int at91_wdt_close(struct inode *inode, struct file *file)
114{
115	clear_bit(0, &at91wdt_private.open);
116
117	/* stop internal ping */
118	if (!at91wdt_private.expect_close)
119		del_timer(&at91wdt_private.timer);
120
121	at91wdt_private.expect_close = 0;
122	return 0;
123}
124
125/*
126 * Set the watchdog time interval in 1/256Hz (write-once)
127 * Counter is 12 bit.
128 */
129static int at91_wdt_settimeout(unsigned int timeout)
130{
131	unsigned int reg;
132	unsigned int mr;
133
134	/* Check if disabled */
135	mr = at91_sys_read(AT91_WDT_MR);
136	if (mr & AT91_WDT_WDDIS) {
137		printk(KERN_ERR DRV_NAME": sorry, watchdog is disabled\n");
138		return -EIO;
139	}
140
141	/*
142	 * All counting occurs at SLOW_CLOCK / 128 = 256 Hz
143	 *
144	 * Since WDV is a 12-bit counter, the maximum period is
145	 * 4096 / 256 = 16 seconds.
146	 */
147	reg = AT91_WDT_WDRSTEN	/* causes watchdog reset */
148		/* | AT91_WDT_WDRPROC	causes processor reset only */
149		| AT91_WDT_WDDBGHLT	/* disabled in debug mode */
150		| AT91_WDT_WDD		/* restart at any time */
151		| (timeout & AT91_WDT_WDV);  /* timer value */
152	at91_sys_write(AT91_WDT_MR, reg);
153
154	return 0;
155}
156
157static const struct watchdog_info at91_wdt_info = {
158	.identity	= DRV_NAME,
159	.options	= WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
160						WDIOF_MAGICCLOSE,
161};
162
163/*
164 * Handle commands from user-space.
165 */
166static long at91_wdt_ioctl(struct file *file,
167		unsigned int cmd, unsigned long arg)
168{
169	void __user *argp = (void __user *)arg;
170	int __user *p = argp;
171	int new_value;
172
173	switch (cmd) {
174	case WDIOC_GETSUPPORT:
175		return copy_to_user(argp, &at91_wdt_info,
176				    sizeof(at91_wdt_info)) ? -EFAULT : 0;
177
178	case WDIOC_GETSTATUS:
179	case WDIOC_GETBOOTSTATUS:
180		return put_user(0, p);
181
182	case WDIOC_KEEPALIVE:
183		at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ;
184		return 0;
185
186	case WDIOC_SETTIMEOUT:
187		if (get_user(new_value, p))
188			return -EFAULT;
189
190		heartbeat = new_value;
191		at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ;
192
193		return put_user(new_value, p);  /* return current value */
194
195	case WDIOC_GETTIMEOUT:
196		return put_user(heartbeat, p);
197	}
198	return -ENOTTY;
199}
200
201/*
202 * Pat the watchdog whenever device is written to.
203 */
204static ssize_t at91_wdt_write(struct file *file, const char *data, size_t len,
205								loff_t *ppos)
206{
207	if (!len)
208		return 0;
209
210	/* Scan for magic character */
211	if (!nowayout) {
212		size_t i;
213
214		at91wdt_private.expect_close = 0;
215
216		for (i = 0; i < len; i++) {
217			char c;
218			if (get_user(c, data + i))
219				return -EFAULT;
220			if (c == 'V') {
221				at91wdt_private.expect_close = 42;
222				break;
223			}
224		}
225	}
226
227	at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ;
228
229	return len;
230}
231
232/* ......................................................................... */
233
234static const struct file_operations at91wdt_fops = {
235	.owner			= THIS_MODULE,
236	.llseek			= no_llseek,
237	.unlocked_ioctl	= at91_wdt_ioctl,
238	.open			= at91_wdt_open,
239	.release		= at91_wdt_close,
240	.write			= at91_wdt_write,
241};
242
243static struct miscdevice at91wdt_miscdev = {
244	.minor		= WATCHDOG_MINOR,
245	.name		= "watchdog",
246	.fops		= &at91wdt_fops,
247};
248
249static int __init at91wdt_probe(struct platform_device *pdev)
250{
251	int res;
252
253	if (at91wdt_miscdev.parent)
254		return -EBUSY;
255	at91wdt_miscdev.parent = &pdev->dev;
256
257	/* Set watchdog */
258	res = at91_wdt_settimeout(ms_to_ticks(WDT_HW_TIMEOUT * 1000));
259	if (res)
260		return res;
261
262	res = misc_register(&at91wdt_miscdev);
263	if (res)
264		return res;
265
266	at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ;
267	setup_timer(&at91wdt_private.timer, at91_ping, 0);
268	mod_timer(&at91wdt_private.timer, jiffies + WDT_TIMEOUT);
269
270	printk(KERN_INFO DRV_NAME " enabled (heartbeat=%d sec, nowayout=%d)\n",
271		heartbeat, nowayout);
272
273	return 0;
274}
275
276static int __exit at91wdt_remove(struct platform_device *pdev)
277{
278	int res;
279
280	res = misc_deregister(&at91wdt_miscdev);
281	if (!res)
282		at91wdt_miscdev.parent = NULL;
283
284	return res;
285}
286
287static struct platform_driver at91wdt_driver = {
288	.remove		= __exit_p(at91wdt_remove),
289	.driver		= {
290		.name	= "at91_wdt",
291		.owner	= THIS_MODULE,
292	},
293};
294
295static int __init at91sam_wdt_init(void)
296{
297	return platform_driver_probe(&at91wdt_driver, at91wdt_probe);
298}
299
300static void __exit at91sam_wdt_exit(void)
301{
302	platform_driver_unregister(&at91wdt_driver);
303}
304
305module_init(at91sam_wdt_init);
306module_exit(at91sam_wdt_exit);
307
308MODULE_AUTHOR("Renaud CERRATO <r.cerrato@til-technologies.fr>");
309MODULE_DESCRIPTION("Watchdog driver for Atmel AT91SAM9x processors");
310MODULE_LICENSE("GPL");
311MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);