[net-next-2.6.git] / drivers / watchdog / mpc8xxx_wdt.c

/*
 * mpc8xxx_wdt.c - MPC83xx/MPC86xx watchdog userspace interface
 *
 * Authors: Dave Updegraff <dave@cray.org>
 * 	    Kumar Gala <galak@kernel.crashing.org>
 * 		Attribution: from 83xx_wst: Florian Schirmer <jolt@tuxbox.org>
 * 				..and from sc520_wdt
 * Copyright (c) 2008  MontaVista Software, Inc.
 *                     Anton Vorontsov <avorontsov@ru.mvista.com>
 *
 * Note: it appears that you can only actually ENABLE or DISABLE the thing
 * once after POR. Once enabled, you cannot disable, and vice versa.
 *
 * 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.
 */

#include <linux/fs.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/timer.h>
#include <linux/miscdevice.h>
#include <linux/of_platform.h>
#include <linux/module.h>
#include <linux/watchdog.h>
#include <linux/io.h>
#include <linux/uaccess.h>
#include <sysdev/fsl_soc.h>

struct mpc8xxx_wdt {
	__be32 res0;
	__be32 swcrr; /* System watchdog control register */
#define SWCRR_SWTC 0xFFFF0000 /* Software Watchdog Time Count. */
#define SWCRR_SWEN 0x00000004 /* Watchdog Enable bit. */
#define SWCRR_SWRI 0x00000002 /* Software Watchdog Reset/Interrupt Select bit.*/
#define SWCRR_SWPR 0x00000001 /* Software Watchdog Counter Prescale bit. */
	__be32 swcnr; /* System watchdog count register */
	u8 res1[2];
	__be16 swsrr; /* System watchdog service register */
	u8 res2[0xF0];
};

struct mpc8xxx_wdt_type {
	int prescaler;
	bool hw_enabled;
};

static struct mpc8xxx_wdt __iomem *wd_base;

static u16 timeout = 0xffff;
module_param(timeout, ushort, 0);
MODULE_PARM_DESC(timeout,
	"Watchdog timeout in ticks. (0<timeout<65536, default=65535");

static int reset = 1;
module_param(reset, bool, 0);
MODULE_PARM_DESC(reset,
	"Watchdog Interrupt/Reset Mode. 0 = interrupt, 1 = reset");

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

/*
 * We always prescale, but if someone really doesn't want to they can set this
 * to 0
 */
static int prescale = 1;
static unsigned int timeout_sec;

static unsigned long wdt_is_open;
static DEFINE_SPINLOCK(wdt_spinlock);

static void mpc8xxx_wdt_keepalive(void)
{
	/* Ping the WDT */
	spin_lock(&wdt_spinlock);
	out_be16(&wd_base->swsrr, 0x556c);
	out_be16(&wd_base->swsrr, 0xaa39);
	spin_unlock(&wdt_spinlock);
}

static void mpc8xxx_wdt_timer_ping(unsigned long arg);
static DEFINE_TIMER(wdt_timer, mpc8xxx_wdt_timer_ping, 0, 0);

static void mpc8xxx_wdt_timer_ping(unsigned long arg)
{
	mpc8xxx_wdt_keepalive();
	/* We're pinging it twice faster than needed, just to be sure. */
	mod_timer(&wdt_timer, jiffies + HZ * timeout_sec / 2);
}

static void mpc8xxx_wdt_pr_warn(const char *msg)
{
	pr_crit("mpc8xxx_wdt: %s, expect the %s soon!\n", msg,
		reset ? "reset" : "machine check exception");
}

static ssize_t mpc8xxx_wdt_write(struct file *file, const char __user *buf,
				 size_t count, loff_t *ppos)
{
	if (count)
		mpc8xxx_wdt_keepalive();
	return count;
}

