Merge remote-tracking branch 'stable/linux-5.15.y' into rpi-5.15.y
[platform/kernel/linux-rpi.git] / drivers / watchdog / asm9260_wdt.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Watchdog driver for Alphascale ASM9260.
4  *
5  * Copyright (c) 2014 Oleksij Rempel <linux@rempel-privat.de>
6  */
7
8 #include <linux/bitops.h>
9 #include <linux/clk.h>
10 #include <linux/delay.h>
11 #include <linux/interrupt.h>
12 #include <linux/io.h>
13 #include <linux/module.h>
14 #include <linux/of.h>
15 #include <linux/platform_device.h>
16 #include <linux/reset.h>
17 #include <linux/watchdog.h>
18
19 #define CLOCK_FREQ      1000000
20
21 /* Watchdog Mode register */
22 #define HW_WDMOD                        0x00
23 /* Wake interrupt. Set by HW, can't be cleared. */
24 #define BM_MOD_WDINT                    BIT(3)
25 /* This bit set if timeout reached. Cleared by SW. */
26 #define BM_MOD_WDTOF                    BIT(2)
27 /* HW Reset on timeout */
28 #define BM_MOD_WDRESET                  BIT(1)
29 /* WD enable */
30 #define BM_MOD_WDEN                     BIT(0)
31
32 /*
33  * Watchdog Timer Constant register
34  * Minimal value is 0xff, the meaning of this value
35  * depends on used clock: T = WDCLK * (0xff + 1) * 4
36  */
37 #define HW_WDTC                         0x04
38 #define BM_WDTC_MAX(freq)               (0x7fffffff / (freq))
39
40 /* Watchdog Feed register */
41 #define HW_WDFEED                       0x08
42
43 /* Watchdog Timer Value register */
44 #define HW_WDTV                         0x0c
45
46 #define ASM9260_WDT_DEFAULT_TIMEOUT     30
47
48 enum asm9260_wdt_mode {
49         HW_RESET,
50         SW_RESET,
51         DEBUG,
52 };
53
54 struct asm9260_wdt_priv {
55         struct device           *dev;
56         struct watchdog_device  wdd;
57         struct clk              *clk;
58         struct clk              *clk_ahb;
59         struct reset_control    *rst;
60
61         void __iomem            *iobase;
62         int                     irq;
63         unsigned long           wdt_freq;
64         enum asm9260_wdt_mode   mode;
65 };
66
67 static int asm9260_wdt_feed(struct watchdog_device *wdd)
68 {
69         struct asm9260_wdt_priv *priv = watchdog_get_drvdata(wdd);
70
71         iowrite32(0xaa, priv->iobase + HW_WDFEED);
72         iowrite32(0x55, priv->iobase + HW_WDFEED);
73
74         return 0;
75 }
76
77 static unsigned int asm9260_wdt_gettimeleft(struct watchdog_device *wdd)
78 {
79         struct asm9260_wdt_priv *priv = watchdog_get_drvdata(wdd);
80         u32 counter;
81
82         counter = ioread32(priv->iobase + HW_WDTV);
83
84         return counter / priv->wdt_freq;
85 }
86
87 static int asm9260_wdt_updatetimeout(struct watchdog_device *wdd)
88 {
89         struct asm9260_wdt_priv *priv = watchdog_get_drvdata(wdd);
90         u32 counter;
91
92         counter = wdd->timeout * priv->wdt_freq;
93
94         iowrite32(counter, priv->iobase + HW_WDTC);
95
96         return 0;
97 }
98
99 static int asm9260_wdt_enable(struct watchdog_device *wdd)
100 {
101         struct asm9260_wdt_priv *priv = watchdog_get_drvdata(wdd);
102         u32 mode = 0;
103
104         if (priv->mode == HW_RESET)
105                 mode = BM_MOD_WDRESET;
106
107         iowrite32(BM_MOD_WDEN | mode, priv->iobase + HW_WDMOD);
108
109         asm9260_wdt_updatetimeout(wdd);
110
111         asm9260_wdt_feed(wdd);
112
113         return 0;
114 }
115
116 static int asm9260_wdt_disable(struct watchdog_device *wdd)
117 {
118         struct asm9260_wdt_priv *priv = watchdog_get_drvdata(wdd);
119
120         /* The only way to disable WD is to reset it. */
121         reset_control_assert(priv->rst);
122         reset_control_deassert(priv->rst);
123
124         return 0;
125 }
126
127 static int asm9260_wdt_settimeout(struct watchdog_device *wdd, unsigned int to)
128 {
129         wdd->timeout = to;
130         asm9260_wdt_updatetimeout(wdd);
131
132         return 0;
133 }
134
135 static void asm9260_wdt_sys_reset(struct asm9260_wdt_priv *priv)
136 {
137         /* init WD if it was not started */
138
139         iowrite32(BM_MOD_WDEN | BM_MOD_WDRESET, priv->iobase + HW_WDMOD);
140
141         iowrite32(0xff, priv->iobase + HW_WDTC);
142         /* first pass correct sequence */
143         asm9260_wdt_feed(&priv->wdd);
144         /*
145          * Then write wrong pattern to the feed to trigger reset
146          * ASAP.
147          */
148         iowrite32(0xff, priv->iobase + HW_WDFEED);
149
150         mdelay(1000);
151 }
152
153 static irqreturn_t asm9260_wdt_irq(int irq, void *devid)
154 {
155         struct asm9260_wdt_priv *priv = devid;
156         u32 stat;
157
158         stat = ioread32(priv->iobase + HW_WDMOD);
159         if (!(stat & BM_MOD_WDINT))
160                 return IRQ_NONE;
161
162         if (priv->mode == DEBUG) {
163                 dev_info(priv->dev, "Watchdog Timeout. Do nothing.\n");
164         } else {
165                 dev_info(priv->dev, "Watchdog Timeout. Doing SW Reset.\n");
166                 asm9260_wdt_sys_reset(priv);
167         }
168
169         return IRQ_HANDLED;
170 }
171
172 static int asm9260_restart(struct watchdog_device *wdd, unsigned long action,
173                            void *data)
174 {
175         struct asm9260_wdt_priv *priv = watchdog_get_drvdata(wdd);
176
177         asm9260_wdt_sys_reset(priv);
178
179         return 0;
180 }
181
182 static const struct watchdog_info asm9260_wdt_ident = {
183         .options          =     WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING
184                                 | WDIOF_MAGICCLOSE,
185         .identity         =     "Alphascale asm9260 Watchdog",
186 };
187
188 static const struct watchdog_ops asm9260_wdt_ops = {
189         .owner          = THIS_MODULE,
190         .start          = asm9260_wdt_enable,
191         .stop           = asm9260_wdt_disable,
192         .get_timeleft   = asm9260_wdt_gettimeleft,
193         .ping           = asm9260_wdt_feed,
194         .set_timeout    = asm9260_wdt_settimeout,
195         .restart        = asm9260_restart,
196 };
197
198 static void asm9260_clk_disable_unprepare(void *data)
199 {
200         clk_disable_unprepare(data);
201 }
202
203 static int asm9260_wdt_get_dt_clks(struct asm9260_wdt_priv *priv)
204 {
205         int err;
206         unsigned long clk;
207
208         priv->clk = devm_clk_get(priv->dev, "mod");
209         if (IS_ERR(priv->clk)) {
210                 dev_err(priv->dev, "Failed to get \"mod\" clk\n");
211                 return PTR_ERR(priv->clk);
212         }
213
214         /* configure AHB clock */
215         priv->clk_ahb = devm_clk_get(priv->dev, "ahb");
216         if (IS_ERR(priv->clk_ahb)) {
217                 dev_err(priv->dev, "Failed to get \"ahb\" clk\n");
218                 return PTR_ERR(priv->clk_ahb);
219         }
220
221         err = clk_prepare_enable(priv->clk_ahb);
222         if (err) {
223                 dev_err(priv->dev, "Failed to enable ahb_clk!\n");
224                 return err;
225         }
226         err = devm_add_action_or_reset(priv->dev,
227                                        asm9260_clk_disable_unprepare,
228                                        priv->clk_ahb);
229         if (err)
230                 return err;
231
232         err = clk_set_rate(priv->clk, CLOCK_FREQ);
233         if (err) {
234                 dev_err(priv->dev, "Failed to set rate!\n");
235                 return err;
236         }
237
238         err = clk_prepare_enable(priv->clk);
239         if (err) {
240                 dev_err(priv->dev, "Failed to enable clk!\n");
241                 return err;
242         }
243         err = devm_add_action_or_reset(priv->dev,
244                                        asm9260_clk_disable_unprepare,
245                                        priv->clk);
246         if (err)
247                 return err;
248
249         /* wdt has internal divider */
250         clk = clk_get_rate(priv->clk);
251         if (!clk) {
252                 dev_err(priv->dev, "Failed, clk is 0!\n");
253                 return -EINVAL;
254         }
255
256         priv->wdt_freq = clk / 2;
257
258         return 0;
259 }
260
261 static void asm9260_wdt_get_dt_mode(struct asm9260_wdt_priv *priv)
262 {
263         const char *tmp;
264         int ret;
265
266         /* default mode */
267         priv->mode = HW_RESET;
268
269         ret = of_property_read_string(priv->dev->of_node,
270                                       "alphascale,mode", &tmp);
271         if (ret < 0)
272                 return;
273
274         if (!strcmp(tmp, "hw"))
275                 priv->mode = HW_RESET;
276         else if (!strcmp(tmp, "sw"))
277                 priv->mode = SW_RESET;
278         else if (!strcmp(tmp, "debug"))
279                 priv->mode = DEBUG;
280         else
281                 dev_warn(priv->dev, "unknown reset-type: %s. Using default \"hw\" mode.",
282                          tmp);
283 }
284
285 static int asm9260_wdt_probe(struct platform_device *pdev)
286 {
287         struct device *dev = &pdev->dev;
288         struct asm9260_wdt_priv *priv;
289         struct watchdog_device *wdd;
290         int ret;
291         static const char * const mode_name[] = { "hw", "sw", "debug", };
292
293         priv = devm_kzalloc(dev, sizeof(struct asm9260_wdt_priv), GFP_KERNEL);
294         if (!priv)
295                 return -ENOMEM;
296
297         priv->dev = dev;
298
299         priv->iobase = devm_platform_ioremap_resource(pdev, 0);
300         if (IS_ERR(priv->iobase))
301                 return PTR_ERR(priv->iobase);
302
303         priv->rst = devm_reset_control_get_exclusive(dev, "wdt_rst");
304         if (IS_ERR(priv->rst))
305                 return PTR_ERR(priv->rst);
306
307         ret = asm9260_wdt_get_dt_clks(priv);
308         if (ret)
309                 return ret;
310
311         wdd = &priv->wdd;
312         wdd->info = &asm9260_wdt_ident;
313         wdd->ops = &asm9260_wdt_ops;
314         wdd->min_timeout = 1;
315         wdd->max_timeout = BM_WDTC_MAX(priv->wdt_freq);
316         wdd->parent = dev;
317
318         watchdog_set_drvdata(wdd, priv);
319
320         /*
321          * If 'timeout-sec' unspecified in devicetree, assume a 30 second
322          * default, unless the max timeout is less than 30 seconds, then use
323          * the max instead.
324          */
325         wdd->timeout = ASM9260_WDT_DEFAULT_TIMEOUT;
326         watchdog_init_timeout(wdd, 0, dev);
327
328         asm9260_wdt_get_dt_mode(priv);
329
330         if (priv->mode != HW_RESET)
331                 priv->irq = platform_get_irq(pdev, 0);
332
333         if (priv->irq > 0) {
334                 /*
335                  * Not all supported platforms specify an interrupt for the
336                  * watchdog, so let's make it optional.
337                  */
338                 ret = devm_request_irq(dev, priv->irq, asm9260_wdt_irq, 0,
339                                        pdev->name, priv);
340                 if (ret < 0)
341                         dev_warn(dev, "failed to request IRQ\n");
342         }
343
344         watchdog_set_restart_priority(wdd, 128);
345
346         watchdog_stop_on_reboot(wdd);
347         watchdog_stop_on_unregister(wdd);
348         ret = devm_watchdog_register_device(dev, wdd);
349         if (ret)
350                 return ret;
351
352         platform_set_drvdata(pdev, priv);
353
354         dev_info(dev, "Watchdog enabled (timeout: %d sec, mode: %s)\n",
355                  wdd->timeout, mode_name[priv->mode]);
356         return 0;
357 }
358
359 static const struct of_device_id asm9260_wdt_of_match[] = {
360         { .compatible = "alphascale,asm9260-wdt"},
361         {},
362 };
363 MODULE_DEVICE_TABLE(of, asm9260_wdt_of_match);
364
365 static struct platform_driver asm9260_wdt_driver = {
366         .driver = {
367                 .name = "asm9260-wdt",
368                 .of_match_table = asm9260_wdt_of_match,
369         },
370         .probe = asm9260_wdt_probe,
371 };
372 module_platform_driver(asm9260_wdt_driver);
373
374 MODULE_DESCRIPTION("asm9260 WatchDog Timer Driver");
375 MODULE_AUTHOR("Oleksij Rempel <linux@rempel-privat.de>");
376 MODULE_LICENSE("GPL");