16 files changed, 429 insertions, 61 deletions

diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index b87ba23442d2..afcfacc9bbe2 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -145,13 +145,19 @@ config KS8695_WATCHDOG
           Watchdog timer embedded into KS8695 processor. This will reboot your
           system when the timeout is reached.
 
+config HAVE_S3C2410_WATCHDOG
+        bool
+        help
+          This will include watchdog timer support for Samsung SoCs. If
+          you want to include watchdog support for any machine, kindly
+          select this in the respective mach-XXXX/Kconfig file.
+
 config S3C2410_WATCHDOG
         tristate "S3C2410 Watchdog"
-        depends on ARCH_S3C2410
+        depends on ARCH_S3C2410 || HAVE_S3C2410_WATCHDOG
         help
-          Watchdog timer block in the Samsung S3C2410 chips. This will
-          reboot the system when the timer expires with the watchdog
-          enabled.
+          Watchdog timer block in the Samsung SoCs. This will reboot
+          the system when the timer expires with the watchdog enabled.
 
           The driver is limited by the speed of the system's PCLK
           signal, so with reasonably fast systems (PCLK around 50-66MHz)
@@ -306,6 +312,18 @@ config MAX63XX_WATCHDOG
         help
           Support for memory mapped max63{69,70,71,72,73,74} watchdog timer.
 
+config IMX2_WDT
+        tristate "IMX2+ Watchdog"
+        depends on ARCH_MX2 || ARCH_MX25 || ARCH_MX3 || ARCH_MX5
+        help
+          This is the driver for the hardware watchdog
+          on the Freescale IMX2 and later processors.
+          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 imx2_wdt.
+
 # AVR32 Architecture
 
 config AT32AP700X_WDT
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index 5e3cb95bb0e9..72f3e2073f8e 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -47,6 +47,7 @@ obj-$(CONFIG_STMP3XXX_WATCHDOG) += stmp3xxx_wdt.o
 obj-$(CONFIG_NUC900_WATCHDOG) += nuc900_wdt.o
 obj-$(CONFIG_ADX_WATCHDOG) += adx_wdt.o
 obj-$(CONFIG_TS72XX_WATCHDOG) += ts72xx_wdt.o
+obj-$(CONFIG_IMX2_WDT) += imx2_wdt.o
 
 # AVR32 Architecture
 obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
diff --git a/drivers/watchdog/bfin_wdt.c b/drivers/watchdog/bfin_wdt.c
index 9c7ccd1e9088..9042a95fc98c 100644
--- a/drivers/watchdog/bfin_wdt.c
+++ b/drivers/watchdog/bfin_wdt.c
@@ -23,6 +23,7 @@
 #include <linux/interrupt.h>
 #include <linux/uaccess.h>
 #include <asm/blackfin.h>