static int mpc8xxx_wdt_open(struct inode *inode, struct file *file)
{
	u32 tmp = SWCRR_SWEN;
	if (test_and_set_bit(0, &wdt_is_open))
		return -EBUSY;

	/* Once we start the watchdog we can't stop it */
	if (nowayout)
		__module_get(THIS_MODULE);

	/* Good, fire up the show */
	if (prescale)
		tmp |= SWCRR_SWPR;
	if (reset)
		tmp |= SWCRR_SWRI;

	tmp |= timeout << 16;

	out_be32(&wd_base->swcrr, tmp);

	del_timer_sync(&wdt_timer);

	return nonseekable_open(inode, file);
}

static int mpc8xxx_wdt_release(struct inode *inode, struct file *file)
{
	if (!nowayout)
		mpc8xxx_wdt_timer_ping(0);
	else
		mpc8xxx_wdt_pr_warn("watchdog closed");
	clear_bit(0, &wdt_is_open);
	return 0;
}

static long mpc8xxx_wdt_ioctl(struct inode *inode, struct file *file,
							unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	int __user *p = argp;
	static struct watchdog_info ident = {
		.options = WDIOF_KEEPALIVEPING,
		.firmware_version = 1,
		.identity = "MPC8xxx",
	};

	switch (cmd) {
	case WDIOC_GETSUPPORT:
		return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
	case WDIOC_GETSTATUS:
	case WDIOC_GETBOOTSTATUS:
		return put_user(0, p);
	case WDIOC_KEEPALIVE:
		mpc8xxx_wdt_keepalive();
		return 0;
	case WDIOC_GETTIMEOUT:
		return put_user(timeout_sec, p);
	default:
		return -ENOTTY;
	}
}

static const struct file_operations mpc8xxx_wdt_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.write		= mpc8xxx_wdt_write,
	.unlocked_ioctl	= mpc8xxx_wdt_ioctl,
	.open		= mpc8xxx_wdt_open,
	.release	= mpc8xxx_wdt_release,
};

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

static int __devinit mpc8xxx_wdt_probe(struct of_device *ofdev,
				       const struct of_device_id *match)
{
	int ret;
	struct device_node *np = ofdev->node;
	struct mpc8xxx_wdt_type *wdt_type = match->data;
	u32 freq = fsl_get_sys_freq();
	bool enabled;

	if (!freq || freq == -1)
		return -EINVAL;

	wd_base = of_iomap(np, 0);
	if (!wd_base)
		return -ENOMEM;

	enabled = in_be32(&wd_base->swcrr) & SWCRR_SWEN;
	if (!enabled && wdt_type->hw_enabled) {
		pr_info("mpc8xxx_wdt: could not be enabled in software\n");
		ret = -ENOSYS;
		goto err_unmap;
	}

	ret = misc_register(&mpc8xxx_wdt_miscdev);
	if (ret) {
		pr_err("cannot register miscdev on minor=%d (err=%d)\n",
			WATCHDOG_MINOR, ret);
		goto err_unmap;
	}

	/* Calculate the timeout in seconds */
	if (prescale)
		timeout_sec = (timeout * wdt_type->prescaler) / freq;
	else
		timeout_sec = timeout / freq;

	pr_info("WDT driver for MPC8xxx initialized. mode:%s timeout=%d "
		"(%d seconds)\n", reset ? "reset" : "interrupt", timeout,
		timeout_sec);

	/*
	 * If the watchdog was previously enabled or we're running on
	 * MPC8xxx, we should ping the wdt from the kernel until the
	 * userspace handles it.
	 */
	if (enabled)
		mpc8xxx_wdt_timer_ping(0);
	return 0;
err_unmap:
	iounmap(wd_base);
	return ret;
}

static int __devexit mpc8xxx_wdt_remove(struct of_device *ofdev)
{
	mpc8xxx_wdt_pr_warn("watchdog removed");
	del_timer_sync(&wdt_timer);
	misc_deregister(&mpc8xxx_wdt_miscdev);
	iounmap(wd_base);

	return 0;
}

