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

#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/watchdog.h>
#include <linux/io.h>
#include <linux/spinlock.h>
#include <linux/of_platform.h>
#include <linux/uaccess.h>
#include <asm/mpc52xx.h>


#define GPT_MODE_WDT		(1 << 15)
#define GPT_MODE_CE		(1 << 12)
#define GPT_MODE_MS_TIMER	(0x4)


struct mpc5200_wdt {
	unsigned count;	/* timer ticks before watchdog kicks in */
	long ipb_freq;
	struct miscdevice miscdev;
	struct resource mem;
	struct mpc52xx_gpt __iomem *regs;
	spinlock_t io_lock;
};

/* is_active stores wether or not the /dev/watchdog device is opened */
static unsigned long is_active;

/* misc devices don't provide a way, to get back to 'dev' or 'miscdev' from
 * file operations, which sucks. But there can be max 1 watchdog anyway, so...
 */
static struct mpc5200_wdt *wdt_global;


/* helper to calculate timeout in timer counts */
static void mpc5200_wdt_set_timeout(struct mpc5200_wdt *wdt, int timeout)
{
	/* use biggest prescaler of 64k */
	wdt->count = (wdt->ipb_freq + 0xffff) / 0x10000 * timeout;

	if (wdt->count > 0xffff)
		wdt->count = 0xffff;
}
/* return timeout in seconds (calculated from timer count) */
static int mpc5200_wdt_get_timeout(struct mpc5200_wdt *wdt)
{
	return wdt->count * 0x10000 / wdt->ipb_freq;
}


/* watchdog operations */
static int mpc5200_wdt_start(struct mpc5200_wdt *wdt)
{
	spin_lock(&wdt->io_lock);
	/* disable */
	out_be32(&wdt->regs->mode, 0);
	/* set timeout, with maximum prescaler */
	out_be32(&wdt->regs->count, 0x0 | wdt->count);
	/* enable watchdog */
	out_be32(&wdt->regs->mode, GPT_MODE_CE | GPT_MODE_WDT |
						GPT_MODE_MS_TIMER);
	spin_unlock(&wdt->io_lock);

	return 0;
}
static int mpc5200_wdt_ping(struct mpc5200_wdt *wdt)
{
	spin_lock(&wdt->io_lock);
	/* writing A5 to OCPW resets the watchdog */
	out_be32(&wdt->regs->mode, 0xA5000000 |
				(0xffffff & in_be32(&wdt->regs->mode)));
	spin_unlock(&wdt->io_lock);
	return 0;
}
static int mpc5200_wdt_stop(struct mpc5200_wdt *wdt)
{
	spin_lock(&wdt->io_lock);
	/* disable */
	out_be32(&wdt->regs->mode, 0);
	spin_unlock(&wdt->io_lock);
	return 0;
}


/* file operations */
static ssize_t mpc5200_wdt_write(struct file *file, const char __user *data,
		size_t len, loff_t *ppos)
{
	struct mpc5200_wdt *wdt = file->private_data;
	mpc5200_wdt_ping(wdt);
	return 0;
}
static struct watchdog_info mpc5200_wdt_info = {
	.options	= WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
	.identity	= "mpc5200 watchdog on GPT0",
};
static long mpc5200_wdt_ioctl(struct file *file, unsigned int cmd,
							unsigned long arg)
{
	struct mpc5200_wdt *wdt = file->private_data;
	int __user *data = (int __user *)arg;
	int timeout;
	int ret = 0;

	switch (cmd) {
	case WDIOC_GETSUPPORT:
		ret = copy_to_user(data, &mpc5200_wdt_info,
						sizeof(mpc5200_wdt_info));
		if (ret)
			ret = -EFAULT;
		break;

	case WDIOC_GETSTATUS:
	case WDIOC_GETBOOTSTATUS:
		ret = put_user(0, data);
		break;

	case WDIOC_KEEPALIVE:
		mpc5200_wdt_ping(wdt);
		break;

	case WDIOC_SETTIMEOUT:
		ret = get_user(timeout, data);
		if (ret)
			break;
		mpc5200_wdt_set_timeout(wdt, timeout);
		mpc5200_wdt_start(wdt);
		/* fall through and return the timeout */

	case WDIOC_GETTIMEOUT:
		timeout = mpc5200_wdt_get_timeout(wdt);
		ret = put_user(timeout, data);
		break;

	default:
		ret = -ENOTTY;
	}
	return ret;
}

