Release 4.7 drivers/watchdog/imx2_wdt.c

/*
 * Watchdog driver for IMX2 and later processors
 *
 *  Copyright (C) 2010 Wolfram Sang, Pengutronix e.K. <w.sang@pengutronix.de>
 *  Copyright (C) 2014 Freescale Semiconductor, Inc.
 *
 * some parts adapted by similar drivers from Darius Augulis and Vladimir
 * Zapolskiy, additional improvements by Wim Van Sebroeck.
 *
 * 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.
 *
 * NOTE: MX1 has a slightly different Watchdog than MX2 and later:
 *
 *                      MX1:            MX2+:
 *                      ----            -----
 * Registers:           32-bit          16-bit
 * Stopable timer:      Yes             No
 * Need to enable clk:  No              Yes
 * Halt on suspend:     Manual          Can be automatic
 */

#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/of_address.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/watchdog.h>


#define DRIVER_NAME "imx2-wdt"


#define IMX2_WDT_WCR		0x00		
/* Control Register */

#define IMX2_WDT_WCR_WT		(0xFF << 8)	
/* -> Watchdog Timeout Field */

#define IMX2_WDT_WCR_WDA	(1 << 5)	
/* -> External Reset WDOG_B */

#define IMX2_WDT_WCR_SRS	(1 << 4)	
/* -> Software Reset Signal */

#define IMX2_WDT_WCR_WRE	(1 << 3)	
/* -> WDOG Reset Enable */

#define IMX2_WDT_WCR_WDE	(1 << 2)	
/* -> Watchdog Enable */

#define IMX2_WDT_WCR_WDZST	(1 << 0)	
/* -> Watchdog timer Suspend */


#define IMX2_WDT_WSR		0x02		
/* Service Register */

#define IMX2_WDT_SEQ1		0x5555		
/* -> service sequence 1 */

#define IMX2_WDT_SEQ2		0xAAAA		
/* -> service sequence 2 */


#define IMX2_WDT_WRSR		0x04		
/* Reset Status Register */

#define IMX2_WDT_WRSR_TOUT	(1 << 1)	
/* -> Reset due to Timeout */


#define IMX2_WDT_WMCR		0x08		
/* Misc Register */


#define IMX2_WDT_MAX_TIME	128

#define IMX2_WDT_DEFAULT_TIME	60		
/* in seconds */


#define WDOG_SEC_TO_COUNT(s)	((s * 2 - 1) << 8)


struct imx2_wdt_device {
	
struct clk *clk;
	
struct regmap *regmap;
	
struct watchdog_device wdog;
	
bool ext_reset;
};


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 unsigned timeout = IMX2_WDT_DEFAULT_TIME;
module_param(timeout, uint, 0);
MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds (default="
				__MODULE_STRING(IMX2_WDT_DEFAULT_TIME) ")");


static const struct watchdog_info imx2_wdt_info = {
	.identity = "imx2+ watchdog",
	.options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE,
};



static int imx2_wdt_restart(struct watchdog_device *wdog, unsigned long action,
			    void *data)
{
	struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);
	unsigned int wcr_enable = IMX2_WDT_WCR_WDE;

	/* Use internal reset or external - not both */
	if (wdev->ext_reset)
		wcr_enable |= IMX2_WDT_WCR_SRS; /* do not assert int reset */
	else
		wcr_enable |= IMX2_WDT_WCR_WDA; /* do not assert ext-reset */

	/* Assert SRS signal */
	regmap_write(wdev->regmap, IMX2_WDT_WCR, wcr_enable);
	/*
         * Due to imx6q errata ERR004346 (WDOG: WDOG SRS bit requires to be
         * written twice), we add another two writes to ensure there must be at
         * least two writes happen in the same one 32kHz clock period.  We save
         * the target check here, since the writes shouldn't be a huge burden
         * for other platforms.
         */
	regmap_write(wdev->regmap, IMX2_WDT_WCR, wcr_enable);
	regmap_write(wdev->regmap, IMX2_WDT_WCR, wcr_enable);

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

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jingchang lu
jingchang lu
56
57.73%
1
20.00%
tim harvey
tim harvey
18
18.56%
1
20.00%
damien riegel
damien riegel
12
12.37%
1
20.00%
guenter roeck
guenter roeck
8
8.25%
1
20.00%
fabio estevam
fabio estevam
3
3.09%
1
20.00%
Total
97
100.00%
5
100.00%