static const struct of_device_id mpc8xxx_wdt_match[] = {
	{
		.compatible = "mpc83xx_wdt",
		.data = &(struct mpc8xxx_wdt_type) {
			.prescaler = 0x10000,
		},
	},
	{
		.compatible = "fsl,mpc8610-wdt",
		.data = &(struct mpc8xxx_wdt_type) {
			.prescaler = 0x10000,
			.hw_enabled = true,
		},
	},
	{},
};
MODULE_DEVICE_TABLE(of, mpc8xxx_wdt_match);

static struct of_platform_driver mpc8xxx_wdt_driver = {
	.match_table	= mpc8xxx_wdt_match,
	.probe		= mpc8xxx_wdt_probe,
	.remove		= __devexit_p(mpc8xxx_wdt_remove),
	.driver		= {
		.name	= "mpc8xxx_wdt",
		.owner	= THIS_MODULE,
	},
};

static int __init mpc8xxx_wdt_init(void)
{
	return of_register_platform_driver(&mpc8xxx_wdt_driver);
}

static void __exit mpc8xxx_wdt_exit(void)
{
	of_unregister_platform_driver(&mpc8xxx_wdt_driver);
}

subsys_initcall(mpc8xxx_wdt_init);
module_exit(mpc8xxx_wdt_exit);

MODULE_AUTHOR("Dave Updegraff, Kumar Gala");
MODULE_DESCRIPTION("Driver for watchdog timer in MPC83xx/MPC86xx uProcessors");
MODULE_LICENSE("GPL");
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
Commit	Line	Data
fabbfb9e	1	/*
59ca1b0d	2	* mpc8xxx_wdt.c - MPC83xx/MPC86xx watchdog userspace interface
fabbfb9e KG	3	*
	4	* Authors: Dave Updegraff <dave@cray.org>
	5	* Kumar Gala <galak@kernel.crashing.org>
	6	* Attribution: from 83xx_wst: Florian Schirmer <jolt@tuxbox.org>
	7	* ..and from sc520_wdt
500c919e AV	8	* Copyright (c) 2008 MontaVista Software, Inc.
500c919e AV	9	* Anton Vorontsov <avorontsov@ru.mvista.com>
fabbfb9e KG	10	*
	11	* Note: it appears that you can only actually ENABLE or DISABLE the thing
	12	* once after POR. Once enabled, you cannot disable, and vice versa.
	13	*
	14	* This program is free software; you can redistribute it and/or modify it
	15	* under the terms of the GNU General Public License as published by the
	16	* Free Software Foundation; either version 2 of the License, or (at your
	17	* option) any later version.
	18	*/
	19
fabbfb9e KG	20	#include <linux/fs.h>
	21	#include <linux/init.h>
	22	#include <linux/kernel.h>
500c919e	23	#include <linux/timer.h>
fabbfb9e	24	#include <linux/miscdevice.h>
ef8ab12e	25	#include <linux/of_platform.h>
fabbfb9e KG	26	#include <linux/module.h>
fabbfb9e KG	27	#include <linux/watchdog.h>
f26ef3dc AC	28	#include <linux/io.h>
f26ef3dc AC	29	#include <linux/uaccess.h>
ef8ab12e	30	#include <sysdev/fsl_soc.h>
fabbfb9e	31
59ca1b0d	32	struct mpc8xxx_wdt {
fabbfb9e KG	33	__be32 res0;
	34	__be32 swcrr; /* System watchdog control register */
	35	#define SWCRR_SWTC 0xFFFF0000 /* Software Watchdog Time Count. */
	36	#define SWCRR_SWEN 0x00000004 /* Watchdog Enable bit. */
	37	#define SWCRR_SWRI 0x00000002 /* Software Watchdog Reset/Interrupt Select bit.*/
	38	#define SWCRR_SWPR 0x00000001 /* Software Watchdog Counter Prescale bit. */
	39	__be32 swcnr; /* System watchdog count register */
	40	u8 res1[2];
	41	__be16 swsrr; /* System watchdog service register */
	42	u8 res2[0xF0];
	43	};
	44
59ca1b0d	45	struct mpc8xxx_wdt_type {
500c919e AV	46	int prescaler;
	47	bool hw_enabled;
	48	};
	49