+#include <asm/bfin_watchdog.h>
 
 #define stamp(fmt, args...) \
         pr_debug("%s:%i: " fmt "\n", __func__, __LINE__, ## args)
@@ -49,24 +50,6 @@
 # define bfin_write_WDOG_STAT(x) bfin_write_WDOGA_STAT(x)
 #endif
 
-/* Bit in SWRST that indicates boot caused by watchdog */
-#define SWRST_RESET_WDOG 0x4000
-
-/* Bit in WDOG_CTL that indicates watchdog has expired (WDR0) */
-#define WDOG_EXPIRED 0x8000
-
-/* Masks for WDEV field in WDOG_CTL register */
-#define ICTL_RESET   0x0
-#define ICTL_NMI     0x2
-#define ICTL_GPI     0x4
-#define ICTL_NONE    0x6
-#define ICTL_MASK    0x6
-
-/* Masks for WDEN field in WDOG_CTL register */
-#define WDEN_MASK    0x0FF0
-#define WDEN_ENABLE  0x0000
-#define WDEN_DISABLE 0x0AD0
-
 /* some defaults */
 #define WATCHDOG_TIMEOUT 20
 
diff --git a/drivers/watchdog/booke_wdt.c b/drivers/watchdog/booke_wdt.c
index 801ead191499..3d49671cdf5a 100644
--- a/drivers/watchdog/booke_wdt.c
+++ b/drivers/watchdog/booke_wdt.c
@@ -137,12 +137,12 @@ static long booke_wdt_ioctl(struct file *file,
                 if (copy_to_user((void *)arg, &ident, sizeof(ident)))
                         return -EFAULT;
         case WDIOC_GETSTATUS:
-                return put_user(ident.options, p);
+                return put_user(0, p);
         case WDIOC_GETBOOTSTATUS:
                 /* XXX: something is clearing TSR */
                 tmp = mfspr(SPRN_TSR) & TSR_WRS(3);
-                /* returns 1 if last reset was caused by the WDT */
-                return (tmp ? 1 : 0);
+                /* returns CARDRESET if last reset was caused by the WDT */
+                return (tmp ? WDIOF_CARDRESET : 0);
         case WDIOC_SETOPTIONS:
                 if (get_user(tmp, p))
                         return -EINVAL;
diff --git a/drivers/watchdog/eurotechwdt.c b/drivers/watchdog/eurotechwdt.c
index d1c4e55b1db0..3f3dc093ad68 100644
--- a/drivers/watchdog/eurotechwdt.c
+++ b/drivers/watchdog/eurotechwdt.c
@@ -68,7 +68,6 @@ static spinlock_t eurwdt_lock;
 
 /*
  * You must set these - there is no sane way to probe for this board.
- * You can use eurwdt=x,y to set these now.
  */
 
 static int io = 0x3f0;
diff --git a/drivers/watchdog/iTCO_vendor_support.c b/drivers/watchdog/iTCO_vendor_support.c
index 5133bca5ccbe..481d1ad43464 100644
--- a/drivers/watchdog/iTCO_vendor_support.c
+++ b/drivers/watchdog/iTCO_vendor_support.c
@@ -101,13 +101,6 @@ static void supermicro_old_pre_stop(unsigned long acpibase)
         outl(val32, SMI_EN);    /* Needed to deactivate watchdog */
 }
 
-static void supermicro_old_pre_keepalive(unsigned long acpibase)
-{
-        /* Reload TCO Timer (done in iTCO_wdt_keepalive) + */
-        /* Clear "Expire Flag" (Bit 3 of TC01_STS register) */
-        outb(0x08, TCO1_STS);
-}
-
 /*
  *      Vendor Support: 2
  *      Board: Super Micro Computer Inc. P4SBx, P4DPx
@@ -337,9 +330,7 @@ EXPORT_SYMBOL(iTCO_vendor_pre_stop);
 
 void iTCO_vendor_pre_keepalive(unsigned long acpibase, unsigned int heartbeat)
 {
-        if (vendorsupport == SUPERMICRO_OLD_BOARD)
-                supermicro_old_pre_keepalive(acpibase);
-        else if (vendorsupport == SUPERMICRO_NEW_BOARD)
+        if (vendorsupport == SUPERMICRO_NEW_BOARD)
                 supermicro_new_pre_set_heartbeat(heartbeat);
 }
 EXPORT_SYMBOL(iTCO_vendor_pre_keepalive);
diff --git a/drivers/watchdog/iTCO_wdt.c b/drivers/watchdog/iTCO_wdt.c
index 8da886035374..69de8713b8e4 100644
--- a/drivers/watchdog/iTCO_wdt.c
+++ b/drivers/watchdog/iTCO_wdt.c
@@ -40,7 +40,7 @@
 
 /* Module and version information */
 #define DRV_NAME        "iTCO_wdt"
-#define DRV_VERSION     "1.05"
+#define DRV_VERSION     "1.06"
 #define PFX             DRV_NAME ": "
 
 /* Includes */
@@ -391,8 +391,8 @@ static struct platform_device *iTCO_wdt_platform_device;
 #define WATCHDOG_HEARTBEAT 30   /* 30 sec default heartbeat */
 static int heartbeat = WATCHDOG_HEARTBEAT;  /* in seconds */
 module_param(heartbeat, int, 0);
-MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. "
-        "(2<heartbeat<39 (TCO v1) or 613 (TCO v2), default="
+MODULE_PARM_DESC(heartbeat, "Watchdog timeout in seconds. "
+        "5..76 (TCO v1) or 3..614 (TCO v2), default="
                                 __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
 
 static int nowayout = WATCHDOG_NOWAYOUT;
@@ -523,8 +523,13 @@ static int iTCO_wdt_keepalive(void)
         /* Reload the timer by writing to the TCO Timer Counter register */
         if (iTCO_wdt_private.iTCO_version == 2)
                 outw(0x01, TCO_RLD);
-        else if (iTCO_wdt_private.iTCO_version == 1)
+        else if (iTCO_wdt_private.iTCO_version == 1) {
+                /* Reset the timeout status bit so that the timer
+                 * needs to count down twice again before rebooting */
+                outw(0x0008, TCO1_STS); /* write 1 to clear bit */
+
                 outb(0x01, TCO_RLD);
+        }
 
         spin_unlock(&iTCO_wdt_private.io_lock);
         return 0;
@@ -537,6 +542,11 @@ static int iTCO_wdt_set_heartbeat(int t)
         unsigned int tmrval;
 
         tmrval = seconds_to_ticks(t);
+
+        /* For TCO v1 the timer counts down twice before rebooting */
+        if (iTCO_wdt_private.iTCO_version == 1)
+                tmrval /= 2;
+
         /* from the specs: */
         /* "Values of 0h-3h are ignored and should not be attempted" */
         if (tmrval < 0x04)
@@ -593,6 +603,8 @@ static int iTCO_wdt_get_timeleft(int *time_left)
                 spin_lock(&iTCO_wdt_private.io_lock);
                 val8 = inb(TCO_RLD);
                 val8 &= 0x3f;
+                if (!(inw(TCO1_STS) & 0x0008))
+                        val8 += (inb(TCOv1_TMR) & 0x3f);
                 spin_unlock(&iTCO_wdt_private.io_lock);
 
                 *time_left = (val8 * 6) / 10;
@@ -832,9 +844,9 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev,
                         TCOBASE);
 
         /* Clear out the (probably old) status */
-        outb(8, TCO1_STS);      /* Clear the Time Out Status bit */
-        outb(2, TCO2_STS);      /* Clear SECOND_TO_STS bit */
-        outb(4, TCO2_STS);      /* Clear BOOT_STS bit */
+        outw(0x0008, TCO1_STS); /* Clear the Time Out Status bit */
+        outw(0x0002, TCO2_STS); /* Clear SECOND_TO_STS bit */
+        outw(0x0004, TCO2_STS); /* Clear BOOT_STS bit */
 
         /* Make sure the watchdog is not running */
         iTCO_wdt_stop();
@@ -844,8 +856,7 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev,
         if (iTCO_wdt_set_heartbeat(heartbeat)) {
                 iTCO_wdt_set_heartbeat(WATCHDOG_HEARTBEAT);
                 printk(KERN_INFO PFX
-                        "heartbeat value must be 2 < heartbeat < 39 (TCO v1) "
-                                "or 613 (TCO v2), using %d\n", heartbeat);
+                        "timeout value out of range, using %d\n", heartbeat);
         }
 
         ret = misc_register(&iTCO_wdt_miscdev);