static int mpc5200_wdt_open(struct inode *inode, struct file *file)
{
	/* /dev/watchdog can only be opened once */
	if (test_and_set_bit(0, &is_active))
		return -EBUSY;

	/* Set and activate the watchdog */
	mpc5200_wdt_set_timeout(wdt_global, 30);
	mpc5200_wdt_start(wdt_global);
	file->private_data = wdt_global;
	return nonseekable_open(inode, file);
}
static int mpc5200_wdt_release(struct inode *inode, struct file *file)
{
#if WATCHDOG_NOWAYOUT == 0
	struct mpc5200_wdt *wdt = file->private_data;
	mpc5200_wdt_stop(wdt);
	wdt->count = 0;		/* == disabled */
#endif
	clear_bit(0, &is_active);
	return 0;
}

static const struct file_operations mpc5200_wdt_fops = {
	.owner	= THIS_MODULE,
	.write	= mpc5200_wdt_write,
	.unlocked_ioctl	= mpc5200_wdt_ioctl,
	.open	= mpc5200_wdt_open,
	.release = mpc5200_wdt_release,
};

/* module operations */
static int mpc5200_wdt_probe(struct of_device *op,
					const struct of_device_id *match)
{
	struct mpc5200_wdt *wdt;
	int err;
	const void *has_wdt;
	int size;

	has_wdt = of_get_property(op->node, "has-wdt", NULL);
	if (!has_wdt)
		has_wdt = of_get_property(op->node, "fsl,has-wdt", NULL);
	if (!has_wdt)
		return -ENODEV;

	wdt = kzalloc(sizeof(*wdt), GFP_KERNEL);
	if (!wdt)
		return -ENOMEM;

	wdt->ipb_freq = mpc52xx_find_ipb_freq(op->node);

	err = of_address_to_resource(op->node, 0, &wdt->mem);
	if (err)
		goto out_free;
	size = wdt->mem.end - wdt->mem.start + 1;
	if (!request_mem_region(wdt->mem.start, size, "mpc5200_wdt")) {
		err = -ENODEV;
		goto out_free;
	}
	wdt->regs = ioremap(wdt->mem.start, size);
	if (!wdt->regs) {
		err = -ENODEV;
		goto out_release;
	}

	dev_set_drvdata(&op->dev, wdt);
	spin_lock_init(&wdt->io_lock);

	wdt->miscdev = (struct miscdevice) {
		.minor	= WATCHDOG_MINOR,
		.name	= "watchdog",
		.fops	= &mpc5200_wdt_fops,
		.parent = &op->dev,
	};
	wdt_global = wdt;
	err = misc_register(&wdt->miscdev);
	if (!err)
		return 0;

	iounmap(wdt->regs);
out_release:
	release_mem_region(wdt->mem.start, size);
out_free:
	kfree(wdt);
	return err;
}

static int mpc5200_wdt_remove(struct of_device *op)
{
	struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);

	mpc5200_wdt_stop(wdt);
	misc_deregister(&wdt->miscdev);
	iounmap(wdt->regs);
	release_mem_region(wdt->mem.start, wdt->mem.end - wdt->mem.start + 1);
	kfree(wdt);

	return 0;
}
static int mpc5200_wdt_suspend(struct of_device *op, pm_message_t state)
{
	struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	mpc5200_wdt_stop(wdt);
	return 0;
}
static int mpc5200_wdt_resume(struct of_device *op)
{
	struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	if (wdt->count)
		mpc5200_wdt_start(wdt);
	return 0;
}
static int mpc5200_wdt_shutdown(struct of_device *op)
{
	struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	mpc5200_wdt_stop(wdt);
	return 0;
}

static struct of_device_id mpc5200_wdt_match[] = {
	{ .compatible = "mpc5200-gpt", },
	{ .compatible = "fsl,mpc5200-gpt", },
	{},
};
static struct of_platform_driver mpc5200_wdt_driver = {
	.owner		= THIS_MODULE,
	.name		= "mpc5200-gpt-wdt",
	.match_table	= mpc5200_wdt_match,
	.probe		= mpc5200_wdt_probe,
	.remove		= mpc5200_wdt_remove,
	.suspend	= mpc5200_wdt_suspend,
	.resume		= mpc5200_wdt_resume,
	.shutdown	= mpc5200_wdt_shutdown,
};


