Merge tag 'for-v3.18' of git://git.infradead.org/battery-2.6

Pull power supply and reset updates from Sebastian Reichel:
 - Initial support for the following chips
   * max77836 (charger)
   * max14577 (charger)
   * bq27742 (battery gauge)
   * ltc2952 (poweroff)
   * stih416 (restart)
   * syscon-reboot (restart)
   * gpio-restart (restart)
 - cleanup of power supply core
 - misc fixes in power supply and reset drivers

* tag 'for-v3.18' of git://git.infradead.org/battery-2.6: (48 commits)
  power: ab8500_fg: Fix build warning
  Documentation: charger: max14577: Update the date of introducing ABI
  power: reset: corrections for simple syscon reboot driver
  Documentation: power: reset: Add documentation for generic SYSCON reboot driver
  power: reset: Add generic SYSCON register mapped reset
  bq27x00_battery: Fix flag reading for bq27742
  power: reset: use restart_notifier mechanism for msm-poweroff
  power: Add simple gpio-restart driver
  power: reset: st: Provide DT bindings for ST's Power Reset driver
  power: reset: Add restart functionality for STiH41x platforms
  power: charger-manager: Fix NULL pointer exception with missing cm-fuel-gauge
  power: max14577: Fix circular config SYSFS dependency
  power: gpio-charger: do not use gpio value directly
  power: max8925: Use of_get_child_by_name
  power: max8925: Fix NULL ptr dereference on memory allocation failure
  bq27x00_battery: Add support to bq27742
  Documentation: charger: max14577: Document exported sysfs entry
  devicetree: mfd: max14577: Add device tree bindings document
  power: max17040: Add ID for MAX77836 Fuel Gauge block
  charger: max14577: Configure battery-dependent settings from DTS and sysfs
  ...

Conflicts:
	drivers/power/reset/Kconfig
	drivers/power/reset/Makefile

8 files changed, 827 insertions, 9 deletions

diff --git a/drivers/power/reset/Kconfig b/drivers/power/reset/Kconfig
index 527a0f47ef44..f65ff49bb275 100644
--- a/drivers/power/reset/Kconfig
+++ b/drivers/power/reset/Kconfig
@@ -40,7 +40,7 @@ config POWER_RESET_AXXIA
 
 config POWER_RESET_BRCMSTB
         bool "Broadcom STB reset driver" if COMPILE_TEST
-        depends on POWER_RESET && ARM
+        depends on ARM
         default ARCH_BRCMSTB
         help
           This driver provides restart support for ARM-based Broadcom STB
@@ -57,9 +57,17 @@ config POWER_RESET_GPIO
           If your board needs a GPIO high/low to power down, say Y and
           create a binding in your devicetree.
 
+config POWER_RESET_GPIO_RESTART
+        bool "GPIO restart driver"
+        depends on OF_GPIO
+        help
+          This driver supports restarting your board via a GPIO line.
+          If your board needs a GPIO high/low to restart, say Y and
+          create a binding in your devicetree.
+
 config POWER_RESET_HISI
         bool "Hisilicon power-off driver"
-        depends on POWER_RESET && ARCH_HISI
+        depends on ARCH_HISI
         help
           Reboot support for Hisilicon boards.
 
@@ -69,6 +77,13 @@ config POWER_RESET_MSM
         help
           Power off and restart support for Qualcomm boards.
 
+config POWER_RESET_LTC2952
+        bool "LTC2952 PowerPath power-off driver"
+        depends on OF_GPIO
+        help
+          This driver supports an external powerdown trigger and board power
+          down via the LTC2952. Bindings are made in the device tree.
+
 config POWER_RESET_QNAP
         bool "QNAP power-off driver"
         depends on OF_GPIO && PLAT_ORION
@@ -92,6 +107,12 @@ config POWER_RESET_SUN6I
         help
           Reboot support for the Allwinner A31 SoCs.
 
+config POWER_RESET_ST
+        bool "ST restart power-off driver"
+        depends on ARCH_STI
+        help
+          Power off and reset support for STMicroelectronics boards.
+
 config POWER_RESET_VERSATILE
         bool "ARM Versatile family reboot driver"
         depends on ARM
