Release 4.11 drivers/watchdog/dw_wdt.c

/*
 * Copyright 2010-2011 Picochip Ltd., Jamie Iles
 * http://www.picochip.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 file implements a driver for the Synopsys DesignWare watchdog device
 * in the many subsystems. The watchdog has 16 different timeout periods
 * and these are a function of the input clock frequency.
 *
 * The DesignWare watchdog cannot be stopped once it has been started so we
 * do not implement a stop function. The watchdog core will continue to send
 * heartbeat requests after the watchdog device has been closed.
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/bitops.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/of.h>
#include <linux/pm.h>
#include <linux/platform_device.h>
#include <linux/watchdog.h>


#define WDOG_CONTROL_REG_OFFSET		    0x00

#define WDOG_CONTROL_REG_WDT_EN_MASK	    0x01

#define WDOG_TIMEOUT_RANGE_REG_OFFSET	    0x04

#define WDOG_TIMEOUT_RANGE_TOPINIT_SHIFT    4

#define WDOG_CURRENT_COUNT_REG_OFFSET	    0x08

#define WDOG_COUNTER_RESTART_REG_OFFSET     0x0c

#define WDOG_COUNTER_RESTART_KICK_VALUE	    0x76

/* The maximum TOP (timeout period) value that can be set in the watchdog. */

#define DW_WDT_MAX_TOP		15


#define DW_WDT_DEFAULT_SECONDS	30


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) ")");


struct dw_wdt {
	
void __iomem		*regs;
	
struct clk		*clk;
	
unsigned long		rate;
	
struct watchdog_device	wdd;
};


#define to_dw_wdt(wdd)	container_of(wdd, struct dw_wdt, wdd)



