mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
![Pratyush Anand](/assets/img/avatar_default.png)
/sys/class/watchdog/watchdogn/device/modalias can help to identify the driver/module for a given watchdog node. However, many wdt devices do not set their parent and so, we do not see an entry for device in sysfs for such devices. This patch fixes parent of watchdog_device so that /sys/class/watchdog/watchdogn/device is populated. Exceptions: booke, diag288, octeon, softdog and w83627hf -- They do not have any parent. Not sure, how we can identify driver for these devices. Signed-off-by: Pratyush Anand <panand@redhat.com> Reviewed-by: Johannes Thumshirn <jthumshirn@suse.de> Acked-by: Guenter Roeck <linux@roeck-us.net> Acked-by: H Hartley Sweeten <hsweeten@visionengravers.com> Acked-by: Lee Jones <lee.jones@linaro.org> Acked-by: Lubomir Rintel <lkundrak@v3.sk> Acked-by: Maxime Coquelin <maxime.coquelin@st.com> Acked-by: Thierry Reding <treding@nvidia.com> Acked-by: Viresh Kumar <viresh.kumar@linaro.org> Acked-by: Linus Walleij <linus.walleij@linaro.org> Signed-off-by: Wim Van Sebroeck <wim@iguana.be>
234 lines
5.7 KiB
C
234 lines
5.7 KiB
C
/* Copyright (c) 2014, The Linux Foundation. All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 and
|
|
* only version 2 as published by the Free Software Foundation.
|
|
*
|
|
* 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/clk.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/io.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/watchdog.h>
|
|
|
|
#define WDT_RST 0x38
|
|
#define WDT_EN 0x40
|
|
#define WDT_BITE_TIME 0x5C
|
|
|
|
struct qcom_wdt {
|
|
struct watchdog_device wdd;
|
|
struct clk *clk;
|
|
unsigned long rate;
|
|
struct notifier_block restart_nb;
|
|
void __iomem *base;
|
|
};
|
|
|
|
static inline
|
|
struct qcom_wdt *to_qcom_wdt(struct watchdog_device *wdd)
|
|
{
|
|
return container_of(wdd, struct qcom_wdt, wdd);
|
|
}
|
|
|
|
static int qcom_wdt_start(struct watchdog_device *wdd)
|
|
{
|
|
struct qcom_wdt *wdt = to_qcom_wdt(wdd);
|
|
|
|
writel(0, wdt->base + WDT_EN);
|
|
writel(1, wdt->base + WDT_RST);
|
|
writel(wdd->timeout * wdt->rate, wdt->base + WDT_BITE_TIME);
|
|
writel(1, wdt->base + WDT_EN);
|
|
return 0;
|
|
}
|
|
|
|
static int qcom_wdt_stop(struct watchdog_device *wdd)
|
|
{
|
|
struct qcom_wdt *wdt = to_qcom_wdt(wdd);
|
|
|
|
writel(0, wdt->base + WDT_EN);
|
|
return 0;
|
|
}
|
|
|
|
static int qcom_wdt_ping(struct watchdog_device *wdd)
|
|
{
|
|
struct qcom_wdt *wdt = to_qcom_wdt(wdd);
|
|
|
|
writel(1, wdt->base + WDT_RST);
|
|
return 0;
|
|
}
|
|
|
|
static int qcom_wdt_set_timeout(struct watchdog_device *wdd,
|
|
unsigned int timeout)
|
|
{
|
|
wdd->timeout = timeout;
|
|
return qcom_wdt_start(wdd);
|
|
}
|
|
|
|
static const struct watchdog_ops qcom_wdt_ops = {
|
|
.start = qcom_wdt_start,
|
|
.stop = qcom_wdt_stop,
|
|
.ping = qcom_wdt_ping,
|
|
.set_timeout = qcom_wdt_set_timeout,
|
|
.owner = THIS_MODULE,
|
|
};
|
|
|
|
static const struct watchdog_info qcom_wdt_info = {
|
|
.options = WDIOF_KEEPALIVEPING
|
|
| WDIOF_MAGICCLOSE
|
|
| WDIOF_SETTIMEOUT,
|
|
.identity = KBUILD_MODNAME,
|
|
};
|
|
|
|
static int qcom_wdt_restart(struct notifier_block *nb, unsigned long action,
|
|
void *data)
|
|
{
|
|
struct qcom_wdt *wdt = container_of(nb, struct qcom_wdt, restart_nb);
|
|
u32 timeout;
|
|
|
|
/*
|
|
* Trigger watchdog bite:
|
|
* Setup BITE_TIME to be 128ms, and enable WDT.
|
|
*/
|
|
timeout = 128 * wdt->rate / 1000;
|
|
|
|
writel(0, wdt->base + WDT_EN);
|
|
writel(1, wdt->base + WDT_RST);
|
|
writel(timeout, wdt->base + WDT_BITE_TIME);
|
|
writel(1, wdt->base + WDT_EN);
|
|
|
|
/*
|
|
* Actually make sure the above sequence hits hardware before sleeping.
|
|
*/
|
|
wmb();
|
|
|
|
msleep(150);
|
|
return NOTIFY_DONE;
|
|
}
|
|
|
|
static int qcom_wdt_probe(struct platform_device *pdev)
|
|
{
|
|
struct qcom_wdt *wdt;
|
|
struct resource *res;
|
|
struct device_node *np = pdev->dev.of_node;
|
|
u32 percpu_offset;
|
|
int ret;
|
|
|
|
wdt = devm_kzalloc(&pdev->dev, sizeof(*wdt), GFP_KERNEL);
|
|
if (!wdt)
|
|
return -ENOMEM;
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
/* We use CPU0's DGT for the watchdog */
|
|
if (of_property_read_u32(np, "cpu-offset", &percpu_offset))
|
|
percpu_offset = 0;
|
|
|
|
res->start += percpu_offset;
|
|
res->end += percpu_offset;
|
|
|
|
wdt->base = devm_ioremap_resource(&pdev->dev, res);
|
|
if (IS_ERR(wdt->base))
|
|
return PTR_ERR(wdt->base);
|
|
|
|
wdt->clk = devm_clk_get(&pdev->dev, NULL);
|
|
if (IS_ERR(wdt->clk)) {
|
|
dev_err(&pdev->dev, "failed to get input clock\n");
|
|
return PTR_ERR(wdt->clk);
|
|
}
|
|
|
|
ret = clk_prepare_enable(wdt->clk);
|
|
if (ret) {
|
|
dev_err(&pdev->dev, "failed to setup clock\n");
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* We use the clock rate to calculate the max timeout, so ensure it's
|
|
* not zero to avoid a divide-by-zero exception.
|
|
*
|
|
* WATCHDOG_CORE assumes units of seconds, if the WDT is clocked such
|
|
* that it would bite before a second elapses it's usefulness is
|
|
* limited. Bail if this is the case.
|
|
*/
|
|
wdt->rate = clk_get_rate(wdt->clk);
|
|
if (wdt->rate == 0 ||
|
|
wdt->rate > 0x10000000U) {
|
|
dev_err(&pdev->dev, "invalid clock rate\n");
|
|
ret = -EINVAL;
|
|
goto err_clk_unprepare;
|
|
}
|
|
|
|
wdt->wdd.dev = &pdev->dev;
|
|
wdt->wdd.info = &qcom_wdt_info;
|
|
wdt->wdd.ops = &qcom_wdt_ops;
|
|
wdt->wdd.min_timeout = 1;
|
|
wdt->wdd.max_timeout = 0x10000000U / wdt->rate;
|
|
wdt->wdd.parent = &pdev->dev;
|
|
|
|
/*
|
|
* If 'timeout-sec' unspecified in devicetree, assume a 30 second
|
|
* default, unless the max timeout is less than 30 seconds, then use
|
|
* the max instead.
|
|
*/
|
|
wdt->wdd.timeout = min(wdt->wdd.max_timeout, 30U);
|
|
watchdog_init_timeout(&wdt->wdd, 0, &pdev->dev);
|
|
|
|
ret = watchdog_register_device(&wdt->wdd);
|
|
if (ret) {
|
|
dev_err(&pdev->dev, "failed to register watchdog\n");
|
|
goto err_clk_unprepare;
|
|
}
|
|
|
|
/*
|
|
* WDT restart notifier has priority 0 (use as a last resort)
|
|
*/
|
|
wdt->restart_nb.notifier_call = qcom_wdt_restart;
|
|
ret = register_restart_handler(&wdt->restart_nb);
|
|
if (ret)
|
|
dev_err(&pdev->dev, "failed to setup restart handler\n");
|
|
|
|
platform_set_drvdata(pdev, wdt);
|
|
return 0;
|
|
|
|
err_clk_unprepare:
|
|
clk_disable_unprepare(wdt->clk);
|
|
return ret;
|
|
}
|
|
|
|
static int qcom_wdt_remove(struct platform_device *pdev)
|
|
{
|
|
struct qcom_wdt *wdt = platform_get_drvdata(pdev);
|
|
|
|
unregister_restart_handler(&wdt->restart_nb);
|
|
watchdog_unregister_device(&wdt->wdd);
|
|
clk_disable_unprepare(wdt->clk);
|
|
return 0;
|
|
}
|
|
|
|
static const struct of_device_id qcom_wdt_of_table[] = {
|
|
{ .compatible = "qcom,kpss-timer" },
|
|
{ .compatible = "qcom,scss-timer" },
|
|
{ },
|
|
};
|
|
MODULE_DEVICE_TABLE(of, qcom_wdt_of_table);
|
|
|
|
static struct platform_driver qcom_watchdog_driver = {
|
|
.probe = qcom_wdt_probe,
|
|
.remove = qcom_wdt_remove,
|
|
.driver = {
|
|
.name = KBUILD_MODNAME,
|
|
.of_match_table = qcom_wdt_of_table,
|
|
},
|
|
};
|
|
module_platform_driver(qcom_watchdog_driver);
|
|
|
|
MODULE_DESCRIPTION("QCOM KPSS Watchdog Driver");
|
|
MODULE_LICENSE("GPL v2");
|