path: root/target/linux/storm/patches/009-watchdog.patch

--- a/arch/arm/mach-sl2312/sl3516_device.c
+++ b/arch/arm/mach-sl2312/sl3516_device.c
@@ -76,9 +76,30 @@
 	.resource       = sl3516_sata0_resources,
 };
 
+static struct resource sl351x_wdt_resources[] = {
+	[0] = {
+		.start  = SL2312_WAQTCHDOG_BASE + 0x00,
+		.end    = SL2312_WAQTCHDOG_BASE + 0x1C,
+		.flags  = IORESOURCE_MEM,
+	},
+	[1] = {
+		.start  = IRQ_WATCHDOG,
+		.end    = IRQ_WATCHDOG,
+		.flags  = IORESOURCE_IRQ,
+	},
+};
+
+static struct platform_device sl351x_wdt = {
+	.name		= "sl351x-wdt",
+	.id		= -1,
+	.resource	= sl351x_wdt_resources,
+	.num_resources	= ARRAY_SIZE(sl351x_wdt_resources),
+};
+
 static struct platform_device *sata_devices[] __initdata = {
 	&sata_device,
 	&sata0_device,
+	&sl351x_wdt,
 };
 
 static int __init sl3516_init(void)
--- a/drivers/char/watchdog/Kconfig
+++ b/drivers/char/watchdog/Kconfig
@@ -171,6 +171,17 @@
 	  To compile this driver as a module, choose M here: the
 	  module will be called ep93xx_wdt.
 
+config WATCHDOG_SL351X
+	tristate "SL351x Watchdog"
+	depends on WATCHDOG && ARCH_SL2312
+	help
+	  This driver adds watchdog support for the integrated watchdog in the
+	  SL351x processors (Farraday core). If you have one of these processors
+	  and wish to have watchdog support enabled, say Y, otherwise say N.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called sl351x_wdt.
+
 config OMAP_WATCHDOG
 	tristate "OMAP Watchdog"
 	depends on ARCH_OMAP16XX || ARCH_OMAP24XX
--- a/drivers/char/watchdog/Makefile
+++ b/drivers/char/watchdog/Makefile
@@ -36,6 +36,7 @@
 obj-$(CONFIG_SA1100_WATCHDOG) += sa1100_wdt.o
 obj-$(CONFIG_MPCORE_WATCHDOG) += mpcore_wdt.o
 obj-$(CONFIG_EP93XX_WATCHDOG) += ep93xx_wdt.o
+obj-$(CONFIG_WATCHDOG_SL351X) += sl351x_wdt.o
 obj-$(CONFIG_PNX4008_WATCHDOG) += pnx4008_wdt.o
 obj-$(CONFIG_IOP_WATCHDOG) += iop_wdt.o
 obj-$(CONFIG_DAVINCI_WATCHDOG) += davinci_wdt.o
