[WATCHDOG] mpc5200 watchdog (GPT0)

Driver for internal mpc5200 watchdog on general purpose timer 0. For IPB clock of 132 MHz the maximum timeout is about 32 seconds. Signed-off-by: Domen Puncer <domen.puncer@telargo.com> Signed-off-by: Wim Van Sebroeck <wim@iguana.be>

[WATCHDOG] mpc5200 watchdog (GPT0)
Driver for internal mpc5200 watchdog on general purpose timer 0. For IPB clock of 132 MHz the maximum timeout is about 32 seconds. Signed-off-by: Domen Puncer <domen.puncer@telargo.com> Signed-off-by: Wim Van Sebroeck <wim@iguana.be>
Domen Puncer · Wim Van Sebroeck
1 parent f695baf2df
Showing 3 changed files with 263 additions and 0 deletions Side-by-side Diff
drivers/char/watchdog/Kconfig
drivers/char/watchdog/Makefile
drivers/char/watchdog/mpc5200_wdt.c
@@ -546,6 +546,10 @@
 	tristate "MPC8xx Watchdog Timer"
 	depends on 8xx
  
+config MPC5200_WDT
+	tristate "MPC5200 Watchdog Timer"
+	depends on PPC_MPC52xx
+
 config 83xx_WDT
 	tristate "MPC83xx Watchdog Timer"
 	depends on PPC_83xx
@@ -68,6 +68,7 @@
  
 # PowerPC Architecture
 obj-$(CONFIG_8xx_WDT) += mpc8xx_wdt.o
+obj-$(CONFIG_MPC5200_WDT) += mpc5200_wdt.o
 obj-$(CONFIG_83xx_WDT) += mpc83xx_wdt.o
 obj-$(CONFIG_MV64X60_WDT) += mv64x60_wdt.o
 obj-$(CONFIG_BOOKE_WDT) += booke_wdt.o
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/io.h>
+#include <asm/of_platform.h>
+#include <asm/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;
+};
+
+
+/* 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)
+{
+	/* 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);
+
+	return 0;
+}
+static int mpc5200_wdt_ping(struct mpc5200_wdt *wdt)
+{
+	/* writing A5 to OCPW resets the watchdog */
+	out_be32(&wdt->regs->mode, 0xA5000000 | (0xffffff & in_be32(&wdt->regs->mode)));
+	return 0;
+}
+static int mpc5200_wdt_stop(struct mpc5200_wdt *wdt)
+{
+	out_be32(&wdt->regs->mode, 0);
+	return 0;
+}
+
+
+/* file operations */
+static ssize_t mpc5200_wdt_write(struct file *file, const char *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 int mpc5200_wdt_ioctl(struct inode *inode, 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_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;
+	}
+	return ret;
+}
+static int mpc5200_wdt_open(struct inode *inode, struct file *file)
+{
+	mpc5200_wdt_set_timeout(wdt_global, 30);
+	mpc5200_wdt_start(wdt_global);
+	file->private_data = wdt_global;
+	return 0;
+}
+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
+	return 0;
+}
+
+static struct file_operations mpc5200_wdt_fops = {
+	.owner	= THIS_MODULE,
+	.write	= mpc5200_wdt_write,
+	.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)
+		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);
+
+	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", },
+	{},
+};
+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");
...	...	@@ -546,6 +546,10 @@
546	546	tristate "MPC8xx Watchdog Timer"
547	547	depends on 8xx
548	548
	549	+config MPC5200_WDT
	550	+ tristate "MPC5200 Watchdog Timer"
	551	+ depends on PPC_MPC52xx
	552	+
549	553	config 83xx_WDT
550	554	tristate "MPC83xx Watchdog Timer"
551	555	depends on PPC_83xx
...	...	@@ -68,6 +68,7 @@
68	68
69	69	# PowerPC Architecture
70	70	obj-$(CONFIG_8xx_WDT) += mpc8xx_wdt.o
	71	+obj-$(CONFIG_MPC5200_WDT) += mpc5200_wdt.o
