[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / drivers / watchdog / at91sam9_wdt.c

/*
 * Watchdog driver for Atmel AT91SAM9x processors.
 *
 * Copyright (C) 2008 Renaud CERRATO r.cerrato@til-technologies.fr
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

/*
 * The Watchdog Timer Mode Register can be only written to once. If the
 * timeout need to be set from Linux, be sure that the bootstrap or the
 * bootloader doesn't write to this register.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/platform_device.h>
#include <linux/types.h>
#include <linux/watchdog.h>
#include <linux/jiffies.h>
#include <linux/timer.h>
#include <linux/bitops.h>
#include <linux/uaccess.h>

#include "at91sam9_wdt.h"

#define DRV_NAME "AT91SAM9 Watchdog"

#define wdt_read(field) \
	__raw_readl(at91wdt_private.base + field)
#define wdt_write(field, val) \
	__raw_writel((val), at91wdt_private.base + field)

/* AT91SAM9 watchdog runs a 12bit counter @ 256Hz,
 * use this to convert a watchdog
 * value from/to milliseconds.
 */
#define ms_to_ticks(t)	(((t << 8) / 1000) - 1)
#define ticks_to_ms(t)	(((t + 1) * 1000) >> 8)

/* Hardware timeout in seconds */
#define WDT_HW_TIMEOUT 2

/* Timer heartbeat (500ms) */
#define WDT_TIMEOUT	(HZ/2)

/* User land timeout */
#define WDT_HEARTBEAT 15
static int heartbeat = WDT_HEARTBEAT;
module_param(heartbeat, int, 0);
MODULE_PARM_DESC(heartbeat, "Watchdog heartbeats in seconds. "
	"(default = " __MODULE_STRING(WDT_HEARTBEAT) ")");

static bool nowayout = WATCHDOG_NOWAYOUT;
module_param(nowayout, bool, 0);
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
	"(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");

static void at91_ping(unsigned long data);

static struct {
	void __iomem *base;
	unsigned long next_heartbeat;	/* the next_heartbeat for the timer */
	unsigned long open;
	char expect_close;
	struct timer_list timer;	/* The timer that pings the watchdog */
} at91wdt_private;

/* ......................................................................... */


/*
 * Reload the watchdog timer.  (ie, pat the watchdog)
 */
static inline void at91_wdt_reset(void)
{
	wdt_write(AT91_WDT_CR, AT91_WDT_KEY | AT91_WDT_WDRSTT);
}

/*
 * Timer tick
 */
static void at91_ping(unsigned long data)
{
	if (time_before(jiffies, at91wdt_private.next_heartbeat) ||
			(!nowayout && !at91wdt_private.open)) {
		at91_wdt_reset();
		mod_timer(&at91wdt_private.timer, jiffies + WDT_TIMEOUT);
	} else
		pr_crit("I will reset your machine !\n");
}

/*
 * Watchdog device is opened, and watchdog starts running.
 */
static int at91_wdt_open(struct inode *inode, struct file *file)
{
	if (test_and_set_bit(0, &at91wdt_private.open))
		return -EBUSY;

	at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ;
	mod_timer(&at91wdt_private.timer, jiffies + WDT_TIMEOUT);

	return nonseekable_open(inode, file);
}

/*
 * Close the watchdog device.
 */
static int at91_wdt_close(struct inode *inode, struct file *file)
{
	clear_bit(0, &at91wdt_private.open);

	/* stop internal ping */
	if (!at91wdt_private.expect_close)
		del_timer(&at91wdt_private.timer);

	at91wdt_private.expect_close = 0;
	return 0;
}

/*
 * Set the watchdog time interval in 1/256Hz (write-once)
 * Counter is 12 bit.
 */
static int at91_wdt_settimeout(unsigned int timeout)
{
	unsigned int reg;
	unsigned int mr;

	/* Check if disabled */
	mr = wdt_read(AT91_WDT_MR);
	if (mr & AT91_WDT_WDDIS) {
		pr_err("sorry, watchdog is disabled\n");
		return -EIO;
	}

	/*
	 * All counting occurs at SLOW_CLOCK / 128 = 256 Hz
	 *
	 * Since WDV is a 12-bit counter, the maximum period is
	 * 4096 / 256 = 16 seconds.
	 */
	reg = AT91_WDT_WDRSTEN	/* causes watchdog reset */
		/* | AT91_WDT_WDRPROC	causes processor reset only */
		| AT91_WDT_WDDBGHLT	/* disabled in debug mode */
		| AT91_WDT_WDD		/* restart at any time */
		| (timeout & AT91_WDT_WDV);  /* timer value */
	wdt_write(AT91_WDT_MR, reg);

	return 0;
}