59ca1b0d	50	static struct mpc8xxx_wdt __iomem *wd_base;
fabbfb9e KG	51
	52	static u16 timeout = 0xffff;
	53	module_param(timeout, ushort, 0);
f26ef3dc AC	54	MODULE_PARM_DESC(timeout,
f26ef3dc AC	55	"Watchdog timeout in ticks. (0<timeout<65536, default=65535");
fabbfb9e KG	56
	57	static int reset = 1;
	58	module_param(reset, bool, 0);
f26ef3dc AC	59	MODULE_PARM_DESC(reset,
f26ef3dc AC	60	"Watchdog Interrupt/Reset Mode. 0 = interrupt, 1 = reset");
fabbfb9e	61
500c919e AV	62	static int nowayout = WATCHDOG_NOWAYOUT;
	63	module_param(nowayout, int, 0);
	64	MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
	65	"(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
	66
fabbfb9e KG	67	/*
	68	* We always prescale, but if someone really doesn't want to they can set this
	69	* to 0
	70	*/
	71	static int prescale = 1;
	72	static unsigned int timeout_sec;
	73
	74	static unsigned long wdt_is_open;
c7dfd0cc	75	static DEFINE_SPINLOCK(wdt_spinlock);
fabbfb9e	76
59ca1b0d	77	static void mpc8xxx_wdt_keepalive(void)
fabbfb9e KG	78	{
	79	/* Ping the WDT */
	80	spin_lock(&wdt_spinlock);
	81	out_be16(&wd_base->swsrr, 0x556c);
	82	out_be16(&wd_base->swsrr, 0xaa39);
	83	spin_unlock(&wdt_spinlock);
	84	}
	85
59ca1b0d AV	86	static void mpc8xxx_wdt_timer_ping(unsigned long arg);
59ca1b0d AV	87	static DEFINE_TIMER(wdt_timer, mpc8xxx_wdt_timer_ping, 0, 0);
500c919e	88
59ca1b0d	89	static void mpc8xxx_wdt_timer_ping(unsigned long arg)
500c919e	90	{
59ca1b0d	91	mpc8xxx_wdt_keepalive();
500c919e AV	92	/* We're pinging it twice faster than needed, just to be sure. */
	93	mod_timer(&wdt_timer, jiffies + HZ * timeout_sec / 2);
	94	}
	95
59ca1b0d	96	static void mpc8xxx_wdt_pr_warn(const char *msg)
500c919e	97	{
59ca1b0d	98	pr_crit("mpc8xxx_wdt: %s, expect the %s soon!\n", msg,
500c919e AV	99	reset ? "reset" : "machine check exception");
	100	}
	101
59ca1b0d	102	static ssize_t mpc8xxx_wdt_write(struct file file, const char __user buf,
fabbfb9e KG	103	size_t count, loff_t *ppos)
	104	{
	105	if (count)
59ca1b0d	106	mpc8xxx_wdt_keepalive();
fabbfb9e KG	107	return count;
	108	}
	109
59ca1b0d	110	static int mpc8xxx_wdt_open(struct inode inode, struct file file)
fabbfb9e KG	111	{
	112	u32 tmp = SWCRR_SWEN;
	113	if (test_and_set_bit(0, &wdt_is_open))
	114	return -EBUSY;
	115
	116	/* Once we start the watchdog we can't stop it */
500c919e AV	117	if (nowayout)
500c919e AV	118	__module_get(THIS_MODULE);
fabbfb9e KG	119
	120	/* Good, fire up the show */
	121	if (prescale)
	122	tmp \|= SWCRR_SWPR;
	123	if (reset)
	124	tmp \|= SWCRR_SWRI;
	125
	126	tmp \|= timeout << 16;
	127
	128	out_be32(&wd_base->swcrr, tmp);
	129
500c919e AV	130	del_timer_sync(&wdt_timer);
500c919e AV	131
fabbfb9e KG	132	return nonseekable_open(inode, file);
	133	}
	134