71	72	obj-$(CONFIG_83xx_WDT) += mpc83xx_wdt.o
72	73	obj-$(CONFIG_MV64X60_WDT) += mv64x60_wdt.o
73	74	obj-$(CONFIG_BOOKE_WDT) += booke_wdt.o
	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>
	6	+#include <asm/of_platform.h>
	7	+#include <asm/uaccess.h>
	8	+#include <asm/mpc52xx.h>
	9	+
	10	+
	11	+#define GPT_MODE_WDT (1<<15)
	12	+#define GPT_MODE_CE (1<<12)
	13	+#define GPT_MODE_MS_TIMER (0x4)
	14	+
	15	+
	16	+struct mpc5200_wdt {
	17	+ unsigned count; /* timer ticks before watchdog kicks in */
	18	+ long ipb_freq;
	19	+ struct miscdevice miscdev;
	20	+ struct resource mem;
	21	+ struct mpc52xx_gpt __iomem *regs;
	22	+};
	23	+
	24	+
	25	+/* misc devices don't provide a way, to get back to 'dev' or 'miscdev' from
	26	+ * file operations, which sucks. But there can be max 1 watchdog anyway, so...
	27	+ */
	28	+static struct mpc5200_wdt *wdt_global;
	29	+
	30	+
	31	+/* helper to calculate timeout in timer counts */
	32	+static void mpc5200_wdt_set_timeout(struct mpc5200_wdt *wdt, int timeout)
	33	+{
	34	+ /* use biggest prescaler of 64k */
	35	+ wdt->count = (wdt->ipb_freq + 0xffff) / 0x10000 * timeout;
	36	+
	37	+ if (wdt->count > 0xffff)
	38	+ wdt->count = 0xffff;
	39	+}
	40	+/* return timeout in seconds (calculated from timer count) */
	41	+static int mpc5200_wdt_get_timeout(struct mpc5200_wdt *wdt)
	42	+{
	43	+ return wdt->count * 0x10000 / wdt->ipb_freq;
	44	+}
	45	+
	46	+
	47	+/* watchdog operations */
	48	+static int mpc5200_wdt_start(struct mpc5200_wdt *wdt)
	49	+{
	50	+ /* disable */
	51	+ out_be32(&wdt->regs->mode, 0);
	52	+ /* set timeout, with maximum prescaler */
	53	+ out_be32(&wdt->regs->count, 0x0 \| wdt->count);
	54	+ /* enable watchdog */
	55	+ out_be32(&wdt->regs->mode, GPT_MODE_CE \| GPT_MODE_WDT \| GPT_MODE_MS_TIMER);
	56	+
	57	+ return 0;
	58	+}
	59	+static int mpc5200_wdt_ping(struct mpc5200_wdt *wdt)
	60	+{
	61	+ /* writing A5 to OCPW resets the watchdog */
	62	+ out_be32(&wdt->regs->mode, 0xA5000000 \| (0xffffff & in_be32(&wdt->regs->mode)));
	63	+ return 0;
	64	+}
	65	+static int mpc5200_wdt_stop(struct mpc5200_wdt *wdt)
	66	+{
	67	+ out_be32(&wdt->regs->mode, 0);
	68	+ return 0;
	69	+}
	70	+
	71	+
	72	+/* file operations */
	73	+static ssize_t mpc5200_wdt_write(struct file file, const char data,
	74	+ size_t len, loff_t *ppos)
	75	+{
	76	+ struct mpc5200_wdt *wdt = file->private_data;
	77	+ mpc5200_wdt_ping(wdt);
	78	+ return 0;
	79	+}
	80	+static struct watchdog_info mpc5200_wdt_info = {
	81	+ .options = WDIOF_SETTIMEOUT \| WDIOF_KEEPALIVEPING,
	82	+ .identity = "mpc5200 watchdog on GPT0",
	83	+};
	84	+static int mpc5200_wdt_ioctl(struct inode inode, struct file file,
	85	+ unsigned int cmd, unsigned long arg)
	86	+{
	87	+ struct mpc5200_wdt *wdt = file->private_data;
	88	+ int __user data = (int __user )arg;
	89	+ int timeout;
	90	+ int ret = 0;
	91	+
	92	+ switch (cmd) {
	93	+ case WDIOC_GETSUPPORT:
	94	+ ret = copy_to_user(data, &mpc5200_wdt_info, sizeof(mpc5200_wdt_info));
	95	+ if (ret)
	96	+ ret = -EFAULT;
	97	+ break;
	98	+
	99	+ case WDIOC_KEEPALIVE:
	100	+ mpc5200_wdt_ping(wdt);
	101	+ break;
	102	+
	103	+ case WDIOC_SETTIMEOUT:
	104	+ ret = get_user(timeout, data);
	105	+ if (ret)
	106	+ break;
	107	+ mpc5200_wdt_set_timeout(wdt, timeout);
	108	+ mpc5200_wdt_start(wdt);
	109	+ /* fall through and return the timeout */
	110	+
	111	+ case WDIOC_GETTIMEOUT:
	112	+ timeout = mpc5200_wdt_get_timeout(wdt);
	113	+ ret = put_user(timeout, data);
	114	+ break;
	115	+ }
	116	+ return ret;
	117	+}
	118	+static int mpc5200_wdt_open(struct inode inode, struct file file)
	119	+{
	120	+ mpc5200_wdt_set_timeout(wdt_global, 30);
	121	+ mpc5200_wdt_start(wdt_global);
	122	+ file->private_data = wdt_global;
	123	+ return 0;
	124	+}
	125	+static int mpc5200_wdt_release(struct inode inode, struct file file)
	126	+{
	127	+#if WATCHDOG_NOWAYOUT == 0
	128	+ struct mpc5200_wdt *wdt = file->private_data;
	129	+ mpc5200_wdt_stop(wdt);
	130	+ wdt->count = 0; /* == disabled */
	131	+#endif
	132	+ return 0;
	133	+}
	134	+
	135	+static struct file_operations mpc5200_wdt_fops = {
	136	+ .owner = THIS_MODULE,
	137	+ .write = mpc5200_wdt_write,
	138	+ .ioctl = mpc5200_wdt_ioctl,
	139	+ .open = mpc5200_wdt_open,
	140	+ .release = mpc5200_wdt_release,
	141	+};
	142	+
	143	+/* module operations */
	144	+static int mpc5200_wdt_probe(struct of_device op, const struct of_device_id match)
	145	+{
	146	+ struct mpc5200_wdt *wdt;
	147	+ int err;
	148	+ const void *has_wdt;
	149	+ int size;
	150	+
	151	+ has_wdt = of_get_property(op->node, "has-wdt", NULL);
	152	+ if (!has_wdt)
	153	+ return -ENODEV;
	154	+
	155	+ wdt = kzalloc(sizeof(*wdt), GFP_KERNEL);
	156	+ if (!wdt)
	157	+ return -ENOMEM;
	158	+
	159	+ wdt->ipb_freq = mpc52xx_find_ipb_freq(op->node);
	160	+
	161	+ err = of_address_to_resource(op->node, 0, &wdt->mem);
	162	+ if (err)
	163	+ goto out_free;
	164	+ size = wdt->mem.end - wdt->mem.start + 1;
	165	+ if (!request_mem_region(wdt->mem.start, size, "mpc5200_wdt")) {
	166	+ err = -ENODEV;
	167	+ goto out_free;
	168	+ }
	169	+ wdt->regs = ioremap(wdt->mem.start, size);
	170	+ if (!wdt->regs) {
	171	+ err = -ENODEV;
	172	+ goto out_release;
	173	+ }
	174	+
	175	+ dev_set_drvdata(&op->dev, wdt);
	176	+
	177	+ wdt->miscdev = (struct miscdevice) {
	178	+ .minor = WATCHDOG_MINOR,
	179	+ .name = "watchdog",
	180	+ .fops = &mpc5200_wdt_fops,
	181	+ .parent = &op->dev,
	182	+ };
	183	+ wdt_global = wdt;
	184	+ err = misc_register(&wdt->miscdev);
	185	+ if (!err)
	186	+ return 0;
	187	+
	188	+ iounmap(wdt->regs);
	189	+ out_release:
	190	+ release_mem_region(wdt->mem.start, size);
	191	+ out_free:
	192	+ kfree(wdt);
	193	+ return err;
	194	+}
	195	+
	196	+static int mpc5200_wdt_remove(struct of_device *op)
	197	+{
	198	+ struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	199	+
	200	+ mpc5200_wdt_stop(wdt);
	201	+ misc_deregister(&wdt->miscdev);
	202	+ iounmap(wdt->regs);
	203	+ release_mem_region(wdt->mem.start, wdt->mem.end - wdt->mem.start + 1);
	204	+ kfree(wdt);
	205	+
	206	+ return 0;
	207	+}
	208	+static int mpc5200_wdt_suspend(struct of_device *op, pm_message_t state)
	209	+{
	210	+ struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	211	+ mpc5200_wdt_stop(wdt);
	212	+ return 0;
	213	+}
	214	+static int mpc5200_wdt_resume(struct of_device *op)
	215	+{
	216	+ struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	217	+ if (wdt->count)
	218	+ mpc5200_wdt_start(wdt);
	219	+ return 0;
	220	+}
	221	+static int mpc5200_wdt_shutdown(struct of_device *op)
	222	+{
	223	+ struct mpc5200_wdt *wdt = dev_get_drvdata(&op->dev);
	224	+ mpc5200_wdt_stop(wdt);
	225	+ return 0;
	226	+}
	227	+
	228	+static struct of_device_id mpc5200_wdt_match[] = {
	229	+ { .compatible = "mpc5200-gpt", },
	230	+ {},
	231	+};
	232	+static struct of_platform_driver mpc5200_wdt_driver = {
	233	+ .owner = THIS_MODULE,
	234	+ .name = "mpc5200-gpt-wdt",
	235	+ .match_table = mpc5200_wdt_match,
	236	+ .probe = mpc5200_wdt_probe,
	237	+ .remove = mpc5200_wdt_remove,
	238	+ .suspend = mpc5200_wdt_suspend,
	239	+ .resume = mpc5200_wdt_resume,
	240	+ .shutdown = mpc5200_wdt_shutdown,
	241	+};
	242	+
	243	+
	244	+static int __init mpc5200_wdt_init(void)
	245	+{
	246	+ return of_register_platform_driver(&mpc5200_wdt_driver);
	247	+}
	248	+
	249	+static void __exit mpc5200_wdt_exit(void)
	250	+{
	251	+ of_unregister_platform_driver(&mpc5200_wdt_driver);
	252	+}
	253	+
	254	+module_init(mpc5200_wdt_init);
	255	+module_exit(mpc5200_wdt_exit);
	256	+
	257	+MODULE_AUTHOR("Domen Puncer <domen.puncer@telargo.com>");
	258	+MODULE_LICENSE("Dual BSD/GPL");