static int __init mpc5200_wdt_init(void)
{
	return of_register_platform_driver(&mpc5200_wdt_driver);
}

static void __exit mpc5200_wdt_exit(void)
{
	of_unregister_platform_driver(&mpc5200_wdt_driver);
}

module_init(mpc5200_wdt_init);
module_exit(mpc5200_wdt_exit);

MODULE_AUTHOR("Domen Puncer <domen.puncer@telargo.com>");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
Commit	Line	Data
8cf18971 DP	1	#include <linux/init.h>
	2	#include <linux/module.h>
	3	#include <linux/miscdevice.h>
	4	#include <linux/watchdog.h>
	5	#include <linux/io.h>
de81225a	6	#include <linux/spinlock.h>
f26ef3dc AC	7	#include <linux/of_platform.h>
f26ef3dc AC	8	#include <linux/uaccess.h>
8cf18971 DP	9	#include <asm/mpc52xx.h>
	10
	11
143a2e54 WVS	12	#define GPT_MODE_WDT (1 << 15)
143a2e54 WVS	13	#define GPT_MODE_CE (1 << 12)
8cf18971 DP	14	#define GPT_MODE_MS_TIMER (0x4)
	15
	16
	17	struct mpc5200_wdt {
	18	unsigned count; /* timer ticks before watchdog kicks in */
	19	long ipb_freq;
	20	struct miscdevice miscdev;
	21	struct resource mem;
	22	struct mpc52xx_gpt __iomem *regs;
de81225a	23	spinlock_t io_lock;
8cf18971 DP	24	};
8cf18971 DP	25
de81225a WVS	26	/* is_active stores wether or not the /dev/watchdog device is opened */
de81225a WVS	27	static unsigned long is_active;
8cf18971 DP	28
	29	/* misc devices don't provide a way, to get back to 'dev' or 'miscdev' from
	30	* file operations, which sucks. But there can be max 1 watchdog anyway, so...
	31	*/
	32	static struct mpc5200_wdt *wdt_global;
	33
	34
	35	/* helper to calculate timeout in timer counts */
	36	static void mpc5200_wdt_set_timeout(struct mpc5200_wdt *wdt, int timeout)
	37	{
	38	/* use biggest prescaler of 64k */
	39	wdt->count = (wdt->ipb_freq + 0xffff) / 0x10000 * timeout;
	40
	41	if (wdt->count > 0xffff)
	42	wdt->count = 0xffff;
	43	}
	44	/* return timeout in seconds (calculated from timer count) */
	45	static int mpc5200_wdt_get_timeout(struct mpc5200_wdt *wdt)
	46	{
	47	return wdt->count * 0x10000 / wdt->ipb_freq;
	48	}
	49
	50
	51	/* watchdog operations */
	52	static int mpc5200_wdt_start(struct mpc5200_wdt *wdt)
	53	{
de81225a	54	spin_lock(&wdt->io_lock);
8cf18971 DP	55	/* disable */
	56	out_be32(&wdt->regs->mode, 0);
	57	/* set timeout, with maximum prescaler */
	58	out_be32(&wdt->regs->count, 0x0 \| wdt->count);
	59	/* enable watchdog */
f26ef3dc AC	60	out_be32(&wdt->regs->mode, GPT_MODE_CE \| GPT_MODE_WDT \|
f26ef3dc AC	61	GPT_MODE_MS_TIMER);
de81225a	62	spin_unlock(&wdt->io_lock);
8cf18971 DP	63
	64	return 0;
	65	}
	66	static int mpc5200_wdt_ping(struct mpc5200_wdt *wdt)
	67	{
de81225a	68	spin_lock(&wdt->io_lock);
8cf18971	69	/* writing A5 to OCPW resets the watchdog */
f26ef3dc AC	70	out_be32(&wdt->regs->mode, 0xA5000000 \|
f26ef3dc AC	71	(0xffffff & in_be32(&wdt->regs->mode)));
de81225a	72	spin_unlock(&wdt->io_lock);
8cf18971 DP	73	return 0;
	74	}
	75	static int mpc5200_wdt_stop(struct mpc5200_wdt *wdt)
	76	{
de81225a WVS	77	spin_lock(&wdt->io_lock);
de81225a WVS	78	/* disable */
8cf18971	79	out_be32(&wdt->regs->mode, 0);
de81225a	80	spin_unlock(&wdt->io_lock);
8cf18971 DP	81	return 0;
	82	}
	83
	84
	85	/* file operations */