@@ -122,4 +143,12 @@ config POWER_RESET_KEYSTONE
         help
           Reboot support for the KEYSTONE SoCs.
 
+config POWER_RESET_SYSCON
+        bool "Generic SYSCON regmap reset driver"
+        depends on OF
+        select MFD_SYSCON
+        help
+          Reboot support for generic SYSCON mapped register reset.
+
 endif
+
diff --git a/drivers/power/reset/Makefile b/drivers/power/reset/Makefile
index 73221009f2bf..76ce1c59469b 100644
--- a/drivers/power/reset/Makefile
+++ b/drivers/power/reset/Makefile
@@ -4,12 +4,16 @@ obj-$(CONFIG_POWER_RESET_AT91_RESET) += at91-reset.o
 obj-$(CONFIG_POWER_RESET_AXXIA) += axxia-reset.o
 obj-$(CONFIG_POWER_RESET_BRCMSTB) += brcmstb-reboot.o
 obj-$(CONFIG_POWER_RESET_GPIO) += gpio-poweroff.o
+obj-$(CONFIG_POWER_RESET_GPIO_RESTART) += gpio-restart.o
 obj-$(CONFIG_POWER_RESET_HISI) += hisi-reboot.o
 obj-$(CONFIG_POWER_RESET_MSM) += msm-poweroff.o
+obj-$(CONFIG_POWER_RESET_LTC2952) += ltc2952-poweroff.o
 obj-$(CONFIG_POWER_RESET_QNAP) += qnap-poweroff.o
 obj-$(CONFIG_POWER_RESET_RESTART) += restart-poweroff.o
 obj-$(CONFIG_POWER_RESET_SUN6I) += sun6i-reboot.o
+obj-$(CONFIG_POWER_RESET_ST) += st-poweroff.o
 obj-$(CONFIG_POWER_RESET_VERSATILE) += arm-versatile-reboot.o
 obj-$(CONFIG_POWER_RESET_VEXPRESS) += vexpress-poweroff.o
 obj-$(CONFIG_POWER_RESET_XGENE) += xgene-reboot.o
 obj-$(CONFIG_POWER_RESET_KEYSTONE) += keystone-reset.o