diff --git a/drivers/watchdog/imx2_wdt.c b/drivers/watchdog/imx2_wdt.c
new file mode 100644
index 000000000000..ea25885781bb
--- /dev/null
+++ b/drivers/watchdog/imx2_wdt.c
@@ -0,0 +1,358 @@
+/*
+ * Watchdog driver for IMX2 and later processors
+ *
+ *  Copyright (C) 2010 Wolfram Sang, Pengutronix e.K. <w.sang@pengutronix.de>
+ *
+ * some parts adapted by similar drivers from Darius Augulis and Vladimir
+ * Zapolskiy, additional improvements by Wim Van Sebroeck.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * NOTE: MX1 has a slightly different Watchdog than MX2 and later:
+ *
+ *                      MX1:            MX2+:
+ *                      ----            -----
+ * Registers:           32-bit          16-bit
+ * Stopable timer:      Yes             No
+ * Need to enable clk:  No              Yes
+ * Halt on suspend:     Manual          Can be automatic
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/platform_device.h>
+#include <linux/watchdog.h>
+#include <linux/clk.h>
+#include <linux/fs.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+#include <linux/timer.h>
+#include <linux/jiffies.h>
+#include <mach/hardware.h>
+
+#define DRIVER_NAME "imx2-wdt"
+
+#define IMX2_WDT_WCR            0x00            /* Control Register */
+#define IMX2_WDT_WCR_WT         (0xFF << 8)     /* -> Watchdog Timeout Field */
+#define IMX2_WDT_WCR_WRE        (1 << 3)        /* -> WDOG Reset Enable */
+#define IMX2_WDT_WCR_WDE        (1 << 2)        /* -> Watchdog Enable */
+
+#define IMX2_WDT_WSR            0x02            /* Service Register */
+#define IMX2_WDT_SEQ1           0x5555          /* -> service sequence 1 */
+#define IMX2_WDT_SEQ2           0xAAAA          /* -> service sequence 2 */
+
+#define IMX2_WDT_MAX_TIME       128
+#define IMX2_WDT_DEFAULT_TIME   60              /* in seconds */
+
+#define WDOG_SEC_TO_COUNT(s)    ((s * 2 - 1) << 8)
+
+#define IMX2_WDT_STATUS_OPEN    0
+#define IMX2_WDT_STATUS_STARTED 1
+#define IMX2_WDT_EXPECT_CLOSE   2
+
+static struct {
+        struct clk *clk;
+        void __iomem *base;
+        unsigned timeout;
+        unsigned long status;
+        struct timer_list timer;        /* Pings the watchdog when closed */
+} imx2_wdt;
+
+static struct miscdevice imx2_wdt_miscdev;
+
+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) ")");
+
+
+static unsigned timeout = IMX2_WDT_DEFAULT_TIME;
+module_param(timeout, uint, 0);
+MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds (default="
+                                __MODULE_STRING(IMX2_WDT_DEFAULT_TIME) ")");
+
+static const struct watchdog_info imx2_wdt_info = {
+        .identity = "imx2+ watchdog",
+        .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
+};
+
+static inline void imx2_wdt_setup(void)
+{
+        u16 val = __raw_readw(imx2_wdt.base + IMX2_WDT_WCR);
+
+        /* Strip the old watchdog Time-Out value */
+        val &= ~IMX2_WDT_WCR_WT;
+        /* Generate reset if WDOG times out */
+        val &= ~IMX2_WDT_WCR_WRE;
+        /* Keep Watchdog Disabled */
+        val &= ~IMX2_WDT_WCR_WDE;
+        /* Set the watchdog's Time-Out value */
+        val |= WDOG_SEC_TO_COUNT(imx2_wdt.timeout);
+
+        __raw_writew(val, imx2_wdt.base + IMX2_WDT_WCR);
+
+        /* enable the watchdog */
+        val |= IMX2_WDT_WCR_WDE;
+        __raw_writew(val, imx2_wdt.base + IMX2_WDT_WCR);
+}
+
+static inline void imx2_wdt_ping(void)
+{
+        __raw_writew(IMX2_WDT_SEQ1, imx2_wdt.base + IMX2_WDT_WSR);
+        __raw_writew(IMX2_WDT_SEQ2, imx2_wdt.base + IMX2_WDT_WSR);
+}
+
+static void imx2_wdt_timer_ping(unsigned long arg)
+{
+        /* ping it every imx2_wdt.timeout / 2 seconds to prevent reboot */
+        imx2_wdt_ping();
+        mod_timer(&imx2_wdt.timer, jiffies + imx2_wdt.timeout * HZ / 2);
+}
+
+static void imx2_wdt_start(void)
+{
+        if (!test_and_set_bit(IMX2_WDT_STATUS_STARTED, &imx2_wdt.status)) {
+                /* at our first start we enable clock and do initialisations */
+                clk_enable(imx2_wdt.clk);
+
+                imx2_wdt_setup();
+        } else  /* delete the timer that pings the watchdog after close */
+                del_timer_sync(&imx2_wdt.timer);
+
+        /* Watchdog is enabled - time to reload the timeout value */
+        imx2_wdt_ping();
+}
+
+static void imx2_wdt_stop(void)
+{
+        /* we don't need a clk_disable, it cannot be disabled once started.
+         * We use a timer to ping the watchdog while /dev/watchdog is closed */
+        imx2_wdt_timer_ping(0);
+}
+
+static void imx2_wdt_set_timeout(int new_timeout)
+{
+        u16 val = __raw_readw(imx2_wdt.base + IMX2_WDT_WCR);
+
+        /* set the new timeout value in the WSR */
+        val &= ~IMX2_WDT_WCR_WT;
+        val |= WDOG_SEC_TO_COUNT(new_timeout);
+        __raw_writew(val, imx2_wdt.base + IMX2_WDT_WCR);
+}
+
+static int imx2_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(IMX2_WDT_STATUS_OPEN, &imx2_wdt.status))
+                return -EBUSY;
+
+        imx2_wdt_start();
+        return nonseekable_open(inode, file);
+}
+
+static int imx2_wdt_close(struct inode *inode, struct file *file)
+{
+        if (test_bit(IMX2_WDT_EXPECT_CLOSE, &imx2_wdt.status) && !nowayout)
+                imx2_wdt_stop();
+        else {
+                dev_crit(imx2_wdt_miscdev.parent,
+                        "Unexpected close: Expect reboot!\n");
+                imx2_wdt_ping();
+        }
+
+        clear_bit(IMX2_WDT_EXPECT_CLOSE, &imx2_wdt.status);
+        clear_bit(IMX2_WDT_STATUS_OPEN, &imx2_wdt.status);
+        return 0;
+}
+
+static long imx2_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, &imx2_wdt_info,
+                        sizeof(struct watchdog_info)) ? -EFAULT : 0;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+
+        case WDIOC_KEEPALIVE:
+                imx2_wdt_ping();
+                return 0;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_value, p))
+                        return -EFAULT;
+                if ((new_value < 1) || (new_value > IMX2_WDT_MAX_TIME))
+                        return -EINVAL;
+                imx2_wdt_set_timeout(new_value);
+                imx2_wdt.timeout = new_value;
+                imx2_wdt_ping();
+
+                /* Fallthrough to return current value */
+        case WDIOC_GETTIMEOUT:
+                return put_user(imx2_wdt.timeout, p);
+
+        default:
+                return -ENOTTY;
+        }
+}
+
+static ssize_t imx2_wdt_write(struct file *file, const char __user *data,
+                                                size_t len, loff_t *ppos)
+{
+        size_t i;
+        char c;
+
+        if (len == 0)   /* Can we see this even ? */
+                return 0;
+
+        clear_bit(IMX2_WDT_EXPECT_CLOSE, &imx2_wdt.status);
+        /* scan to see whether or not we got the magic character */
+        for (i = 0; i != len; i++) {
+                if (get_user(c, data + i))
+                        return -EFAULT;
+                if (c == 'V')
+                        set_bit(IMX2_WDT_EXPECT_CLOSE, &imx2_wdt.status);
+        }
+
+        imx2_wdt_ping();
+        return len;
+}
+
+static const struct file_operations imx2_wdt_fops = {
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .unlocked_ioctl = imx2_wdt_ioctl,
+        .open = imx2_wdt_open,
+        .release = imx2_wdt_close,
+        .write = imx2_wdt_write,
+};
+
+static struct miscdevice imx2_wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &imx2_wdt_fops,
+};
+
+static int __init imx2_wdt_probe(struct platform_device *pdev)
+{
+        int ret;
+        int res_size;
+        struct resource *res;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "can't get device resources\n");
+                return -ENODEV;
+        }
+
+        res_size = resource_size(res);
+        if (!devm_request_mem_region(&pdev->dev, res->start, res_size,
+                res->name)) {
+                dev_err(&pdev->dev, "can't allocate %d bytes at %d address\n",
+                        res_size, res->start);
+                return -ENOMEM;
+        }
+
+        imx2_wdt.base = devm_ioremap_nocache(&pdev->dev, res->start, res_size);
+        if (!imx2_wdt.base) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                return -ENOMEM;
+        }
+
+        imx2_wdt.clk = clk_get_sys("imx-wdt.0", NULL);
+        if (IS_ERR(imx2_wdt.clk)) {
+                dev_err(&pdev->dev, "can't get Watchdog clock\n");
+                return PTR_ERR(imx2_wdt.clk);
+        }
+
+        imx2_wdt.timeout = clamp_t(unsigned, timeout, 1, IMX2_WDT_MAX_TIME);
+        if (imx2_wdt.timeout != timeout)
+                dev_warn(&pdev->dev, "Initial timeout out of range! "
+                        "Clamped from %u to %u\n", timeout, imx2_wdt.timeout);
+
+        setup_timer(&imx2_wdt.timer, imx2_wdt_timer_ping, 0);
+
+        imx2_wdt_miscdev.parent = &pdev->dev;
+        ret = misc_register(&imx2_wdt_miscdev);
+        if (ret)
+                goto fail;
+
+        dev_info(&pdev->dev,
+                "IMX2+ Watchdog Timer enabled. timeout=%ds (nowayout=%d)\n",
+                                                imx2_wdt.timeout, nowayout);
+        return 0;
+
+fail:
+        imx2_wdt_miscdev.parent = NULL;
+        clk_put(imx2_wdt.clk);
+        return ret;
+}
+
+static int __exit imx2_wdt_remove(struct platform_device *pdev)
+{
+        misc_deregister(&imx2_wdt_miscdev);
+
+        if (test_bit(IMX2_WDT_STATUS_STARTED, &imx2_wdt.status)) {
+                del_timer_sync(&imx2_wdt.timer);
+
+                dev_crit(imx2_wdt_miscdev.parent,
+                        "Device removed: Expect reboot!\n");
+        } else
+                clk_put(imx2_wdt.clk);
+
+        imx2_wdt_miscdev.parent = NULL;
+        return 0;
+}
+
+static void imx2_wdt_shutdown(struct platform_device *pdev)
+{
+        if (test_bit(IMX2_WDT_STATUS_STARTED, &imx2_wdt.status)) {
+                /* we are running, we need to delete the timer but will give
+                 * max timeout before reboot will take place */
+                del_timer_sync(&imx2_wdt.timer);
+                imx2_wdt_set_timeout(IMX2_WDT_MAX_TIME);
+                imx2_wdt_ping();
+
+                dev_crit(imx2_wdt_miscdev.parent,
+                        "Device shutdown: Expect reboot!\n");
+        }
+}
+
+static struct platform_driver imx2_wdt_driver = {
+        .probe          = imx2_wdt_probe,
+        .remove         = __exit_p(imx2_wdt_remove),
+        .shutdown       = imx2_wdt_shutdown,
+        .driver         = {
+                .name   = DRIVER_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init imx2_wdt_init(void)
+{
+        return platform_driver_probe(&imx2_wdt_driver, imx2_wdt_probe);
+}
+module_init(imx2_wdt_init);
+
+static void __exit imx2_wdt_exit(void)
+{
+        platform_driver_unregister(&imx2_wdt_driver);
+}
+module_exit(imx2_wdt_exit);
+
+MODULE_AUTHOR("Wolfram Sang");
+MODULE_DESCRIPTION("Watchdog driver for IMX2 and later");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/watchdog/mpc8xxx_wdt.c b/drivers/watchdog/mpc8xxx_wdt.c
index 7b55974191dd..6622335773bb 100644
--- a/drivers/watchdog/mpc8xxx_wdt.c
+++ b/drivers/watchdog/mpc8xxx_wdt.c
@@ -53,7 +53,7 @@ static int mpc8xxx_wdt_init_late(void);
 static u16 timeout = 0xffff;
 module_param(timeout, ushort, 0);
 MODULE_PARM_DESC(timeout,
-        "Watchdog timeout in ticks. (0<timeout<65536, default=65535");
+        "Watchdog timeout in ticks. (0<timeout<65536, default=65535)");
 
 static int reset = 1;
 module_param(reset, bool, 0);
diff --git a/drivers/watchdog/pc87413_wdt.c b/drivers/watchdog/pc87413_wdt.c
index d3aa2f1fe61d..3a56bc360924 100644
--- a/drivers/watchdog/pc87413_wdt.c
+++ b/drivers/watchdog/pc87413_wdt.c
@@ -53,7 +53,9 @@
 #define WDTO                0x11        /* Watchdog timeout register */
 #define WDCFG               0x12        /* Watchdog config register */
 
-static int io = 0x2E;                   /* Address used on Portwell Boards */
+#define IO_DEFAULT      0x2E            /* Address used on Portwell Boards */
+
+static int io = IO_DEFAULT;
 
 static int timeout = DEFAULT_TIMEOUT;   /* timeout value */
 static unsigned long timer_enabled;     /* is the timer enabled? */
@@ -583,12 +585,13 @@ MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 module_param(io, int, 0);
-MODULE_PARM_DESC(io, MODNAME " I/O port (default: " __MODULE_STRING(io) ").");
+MODULE_PARM_DESC(io, MODNAME " I/O port (default: "
+                                        __MODULE_STRING(IO_DEFAULT) ").");
 
 module_param(timeout, int, 0);
 MODULE_PARM_DESC(timeout,
                 "Watchdog timeout in minutes (default="
-                                __MODULE_STRING(timeout) ").");
+                                __MODULE_STRING(DEFAULT_TIMEOUT) ").");
 
 module_param(nowayout, int, 0);
 MODULE_PARM_DESC(nowayout,
diff --git a/drivers/watchdog/pnx833x_wdt.c b/drivers/watchdog/pnx833x_wdt.c
index 09102f09e681..a7b5ad2a98bd 100644
--- a/drivers/watchdog/pnx833x_wdt.c
+++ b/drivers/watchdog/pnx833x_wdt.c
@@ -33,6 +33,8 @@
 #define PFX "pnx833x: "
 #define WATCHDOG_TIMEOUT 30             /* 30 sec Maximum timeout */
 #define WATCHDOG_COUNT_FREQUENCY 68000000U /* Watchdog counts at 68MHZ. */
+#define PNX_WATCHDOG_TIMEOUT    (WATCHDOG_TIMEOUT * WATCHDOG_COUNT_FREQUENCY)
+#define PNX_TIMEOUT_VALUE       2040000000U
 
 /** CONFIG block */
 #define PNX833X_CONFIG                      (0x07000U)
@@ -47,20 +49,21 @@
 static int pnx833x_wdt_alive;
 
 /* Set default timeout in MHZ.*/
-static int pnx833x_wdt_timeout = (WATCHDOG_TIMEOUT * WATCHDOG_COUNT_FREQUENCY);
+static int pnx833x_wdt_timeout = PNX_WATCHDOG_TIMEOUT;
 module_param(pnx833x_wdt_timeout, int, 0);
 MODULE_PARM_DESC(timeout, "Watchdog timeout in Mhz. (68Mhz clock), default="
-                        __MODULE_STRING(pnx833x_wdt_timeout) "(30 seconds).");
+                        __MODULE_STRING(PNX_TIMEOUT_VALUE) "(30 seconds).");
 
 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) ")");
 