a39f9d02	86	static ssize_t mpc5200_wdt_write(struct file file, const char __user data,
8cf18971 DP	87	size_t len, loff_t *ppos)
	88	{
	89	struct mpc5200_wdt *wdt = file->private_data;
	90	mpc5200_wdt_ping(wdt);
	91	return 0;
	92	}
	93	static struct watchdog_info mpc5200_wdt_info = {
	94	.options = WDIOF_SETTIMEOUT \| WDIOF_KEEPALIVEPING,
	95	.identity = "mpc5200 watchdog on GPT0",
	96	};
f26ef3dc AC	97	static long mpc5200_wdt_ioctl(struct file *file, unsigned int cmd,
f26ef3dc AC	98	unsigned long arg)
8cf18971 DP	99	{
	100	struct mpc5200_wdt *wdt = file->private_data;
	101	int __user data = (int __user )arg;
	102	int timeout;
	103	int ret = 0;
	104
	105	switch (cmd) {
	106	case WDIOC_GETSUPPORT:
de81225a	107	ret = copy_to_user(data, &mpc5200_wdt_info,
f26ef3dc	108	sizeof(mpc5200_wdt_info));
8cf18971 DP	109	if (ret)
	110	ret = -EFAULT;
	111	break;
	112
de81225a WVS	113	case WDIOC_GETSTATUS:
	114	case WDIOC_GETBOOTSTATUS:
	115	ret = put_user(0, data);
	116	break;
	117
8cf18971 DP	118	case WDIOC_KEEPALIVE:
	119	mpc5200_wdt_ping(wdt);
	120	break;
	121
	122	case WDIOC_SETTIMEOUT:
	123	ret = get_user(timeout, data);
	124	if (ret)
	125	break;
	126	mpc5200_wdt_set_timeout(wdt, timeout);
	127	mpc5200_wdt_start(wdt);
	128	/* fall through and return the timeout */
	129
	130	case WDIOC_GETTIMEOUT:
	131	timeout = mpc5200_wdt_get_timeout(wdt);
	132	ret = put_user(timeout, data);
	133	break;
de81225a WVS	134
	135	default:
	136	ret = -ENOTTY;
8cf18971 DP	137	}
	138	return ret;
	139	}
f26ef3dc	140
8cf18971 DP	141	static int mpc5200_wdt_open(struct inode inode, struct file file)
8cf18971 DP	142	{
de81225a WVS	143	/* /dev/watchdog can only be opened once */
	144	if (test_and_set_bit(0, &is_active))
	145	return -EBUSY;
	146
	147	/* Set and activate the watchdog */
8cf18971 DP	148	mpc5200_wdt_set_timeout(wdt_global, 30);
	149	mpc5200_wdt_start(wdt_global);
	150	file->private_data = wdt_global;
de81225a	151	return nonseekable_open(inode, file);
8cf18971 DP	152	}
	153	static int mpc5200_wdt_release(struct inode inode, struct file file)
	154	{
	155	#if WATCHDOG_NOWAYOUT == 0
	156	struct mpc5200_wdt *wdt = file->private_data;
	157	mpc5200_wdt_stop(wdt);
	158	wdt->count = 0; /* == disabled */
	159	#endif
de81225a	160	clear_bit(0, &is_active);
8cf18971 DP	161	return 0;
	162	}
	163
b47a166e	164	static const struct file_operations mpc5200_wdt_fops = {
8cf18971 DP	165	.owner = THIS_MODULE,
8cf18971 DP	166	.write = mpc5200_wdt_write,
7944d3a5	167	.unlocked_ioctl = mpc5200_wdt_ioctl,
8cf18971 DP	168	.open = mpc5200_wdt_open,
	169	.release = mpc5200_wdt_release,
	170	};
	171
	172	/* module operations */
