Merge tag 'restart-handler-for-v3.18' of git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging

Pull restart handler infrastructure from Guenter Roeck:
 "This series was supposed to be pulled through various trees using it,
  and I did not plan to send a separate pull request.  As it turns out,
  the pinctrl tree did not merge with it, is now upstream, and uses it,
  meaning there are now build failures.

  Please pull this series directly to fix those build failures"

* tag 'restart-handler-for-v3.18' of git://git.kernel.org/pub/scm/linux/kernel/git/groeck/linux-staging:
  arm/arm64: unexport restart handlers
  watchdog: sunxi: register restart handler with kernel restart handler
  watchdog: alim7101: register restart handler with kernel restart handler
  watchdog: moxart: register restart handler with kernel restart handler
  arm: support restart through restart handler call chain
  arm64: support restart through restart handler call chain
  power/restart: call machine_restart instead of arm_pm_restart
  kernel: add support for kernel restart handler call chain

3 files changed, 72 insertions, 33 deletions

diff --git a/drivers/watchdog/alim7101_wdt.c b/drivers/watchdog/alim7101_wdt.c
index 996b2f7d330e..665e0e7dfe1e 100644
--- a/drivers/watchdog/alim7101_wdt.c
+++ b/drivers/watchdog/alim7101_wdt.c
@@ -301,6 +301,28 @@ static struct miscdevice wdt_miscdev = {
         .fops   =       &wdt_fops,
 };
 
+static int wdt_restart_handle(struct notifier_block *this, unsigned long mode,
+                              void *cmd)
+{
+        /*
+         * Cobalt devices have no way of rebooting themselves other
+         * than getting the watchdog to pull reset, so we restart the
+         * watchdog on reboot with no heartbeat.
+         */
+        wdt_change(WDT_ENABLE);
+
+        /* loop until the watchdog fires */
+        while (true)
+                ;
+
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block wdt_restart_handler = {
+        .notifier_call = wdt_restart_handle,
+        .priority = 128,
+};
+
 /*
  *      Notifier for system down
  */
@@ -311,15 +333,6 @@ static int wdt_notify_sys(struct notifier_block *this,
         if (code == SYS_DOWN || code == SYS_HALT)
                 wdt_turnoff();
 
-        if (code == SYS_RESTART) {
-                /*
-                 * Cobalt devices have no way of rebooting themselves other
-                 * than getting the watchdog to pull reset, so we restart the
-                 * watchdog on reboot with no heartbeat
-                 */
-                wdt_change(WDT_ENABLE);
-                pr_info("Watchdog timer is now enabled with no heartbeat - should reboot in ~1 second\n");
-        }
         return NOTIFY_DONE;
 }
 
@@ -338,6 +351,7 @@ static void __exit alim7101_wdt_unload(void)
         /* Deregister */
         misc_deregister(&wdt_miscdev);
         unregister_reboot_notifier(&wdt_notifier);
+        unregister_restart_handler(&wdt_restart_handler);
         pci_dev_put(alim7101_pmu);
 }
 
@@ -390,11 +404,17 @@ static int __init alim7101_wdt_init(void)
                 goto err_out;
         }
 
+        rc = register_restart_handler(&wdt_restart_handler);
+        if (rc) {
+                pr_err("cannot register restart handler (err=%d)\n", rc);
+                goto err_out_reboot;
+        }
+
         rc = misc_register(&wdt_miscdev);
         if (rc) {
                 pr_err("cannot register miscdev on minor=%d (err=%d)\n",
                        wdt_miscdev.minor, rc);
-                goto err_out_reboot;
+                goto err_out_restart;
         }
 
         if (nowayout)
@@ -404,6 +424,8 @@ static int __init alim7101_wdt_init(void)
                 timeout, nowayout);
         return 0;
 
+err_out_restart:
+        unregister_restart_handler(&wdt_restart_handler);
 err_out_reboot:
         unregister_reboot_notifier(&wdt_notifier);
 err_out:
diff --git a/drivers/watchdog/moxart_wdt.c b/drivers/watchdog/moxart_wdt.c
index 4aa3a8a876fe..a64405b82596 100644
--- a/drivers/watchdog/moxart_wdt.c
+++ b/drivers/watchdog/moxart_wdt.c
@@ -15,12 +15,12 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/kernel.h>
+#include <linux/notifier.h>
 #include <linux/platform_device.h>
+#include <linux/reboot.h>
 #include <linux/watchdog.h>
 #include <linux/moduleparam.h>
 
-#include <asm/system_misc.h>
-
 #define REG_COUNT                       0x4
 #define REG_MODE                        0x8
 #define REG_ENABLE                      0xC
@@ -29,17 +29,22 @@ struct moxart_wdt_dev {
         struct watchdog_device dev;
         void __iomem *base;
         unsigned int clock_frequency;
+        struct notifier_block restart_handler;
 };
 
-static struct moxart_wdt_dev *moxart_restart_ctx;
-
 static int heartbeat;
 
-static void moxart_wdt_restart(enum reboot_mode reboot_mode, const char *cmd)
+static int moxart_restart_handle(struct notifier_block *this,
+                                 unsigned long mode, void *cmd)
 {
-        writel(1, moxart_restart_ctx->base + REG_COUNT);
-        writel(0x5ab9, moxart_restart_ctx->base + REG_MODE);
-        writel(0x03, moxart_restart_ctx->base + REG_ENABLE);
+        struct moxart_wdt_dev *moxart_wdt = container_of(this,
+                                                         struct moxart_wdt_dev,
+                                                         restart_handler);
+        writel(1, moxart_wdt->base + REG_COUNT);
+        writel(0x5ab9, moxart_wdt->base + REG_MODE);
+        writel(0x03, moxart_wdt->base + REG_ENABLE);
+
+        return NOTIFY_DONE;
 }
 
 static int moxart_wdt_stop(struct watchdog_device *wdt_dev)