59ca1b0d	135	static int mpc8xxx_wdt_release(struct inode inode, struct file file)
fabbfb9e	136	{
500c919e	137	if (!nowayout)
59ca1b0d	138	mpc8xxx_wdt_timer_ping(0);
500c919e	139	else
59ca1b0d	140	mpc8xxx_wdt_pr_warn("watchdog closed");
fabbfb9e KG	141	clear_bit(0, &wdt_is_open);
	142	return 0;
	143	}
	144
59ca1b0d	145	static long mpc8xxx_wdt_ioctl(struct inode inode, struct file file,
f26ef3dc	146	unsigned long arg)
fabbfb9e KG	147	{
	148	void __user argp = (void __user )arg;
	149	int __user *p = argp;
	150	static struct watchdog_info ident = {
	151	.options = WDIOF_KEEPALIVEPING,
	152	.firmware_version = 1,
59ca1b0d	153	.identity = "MPC8xxx",
fabbfb9e KG	154	};
	155
	156	switch (cmd) {
	157	case WDIOC_GETSUPPORT:
	158	return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
5c4eb61b WVS	159	case WDIOC_GETSTATUS:
	160	case WDIOC_GETBOOTSTATUS:
	161	return put_user(0, p);
fabbfb9e	162	case WDIOC_KEEPALIVE:
59ca1b0d	163	mpc8xxx_wdt_keepalive();
fabbfb9e KG	164	return 0;
	165	case WDIOC_GETTIMEOUT:
	166	return put_user(timeout_sec, p);
	167	default:
795b89d2	168	return -ENOTTY;
fabbfb9e KG	169	}
	170	}
	171
59ca1b0d	172	static const struct file_operations mpc8xxx_wdt_fops = {
fabbfb9e KG	173	.owner = THIS_MODULE,
fabbfb9e KG	174	.llseek = no_llseek,
59ca1b0d AV	175	.write = mpc8xxx_wdt_write,
	176	.unlocked_ioctl = mpc8xxx_wdt_ioctl,
	177	.open = mpc8xxx_wdt_open,
	178	.release = mpc8xxx_wdt_release,
fabbfb9e KG	179	};
fabbfb9e KG	180
59ca1b0d	181	static struct miscdevice mpc8xxx_wdt_miscdev = {
fabbfb9e KG	182	.minor = WATCHDOG_MINOR,
fabbfb9e KG	183	.name = "watchdog",
59ca1b0d	184	.fops = &mpc8xxx_wdt_fops,
fabbfb9e KG	185	};
fabbfb9e KG	186
59ca1b0d	187	static int __devinit mpc8xxx_wdt_probe(struct of_device *ofdev,
ef8ab12e	188	const struct of_device_id *match)
fabbfb9e	189	{
fabbfb9e	190	int ret;
500c919e	191	struct device_node *np = ofdev->node;
59ca1b0d	192	struct mpc8xxx_wdt_type *wdt_type = match->data;
ef8ab12e	193	u32 freq = fsl_get_sys_freq();
500c919e	194	bool enabled;
fabbfb9e	195
ef8ab12e AV	196	if (!freq \|\| freq == -1)
ef8ab12e AV	197	return -EINVAL;
fabbfb9e	198
500c919e	199	wd_base = of_iomap(np, 0);
ef8ab12e AV	200	if (!wd_base)
ef8ab12e AV	201	return -ENOMEM;
fabbfb9e	202
500c919e AV	203	enabled = in_be32(&wd_base->swcrr) & SWCRR_SWEN;
500c919e AV	204	if (!enabled && wdt_type->hw_enabled) {
59ca1b0d	205	pr_info("mpc8xxx_wdt: could not be enabled in software\n");
500c919e AV	206	ret = -ENOSYS;
	207	goto err_unmap;
	208	}
	209
59ca1b0d	210	ret = misc_register(&mpc8xxx_wdt_miscdev);
fabbfb9e	211	if (ret) {
ef8ab12e AV	212	pr_err("cannot register miscdev on minor=%d (err=%d)\n",
ef8ab12e AV	213	WATCHDOG_MINOR, ret);
fabbfb9e KG	214	goto err_unmap;
	215	}
	216
	217	/* Calculate the timeout in seconds */
	218	if (prescale)
500c919e	219	timeout_sec = (timeout * wdt_type->prescaler) / freq;
fabbfb9e	220	else
ef8ab12e	221	timeout_sec = timeout / freq;
fabbfb9e	222
59ca1b0d	223	pr_info("WDT driver for MPC8xxx initialized. mode:%s timeout=%d "
ef8ab12e AV	224	"(%d seconds)\n", reset ? "reset" : "interrupt", timeout,
ef8ab12e AV	225	timeout_sec);
500c919e AV	226
	227	/*
	228	* If the watchdog was previously enabled or we're running on
59ca1b0d	229	* MPC8xxx, we should ping the wdt from the kernel until the
500c919e AV	230	* userspace handles it.
	231	*/
	232	if (enabled)
59ca1b0d	233	mpc8xxx_wdt_timer_ping(0);
fabbfb9e	234	return 0;
fabbfb9e KG	235	err_unmap:
fabbfb9e KG	236	iounmap(wd_base);
fabbfb9e KG	237	return ret;
	238	}
	239