static inline void imx2_wdt_setup(struct watchdog_device *wdog)
{
	struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);
	u32 val;

	regmap_read(wdev->regmap, IMX2_WDT_WCR, &val);

	/* Suspend timer in low power mode, write once-only */
	val |= IMX2_WDT_WCR_WDZST;
	/* Strip the old watchdog Time-Out value */
	val &= ~IMX2_WDT_WCR_WT;
	/* Generate internal chip-level reset if WDOG times out */
	if (!wdev->ext_reset)
		val &= ~IMX2_WDT_WCR_WRE;
	/* Or if external-reset assert WDOG_B reset only on time-out */
	else
		val |= IMX2_WDT_WCR_WRE;
	/* Keep Watchdog Disabled */
	val &= ~IMX2_WDT_WCR_WDE;
	/* Set the watchdog's Time-Out value */
	val |= WDOG_SEC_TO_COUNT(wdog->timeout);

	regmap_write(wdev->regmap, IMX2_WDT_WCR, val);

	/* enable the watchdog */
	val |= IMX2_WDT_WCR_WDE;
	regmap_write(wdev->regmap, IMX2_WDT_WCR, val);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
wolfram sang
wolfram sang
50
45.45%
1
20.00%
anatolij gustschin
anatolij gustschin
22
20.00%
1
20.00%
xiubo li
xiubo li
19
17.27%
1
20.00%
tim harvey
tim harvey
14
12.73%
1
20.00%
anson huang
anson huang
5
4.55%
1
20.00%
Total
110
100.00%
5
100.00%