static const struct watchdog_info at91_wdt_info = {
	.identity	= DRV_NAME,
	.options	= WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
						WDIOF_MAGICCLOSE,
};

/*
 * Handle commands from user-space.
 */
static long at91_wdt_ioctl(struct file *file,
		unsigned int cmd, unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	int __user *p = argp;
	int new_value;

	switch (cmd) {
	case WDIOC_GETSUPPORT:
		return copy_to_user(argp, &at91_wdt_info,
				    sizeof(at91_wdt_info)) ? -EFAULT : 0;

	case WDIOC_GETSTATUS:
	case WDIOC_GETBOOTSTATUS:
		return put_user(0, p);

	case WDIOC_KEEPALIVE:
		at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ;
		return 0;

	case WDIOC_SETTIMEOUT:
		if (get_user(new_value, p))
			return -EFAULT;

		heartbeat = new_value;
		at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ;

		return put_user(new_value, p);  /* return current value */

	case WDIOC_GETTIMEOUT:
		return put_user(heartbeat, p);
	}
	return -ENOTTY;
}

/*
 * Pat the watchdog whenever device is written to.
 */
static ssize_t at91_wdt_write(struct file *file, const char *data, size_t len,
								loff_t *ppos)
{
	if (!len)
		return 0;

	/* Scan for magic character */
	if (!nowayout) {
		size_t i;

		at91wdt_private.expect_close = 0;

		for (i = 0; i < len; i++) {
			char c;
			if (get_user(c, data + i))
				return -EFAULT;
			if (c == 'V') {
				at91wdt_private.expect_close = 42;
				break;
			}
		}
	}

	at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ;

	return len;
}

/* ......................................................................... */

static const struct file_operations at91wdt_fops = {
	.owner			= THIS_MODULE,
	.llseek			= no_llseek,
	.unlocked_ioctl	= at91_wdt_ioctl,
	.open			= at91_wdt_open,
	.release		= at91_wdt_close,
	.write			= at91_wdt_write,
};

static struct miscdevice at91wdt_miscdev = {
	.minor		= WATCHDOG_MINOR,
	.name		= "watchdog",
	.fops		= &at91wdt_fops,
};

static int __init at91wdt_probe(struct platform_device *pdev)
{
	struct resource	*r;
	int res;

	if (at91wdt_miscdev.parent)
		return -EBUSY;
	at91wdt_miscdev.parent = &pdev->dev;

	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!r)
		return -ENODEV;
	at91wdt_private.base = ioremap(r->start, resource_size(r));
	if (!at91wdt_private.base) {
		dev_err(&pdev->dev, "failed to map registers, aborting.\n");
		return -ENOMEM;
	}

	/* Set watchdog */
	res = at91_wdt_settimeout(ms_to_ticks(WDT_HW_TIMEOUT * 1000));
	if (res)
		return res;

	res = misc_register(&at91wdt_miscdev);
	if (res)
		return res;

	at91wdt_private.next_heartbeat = jiffies + heartbeat * HZ;
	setup_timer(&at91wdt_private.timer, at91_ping, 0);
	mod_timer(&at91wdt_private.timer, jiffies + WDT_TIMEOUT);

	pr_info("enabled (heartbeat=%d sec, nowayout=%d)\n",
		heartbeat, nowayout);

	return 0;
}

static int __exit at91wdt_remove(struct platform_device *pdev)
{
	int res;

	res = misc_deregister(&at91wdt_miscdev);
	if (!res)
		at91wdt_miscdev.parent = NULL;

	return res;
}

static struct platform_driver at91wdt_driver = {
	.remove		= __exit_p(at91wdt_remove),
	.driver		= {
		.name	= "at91_wdt",
		.owner	= THIS_MODULE,
	},
};

static int __init at91sam_wdt_init(void)
{
	return platform_driver_probe(&at91wdt_driver, at91wdt_probe);
}

static void __exit at91sam_wdt_exit(void)
{
	platform_driver_unregister(&at91wdt_driver);
}

module_init(at91sam_wdt_init);
module_exit(at91sam_wdt_exit);

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