2 * Watchdog driver for Alphascale ASM9260.
4 * Copyright (c) 2014 Oleksij Rempel <linux@rempel-privat.de>
6 * Licensed under GPLv2 or later.
9 #include <linux/bitops.h>
10 #include <linux/clk.h>
11 #include <linux/delay.h>
12 #include <linux/interrupt.h>
14 #include <linux/module.h>
16 #include <linux/platform_device.h>
17 #include <linux/reset.h>
18 #include <linux/watchdog.h>
20 #define CLOCK_FREQ 1000000
22 /* Watchdog Mode register */
24 /* Wake interrupt. Set by HW, can't be cleared. */
25 #define BM_MOD_WDINT BIT(3)
26 /* This bit set if timeout reached. Cleared by SW. */
27 #define BM_MOD_WDTOF BIT(2)
28 /* HW Reset on timeout */
29 #define BM_MOD_WDRESET BIT(1)
31 #define BM_MOD_WDEN BIT(0)
34 * Watchdog Timer Constant register
35 * Minimal value is 0xff, the meaning of this value
36 * depends on used clock: T = WDCLK * (0xff + 1) * 4
39 #define BM_WDTC_MAX(freq) (0x7fffffff / (freq))
41 /* Watchdog Feed register */
42 #define HW_WDFEED 0x08
44 /* Watchdog Timer Value register */
47 #define ASM9260_WDT_DEFAULT_TIMEOUT 30
49 enum asm9260_wdt_mode
{
55 struct asm9260_wdt_priv
{
57 struct watchdog_device wdd
;
60 struct reset_control
*rst
;
64 unsigned long wdt_freq
;
65 enum asm9260_wdt_mode mode
;
68 static int asm9260_wdt_feed(struct watchdog_device
*wdd
)
70 struct asm9260_wdt_priv
*priv
= watchdog_get_drvdata(wdd
);
72 iowrite32(0xaa, priv
->iobase
+ HW_WDFEED
);
73 iowrite32(0x55, priv
->iobase
+ HW_WDFEED
);
78 static unsigned int asm9260_wdt_gettimeleft(struct watchdog_device
*wdd
)
80 struct asm9260_wdt_priv
*priv
= watchdog_get_drvdata(wdd
);
83 counter
= ioread32(priv
->iobase
+ HW_WDTV
);
85 return counter
/ priv
->wdt_freq
;
88 static int asm9260_wdt_updatetimeout(struct watchdog_device
*wdd
)
90 struct asm9260_wdt_priv
*priv
= watchdog_get_drvdata(wdd
);
93 counter
= wdd
->timeout
* priv
->wdt_freq
;
95 iowrite32(counter
, priv
->iobase
+ HW_WDTC
);
100 static int asm9260_wdt_enable(struct watchdog_device
*wdd
)
102 struct asm9260_wdt_priv
*priv
= watchdog_get_drvdata(wdd
);
105 if (priv
->mode
== HW_RESET
)
106 mode
= BM_MOD_WDRESET
;
108 iowrite32(BM_MOD_WDEN
| mode
, priv
->iobase
+ HW_WDMOD
);
110 asm9260_wdt_updatetimeout(wdd
);
112 asm9260_wdt_feed(wdd
);
117 static int asm9260_wdt_disable(struct watchdog_device
*wdd
)
119 struct asm9260_wdt_priv
*priv
= watchdog_get_drvdata(wdd
);
121 /* The only way to disable WD is to reset it. */
122 reset_control_assert(priv
->rst
);
123 reset_control_deassert(priv
->rst
);
128 static int asm9260_wdt_settimeout(struct watchdog_device
*wdd
, unsigned int to
)
131 asm9260_wdt_updatetimeout(wdd
);
136 static void asm9260_wdt_sys_reset(struct asm9260_wdt_priv
*priv
)
138 /* init WD if it was not started */
140 iowrite32(BM_MOD_WDEN
| BM_MOD_WDRESET
, priv
->iobase
+ HW_WDMOD
);
142 iowrite32(0xff, priv
->iobase
+ HW_WDTC
);
143 /* first pass correct sequence */
144 asm9260_wdt_feed(&priv
->wdd
);
146 * Then write wrong pattern to the feed to trigger reset
149 iowrite32(0xff, priv
->iobase
+ HW_WDFEED
);
154 static irqreturn_t
asm9260_wdt_irq(int irq
, void *devid
)
156 struct asm9260_wdt_priv
*priv
= devid
;
159 stat
= ioread32(priv
->iobase
+ HW_WDMOD
);
160 if (!(stat
& BM_MOD_WDINT
))
163 if (priv
->mode
== DEBUG
) {
164 dev_info(priv
->dev
, "Watchdog Timeout. Do nothing.\n");
166 dev_info(priv
->dev
, "Watchdog Timeout. Doing SW Reset.\n");
167 asm9260_wdt_sys_reset(priv
);
173 static int asm9260_restart(struct watchdog_device
*wdd
, unsigned long action
,
176 struct asm9260_wdt_priv
*priv
= watchdog_get_drvdata(wdd
);
178 asm9260_wdt_sys_reset(priv
);
183 static const struct watchdog_info asm9260_wdt_ident
= {
184 .options
= WDIOF_SETTIMEOUT
| WDIOF_KEEPALIVEPING
186 .identity
= "Alphascale asm9260 Watchdog",
189 static const struct watchdog_ops asm9260_wdt_ops
= {
190 .owner
= THIS_MODULE
,
191 .start
= asm9260_wdt_enable
,
192 .stop
= asm9260_wdt_disable
,
193 .get_timeleft
= asm9260_wdt_gettimeleft
,
194 .ping
= asm9260_wdt_feed
,
195 .set_timeout
= asm9260_wdt_settimeout
,
196 .restart
= asm9260_restart
,
199 static void asm9260_clk_disable_unprepare(void *data
)
201 clk_disable_unprepare(data
);
204 static int asm9260_wdt_get_dt_clks(struct asm9260_wdt_priv
*priv
)
209 priv
->clk
= devm_clk_get(priv
->dev
, "mod");
210 if (IS_ERR(priv
->clk
)) {
211 dev_err(priv
->dev
, "Failed to get \"mod\" clk\n");
212 return PTR_ERR(priv
->clk
);
215 /* configure AHB clock */
216 priv
->clk_ahb
= devm_clk_get(priv
->dev
, "ahb");
217 if (IS_ERR(priv
->clk_ahb
)) {
218 dev_err(priv
->dev
, "Failed to get \"ahb\" clk\n");
219 return PTR_ERR(priv
->clk_ahb
);
222 err
= clk_prepare_enable(priv
->clk_ahb
);
224 dev_err(priv
->dev
, "Failed to enable ahb_clk!\n");
227 err
= devm_add_action_or_reset(priv
->dev
,
228 asm9260_clk_disable_unprepare
,
233 err
= clk_set_rate(priv
->clk
, CLOCK_FREQ
);
235 dev_err(priv
->dev
, "Failed to set rate!\n");
239 err
= clk_prepare_enable(priv
->clk
);
241 dev_err(priv
->dev
, "Failed to enable clk!\n");
244 err
= devm_add_action_or_reset(priv
->dev
,
245 asm9260_clk_disable_unprepare
,
250 /* wdt has internal divider */
251 clk
= clk_get_rate(priv
->clk
);
253 dev_err(priv
->dev
, "Failed, clk is 0!\n");
257 priv
->wdt_freq
= clk
/ 2;
262 static void asm9260_wdt_get_dt_mode(struct asm9260_wdt_priv
*priv
)
268 priv
->mode
= HW_RESET
;
270 ret
= of_property_read_string(priv
->dev
->of_node
,
271 "alphascale,mode", &tmp
);
275 if (!strcmp(tmp
, "hw"))
276 priv
->mode
= HW_RESET
;
277 else if (!strcmp(tmp
, "sw"))
278 priv
->mode
= SW_RESET
;
279 else if (!strcmp(tmp
, "debug"))
282 dev_warn(priv
->dev
, "unknown reset-type: %s. Using default \"hw\" mode.",
286 static int asm9260_wdt_probe(struct platform_device
*pdev
)
288 struct device
*dev
= &pdev
->dev
;
289 struct asm9260_wdt_priv
*priv
;
290 struct watchdog_device
*wdd
;
292 static const char * const mode_name
[] = { "hw", "sw", "debug", };
294 priv
= devm_kzalloc(dev
, sizeof(struct asm9260_wdt_priv
), GFP_KERNEL
);
300 priv
->iobase
= devm_platform_ioremap_resource(pdev
, 0);
301 if (IS_ERR(priv
->iobase
))
302 return PTR_ERR(priv
->iobase
);
304 priv
->rst
= devm_reset_control_get_exclusive(dev
, "wdt_rst");
305 if (IS_ERR(priv
->rst
))
306 return PTR_ERR(priv
->rst
);
308 ret
= asm9260_wdt_get_dt_clks(priv
);
313 wdd
->info
= &asm9260_wdt_ident
;
314 wdd
->ops
= &asm9260_wdt_ops
;
315 wdd
->min_timeout
= 1;
316 wdd
->max_timeout
= BM_WDTC_MAX(priv
->wdt_freq
);
319 watchdog_set_drvdata(wdd
, priv
);
322 * If 'timeout-sec' unspecified in devicetree, assume a 30 second
323 * default, unless the max timeout is less than 30 seconds, then use
326 wdd
->timeout
= ASM9260_WDT_DEFAULT_TIMEOUT
;
327 watchdog_init_timeout(wdd
, 0, dev
);
329 asm9260_wdt_get_dt_mode(priv
);
331 if (priv
->mode
!= HW_RESET
)
332 priv
->irq
= platform_get_irq(pdev
, 0);
336 * Not all supported platforms specify an interrupt for the
337 * watchdog, so let's make it optional.
339 ret
= devm_request_irq(dev
, priv
->irq
, asm9260_wdt_irq
, 0,
342 dev_warn(dev
, "failed to request IRQ\n");
345 watchdog_set_restart_priority(wdd
, 128);
347 watchdog_stop_on_reboot(wdd
);
348 watchdog_stop_on_unregister(wdd
);
349 ret
= devm_watchdog_register_device(dev
, wdd
);
353 platform_set_drvdata(pdev
, priv
);
355 dev_info(dev
, "Watchdog enabled (timeout: %d sec, mode: %s)\n",
356 wdd
->timeout
, mode_name
[priv
->mode
]);
360 static const struct of_device_id asm9260_wdt_of_match
[] = {
361 { .compatible
= "alphascale,asm9260-wdt"},
364 MODULE_DEVICE_TABLE(of
, asm9260_wdt_of_match
);
366 static struct platform_driver asm9260_wdt_driver
= {
368 .name
= "asm9260-wdt",
369 .of_match_table
= asm9260_wdt_of_match
,
371 .probe
= asm9260_wdt_probe
,
373 module_platform_driver(asm9260_wdt_driver
);
375 MODULE_DESCRIPTION("asm9260 WatchDog Timer Driver");
376 MODULE_AUTHOR("Oleksij Rempel <linux@rempel-privat.de>");
377 MODULE_LICENSE("GPL");