forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
552 lines
14 KiB
552 lines
14 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Kontron PLD watchdog driver |
|
* |
|
* Copyright (c) 2010-2013 Kontron Europe GmbH |
|
* Author: Michael Brunner <[email protected]> |
|
* |
|
* Note: From the PLD watchdog point of view timeout and pretimeout are |
|
* defined differently than in the kernel. |
|
* First the pretimeout stage runs out before the timeout stage gets |
|
* active. |
|
* |
|
* Kernel/API: P-----| pretimeout |
|
* |-----------------------T timeout |
|
* Watchdog: |-----------------P pretimeout_stage |
|
* |-----T timeout_stage |
|
*/ |
|
|
|
#include <linux/module.h> |
|
#include <linux/moduleparam.h> |
|
#include <linux/uaccess.h> |
|
#include <linux/watchdog.h> |
|
#include <linux/platform_device.h> |
|
#include <linux/mfd/kempld.h> |
|
|
|
#define KEMPLD_WDT_STAGE_TIMEOUT(x) (0x1b + (x) * 4) |
|
#define KEMPLD_WDT_STAGE_CFG(x) (0x18 + (x)) |
|
#define STAGE_CFG_GET_PRESCALER(x) (((x) & 0x30) >> 4) |
|
#define STAGE_CFG_SET_PRESCALER(x) (((x) & 0x3) << 4) |
|
#define STAGE_CFG_PRESCALER_MASK 0x30 |
|
#define STAGE_CFG_ACTION_MASK 0x7 |
|
#define STAGE_CFG_ASSERT (1 << 3) |
|
|
|
#define KEMPLD_WDT_MAX_STAGES 2 |
|
#define KEMPLD_WDT_KICK 0x16 |
|
#define KEMPLD_WDT_CFG 0x17 |
|
#define KEMPLD_WDT_CFG_ENABLE 0x10 |
|
#define KEMPLD_WDT_CFG_ENABLE_LOCK 0x8 |
|
#define KEMPLD_WDT_CFG_GLOBAL_LOCK 0x80 |
|
|
|
enum { |
|
ACTION_NONE = 0, |
|
ACTION_RESET, |
|
ACTION_NMI, |
|
ACTION_SMI, |
|
ACTION_SCI, |
|
ACTION_DELAY, |
|
}; |
|
|
|
enum { |
|
STAGE_TIMEOUT = 0, |
|
STAGE_PRETIMEOUT, |
|
}; |
|
|
|
enum { |
|
PRESCALER_21 = 0, |
|
PRESCALER_17, |
|
PRESCALER_12, |
|
}; |
|
|
|
static const u32 kempld_prescaler[] = { |
|
[PRESCALER_21] = (1 << 21) - 1, |
|
[PRESCALER_17] = (1 << 17) - 1, |
|
[PRESCALER_12] = (1 << 12) - 1, |
|
0, |
|
}; |
|
|
|
struct kempld_wdt_stage { |
|
unsigned int id; |
|
u32 mask; |
|
}; |
|
|
|
struct kempld_wdt_data { |
|
struct kempld_device_data *pld; |
|
struct watchdog_device wdd; |
|
unsigned int pretimeout; |
|
struct kempld_wdt_stage stage[KEMPLD_WDT_MAX_STAGES]; |
|
#ifdef CONFIG_PM |
|
u8 pm_status_store; |
|
#endif |
|
}; |
|
|
|
#define DEFAULT_TIMEOUT 30 /* seconds */ |
|
#define DEFAULT_PRETIMEOUT 0 |
|
|
|
static unsigned int timeout = DEFAULT_TIMEOUT; |
|
module_param(timeout, uint, 0); |
|
MODULE_PARM_DESC(timeout, |
|
"Watchdog timeout in seconds. (>=0, default=" |
|
__MODULE_STRING(DEFAULT_TIMEOUT) ")"); |
|
|
|
static unsigned int pretimeout = DEFAULT_PRETIMEOUT; |
|
module_param(pretimeout, uint, 0); |
|
MODULE_PARM_DESC(pretimeout, |
|
"Watchdog pretimeout in seconds. (>=0, default=" |
|
__MODULE_STRING(DEFAULT_PRETIMEOUT) ")"); |
|
|
|
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 int kempld_wdt_set_stage_action(struct kempld_wdt_data *wdt_data, |
|
struct kempld_wdt_stage *stage, |
|
u8 action) |
|
{ |
|
struct kempld_device_data *pld = wdt_data->pld; |
|
u8 stage_cfg; |
|
|
|
if (!stage || !stage->mask) |
|
return -EINVAL; |
|
|
|
kempld_get_mutex(pld); |
|
stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id)); |
|
stage_cfg &= ~STAGE_CFG_ACTION_MASK; |
|
stage_cfg |= (action & STAGE_CFG_ACTION_MASK); |
|
|
|
if (action == ACTION_RESET) |
|
stage_cfg |= STAGE_CFG_ASSERT; |
|
else |
|
stage_cfg &= ~STAGE_CFG_ASSERT; |
|
|
|
kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->id), stage_cfg); |
|
kempld_release_mutex(pld); |
|
|
|
return 0; |
|
} |
|
|
|
static int kempld_wdt_set_stage_timeout(struct kempld_wdt_data *wdt_data, |
|
struct kempld_wdt_stage *stage, |
|
unsigned int timeout) |
|
{ |
|
struct kempld_device_data *pld = wdt_data->pld; |
|
u32 prescaler; |
|
u64 stage_timeout64; |
|
u32 stage_timeout; |
|
u32 remainder; |
|
u8 stage_cfg; |
|
|
|
prescaler = kempld_prescaler[PRESCALER_21]; |
|
|
|
if (!stage) |
|
return -EINVAL; |
|
|
|
stage_timeout64 = (u64)timeout * pld->pld_clock; |
|
remainder = do_div(stage_timeout64, prescaler); |
|
if (remainder) |
|
stage_timeout64++; |
|
|
|
if (stage_timeout64 > stage->mask) |
|
return -EINVAL; |
|
|
|
stage_timeout = stage_timeout64 & stage->mask; |
|
|
|
kempld_get_mutex(pld); |
|
stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id)); |
|
stage_cfg &= ~STAGE_CFG_PRESCALER_MASK; |
|
stage_cfg |= STAGE_CFG_SET_PRESCALER(PRESCALER_21); |
|
kempld_write8(pld, KEMPLD_WDT_STAGE_CFG(stage->id), stage_cfg); |
|
kempld_write32(pld, KEMPLD_WDT_STAGE_TIMEOUT(stage->id), |
|
stage_timeout); |
|
kempld_release_mutex(pld); |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* kempld_get_mutex must be called prior to calling this function. |
|
*/ |
|
static unsigned int kempld_wdt_get_timeout(struct kempld_wdt_data *wdt_data, |
|
struct kempld_wdt_stage *stage) |
|
{ |
|
struct kempld_device_data *pld = wdt_data->pld; |
|
unsigned int timeout; |
|
u64 stage_timeout; |
|
u32 prescaler; |
|
u32 remainder; |
|
u8 stage_cfg; |
|
|
|
if (!stage->mask) |
|
return 0; |
|
|
|
stage_cfg = kempld_read8(pld, KEMPLD_WDT_STAGE_CFG(stage->id)); |
|
stage_timeout = kempld_read32(pld, KEMPLD_WDT_STAGE_TIMEOUT(stage->id)); |
|
prescaler = kempld_prescaler[STAGE_CFG_GET_PRESCALER(stage_cfg)]; |
|
|
|
stage_timeout = (stage_timeout & stage->mask) * prescaler; |
|
remainder = do_div(stage_timeout, pld->pld_clock); |
|
if (remainder) |
|
stage_timeout++; |
|
|
|
timeout = stage_timeout; |
|
WARN_ON_ONCE(timeout != stage_timeout); |
|
|
|
return timeout; |
|
} |
|
|
|
static int kempld_wdt_set_timeout(struct watchdog_device *wdd, |
|
unsigned int timeout) |
|
{ |
|
struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); |
|
struct kempld_wdt_stage *pretimeout_stage; |
|
struct kempld_wdt_stage *timeout_stage; |
|
int ret; |
|
|
|
timeout_stage = &wdt_data->stage[STAGE_TIMEOUT]; |
|
pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT]; |
|
|
|
if (pretimeout_stage->mask && wdt_data->pretimeout > 0) |
|
timeout = wdt_data->pretimeout; |
|
|
|
ret = kempld_wdt_set_stage_action(wdt_data, timeout_stage, |
|
ACTION_RESET); |
|
if (ret) |
|
return ret; |
|
ret = kempld_wdt_set_stage_timeout(wdt_data, timeout_stage, |
|
timeout); |
|
if (ret) |
|
return ret; |
|
|
|
wdd->timeout = timeout; |
|
return 0; |
|
} |
|
|
|
static int kempld_wdt_set_pretimeout(struct watchdog_device *wdd, |
|
unsigned int pretimeout) |
|
{ |
|
struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); |
|
struct kempld_wdt_stage *pretimeout_stage; |
|
u8 action = ACTION_NONE; |
|
int ret; |
|
|
|
pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT]; |
|
|
|
if (!pretimeout_stage->mask) |
|
return -ENXIO; |
|
|
|
if (pretimeout > wdd->timeout) |
|
return -EINVAL; |
|
|
|
if (pretimeout > 0) |
|
action = ACTION_NMI; |
|
|
|
ret = kempld_wdt_set_stage_action(wdt_data, pretimeout_stage, |
|
action); |
|
if (ret) |
|
return ret; |
|
ret = kempld_wdt_set_stage_timeout(wdt_data, pretimeout_stage, |
|
wdd->timeout - pretimeout); |
|
if (ret) |
|
return ret; |
|
|
|
wdt_data->pretimeout = pretimeout; |
|
return 0; |
|
} |
|
|
|
static void kempld_wdt_update_timeouts(struct kempld_wdt_data *wdt_data) |
|
{ |
|
struct kempld_device_data *pld = wdt_data->pld; |
|
struct kempld_wdt_stage *pretimeout_stage; |
|
struct kempld_wdt_stage *timeout_stage; |
|
unsigned int pretimeout, timeout; |
|
|
|
pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT]; |
|
timeout_stage = &wdt_data->stage[STAGE_TIMEOUT]; |
|
|
|
kempld_get_mutex(pld); |
|
pretimeout = kempld_wdt_get_timeout(wdt_data, pretimeout_stage); |
|
timeout = kempld_wdt_get_timeout(wdt_data, timeout_stage); |
|
kempld_release_mutex(pld); |
|
|
|
if (pretimeout) |
|
wdt_data->pretimeout = timeout; |
|
else |
|
wdt_data->pretimeout = 0; |
|
|
|
wdt_data->wdd.timeout = pretimeout + timeout; |
|
} |
|
|
|
static int kempld_wdt_start(struct watchdog_device *wdd) |
|
{ |
|
struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); |
|
struct kempld_device_data *pld = wdt_data->pld; |
|
u8 status; |
|
int ret; |
|
|
|
ret = kempld_wdt_set_timeout(wdd, wdd->timeout); |
|
if (ret) |
|
return ret; |
|
|
|
kempld_get_mutex(pld); |
|
status = kempld_read8(pld, KEMPLD_WDT_CFG); |
|
status |= KEMPLD_WDT_CFG_ENABLE; |
|
kempld_write8(pld, KEMPLD_WDT_CFG, status); |
|
status = kempld_read8(pld, KEMPLD_WDT_CFG); |
|
kempld_release_mutex(pld); |
|
|
|
/* Check if the watchdog was enabled */ |
|
if (!(status & KEMPLD_WDT_CFG_ENABLE)) |
|
return -EACCES; |
|
|
|
return 0; |
|
} |
|
|
|
static int kempld_wdt_stop(struct watchdog_device *wdd) |
|
{ |
|
struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); |
|
struct kempld_device_data *pld = wdt_data->pld; |
|
u8 status; |
|
|
|
kempld_get_mutex(pld); |
|
status = kempld_read8(pld, KEMPLD_WDT_CFG); |
|
status &= ~KEMPLD_WDT_CFG_ENABLE; |
|
kempld_write8(pld, KEMPLD_WDT_CFG, status); |
|
status = kempld_read8(pld, KEMPLD_WDT_CFG); |
|
kempld_release_mutex(pld); |
|
|
|
/* Check if the watchdog was disabled */ |
|
if (status & KEMPLD_WDT_CFG_ENABLE) |
|
return -EACCES; |
|
|
|
return 0; |
|
} |
|
|
|
static int kempld_wdt_keepalive(struct watchdog_device *wdd) |
|
{ |
|
struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); |
|
struct kempld_device_data *pld = wdt_data->pld; |
|
|
|
kempld_get_mutex(pld); |
|
kempld_write8(pld, KEMPLD_WDT_KICK, 'K'); |
|
kempld_release_mutex(pld); |
|
|
|
return 0; |
|
} |
|
|
|
static long kempld_wdt_ioctl(struct watchdog_device *wdd, unsigned int cmd, |
|
unsigned long arg) |
|
{ |
|
struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); |
|
void __user *argp = (void __user *)arg; |
|
int ret = -ENOIOCTLCMD; |
|
int __user *p = argp; |
|
int new_value; |
|
|
|
switch (cmd) { |
|
case WDIOC_SETPRETIMEOUT: |
|
if (get_user(new_value, p)) |
|
return -EFAULT; |
|
ret = kempld_wdt_set_pretimeout(wdd, new_value); |
|
if (ret) |
|
return ret; |
|
ret = kempld_wdt_keepalive(wdd); |
|
break; |
|
case WDIOC_GETPRETIMEOUT: |
|
ret = put_user(wdt_data->pretimeout, (int __user *)arg); |
|
break; |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
static int kempld_wdt_probe_stages(struct watchdog_device *wdd) |
|
{ |
|
struct kempld_wdt_data *wdt_data = watchdog_get_drvdata(wdd); |
|
struct kempld_device_data *pld = wdt_data->pld; |
|
struct kempld_wdt_stage *pretimeout_stage; |
|
struct kempld_wdt_stage *timeout_stage; |
|
u8 index, data, data_orig; |
|
u32 mask; |
|
int i, j; |
|
|
|
pretimeout_stage = &wdt_data->stage[STAGE_PRETIMEOUT]; |
|
timeout_stage = &wdt_data->stage[STAGE_TIMEOUT]; |
|
|
|
pretimeout_stage->mask = 0; |
|
timeout_stage->mask = 0; |
|
|
|
for (i = 0; i < 3; i++) { |
|
index = KEMPLD_WDT_STAGE_TIMEOUT(i); |
|
mask = 0; |
|
|
|
kempld_get_mutex(pld); |
|
/* Probe each byte individually. */ |
|
for (j = 0; j < 4; j++) { |
|
data_orig = kempld_read8(pld, index + j); |
|
kempld_write8(pld, index + j, 0x00); |
|
data = kempld_read8(pld, index + j); |
|
/* A failed write means this byte is reserved */ |
|
if (data != 0x00) |
|
break; |
|
kempld_write8(pld, index + j, data_orig); |
|
mask |= 0xff << (j * 8); |
|
} |
|
kempld_release_mutex(pld); |
|
|
|
/* Assign available stages to timeout and pretimeout */ |
|
if (!timeout_stage->mask) { |
|
timeout_stage->mask = mask; |
|
timeout_stage->id = i; |
|
} else { |
|
if (pld->feature_mask & KEMPLD_FEATURE_BIT_NMI) { |
|
pretimeout_stage->mask = timeout_stage->mask; |
|
timeout_stage->mask = mask; |
|
pretimeout_stage->id = timeout_stage->id; |
|
timeout_stage->id = i; |
|
} |
|
break; |
|
} |
|
} |
|
|
|
if (!timeout_stage->mask) |
|
return -ENODEV; |
|
|
|
return 0; |
|
} |
|
|
|
static const struct watchdog_info kempld_wdt_info = { |
|
.identity = "KEMPLD Watchdog", |
|
.options = WDIOF_SETTIMEOUT | |
|
WDIOF_KEEPALIVEPING | |
|
WDIOF_MAGICCLOSE | |
|
WDIOF_PRETIMEOUT |
|
}; |
|
|
|
static const struct watchdog_ops kempld_wdt_ops = { |
|
.owner = THIS_MODULE, |
|
.start = kempld_wdt_start, |
|
.stop = kempld_wdt_stop, |
|
.ping = kempld_wdt_keepalive, |
|
.set_timeout = kempld_wdt_set_timeout, |
|
.ioctl = kempld_wdt_ioctl, |
|
}; |
|
|
|
static int kempld_wdt_probe(struct platform_device *pdev) |
|
{ |
|
struct kempld_device_data *pld = dev_get_drvdata(pdev->dev.parent); |
|
struct kempld_wdt_data *wdt_data; |
|
struct device *dev = &pdev->dev; |
|
struct watchdog_device *wdd; |
|
u8 status; |
|
int ret = 0; |
|
|
|
wdt_data = devm_kzalloc(dev, sizeof(*wdt_data), GFP_KERNEL); |
|
if (!wdt_data) |
|
return -ENOMEM; |
|
|
|
wdt_data->pld = pld; |
|
wdd = &wdt_data->wdd; |
|
wdd->parent = dev; |
|
|
|
kempld_get_mutex(pld); |
|
status = kempld_read8(pld, KEMPLD_WDT_CFG); |
|
kempld_release_mutex(pld); |
|
|
|
/* Enable nowayout if watchdog is already locked */ |
|
if (status & (KEMPLD_WDT_CFG_ENABLE_LOCK | |
|
KEMPLD_WDT_CFG_GLOBAL_LOCK)) { |
|
if (!nowayout) |
|
dev_warn(dev, |
|
"Forcing nowayout - watchdog lock enabled!\n"); |
|
nowayout = true; |
|
} |
|
|
|
wdd->info = &kempld_wdt_info; |
|
wdd->ops = &kempld_wdt_ops; |
|
|
|
watchdog_set_drvdata(wdd, wdt_data); |
|
watchdog_set_nowayout(wdd, nowayout); |
|
|
|
ret = kempld_wdt_probe_stages(wdd); |
|
if (ret) |
|
return ret; |
|
|
|
kempld_wdt_set_timeout(wdd, timeout); |
|
kempld_wdt_set_pretimeout(wdd, pretimeout); |
|
|
|
/* Check if watchdog is already enabled */ |
|
if (status & KEMPLD_WDT_CFG_ENABLE) { |
|
/* Get current watchdog settings */ |
|
kempld_wdt_update_timeouts(wdt_data); |
|
dev_info(dev, "Watchdog was already enabled\n"); |
|
} |
|
|
|
platform_set_drvdata(pdev, wdt_data); |
|
watchdog_stop_on_reboot(wdd); |
|
watchdog_stop_on_unregister(wdd); |
|
ret = devm_watchdog_register_device(dev, wdd); |
|
if (ret) |
|
return ret; |
|
|
|
dev_info(dev, "Watchdog registered with %ds timeout\n", wdd->timeout); |
|
|
|
return 0; |
|
} |
|
|
|
#ifdef CONFIG_PM |
|
/* Disable watchdog if it is active during suspend */ |
|
static int kempld_wdt_suspend(struct platform_device *pdev, |
|
pm_message_t message) |
|
{ |
|
struct kempld_wdt_data *wdt_data = platform_get_drvdata(pdev); |
|
struct kempld_device_data *pld = wdt_data->pld; |
|
struct watchdog_device *wdd = &wdt_data->wdd; |
|
|
|
kempld_get_mutex(pld); |
|
wdt_data->pm_status_store = kempld_read8(pld, KEMPLD_WDT_CFG); |
|
kempld_release_mutex(pld); |
|
|
|
kempld_wdt_update_timeouts(wdt_data); |
|
|
|
if (wdt_data->pm_status_store & KEMPLD_WDT_CFG_ENABLE) |
|
return kempld_wdt_stop(wdd); |
|
|
|
return 0; |
|
} |
|
|
|
/* Enable watchdog and configure it if necessary */ |
|
static int kempld_wdt_resume(struct platform_device *pdev) |
|
{ |
|
struct kempld_wdt_data *wdt_data = platform_get_drvdata(pdev); |
|
struct watchdog_device *wdd = &wdt_data->wdd; |
|
|
|
/* |
|
* If watchdog was stopped before suspend be sure it gets disabled |
|
* again, for the case BIOS has enabled it during resume |
|
*/ |
|
if (wdt_data->pm_status_store & KEMPLD_WDT_CFG_ENABLE) |
|
return kempld_wdt_start(wdd); |
|
else |
|
return kempld_wdt_stop(wdd); |
|
} |
|
#else |
|
#define kempld_wdt_suspend NULL |
|
#define kempld_wdt_resume NULL |
|
#endif |
|
|
|
static struct platform_driver kempld_wdt_driver = { |
|
.driver = { |
|
.name = "kempld-wdt", |
|
}, |
|
.probe = kempld_wdt_probe, |
|
.suspend = kempld_wdt_suspend, |
|
.resume = kempld_wdt_resume, |
|
}; |
|
|
|
module_platform_driver(kempld_wdt_driver); |
|
|
|
MODULE_DESCRIPTION("KEM PLD Watchdog Driver"); |
|
MODULE_AUTHOR("Michael Brunner <[email protected]>"); |
|
MODULE_LICENSE("GPL");
|
|
|