103 files changed, 905 insertions, 407 deletions

diff --git a/Documentation/devicetree/bindings/watchdog/dw_wdt.txt b/Documentation/devicetree/bindings/watchdog/dw_wdt.txt
new file mode 100644
index 000000000000..08e16f684f2d
--- /dev/null
+++ b/Documentation/devicetree/bindings/watchdog/dw_wdt.txt
@@ -0,0 +1,21 @@
+Synopsys Designware Watchdog Timer
+
+Required Properties:
+
+- compatible    : Should contain "snps,dw-wdt"
+- reg           : Base address and size of the watchdog timer registers.
+- clocks        : phandle + clock-specifier for the clock that drives the
+                watchdog timer.
+
+Optional Properties:
+
+- interrupts    : The interrupt used for the watchdog timeout warning.
+
+Example:
+
+        watchdog0: wd@ffd02000 {
+                compatible = "snps,dw-wdt";
+                reg = <0xffd02000 0x1000>;
+                interrupts = <0 171 4>;
+                clocks = <&per_base_clk>;
+        };
diff --git a/Documentation/devicetree/bindings/gpio/men-a021-wdt.txt b/Documentation/devicetree/bindings/watchdog/men-a021-wdt.txt
index 370dee3226d9..370dee3226d9 100644
--- a/Documentation/devicetree/bindings/gpio/men-a021-wdt.txt
+++ b/Documentation/devicetree/bindings/watchdog/men-a021-wdt.txt
diff --git a/Documentation/devicetree/bindings/watchdog/moxa,moxart-watchdog.txt b/Documentation/devicetree/bindings/watchdog/moxa,moxart-watchdog.txt
new file mode 100644
index 000000000000..1169857d1d12
--- /dev/null
+++ b/Documentation/devicetree/bindings/watchdog/moxa,moxart-watchdog.txt
@@ -0,0 +1,15 @@
+MOXA ART Watchdog timer
+
+Required properties:
+
+- compatible : Must be "moxa,moxart-watchdog"
+- reg : Should contain registers location and length
+- clocks : Should contain phandle for the clock that drives the counter
+
+Example:
+
+        watchdog: watchdog@98500000 {
+                compatible = "moxa,moxart-watchdog";
+                reg = <0x98500000 0x10>;
+                clocks = <&coreclk>;
+        };
diff --git a/Documentation/devicetree/bindings/watchdog/rt2880-wdt.txt b/Documentation/devicetree/bindings/watchdog/rt2880-wdt.txt
new file mode 100644
index 000000000000..d7bab3db9d1f
--- /dev/null
+++ b/Documentation/devicetree/bindings/watchdog/rt2880-wdt.txt
@@ -0,0 +1,19 @@
+Ralink Watchdog Timers
+
+Required properties:
+- compatible: must be "ralink,rt2880-wdt"
+- reg: physical base address of the controller and length of the register range
+
+Optional properties:
+- interrupt-parent: phandle to the INTC device node
+- interrupts: Specify the INTC interrupt number
+
+Example:
+
+        watchdog@120 {
+                compatible = "ralink,rt2880-wdt";
+                reg = <0x120 0x10>;
+
+                interrupt-parent = <&intc>;
+                interrupts = <1>;
+        };
diff --git a/Documentation/devicetree/bindings/watchdog/sirfsoc_wdt.txt b/Documentation/devicetree/bindings/watchdog/sirfsoc_wdt.txt
new file mode 100644
index 000000000000..9cbc76c89b2b
--- /dev/null
+++ b/Documentation/devicetree/bindings/watchdog/sirfsoc_wdt.txt
@@ -0,0 +1,14 @@
+SiRFSoC Timer and Watchdog Timer(WDT) Controller
+
+Required properties:
+- compatible: "sirf,prima2-tick"
+- reg: Address range of tick timer/WDT register set
+- interrupts: interrupt number to the cpu
+
+Example:
+
+timer@b0020000 {
+        compatible = "sirf,prima2-tick";
+        reg = <0xb0020000 0x1000>;
+        interrupts = <0>;
+};
diff --git a/arch/arm/configs/prima2_defconfig b/arch/arm/configs/prima2_defconfig
index 002a1ceadceb..23591dba47a0 100644
--- a/arch/arm/configs/prima2_defconfig
+++ b/arch/arm/configs/prima2_defconfig
@@ -39,6 +39,7 @@ CONFIG_SPI=y
 CONFIG_SPI_SIRF=y
 CONFIG_SPI_SPIDEV=y
 # CONFIG_HWMON is not set
+CONFIG_WATCHDOG=y
 CONFIG_USB_GADGET=y
 CONFIG_USB_MASS_STORAGE=m
 CONFIG_MMC=y
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index 6df632e0bb55..5be6e919f785 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -392,6 +392,25 @@ config RETU_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called retu_wdt.
 
+config MOXART_WDT
+        tristate "MOXART watchdog"
+        depends on ARCH_MOXART
+        help
+          Say Y here to include Watchdog timer support for the watchdog
+          existing on the MOXA ART SoC series platforms.
+
+          To compile this driver as a module, choose M here: the
+          module will be called moxart_wdt.
+
+config SIRFSOC_WATCHDOG
+        tristate "SiRFSOC watchdog"
+        depends on ARCH_SIRF
+        select WATCHDOG_CORE
+        default y
+        help
+          Support for CSR SiRFprimaII and SiRFatlasVI watchdog. When
+          the watchdog triggers the system will be reset.
+
 # AVR32 Architecture
 
 config AT32AP700X_WDT
@@ -866,6 +885,7 @@ config VIA_WDT
 config W83627HF_WDT
         tristate "W83627HF/W83627DHG Watchdog Timer"
         depends on X86
+        select WATCHDOG_CORE
         ---help---
           This is the driver for the hardware watchdog on the W83627HF chipset
           as used in Advantech PC-9578 and Tyan S2721-533 motherboards
@@ -1125,6 +1145,13 @@ config LANTIQ_WDT
         help
           Hardware driver for the Lantiq SoC Watchdog Timer.
 
+config RALINK_WDT
+        tristate "Ralink SoC watchdog"
+        select WATCHDOG_CORE
+        depends on RALINK
+        help
+          Hardware driver for the Ralink SoC Watchdog Timer.
+
 # PARISC Architecture
 
 # POWERPC Architecture
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index 8c7b8bcbbdc5..91bd95a64baf 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -55,6 +55,8 @@ obj-$(CONFIG_IMX2_WDT) += imx2_wdt.o
 obj-$(CONFIG_UX500_WATCHDOG) += ux500_wdt.o
 obj-$(CONFIG_RETU_WATCHDOG) += retu_wdt.o
 obj-$(CONFIG_BCM2835_WDT) += bcm2835_wdt.o
+obj-$(CONFIG_MOXART_WDT) += moxart_wdt.o
+obj-$(CONFIG_SIRFSOC_WATCHDOG) += sirfsoc_wdt.o
 
 # AVR32 Architecture
 obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
@@ -134,6 +136,7 @@ obj-$(CONFIG_TXX9_WDT) += txx9wdt.o
 obj-$(CONFIG_OCTEON_WDT) += octeon-wdt.o
 octeon-wdt-y := octeon-wdt-main.o octeon-wdt-nmi.o
 obj-$(CONFIG_LANTIQ_WDT) += lantiq_wdt.o
+obj-$(CONFIG_RALINK_WDT) += rt2880_wdt.o
 
 # PARISC Architecture
 
diff --git a/drivers/watchdog/acquirewdt.c b/drivers/watchdog/acquirewdt.c
index 24a517777fa0..5cf1621def9c 100644
--- a/drivers/watchdog/acquirewdt.c
+++ b/drivers/watchdog/acquirewdt.c
@@ -60,8 +60,7 @@
 #include <linux/types.h>                /* For standard types (like size_t) */
 #include <linux/errno.h>                /* For the -ENODEV/... values */
 #include <linux/kernel.h>               /* For printk/panic/... */
-#include <linux/miscdevice.h>           /* For MODULE_ALIAS_MISCDEV
-                                                        (WATCHDOG_MINOR) */
+#include <linux/miscdevice.h>           /* For struct miscdevice */
 #include <linux/watchdog.h>             /* For the watchdog specific items */
 #include <linux/fs.h>                   /* For file operations */
 #include <linux/ioport.h>               /* For io-port access */