static inline int dw_wdt_is_enabled(struct dw_wdt *dw_wdt)
{
	return readl(dw_wdt->regs + WDOG_CONTROL_REG_OFFSET) &
		WDOG_CONTROL_REG_WDT_EN_MASK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jamie Iles
19
79.17%
1
50.00%
Guenter Roeck
5
20.83%
1
50.00%
Total
24
100.00%
2
100.00%



static inline int dw_wdt_top_in_seconds(struct dw_wdt *dw_wdt, unsigned top)
{
	/*
         * There are 16 possible timeout values in 0..15 where the number of
         * cycles is 2 ^ (16 + i) and the watchdog counts down.
         */
	return (1U << (16 + top)) / dw_wdt->rate;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jamie Iles
23
74.19%
1
25.00%
Guenter Roeck
7
22.58%
2
50.00%
JiSheng Zhang
1
3.23%
1
25.00%
Total
31
100.00%
4
100.00%



static int dw_wdt_get_top(struct dw_wdt *dw_wdt)
{
	int top = readl(dw_wdt->regs + WDOG_TIMEOUT_RANGE_REG_OFFSET) & 0xF;

	return dw_wdt_top_in_seconds(dw_wdt, top);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jamie Iles
26
78.79%
1
50.00%
Guenter Roeck
7
21.21%
1
50.00%
Total
33
100.00%
2
100.00%



static int dw_wdt_ping(struct watchdog_device *wdd)
{
	struct dw_wdt *dw_wdt = to_dw_wdt(wdd);

	writel(WDOG_COUNTER_RESTART_KICK_VALUE, dw_wdt->regs +
	       WDOG_COUNTER_RESTART_REG_OFFSET);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Guenter Roeck
19
54.29%
1
33.33%
Douglas Anderson
11
31.43%
1
33.33%
Jamie Iles
5
14.29%
1
33.33%
Total
35
100.00%
3
100.00%



static int dw_wdt_set_timeout(struct watchdog_device *wdd, unsigned int top_s)
{
	struct dw_wdt *dw_wdt = to_dw_wdt(wdd);
	int i, top_val = DW_WDT_MAX_TOP;

	/*
         * Iterate over the timeout values until we find the closest match. We
         * always look for >=.
         */
	for (i = 0; i <= DW_WDT_MAX_TOP; ++i)
		if (dw_wdt_top_in_seconds(dw_wdt, i) >= top_s) {
			top_val = i;
			break;
		}

	/*
         * Set the new value in the watchdog.  Some versions of dw_wdt
         * have have TOPINIT in the TIMEOUT_RANGE register (as per
         * CP_WDT_DUAL_TOP in WDT_COMP_PARAMS_1).  On those we
         * effectively get a pat of the watchdog right here.
         */
	writel(top_val | top_val << WDOG_TIMEOUT_RANGE_TOPINIT_SHIFT,
	       dw_wdt->regs + WDOG_TIMEOUT_RANGE_REG_OFFSET);

	wdd->timeout = dw_wdt_top_in_seconds(dw_wdt, top_val);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jamie Iles
58
61.70%
1
25.00%
Guenter Roeck
31
32.98%
1
25.00%
JiSheng Zhang
4
4.26%
1
25.00%
Douglas Anderson
1
1.06%
1
25.00%
Total
94
100.00%
4
100.00%



static int dw_wdt_start(struct watchdog_device *wdd)
{
	struct dw_wdt *dw_wdt = to_dw_wdt(wdd);

	dw_wdt_set_timeout(wdd, wdd->timeout);

	set_bit(WDOG_HW_RUNNING, &wdd->status);

	writel(WDOG_CONTROL_REG_WDT_EN_MASK,
	       dw_wdt->regs + WDOG_CONTROL_REG_OFFSET);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Guenter Roeck
52
96.30%
1
50.00%
Jamie Iles
2
3.70%
1
50.00%
Total
54
100.00%
2
100.00%



static int dw_wdt_restart(struct watchdog_device *wdd,
			  unsigned long action, void *data)
{
	struct dw_wdt *dw_wdt = to_dw_wdt(wdd);
	u32 val;

	writel(0, dw_wdt->regs + WDOG_TIMEOUT_RANGE_REG_OFFSET);
	val = readl(dw_wdt->regs + WDOG_CONTROL_REG_OFFSET);
	if (val & WDOG_CONTROL_REG_WDT_EN_MASK)
		writel(WDOG_COUNTER_RESTART_KICK_VALUE,
		       dw_wdt->regs + WDOG_COUNTER_RESTART_REG_OFFSET);
	else
		writel(WDOG_CONTROL_REG_WDT_EN_MASK,
		       dw_wdt->regs + WDOG_CONTROL_REG_OFFSET);

	/* wait for reset to assert... */
	mdelay(500);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
JiSheng Zhang
72
78.26%
1
33.33%
Guenter Roeck
20
21.74%
2
66.67%
Total
92
100.00%
3
100.00%



static unsigned int dw_wdt_get_timeleft(struct watchdog_device *wdd)
{
	struct dw_wdt *dw_wdt = to_dw_wdt(wdd);

	return readl(dw_wdt->regs + WDOG_CURRENT_COUNT_REG_OFFSET) /
		dw_wdt->rate;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Guenter Roeck
25
69.44%
2
66.67%
Jamie Iles
11
30.56%
1
33.33%
Total
36
100.00%
3
100.00%


static const struct watchdog_info dw_wdt_ident = {
	.options	= WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
			  WDIOF_MAGICCLOSE,
	.identity	= "Synopsys DesignWare Watchdog",
};


static const struct watchdog_ops dw_wdt_ops = {
	.owner		= THIS_MODULE,
	.start		= dw_wdt_start,
	.ping		= dw_wdt_ping,
	.set_timeout	= dw_wdt_set_timeout,
	.get_timeleft	= dw_wdt_get_timeleft,
	.restart	= dw_wdt_restart,
};

#ifdef CONFIG_PM_SLEEP


static int dw_wdt_suspend(struct device *dev)
{
	struct dw_wdt *dw_wdt = dev_get_drvdata(dev);

	clk_disable_unprepare(dw_wdt->clk);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jamie Iles
19
61.29%
1
33.33%
Guenter Roeck
11
35.48%
1
33.33%
Heiko Stübner
1
3.23%
1
33.33%
Total
31
100.00%
3
100.00%



static int dw_wdt_resume(struct device *dev)
{
	struct dw_wdt *dw_wdt = dev_get_drvdata(dev);
	int err = clk_prepare_enable(dw_wdt->clk);

	if (err)
		return err;

	dw_wdt_ping(&dw_wdt->wdd);

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Jamie Iles
30
61.22%
1
33.33%
Guenter Roeck
18
36.73%
1
33.33%
Heiko Stübner
1
2.04%
1
33.33%
Total
49
100.00%
3
100.00%

#endif /* CONFIG_PM_SLEEP */

static SIMPLE_DEV_PM_OPS(dw_wdt_pm_ops, dw_wdt_suspend, dw_wdt_resume);



static int dw_wdt_drv_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct watchdog_device *wdd;
	struct dw_wdt *dw_wdt;
	struct resource *mem;
	int ret;

	dw_wdt = devm_kzalloc(dev, sizeof(*dw_wdt), GFP_KERNEL);
	if (!dw_wdt)
		return -ENOMEM;

	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	dw_wdt->regs = devm_ioremap_resource(dev, mem);
	if (IS_ERR(dw_wdt->regs))
		return PTR_ERR(dw_wdt->regs);

	dw_wdt->clk = devm_clk_get(dev, NULL);
	if (IS_ERR(dw_wdt->clk))
		return PTR_ERR(dw_wdt->clk);

	ret = clk_prepare_enable(dw_wdt->clk);
	if (ret)
		return ret;

	dw_wdt->rate = clk_get_rate(dw_wdt->clk);
	if (dw_wdt->rate == 0) {
		ret = -EINVAL;
		goto out_disable_clk;
	}

	wdd = &dw_wdt->wdd;
	wdd->info = &dw_wdt_ident;
	wdd->ops = &dw_wdt_ops;
	wdd->min_timeout = 1;
	wdd->max_hw_heartbeat_ms =
		dw_wdt_top_in_seconds(dw_wdt, DW_WDT_MAX_TOP) * 1000;
	wdd->parent = dev;

	watchdog_set_drvdata(wdd, dw_wdt);
	watchdog_set_nowayout(wdd, nowayout);
	watchdog_init_timeout(wdd, 0, dev);

	/*
         * If the watchdog is already running, use its already configured
         * timeout. Otherwise use the default or the value provided through
         * devicetree.
         */
	if (dw_wdt_is_enabled(dw_wdt)) {
		wdd->timeout = dw_wdt_get_top(dw_wdt);
		set_bit(WDOG_HW_RUNNING, &wdd->status);
	} else {
		wdd->timeout = DW_WDT_DEFAULT_SECONDS;
		watchdog_init_timeout(wdd, 0, dev);
	}

	platform_set_drvdata(pdev, dw_wdt);

	watchdog_set_restart_priority(wdd, 128);

	ret = watchdog_register_device(wdd);
	if (ret)
		goto out_disable_clk;

	return 0;

out_disable_clk:
	clk_disable_unprepare(dw_wdt->clk);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Guenter Roeck
219
65.57%
3
42.86%
Jamie Iles
100
29.94%
1
14.29%
Thierry Reding
9
2.69%
1
14.29%
Jingoo Han
4
1.20%
1
14.29%
Heiko Stübner
2
0.60%
1
14.29%
Total
334
100.00%
7
100.00%



static int dw_wdt_drv_remove(struct platform_device *pdev)
{
	struct dw_wdt *dw_wdt = platform_get_drvdata(pdev);

	watchdog_unregister_device(&dw_wdt->wdd);
	clk_disable_unprepare(dw_wdt->clk);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Jamie Iles
23
58.97%
1
33.33%
Guenter Roeck
15
38.46%
1
33.33%
Heiko Stübner
1
2.56%
1
33.33%
Total
39
100.00%
3
100.00%

#ifdef CONFIG_OF

static const struct of_device_id dw_wdt_of_match[] = {
	{ .compatible = "snps,dw-wdt", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, dw_wdt_of_match);
#endif


static struct platform_driver dw_wdt_driver = {
	.probe		= dw_wdt_drv_probe,
	.remove		= dw_wdt_drv_remove,
	.driver		= {
		.name	= "dw_wdt",
		.of_match_table = of_match_ptr(dw_wdt_of_match),
		.pm	= &dw_wdt_pm_ops,
        },
};


module_platform_driver(dw_wdt_driver);

MODULE_AUTHOR("Jamie Iles");
MODULE_DESCRIPTION("Synopsys DesignWare Watchdog Driver");
MODULE_LICENSE("GPL");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Jamie Iles
506
43.62%
1
5.88%
Guenter Roeck
476
41.03%
3
17.65%
JiSheng Zhang
84
7.24%
3
17.65%
Dinh Nguyen
43
3.71%
1
5.88%
Heiko Stübner
18
1.55%
2
11.76%
Douglas Anderson
16
1.38%
2
11.76%
Thierry Reding
9
0.78%
1
5.88%
Jingoo Han
4
0.34%
1
5.88%
Wim Van Sebroeck
2
0.17%
1
5.88%
Axel Lin
1
0.09%
1
5.88%
Joe Perches
1
0.09%
1
5.88%
Total
1160
100.00%
17
100.00%
Directory: drivers/watchdog

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.