f26ef3dc AC	173	static int mpc5200_wdt_probe(struct of_device *op,
f26ef3dc AC	174	const struct of_device_id *match)
8cf18971 DP	175	{
	176	struct mpc5200_wdt *wdt;
	177	int err;
	178	const void *has_wdt;
	179	int size;
	180
	181	has_wdt = of_get_property(op->node, "has-wdt", NULL);
d24bc314 MB	182	if (!has_wdt)
d24bc314 MB	183	has_wdt = of_get_property(op->node, "fsl,has-wdt", NULL);
8cf18971 DP	184	if (!has_wdt)
	185	return -ENODEV;
	186
	187	wdt = kzalloc(sizeof(*wdt), GFP_KERNEL);
	188	if (!wdt)
	189	return -ENOMEM;
	190
	191	wdt->ipb_freq = mpc52xx_find_ipb_freq(op->node);
	192
	193	err = of_address_to_resource(op->node, 0, &wdt->mem);
	194	if (err)
	195	goto out_free;
	196	size = wdt->mem.end - wdt->mem.start + 1;
	197	if (!request_mem_region(wdt->mem.start, size, "mpc5200_wdt")) {
	198	err = -ENODEV;
	199	goto out_free;
	200	}
	201	wdt->regs = ioremap(wdt->mem.start, size);
	202	if (!wdt->regs) {
	203	err = -ENODEV;
	204	goto out_release;
	205	}
	206
	207	dev_set_drvdata(&op->dev, wdt);
de81225a	208	spin_lock_init(&wdt->io_lock);
8cf18971 DP	209
	210	wdt->miscdev = (struct miscdevice) {
	211	.minor = WATCHDOG_MINOR,
	212	.name = "watchdog",
	213	.fops = &mpc5200_wdt_fops,
	214	.parent = &op->dev,
	215	};
	216	wdt_global = wdt;
	217	err = misc_register(&wdt->miscdev);
	218	if (!err)
	219	return 0;
	220
	221	iounmap(wdt->regs);
7944d3a5	222	out_release:
8cf18971	223	release_mem_region(wdt->mem.start, size);
7944d3a5	224	out_free:
8cf18971 DP	225	kfree(wdt);
	226	return err;
	227	}
	228
	229	static int mpc5200_wdt_remove(struct of_device *op)
	230	{
	231	struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	232
	233	mpc5200_wdt_stop(wdt);
	234	misc_deregister(&wdt->miscdev);
	235	iounmap(wdt->regs);
	236	release_mem_region(wdt->mem.start, wdt->mem.end - wdt->mem.start + 1);
	237	kfree(wdt);
	238
	239	return 0;
	240	}
	241	static int mpc5200_wdt_suspend(struct of_device *op, pm_message_t state)
	242	{
	243	struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	244	mpc5200_wdt_stop(wdt);
	245	return 0;
	246	}
	247	static int mpc5200_wdt_resume(struct of_device *op)
	248	{
	249	struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	250	if (wdt->count)
	251	mpc5200_wdt_start(wdt);
	252	return 0;
	253	}
	254	static int mpc5200_wdt_shutdown(struct of_device *op)
	255	{
	256	struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	257	mpc5200_wdt_stop(wdt);
	258	return 0;
	259	}
	260
	261	static struct of_device_id mpc5200_wdt_match[] = {
	262	{ .compatible = "mpc5200-gpt", },
d24bc314	263	{ .compatible = "fsl,mpc5200-gpt", },
8cf18971 DP	264	{},
	265	};
	266	static struct of_platform_driver mpc5200_wdt_driver = {
	267	.owner = THIS_MODULE,
	268	.name = "mpc5200-gpt-wdt",
	269	.match_table = mpc5200_wdt_match,
	270	.probe = mpc5200_wdt_probe,
	271	.remove = mpc5200_wdt_remove,
	272	.suspend = mpc5200_wdt_suspend,
	273	.resume = mpc5200_wdt_resume,
	274	.shutdown = mpc5200_wdt_shutdown,
	275	};
	276
	277
	278	static int __init mpc5200_wdt_init(void)
	279	{
	280	return of_register_platform_driver(&mpc5200_wdt_driver);
	281	}
	282
	283	static void __exit mpc5200_wdt_exit(void)
	284	{
	285	of_unregister_platform_driver(&mpc5200_wdt_driver);
	286	}
	287
	288	module_init(mpc5200_wdt_init);
	289	module_exit(mpc5200_wdt_exit);
	290
	291	MODULE_AUTHOR("Domen Puncer <domen.puncer@telargo.com>");
	292	MODULE_LICENSE("Dual BSD/GPL");
de81225a	293	MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);