--- /dev/null
+++ b/drivers/char/watchdog/sl351x_wdt.c
@@ -0,0 +1,332 @@
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/platform_device.h>
+#include <asm/uaccess.h>
+#include <asm/arch/sl2312.h>
+#include <asm/arch/hardware.h>
+#include <asm/arch/irqs.h>
+#include <asm/arch/watchdog.h>
+#include <asm/io.h>
+#include <linux/interrupt.h>
+
+#define WATCHDOG_TEST 1
+#define PFX "sl351x-wdt: "
+
+#define _WATCHDOG_COUNTER  0x00
+#define _WATCHDOG_LOAD     0x04
+#define _WATCHDOG_RESTART  0x08
+#define _WATCHDOG_CR       0x0C
+#define _WATCHDOG_STATUS   0x10
+#define _WATCHDOG_CLEAR    0x14
+#define _WATCHDOG_INTRLEN  0x18
+
+static struct resource  *wdt_mem;
+static struct resource  *wdt_irq;
+static void __iomem     *wdt_base;
+static int 		wdt_margin = WATCHDOG_TIMEOUT_MARGIN;	/* in range of 0 .. 60s */
+
+static int open_state = WATCHDOG_DRIVER_CLOSE;
+static int wd_expire = 0;
+
+static void watchdog_enable(void)
+{
+	unsigned long wdcr;
+
+	wdcr = readl(wdt_base + _WATCHDOG_CR);
+	wdcr |= (WATCHDOG_WDENABLE_MSK|WATCHDOG_WDRST_MSK);
+#ifdef WATCHDOG_TEST
+	wdcr |= WATCHDOG_WDINTR_MSK;
+//	wdcr &= ~WATCHDOG_WDRST_MSK;
+#endif
+	wdcr &= ~WATCHDOG_WDCLOCK_MSK;
+	writel(wdcr, wdt_base + _WATCHDOG_CR);
+}
+
+static void watchdog_set_timeout(unsigned long timeout)
+{
+	timeout = WATCHDOG_TIMEOUT_SCALE * timeout;
+	writel(timeout, wdt_base + _WATCHDOG_LOAD);
+	writel(WATCHDOG_RESTART_VALUE, wdt_base + _WATCHDOG_RESTART);
+}
+
+static void watchdog_keepalive(void)
+{
+	writel(WATCHDOG_RESTART_VALUE, wdt_base + _WATCHDOG_RESTART);
+}
+
+static void watchdog_disable(void)
+{
+	unsigned long wdcr;
+
+	wdcr = readl(wdt_base + _WATCHDOG_CR);
+	wdcr &= ~WATCHDOG_WDENABLE_MSK;
+	writel(wdcr, wdt_base + _WATCHDOG_CR);
+}
+
+
+#ifdef WATCHDOG_TEST
+static irqreturn_t watchdog_irq(int irq, void *dev_id, struct pt_regs *regs)
+{
+	unsigned int clear;
+
+	writel(WATCHDOG_CLEAR_STATUS, wdt_base + _WATCHDOG_CLEAR);
+	printk(KERN_INFO PFX "Watchdog timeout, resetting system...\n");
+
+	clear = __raw_readl(IO_ADDRESS(SL2312_INTERRUPT_BASE)+0x0C);
+	clear &= 0x01;
+	__raw_writel(clear,IO_ADDRESS(SL2312_INTERRUPT_BASE)+0x08);
+	wd_expire = 1;
+	return IRQ_HANDLED;
+}
+
+#endif
+
+#define OPTIONS WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE
+static struct watchdog_info sl351x_wdt_ident = {
+	.options          =     OPTIONS,
+	.firmware_version =     0,
+	.identity         =     "sl351x Watchdog",
+};
+
+struct file_operations watchdog_fops = {
+	.write		= watchdog_write,
+	.read		= watchdog_read,
+	.open		= watchdog_open,
+	.release	= watchdog_release,
+	.ioctl		= watchdog_ioctl,
+};
+
+static int watchdog_open(struct inode *inode, struct file *filp)
+{
+	if (open_state == WATCHDOG_DRIVER_OPEN)
+		return -EBUSY;
+
+	wd_expire = 0;
+
+	watchdog_disable();
+	watchdog_set_timeout(wdt_margin);
+	watchdog_enable();
+
+	printk(KERN_INFO PFX "watchog timer enabled, margin: %ds.\n", wdt_margin);
+	open_state = WATCHDOG_DRIVER_OPEN;
+
+	return nonseekable_open(inode, filp);
+}
+
+static int watchdog_release(struct inode *inode, struct file *filp)
+{
+	watchdog_disable();
+
+	open_state = WATCHDOG_DRIVER_CLOSE;
+	wd_expire = 0;
+	printk(KERN_INFO PFX "watchog timer disabled, margin: %ds.\n", wdt_margin);
+
+	return 0;
+}
+
+static ssize_t watchdog_read(struct file *filp, char *buf, size_t count, loff_t *off)
+{
+	int i;
+	unsigned long val;
+
+
+	for(i=0;i< count;i++)
+	{
+		if ((i%4)==0)
+			val = *((unsigned long *)WATCHDOG_COUNTER);
+		buf[i] = (val & 0xFF);
+		val >>= 8;
+	}
+	return count;
+}
+
+static ssize_t watchdog_write(struct file *filp, const char *buf, size_t len, loff_t *off)
+{
+	/*  Refresh the timer. */
+	if (len) {
+		watchdog_keepalive();
+	}
+	return len;
+
+}
+
+static int watchdog_ioctl(struct inode *inode, struct file *filp,
+			  unsigned int cmd, unsigned long arg)
+{
+	void __user *argp = (void __user *)arg;
+	int margin;
+
+	switch(cmd)
+	{
+	case WDIOC_GETSUPPORT:
+		return copy_to_user(argp, &sl351x_wdt_ident,
+				    sizeof(sl351x_wdt_ident)) ? -EFAULT : 0;
+
+	case WDIOC_GETSTATUS:
+	case WDIOC_GETBOOTSTATUS:
+		return put_user(0, (int __user*)argp);
+
+	case WDIOC_KEEPALIVE:
+		watchdog_keepalive();
+		return 0;
+
+	case WDIOC_SETTIMEOUT:
+		if (get_user(margin, (int __user*)argp))
+			return -EFAULT;
+
+		/* Arbitrary, can't find the card's limits */
+		if ((margin < 0) || (margin > 60))
+			return -EINVAL;
+
+		// watchdog_disable();
+		wdt_margin = margin;
+		watchdog_set_timeout(margin);
+		watchdog_keepalive();
+		// watchdog_enable();
+
+		/* Fall through */
+
+	case WDIOC_GETTIMEOUT:
+		return put_user(wdt_margin, (int *)arg);
+
+	default:
+		return -ENOIOCTLCMD;
+	}
+}
+
+static struct miscdevice wd_dev= {
+	WATCHDOG_MINOR,
+	"watchdog",
+	&watchdog_fops
+};
+
+static char banner[] __initdata = KERN_INFO "SL351x Watchdog Timer, (c) 2007 WILIBOX\n";
+
+static int sl351x_wdt_probe(struct platform_device *pdev)
+{
+	struct resource *res;
+	int ret, size;
+	unsigned long wdcr;
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (res == NULL) {
+		printk(KERN_INFO PFX "failed to get memory region resouce\n");
+		return -ENOMEM;
+	}
+
+	size = (res->end-res->start)+1;
+
+	wdt_mem = request_mem_region(res->start, size, pdev->name);
+	if (wdt_mem == NULL) {
+		printk(KERN_INFO PFX "failed to get memory region\n");
+		return -ENOENT;
+	}
+
+	wdt_base = ioremap(res->start, size);
+	if (wdt_base == NULL) {
+		printk(KERN_INFO PFX "failed to ioremap() region\n");
+		return -EINVAL;
+	}
+
+	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+	if (res == NULL) {
+		 printk(KERN_INFO PFX "failed to get irq resource\n");
+		 return -ENOENT;
+	}
+
+	wdt_irq = res;
+
+	ret = request_irq(res->start, watchdog_irq, 0, pdev->name, pdev);
+	if (ret != 0) {
+		printk(KERN_INFO PFX "failed to install irq (%d)\n", ret);
+		return ret;
+	}
+
+	wdcr = readl(wdt_base + _WATCHDOG_CR);
+	if (wdcr & WATCHDOG_WDENABLE_MSK) {
+		printk(KERN_INFO PFX "Found watchdog in enabled state, reseting ...\n");
+		wdcr &= ~WATCHDOG_WDENABLE_MSK;
+		writel(wdcr, wdt_base + _WATCHDOG_CR);
+	}
+
+	ret = misc_register(&wd_dev);
+
+	return ret;
+}
+
+static int sl351x_wdt_remove(struct platform_device *pdev)
+{
+	if (wdt_base != NULL) {
+		iounmap(wdt_base);
+		wdt_base = NULL;
+	}
+
+	if (wdt_irq != NULL) {
+		free_irq(wdt_irq->start, pdev);
+		release_resource(wdt_irq);
+		wdt_irq = NULL;
+	}
+
+	if (wdt_mem != NULL) {
+		release_resource(wdt_mem);
+		wdt_mem = NULL;
+	}
+
+	misc_deregister(&wd_dev);
+
+	return 0;
+}
+
+static void sl351x_wdt_shutdown(struct platform_device *dev)
+{
+	watchdog_disable();
+}
+
+#ifdef CONFIG_PM
+static int sl351x_wdt_suspend(struct platform_device *dev, pm_message_t state)
+{
+	watchdog_disable();
+}
+
+static int sl351x_wdt_resume(struct platform_device *dev)
+{
+	watchdog_set_timeout(wdt_margin);
+	watchdog_enable();
+}
+
+#else
+#define sl351x_wdt_suspend	NULL
+#define sl351x_wdt_resume	NULL
+#endif
+
+static struct platform_driver sl351x_wdt_driver = {
+	.probe          = sl351x_wdt_probe,
+	.remove         = sl351x_wdt_remove,
+	.shutdown       = sl351x_wdt_shutdown,
+	.suspend        = sl351x_wdt_suspend,
+	.resume         = sl351x_wdt_resume,
+	.driver         = {
+		.owner  = THIS_MODULE,
+		.name   = "sl351x-wdt",
+	},
+};
+
+static int __init watchdog_init(void)
+{
+	printk(banner);
+	return platform_driver_register(&sl351x_wdt_driver);
+}
+
+static void __exit watchdog_exit(void)
+{
+	platform_driver_unregister(&sl351x_wdt_driver);
+}
+
+module_init(watchdog_init);
+module_exit(watchdog_exit);