1
2
3
4
5
6
7
8
9
10
11
12
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15#include <linux/module.h>
16#include <linux/moduleparam.h>
17#include <linux/types.h>
18#include <linux/kernel.h>
19#include <linux/miscdevice.h>
20#include <linux/platform_device.h>
21#include <linux/watchdog.h>
22#include <linux/init.h>
23#include <linux/io.h>
24#include <linux/spinlock.h>
25#include <linux/clk.h>
26#include <linux/err.h>
27#include <linux/of.h>
28#include <mach/bridge-regs.h>
29
30
31
32
33#define TIMER_CTRL 0x0000
34#define WDT_EN 0x0010
35#define WDT_VAL 0x0024
36
37#define WDT_MAX_CYCLE_COUNT 0xffffffff
38#define WDT_IN_USE 0
39#define WDT_OK_TO_CLOSE 1
40
41static bool nowayout = WATCHDOG_NOWAYOUT;
42static int heartbeat = -1;
43static unsigned int wdt_max_duration;
44static struct clk *clk;
45static unsigned int wdt_tclk;
46static void __iomem *wdt_reg;
47static DEFINE_SPINLOCK(wdt_lock);
48
49static int orion_wdt_ping(struct watchdog_device *wdt_dev)
50{
51 spin_lock(&wdt_lock);
52
53
54 writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
55
56 spin_unlock(&wdt_lock);
57 return 0;
58}
59
60static int orion_wdt_start(struct watchdog_device *wdt_dev)
61{
62 u32 reg;
63
64 spin_lock(&wdt_lock);
65
66
67 writel(wdt_tclk * wdt_dev->timeout, wdt_reg + WDT_VAL);
68
69
70 reg = readl(BRIDGE_CAUSE);
71 reg &= ~WDT_INT_REQ;
72 writel(reg, BRIDGE_CAUSE);
73
74
75 reg = readl(wdt_reg + TIMER_CTRL);
76 reg |= WDT_EN;
77 writel(reg, wdt_reg + TIMER_CTRL);
78
79
80 reg = readl(RSTOUTn_MASK);
81 reg |= WDT_RESET_OUT_EN;
82 writel(reg, RSTOUTn_MASK);
83
84 spin_unlock(&wdt_lock);
85 return 0;
86}
87
88static int orion_wdt_stop(struct watchdog_device *wdt_dev)
89{
90 u32 reg;
91
92 spin_lock(&wdt_lock);
93
94
95 reg = readl(RSTOUTn_MASK);
96 reg &= ~WDT_RESET_OUT_EN;
97 writel(reg, RSTOUTn_MASK);
98
99
100 reg = readl(wdt_reg + TIMER_CTRL);
101 reg &= ~WDT_EN;
102 writel(reg, wdt_reg + TIMER_CTRL);
103
104 spin_unlock(&wdt_lock);
105 return 0;
106}
107
108static unsigned int orion_wdt_get_timeleft(struct watchdog_device *wdt_dev)
109{
110 unsigned int time_left;
111
112 spin_lock(&wdt_lock);
113 time_left = readl(wdt_reg + WDT_VAL) / wdt_tclk;
114 spin_unlock(&wdt_lock);
115
116 return time_left;
117}
118
119static int orion_wdt_set_timeout(struct watchdog_device *wdt_dev,
120 unsigned int timeout)
121{
122 wdt_dev->timeout = timeout;
123 return 0;
124}
125
126static const struct watchdog_info orion_wdt_info = {
127 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
128 .identity = "Orion Watchdog",
129};
130
131static const struct watchdog_ops orion_wdt_ops = {
132 .owner = THIS_MODULE,
133 .start = orion_wdt_start,
134 .stop = orion_wdt_stop,
135 .ping = orion_wdt_ping,
136 .set_timeout = orion_wdt_set_timeout,
137 .get_timeleft = orion_wdt_get_timeleft,
138};
139
140static struct watchdog_device orion_wdt = {
141 .info = &orion_wdt_info,
142 .ops = &orion_wdt_ops,
143 .min_timeout = 1,
144};
145
146static int orion_wdt_probe(struct platform_device *pdev)
147{
148 struct resource *res;
149 int ret;
150
151 clk = devm_clk_get(&pdev->dev, NULL);
152 if (IS_ERR(clk)) {
153 dev_err(&pdev->dev, "Orion Watchdog missing clock\n");
154 return -ENODEV;
155 }
156 clk_prepare_enable(clk);
157 wdt_tclk = clk_get_rate(clk);
158
159 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
160 if (!res)
161 return -ENODEV;
162 wdt_reg = devm_ioremap(&pdev->dev, res->start, resource_size(res));
163 if (!wdt_reg)
164 return -ENOMEM;
165
166 wdt_max_duration = WDT_MAX_CYCLE_COUNT / wdt_tclk;
167
168 orion_wdt.timeout = wdt_max_duration;
169 orion_wdt.max_timeout = wdt_max_duration;
170 watchdog_init_timeout(&orion_wdt, heartbeat, &pdev->dev);
171
172 watchdog_set_nowayout(&orion_wdt, nowayout);
173 ret = watchdog_register_device(&orion_wdt);
174 if (ret) {
175 clk_disable_unprepare(clk);
176 return ret;
177 }
178
179 pr_info("Initial timeout %d sec%s\n",
180 orion_wdt.timeout, nowayout ? ", nowayout" : "");
181 return 0;
182}
183
184static int orion_wdt_remove(struct platform_device *pdev)
185{
186 watchdog_unregister_device(&orion_wdt);
187 clk_disable_unprepare(clk);
188 return 0;
189}
190
191static void orion_wdt_shutdown(struct platform_device *pdev)
192{
193 orion_wdt_stop(&orion_wdt);
194}
195
196static const struct of_device_id orion_wdt_of_match_table[] = {
197 { .compatible = "marvell,orion-wdt", },
198 {},
199};
200MODULE_DEVICE_TABLE(of, orion_wdt_of_match_table);
201
202static struct platform_driver orion_wdt_driver = {
203 .probe = orion_wdt_probe,
204 .remove = orion_wdt_remove,
205 .shutdown = orion_wdt_shutdown,
206 .driver = {
207 .owner = THIS_MODULE,
208 .name = "orion_wdt",
209 .of_match_table = of_match_ptr(orion_wdt_of_match_table),
210 },
211};
212
213module_platform_driver(orion_wdt_driver);
214
215MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
216MODULE_DESCRIPTION("Orion Processor Watchdog");
217
218module_param(heartbeat, int, 0);
219MODULE_PARM_DESC(heartbeat, "Initial watchdog heartbeat in seconds");
220
221module_param(nowayout, bool, 0);
222MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
223 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
224
225MODULE_LICENSE("GPL");
226MODULE_ALIAS("platform:orion_wdt");
227MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
228
