1
2
3
4
5
6
7
8
9
10
11#include <linux/bitops.h>
12#include <linux/clk.h>
13#include <linux/delay.h>
14#include <linux/io.h>
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/moduleparam.h>
18#include <linux/notifier.h>
19#include <linux/platform_device.h>
20#include <linux/reboot.h>
21#include <linux/watchdog.h>
22
23#define DEFAULT_TIMEOUT 30
24
25static bool nowayout = WATCHDOG_NOWAYOUT;
26module_param(nowayout, bool, 0);
27MODULE_PARM_DESC(nowayout,
28 "Watchdog cannot be stopped once started (default="
29 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
30
31static unsigned int timeout;
32module_param(timeout, int, 0);
33MODULE_PARM_DESC(timeout, "Watchdog timeout");
34
35
36
37
38
39#define WD_COUNTER 0
40
41#define WD_CONFIG 4
42#define WD_CONFIG_XTAL_IN BIT(0)
43#define WD_CONFIG_DISABLE BIT(31)
44
45struct tangox_wdt_device {
46 struct watchdog_device wdt;
47 void __iomem *base;
48 unsigned long clk_rate;
49 struct clk *clk;
50 struct notifier_block restart;
51};
52
53static int tangox_wdt_set_timeout(struct watchdog_device *wdt,
54 unsigned int new_timeout)
55{
56 wdt->timeout = new_timeout;
57
58 return 0;
59}
60
61static int tangox_wdt_start(struct watchdog_device *wdt)
62{
63 struct tangox_wdt_device *dev = watchdog_get_drvdata(wdt);
64 u32 ticks;
65
66 ticks = 1 + wdt->timeout * dev->clk_rate;
67 writel(ticks, dev->base + WD_COUNTER);
68
69 return 0;
70}
71
72static int tangox_wdt_stop(struct watchdog_device *wdt)
73{
74 struct tangox_wdt_device *dev = watchdog_get_drvdata(wdt);
75
76 writel(0, dev->base + WD_COUNTER);
77
78 return 0;
79}
80
81static unsigned int tangox_wdt_get_timeleft(struct watchdog_device *wdt)
82{
83 struct tangox_wdt_device *dev = watchdog_get_drvdata(wdt);
84 u32 count;
85
86 count = readl(dev->base + WD_COUNTER);
87
88 if (!count)
89 return 0;
90
91 return (count - 1) / dev->clk_rate;
92}
93
94static const struct watchdog_info tangox_wdt_info = {
95 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
96 .identity = "tangox watchdog",
97};
98
99static const struct watchdog_ops tangox_wdt_ops = {
100 .start = tangox_wdt_start,
101 .stop = tangox_wdt_stop,
102 .set_timeout = tangox_wdt_set_timeout,
103 .get_timeleft = tangox_wdt_get_timeleft,
104};
105
106static int tangox_wdt_restart(struct notifier_block *nb, unsigned long action,
107 void *data)
108{
109 struct tangox_wdt_device *dev =
110 container_of(nb, struct tangox_wdt_device, restart);
111
112 writel(1, dev->base + WD_COUNTER);
113
114 return NOTIFY_DONE;
115}
116
117static int tangox_wdt_probe(struct platform_device *pdev)
118{
119 struct tangox_wdt_device *dev;
120 struct resource *res;
121 u32 config;
122 int err;
123
124 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
125 if (!dev)
126 return -ENOMEM;
127
128 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
129 dev->base = devm_ioremap_resource(&pdev->dev, res);
130 if (IS_ERR(dev->base))
131 return PTR_ERR(dev->base);
132
133 dev->clk = devm_clk_get(&pdev->dev, NULL);
134 if (IS_ERR(dev->clk))
135 return PTR_ERR(dev->clk);
136
137 err = clk_prepare_enable(dev->clk);
138 if (err)
139 return err;
140
141 dev->clk_rate = clk_get_rate(dev->clk);
142 if (!dev->clk_rate) {
143 err = -EINVAL;
144 goto err;
145 }
146
147 dev->wdt.parent = &pdev->dev;
148 dev->wdt.info = &tangox_wdt_info;
149 dev->wdt.ops = &tangox_wdt_ops;
150 dev->wdt.timeout = DEFAULT_TIMEOUT;
151 dev->wdt.min_timeout = 1;
152 dev->wdt.max_timeout = (U32_MAX - 1) / dev->clk_rate;
153
154 watchdog_init_timeout(&dev->wdt, timeout, &pdev->dev);
155 watchdog_set_nowayout(&dev->wdt, nowayout);
156 watchdog_set_drvdata(&dev->wdt, dev);
157
158
159
160
161
162 config = readl(dev->base + WD_CONFIG);
163 if (config & WD_CONFIG_DISABLE)
164 writel(0, dev->base + WD_COUNTER);
165
166 writel(WD_CONFIG_XTAL_IN, dev->base + WD_CONFIG);
167
168
169
170
171
172 if (readl(dev->base + WD_COUNTER)) {
173 set_bit(WDOG_ACTIVE, &dev->wdt.status);
174 tangox_wdt_start(&dev->wdt);
175 }
176
177 err = watchdog_register_device(&dev->wdt);
178 if (err)
179 goto err;
180
181 platform_set_drvdata(pdev, dev);
182
183 dev->restart.notifier_call = tangox_wdt_restart;
184 dev->restart.priority = 128;
185 err = register_restart_handler(&dev->restart);
186 if (err)
187 dev_warn(&pdev->dev, "failed to register restart handler\n");
188
189 dev_info(&pdev->dev, "SMP86xx/SMP87xx watchdog registered\n");
190
191 return 0;
192
193 err:
194 clk_disable_unprepare(dev->clk);
195 return err;
196}
197
198static int tangox_wdt_remove(struct platform_device *pdev)
199{
200 struct tangox_wdt_device *dev = platform_get_drvdata(pdev);
201
202 tangox_wdt_stop(&dev->wdt);
203 clk_disable_unprepare(dev->clk);
204
205 unregister_restart_handler(&dev->restart);
206 watchdog_unregister_device(&dev->wdt);
207
208 return 0;
209}
210
211static const struct of_device_id tangox_wdt_dt_ids[] = {
212 { .compatible = "sigma,smp8642-wdt" },
213 { .compatible = "sigma,smp8759-wdt" },
214 { }
215};
216MODULE_DEVICE_TABLE(of, tangox_wdt_dt_ids);
217
218static struct platform_driver tangox_wdt_driver = {
219 .probe = tangox_wdt_probe,
220 .remove = tangox_wdt_remove,
221 .driver = {
222 .name = "tangox-wdt",
223 .of_match_table = tangox_wdt_dt_ids,
224 },
225};
226
227module_platform_driver(tangox_wdt_driver);
228
229MODULE_AUTHOR("Mans Rullgard <mans@mansr.com>");
230MODULE_DESCRIPTION("SMP86xx/SMP87xx Watchdog driver");
231MODULE_LICENSE("GPL");
232