@@ -136,8 +141,12 @@ static int moxart_wdt_probe(struct platform_device *pdev)
         if (err)
                 return err;
 
-        moxart_restart_ctx = moxart_wdt;
-        arm_pm_restart = moxart_wdt_restart;
+        moxart_wdt->restart_handler.notifier_call = moxart_restart_handle;
+        moxart_wdt->restart_handler.priority = 128;
+        err = register_restart_handler(&moxart_wdt->restart_handler);
+        if (err)
+                dev_err(dev, "cannot register restart notifier (err=%d)\n",
+                        err);
 
         dev_dbg(dev, "Watchdog enabled (heartbeat=%d sec, nowayout=%d)\n",
                 moxart_wdt->dev.timeout, nowayout);
@@ -149,9 +158,8 @@ static int moxart_wdt_remove(struct platform_device *pdev)
 {
         struct moxart_wdt_dev *moxart_wdt = platform_get_drvdata(pdev);
 
-        arm_pm_restart = NULL;
+        unregister_restart_handler(&moxart_wdt->restart_handler);
         moxart_wdt_stop(&moxart_wdt->dev);
-        watchdog_unregister_device(&moxart_wdt->dev);
 
         return 0;
 }
diff --git a/drivers/watchdog/sunxi_wdt.c b/drivers/watchdog/sunxi_wdt.c
index 60deb9d304c0..480bb557f353 100644
--- a/drivers/watchdog/sunxi_wdt.c
+++ b/drivers/watchdog/sunxi_wdt.c
@@ -21,14 +21,13 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/notifier.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/reboot.h>
 #include <linux/types.h>
 #include <linux/watchdog.h>
 
-#include <asm/system_misc.h>
-
 #define WDT_MAX_TIMEOUT         16
 #define WDT_MIN_TIMEOUT         1
 #define WDT_MODE_TIMEOUT(n)     ((n) << 3)
@@ -50,6 +49,7 @@ static unsigned int timeout = WDT_MAX_TIMEOUT;
 struct sunxi_wdt_dev {
         struct watchdog_device wdt_dev;
         void __iomem *wdt_base;
+        struct notifier_block restart_handler;
 };
 
 /*
@@ -74,24 +74,29 @@ static const int wdt_timeout_map[] = {
         [16] = 0xB, /* 16s */
 };
 
-static void __iomem *reboot_wdt_base;
 
-static void sun4i_wdt_restart(enum reboot_mode mode, const char *cmd)
+static int sunxi_restart_handle(struct notifier_block *this, unsigned long mode,
+                                void *cmd)
 {
+        struct sunxi_wdt_dev *sunxi_wdt = container_of(this,
+                                                       struct sunxi_wdt_dev,
+                                                       restart_handler);
+        void __iomem *wdt_base = sunxi_wdt->wdt_base;
+
         /* Enable timer and set reset bit in the watchdog */
-        writel(WDT_MODE_EN | WDT_MODE_RST_EN, reboot_wdt_base + WDT_MODE);
+        writel(WDT_MODE_EN | WDT_MODE_RST_EN, wdt_base + WDT_MODE);
 
         /*
          * Restart the watchdog. The default (and lowest) interval
          * value for the watchdog is 0.5s.
          */
-        writel(WDT_CTRL_RELOAD, reboot_wdt_base + WDT_CTRL);
+        writel(WDT_CTRL_RELOAD, wdt_base + WDT_CTRL);
 
         while (1) {
                 mdelay(5);
-                writel(WDT_MODE_EN | WDT_MODE_RST_EN,
-                       reboot_wdt_base + WDT_MODE);
+                writel(WDT_MODE_EN | WDT_MODE_RST_EN, wdt_base + WDT_MODE);
         }
+        return NOTIFY_DONE;
 }
 
 static int sunxi_wdt_ping(struct watchdog_device *wdt_dev)
@@ -205,8 +210,12 @@ static int sunxi_wdt_probe(struct platform_device *pdev)
         if (unlikely(err))
                 return err;
 
-        reboot_wdt_base = sunxi_wdt->wdt_base;
-        arm_pm_restart = sun4i_wdt_restart;
+        sunxi_wdt->restart_handler.notifier_call = sunxi_restart_handle;
+        sunxi_wdt->restart_handler.priority = 128;
+        err = register_restart_handler(&sunxi_wdt->restart_handler);
+        if (err)
+                dev_err(&pdev->dev,
+                        "cannot register restart handler (err=%d)\n", err);
 
         dev_info(&pdev->dev, "Watchdog enabled (timeout=%d sec, nowayout=%d)",
                         sunxi_wdt->wdt_dev.timeout, nowayout);
@@ -218,7 +227,7 @@ static int sunxi_wdt_remove(struct platform_device *pdev)
 {
         struct sunxi_wdt_dev *sunxi_wdt = platform_get_drvdata(pdev);
 
-        arm_pm_restart = NULL;
+        unregister_restart_handler(&sunxi_wdt->restart_handler);
 
         watchdog_unregister_device(&sunxi_wdt->wdt_dev);
         watchdog_set_drvdata(&sunxi_wdt->wdt_dev, NULL);