orion_wdt.c 5.2 KB
Newer Older
1
/*
2
 * drivers/watchdog/orion_wdt.c
3
 *
4
 * Watchdog driver for Orion/Kirkwood processors
5 6 7 8 9 10 11 12
 *
 * Author: Sylver Bruneau <sylver.bruneau@googlemail.com>
 *
 * This file is licensed under  the terms of the GNU General Public
 * License version 2. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

13 14
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

15 16 17 18
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/types.h>
#include <linux/kernel.h>
19
#include <linux/platform_device.h>
20 21
#include <linux/watchdog.h>
#include <linux/io.h>
22
#include <linux/spinlock.h>
23
#include <linux/clk.h>
24
#include <linux/err.h>
25
#include <linux/of.h>
26
#include <mach/bridge-regs.h>
27 28 29 30

/*
 * Watchdog timer block registers.
 */
31
#define TIMER_CTRL		0x0000
32
#define WDT_EN			0x0010
33
#define WDT_VAL			0x0024
34

35
#define WDT_MAX_CYCLE_COUNT	0xffffffff
36 37 38
#define WDT_IN_USE		0
#define WDT_OK_TO_CLOSE		1

39 40 41
#define WDT_RESET_OUT_EN	BIT(1)
#define WDT_INT_REQ		BIT(3)

W
Wim Van Sebroeck 已提交
42
static bool nowayout = WATCHDOG_NOWAYOUT;
43 44
static int heartbeat = -1;		/* module parameter (seconds) */
static unsigned int wdt_max_duration;	/* (seconds) */
45
static struct clk *clk;
46
static unsigned int wdt_tclk;
47
static void __iomem *wdt_reg;
48
static DEFINE_SPINLOCK(wdt_lock);
49

50
static int orion_wdt_ping(struct watchdog_device *wdt_dev)
51 52 53 54
{
	spin_lock(&wdt_lock);

	/* Reload watchdog duration */
55
	writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
56 57

	spin_unlock(&wdt_lock);
58
	return 0;
59 60
}

61
static int orion_wdt_start(struct watchdog_device *wdt_dev)
62 63 64
{
	u32 reg;

65 66
	spin_lock(&wdt_lock);

67
	/* Set watchdog duration */
68
	writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
69 70

	/* Clear watchdog timer interrupt */
71
	writel(~WDT_INT_REQ, BRIDGE_CAUSE);
72 73

	/* Enable watchdog timer */
74
	reg = readl(wdt_reg + TIMER_CTRL);
75
	reg |= WDT_EN;
76
	writel(reg, wdt_reg + TIMER_CTRL);
77 78

	/* Enable reset on watchdog */
79 80 81
	reg = readl(RSTOUTn_MASK);
	reg |= WDT_RESET_OUT_EN;
	writel(reg, RSTOUTn_MASK);
82 83

	spin_unlock(&wdt_lock);
84
	return 0;
85 86
}

87
static int orion_wdt_stop(struct watchdog_device *wdt_dev)
88 89 90
{
	u32 reg;

91 92
	spin_lock(&wdt_lock);

93
	/* Disable reset on watchdog */
94 95 96
	reg = readl(RSTOUTn_MASK);
	reg &= ~WDT_RESET_OUT_EN;
	writel(reg, RSTOUTn_MASK);
97 98

	/* Disable watchdog timer */
99
	reg = readl(wdt_reg + TIMER_CTRL);
100
	reg &= ~WDT_EN;
101
	writel(reg, wdt_reg + TIMER_CTRL);
102 103

	spin_unlock(&wdt_lock);
104
	return 0;
105 106
}

107
static unsigned int orion_wdt_get_timeleft(struct watchdog_device *wdt_dev)
108
{
109 110
	unsigned int time_left;

111
	spin_lock(&wdt_lock);
112
	time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
113
	spin_unlock(&wdt_lock);
114

115
	return time_left;
116 117
}

118 119
static int orion_wdt_set_timeout(struct watchdog_device *wdt_dev,
				 unsigned int timeout)
120
{
121
	wdt_dev->timeout = timeout;
122 123 124
	return 0;
}

125 126 127
static const struct watchdog_info orion_wdt_info = {
	.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
	.identity = "Orion Watchdog",
128 129
};

130 131 132 133 134 135 136
static const struct watchdog_ops orion_wdt_ops = {
	.owner = THIS_MODULE,
	.start = orion_wdt_start,
	.stop = orion_wdt_stop,
	.ping = orion_wdt_ping,
	.set_timeout = orion_wdt_set_timeout,
	.get_timeleft = orion_wdt_get_timeleft,
137 138
};

139 140 141
static struct watchdog_device orion_wdt = {
	.info = &orion_wdt_info,
	.ops = &orion_wdt_ops,
142
	.min_timeout = 1,
143 144
};

B
Bill Pemberton 已提交
145
static int orion_wdt_probe(struct platform_device *pdev)
146
{
147
	struct resource *res;
148 149
	int ret;

150
	clk = devm_clk_get(&pdev->dev, NULL);
151
	if (IS_ERR(clk)) {
152
		dev_err(&pdev->dev, "Orion Watchdog missing clock\n");
153 154
		return -ENODEV;
	}
155 156
	clk_prepare_enable(clk);
	wdt_tclk = clk_get_rate(clk);
157

158
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
159 160
	if (!res)
		return -ENODEV;
161 162 163
	wdt_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res));
	if (!wdt_reg)
		return -ENOMEM;
164 165

	wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
166

167
	orion_wdt.timeout = wdt_max_duration;
168
	orion_wdt.max_timeout = wdt_max_duration;
169
	watchdog_init_timeout(&orion_wdt, heartbeat, &pdev->dev);
170 171 172 173 174

	watchdog_set_nowayout(&orion_wdt, nowayout);
	ret = watchdog_register_device(&orion_wdt);
	if (ret) {
		clk_disable_unprepare(clk);
175
		return ret;
176
	}
177

178
	pr_info("Initial timeout %d sec%s\n",
179
		orion_wdt.timeout, nowayout ? ", nowayout" : "");
180 181 182
	return 0;
}

B
Bill Pemberton 已提交
183
static int orion_wdt_remove(struct platform_device *pdev)
184
{
185
	watchdog_unregister_device(&orion_wdt);
186
	clk_disable_unprepare(clk);
187
	return 0;
188 189
}

190
static void orion_wdt_shutdown(struct platform_device *pdev)
191
{
192
	orion_wdt_stop(&orion_wdt);
193 194
}

195
static const struct of_device_id orion_wdt_of_match_table[] = {
196 197 198 199 200
	{ .compatible = "marvell,orion-wdt", },
	{},
};
MODULE_DEVICE_TABLE(of, orion_wdt_of_match_table);

201 202
static struct platform_driver orion_wdt_driver = {
	.probe		= orion_wdt_probe,
203
	.remove		= orion_wdt_remove,
204
	.shutdown	= orion_wdt_shutdown,
205 206
	.driver		= {
		.owner	= THIS_MODULE,
207
		.name	= "orion_wdt",
208
		.of_match_table = orion_wdt_of_match_table,
209 210 211
	},
};

212
module_platform_driver(orion_wdt_driver);
213 214

MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
215
MODULE_DESCRIPTION("Orion Processor Watchdog");
216 217

module_param(heartbeat, int, 0);
218
MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
219

W
Wim Van Sebroeck 已提交
220
module_param(nowayout, bool, 0);
221 222
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
				__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
223 224

MODULE_LICENSE("GPL");
225
MODULE_ALIAS("platform:orion_wdt");