Immutable branch with restart handler patches for v3.18
-----BEGIN PGP SIGNATURE----- Version: GnuPG v1 iQIcBAABAgAGBQJUJQ8/AAoJEMsfJm/On5mBMNgP+QEUHpRKJaOGU3jX/ftHH/t3 EoNUx7lZt6Q0c9MB2ySAxILYpWUujc9N0tDkRDyW7mTWunF8gEGiRN+iKaSbzcUN Y4VffRAbxBasIaBqRtpDl08ycODh6Xu1t8sAao03DdhnMNLGNNO79s3UFHsubdTC cXx9mfYR/2SHV/0BXiFvKi8ovdqUspdp9cyZO/qc0PVFGbsADx3MNGGzkvWfgvcE 6vXnKnUkZrNl5JPiG77kTKZnDsjEMXggmA9DGWKijFCJjGIbuLiuIDf63Zp+eQ52 mJMRA+ViP/dDgAxY1dkWBcF5nOBT1vTYwLfy69jEoQeHzcomiHVoDKmCSBOpeAEH G8VoasWKWYpYnlcOJb+XgkA3QTe6mOPgAPzNsbYr0Ep7hMFw66mOQgKbgi6k4Qts HHimG9pnBYpPlBUfvNh+6K4dHAm0C2IyoZyMhKWsyFH6hkhS8TVM8j0gPR8rTTmk 0a9/e2vxcFnfBe3UAJaqzWRVFsBkOHrTNpG1hvID3Oq8IeywSBXw2VMSR93+mwaB sa/GCZKlqHGpOfmtILlhiXQX0E/tTHmcrI2VqyCpX0J2CW+MiGvkcGOwKHOJciSA Cj9D68y837QU/DCpMQ6ec/5wqWqZKz8yQb8kxb6vJcL19JcVKdAiPzbuOI49C3Ux YxDWoUutzDfVoUD5RhcJ =cP1w -----END PGP SIGNATURE----- Merge tag 'tags/restart-handler-for-v3.18' into v3.18-next/cpuclk Immutable branch with restart handler patches for v3.18
This commit is contained in:
commit
aec1d96c53
|
@ -114,18 +114,13 @@ void soft_restart(unsigned long addr)
|
|||
BUG();
|
||||
}
|
||||
|
||||
static void null_restart(enum reboot_mode reboot_mode, const char *cmd)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* Function pointers to optional machine specific functions
|
||||
*/
|
||||
void (*pm_power_off)(void);
|
||||
EXPORT_SYMBOL(pm_power_off);
|
||||
|
||||
void (*arm_pm_restart)(enum reboot_mode reboot_mode, const char *cmd) = null_restart;
|
||||
EXPORT_SYMBOL_GPL(arm_pm_restart);
|
||||
void (*arm_pm_restart)(enum reboot_mode reboot_mode, const char *cmd);
|
||||
|
||||
/*
|
||||
* This is our default idle handler.
|
||||
|
@ -230,7 +225,10 @@ void machine_restart(char *cmd)
|
|||
local_irq_disable();
|
||||
smp_send_stop();
|
||||
|
||||
arm_pm_restart(reboot_mode, cmd);
|
||||
if (arm_pm_restart)
|
||||
arm_pm_restart(reboot_mode, cmd);
|
||||
else
|
||||
do_kernel_restart(cmd);
|
||||
|
||||
/* Give a grace period for failure to restart of 1s */
|
||||
mdelay(1000);
|
||||
|
|
|
@ -98,7 +98,6 @@ void (*pm_power_off)(void);
|
|||
EXPORT_SYMBOL_GPL(pm_power_off);
|
||||
|
||||
void (*arm_pm_restart)(enum reboot_mode reboot_mode, const char *cmd);
|
||||
EXPORT_SYMBOL_GPL(arm_pm_restart);
|
||||
|
||||
/*
|
||||
* This is our default idle handler.
|
||||
|
@ -180,6 +179,8 @@ void machine_restart(char *cmd)
|
|||
/* Now call the architecture specific reboot code. */
|
||||
if (arm_pm_restart)
|
||||
arm_pm_restart(reboot_mode, cmd);
|
||||
else
|
||||
do_kernel_restart(cmd);
|
||||
|
||||
/*
|
||||
* Whoops - the architecture was unable to reboot.
|
||||
|
|
|
@ -20,7 +20,8 @@
|
|||
|
||||
static void restart_poweroff_do_poweroff(void)
|
||||
{
|
||||
arm_pm_restart(REBOOT_HARD, NULL);
|
||||
reboot_mode = REBOOT_HARD;
|
||||
machine_restart(NULL);
|
||||
}
|
||||
|
||||
static int restart_poweroff_probe(struct platform_device *pdev)
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -38,6 +38,9 @@ extern int reboot_force;
|
|||
extern int register_reboot_notifier(struct notifier_block *);
|
||||
extern int unregister_reboot_notifier(struct notifier_block *);
|
||||
|
||||
extern int register_restart_handler(struct notifier_block *);
|
||||
extern int unregister_restart_handler(struct notifier_block *);
|
||||
extern void do_kernel_restart(char *cmd);
|
||||
|
||||
/*
|
||||
* Architecture-specific implementations of sys_reboot commands.
|
||||
|
|
|
@ -104,6 +104,87 @@ int unregister_reboot_notifier(struct notifier_block *nb)
|
|||
}
|
||||
EXPORT_SYMBOL(unregister_reboot_notifier);
|
||||
|
||||
/*
|
||||
* Notifier list for kernel code which wants to be called
|
||||
* to restart the system.
|
||||
*/
|
||||
static ATOMIC_NOTIFIER_HEAD(restart_handler_list);
|
||||
|
||||
/**
|
||||
* register_restart_handler - Register function to be called to reset
|
||||
* the system
|
||||
* @nb: Info about handler function to be called
|
||||
* @nb->priority: Handler priority. Handlers should follow the
|
||||
* following guidelines for setting priorities.
|
||||
* 0: Restart handler of last resort,
|
||||
* with limited restart capabilities
|
||||
* 128: Default restart handler; use if no other
|
||||
* restart handler is expected to be available,
|
||||
* and/or if restart functionality is
|
||||
* sufficient to restart the entire system
|
||||
* 255: Highest priority restart handler, will
|
||||
* preempt all other restart handlers
|
||||
*
|
||||
* Registers a function with code to be called to restart the
|
||||
* system.
|
||||
*
|
||||
* Registered functions will be called from machine_restart as last
|
||||
* step of the restart sequence (if the architecture specific
|
||||
* machine_restart function calls do_kernel_restart - see below
|
||||
* for details).
|
||||
* Registered functions are expected to restart the system immediately.
|
||||
* If more than one function is registered, the restart handler priority
|
||||
* selects which function will be called first.
|
||||
*
|
||||
* Restart handlers are expected to be registered from non-architecture
|
||||
* code, typically from drivers. A typical use case would be a system
|
||||
* where restart functionality is provided through a watchdog. Multiple
|
||||
* restart handlers may exist; for example, one restart handler might
|
||||
* restart the entire system, while another only restarts the CPU.
|
||||
* In such cases, the restart handler which only restarts part of the
|
||||
* hardware is expected to register with low priority to ensure that
|
||||
* it only runs if no other means to restart the system is available.
|
||||
*
|
||||
* Currently always returns zero, as atomic_notifier_chain_register()
|
||||
* always returns zero.
|
||||
*/
|
||||
int register_restart_handler(struct notifier_block *nb)
|
||||
{
|
||||
return atomic_notifier_chain_register(&restart_handler_list, nb);
|
||||
}
|
||||
EXPORT_SYMBOL(register_restart_handler);
|
||||
|
||||
/**
|
||||
* unregister_restart_handler - Unregister previously registered
|
||||
* restart handler
|
||||
* @nb: Hook to be unregistered
|
||||
*
|
||||
* Unregisters a previously registered restart handler function.
|
||||
*
|
||||
* Returns zero on success, or %-ENOENT on failure.
|
||||
*/
|
||||
int unregister_restart_handler(struct notifier_block *nb)
|
||||
{
|
||||
return atomic_notifier_chain_unregister(&restart_handler_list, nb);
|
||||
}
|
||||
EXPORT_SYMBOL(unregister_restart_handler);
|
||||
|
||||
/**
|
||||
* do_kernel_restart - Execute kernel restart handler call chain
|
||||
*
|
||||
* Calls functions registered with register_restart_handler.
|
||||
*
|
||||
* Expected to be called from machine_restart as last step of the restart
|
||||
* sequence.
|
||||
*
|
||||
* Restarts the system immediately if a restart handler function has been
|
||||
* registered. Otherwise does nothing.
|
||||
*/
|
||||
void do_kernel_restart(char *cmd)
|
||||
{
|
||||
atomic_notifier_call_chain(&restart_handler_list, reboot_mode, cmd);
|
||||
}
|
||||
|
||||
void migrate_to_reboot_cpu(void)
|
||||
{
|
||||
/* The boot cpu is always logical cpu 0 */
|
||||
|
|
Loading…
Reference in a new issue