]>
Commit | Line | Data |
---|---|---|
e7bf0289 KH |
1 | /* |
2 | * Watchdog driver for the UniPhier watchdog timer | |
3 | * | |
4 | * (c) Copyright 2014 Panasonic Corporation | |
5 | * (c) Copyright 2016 Socionext Inc. | |
6 | * All rights reserved. | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | */ | |
17 | ||
18 | #include <linux/bitops.h> | |
19 | #include <linux/mfd/syscon.h> | |
20 | #include <linux/module.h> | |
21 | #include <linux/of.h> | |
22 | #include <linux/platform_device.h> | |
23 | #include <linux/regmap.h> | |
24 | #include <linux/watchdog.h> | |
25 | ||
26 | /* WDT timer setting register */ | |
27 | #define WDTTIMSET 0x3004 | |
28 | #define WDTTIMSET_PERIOD_MASK (0xf << 0) | |
29 | #define WDTTIMSET_PERIOD_1_SEC (0x3 << 0) | |
30 | ||
31 | /* WDT reset selection register */ | |
32 | #define WDTRSTSEL 0x3008 | |
33 | #define WDTRSTSEL_RSTSEL_MASK (0x3 << 0) | |
34 | #define WDTRSTSEL_RSTSEL_BOTH (0x0 << 0) | |
35 | #define WDTRSTSEL_RSTSEL_IRQ_ONLY (0x2 << 0) | |
36 | ||
37 | /* WDT control register */ | |
38 | #define WDTCTRL 0x300c | |
39 | #define WDTCTRL_STATUS BIT(8) | |
40 | #define WDTCTRL_CLEAR BIT(1) | |
41 | #define WDTCTRL_ENABLE BIT(0) | |
42 | ||
43 | #define SEC_TO_WDTTIMSET_PRD(sec) \ | |
44 | (ilog2(sec) + WDTTIMSET_PERIOD_1_SEC) | |
45 | ||
46 | #define WDTST_TIMEOUT 1000 /* usec */ | |
47 | ||
48 | #define WDT_DEFAULT_TIMEOUT 64 /* Default is 64 seconds */ | |
49 | #define WDT_PERIOD_MIN 1 | |
50 | #define WDT_PERIOD_MAX 128 | |
51 | ||
52 | static unsigned int timeout = 0; | |
53 | static bool nowayout = WATCHDOG_NOWAYOUT; | |
54 | ||
55 | struct uniphier_wdt_dev { | |
56 | struct watchdog_device wdt_dev; | |
57 | struct regmap *regmap; | |
58 | }; | |
59 | ||
60 | /* | |
61 | * UniPhier Watchdog operations | |
62 | */ | |
63 | static int uniphier_watchdog_ping(struct watchdog_device *w) | |
64 | { | |
65 | struct uniphier_wdt_dev *wdev = watchdog_get_drvdata(w); | |
66 | unsigned int val; | |
67 | int ret; | |
68 | ||
69 | /* Clear counter */ | |
70 | ret = regmap_write_bits(wdev->regmap, WDTCTRL, | |
71 | WDTCTRL_CLEAR, WDTCTRL_CLEAR); | |
72 | if (!ret) | |
73 | /* | |
74 | * As SoC specification, after clear counter, | |
75 | * it needs to wait until counter status is 1. | |
76 | */ | |
77 | ret = regmap_read_poll_timeout(wdev->regmap, WDTCTRL, val, | |
78 | (val & WDTCTRL_STATUS), | |
79 | 0, WDTST_TIMEOUT); | |
80 | ||
81 | return ret; | |
82 | } | |
83 | ||
84 | static int __uniphier_watchdog_start(struct regmap *regmap, unsigned int sec) | |
85 | { | |
86 | unsigned int val; | |
87 | int ret; | |
88 | ||
89 | ret = regmap_read_poll_timeout(regmap, WDTCTRL, val, | |
90 | !(val & WDTCTRL_STATUS), | |
91 | 0, WDTST_TIMEOUT); | |
92 | if (ret) | |
93 | return ret; | |
94 | ||
95 | /* Setup period */ | |
96 | ret = regmap_write(regmap, WDTTIMSET, | |
97 | SEC_TO_WDTTIMSET_PRD(sec)); | |
98 | if (ret) | |
99 | return ret; | |
100 | ||
101 | /* Enable and clear watchdog */ | |
102 | ret = regmap_write(regmap, WDTCTRL, WDTCTRL_ENABLE | WDTCTRL_CLEAR); | |
103 | if (!ret) | |
104 | /* | |
105 | * As SoC specification, after clear counter, | |
106 | * it needs to wait until counter status is 1. | |
107 | */ | |
108 | ret = regmap_read_poll_timeout(regmap, WDTCTRL, val, | |
109 | (val & WDTCTRL_STATUS), | |
110 | 0, WDTST_TIMEOUT); | |
111 | ||
112 | return ret; | |
113 | } | |
114 | ||
115 | static int __uniphier_watchdog_stop(struct regmap *regmap) | |
116 | { | |
117 | /* Disable and stop watchdog */ | |
118 | return regmap_write_bits(regmap, WDTCTRL, WDTCTRL_ENABLE, 0); | |
119 | } | |
120 | ||
121 | static int __uniphier_watchdog_restart(struct regmap *regmap, unsigned int sec) | |
122 | { | |
123 | int ret; | |
124 | ||
125 | ret = __uniphier_watchdog_stop(regmap); | |
126 | if (ret) | |
127 | return ret; | |
128 | ||
129 | return __uniphier_watchdog_start(regmap, sec); | |
130 | } | |
131 | ||
132 | static int uniphier_watchdog_start(struct watchdog_device *w) | |
133 | { | |
134 | struct uniphier_wdt_dev *wdev = watchdog_get_drvdata(w); | |
135 | unsigned int tmp_timeout; | |
136 | ||
137 | tmp_timeout = roundup_pow_of_two(w->timeout); | |
138 | ||
139 | return __uniphier_watchdog_start(wdev->regmap, tmp_timeout); | |
140 | } | |
141 | ||
142 | static int uniphier_watchdog_stop(struct watchdog_device *w) | |
143 | { | |
144 | struct uniphier_wdt_dev *wdev = watchdog_get_drvdata(w); | |
145 | ||
146 | return __uniphier_watchdog_stop(wdev->regmap); | |
147 | } | |
148 | ||
149 | static int uniphier_watchdog_set_timeout(struct watchdog_device *w, | |
150 | unsigned int t) | |
151 | { | |
152 | struct uniphier_wdt_dev *wdev = watchdog_get_drvdata(w); | |
153 | unsigned int tmp_timeout; | |
154 | int ret; | |
155 | ||
156 | tmp_timeout = roundup_pow_of_two(t); | |
157 | if (tmp_timeout == w->timeout) | |
158 | return 0; | |
159 | ||
160 | if (watchdog_active(w)) { | |
161 | ret = __uniphier_watchdog_restart(wdev->regmap, tmp_timeout); | |
162 | if (ret) | |
163 | return ret; | |
164 | } | |
165 | ||
166 | w->timeout = tmp_timeout; | |
167 | ||
168 | return 0; | |
169 | } | |
170 | ||
171 | /* | |
172 | * Kernel Interfaces | |
173 | */ | |
174 | static const struct watchdog_info uniphier_wdt_info = { | |
175 | .identity = "uniphier-wdt", | |
176 | .options = WDIOF_SETTIMEOUT | | |
177 | WDIOF_KEEPALIVEPING | | |
178 | WDIOF_MAGICCLOSE | | |
179 | WDIOF_OVERHEAT, | |
180 | }; | |
181 | ||
182 | static const struct watchdog_ops uniphier_wdt_ops = { | |
183 | .owner = THIS_MODULE, | |
184 | .start = uniphier_watchdog_start, | |
185 | .stop = uniphier_watchdog_stop, | |
186 | .ping = uniphier_watchdog_ping, | |
187 | .set_timeout = uniphier_watchdog_set_timeout, | |
188 | }; | |
189 | ||
190 | static int uniphier_wdt_probe(struct platform_device *pdev) | |
191 | { | |
192 | struct device *dev = &pdev->dev; | |
193 | struct uniphier_wdt_dev *wdev; | |
194 | struct regmap *regmap; | |
195 | struct device_node *parent; | |
196 | int ret; | |
197 | ||
198 | wdev = devm_kzalloc(dev, sizeof(*wdev), GFP_KERNEL); | |
199 | if (!wdev) | |
200 | return -ENOMEM; | |
201 | ||
202 | platform_set_drvdata(pdev, wdev); | |
203 | ||
204 | parent = of_get_parent(dev->of_node); /* parent should be syscon node */ | |
205 | regmap = syscon_node_to_regmap(parent); | |
206 | of_node_put(parent); | |
207 | if (IS_ERR(regmap)) | |
208 | return PTR_ERR(regmap); | |
209 | ||
210 | wdev->regmap = regmap; | |
211 | wdev->wdt_dev.info = &uniphier_wdt_info; | |
212 | wdev->wdt_dev.ops = &uniphier_wdt_ops; | |
213 | wdev->wdt_dev.max_timeout = WDT_PERIOD_MAX; | |
214 | wdev->wdt_dev.min_timeout = WDT_PERIOD_MIN; | |
215 | wdev->wdt_dev.parent = dev; | |
216 | ||
217 | if (watchdog_init_timeout(&wdev->wdt_dev, timeout, dev) < 0) { | |
218 | wdev->wdt_dev.timeout = WDT_DEFAULT_TIMEOUT; | |
219 | } | |
220 | watchdog_set_nowayout(&wdev->wdt_dev, nowayout); | |
221 | watchdog_stop_on_reboot(&wdev->wdt_dev); | |
222 | ||
223 | watchdog_set_drvdata(&wdev->wdt_dev, wdev); | |
224 | ||
225 | uniphier_watchdog_stop(&wdev->wdt_dev); | |
226 | ret = regmap_write(wdev->regmap, WDTRSTSEL, WDTRSTSEL_RSTSEL_BOTH); | |
227 | if (ret) | |
228 | return ret; | |
229 | ||
230 | ret = devm_watchdog_register_device(dev, &wdev->wdt_dev); | |
231 | if (ret) | |
232 | return ret; | |
233 | ||
234 | dev_info(dev, "watchdog driver (timeout=%d sec, nowayout=%d)\n", | |
235 | wdev->wdt_dev.timeout, nowayout); | |
236 | ||
237 | return 0; | |
238 | } | |
239 | ||
240 | static const struct of_device_id uniphier_wdt_dt_ids[] = { | |
241 | { .compatible = "socionext,uniphier-wdt" }, | |
242 | { /* sentinel */ } | |
243 | }; | |
244 | MODULE_DEVICE_TABLE(of, uniphier_wdt_dt_ids); | |
245 | ||
246 | static struct platform_driver uniphier_wdt_driver = { | |
247 | .probe = uniphier_wdt_probe, | |
248 | .driver = { | |
249 | .name = "uniphier-wdt", | |
250 | .of_match_table = uniphier_wdt_dt_ids, | |
251 | }, | |
252 | }; | |
253 | ||
254 | module_platform_driver(uniphier_wdt_driver); | |
255 | ||
256 | module_param(timeout, uint, 0000); | |
257 | MODULE_PARM_DESC(timeout, | |
258 | "Watchdog timeout seconds in power of 2. (0 < timeout < 128, default=" | |
259 | __MODULE_STRING(WDT_DEFAULT_TIMEOUT) ")"); | |
260 | ||
261 | module_param(nowayout, bool, 0000); | |
262 | MODULE_PARM_DESC(nowayout, | |
263 | "Watchdog cannot be stopped once started (default=" | |
264 | __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); | |
265 | ||
266 | MODULE_AUTHOR("Keiji Hayashibara <hayashibara.keiji@socionext.com>"); | |
267 | MODULE_DESCRIPTION("UniPhier Watchdog Device Driver"); | |
268 | MODULE_LICENSE("GPL v2"); |