-static int start_enabled = 1;
+#define START_DEFAULT   1
+static int start_enabled = START_DEFAULT;
 module_param(start_enabled, int, 0);
 MODULE_PARM_DESC(start_enabled, "Watchdog is started on module insertion "
-                                "(default=" __MODULE_STRING(start_enabled) ")");
+                                "(default=" __MODULE_STRING(START_DEFAULT) ")");
 
 static void pnx833x_wdt_start(void)
 {
diff --git a/drivers/watchdog/s3c2410_wdt.c b/drivers/watchdog/s3c2410_wdt.c
index e4cebef55177..300932580ded 100644
--- a/drivers/watchdog/s3c2410_wdt.c
+++ b/drivers/watchdog/s3c2410_wdt.c
@@ -63,7 +63,7 @@ module_param(nowayout,    int, 0);
 module_param(soft_noboot, int, 0);
 module_param(debug,       int, 0);
 
-MODULE_PARM_DESC(tmr_margin, "Watchdog tmr_margin in seconds. default="
+MODULE_PARM_DESC(tmr_margin, "Watchdog tmr_margin in seconds. (default="
                 __MODULE_STRING(CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME) ")");
 MODULE_PARM_DESC(tmr_atboot,
                 "Watchdog is started at boot time if set to 1, default="
@@ -71,8 +71,8 @@ MODULE_PARM_DESC(tmr_atboot,
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
                         __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 MODULE_PARM_DESC(soft_noboot, "Watchdog action, set to 1 to ignore reboots, "
-                        "0 to reboot (default depends on ONLY_TESTING)");
-MODULE_PARM_DESC(debug, "Watchdog debug, set to >1 for debug, (default 0)");
+                        "0 to reboot (default 0)");
+MODULE_PARM_DESC(debug, "Watchdog debug, set to >1 for debug (default 0)");
 
 static unsigned long open_lock;
 static struct device    *wdt_dev;       /* platform device attached to */
@@ -426,8 +426,7 @@ static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
         wdt_mem = request_mem_region(res->start, size, pdev->name);
         if (wdt_mem == NULL) {
                 dev_err(dev, "failed to get memory region\n");
-                ret = -ENOENT;
-                goto err_req;
+                return -EBUSY;
         }
 
         wdt_base = ioremap(res->start, size);
diff --git a/drivers/watchdog/shwdt.c b/drivers/watchdog/shwdt.c
index a03f84e5ee1f..6fc74065abee 100644
--- a/drivers/watchdog/shwdt.c
+++ b/drivers/watchdog/shwdt.c
@@ -496,7 +496,7 @@ MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 module_param(clock_division_ratio, int, 0);
 MODULE_PARM_DESC(clock_division_ratio,
         "Clock division ratio. Valid ranges are from 0x5 (1.31ms) "
-        "to 0x7 (5.25ms). (default=" __MODULE_STRING(clock_division_ratio) ")");
+        "to 0x7 (5.25ms). (default=" __MODULE_STRING(WTCSR_CKS_4096) ")");
 
 module_param(heartbeat, int, 0);
 MODULE_PARM_DESC(heartbeat,
diff --git a/drivers/watchdog/twl4030_wdt.c b/drivers/watchdog/twl4030_wdt.c
index dcabe77ad141..b5045ca7e61c 100644
--- a/drivers/watchdog/twl4030_wdt.c
+++ b/drivers/watchdog/twl4030_wdt.c
@@ -190,6 +190,8 @@ static int __devinit twl4030_wdt_probe(struct platform_device *pdev)
 
         twl4030_wdt_dev = pdev;
 
+        twl4030_wdt_disable(wdt);
+
         ret = misc_register(&wdt->miscdev);
         if (ret) {
                 dev_err(wdt->miscdev.parent,
diff --git a/drivers/watchdog/wdt.c b/drivers/watchdog/wdt.c
index bfda2e99dd89..552a4381e78f 100644
--- a/drivers/watchdog/wdt.c
+++ b/drivers/watchdog/wdt.c
@@ -91,7 +91,7 @@ MODULE_PARM_DESC(tachometer,
 static int type = 500;
 module_param(type, int, 0);
 MODULE_PARM_DESC(type,
-                "WDT501-P Card type (500 or 501 , default=500)");
+                "WDT501-P Card type (500 or 501, default=500)");
 
 /*
  *      Programming support
diff --git a/drivers/watchdog/wdt977.c b/drivers/watchdog/wdt977.c
index 90ef70eb47d7..5c2521fc836c 100644
--- a/drivers/watchdog/wdt977.c
+++ b/drivers/watchdog/wdt977.c
@@ -63,7 +63,7 @@ static	char expect_close;
 static  DEFINE_SPINLOCK(spinlock);
 
 module_param(timeout, int, 0);
-MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds (60..15300), default="
+MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds (60..15300, default="
                                 __MODULE_STRING(DEFAULT_TIMEOUT) ")");
 module_param(testmode, int, 0);
 MODULE_PARM_DESC(testmode, "Watchdog testmode (1 = no reboot), default=0");