+obj-$(CONFIG_POWER_RESET_SYSCON) += syscon-reboot.o
diff --git a/drivers/power/reset/gpio-restart.c b/drivers/power/reset/gpio-restart.c
new file mode 100644
index 000000000000..a76829b3f1cd
--- /dev/null
+++ b/drivers/power/reset/gpio-restart.c
@@ -0,0 +1,149 @@
+/*
+ * Toggles a GPIO pin to restart a device
+ *
+ * Copyright (C) 2014 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Based on the gpio-poweroff driver.
+ */
+#include <linux/reboot.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/gpio/consumer.h>
+#include <linux/of_platform.h>
+#include <linux/module.h>
+
+struct gpio_restart {
+        struct gpio_desc *reset_gpio;
+        struct notifier_block restart_handler;
+        u32 active_delay_ms;
+        u32 inactive_delay_ms;
+        u32 wait_delay_ms;
+};
+
+static int gpio_restart_notify(struct notifier_block *this,
+                                unsigned long mode, void *cmd)
+{
+        struct gpio_restart *gpio_restart =
+                container_of(this, struct gpio_restart, restart_handler);
+
+        /* drive it active, also inactive->active edge */
+        gpiod_direction_output(gpio_restart->reset_gpio, 1);
+        mdelay(gpio_restart->active_delay_ms);
+
+        /* drive inactive, also active->inactive edge */
+        gpiod_set_value(gpio_restart->reset_gpio, 0);
+        mdelay(gpio_restart->inactive_delay_ms);
+
+        /* drive it active, also inactive->active edge */
+        gpiod_set_value(gpio_restart->reset_gpio, 1);
+
+        /* give it some time */
+        mdelay(gpio_restart->wait_delay_ms);
+
+        WARN_ON(1);
+
+        return NOTIFY_DONE;
+}
+
+static int gpio_restart_probe(struct platform_device *pdev)
+{
+        struct gpio_restart *gpio_restart;
+        bool open_source = false;
+        u32 property;
+        int ret;
+
+        gpio_restart = devm_kzalloc(&pdev->dev, sizeof(*gpio_restart),
+                        GFP_KERNEL);
+        if (!gpio_restart)
+                return -ENOMEM;
+
+        open_source = of_property_read_bool(pdev->dev.of_node, "open-source");
+
+        gpio_restart->reset_gpio = devm_gpiod_get(&pdev->dev, NULL,
+                        open_source ? GPIOD_IN : GPIOD_OUT_LOW);
+        if (IS_ERR(gpio_restart->reset_gpio)) {
+                dev_err(&pdev->dev, "Could net get reset GPIO\n");
+                return PTR_ERR(gpio_restart->reset_gpio);
+        }
+
+        gpio_restart->restart_handler.notifier_call = gpio_restart_notify;
+        gpio_restart->restart_handler.priority = 128;
+        gpio_restart->active_delay_ms = 100;
+        gpio_restart->inactive_delay_ms = 100;
+        gpio_restart->wait_delay_ms = 3000;
+
+        ret = of_property_read_u32(pdev->dev.of_node, "priority", &property);
+        if (!ret) {
+                if (property > 255)
+                        dev_err(&pdev->dev, "Invalid priority property: %u\n",
+                                        property);
+                else
+                        gpio_restart->restart_handler.priority = property;
+        }
+
+        of_property_read_u32(pdev->dev.of_node, "active-delay",
+                        &gpio_restart->active_delay_ms);
+        of_property_read_u32(pdev->dev.of_node, "inactive-delay",
+                        &gpio_restart->inactive_delay_ms);
+        of_property_read_u32(pdev->dev.of_node, "wait-delay",
+                        &gpio_restart->wait_delay_ms);
+
+        platform_set_drvdata(pdev, gpio_restart);
+
+        ret = register_restart_handler(&gpio_restart->restart_handler);
+        if (ret) {
+                dev_err(&pdev->dev, "%s: cannot register restart handler, %d\n",
+                                __func__, ret);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int gpio_restart_remove(struct platform_device *pdev)
+{
+        struct gpio_restart *gpio_restart = platform_get_drvdata(pdev);
+        int ret;
+
+        ret = unregister_restart_handler(&gpio_restart->restart_handler);
+        if (ret) {
+                dev_err(&pdev->dev,
+                                "%s: cannot unregister restart handler, %d\n",
+                                __func__, ret);
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static const struct of_device_id of_gpio_restart_match[] = {
+        { .compatible = "gpio-restart", },
+        {},
+};
+
+static struct platform_driver gpio_restart_driver = {
+        .probe = gpio_restart_probe,
+        .remove = gpio_restart_remove,
+        .driver = {
+                .name = "restart-gpio",
+                .owner = THIS_MODULE,
+                .of_match_table = of_gpio_restart_match,
+        },
+};
+
+module_platform_driver(gpio_restart_driver);
+
+MODULE_AUTHOR("David Riley <davidriley@chromium.org>");
+MODULE_DESCRIPTION("GPIO restart driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/power/reset/ltc2952-poweroff.c b/drivers/power/reset/ltc2952-poweroff.c
new file mode 100644
index 000000000000..116a1cef8f7b
--- /dev/null
+++ b/drivers/power/reset/ltc2952-poweroff.c
@@ -0,0 +1,386 @@
+/*
+ * LTC2952 (PowerPath) driver
+ *
+ * Copyright (C) 2014, Xsens Technologies BV <info@xsens.com>
+ * Maintainer: René Moll <linux@r-moll.nl>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * ----------------------------------------
+ * - Description
+ * ----------------------------------------
+ *
+ * This driver is to be used with an external PowerPath Controller (LTC2952).
+ * Its function is to determine when a external shut down is triggered
+ * and react by properly shutting down the system.
+ *
+ * This driver expects a device tree with a ltc2952 entry for pin mapping.
+ *
+ * ----------------------------------------
+ * - GPIO
+ * ----------------------------------------
+ *
+ * The following GPIOs are used:
+ * - trigger (input)
+ *     A level change indicates the shut-down trigger. If it's state reverts
+ *     within the time-out defined by trigger_delay, the shut down is not
+ *     executed.
+ *
+ * - watchdog (output)
+ *     Once a shut down is triggered, the driver will toggle this signal,
+ *     with an internal (wde_interval) to stall the hardware shut down.
+ *
+ * - kill (output)
+ *     The last action during shut down is triggering this signalling, such
+ *     that the PowerPath Control will power down the hardware.
+ *
+ * ----------------------------------------
+ * - Interrupts
+ * ----------------------------------------
+ *
+ * The driver requires a non-shared, edge-triggered interrupt on the trigger
+ * GPIO.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/ktime.h>
+#include <linux/slab.h>
+#include <linux/kmod.h>
+#include <linux/module.h>
+#include <linux/gpio/consumer.h>
+#include <linux/reboot.h>
+
+struct ltc2952_poweroff_data {
+        struct hrtimer timer_trigger;
+        struct hrtimer timer_wde;
+
+        ktime_t trigger_delay;
+        ktime_t wde_interval;
+
+        struct device *dev;
+
+        unsigned int virq;
+
+        /**
+         * 0: trigger
+         * 1: watchdog
+         * 2: kill
+         */
+        struct gpio_desc *gpio[3];
+};
+
+static int ltc2952_poweroff_panic;
+static struct ltc2952_poweroff_data *ltc2952_data;
+
+#define POWERPATH_IO_TRIGGER    0
+#define POWERPATH_IO_WATCHDOG   1
+#define POWERPATH_IO_KILL       2
+
+/**
+ * ltc2952_poweroff_timer_wde - Timer callback
+ * Toggles the watchdog reset signal each wde_interval
+ *
+ * @timer: corresponding timer
+ *
+ * Returns HRTIMER_RESTART for an infinite loop which will only stop when the
+ * machine actually shuts down
+ */
+static enum hrtimer_restart ltc2952_poweroff_timer_wde(struct hrtimer *timer)
+{
+        ktime_t now;
+        int state;
+        unsigned long overruns;
+
+        if (ltc2952_poweroff_panic)
+                return HRTIMER_NORESTART;
+
+        state = gpiod_get_value(ltc2952_data->gpio[POWERPATH_IO_WATCHDOG]);
+        gpiod_set_value(ltc2952_data->gpio[POWERPATH_IO_WATCHDOG], !state);
+
+        now = hrtimer_cb_get_time(timer);
+        overruns = hrtimer_forward(timer, now, ltc2952_data->wde_interval);
+
+        return HRTIMER_RESTART;
+}
+
+static enum hrtimer_restart ltc2952_poweroff_timer_trigger(
+        struct hrtimer *timer)
+{
+        int ret;
+
+        ret = hrtimer_start(&ltc2952_data->timer_wde,
+                ltc2952_data->wde_interval, HRTIMER_MODE_REL);
+
+        if (ret) {
+                dev_err(ltc2952_data->dev, "unable to start the timer\n");
+                /*
+                 * The device will not toggle the watchdog reset,
+                 * thus shut down is only safe if the PowerPath controller
+                 * has a long enough time-off before triggering a hardware
+                 * power-off.
+                 *
+                 * Only sending a warning as the system will power-off anyway
+                 */
+        }
+
+        dev_info(ltc2952_data->dev, "executing shutdown\n");
+
+        orderly_poweroff(true);
+
+        return HRTIMER_NORESTART;
+}
+
+/**
+ * ltc2952_poweroff_handler - Interrupt handler
+ * Triggered each time the trigger signal changes state and (de)activates a
+ * time-out (timer_trigger). Once the time-out is actually reached the shut
+ * down is executed.
+ *
+ * @irq: IRQ number
+ * @dev_id: pointer to the main data structure
+ */
+static irqreturn_t ltc2952_poweroff_handler(int irq, void *dev_id)
+{
+        int ret;
+        struct ltc2952_poweroff_data *data = dev_id;
+
+        if (ltc2952_poweroff_panic)
+                goto irq_ok;
+
+        if (hrtimer_active(&data->timer_wde)) {
+                /* shutdown is already triggered, nothing to do any more */
+                goto irq_ok;
+        }
+
+        if (!hrtimer_active(&data->timer_trigger)) {
+                ret = hrtimer_start(&data->timer_trigger, data->trigger_delay,
+                        HRTIMER_MODE_REL);
+
+                if (ret)
+                        dev_err(data->dev, "unable to start the wait timer\n");
+        } else {
+                ret = hrtimer_cancel(&data->timer_trigger);
+                /* omitting return value check, timer should have been valid */
+        }
+
+irq_ok:
+        return IRQ_HANDLED;
+}
+
+static void ltc2952_poweroff_kill(void)
+{
+        gpiod_set_value(ltc2952_data->gpio[POWERPATH_IO_KILL], 1);
+}
+
+static int ltc2952_poweroff_suspend(struct platform_device *pdev,
+        pm_message_t state)
+{
+        return -ENOSYS;
+}
+
+static int ltc2952_poweroff_resume(struct platform_device *pdev)
+{
+        return -ENOSYS;
+}
+
+static void ltc2952_poweroff_default(struct ltc2952_poweroff_data *data)
+{
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(data->gpio); i++)
+                data->gpio[i] = NULL;
+
+        data->wde_interval = ktime_set(0, 300L*1E6L);
+        data->trigger_delay = ktime_set(2, 500L*1E6L);
+
+        hrtimer_init(&data->timer_trigger, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+        data->timer_trigger.function = &ltc2952_poweroff_timer_trigger;
+
+        hrtimer_init(&data->timer_wde, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+        data->timer_wde.function = &ltc2952_poweroff_timer_wde;
+}
+
+static int ltc2952_poweroff_init(struct platform_device *pdev)
+{
+        int ret, virq;
+        unsigned int i;
+        struct ltc2952_poweroff_data *data;
+
+        static char *name[] = {
+                "trigger",
+                "watchdog",
+                "kill",
+                NULL
+        };
+
+        data = ltc2952_data;
+        ltc2952_poweroff_default(ltc2952_data);
+
+        for (i = 0; i < ARRAY_SIZE(ltc2952_data->gpio); i++) {
+                ltc2952_data->gpio[i] = gpiod_get(&pdev->dev, name[i]);
+
+                if (IS_ERR(ltc2952_data->gpio[i])) {
+                        ret = PTR_ERR(ltc2952_data->gpio[i]);
+                        dev_err(&pdev->dev,
+                                "unable to claim the following gpio: %s\n",
+                                name[i]);
+                        goto err_io;
+                }
+        }
+
+        ret = gpiod_direction_output(
+                ltc2952_data->gpio[POWERPATH_IO_WATCHDOG], 0);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to use watchdog-gpio as output\n");
+                goto err_io;
+        }
+
+        ret = gpiod_direction_output(ltc2952_data->gpio[POWERPATH_IO_KILL], 0);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to use kill-gpio as output\n");
+                goto err_io;
+        }
+
+        virq = gpiod_to_irq(ltc2952_data->gpio[POWERPATH_IO_TRIGGER]);
+        if (virq < 0) {
+                dev_err(&pdev->dev, "cannot map GPIO as interrupt");
+                goto err_io;
+        }
+
+        ltc2952_data->virq = virq;
+        ret = request_irq(virq,
+                ltc2952_poweroff_handler,
+                (IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING),
+                "ltc2952-poweroff",
+                ltc2952_data
+        );
+
+        if (ret) {
+                dev_err(&pdev->dev, "cannot configure an interrupt handler\n");
+                goto err_io;
+        }
+
+        return 0;
+
+err_io:
+        for (i = 0; i < ARRAY_SIZE(ltc2952_data->gpio); i++)
+                if (ltc2952_data->gpio[i])
+                        gpiod_put(ltc2952_data->gpio[i]);
+
+        return ret;
+}
+
+static int ltc2952_poweroff_probe(struct platform_device *pdev)
+{
+        int ret;
+
+        if (pm_power_off) {
+                dev_err(&pdev->dev, "pm_power_off already registered");
+                return -EBUSY;
+        }
+
+        ltc2952_data = kzalloc(sizeof(*ltc2952_data), GFP_KERNEL);
+        if (!ltc2952_data)
+                return -ENOMEM;
+
+        ltc2952_data->dev = &pdev->dev;
+
+        ret = ltc2952_poweroff_init(pdev);
+        if (ret)
+                goto err;
+
+        pm_power_off = &ltc2952_poweroff_kill;
+
+        dev_info(&pdev->dev, "probe successful\n");
+
+        return 0;
+
+err:
+        kfree(ltc2952_data);
+        return ret;
+}
+
+static int ltc2952_poweroff_remove(struct platform_device *pdev)
+{
+        unsigned int i;
+
+        pm_power_off = NULL;
+
+        if (ltc2952_data) {
+                free_irq(ltc2952_data->virq, ltc2952_data);
+
+                for (i = 0; i < ARRAY_SIZE(ltc2952_data->gpio); i++)
+                        gpiod_put(ltc2952_data->gpio[i]);
+
+                kfree(ltc2952_data);
+        }
+
+        return 0;
+}
+
+static const struct of_device_id of_ltc2952_poweroff_match[] = {
+        { .compatible = "lltc,ltc2952"},
+        {},
+};
+MODULE_DEVICE_TABLE(of, of_ltc2952_poweroff_match);
+
+static struct platform_driver ltc2952_poweroff_driver = {
+        .probe = ltc2952_poweroff_probe,
+        .remove = ltc2952_poweroff_remove,
+        .driver = {
+                .name = "ltc2952-poweroff",
+                .owner = THIS_MODULE,
+                .of_match_table = of_ltc2952_poweroff_match,
+        },
+        .suspend = ltc2952_poweroff_suspend,
+        .resume = ltc2952_poweroff_resume,
+};
+
+static int ltc2952_poweroff_notify_panic(struct notifier_block *nb,
+        unsigned long code, void *unused)
+{
+        ltc2952_poweroff_panic = 1;
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block ltc2952_poweroff_panic_nb = {
+        .notifier_call = ltc2952_poweroff_notify_panic,
+};
+
+static int __init ltc2952_poweroff_platform_init(void)
+{
+        ltc2952_poweroff_panic = 0;
+
+        atomic_notifier_chain_register(&panic_notifier_list,
+                &ltc2952_poweroff_panic_nb);
+
+        return platform_driver_register(&ltc2952_poweroff_driver);
+}
+
+static void __exit ltc2952_poweroff_platform_exit(void)
+{
+        atomic_notifier_chain_unregister(&panic_notifier_list,
+                &ltc2952_poweroff_panic_nb);
+
+        platform_driver_unregister(&ltc2952_poweroff_driver);
+}
+
+module_init(ltc2952_poweroff_platform_init);
+module_exit(ltc2952_poweroff_platform_exit);
+
+MODULE_AUTHOR("René Moll <rene.moll@xsens.com>");
+MODULE_DESCRIPTION("LTC PowerPath power-off driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/power/reset/msm-poweroff.c b/drivers/power/reset/msm-poweroff.c
index 774f9a3b310d..4702efdfe466 100644
--- a/drivers/power/reset/msm-poweroff.c
+++ b/drivers/power/reset/msm-poweroff.c
@@ -20,21 +20,27 @@
 #include <linux/platform_device.h>
 #include <linux/module.h>
 #include <linux/reboot.h>
-
-#include <asm/system_misc.h>
+#include <linux/pm.h>
 
 static void __iomem *msm_ps_hold;
-
-static void do_msm_restart(enum reboot_mode reboot_mode, const char *cmd)
+static int do_msm_restart(struct notifier_block *nb, unsigned long action,
+                           void *data)
 {
         writel(0, msm_ps_hold);
         mdelay(10000);
+
+        return NOTIFY_DONE;
 }
 
+static struct notifier_block restart_nb = {
+        .notifier_call = do_msm_restart,
+        .priority = 128,
+};
+
 static void do_msm_poweroff(void)
 {
         /* TODO: Add poweroff capability */
-        do_msm_restart(REBOOT_HARD, NULL);
+        do_msm_restart(&restart_nb, 0, NULL);
 }
 
 static int msm_restart_probe(struct platform_device *pdev)
@@ -47,8 +53,10 @@ static int msm_restart_probe(struct platform_device *pdev)
         if (IS_ERR(msm_ps_hold))
                 return PTR_ERR(msm_ps_hold);
 
+        register_restart_handler(&restart_nb);
+
         pm_power_off = do_msm_poweroff;
-        arm_pm_restart = do_msm_restart;
+
         return 0;
 }
 
diff --git a/drivers/power/reset/st-poweroff.c b/drivers/power/reset/st-poweroff.c
new file mode 100644
index 000000000000..a0acf25ee2a2
--- /dev/null
+++ b/drivers/power/reset/st-poweroff.c
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2014 STMicroelectronics
+ *
+ * Power off Restart driver, used in STMicroelectronics devices.
+ *
+ * Author: Christophe Kerello <christophe.kerello@st.com>
+ *
+ * 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/module.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/syscon.h>
+#include <linux/regmap.h>
+
+#include <asm/system_misc.h>
+
+struct reset_syscfg {
+        struct regmap *regmap;
+        /* syscfg used for reset */
+        unsigned int offset_rst;
+        unsigned int mask_rst;
+        /* syscfg used for unmask the reset */
+        unsigned int offset_rst_msk;
+        unsigned int mask_rst_msk;
+};
+
+/* STiH415 */
+#define STIH415_SYSCFG_11       0x2c
+#define STIH415_SYSCFG_15       0x3c
+
+static struct reset_syscfg stih415_reset = {
+        .offset_rst = STIH415_SYSCFG_11,
+        .mask_rst = BIT(0),
+        .offset_rst_msk = STIH415_SYSCFG_15,
+        .mask_rst_msk = BIT(0)
+};
+
+/* STiH416 */
+#define STIH416_SYSCFG_500      0x7d0
+#define STIH416_SYSCFG_504      0x7e0
+
+static struct reset_syscfg stih416_reset = {
+        .offset_rst = STIH416_SYSCFG_500,
+        .mask_rst = BIT(0),
+        .offset_rst_msk = STIH416_SYSCFG_504,
+        .mask_rst_msk = BIT(0)
+};
+
+/* STiH407 */
+#define STIH407_SYSCFG_4000     0x0
+#define STIH407_SYSCFG_4008     0x20
+
+static struct reset_syscfg stih407_reset = {
+        .offset_rst = STIH407_SYSCFG_4000,
+        .mask_rst = BIT(0),
+        .offset_rst_msk = STIH407_SYSCFG_4008,
+        .mask_rst_msk = BIT(0)
+};
+
+/* STiD127 */
+#define STID127_SYSCFG_700      0x0
+#define STID127_SYSCFG_773      0x124
+
+static struct reset_syscfg stid127_reset = {
+        .offset_rst = STID127_SYSCFG_773,
+        .mask_rst = BIT(0),
+        .offset_rst_msk = STID127_SYSCFG_700,
+        .mask_rst_msk = BIT(8)
+};
+
+static struct reset_syscfg *st_restart_syscfg;
+
+static void st_restart(enum reboot_mode reboot_mode, const char *cmd)
+{
+        /* reset syscfg updated */
+        regmap_update_bits(st_restart_syscfg->regmap,
+                           st_restart_syscfg->offset_rst,
+                           st_restart_syscfg->mask_rst,
+                           0);
+
+        /* unmask the reset */
+        regmap_update_bits(st_restart_syscfg->regmap,
+                           st_restart_syscfg->offset_rst_msk,
+                           st_restart_syscfg->mask_rst_msk,
+                           0);
+}
+
+static struct of_device_id st_reset_of_match[] = {
+        {
+                .compatible = "st,stih415-restart",
+                .data = (void *)&stih415_reset,
+        }, {
+                .compatible = "st,stih416-restart",
+                .data = (void *)&stih416_reset,
+        }, {
+                .compatible = "st,stih407-restart",
+                .data = (void *)&stih407_reset,
+        }, {
+                .compatible = "st,stid127-restart",
+                .data = (void *)&stid127_reset,
+        },
+        {}
+};
+
+static int st_reset_probe(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        const struct of_device_id *match;
+        struct device *dev = &pdev->dev;
+
+        match = of_match_device(st_reset_of_match, dev);
+        if (!match)
+                return -ENODEV;
+
+        st_restart_syscfg = (struct reset_syscfg *)match->data;
+
+        st_restart_syscfg->regmap =
+                syscon_regmap_lookup_by_phandle(np, "st,syscfg");
+        if (IS_ERR(st_restart_syscfg->regmap)) {
+                dev_err(dev, "No syscfg phandle specified\n");
+                return PTR_ERR(st_restart_syscfg->regmap);
+        }
+
+        arm_pm_restart = st_restart;
+
+        return 0;
+}
+
+static struct platform_driver st_reset_driver = {
+        .probe = st_reset_probe,
+        .driver = {
+                .name = "st_reset",
+                .of_match_table = st_reset_of_match,
+        },
+};
+
+static int __init st_reset_init(void)
+{
+        return platform_driver_register(&st_reset_driver);
+}
+
+device_initcall(st_reset_init);
+
+MODULE_AUTHOR("Christophe Kerello <christophe.kerello@st.com>");
+MODULE_DESCRIPTION("STMicroelectronics Power off Restart driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/power/reset/syscon-reboot.c b/drivers/power/reset/syscon-reboot.c
new file mode 100644
index 000000000000..815b901822cf
--- /dev/null
+++ b/drivers/power/reset/syscon-reboot.c
@@ -0,0 +1,91 @@
+/*
+ * Generic Syscon Reboot Driver
+ *
+ * Copyright (c) 2013, Applied Micro Circuits Corporation
+ * Author: Feng Kan <fkan@apm.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/notifier.h>
+#include <linux/mfd/syscon.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/reboot.h>
+#include <linux/regmap.h>
+
+struct syscon_reboot_context {
+        struct regmap *map;
+        u32 offset;
+        u32 mask;
+        struct notifier_block restart_handler;
+};
+
+static int syscon_restart_handle(struct notifier_block *this,
+                                        unsigned long mode, void *cmd)
+{
+        struct syscon_reboot_context *ctx =
+                        container_of(this, struct syscon_reboot_context,
+                                        restart_handler);
+
+        /* Issue the reboot */
+        regmap_write(ctx->map, ctx->offset, ctx->mask);
+
+        mdelay(1000);
+
+        pr_emerg("Unable to restart system\n");
+        return NOTIFY_DONE;
+}
+
+static int syscon_reboot_probe(struct platform_device *pdev)
+{
+        struct syscon_reboot_context *ctx;
+        struct device *dev = &pdev->dev;
+        int err;
+
+        ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
+        if (!ctx)
+                return -ENOMEM;
+
+        ctx->map = syscon_regmap_lookup_by_phandle(dev->of_node, "regmap");
+        if (IS_ERR(ctx->map))
+                return PTR_ERR(ctx->map);
+
+        if (of_property_read_u32(pdev->dev.of_node, "offset", &ctx->offset))
+                return -EINVAL;
+
+        if (of_property_read_u32(pdev->dev.of_node, "mask", &ctx->mask))
+                return -EINVAL;
+
+        ctx->restart_handler.notifier_call = syscon_restart_handle;
+        ctx->restart_handler.priority = 128;
+        err = register_restart_handler(&ctx->restart_handler);
+        if (err)
+                dev_err(dev, "can't register restart notifier (err=%d)\n", err);
+
+        return err;
+}
+
+static struct of_device_id syscon_reboot_of_match[] = {
+        { .compatible = "syscon-reboot" },
+        {}
+};
+
+static struct platform_driver syscon_reboot_driver = {
+        .probe = syscon_reboot_probe,
+        .driver = {
+                .name = "syscon-reboot",
+                .of_match_table = syscon_reboot_of_match,
+        },
+};
+module_platform_driver(syscon_reboot_driver);
diff --git a/drivers/power/reset/xgene-reboot.c b/drivers/power/reset/xgene-reboot.c
index ecd55f81b9d1..6b49be6867ab 100644
--- a/drivers/power/reset/xgene-reboot.c
+++ b/drivers/power/reset/xgene-reboot.c
@@ -40,7 +40,7 @@ struct xgene_reboot_context {
 
 static struct xgene_reboot_context *xgene_restart_ctx;
 
-static void xgene_restart(char str, const char *cmd)
+static void xgene_restart(enum reboot_mode mode, const char *cmd)
 {
         struct xgene_reboot_context *ctx = xgene_restart_ctx;
         unsigned long timeout;