59ca1b0d	240	static int __devexit mpc8xxx_wdt_remove(struct of_device *ofdev)
fabbfb9e	241	{
59ca1b0d	242	mpc8xxx_wdt_pr_warn("watchdog removed");
500c919e	243	del_timer_sync(&wdt_timer);
59ca1b0d	244	misc_deregister(&mpc8xxx_wdt_miscdev);
fabbfb9e KG	245	iounmap(wd_base);
	246
	247	return 0;
	248	}
	249
59ca1b0d	250	static const struct of_device_id mpc8xxx_wdt_match[] = {
ef8ab12e AV	251	{
ef8ab12e AV	252	.compatible = "mpc83xx_wdt",
59ca1b0d	253	.data = &(struct mpc8xxx_wdt_type) {
500c919e AV	254	.prescaler = 0x10000,
	255	},
	256	},
	257	{
	258	.compatible = "fsl,mpc8610-wdt",
59ca1b0d	259	.data = &(struct mpc8xxx_wdt_type) {
500c919e AV	260	.prescaler = 0x10000,
	261	.hw_enabled = true,
	262	},
ef8ab12e AV	263	},
	264	{},
	265	};
59ca1b0d	266	MODULE_DEVICE_TABLE(of, mpc8xxx_wdt_match);
ef8ab12e	267
59ca1b0d AV	268	static struct of_platform_driver mpc8xxx_wdt_driver = {
	269	.match_table = mpc8xxx_wdt_match,
	270	.probe = mpc8xxx_wdt_probe,
	271	.remove = __devexit_p(mpc8xxx_wdt_remove),
fabbfb9e	272	.driver = {
59ca1b0d	273	.name = "mpc8xxx_wdt",
f37d193c	274	.owner = THIS_MODULE,
fabbfb9e KG	275	},
	276	};
	277
59ca1b0d	278	static int __init mpc8xxx_wdt_init(void)
fabbfb9e	279	{
59ca1b0d	280	return of_register_platform_driver(&mpc8xxx_wdt_driver);
fabbfb9e KG	281	}
fabbfb9e KG	282
59ca1b0d	283	static void __exit mpc8xxx_wdt_exit(void)
fabbfb9e	284	{
59ca1b0d	285	of_unregister_platform_driver(&mpc8xxx_wdt_driver);
fabbfb9e KG	286	}
fabbfb9e KG	287
59ca1b0d AV	288	subsys_initcall(mpc8xxx_wdt_init);
59ca1b0d AV	289	module_exit(mpc8xxx_wdt_exit);
fabbfb9e KG	290
fabbfb9e KG	291	MODULE_AUTHOR("Dave Updegraff, Kumar Gala");
500c919e	292	MODULE_DESCRIPTION("Driver for watchdog timer in MPC83xx/MPC86xx uProcessors");
fabbfb9e KG	293	MODULE_LICENSE("GPL");
fabbfb9e KG	294	MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);