static inline bool imx2_wdt_is_running(struct imx2_wdt_device *wdev)
{
	u32 val;

	regmap_read(wdev->regmap, IMX2_WDT_WCR, &val);

	return val & IMX2_WDT_WCR_WDE;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
anatolij gustschin
anatolij gustschin
30
93.75%
1
50.00%
wolfram sang
wolfram sang
2
6.25%
1
50.00%
Total
32
100.00%
2
100.00%



static int imx2_wdt_ping(struct watchdog_device *wdog)
{
	struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);

	regmap_write(wdev->regmap, IMX2_WDT_WSR, IMX2_WDT_SEQ1);
	regmap_write(wdev->regmap, IMX2_WDT_WSR, IMX2_WDT_SEQ2);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
anatolij gustschin
anatolij gustschin
23
50.00%
1
33.33%
wolfram sang
wolfram sang
13
28.26%
1
33.33%
xiubo li
xiubo li
10
21.74%
1
33.33%
Total
46
100.00%
3
100.00%



static int imx2_wdt_set_timeout(struct watchdog_device *wdog,
				unsigned int new_timeout)
{
	struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);

	wdog->timeout = new_timeout;

	regmap_update_bits(wdev->regmap, IMX2_WDT_WCR, IMX2_WDT_WCR_WT,
			   WDOG_SEC_TO_COUNT(new_timeout));
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
anatolij gustschin
anatolij gustschin
22
44.00%
1
25.00%
wolfram sang
wolfram sang
17
34.00%
1
25.00%
michael grzeschik
michael grzeschik
6
12.00%
1
25.00%
xiubo li
xiubo li
5
10.00%
1
25.00%
Total
50
100.00%
4
100.00%



static int imx2_wdt_start(struct watchdog_device *wdog)
{
	struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);

	if (imx2_wdt_is_running(wdev))
		imx2_wdt_set_timeout(wdog, wdog->timeout);
	else
		imx2_wdt_setup(wdog);

	set_bit(WDOG_HW_RUNNING, &wdog->status);

	return imx2_wdt_ping(wdog);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
anatolij gustschin
anatolij gustschin
31
52.54%
1
33.33%
wolfram sang
wolfram sang
21
35.59%
1
33.33%
guenter roeck
guenter roeck
7
11.86%
1
33.33%
Total
59
100.00%
3
100.00%


static const struct watchdog_ops imx2_wdt_ops = {
	.owner = THIS_MODULE,
	.start = imx2_wdt_start,
	.ping = imx2_wdt_ping,
	.set_timeout = imx2_wdt_set_timeout,
	.restart = imx2_wdt_restart,
};


static const struct regmap_config imx2_wdt_regmap_config = {
	.reg_bits = 16,
	.reg_stride = 2,
	.val_bits = 16,
	.max_register = 0x8,
};



static int __init imx2_wdt_probe(struct platform_device *pdev)
{
	struct imx2_wdt_device *wdev;
	struct watchdog_device *wdog;
	struct resource *res;
	void __iomem *base;
	int ret;
	u32 val;

	wdev = devm_kzalloc(&pdev->dev, sizeof(*wdev), GFP_KERNEL);
	if (!wdev)
		return -ENOMEM;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	base = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(base))
		return PTR_ERR(base);

	wdev->regmap = devm_regmap_init_mmio_clk(&pdev->dev, NULL, base,
						 &imx2_wdt_regmap_config);
	if (IS_ERR(wdev->regmap)) {
		dev_err(&pdev->dev, "regmap init failed\n");
		return PTR_ERR(wdev->regmap);
	}

	wdev->clk = devm_clk_get(&pdev->dev, NULL);
	if (IS_ERR(wdev->clk)) {
		dev_err(&pdev->dev, "can't get Watchdog clock\n");
		return PTR_ERR(wdev->clk);
	}

	wdog			= &wdev->wdog;
	wdog->info		= &imx2_wdt_info;
	wdog->ops		= &imx2_wdt_ops;
	wdog->min_timeout	= 1;
	wdog->max_hw_heartbeat_ms = IMX2_WDT_MAX_TIME * 1000;
	wdog->parent		= &pdev->dev;

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

	regmap_read(wdev->regmap, IMX2_WDT_WRSR, &val);
	wdog->bootstatus = val & IMX2_WDT_WRSR_TOUT ? WDIOF_CARDRESET : 0;

	wdev->ext_reset = of_property_read_bool(pdev->dev.of_node,
						"fsl,ext-reset-output");
	wdog->timeout = clamp_t(unsigned, timeout, 1, IMX2_WDT_MAX_TIME);
	if (wdog->timeout != timeout)
		dev_warn(&pdev->dev, "Initial timeout out of range! Clamped from %u to %u\n",
			 timeout, wdog->timeout);

	platform_set_drvdata(pdev, wdog);
	watchdog_set_drvdata(wdog, wdev);
	watchdog_set_nowayout(wdog, nowayout);
	watchdog_set_restart_priority(wdog, 128);
	watchdog_init_timeout(wdog, timeout, &pdev->dev);

	if (imx2_wdt_is_running(wdev)) {
		imx2_wdt_set_timeout(wdog, wdog->timeout);
		set_bit(WDOG_HW_RUNNING, &wdog->status);
	}

	/*
         * Disable the watchdog power down counter at boot. Otherwise the power
         * down counter will pull down the #WDOG interrupt line for one clock
         * cycle.
         */
	regmap_write(wdev->regmap, IMX2_WDT_WMCR, 0);

	ret = watchdog_register_device(wdog);
	if (ret) {
		dev_err(&pdev->dev, "cannot register watchdog device\n");
		goto disable_clk;
	}

	dev_info(&pdev->dev, "timeout %d sec (nowayout=%d)\n",
		 wdog->timeout, nowayout);

	return 0;

disable_clk:
	clk_disable_unprepare(wdev->clk);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
anatolij gustschin
anatolij gustschin
172
36.83%
1
7.69%
wolfram sang
wolfram sang
145
31.05%
1
7.69%
xiubo li
xiubo li
51
10.92%
1
7.69%
fabio estevam
fabio estevam
28
6.00%
3
23.08%
guenter roeck
guenter roeck
21
4.50%
1
7.69%
tim harvey
tim harvey
15
3.21%
1
7.69%
markus pargmann
markus pargmann
12
2.57%
1
7.69%
vladimir zapolskiy
vladimir zapolskiy
9
1.93%
1
7.69%
damien riegel
damien riegel
7
1.50%
1
7.69%
thierry reding
thierry reding
6
1.28%
1
7.69%
jingoo han
jingoo han
1
0.21%
1
7.69%
Total
467
100.00%
13
100.00%



static int __exit imx2_wdt_remove(struct platform_device *pdev)
{
	struct watchdog_device *wdog = platform_get_drvdata(pdev);
	struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);

	watchdog_unregister_device(wdog);

	if (imx2_wdt_is_running(wdev)) {
		imx2_wdt_ping(wdog);
		dev_crit(&pdev->dev, "Device removed: Expect reboot!\n");
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
anatolij gustschin
anatolij gustschin
33
51.56%
1
50.00%
wolfram sang
wolfram sang
31
48.44%
1
50.00%
Total
64
100.00%
2
100.00%



static void imx2_wdt_shutdown(struct platform_device *pdev)
{
	struct watchdog_device *wdog = platform_get_drvdata(pdev);
	struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);

	if (imx2_wdt_is_running(wdev)) {
		/*
                 * We are running, configure max timeout before reboot
                 * will take place.
                 */
		imx2_wdt_set_timeout(wdog, IMX2_WDT_MAX_TIME);
		imx2_wdt_ping(wdog);
		dev_crit(&pdev->dev, "Device shutdown: Expect reboot!\n");
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
wolfram sang
wolfram sang
31
49.21%
1
33.33%
anatolij gustschin
anatolij gustschin
31
49.21%
1
33.33%
guenter roeck
guenter roeck
1
1.59%
1
33.33%
Total
63
100.00%
3
100.00%

#ifdef CONFIG_PM_SLEEP
/* Disable watchdog if it is active or non-active but still running */


static int imx2_wdt_suspend(struct device *dev)
{
	struct watchdog_device *wdog = dev_get_drvdata(dev);
	struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);

	/* The watchdog IP block is running */
	if (imx2_wdt_is_running(wdev)) {
		imx2_wdt_set_timeout(wdog, IMX2_WDT_MAX_TIME);
		imx2_wdt_ping(wdog);
	}

	clk_disable_unprepare(wdev->clk);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
xiubo li
xiubo li
63
100.00%
2
100.00%
Total
63
100.00%
2
100.00%

/* Enable watchdog and configure it if necessary */


static int imx2_wdt_resume(struct device *dev)
{
	struct watchdog_device *wdog = dev_get_drvdata(dev);
	struct imx2_wdt_device *wdev = watchdog_get_drvdata(wdog);
	int ret;

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

	if (watchdog_active(wdog) && !imx2_wdt_is_running(wdev)) {
		/*
                 * If the watchdog is still active and resumes
                 * from deep sleep state, need to restart the
                 * watchdog again.
                 */
		imx2_wdt_setup(wdog);
	}
	if (imx2_wdt_is_running(wdev)) {
		imx2_wdt_set_timeout(wdog, wdog->timeout);
		imx2_wdt_ping(wdog);
	}

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
xiubo li
xiubo li
85
87.63%
2
66.67%
fabio estevam
fabio estevam
12
12.37%
1
33.33%
Total
97
100.00%
3
100.00%

#endif

static SIMPLE_DEV_PM_OPS(imx2_wdt_pm_ops, imx2_wdt_suspend,
			 imx2_wdt_resume);


static const struct of_device_id imx2_wdt_dt_ids[] = {
	{ .compatible = "fsl,imx21-wdt", },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, imx2_wdt_dt_ids);


static struct platform_driver imx2_wdt_driver = {
	.remove		= __exit_p(imx2_wdt_remove),
	.shutdown	= imx2_wdt_shutdown,
	.driver		= {
		.name	= DRIVER_NAME,
		.pm     = &imx2_wdt_pm_ops,
		.of_match_table = imx2_wdt_dt_ids,
        },
};

module_platform_driver_probe(imx2_wdt_driver, imx2_wdt_probe);

MODULE_AUTHOR("Wolfram Sang");
MODULE_DESCRIPTION("Watchdog driver for IMX2 and later");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:" DRIVER_NAME);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
wolfram sang
wolfram sang
544
35.35%
1
3.57%
anatolij gustschin
anatolij gustschin
377
24.50%
1
3.57%
xiubo li
xiubo li
300
19.49%
5
17.86%
tim harvey
tim harvey
60
3.90%
1
3.57%
jingchang lu
jingchang lu
59
3.83%
1
3.57%
fabio estevam
fabio estevam
43
2.79%
4
14.29%
guenter roeck
guenter roeck
37
2.40%
2
7.14%
damien riegel
damien riegel
24
1.56%
1
3.57%
shawn guo
shawn guo
23
1.49%
1
3.57%
markus pargmann
markus pargmann
17
1.10%
1
3.57%
anson huang
anson huang
11
0.71%
1
3.57%
oskar schirmer
oskar schirmer
10
0.65%
1
3.57%
vladimir zapolskiy
vladimir zapolskiy
9
0.58%
1
3.57%
niels de vos
niels de vos
7
0.45%
1
3.57%
thierry reding
thierry reding
6
0.39%
1
3.57%
michael grzeschik
michael grzeschik
6
0.39%
1
3.57%
wim van sebroeck
wim van sebroeck
2
0.13%
1
3.57%
krzysztof kozlowski
krzysztof kozlowski
2
0.13%
1
3.57%
jingoo han
jingoo han
1
0.06%
1
3.57%
fabio porcedda
fabio porcedda
1
0.06%
1
3.57%
Total
1539
100.00%
28
100.00%
  
Directory: drivers/watchdog

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