@@ -337,4 +336,3 @@ module_exit(acq_exit);
 MODULE_AUTHOR("David Woodhouse");
 MODULE_DESCRIPTION("Acquire Inc. Single Board Computer Watchdog Timer driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/advantechwdt.c b/drivers/watchdog/advantechwdt.c
index cc6702fc5268..a8961addc59c 100644
--- a/drivers/watchdog/advantechwdt.c
+++ b/drivers/watchdog/advantechwdt.c
@@ -345,4 +345,3 @@ module_exit(advwdt_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Marek Michalkiewicz <marekm@linux.org.pl>");
 MODULE_DESCRIPTION("Advantech Single Board Computer WDT driver");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/alim1535_wdt.c b/drivers/watchdog/alim1535_wdt.c
index 41b84936a521..fbb7b94cabfd 100644
--- a/drivers/watchdog/alim1535_wdt.c
+++ b/drivers/watchdog/alim1535_wdt.c
@@ -452,4 +452,3 @@ module_exit(watchdog_exit);
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("ALi M1535 PMU Watchdog Timer driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/alim7101_wdt.c b/drivers/watchdog/alim7101_wdt.c
index 5eee55012e33..12f0b762b528 100644
--- a/drivers/watchdog/alim7101_wdt.c
+++ b/drivers/watchdog/alim7101_wdt.c
@@ -425,4 +425,3 @@ MODULE_DEVICE_TABLE(pci, alim7101_pci_tbl);
 MODULE_AUTHOR("Steve Hill");
 MODULE_DESCRIPTION("ALi M7101 PMU Computer Watchdog Timer driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/ar7_wdt.c b/drivers/watchdog/ar7_wdt.c
index b3709f9cf5be..3a996576343a 100644
--- a/drivers/watchdog/ar7_wdt.c
+++ b/drivers/watchdog/ar7_wdt.c
@@ -46,7 +46,6 @@
 MODULE_AUTHOR("Nicolas Thill <nico@openwrt.org>");
 MODULE_DESCRIPTION(LONGNAME);
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 static int margin = 60;
 module_param(margin, int, 0);
diff --git a/drivers/watchdog/at32ap700x_wdt.c b/drivers/watchdog/at32ap700x_wdt.c
index b178e717ef09..afe7d17e6776 100644
--- a/drivers/watchdog/at32ap700x_wdt.c
+++ b/drivers/watchdog/at32ap700x_wdt.c
@@ -434,4 +434,3 @@ module_platform_driver_probe(at32_wdt_driver, at32_wdt_probe);
 MODULE_AUTHOR("Hans-Christian Egtvedt <egtvedt@samfundet.no>");
 MODULE_DESCRIPTION("Watchdog driver for Atmel AT32AP700X");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/at91rm9200_wdt.c b/drivers/watchdog/at91rm9200_wdt.c
index 1c75260b987c..dee6cc21d270 100644
--- a/drivers/watchdog/at91rm9200_wdt.c
+++ b/drivers/watchdog/at91rm9200_wdt.c
@@ -269,7 +269,7 @@ static struct platform_driver at91wdt_driver = {
         .driver         = {
                 .name   = "at91_wdt",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(at91_wdt_dt_ids),
+                .of_match_table = at91_wdt_dt_ids,
         },
 };
 
@@ -297,5 +297,4 @@ module_exit(at91_wdt_exit);
 MODULE_AUTHOR("Andrew Victor");
 MODULE_DESCRIPTION("Watchdog driver for Atmel AT91RM9200");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:at91_wdt");
diff --git a/drivers/watchdog/ath79_wdt.c b/drivers/watchdog/ath79_wdt.c
index 37cb09b27b63..9fa1f69dac13 100644
--- a/drivers/watchdog/ath79_wdt.c
+++ b/drivers/watchdog/ath79_wdt.c
@@ -329,4 +329,3 @@ MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org");
 MODULE_AUTHOR("Imre Kaloz <kaloz@openwrt.org");
 MODULE_LICENSE("GPL v2");
 MODULE_ALIAS("platform:" DRIVER_NAME);
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/bcm2835_wdt.c b/drivers/watchdog/bcm2835_wdt.c
index 61566fc47f84..a6a2cebb2587 100644
--- a/drivers/watchdog/bcm2835_wdt.c
+++ b/drivers/watchdog/bcm2835_wdt.c
@@ -186,4 +186,3 @@ MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
 MODULE_AUTHOR("Lubomir Rintel <lkundrak@v3.sk>");
 MODULE_DESCRIPTION("Driver for Broadcom BCM2835 watchdog timer");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/bcm63xx_wdt.c b/drivers/watchdog/bcm63xx_wdt.c
index a14a58d9d110..4eb188b87f8e 100644
--- a/drivers/watchdog/bcm63xx_wdt.c
+++ b/drivers/watchdog/bcm63xx_wdt.c
@@ -317,5 +317,4 @@ MODULE_AUTHOR("Miguel Gaio <miguel.gaio@efixo.com>");
 MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>");
 MODULE_DESCRIPTION("Driver for the Broadcom BCM63xx SoC watchdog");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:bcm63xx-wdt");
diff --git a/drivers/watchdog/bfin_wdt.c b/drivers/watchdog/bfin_wdt.c
index 5d36d6fb4969..a3b6a5b30f9f 100644
--- a/drivers/watchdog/bfin_wdt.c
+++ b/drivers/watchdog/bfin_wdt.c
@@ -465,7 +465,6 @@ module_exit(bfin_wdt_exit);
 MODULE_AUTHOR("Michele d'Amico, Mike Frysinger <vapier@gentoo.org>");
 MODULE_DESCRIPTION("Blackfin Watchdog Device Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 module_param(timeout, uint, 0);
 MODULE_PARM_DESC(timeout,
diff --git a/drivers/watchdog/cpu5wdt.c b/drivers/watchdog/cpu5wdt.c
index f270bb7bc456..f7ae49edb518 100644
--- a/drivers/watchdog/cpu5wdt.c
+++ b/drivers/watchdog/cpu5wdt.c
@@ -289,7 +289,6 @@ MODULE_AUTHOR("Heiko Ronsdorf <hero@ihg.uni-duisburg.de>");
 MODULE_DESCRIPTION("sma cpu5 watchdog driver");
 MODULE_SUPPORTED_DEVICE("sma cpu5 watchdog");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 module_param(port, int, 0);
 MODULE_PARM_DESC(port, "base address of watchdog card, default is 0x91");
diff --git a/drivers/watchdog/davinci_wdt.c b/drivers/watchdog/davinci_wdt.c
index bead7740c86a..dd625cca1ae5 100644
--- a/drivers/watchdog/davinci_wdt.c
+++ b/drivers/watchdog/davinci_wdt.c
@@ -267,5 +267,4 @@ MODULE_PARM_DESC(heartbeat,
                  __MODULE_STRING(DEFAULT_HEARTBEAT));
 
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:watchdog");
diff --git a/drivers/watchdog/dw_wdt.c b/drivers/watchdog/dw_wdt.c
index e621098bf663..a46f5c7ee7ff 100644
--- a/drivers/watchdog/dw_wdt.c
+++ b/drivers/watchdog/dw_wdt.c
@@ -29,6 +29,7 @@
 #include <linux/miscdevice.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/of.h>
 #include <linux/pm.h>
 #include <linux/platform_device.h>
 #include <linux/spinlock.h>
@@ -203,12 +204,12 @@ static long dw_wdt_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                return copy_to_user((struct watchdog_info *)arg, &dw_wdt_ident,
+                return copy_to_user((void __user *)arg, &dw_wdt_ident,
                                     sizeof(dw_wdt_ident)) ? -EFAULT : 0;
 
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
-                return put_user(0, (int *)arg);
+                return put_user(0, (int __user *)arg);
 
         case WDIOC_KEEPALIVE:
                 dw_wdt_set_next_heartbeat();
@@ -252,17 +253,17 @@ static int dw_wdt_release(struct inode *inode, struct file *filp)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int dw_wdt_suspend(struct device *dev)
 {
-        clk_disable(dw_wdt.clk);
+        clk_disable_unprepare(dw_wdt.clk);
 
         return 0;
 }
 
 static int dw_wdt_resume(struct device *dev)
 {
-        int err = clk_enable(dw_wdt.clk);
+        int err = clk_prepare_enable(dw_wdt.clk);
 
         if (err)
                 return err;
@@ -271,12 +272,9 @@ static int dw_wdt_resume(struct device *dev)
 
         return 0;
 }
+#endif /* CONFIG_PM_SLEEP */
 
-static const struct dev_pm_ops dw_wdt_pm_ops = {
-        .suspend        = dw_wdt_suspend,
-        .resume         = dw_wdt_resume,
-};
-#endif /* CONFIG_PM */
+static SIMPLE_DEV_PM_OPS(dw_wdt_pm_ops, dw_wdt_suspend, dw_wdt_resume);
 
 static const struct file_operations wdt_fops = {
         .owner          = THIS_MODULE,
@@ -309,7 +307,7 @@ static int dw_wdt_drv_probe(struct platform_device *pdev)
         if (IS_ERR(dw_wdt.clk))
                 return PTR_ERR(dw_wdt.clk);
 
-        ret = clk_enable(dw_wdt.clk);
+        ret = clk_prepare_enable(dw_wdt.clk);
         if (ret)
                 return ret;
 
@@ -326,7 +324,7 @@ static int dw_wdt_drv_probe(struct platform_device *pdev)
         return 0;
 
 out_disable_clk:
-        clk_disable(dw_wdt.clk);
+        clk_disable_unprepare(dw_wdt.clk);
 
         return ret;
 }
@@ -335,20 +333,27 @@ static int dw_wdt_drv_remove(struct platform_device *pdev)
 {
         misc_deregister(&dw_wdt_miscdev);
 
-        clk_disable(dw_wdt.clk);
+        clk_disable_unprepare(dw_wdt.clk);
 
         return 0;
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id dw_wdt_of_match[] = {
+        { .compatible = "snps,dw-wdt", },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, dw_wdt_of_match);
+#endif
+
 static struct platform_driver dw_wdt_driver = {
         .probe          = dw_wdt_drv_probe,
         .remove         = dw_wdt_drv_remove,
         .driver         = {
                 .name   = "dw_wdt",
                 .owner  = THIS_MODULE,
-#ifdef CONFIG_PM
+                .of_match_table = of_match_ptr(dw_wdt_of_match),
                 .pm     = &dw_wdt_pm_ops,
-#endif /* CONFIG_PM */
         },
 };
 
@@ -357,4 +362,3 @@ module_platform_driver(dw_wdt_driver);
 MODULE_AUTHOR("Jamie Iles");
 MODULE_DESCRIPTION("Synopsys DesignWare Watchdog Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/ep93xx_wdt.c b/drivers/watchdog/ep93xx_wdt.c
index e0574844c313..833e81311848 100644
--- a/drivers/watchdog/ep93xx_wdt.c
+++ b/drivers/watchdog/ep93xx_wdt.c
@@ -179,4 +179,3 @@ MODULE_AUTHOR("Ray Lehtiniemi <rayl@mail.com>,"
 MODULE_DESCRIPTION("EP93xx Watchdog");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(WDT_VERSION);
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/eurotechwdt.c b/drivers/watchdog/eurotechwdt.c
index cd31b8a2a729..23ee53240c4c 100644
--- a/drivers/watchdog/eurotechwdt.c
+++ b/drivers/watchdog/eurotechwdt.c
@@ -477,4 +477,3 @@ module_exit(eurwdt_exit);
 MODULE_AUTHOR("Rodolfo Giometti");
 MODULE_DESCRIPTION("Driver for Eurotech CPU-1220/1410 on board watchdog");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/gef_wdt.c b/drivers/watchdog/gef_wdt.c
index 3755833430dc..25beb30878d7 100644
--- a/drivers/watchdog/gef_wdt.c
+++ b/drivers/watchdog/gef_wdt.c
@@ -331,5 +331,4 @@ module_exit(gef_wdt_exit);
 MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com>");
 MODULE_DESCRIPTION("GE watchdog driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:gef_wdt");
diff --git a/drivers/watchdog/geodewdt.c b/drivers/watchdog/geodewdt.c
index fcd599d4e225..4a6ae84b42bc 100644
--- a/drivers/watchdog/geodewdt.c
+++ b/drivers/watchdog/geodewdt.c
@@ -297,4 +297,3 @@ module_exit(geodewdt_exit);
 MODULE_AUTHOR("Advanced Micro Devices, Inc");
 MODULE_DESCRIPTION("Geode GX/LX Watchdog Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/hpwdt.c b/drivers/watchdog/hpwdt.c
index 19f3c3fc65f4..45b979d9dd13 100644
--- a/drivers/watchdog/hpwdt.c
+++ b/drivers/watchdog/hpwdt.c
@@ -881,7 +881,6 @@ MODULE_AUTHOR("Tom Mingarelli");
 MODULE_DESCRIPTION("hp watchdog driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(HPWDT_VERSION);
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 module_param(soft_margin, int, 0);
 MODULE_PARM_DESC(soft_margin, "Watchdog timeout in seconds");
diff --git a/drivers/watchdog/i6300esb.c b/drivers/watchdog/i6300esb.c
index 2b2ea13d03ea..a72fe9361ddf 100644
--- a/drivers/watchdog/i6300esb.c
+++ b/drivers/watchdog/i6300esb.c
@@ -497,4 +497,3 @@ module_pci_driver(esb_driver);
 MODULE_AUTHOR("Ross Biro and David Härdeman");
 MODULE_DESCRIPTION("Watchdog driver for Intel 6300ESB chipsets");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/iTCO_wdt.c b/drivers/watchdog/iTCO_wdt.c
index 6130321da387..04f8af65acfd 100644
--- a/drivers/watchdog/iTCO_wdt.c
+++ b/drivers/watchdog/iTCO_wdt.c
@@ -56,8 +56,6 @@
 #include <linux/types.h>                /* For standard types (like size_t) */
 #include <linux/errno.h>                /* For the -ENODEV/... values */
 #include <linux/kernel.h>               /* For printk/panic/... */
-#include <linux/miscdevice.h>           /* For MODULE_ALIAS_MISCDEV
-                                                        (WATCHDOG_MINOR) */
 #include <linux/watchdog.h>             /* For the watchdog specific items */
 #include <linux/init.h>                 /* For __init/__exit/... */
 #include <linux/fs.h>                   /* For file operations */
@@ -394,7 +392,7 @@ static int iTCO_wdt_probe(struct platform_device *dev)
 {
         int ret = -ENODEV;
         unsigned long val32;
-        struct lpc_ich_info *ich_info = dev->dev.platform_data;
+        struct lpc_ich_info *ich_info = dev_get_platdata(&dev->dev);
 
         if (!ich_info)
                 goto out;
@@ -582,5 +580,4 @@ MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
 MODULE_DESCRIPTION("Intel TCO WatchDog Timer Driver");
 MODULE_VERSION(DRV_VERSION);
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/watchdog/ib700wdt.c b/drivers/watchdog/ib700wdt.c
index eb6b5cc98ec6..7ae36690c449 100644
--- a/drivers/watchdog/ib700wdt.c
+++ b/drivers/watchdog/ib700wdt.c
@@ -382,6 +382,5 @@ module_exit(ibwdt_exit);
 MODULE_AUTHOR("Charles Howes <chowes@vsol.net>");
 MODULE_DESCRIPTION("IB700 SBC watchdog driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 /* end of ib700wdt.c */
diff --git a/drivers/watchdog/ibmasr.c b/drivers/watchdog/ibmasr.c
index bc3fb8fe89ab..db0a34460e57 100644
--- a/drivers/watchdog/ibmasr.c
+++ b/drivers/watchdog/ibmasr.c
@@ -419,4 +419,3 @@ MODULE_PARM_DESC(nowayout,
 MODULE_DESCRIPTION("IBM Automatic Server Restart driver");
 MODULE_AUTHOR("Andrey Panin");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/ie6xx_wdt.c b/drivers/watchdog/ie6xx_wdt.c
index e24ef6a6e064..70a240297c6d 100644
--- a/drivers/watchdog/ie6xx_wdt.c
+++ b/drivers/watchdog/ie6xx_wdt.c
@@ -344,5 +344,4 @@ module_exit(ie6xx_wdt_exit);
 MODULE_AUTHOR("Alexander Stein <alexander.stein@systec-electronic.com>");
 MODULE_DESCRIPTION("Intel Atom E6xx Watchdog Device Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/watchdog/imx2_wdt.c b/drivers/watchdog/imx2_wdt.c
index 693ac3f4de5a..b4786bccc42c 100644
--- a/drivers/watchdog/imx2_wdt.c
+++ b/drivers/watchdog/imx2_wdt.c
@@ -322,6 +322,7 @@ static const struct of_device_id imx2_wdt_dt_ids[] = {
         { .compatible = "fsl,imx21-wdt", },
         { /* sentinel */ }
 };
+MODULE_DEVICE_TABLE(of, imx2_wdt_dt_ids);
 
 static struct platform_driver imx2_wdt_driver = {
         .remove         = __exit_p(imx2_wdt_remove),
@@ -338,5 +339,4 @@ module_platform_driver_probe(imx2_wdt_driver, imx2_wdt_probe);
 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/indydog.c b/drivers/watchdog/indydog.c
index 6d90f7a2ce22..1b5c25a47b87 100644
--- a/drivers/watchdog/indydog.c
+++ b/drivers/watchdog/indydog.c
@@ -214,4 +214,3 @@ module_exit(watchdog_exit);
 MODULE_AUTHOR("Guido Guenther <agx@sigxcpu.org>");
 MODULE_DESCRIPTION("Hardware Watchdog Device for SGI IP22");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/intel_scu_watchdog.c b/drivers/watchdog/intel_scu_watchdog.c
index 8ced25613956..e13e65e996aa 100644
--- a/drivers/watchdog/intel_scu_watchdog.c
+++ b/drivers/watchdog/intel_scu_watchdog.c
@@ -564,5 +564,4 @@ module_exit(intel_scu_watchdog_exit);
 MODULE_AUTHOR("Intel Corporation");
 MODULE_DESCRIPTION("Intel SCU Watchdog Device Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_VERSION(WDT_VER);
diff --git a/drivers/watchdog/iop_wdt.c b/drivers/watchdog/iop_wdt.c
index d964faf1a250..b16013ffacc2 100644
--- a/drivers/watchdog/iop_wdt.c
+++ b/drivers/watchdog/iop_wdt.c
@@ -259,4 +259,3 @@ MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started");
 MODULE_AUTHOR("Curt E Bruns <curt.e.bruns@intel.com>");
 MODULE_DESCRIPTION("iop watchdog timer driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/it8712f_wdt.c b/drivers/watchdog/it8712f_wdt.c
index f4cce6d66a55..41b3979a9d87 100644
--- a/drivers/watchdog/it8712f_wdt.c
+++ b/drivers/watchdog/it8712f_wdt.c
@@ -41,7 +41,6 @@
 MODULE_AUTHOR("Jorge Boncompte - DTI2 <jorge@dti2.net>");
 MODULE_DESCRIPTION("IT8712F Watchdog Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 static int max_units = 255;
 static int margin = 60;         /* in seconds */
diff --git a/drivers/watchdog/it87_wdt.c b/drivers/watchdog/it87_wdt.c
index d3dcc6988b5f..e2bba68ae71e 100644
--- a/drivers/watchdog/it87_wdt.c
+++ b/drivers/watchdog/it87_wdt.c
@@ -772,4 +772,3 @@ module_exit(it87_wdt_exit);
 MODULE_AUTHOR("Oliver Schuster");
 MODULE_DESCRIPTION("Hardware Watchdog Device Driver for IT87xx EC-LPC I/O");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/ixp4xx_wdt.c b/drivers/watchdog/ixp4xx_wdt.c
index 5580b4fff7fe..f20cc53ff719 100644
--- a/drivers/watchdog/ixp4xx_wdt.c
+++ b/drivers/watchdog/ixp4xx_wdt.c
@@ -208,5 +208,3 @@ module_param(nowayout, bool, 0);
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started");
 
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-
diff --git a/drivers/watchdog/jz4740_wdt.c b/drivers/watchdog/jz4740_wdt.c
index d1afdf684c18..2de486a7eea1 100644
--- a/drivers/watchdog/jz4740_wdt.c
+++ b/drivers/watchdog/jz4740_wdt.c
@@ -222,5 +222,4 @@ module_platform_driver(jz4740_wdt_driver);
 MODULE_AUTHOR("Paul Cercueil <paul@crapouillou.net>");
 MODULE_DESCRIPTION("jz4740 Watchdog Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:jz4740-wdt");
diff --git a/drivers/watchdog/kempld_wdt.c b/drivers/watchdog/kempld_wdt.c
index 5c3d4df63e68..a1a3638c579c 100644
--- a/drivers/watchdog/kempld_wdt.c
+++ b/drivers/watchdog/kempld_wdt.c
@@ -67,7 +67,7 @@ enum {
         PRESCALER_12,
 };
 
-const u32 kempld_prescaler[] = {
+static const u32 kempld_prescaler[] = {
         [PRESCALER_21] = (1 << 21) - 1,
         [PRESCALER_17] = (1 << 17) - 1,
         [PRESCALER_12] = (1 << 12) - 1,
@@ -361,7 +361,7 @@ static long kempld_wdt_ioctl(struct watchdog_device *wdd, unsigned int cmd,
                 ret = kempld_wdt_keepalive(wdd);
                 break;
         case WDIOC_GETPRETIMEOUT:
-                ret = put_user(wdt_data->pretimeout, (int *)arg);
+                ret = put_user(wdt_data->pretimeout, (int __user *)arg);
                 break;
         }
 
@@ -578,4 +578,3 @@ module_platform_driver(kempld_wdt_driver);
 MODULE_DESCRIPTION("KEM PLD Watchdog Driver");
 MODULE_AUTHOR("Michael Brunner <michael.brunner@kontron.com>");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/ks8695_wdt.c b/drivers/watchdog/ks8695_wdt.c
index dce9ecffd44a..40ca5594a336 100644
--- a/drivers/watchdog/ks8695_wdt.c
+++ b/drivers/watchdog/ks8695_wdt.c
@@ -323,5 +323,4 @@ module_exit(ks8695_wdt_exit);
 MODULE_AUTHOR("Andrew Victor");
 MODULE_DESCRIPTION("Watchdog driver for KS8695");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:ks8695_wdt");
diff --git a/drivers/watchdog/lantiq_wdt.c b/drivers/watchdog/lantiq_wdt.c
index 088fd0c9d888..3b3148c764a3 100644
--- a/drivers/watchdog/lantiq_wdt.c
+++ b/drivers/watchdog/lantiq_wdt.c
@@ -249,4 +249,3 @@ MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started");
 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
 MODULE_DESCRIPTION("Lantiq SoC Watchdog");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/m54xx_wdt.c b/drivers/watchdog/m54xx_wdt.c
index 173494a681e6..da6fa2b68074 100644
--- a/drivers/watchdog/m54xx_wdt.c
+++ b/drivers/watchdog/m54xx_wdt.c
@@ -223,4 +223,3 @@ module_param(nowayout, bool, 0);
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started");
 
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/machzwd.c b/drivers/watchdog/machzwd.c
index bf84f788e592..9826b59ef734 100644
--- a/drivers/watchdog/machzwd.c
+++ b/drivers/watchdog/machzwd.c
@@ -92,7 +92,6 @@ static unsigned short zf_readw(unsigned char port)
 MODULE_AUTHOR("Fernando Fuganti <fuganti@conectiva.com.br>");
 MODULE_DESCRIPTION("MachZ ZF-Logic Watchdog driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 static bool nowayout = WATCHDOG_NOWAYOUT;
 module_param(nowayout, bool, 0);
diff --git a/drivers/watchdog/max63xx_wdt.c b/drivers/watchdog/max63xx_wdt.c
index cc9d328086ed..6d4f3998e1f6 100644
--- a/drivers/watchdog/max63xx_wdt.c
+++ b/drivers/watchdog/max63xx_wdt.c
@@ -258,4 +258,3 @@ MODULE_PARM_DESC(nodelay,
                  "(max6373/74 only, default=0)");
 
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/mixcomwd.c b/drivers/watchdog/mixcomwd.c
index 97d62ee50341..be86ea359eee 100644
--- a/drivers/watchdog/mixcomwd.c
+++ b/drivers/watchdog/mixcomwd.c
@@ -315,4 +315,3 @@ MODULE_AUTHOR("Gergely Madarasz <gorgo@itc.hu>");
 MODULE_DESCRIPTION("MixCom Watchdog driver");
 MODULE_VERSION(VERSION);
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/moxart_wdt.c b/drivers/watchdog/moxart_wdt.c
new file mode 100644
index 000000000000..4166e4d116a8
--- /dev/null
+++ b/drivers/watchdog/moxart_wdt.c
@@ -0,0 +1,165 @@
+/*
+ * MOXA ART SoCs watchdog driver.
+ *
+ * Copyright (C) 2013 Jonas Jensen
+ *
+ * Jonas Jensen <jonas.jensen@gmail.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/watchdog.h>
+#include <linux/moduleparam.h>
+
+#define REG_COUNT                       0x4
+#define REG_MODE                        0x8
+#define REG_ENABLE                      0xC
+
+struct moxart_wdt_dev {
+        struct watchdog_device dev;
+        void __iomem *base;
+        unsigned int clock_frequency;
+};
+
+static int heartbeat;
+
+static int moxart_wdt_stop(struct watchdog_device *wdt_dev)
+{
+        struct moxart_wdt_dev *moxart_wdt = watchdog_get_drvdata(wdt_dev);
+
+        writel(0, moxart_wdt->base + REG_ENABLE);
+
+        return 0;
+}
+
+static int moxart_wdt_start(struct watchdog_device *wdt_dev)
+{
+        struct moxart_wdt_dev *moxart_wdt = watchdog_get_drvdata(wdt_dev);
+
+        writel(moxart_wdt->clock_frequency * wdt_dev->timeout,
+               moxart_wdt->base + REG_COUNT);
+        writel(0x5ab9, moxart_wdt->base + REG_MODE);
+        writel(0x03, moxart_wdt->base + REG_ENABLE);
+
+        return 0;
+}
+
+static int moxart_wdt_set_timeout(struct watchdog_device *wdt_dev,
+                                  unsigned int timeout)
+{
+        wdt_dev->timeout = timeout;
+
+        return 0;
+}
+
+static const struct watchdog_info moxart_wdt_info = {
+        .identity       = "moxart-wdt",
+        .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
+                          WDIOF_MAGICCLOSE,
+};
+
+static const struct watchdog_ops moxart_wdt_ops = {
+        .owner          = THIS_MODULE,
+        .start          = moxart_wdt_start,
+        .stop           = moxart_wdt_stop,
+        .set_timeout    = moxart_wdt_set_timeout,
+};
+
+static int moxart_wdt_probe(struct platform_device *pdev)
+{
+        struct moxart_wdt_dev *moxart_wdt;
+        struct device *dev = &pdev->dev;
+        struct device_node *node = dev->of_node;
+        struct resource *res;
+        struct clk *clk;
+        int err;
+        unsigned int max_timeout;
+        bool nowayout = WATCHDOG_NOWAYOUT;
+
+        moxart_wdt = devm_kzalloc(dev, sizeof(*moxart_wdt), GFP_KERNEL);
+        if (!moxart_wdt)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, moxart_wdt);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        moxart_wdt->base = devm_ioremap_resource(dev, res);
+        if (IS_ERR(moxart_wdt->base))
+                return PTR_ERR(moxart_wdt->base);
+
+        clk = of_clk_get(node, 0);
+        if (IS_ERR(clk)) {
+                pr_err("%s: of_clk_get failed\n", __func__);
+                return PTR_ERR(clk);
+        }
+
+        moxart_wdt->clock_frequency = clk_get_rate(clk);
+        if (moxart_wdt->clock_frequency == 0) {
+                pr_err("%s: incorrect clock frequency\n", __func__);
+                return -EINVAL;
+        }
+
+        max_timeout = UINT_MAX / moxart_wdt->clock_frequency;
+
+        moxart_wdt->dev.info = &moxart_wdt_info;
+        moxart_wdt->dev.ops = &moxart_wdt_ops;
+        moxart_wdt->dev.timeout = max_timeout;
+        moxart_wdt->dev.min_timeout = 1;
+        moxart_wdt->dev.max_timeout = max_timeout;
+        moxart_wdt->dev.parent = dev;
+
+        watchdog_init_timeout(&moxart_wdt->dev, heartbeat, dev);
+        watchdog_set_nowayout(&moxart_wdt->dev, nowayout);
+
+        watchdog_set_drvdata(&moxart_wdt->dev, moxart_wdt);
+
+        err = watchdog_register_device(&moxart_wdt->dev);
+        if (err)
+                return err;
+
+        dev_dbg(dev, "Watchdog enabled (heartbeat=%d sec, nowayout=%d)\n",
+                moxart_wdt->dev.timeout, nowayout);
+
+        return 0;
+}
+
+static int moxart_wdt_remove(struct platform_device *pdev)
+{
+        struct moxart_wdt_dev *moxart_wdt = platform_get_drvdata(pdev);
+
+        moxart_wdt_stop(&moxart_wdt->dev);
+        watchdog_unregister_device(&moxart_wdt->dev);
+
+        return 0;
+}
+
+static const struct of_device_id moxart_watchdog_match[] = {
+        { .compatible = "moxa,moxart-watchdog" },
+        { },
+};
+
+static struct platform_driver moxart_wdt_driver = {
+        .probe      = moxart_wdt_probe,
+        .remove     = moxart_wdt_remove,
+        .driver     = {
+                .name           = "moxart-watchdog",
+                .owner          = THIS_MODULE,
+                .of_match_table = moxart_watchdog_match,
+        },
+};
+module_platform_driver(moxart_wdt_driver);
+
+module_param(heartbeat, int, 0);
+MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds");
+
+MODULE_DESCRIPTION("MOXART watchdog driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jonas Jensen <jonas.jensen@gmail.com>");
diff --git a/drivers/watchdog/mpc8xxx_wdt.c b/drivers/watchdog/mpc8xxx_wdt.c
index d0ebebae607c..d82152077fd9 100644
--- a/drivers/watchdog/mpc8xxx_wdt.c
+++ b/drivers/watchdog/mpc8xxx_wdt.c
@@ -330,4 +330,3 @@ MODULE_AUTHOR("Dave Updegraff, Kumar Gala");
 MODULE_DESCRIPTION("Driver for watchdog timer in MPC8xx/MPC83xx/MPC86xx "
                    "uProcessors");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/mtx-1_wdt.c b/drivers/watchdog/mtx-1_wdt.c
index b4341110ad4f..edb31ffd7927 100644
--- a/drivers/watchdog/mtx-1_wdt.c
+++ b/drivers/watchdog/mtx-1_wdt.c
@@ -257,5 +257,4 @@ module_platform_driver(mtx1_wdt_driver);
 MODULE_AUTHOR("Michael Stickel, Florian Fainelli");
 MODULE_DESCRIPTION("Driver for the MTX-1 watchdog");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:mtx1-wdt");
diff --git a/drivers/watchdog/mv64x60_wdt.c b/drivers/watchdog/mv64x60_wdt.c
index e4cf98019265..f9fa58409396 100644
--- a/drivers/watchdog/mv64x60_wdt.c
+++ b/drivers/watchdog/mv64x60_wdt.c
@@ -255,7 +255,7 @@ static struct miscdevice mv64x60_wdt_miscdev = {
 
 static int mv64x60_wdt_probe(struct platform_device *dev)
 {
-        struct mv64x60_wdt_pdata *pdata = dev->dev.platform_data;
+        struct mv64x60_wdt_pdata *pdata = dev_get_platdata(&dev->dev);
         struct resource *r;
         int timeout = 10;
 
@@ -323,5 +323,4 @@ module_exit(mv64x60_wdt_exit);
 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
 MODULE_DESCRIPTION("MV64x60 watchdog driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:" MV64x60_WDT_NAME);
diff --git a/drivers/watchdog/nuc900_wdt.c b/drivers/watchdog/nuc900_wdt.c
index b15b6efd91a1..a0d893b0930e 100644
--- a/drivers/watchdog/nuc900_wdt.c
+++ b/drivers/watchdog/nuc900_wdt.c
@@ -307,5 +307,4 @@ module_platform_driver(nuc900wdt_driver);
 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
 MODULE_DESCRIPTION("Watchdog driver for NUC900");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:nuc900-wdt");
diff --git a/drivers/watchdog/nv_tco.c b/drivers/watchdog/nv_tco.c
index 59cf19eeea07..231e5b9d5c8e 100644
--- a/drivers/watchdog/nv_tco.c
+++ b/drivers/watchdog/nv_tco.c
@@ -513,4 +513,3 @@ module_exit(nv_tco_cleanup_module);
 MODULE_AUTHOR("Mike Waychison");
 MODULE_DESCRIPTION("TCO timer driver for NV chipsets");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/of_xilinx_wdt.c b/drivers/watchdog/of_xilinx_wdt.c
index 4dd281f2c33f..fb57103c8ebc 100644
--- a/drivers/watchdog/of_xilinx_wdt.c
+++ b/drivers/watchdog/of_xilinx_wdt.c
@@ -405,4 +405,3 @@ module_platform_driver(xwdt_driver);
 MODULE_AUTHOR("Alejandro Cabrera <aldaya@gmail.com>");
 MODULE_DESCRIPTION("Xilinx Watchdog driver");
 MODULE_LICENSE("GPL v2");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/omap_wdt.c b/drivers/watchdog/omap_wdt.c
index af88ffd1068f..09cf0135e8ac 100644
--- a/drivers/watchdog/omap_wdt.c
+++ b/drivers/watchdog/omap_wdt.c
@@ -68,14 +68,14 @@ static void omap_wdt_reload(struct omap_wdt_dev *wdev)
         void __iomem    *base = wdev->base;
 
         /* wait for posted write to complete */
-        while ((__raw_readl(base + OMAP_WATCHDOG_WPS)) & 0x08)
+        while ((readl_relaxed(base + OMAP_WATCHDOG_WPS)) & 0x08)
                 cpu_relax();
 
         wdev->wdt_trgr_pattern = ~wdev->wdt_trgr_pattern;
-        __raw_writel(wdev->wdt_trgr_pattern, (base + OMAP_WATCHDOG_TGR));
+        writel_relaxed(wdev->wdt_trgr_pattern, (base + OMAP_WATCHDOG_TGR));
 
         /* wait for posted write to complete */
-        while ((__raw_readl(base + OMAP_WATCHDOG_WPS)) & 0x08)
+        while ((readl_relaxed(base + OMAP_WATCHDOG_WPS)) & 0x08)
                 cpu_relax();
         /* reloaded WCRR from WLDR */
 }
@@ -85,12 +85,12 @@ static void omap_wdt_enable(struct omap_wdt_dev *wdev)
         void __iomem *base = wdev->base;
 
         /* Sequence to enable the watchdog */
-        __raw_writel(0xBBBB, base + OMAP_WATCHDOG_SPR);
-        while ((__raw_readl(base + OMAP_WATCHDOG_WPS)) & 0x10)
+        writel_relaxed(0xBBBB, base + OMAP_WATCHDOG_SPR);
+        while ((readl_relaxed(base + OMAP_WATCHDOG_WPS)) & 0x10)
                 cpu_relax();
 
-        __raw_writel(0x4444, base + OMAP_WATCHDOG_SPR);
-        while ((__raw_readl(base + OMAP_WATCHDOG_WPS)) & 0x10)
+        writel_relaxed(0x4444, base + OMAP_WATCHDOG_SPR);
+        while ((readl_relaxed(base + OMAP_WATCHDOG_WPS)) & 0x10)
                 cpu_relax();
 }
 
@@ -99,12 +99,12 @@ static void omap_wdt_disable(struct omap_wdt_dev *wdev)
         void __iomem *base = wdev->base;
 
         /* sequence required to disable watchdog */
-        __raw_writel(0xAAAA, base + OMAP_WATCHDOG_SPR); /* TIMER_MODE */
-        while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x10)
+        writel_relaxed(0xAAAA, base + OMAP_WATCHDOG_SPR);       /* TIMER_MODE */
+        while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x10)
                 cpu_relax();
 
-        __raw_writel(0x5555, base + OMAP_WATCHDOG_SPR); /* TIMER_MODE */
-        while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x10)
+        writel_relaxed(0x5555, base + OMAP_WATCHDOG_SPR);       /* TIMER_MODE */
+        while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x10)
                 cpu_relax();
 }
 
@@ -115,11 +115,11 @@ static void omap_wdt_set_timer(struct omap_wdt_dev *wdev,
         void __iomem *base = wdev->base;
 
         /* just count up at 32 KHz */
-        while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x04)
+        while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x04)
                 cpu_relax();
 
-        __raw_writel(pre_margin, base + OMAP_WATCHDOG_LDR);
-        while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x04)
+        writel_relaxed(pre_margin, base + OMAP_WATCHDOG_LDR);
+        while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x04)
                 cpu_relax();
 }
 
@@ -135,11 +135,11 @@ static int omap_wdt_start(struct watchdog_device *wdog)
         pm_runtime_get_sync(wdev->dev);
 
         /* initialize prescaler */
-        while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x01)
+        while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x01)
                 cpu_relax();
 
-        __raw_writel((1 << 5) | (PTV << 2), base + OMAP_WATCHDOG_CNTRL);
-        while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x01)
+        writel_relaxed((1 << 5) | (PTV << 2), base + OMAP_WATCHDOG_CNTRL);
+        while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x01)
                 cpu_relax();
 
         omap_wdt_set_timer(wdev, wdog->timeout);
@@ -205,7 +205,7 @@ static const struct watchdog_ops omap_wdt_ops = {
 
 static int omap_wdt_probe(struct platform_device *pdev)
 {
-        struct omap_wd_timer_platform_data *pdata = pdev->dev.platform_data;
+        struct omap_wd_timer_platform_data *pdata = dev_get_platdata(&pdev->dev);
         struct watchdog_device *omap_wdt;
         struct resource *res, *mem;
         struct omap_wdt_dev *wdev;
@@ -275,7 +275,7 @@ static int omap_wdt_probe(struct platform_device *pdev)
         }
 
         pr_info("OMAP Watchdog Timer Rev 0x%02x: initial timeout %d sec\n",
-                __raw_readl(wdev->base + OMAP_WATCHDOG_REV) & 0xFF,
+                readl_relaxed(wdev->base + OMAP_WATCHDOG_REV) & 0xFF,
                 omap_wdt->timeout);
 
         pm_runtime_put_sync(wdev->dev);
diff --git a/drivers/watchdog/orion_wdt.c b/drivers/watchdog/orion_wdt.c
index 4ea5fcccac02..44edca66d564 100644
--- a/drivers/watchdog/orion_wdt.c
+++ b/drivers/watchdog/orion_wdt.c
@@ -207,7 +207,7 @@ static struct platform_driver orion_wdt_driver = {
         .driver         = {
                 .owner  = THIS_MODULE,
                 .name   = "orion_wdt",
-                .of_match_table = of_match_ptr(orion_wdt_of_match_table),
+                .of_match_table = orion_wdt_of_match_table,
         },
 };
 
@@ -225,4 +225,3 @@ MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
 
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:orion_wdt");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/pc87413_wdt.c b/drivers/watchdog/pc87413_wdt.c
index 5afb89b48650..5211d56b3681 100644
--- a/drivers/watchdog/pc87413_wdt.c
+++ b/drivers/watchdog/pc87413_wdt.c
@@ -580,8 +580,6 @@ MODULE_AUTHOR("Sven Anders <anders@anduras.de>, "
 MODULE_DESCRIPTION("PC87413 WDT driver");
 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_DEFAULT) ").");
diff --git a/drivers/watchdog/pcwd.c b/drivers/watchdog/pcwd.c
index 33e49a7f889f..e936f15dc7c7 100644
--- a/drivers/watchdog/pcwd.c
+++ b/drivers/watchdog/pcwd.c
@@ -61,7 +61,7 @@
 #include <linux/delay.h>        /* For mdelay function */
 #include <linux/timer.h>        /* For timer related operations */
 #include <linux/jiffies.h>      /* For jiffies stuff */
-#include <linux/miscdevice.h>   /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */
+#include <linux/miscdevice.h>   /* For struct miscdevice */
 #include <linux/watchdog.h>     /* For the watchdog specific items */
 #include <linux/reboot.h>       /* For kernel_power_off() */
 #include <linux/init.h>         /* For __init/__exit/... */
@@ -1011,5 +1011,3 @@ MODULE_AUTHOR("Ken Hollis <kenji@bitgate.com>, "
 MODULE_DESCRIPTION("Berkshire ISA-PC Watchdog driver");
 MODULE_VERSION(WATCHDOG_VERSION);
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-MODULE_ALIAS_MISCDEV(TEMP_MINOR);
diff --git a/drivers/watchdog/pcwd_pci.c b/drivers/watchdog/pcwd_pci.c
index 7890f84edf76..b4864f254b48 100644
--- a/drivers/watchdog/pcwd_pci.c
+++ b/drivers/watchdog/pcwd_pci.c
@@ -40,7 +40,7 @@
 #include <linux/errno.h>        /* For the -ENODEV/... values */
 #include <linux/kernel.h>       /* For printk/panic/... */
 #include <linux/delay.h>        /* For mdelay function */
-#include <linux/miscdevice.h>   /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */
+#include <linux/miscdevice.h>   /* For struct miscdevice */
 #include <linux/watchdog.h>     /* For the watchdog specific items */
 #include <linux/notifier.h>     /* For notifier support */
 #include <linux/reboot.h>       /* For reboot_notifier stuff */
@@ -820,5 +820,3 @@ module_pci_driver(pcipcwd_driver);
 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
 MODULE_DESCRIPTION("Berkshire PCI-PC Watchdog driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-MODULE_ALIAS_MISCDEV(TEMP_MINOR);
diff --git a/drivers/watchdog/pcwd_usb.c b/drivers/watchdog/pcwd_usb.c
index 7b14d1847927..b731b5d129be 100644
--- a/drivers/watchdog/pcwd_usb.c
+++ b/drivers/watchdog/pcwd_usb.c
@@ -32,7 +32,7 @@
 #include <linux/errno.h>        /* For the -ENODEV/... values */
 #include <linux/kernel.h>       /* For printk/panic/... */
 #include <linux/delay.h>        /* For mdelay function */
-#include <linux/miscdevice.h>   /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */
+#include <linux/miscdevice.h>   /* For struct miscdevice */
 #include <linux/watchdog.h>     /* For the watchdog specific items */
 #include <linux/notifier.h>     /* For notifier support */
 #include <linux/reboot.h>       /* For reboot_notifier stuff */
@@ -72,8 +72,6 @@ do {							\
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE(DRIVER_LICENSE);
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-MODULE_ALIAS_MISCDEV(TEMP_MINOR);
 
 /* Module Parameters */
 module_param(debug, int, 0);
@@ -235,13 +233,17 @@ static int usb_pcwd_send_command(struct usb_pcwd_private *usb_pcwd,
                 unsigned char cmd, unsigned char *msb, unsigned char *lsb)
 {
         int got_response, count;
-        unsigned char buf[6];
+        unsigned char *buf;
 
         /* We will not send any commands if the USB PCWD device does
          * not exist */
         if ((!usb_pcwd) || (!usb_pcwd->exists))
                 return -1;
 
+        buf = kmalloc(6, GFP_KERNEL);
+        if (buf == NULL)
+                return 0;
+
         /* The USB PC Watchdog uses a 6 byte report format.
          * The board currently uses only 3 of the six bytes of the report. */
         buf[0] = cmd;                   /* Byte 0 = CMD */
@@ -256,8 +258,8 @@ static int usb_pcwd_send_command(struct usb_pcwd_private *usb_pcwd,
 
         if (usb_control_msg(usb_pcwd->udev, usb_sndctrlpipe(usb_pcwd->udev, 0),
                         HID_REQ_SET_REPORT, HID_DT_REPORT,
-                        0x0200, usb_pcwd->interface_number, buf, sizeof(buf),
-                        USB_COMMAND_TIMEOUT) != sizeof(buf)) {
+                        0x0200, usb_pcwd->interface_number, buf, 6,
+                        USB_COMMAND_TIMEOUT) != 6) {
                 dbg("usb_pcwd_send_command: error in usb_control_msg for "
                                 "cmd 0x%x 0x%x 0x%x\n", cmd, *msb, *lsb);
         }
@@ -277,6 +279,8 @@ static int usb_pcwd_send_command(struct usb_pcwd_private *usb_pcwd,
                 *lsb = usb_pcwd->cmd_data_lsb;
         }
 
+        kfree(buf);
+
         return got_response;
 }
 
diff --git a/drivers/watchdog/pika_wdt.c b/drivers/watchdog/pika_wdt.c
index 329bc60ad7a2..0cdfee266690 100644
--- a/drivers/watchdog/pika_wdt.c
+++ b/drivers/watchdog/pika_wdt.c
@@ -299,5 +299,3 @@ module_exit(pikawdt_exit);
 MODULE_AUTHOR("Sean MacLennan <smaclennan@pikatech.com>");
 MODULE_DESCRIPTION("PIKA FPGA based Watchdog Timer");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-
diff --git a/drivers/watchdog/pnx4008_wdt.c b/drivers/watchdog/pnx4008_wdt.c
index b30bd430f591..1bdcc313e1d9 100644
--- a/drivers/watchdog/pnx4008_wdt.c
+++ b/drivers/watchdog/pnx4008_wdt.c
@@ -233,5 +233,4 @@ MODULE_PARM_DESC(nowayout,
                  "Set to 1 to keep watchdog running after device release");
 
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:pnx4008-watchdog");
diff --git a/drivers/watchdog/pnx833x_wdt.c b/drivers/watchdog/pnx833x_wdt.c
index 1b62a7dfcc95..882fdcb46ad1 100644
--- a/drivers/watchdog/pnx833x_wdt.c
+++ b/drivers/watchdog/pnx833x_wdt.c
@@ -278,4 +278,3 @@ module_exit(watchdog_exit);
 MODULE_AUTHOR("Daniel Laird/Andre McCurdy");
 MODULE_DESCRIPTION("Hardware Watchdog Device for PNX833x");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/rc32434_wdt.c b/drivers/watchdog/rc32434_wdt.c
index 9cf6bc7a234f..71e78ef4b736 100644
--- a/drivers/watchdog/rc32434_wdt.c
+++ b/drivers/watchdog/rc32434_wdt.c
@@ -25,8 +25,7 @@
 #include <linux/errno.h>                /* For the -ENODEV/... values */
 #include <linux/kernel.h>               /* For printk/panic/... */
 #include <linux/fs.h>                   /* For file operations */
-#include <linux/miscdevice.h>           /* For MODULE_ALIAS_MISCDEV
-                                                        (WATCHDOG_MINOR) */
+#include <linux/miscdevice.h>           /* For struct miscdevice */
 #include <linux/watchdog.h>             /* For the watchdog specific items */
 #include <linux/init.h>                 /* For __init/__exit/... */
 #include <linux/platform_device.h>      /* For platform_driver framework */
@@ -329,4 +328,3 @@ MODULE_AUTHOR("Ondrej Zajicek <santiago@crfreenet.org>,"
                 "Florian Fainelli <florian@openwrt.org>");
 MODULE_DESCRIPTION("Driver for the IDT RC32434 SoC watchdog");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/rdc321x_wdt.c b/drivers/watchdog/rdc321x_wdt.c
index b0f116c2fd53..082d06262959 100644
--- a/drivers/watchdog/rdc321x_wdt.c
+++ b/drivers/watchdog/rdc321x_wdt.c
@@ -231,7 +231,7 @@ static int rdc321x_wdt_probe(struct platform_device *pdev)
         struct resource *r;
         struct rdc321x_wdt_pdata *pdata;
 
-        pdata = pdev->dev.platform_data;
+        pdata = dev_get_platdata(&pdev->dev);
         if (!pdata) {
                 dev_err(&pdev->dev, "no platform data supplied\n");
                 return -ENODEV;
@@ -298,4 +298,3 @@ module_platform_driver(rdc321x_wdt_driver);
 MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>");
 MODULE_DESCRIPTION("RDC321x watchdog driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/rt2880_wdt.c b/drivers/watchdog/rt2880_wdt.c
new file mode 100644
index 000000000000..53d37fea183e
--- /dev/null
+++ b/drivers/watchdog/rt2880_wdt.c
@@ -0,0 +1,207 @@
+/*
+ * Ralink RT288x/RT3xxx/MT76xx built-in hardware watchdog timer
+ *
+ * Copyright (C) 2011 Gabor Juhos <juhosg@openwrt.org>
+ * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
+ *
+ * This driver was based on: drivers/watchdog/softdog.c
+ *
+ * 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.
+ */
+
+#include <linux/clk.h>
+#include <linux/reset.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/watchdog.h>
+#include <linux/miscdevice.h>
+#include <linux/moduleparam.h>
+#include <linux/platform_device.h>
+
+#include <asm/mach-ralink/ralink_regs.h>
+
+#define SYSC_RSTSTAT                    0x38
+#define WDT_RST_CAUSE                   BIT(1)
+
+#define RALINK_WDT_TIMEOUT              30
+#define RALINK_WDT_PRESCALE             65536
+
+#define TIMER_REG_TMR1LOAD              0x00
+#define TIMER_REG_TMR1CTL               0x08
+
+#define TMRSTAT_TMR1RST                 BIT(5)
+
+#define TMR1CTL_ENABLE                  BIT(7)
+#define TMR1CTL_MODE_SHIFT              4
+#define TMR1CTL_MODE_MASK               0x3
+#define TMR1CTL_MODE_FREE_RUNNING       0x0
+#define TMR1CTL_MODE_PERIODIC           0x1
+#define TMR1CTL_MODE_TIMEOUT            0x2
+#define TMR1CTL_MODE_WDT                0x3
+#define TMR1CTL_PRESCALE_MASK           0xf
+#define TMR1CTL_PRESCALE_65536          0xf
+
+static struct clk *rt288x_wdt_clk;
+static unsigned long rt288x_wdt_freq;
+static void __iomem *rt288x_wdt_base;
+
+static bool nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, bool, 0);
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+static inline void rt_wdt_w32(unsigned reg, u32 val)
+{
+        iowrite32(val, rt288x_wdt_base + reg);
+}
+
+static inline u32 rt_wdt_r32(unsigned reg)
+{
+        return ioread32(rt288x_wdt_base + reg);
+}
+
+static int rt288x_wdt_ping(struct watchdog_device *w)
+{
+        rt_wdt_w32(TIMER_REG_TMR1LOAD, w->timeout * rt288x_wdt_freq);
+
+        return 0;
+}
+
+static int rt288x_wdt_start(struct watchdog_device *w)
+{
+        u32 t;
+
+        t = rt_wdt_r32(TIMER_REG_TMR1CTL);
+        t &= ~(TMR1CTL_MODE_MASK << TMR1CTL_MODE_SHIFT |
+                TMR1CTL_PRESCALE_MASK);
+        t |= (TMR1CTL_MODE_WDT << TMR1CTL_MODE_SHIFT |
+                TMR1CTL_PRESCALE_65536);
+        rt_wdt_w32(TIMER_REG_TMR1CTL, t);
+
+        rt288x_wdt_ping(w);
+
+        t = rt_wdt_r32(TIMER_REG_TMR1CTL);
+        t |= TMR1CTL_ENABLE;
+        rt_wdt_w32(TIMER_REG_TMR1CTL, t);
+
+        return 0;
+}
+
+static int rt288x_wdt_stop(struct watchdog_device *w)
+{
+        u32 t;
+
+        rt288x_wdt_ping(w);
+
+        t = rt_wdt_r32(TIMER_REG_TMR1CTL);
+        t &= ~TMR1CTL_ENABLE;
+        rt_wdt_w32(TIMER_REG_TMR1CTL, t);
+
+        return 0;
+}
+
+static int rt288x_wdt_set_timeout(struct watchdog_device *w, unsigned int t)
+{
+        w->timeout = t;
+        rt288x_wdt_ping(w);
+
+        return 0;
+}
+
+static int rt288x_wdt_bootcause(void)
+{
+        if (rt_sysc_r32(SYSC_RSTSTAT) & WDT_RST_CAUSE)
+                return WDIOF_CARDRESET;
+
+        return 0;
+}
+
+static struct watchdog_info rt288x_wdt_info = {
+        .identity = "Ralink Watchdog",
+        .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
+};
+
+static struct watchdog_ops rt288x_wdt_ops = {
+        .owner = THIS_MODULE,
+        .start = rt288x_wdt_start,
+        .stop = rt288x_wdt_stop,
+        .ping = rt288x_wdt_ping,
+        .set_timeout = rt288x_wdt_set_timeout,
+};
+
+static struct watchdog_device rt288x_wdt_dev = {
+        .info = &rt288x_wdt_info,
+        .ops = &rt288x_wdt_ops,
+        .min_timeout = 1,
+};
+
+static int rt288x_wdt_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        int ret;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        rt288x_wdt_base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(rt288x_wdt_base))
+                return PTR_ERR(rt288x_wdt_base);
+
+        rt288x_wdt_clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(rt288x_wdt_clk))
+                return PTR_ERR(rt288x_wdt_clk);
+
+        device_reset(&pdev->dev);
+
+        rt288x_wdt_freq = clk_get_rate(rt288x_wdt_clk) / RALINK_WDT_PRESCALE;
+
+        rt288x_wdt_dev.dev = &pdev->dev;
+        rt288x_wdt_dev.bootstatus = rt288x_wdt_bootcause();
+
+        rt288x_wdt_dev.max_timeout = (0xfffful / rt288x_wdt_freq);
+        rt288x_wdt_dev.timeout = rt288x_wdt_dev.max_timeout;
+
+        watchdog_set_nowayout(&rt288x_wdt_dev, nowayout);
+
+        ret = watchdog_register_device(&rt288x_wdt_dev);
+        if (!ret)
+                dev_info(&pdev->dev, "Initialized\n");
+
+        return 0;
+}
+
+static int rt288x_wdt_remove(struct platform_device *pdev)
+{
+        watchdog_unregister_device(&rt288x_wdt_dev);
+
+        return 0;
+}
+
+static void rt288x_wdt_shutdown(struct platform_device *pdev)
+{
+        rt288x_wdt_stop(&rt288x_wdt_dev);
+}
+
+static const struct of_device_id rt288x_wdt_match[] = {
+        { .compatible = "ralink,rt2880-wdt" },
+        {},
+};
+MODULE_DEVICE_TABLE(of, rt288x_wdt_match);
+
+static struct platform_driver rt288x_wdt_driver = {
+        .probe          = rt288x_wdt_probe,
+        .remove         = rt288x_wdt_remove,
+        .shutdown       = rt288x_wdt_shutdown,
+        .driver         = {
+                .name           = KBUILD_MODNAME,
+                .owner          = THIS_MODULE,
+                .of_match_table = rt288x_wdt_match,
+        },
+};
+
+module_platform_driver(rt288x_wdt_driver);
+
+MODULE_DESCRIPTION("MediaTek/Ralink RT288x/RT3xxx hardware watchdog driver");
+MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/watchdog/s3c2410_wdt.c b/drivers/watchdog/s3c2410_wdt.c
index 23aad7c6bf5d..7d8fd041ee25 100644
--- a/drivers/watchdog/s3c2410_wdt.c
+++ b/drivers/watchdog/s3c2410_wdt.c
@@ -29,7 +29,6 @@
 #include <linux/moduleparam.h>
 #include <linux/types.h>
 #include <linux/timer.h>
-#include <linux/miscdevice.h> /* for MODULE_ALIAS_MISCDEV */
 #include <linux/watchdog.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
@@ -539,5 +538,4 @@ MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>, "
               "Dimitry Andric <dimitry.andric@tomtom.com>");
 MODULE_DESCRIPTION("S3C2410 Watchdog Device Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:s3c2410-wdt");
diff --git a/drivers/watchdog/sa1100_wdt.c b/drivers/watchdog/sa1100_wdt.c
index ccd6b29e21bf..e1d39a1e9628 100644
--- a/drivers/watchdog/sa1100_wdt.c
+++ b/drivers/watchdog/sa1100_wdt.c
@@ -193,4 +193,3 @@ module_param(margin, int, 0);
 MODULE_PARM_DESC(margin, "Watchdog margin in seconds (default 60s)");
 
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/sb_wdog.c b/drivers/watchdog/sb_wdog.c
index ea5d84a1fdad..3abae50773b8 100644
--- a/drivers/watchdog/sb_wdog.c
+++ b/drivers/watchdog/sb_wdog.c
@@ -341,7 +341,6 @@ MODULE_PARM_DESC(timeout,
       "Watchdog timeout in microseconds (max/default 8388607 or 8.3ish secs)");
 
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 /*
  * example code that can be put in a platform code area to utilize the
diff --git a/drivers/watchdog/sbc60xxwdt.c b/drivers/watchdog/sbc60xxwdt.c
index 63632ec87c7e..2eef58a0cf05 100644
--- a/drivers/watchdog/sbc60xxwdt.c
+++ b/drivers/watchdog/sbc60xxwdt.c
@@ -387,4 +387,3 @@ module_exit(sbc60xxwdt_unload);
 MODULE_AUTHOR("Jakob Oestergaard <jakob@unthought.net>");
 MODULE_DESCRIPTION("60xx Single Board Computer Watchdog Timer driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/sbc7240_wdt.c b/drivers/watchdog/sbc7240_wdt.c
index 719edc8fdeb3..5f268add17ce 100644
--- a/drivers/watchdog/sbc7240_wdt.c
+++ b/drivers/watchdog/sbc7240_wdt.c
@@ -309,5 +309,3 @@ MODULE_AUTHOR("Gilles Gigan");
 MODULE_DESCRIPTION("Watchdog device driver for single board"
                    " computers EPIC Nano 7240 from iEi");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-
diff --git a/drivers/watchdog/sbc8360.c b/drivers/watchdog/sbc8360.c
index d4781e05f017..da60560ca446 100644
--- a/drivers/watchdog/sbc8360.c
+++ b/drivers/watchdog/sbc8360.c
@@ -404,6 +404,5 @@ MODULE_AUTHOR("Ian E. Morgan <imorgan@webcon.ca>");
 MODULE_DESCRIPTION("SBC8360 watchdog driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION("1.01");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 /* end of sbc8360.c */
diff --git a/drivers/watchdog/sbc_epx_c3.c b/drivers/watchdog/sbc_epx_c3.c
index 0c3e9f66ef77..a1c502e0d8ec 100644
--- a/drivers/watchdog/sbc_epx_c3.c
+++ b/drivers/watchdog/sbc_epx_c3.c
@@ -220,4 +220,3 @@ MODULE_DESCRIPTION("Hardware Watchdog Device for Winsystems EPX-C3 SBC.  "
         "so only use it if you are *sure* you are running on this specific "
         "SBC system from Winsystems!  It writes to IO ports 0x1ee and 0x1ef!");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/sbc_fitpc2_wdt.c b/drivers/watchdog/sbc_fitpc2_wdt.c
index 90d5527ca886..a517d8bae757 100644
--- a/drivers/watchdog/sbc_fitpc2_wdt.c
+++ b/drivers/watchdog/sbc_fitpc2_wdt.c
@@ -263,5 +263,3 @@ module_param(nowayout, bool, 0);
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started");
 
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-
diff --git a/drivers/watchdog/sc1200wdt.c b/drivers/watchdog/sc1200wdt.c
index 3fb83b0c28c2..3b9fff9dcf65 100644
--- a/drivers/watchdog/sc1200wdt.c
+++ b/drivers/watchdog/sc1200wdt.c
@@ -476,4 +476,3 @@ MODULE_AUTHOR("Zwane Mwaikambo <zwane@commfireservices.com>");
 MODULE_DESCRIPTION(
         "Driver for National Semiconductor PC87307/PC97307 watchdog component");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/sc520_wdt.c b/drivers/watchdog/sc520_wdt.c
index 707e027e5002..f353e18b1a82 100644
--- a/drivers/watchdog/sc520_wdt.c
+++ b/drivers/watchdog/sc520_wdt.c
@@ -433,4 +433,3 @@ MODULE_AUTHOR("Scott and Bill Jennings");
 MODULE_DESCRIPTION(
         "Driver for watchdog timer in AMD \"Elan\" SC520 uProcessor");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/sch311x_wdt.c b/drivers/watchdog/sch311x_wdt.c
index af7b136b1874..b96127ea3de1 100644
--- a/drivers/watchdog/sch311x_wdt.c
+++ b/drivers/watchdog/sch311x_wdt.c
@@ -26,8 +26,7 @@
 #include <linux/types.h>                /* For standard types (like size_t) */
 #include <linux/errno.h>                /* For the -ENODEV/... values */
 #include <linux/kernel.h>               /* For printk/... */
-#include <linux/miscdevice.h>           /* For MODULE_ALIAS_MISCDEV
-                                                        (WATCHDOG_MINOR) */
+#include <linux/miscdevice.h>           /* For struct miscdevice */
 #include <linux/watchdog.h>             /* For the watchdog specific items */
 #include <linux/init.h>                 /* For __init/__exit/... */
 #include <linux/fs.h>                   /* For file operations */
@@ -545,5 +544,3 @@ module_exit(sch311x_wdt_exit);
 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
 MODULE_DESCRIPTION("SMSC SCH311x WatchDog Timer Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-
diff --git a/drivers/watchdog/scx200_wdt.c b/drivers/watchdog/scx200_wdt.c
index 8ae7c282d465..836377cf9271 100644
--- a/drivers/watchdog/scx200_wdt.c
+++ b/drivers/watchdog/scx200_wdt.c
@@ -37,7 +37,6 @@
 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
 MODULE_DESCRIPTION("NatSemi SCx200 Watchdog Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 static int margin = 60;         /* in seconds */
 module_param(margin, int, 0);
diff --git a/drivers/watchdog/shwdt.c b/drivers/watchdog/shwdt.c
index 5bca79457768..f9b8e06f3558 100644
--- a/drivers/watchdog/shwdt.c
+++ b/drivers/watchdog/shwdt.c
@@ -343,7 +343,6 @@ MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>");
 MODULE_DESCRIPTION("SuperH watchdog driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:" DRV_NAME);
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 module_param(clock_division_ratio, int, 0);
 MODULE_PARM_DESC(clock_division_ratio,
diff --git a/drivers/watchdog/sirfsoc_wdt.c b/drivers/watchdog/sirfsoc_wdt.c
new file mode 100644
index 000000000000..ced3edc95957
--- /dev/null
+++ b/drivers/watchdog/sirfsoc_wdt.c
@@ -0,0 +1,226 @@
+/*
+ * Watchdog driver for CSR SiRFprimaII and SiRFatlasVI
+ *
+ * Copyright (c) 2013 Cambridge Silicon Radio Limited, a CSR plc group company.
+ *
+ * Licensed under GPLv2 or later.
+ */
+
+#include <linux/module.h>
+#include <linux/watchdog.h>
+#include <linux/platform_device.h>
+#include <linux/moduleparam.h>
+#include <linux/of.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+
+#define CLOCK_FREQ      1000000
+
+#define SIRFSOC_TIMER_COUNTER_LO        0x0000
+#define SIRFSOC_TIMER_MATCH_0           0x0008
+#define SIRFSOC_TIMER_INT_EN            0x0024
+#define SIRFSOC_TIMER_WATCHDOG_EN       0x0028
+#define SIRFSOC_TIMER_LATCH             0x0030
+#define SIRFSOC_TIMER_LATCHED_LO        0x0034
+
+#define SIRFSOC_TIMER_WDT_INDEX         5
+
+#define SIRFSOC_WDT_MIN_TIMEOUT         30              /* 30 secs */
+#define SIRFSOC_WDT_MAX_TIMEOUT         (10 * 60)       /* 10 mins */
+#define SIRFSOC_WDT_DEFAULT_TIMEOUT     30              /* 30 secs */
+
+static unsigned int timeout = SIRFSOC_WDT_DEFAULT_TIMEOUT;
+static bool nowayout = WATCHDOG_NOWAYOUT;
+
+module_param(timeout, uint, 0);
+module_param(nowayout, bool, 0);
+
+MODULE_PARM_DESC(timeout, "Default watchdog timeout (in seconds)");
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
+                        __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+static unsigned int sirfsoc_wdt_gettimeleft(struct watchdog_device *wdd)
+{
+        u32 counter, match;
+        void __iomem *wdt_base;
+        int time_left;
+
+        wdt_base = watchdog_get_drvdata(wdd);
+        counter = readl(wdt_base + SIRFSOC_TIMER_COUNTER_LO);
+        match = readl(wdt_base +
+                SIRFSOC_TIMER_MATCH_0 + (SIRFSOC_TIMER_WDT_INDEX << 2));
+
+        time_left = match - counter;
+
+        return time_left / CLOCK_FREQ;
+}
+
+static int sirfsoc_wdt_updatetimeout(struct watchdog_device *wdd)
+{
+        u32 counter, timeout_ticks;
+        void __iomem *wdt_base;
+
+        timeout_ticks = wdd->timeout * CLOCK_FREQ;
+        wdt_base = watchdog_get_drvdata(wdd);
+
+        /* Enable the latch before reading the LATCH_LO register */
+        writel(1, wdt_base + SIRFSOC_TIMER_LATCH);
+
+        /* Set the TO value */
+        counter = readl(wdt_base + SIRFSOC_TIMER_LATCHED_LO);
+
+        counter += timeout_ticks;
+
+        writel(counter, wdt_base +
+                SIRFSOC_TIMER_MATCH_0 + (SIRFSOC_TIMER_WDT_INDEX << 2));
+
+        return 0;
+}
+
+static int sirfsoc_wdt_enable(struct watchdog_device *wdd)
+{
+        void __iomem *wdt_base = watchdog_get_drvdata(wdd);
+        sirfsoc_wdt_updatetimeout(wdd);
+
+        /*
+         * NOTE: If interrupt is not enabled
+         * then WD-Reset doesn't get generated at all.
+         */
+        writel(readl(wdt_base + SIRFSOC_TIMER_INT_EN)
+                | (1 << SIRFSOC_TIMER_WDT_INDEX),
+                wdt_base + SIRFSOC_TIMER_INT_EN);
+        writel(1, wdt_base + SIRFSOC_TIMER_WATCHDOG_EN);
+
+        return 0;
+}
+
+static int sirfsoc_wdt_disable(struct watchdog_device *wdd)
+{
+        void __iomem *wdt_base = watchdog_get_drvdata(wdd);
+
+        writel(0, wdt_base + SIRFSOC_TIMER_WATCHDOG_EN);
+        writel(readl(wdt_base + SIRFSOC_TIMER_INT_EN)
+                & (~(1 << SIRFSOC_TIMER_WDT_INDEX)),
+                wdt_base + SIRFSOC_TIMER_INT_EN);
+
+        return 0;
+}
+
+static int sirfsoc_wdt_settimeout(struct watchdog_device *wdd, unsigned int to)
+{
+        wdd->timeout = to;
+        sirfsoc_wdt_updatetimeout(wdd);
+
+        return 0;
+}
+
+#define OPTIONS (WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE)
+
+static const struct watchdog_info sirfsoc_wdt_ident = {
+        .options          =     OPTIONS,
+        .firmware_version =     0,
+        .identity         =     "SiRFSOC Watchdog",
+};
+
+static struct watchdog_ops sirfsoc_wdt_ops = {
+        .owner = THIS_MODULE,
+        .start = sirfsoc_wdt_enable,
+        .stop = sirfsoc_wdt_disable,
+        .get_timeleft = sirfsoc_wdt_gettimeleft,
+        .ping = sirfsoc_wdt_updatetimeout,
+        .set_timeout = sirfsoc_wdt_settimeout,
+};
+
+static struct watchdog_device sirfsoc_wdd = {
+        .info = &sirfsoc_wdt_ident,
+        .ops = &sirfsoc_wdt_ops,
+        .timeout = SIRFSOC_WDT_DEFAULT_TIMEOUT,
+        .min_timeout = SIRFSOC_WDT_MIN_TIMEOUT,
+        .max_timeout = SIRFSOC_WDT_MAX_TIMEOUT,
+};
+
+static int sirfsoc_wdt_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        int ret;
+        void __iomem *base;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(base))
+                return PTR_ERR(base);
+
+        watchdog_set_drvdata(&sirfsoc_wdd, base);
+
+        watchdog_init_timeout(&sirfsoc_wdd, timeout, &pdev->dev);
+        watchdog_set_nowayout(&sirfsoc_wdd, nowayout);
+
+        ret = watchdog_register_device(&sirfsoc_wdd);
+        if (ret)
+                return ret;
+
+        platform_set_drvdata(pdev, &sirfsoc_wdd);
+
+        return 0;
+}
+
+static void sirfsoc_wdt_shutdown(struct platform_device *pdev)
+{
+        struct watchdog_device *wdd = platform_get_drvdata(pdev);
+
+        sirfsoc_wdt_disable(wdd);
+}
+
+static int sirfsoc_wdt_remove(struct platform_device *pdev)
+{
+        sirfsoc_wdt_shutdown(pdev);
+        return 0;
+}
+
+#ifdef  CONFIG_PM_SLEEP
+static int sirfsoc_wdt_suspend(struct device *dev)
+{
+        return 0;
+}
+
+static int sirfsoc_wdt_resume(struct device *dev)
+{
+        struct watchdog_device *wdd = dev_get_drvdata(dev);
+
+        /*
+         * NOTE: Since timer controller registers settings are saved
+         * and restored back by the timer-prima2.c, so we need not
+         * update WD settings except refreshing timeout.
+         */
+        sirfsoc_wdt_updatetimeout(wdd);
+
+        return 0;
+}
+#endif
+
+static SIMPLE_DEV_PM_OPS(sirfsoc_wdt_pm_ops,
+                sirfsoc_wdt_suspend, sirfsoc_wdt_resume);
+
+static const struct of_device_id sirfsoc_wdt_of_match[] = {
+        { .compatible = "sirf,prima2-tick"},
+        {},
+};
+MODULE_DEVICE_TABLE(of, sirfsoc_wdt_of_match);
+
+static struct platform_driver sirfsoc_wdt_driver = {
+        .driver = {
+                .name = "sirfsoc-wdt",
+                .owner = THIS_MODULE,
+                .pm = &sirfsoc_wdt_pm_ops,
+                .of_match_table = of_match_ptr(sirfsoc_wdt_of_match),
+        },
+        .probe = sirfsoc_wdt_probe,
+        .remove = sirfsoc_wdt_remove,
+        .shutdown = sirfsoc_wdt_shutdown,
+};
+module_platform_driver(sirfsoc_wdt_driver);
+
+MODULE_DESCRIPTION("SiRF SoC watchdog driver");
+MODULE_AUTHOR("Xianglong Du <Xianglong.Du@csr.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:sirfsoc-wdt");
diff --git a/drivers/watchdog/smsc37b787_wdt.c b/drivers/watchdog/smsc37b787_wdt.c
index 6d665f9c1d58..445ea1ad1fa9 100644
--- a/drivers/watchdog/smsc37b787_wdt.c
+++ b/drivers/watchdog/smsc37b787_wdt.c
@@ -603,8 +603,6 @@ MODULE_DESCRIPTION("Driver for SMsC 37B787 watchdog component (Version "
                                                                 VERSION ")");
 MODULE_LICENSE("GPL");
 
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-
 #ifdef SMSC_SUPPORT_MINUTES
 module_param(unit, int, 0);
 MODULE_PARM_DESC(unit,
diff --git a/drivers/watchdog/softdog.c b/drivers/watchdog/softdog.c
index b68b1e519d53..ef2638fee4a8 100644
--- a/drivers/watchdog/softdog.c
+++ b/drivers/watchdog/softdog.c
@@ -207,4 +207,3 @@ module_exit(watchdog_exit);
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("Software Watchdog Device Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/sp5100_tco.c b/drivers/watchdog/sp5100_tco.c
index 0e9d8c479c35..ce63a1bbf395 100644
--- a/drivers/watchdog/sp5100_tco.c
+++ b/drivers/watchdog/sp5100_tco.c
@@ -580,4 +580,3 @@ module_exit(sp5100_tco_cleanup_module);
 MODULE_AUTHOR("Priyanka Gupta");
 MODULE_DESCRIPTION("TCO timer driver for SP5100/SB800 chipset");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/sp805_wdt.c b/drivers/watchdog/sp805_wdt.c
index 58df98aec122..3f786ce0a6f2 100644
--- a/drivers/watchdog/sp805_wdt.c
+++ b/drivers/watchdog/sp805_wdt.c
@@ -268,7 +268,6 @@ static int sp805_wdt_remove(struct amba_device *adev)
         struct sp805_wdt *wdt = amba_get_drvdata(adev);
 
         watchdog_unregister_device(&wdt->wdd);
-        amba_set_drvdata(adev, NULL);
         watchdog_set_drvdata(&wdt->wdd, NULL);
 
         return 0;
diff --git a/drivers/watchdog/stmp3xxx_rtc_wdt.c b/drivers/watchdog/stmp3xxx_rtc_wdt.c
index c97e98dcde62..d667f6b51d35 100644
--- a/drivers/watchdog/stmp3xxx_rtc_wdt.c
+++ b/drivers/watchdog/stmp3xxx_rtc_wdt.c
@@ -30,7 +30,7 @@ MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat period in seconds from 1 to "
 static int wdt_start(struct watchdog_device *wdd)
 {
         struct device *dev = watchdog_get_drvdata(wdd);
-        struct stmp3xxx_wdt_pdata *pdata = dev->platform_data;
+        struct stmp3xxx_wdt_pdata *pdata = dev_get_platdata(dev);
 
         pdata->wdt_set_timeout(dev->parent, wdd->timeout * WDOG_TICK_RATE);
         return 0;
@@ -39,7 +39,7 @@ static int wdt_start(struct watchdog_device *wdd)
 static int wdt_stop(struct watchdog_device *wdd)
 {
         struct device *dev = watchdog_get_drvdata(wdd);
-        struct stmp3xxx_wdt_pdata *pdata = dev->platform_data;
+        struct stmp3xxx_wdt_pdata *pdata = dev_get_platdata(dev);
 
         pdata->wdt_set_timeout(dev->parent, 0);
         return 0;
@@ -108,4 +108,3 @@ module_platform_driver(stmp3xxx_wdt_driver);
 MODULE_DESCRIPTION("STMP3XXX RTC Watchdog Driver");
 MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/sunxi_wdt.c b/drivers/watchdog/sunxi_wdt.c
index f6caa77151c7..76332d893e12 100644
--- a/drivers/watchdog/sunxi_wdt.c
+++ b/drivers/watchdog/sunxi_wdt.c
@@ -217,7 +217,7 @@ static struct platform_driver sunxi_wdt_driver = {
         .driver         = {
                 .owner          = THIS_MODULE,
                 .name           = DRV_NAME,
-                .of_match_table = of_match_ptr(sunxi_wdt_dt_ids)
+                .of_match_table = sunxi_wdt_dt_ids,
         },
 };
 
diff --git a/drivers/watchdog/ts72xx_wdt.c b/drivers/watchdog/ts72xx_wdt.c
index c9b0c627fe7e..09d4831aa61f 100644
--- a/drivers/watchdog/ts72xx_wdt.c
+++ b/drivers/watchdog/ts72xx_wdt.c
@@ -192,7 +192,7 @@ static int ts72xx_wdt_open(struct inode *inode, struct file *file)
                 dev_err(&wdt->pdev->dev,
                         "failed to convert timeout (%d) to register value\n",
                         timeout);
-                return -EINVAL;
+                return regval;
         }
 
         if (mutex_lock_interruptible(&wdt->lock))
@@ -305,7 +305,8 @@ static long ts72xx_wdt_ioctl(struct file *file, unsigned int cmd,
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                error = copy_to_user(argp, &winfo, sizeof(winfo));
+                if (copy_to_user(argp, &winfo, sizeof(winfo)))
+                        error = -EFAULT;
                 break;
 
         case WDIOC_GETSTATUS:
@@ -320,10 +321,9 @@ static long ts72xx_wdt_ioctl(struct file *file, unsigned int cmd,
         case WDIOC_SETOPTIONS: {
                 int options;
 
-                if (get_user(options, p)) {
-                        error = -EFAULT;
+                error = get_user(options, p);
+                if (error)
                         break;
-                }
 
                 error = -EINVAL;
 
@@ -341,30 +341,26 @@ static long ts72xx_wdt_ioctl(struct file *file, unsigned int cmd,
 
         case WDIOC_SETTIMEOUT: {
                 int new_timeout;
+                int regval;
 
-                if (get_user(new_timeout, p)) {
-                        error = -EFAULT;
-                } else {
-                        int regval;
-
-                        regval = timeout_to_regval(new_timeout);
-                        if (regval < 0) {
-                                error = -EINVAL;
-                        } else {
-                                ts72xx_wdt_stop(wdt);
-                                wdt->regval = regval;
-                                ts72xx_wdt_start(wdt);
-                        }
-                }
+                error = get_user(new_timeout, p);
                 if (error)
                         break;
 
+                regval = timeout_to_regval(new_timeout);
+                if (regval < 0) {
+                        error = regval;
+                        break;
+                }
+                ts72xx_wdt_stop(wdt);
+                wdt->regval = regval;
+                ts72xx_wdt_start(wdt);
+
                 /*FALLTHROUGH*/
         }
 
         case WDIOC_GETTIMEOUT:
-                if (put_user(regval_to_timeout(wdt->regval), p))
-                        error = -EFAULT;
+                error = put_user(regval_to_timeout(wdt->regval), p);
                 break;
 
         default:
diff --git a/drivers/watchdog/txx9wdt.c b/drivers/watchdog/txx9wdt.c
index 88f23c5cfddb..0fd0e8ae62a8 100644
--- a/drivers/watchdog/txx9wdt.c
+++ b/drivers/watchdog/txx9wdt.c
@@ -176,5 +176,4 @@ module_platform_driver_probe(txx9wdt_driver, txx9wdt_probe);
 
 MODULE_DESCRIPTION("TXx9 Watchdog Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:txx9wdt");
diff --git a/drivers/watchdog/ux500_wdt.c b/drivers/watchdog/ux500_wdt.c
index a614d84121c3..e029b5768f2c 100644
--- a/drivers/watchdog/ux500_wdt.c
+++ b/drivers/watchdog/ux500_wdt.c
@@ -88,7 +88,7 @@ static struct watchdog_device ux500_wdt = {
 static int ux500_wdt_probe(struct platform_device *pdev)
 {
         int ret;
-        struct ux500_wdt_data *pdata = pdev->dev.platform_data;
+        struct ux500_wdt_data *pdata = dev_get_platdata(&pdev->dev);
 
         if (pdata) {
                 if (pdata->timeout > 0)
@@ -167,5 +167,4 @@ module_platform_driver(ux500_wdt_driver);
 MODULE_AUTHOR("Jonas Aaberg <jonas.aberg@stericsson.com>");
 MODULE_DESCRIPTION("Ux500 Watchdog Driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform:ux500_wdt");
diff --git a/drivers/watchdog/w83627hf_wdt.c b/drivers/watchdog/w83627hf_wdt.c
index 92f1326f0cfc..e24b21082874 100644
--- a/drivers/watchdog/w83627hf_wdt.c
+++ b/drivers/watchdog/w83627hf_wdt.c
@@ -1,6 +1,9 @@
 /*
  *      w83627hf/thf WDT driver
  *
+ *      (c) Copyright 2013 Guenter Roeck
+ *              converted to watchdog infrastructure
+ *
  *      (c) Copyright 2007 Vlad Drukker <vlad@storewiz.com>
  *              added support for W83627THF.
  *
@@ -31,31 +34,22 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/types.h>
-#include <linux/miscdevice.h>
 #include <linux/watchdog.h>
-#include <linux/fs.h>
 #include <linux/ioport.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
-#include <linux/spinlock.h>
 #include <linux/io.h>
-#include <linux/uaccess.h>
-
 
 #define WATCHDOG_NAME "w83627hf/thf/hg/dhg WDT"
 #define WATCHDOG_TIMEOUT 60             /* 60 sec default timeout */
 
-static unsigned long wdt_is_open;
-static char expect_close;
-static DEFINE_SPINLOCK(io_lock);
-
 /* You must set this - there is no sane way to probe for this board. */
 static int wdt_io = 0x2E;
 module_param(wdt_io, int, 0);
 MODULE_PARM_DESC(wdt_io, "w83627hf/thf WDT io port (default 0x2E)");
 
-static int timeout = WATCHDOG_TIMEOUT;  /* in seconds */
+static int timeout;                     /* in seconds */
 module_param(timeout, int, 0);
 MODULE_PARM_DESC(timeout,
                 "Watchdog timeout in seconds. 1 <= timeout <= 255, default="
@@ -76,236 +70,147 @@ MODULE_PARM_DESC(nowayout,
                                                         (same as EFER) */
 #define WDT_EFDR (WDT_EFIR+1) /* Extended Function Data Register */
 
-static void w83627hf_select_wd_register(void)
+#define W83627HF_LD_WDT         0x08
+
+static void superio_outb(int reg, int val)
 {
-        unsigned char c;
+        outb(reg, WDT_EFER);
+        outb(val, WDT_EFDR);
+}
+
+static inline int superio_inb(int reg)
+{
+        outb(reg, WDT_EFER);
+        return inb(WDT_EFDR);
+}
+
+static int superio_enter(void)
+{
+        if (!request_muxed_region(wdt_io, 2, WATCHDOG_NAME))
+                return -EBUSY;
+
         outb_p(0x87, WDT_EFER); /* Enter extended function mode */
         outb_p(0x87, WDT_EFER); /* Again according to manual */
 
-        outb(0x20, WDT_EFER);   /* check chip version   */
-        c = inb(WDT_EFDR);
-        if (c == 0x82) {        /* W83627THF            */
-                outb_p(0x2b, WDT_EFER); /* select GPIO3 */
-                c = ((inb_p(WDT_EFDR) & 0xf7) | 0x04); /* select WDT0 */
-                outb_p(0x2b, WDT_EFER);
-                outb_p(c, WDT_EFDR);    /* set GPIO3 to WDT0 */
-        } else if (c == 0x88 || c == 0xa0) {    /* W83627EHF / W83627DHG */
-                outb_p(0x2d, WDT_EFER); /* select GPIO5 */
-                c = inb_p(WDT_EFDR) & ~0x01; /* PIN77 -> WDT0# */
-                outb_p(0x2d, WDT_EFER);
-                outb_p(c, WDT_EFDR); /* set GPIO5 to WDT0 */
-        }
+        return 0;
+}
 
-        outb_p(0x07, WDT_EFER); /* point to logical device number reg */
-        outb_p(0x08, WDT_EFDR); /* select logical device 8 (GPIO2) */
-        outb_p(0x30, WDT_EFER); /* select CR30 */
-        outb_p(0x01, WDT_EFDR); /* set bit 0 to activate GPIO2 */
+static void superio_select(int ld)
+{
+        superio_outb(0x07, ld);
 }
 
-static void w83627hf_unselect_wd_register(void)
+static void superio_exit(void)
 {
         outb_p(0xAA, WDT_EFER); /* Leave extended function mode */
+        release_region(wdt_io, 2);
 }
 
 /* tyan motherboards seem to set F5 to 0x4C ?
  * So explicitly init to appropriate value. */
 
-static void w83627hf_init(void)
+static int w83627hf_init(struct watchdog_device *wdog)
 {
+        int ret;
         unsigned char t;
 
-        w83627hf_select_wd_register();
+        ret = superio_enter();
+        if (ret)
+                return ret;
+
+        superio_select(W83627HF_LD_WDT);
+        t = superio_inb(0x20);  /* check chip version   */
+        if (t == 0x82) {        /* W83627THF            */
+                t = (superio_inb(0x2b) & 0xf7);
+                superio_outb(0x2b, t | 0x04); /* set GPIO3 to WDT0 */
+        } else if (t == 0x88 || t == 0xa0) {    /* W83627EHF / W83627DHG */
+                t = superio_inb(0x2d);
+                superio_outb(0x2d, t & ~0x01);  /* set GPIO5 to WDT0 */
+        }
+
+        /* set CR30 bit 0 to activate GPIO2 */
+        t = superio_inb(0x30);
+        if (!(t & 0x01))
+                superio_outb(0x30, t | 0x01);
 
-        outb_p(0xF6, WDT_EFER); /* Select CRF6 */
-        t = inb_p(WDT_EFDR);      /* read CRF6 */
+        t = superio_inb(0xF6);
         if (t != 0) {
                 pr_info("Watchdog already running. Resetting timeout to %d sec\n",
-                        timeout);
-                outb_p(timeout, WDT_EFDR);    /* Write back to CRF6 */
+                        wdog->timeout);
+                superio_outb(0xF6, wdog->timeout);
         }
 
-        outb_p(0xF5, WDT_EFER); /* Select CRF5 */
-        t = inb_p(WDT_EFDR);      /* read CRF5 */
-        t &= ~0x0C;               /* set second mode & disable keyboard
-                                    turning off watchdog */
-        t |= 0x02;                /* enable the WDTO# output low pulse
-                                    to the KBRST# pin (PIN60) */
-        outb_p(t, WDT_EFDR);    /* Write back to CRF5 */
-
-        outb_p(0xF7, WDT_EFER); /* Select CRF7 */
-        t = inb_p(WDT_EFDR);      /* read CRF7 */
-        t &= ~0xC0;               /* disable keyboard & mouse turning off
-                                    watchdog */
-        outb_p(t, WDT_EFDR);    /* Write back to CRF7 */
-
-        w83627hf_unselect_wd_register();
-}
-
-static void wdt_set_time(int timeout)
-{
-        spin_lock(&io_lock);
-
-        w83627hf_select_wd_register();
+        /* set second mode & disable keyboard turning off watchdog */
+        t = superio_inb(0xF5) & ~0x0C;
+        /* enable the WDTO# output low pulse to the KBRST# pin */
+        t |= 0x02;
+        superio_outb(0xF5, t);
 
-        outb_p(0xF6, WDT_EFER);    /* Select CRF6 */
-        outb_p(timeout, WDT_EFDR); /* Write Timeout counter to CRF6 */
+        /* disable keyboard & mouse turning off watchdog */
+        t = superio_inb(0xF7) & ~0xC0;
+        superio_outb(0xF7, t);
 
-        w83627hf_unselect_wd_register();
+        superio_exit();
 
-        spin_unlock(&io_lock);
-}
-
-static int wdt_ping(void)
-{
-        wdt_set_time(timeout);
         return 0;
 }
 
-static int wdt_disable(void)
+static int wdt_set_time(unsigned int timeout)
 {
-        wdt_set_time(0);
-        return 0;
-}
+        int ret;
+
+        ret = superio_enter();
+        if (ret)
+                return ret;
+
+        superio_select(W83627HF_LD_WDT);
+        superio_outb(0xF6, timeout);
+        superio_exit();
 
-static int wdt_set_heartbeat(int t)
-{
-        if (t < 1 || t > 255)
-                return -EINVAL;
-        timeout = t;
         return 0;
 }
 
-static int wdt_get_time(void)
+static int wdt_start(struct watchdog_device *wdog)
 {
-        int timeleft;
-
-        spin_lock(&io_lock);
-
-        w83627hf_select_wd_register();
-
-        outb_p(0xF6, WDT_EFER);    /* Select CRF6 */
-        timeleft = inb_p(WDT_EFDR); /* Read Timeout counter to CRF6 */
-
-        w83627hf_unselect_wd_register();
-
-        spin_unlock(&io_lock);
-
-        return timeleft;
+        return wdt_set_time(wdog->timeout);
 }
 
-static ssize_t wdt_write(struct file *file, const char __user *buf,
-                                                size_t count, loff_t *ppos)
+static int wdt_stop(struct watchdog_device *wdog)
 {
-        if (count) {
-                if (!nowayout) {
-                        size_t i;
-
-                        expect_close = 0;
-
-                        for (i = 0; i != count; i++) {
-                                char c;
-                                if (get_user(c, buf + i))
-                                        return -EFAULT;
-                                if (c == 'V')
-                                        expect_close = 42;
-                        }
-                }
-                wdt_ping();
-        }
-        return count;
+        return wdt_set_time(0);
 }
 
-static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+static int wdt_set_timeout(struct watchdog_device *wdog, unsigned int timeout)
 {
-        void __user *argp = (void __user *)arg;
-        int __user *p = argp;
-        int timeval;
-        static const struct watchdog_info ident = {
-                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
-                                                        WDIOF_MAGICCLOSE,
-                .firmware_version = 1,
-                .identity = "W83627HF WDT",
-        };
-
-        switch (cmd) {
-        case WDIOC_GETSUPPORT:
-                if (copy_to_user(argp, &ident, sizeof(ident)))
-                        return -EFAULT;
-                break;
-        case WDIOC_GETSTATUS:
-        case WDIOC_GETBOOTSTATUS:
-                return put_user(0, p);
-        case WDIOC_SETOPTIONS:
-        {
-                int options, retval = -EINVAL;
-
-                if (get_user(options, p))
-                        return -EFAULT;
-                if (options & WDIOS_DISABLECARD) {
-                        wdt_disable();
-                        retval = 0;
-                }
-                if (options & WDIOS_ENABLECARD) {
-                        wdt_ping();
-                        retval = 0;
-                }
-                return retval;
-        }
-        case WDIOC_KEEPALIVE:
-                wdt_ping();
-                break;
-        case WDIOC_SETTIMEOUT:
-                if (get_user(timeval, p))
-                        return -EFAULT;
-                if (wdt_set_heartbeat(timeval))
-                        return -EINVAL;
-                wdt_ping();
-                /* Fall */
-        case WDIOC_GETTIMEOUT:
-                return put_user(timeout, p);
-        case WDIOC_GETTIMELEFT:
-                timeval = wdt_get_time();
-                return put_user(timeval, p);
-        default:
-                return -ENOTTY;
-        }
+        wdog->timeout = timeout;
+
         return 0;
 }
 
-static int wdt_open(struct inode *inode, struct file *file)
+static unsigned int wdt_get_time(struct watchdog_device *wdog)
 {
-        if (test_and_set_bit(0, &wdt_is_open))
-                return -EBUSY;
-        /*
-         *      Activate
-         */
+        unsigned int timeleft;
+        int ret;
 
-        wdt_ping();
-        return nonseekable_open(inode, file);
-}
+        ret = superio_enter();
+        if (ret)
+                return 0;
 
-static int wdt_close(struct inode *inode, struct file *file)
-{
-        if (expect_close == 42)
-                wdt_disable();
-        else {
-                pr_crit("Unexpected close, not stopping watchdog!\n");
-                wdt_ping();
-        }
-        expect_close = 0;
-        clear_bit(0, &wdt_is_open);
-        return 0;
+        superio_select(W83627HF_LD_WDT);
+        timeleft = superio_inb(0xF6);
+        superio_exit();
+
+        return timeleft;
 }
 
 /*
  *      Notifier for system down
  */
-
 static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
         void *unused)
 {
         if (code == SYS_DOWN || code == SYS_HALT)
-                wdt_disable();  /* Turn the WDT off */
+                wdt_set_time(0);        /* Turn the WDT off */
 
         return NOTIFY_DONE;
 }
@@ -314,19 +219,25 @@ static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
  *      Kernel Interfaces
  */
 
-static const struct file_operations wdt_fops = {
-        .owner          = THIS_MODULE,
-        .llseek         = no_llseek,
-        .write          = wdt_write,
-        .unlocked_ioctl = wdt_ioctl,
-        .open           = wdt_open,
-        .release        = wdt_close,
+static struct watchdog_info wdt_info = {
+        .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
+        .identity = "W83627HF Watchdog",
 };
 
-static struct miscdevice wdt_miscdev = {
-        .minor = WATCHDOG_MINOR,
-        .name = "watchdog",
-        .fops = &wdt_fops,
+static struct watchdog_ops wdt_ops = {
+        .owner = THIS_MODULE,
+        .start = wdt_start,
+        .stop = wdt_stop,
+        .set_timeout = wdt_set_timeout,
+        .get_timeleft = wdt_get_time,
+};
+
+static struct watchdog_device wdt_dev = {
+        .info = &wdt_info,
+        .ops = &wdt_ops,
+        .timeout = WATCHDOG_TIMEOUT,
+        .min_timeout = 1,
+        .max_timeout = 255,
 };
 
 /*
@@ -344,50 +255,39 @@ static int __init wdt_init(void)
 
         pr_info("WDT driver for the Winbond(TM) W83627HF/THF/HG/DHG Super I/O chip initialising\n");
 
-        if (wdt_set_heartbeat(timeout)) {
-                wdt_set_heartbeat(WATCHDOG_TIMEOUT);
-                pr_info("timeout value must be 1 <= timeout <= 255, using %d\n",
-                        WATCHDOG_TIMEOUT);
-        }
+        watchdog_init_timeout(&wdt_dev, timeout, NULL);
+        watchdog_set_nowayout(&wdt_dev, nowayout);
 
-        if (!request_region(wdt_io, 1, WATCHDOG_NAME)) {
-                pr_err("I/O address 0x%04x already in use\n", wdt_io);
-                ret = -EIO;
-                goto out;
+        ret = w83627hf_init(&wdt_dev);
+        if (ret) {
+                pr_err("failed to initialize watchdog (err=%d)\n", ret);
+                return ret;
         }
 
-        w83627hf_init();
-
         ret = register_reboot_notifier(&wdt_notifier);
         if (ret != 0) {
                 pr_err("cannot register reboot notifier (err=%d)\n", ret);
-                goto unreg_regions;
+                return ret;
         }
 
-        ret = misc_register(&wdt_miscdev);
-        if (ret != 0) {
-                pr_err("cannot register miscdev on minor=%d (err=%d)\n",
-                       WATCHDOG_MINOR, ret);
+        ret = watchdog_register_device(&wdt_dev);
+        if (ret)
                 goto unreg_reboot;
-        }
 
         pr_info("initialized. timeout=%d sec (nowayout=%d)\n",
-                timeout, nowayout);
+                wdt_dev.timeout, nowayout);
 
-out:
         return ret;
+
 unreg_reboot:
         unregister_reboot_notifier(&wdt_notifier);
-unreg_regions:
-        release_region(wdt_io, 1);
-        goto out;
+        return ret;
 }
 
 static void __exit wdt_exit(void)
 {
-        misc_deregister(&wdt_miscdev);
+        watchdog_unregister_device(&wdt_dev);
         unregister_reboot_notifier(&wdt_notifier);
-        release_region(wdt_io, 1);
 }
 
 module_init(wdt_init);
@@ -396,4 +296,3 @@ module_exit(wdt_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Pádraig  Brady <P@draigBrady.com>");
 MODULE_DESCRIPTION("w83627hf/thf WDT driver");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/w83697hf_wdt.c b/drivers/watchdog/w83697hf_wdt.c
index cd9f3c1e1af4..aaf2995d37f4 100644
--- a/drivers/watchdog/w83697hf_wdt.c
+++ b/drivers/watchdog/w83697hf_wdt.c
@@ -458,4 +458,3 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Marcus Junker <junker@anduras.de>, "
                 "Samuel Tardieu <sam@rfc1149.net>");
 MODULE_DESCRIPTION("w83697hf/hg WDT driver");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/w83697ug_wdt.c b/drivers/watchdog/w83697ug_wdt.c
index 274be0bfaf24..ff58cb74671f 100644
--- a/drivers/watchdog/w83697ug_wdt.c
+++ b/drivers/watchdog/w83697ug_wdt.c
@@ -395,4 +395,3 @@ module_exit(wdt_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Flemming Frandsen <ff@nrvissing.net>");
 MODULE_DESCRIPTION("w83697ug/uf WDT driver");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/w83877f_wdt.c b/drivers/watchdog/w83877f_wdt.c
index 7874ae06232b..f0483c75ed32 100644
--- a/drivers/watchdog/w83877f_wdt.c
+++ b/drivers/watchdog/w83877f_wdt.c
@@ -406,4 +406,3 @@ module_exit(w83877f_wdt_unload);
 MODULE_AUTHOR("Scott and Bill Jennings");
 MODULE_DESCRIPTION("Driver for watchdog timer in w83877f chip");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/w83977f_wdt.c b/drivers/watchdog/w83977f_wdt.c
index 5d2c902825c2..91bf55a20024 100644
--- a/drivers/watchdog/w83977f_wdt.c
+++ b/drivers/watchdog/w83977f_wdt.c
@@ -527,4 +527,3 @@ module_exit(w83977f_wdt_exit);
 MODULE_AUTHOR("Jose Goncalves <jose.goncalves@inov.pt>");
 MODULE_DESCRIPTION("Driver for watchdog timer in W83977F I/O chip");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/wafer5823wdt.c b/drivers/watchdog/wafer5823wdt.c
index 25aba6e00a23..db0da7ea4fd8 100644
--- a/drivers/watchdog/wafer5823wdt.c
+++ b/drivers/watchdog/wafer5823wdt.c
@@ -322,6 +322,5 @@ module_exit(wafwdt_exit);
 MODULE_AUTHOR("Justin Cormack");
 MODULE_DESCRIPTION("ICP Wafer 5823 Single Board Computer WDT driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 /* end of wafer5823wdt.c */
diff --git a/drivers/watchdog/watchdog_core.c b/drivers/watchdog/watchdog_core.c
index 05d18b4c661b..461336c4519f 100644
--- a/drivers/watchdog/watchdog_core.c
+++ b/drivers/watchdog/watchdog_core.c
@@ -77,7 +77,7 @@ int watchdog_init_timeout(struct watchdog_device *wdd,
 
         watchdog_check_min_max_timeout(wdd);
 
-        /* try to get the tiemout module parameter first */
+        /* try to get the timeout module parameter first */
         if (!watchdog_timeout_invalid(wdd, timeout_parm)) {
                 wdd->timeout = timeout_parm;
                 return ret;
diff --git a/drivers/watchdog/wdrtas.c b/drivers/watchdog/wdrtas.c
index 3045debd5411..0240c60d14e3 100644
--- a/drivers/watchdog/wdrtas.c
+++ b/drivers/watchdog/wdrtas.c
@@ -48,8 +48,6 @@
 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>");
 MODULE_DESCRIPTION("RTAS watchdog driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-MODULE_ALIAS_MISCDEV(TEMP_MINOR);
 
 static bool wdrtas_nowayout = WATCHDOG_NOWAYOUT;
 static atomic_t wdrtas_miscdev_open = ATOMIC_INIT(0);
diff --git a/drivers/watchdog/wdt.c b/drivers/watchdog/wdt.c
index ee4333c01109..e0206b5b7d89 100644
--- a/drivers/watchdog/wdt.c
+++ b/drivers/watchdog/wdt.c
@@ -664,6 +664,4 @@ module_exit(wdt_exit);
 
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("Driver for ISA ICS watchdog cards (WDT500/501)");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-MODULE_ALIAS_MISCDEV(TEMP_MINOR);
 MODULE_LICENSE("GPL");
diff --git a/drivers/watchdog/wdt285.c b/drivers/watchdog/wdt285.c
index 5eec74053882..7355ddd0b207 100644
--- a/drivers/watchdog/wdt285.c
+++ b/drivers/watchdog/wdt285.c
@@ -224,7 +224,6 @@ static void __exit footbridge_watchdog_exit(void)
 MODULE_AUTHOR("Phil Blundell <pb@nexus.co.uk>");
 MODULE_DESCRIPTION("Footbridge watchdog driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 
 module_param(soft_margin, int, 0);
 MODULE_PARM_DESC(soft_margin, "Watchdog timeout in seconds");
diff --git a/drivers/watchdog/wdt977.c b/drivers/watchdog/wdt977.c
index 65a402344933..a8e6f87f60c9 100644
--- a/drivers/watchdog/wdt977.c
+++ b/drivers/watchdog/wdt977.c
@@ -507,4 +507,3 @@ module_exit(wd977_exit);
 MODULE_AUTHOR("Woody Suwalski <woodys@xandros.com>");
 MODULE_DESCRIPTION("W83977AF Watchdog driver");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/wdt_pci.c b/drivers/watchdog/wdt_pci.c
index 36a54c0e32dd..ee89ba4dea63 100644
--- a/drivers/watchdog/wdt_pci.c
+++ b/drivers/watchdog/wdt_pci.c
@@ -744,5 +744,3 @@ module_pci_driver(wdtpci_driver);
 MODULE_AUTHOR("JP Nollmann, Alan Cox");
 MODULE_DESCRIPTION("Driver for the ICS PCI-WDT500/501 watchdog cards");
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
-MODULE_ALIAS_MISCDEV(TEMP_MINOR);
diff --git a/drivers/watchdog/wm831x_wdt.c b/drivers/watchdog/wm831x_wdt.c
index d4e47eda4182..e243bd01c774 100644
--- a/drivers/watchdog/wm831x_wdt.c
+++ b/drivers/watchdog/wm831x_wdt.c
@@ -184,7 +184,7 @@ static const struct watchdog_ops wm831x_wdt_ops = {
 static int wm831x_wdt_probe(struct platform_device *pdev)
 {
         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
-        struct wm831x_pdata *chip_pdata;
+        struct wm831x_pdata *chip_pdata = dev_get_platdata(pdev->dev.parent);
         struct wm831x_watchdog_pdata *pdata;
         struct wm831x_wdt_drvdata *driver_data;
         struct watchdog_device *wm831x_wdt;
@@ -231,12 +231,10 @@ static int wm831x_wdt_probe(struct platform_device *pdev)
                 wm831x_wdt->timeout = wm831x_wdt_cfgs[i].time;
 
         /* Apply any configuration */
-        if (pdev->dev.parent->platform_data) {
-                chip_pdata = pdev->dev.parent->platform_data;
+        if (chip_pdata)
                 pdata = chip_pdata->watchdog;
-        } else {
+        else
                 pdata = NULL;
-        }
 
         if (pdata) {
                 reg &= ~(WM831X_WDOG_SECACT_MASK | WM831X_WDOG_PRIMACT_MASK |
diff --git a/drivers/watchdog/xen_wdt.c b/drivers/watchdog/xen_wdt.c
index 92ad33d0cb71..7a42dffd39e5 100644
--- a/drivers/watchdog/xen_wdt.c
+++ b/drivers/watchdog/xen_wdt.c
@@ -362,4 +362,3 @@ MODULE_AUTHOR("Jan Beulich <jbeulich@novell.com>");
 MODULE_DESCRIPTION("Xen WatchDog Timer Driver");
 MODULE_VERSION(DRV_VERSION);
 MODULE_LICENSE("GPL");
-MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);