2 * Watchdog driver for IMX2 and later processors
4 * Copyright (C) 2010 Wolfram Sang, Pengutronix e.K. <w.sang@pengutronix.de>
5 * Copyright (C) 2014 Freescale Semiconductor, Inc.
7 * some parts adapted by similar drivers from Darius Augulis and Vladimir
8 * Zapolskiy, additional improvements by Wim Van Sebroeck.
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License version 2 as published by
12 * the Free Software Foundation.
14 * NOTE: MX1 has a slightly different Watchdog than MX2 and later:
18 * Registers: 32-bit 16-bit
19 * Stopable timer: Yes No
20 * Need to enable clk: No Yes
21 * Halt on suspend: Manual Can be automatic
24 #include <linux/clk.h>
25 #include <linux/init.h>
27 #include <linux/jiffies.h>
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/moduleparam.h>
31 #include <linux/of_address.h>
32 #include <linux/platform_device.h>
33 #include <linux/regmap.h>
34 #include <linux/timer.h>
35 #include <linux/watchdog.h>
37 #define DRIVER_NAME "imx2-wdt"
39 #define IMX2_WDT_WCR 0x00 /* Control Register */
40 #define IMX2_WDT_WCR_WT (0xFF << 8) /* -> Watchdog Timeout Field */
41 #define IMX2_WDT_WCR_WRE (1 << 3) /* -> WDOG Reset Enable */
42 #define IMX2_WDT_WCR_WDE (1 << 2) /* -> Watchdog Enable */
43 #define IMX2_WDT_WCR_WDZST (1 << 0) /* -> Watchdog timer Suspend */
45 #define IMX2_WDT_WSR 0x02 /* Service Register */
46 #define IMX2_WDT_SEQ1 0x5555 /* -> service sequence 1 */
47 #define IMX2_WDT_SEQ2 0xAAAA /* -> service sequence 2 */
49 #define IMX2_WDT_WRSR 0x04 /* Reset Status Register */
50 #define IMX2_WDT_WRSR_TOUT (1 << 1) /* -> Reset due to Timeout */
52 #define IMX2_WDT_MAX_TIME 128
53 #define IMX2_WDT_DEFAULT_TIME 60 /* in seconds */
55 #define WDOG_SEC_TO_COUNT(s) ((s * 2 - 1) << 8)
57 struct imx2_wdt_device
{
59 struct regmap
*regmap
;
60 struct timer_list timer
; /* Pings the watchdog when closed */
61 struct watchdog_device wdog
;
64 static bool nowayout
= WATCHDOG_NOWAYOUT
;
65 module_param(nowayout
, bool, 0);
66 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started (default="
67 __MODULE_STRING(WATCHDOG_NOWAYOUT
) ")");
70 static unsigned timeout
= IMX2_WDT_DEFAULT_TIME
;
71 module_param(timeout
, uint
, 0);
72 MODULE_PARM_DESC(timeout
, "Watchdog timeout in seconds (default="
73 __MODULE_STRING(IMX2_WDT_DEFAULT_TIME
) ")");
75 static const struct watchdog_info imx2_wdt_info
= {
76 .identity
= "imx2+ watchdog",
77 .options
= WDIOF_KEEPALIVEPING
| WDIOF_SETTIMEOUT
| WDIOF_MAGICCLOSE
,
80 static inline void imx2_wdt_setup(struct watchdog_device
*wdog
)
82 struct imx2_wdt_device
*wdev
= watchdog_get_drvdata(wdog
);
85 regmap_read(wdev
->regmap
, IMX2_WDT_WCR
, &val
);
87 /* Suspend timer in low power mode, write once-only */
88 val
|= IMX2_WDT_WCR_WDZST
;
89 /* Strip the old watchdog Time-Out value */
90 val
&= ~IMX2_WDT_WCR_WT
;
91 /* Generate reset if WDOG times out */
92 val
&= ~IMX2_WDT_WCR_WRE
;
93 /* Keep Watchdog Disabled */
94 val
&= ~IMX2_WDT_WCR_WDE
;
95 /* Set the watchdog's Time-Out value */
96 val
|= WDOG_SEC_TO_COUNT(wdog
->timeout
);
98 regmap_write(wdev
->regmap
, IMX2_WDT_WCR
, val
);
100 /* enable the watchdog */
101 val
|= IMX2_WDT_WCR_WDE
;
102 regmap_write(wdev
->regmap
, IMX2_WDT_WCR
, val
);
105 static inline bool imx2_wdt_is_running(struct imx2_wdt_device
*wdev
)
109 regmap_read(wdev
->regmap
, IMX2_WDT_WCR
, &val
);
111 return val
& IMX2_WDT_WCR_WDE
;
114 static int imx2_wdt_ping(struct watchdog_device
*wdog
)
116 struct imx2_wdt_device
*wdev
= watchdog_get_drvdata(wdog
);
118 regmap_write(wdev
->regmap
, IMX2_WDT_WSR
, IMX2_WDT_SEQ1
);
119 regmap_write(wdev
->regmap
, IMX2_WDT_WSR
, IMX2_WDT_SEQ2
);
123 static void imx2_wdt_timer_ping(unsigned long arg
)
125 struct watchdog_device
*wdog
= (struct watchdog_device
*)arg
;
126 struct imx2_wdt_device
*wdev
= watchdog_get_drvdata(wdog
);
128 /* ping it every wdog->timeout / 2 seconds to prevent reboot */
130 mod_timer(&wdev
->timer
, jiffies
+ wdog
->timeout
* HZ
/ 2);
133 static int imx2_wdt_set_timeout(struct watchdog_device
*wdog
,
134 unsigned int new_timeout
)
136 struct imx2_wdt_device
*wdev
= watchdog_get_drvdata(wdog
);
138 regmap_update_bits(wdev
->regmap
, IMX2_WDT_WCR
, IMX2_WDT_WCR_WT
,
139 WDOG_SEC_TO_COUNT(new_timeout
));
143 static int imx2_wdt_start(struct watchdog_device
*wdog
)
145 struct imx2_wdt_device
*wdev
= watchdog_get_drvdata(wdog
);
147 if (imx2_wdt_is_running(wdev
)) {
148 /* delete the timer that pings the watchdog after close */
149 del_timer_sync(&wdev
->timer
);
150 imx2_wdt_set_timeout(wdog
, wdog
->timeout
);
152 imx2_wdt_setup(wdog
);
154 return imx2_wdt_ping(wdog
);
157 static int imx2_wdt_stop(struct watchdog_device
*wdog
)
160 * We don't need a clk_disable, it cannot be disabled once started.
161 * We use a timer to ping the watchdog while /dev/watchdog is closed
163 imx2_wdt_timer_ping((unsigned long)wdog
);
167 static inline void imx2_wdt_ping_if_active(struct watchdog_device
*wdog
)
169 struct imx2_wdt_device
*wdev
= watchdog_get_drvdata(wdog
);
171 if (imx2_wdt_is_running(wdev
)) {
172 imx2_wdt_set_timeout(wdog
, wdog
->timeout
);
173 imx2_wdt_timer_ping((unsigned long)wdog
);
177 static struct watchdog_ops imx2_wdt_ops
= {
178 .owner
= THIS_MODULE
,
179 .start
= imx2_wdt_start
,
180 .stop
= imx2_wdt_stop
,
181 .ping
= imx2_wdt_ping
,
182 .set_timeout
= imx2_wdt_set_timeout
,
185 static struct regmap_config imx2_wdt_regmap_config
= {
192 static int __init
imx2_wdt_probe(struct platform_device
*pdev
)
194 struct device_node
*np
= pdev
->dev
.of_node
;
195 struct imx2_wdt_device
*wdev
;
196 struct watchdog_device
*wdog
;
197 struct resource
*res
;
203 wdev
= devm_kzalloc(&pdev
->dev
, sizeof(*wdev
), GFP_KERNEL
);
207 big_endian
= of_property_read_bool(np
, "big-endian");
209 imx2_wdt_regmap_config
.val_format_endian
= REGMAP_ENDIAN_BIG
;
211 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
212 base
= devm_ioremap_resource(&pdev
->dev
, res
);
214 return PTR_ERR(base
);
216 wdev
->regmap
= devm_regmap_init_mmio_clk(&pdev
->dev
, NULL
, base
,
217 &imx2_wdt_regmap_config
);
218 if (IS_ERR(wdev
->regmap
)) {
219 dev_err(&pdev
->dev
, "regmap init failed\n");
220 return PTR_ERR(wdev
->regmap
);
223 wdev
->clk
= devm_clk_get(&pdev
->dev
, NULL
);
224 if (IS_ERR(wdev
->clk
)) {
225 dev_err(&pdev
->dev
, "can't get Watchdog clock\n");
226 return PTR_ERR(wdev
->clk
);
230 wdog
->info
= &imx2_wdt_info
;
231 wdog
->ops
= &imx2_wdt_ops
;
232 wdog
->min_timeout
= 1;
233 wdog
->max_timeout
= IMX2_WDT_MAX_TIME
;
235 clk_prepare_enable(wdev
->clk
);
237 regmap_read(wdev
->regmap
, IMX2_WDT_WRSR
, &val
);
238 wdog
->bootstatus
= val
& IMX2_WDT_WRSR_TOUT
? WDIOF_CARDRESET
: 0;
240 wdog
->timeout
= clamp_t(unsigned, timeout
, 1, IMX2_WDT_MAX_TIME
);
241 if (wdog
->timeout
!= timeout
)
242 dev_warn(&pdev
->dev
, "Initial timeout out of range! Clamped from %u to %u\n",
243 timeout
, wdog
->timeout
);
245 platform_set_drvdata(pdev
, wdog
);
246 watchdog_set_drvdata(wdog
, wdev
);
247 watchdog_set_nowayout(wdog
, nowayout
);
248 watchdog_init_timeout(wdog
, timeout
, &pdev
->dev
);
250 setup_timer(&wdev
->timer
, imx2_wdt_timer_ping
, (unsigned long)wdog
);
252 imx2_wdt_ping_if_active(wdog
);
254 ret
= watchdog_register_device(wdog
);
256 dev_err(&pdev
->dev
, "cannot register watchdog device\n");
260 dev_info(&pdev
->dev
, "timeout %d sec (nowayout=%d)\n",
261 wdog
->timeout
, nowayout
);
266 static int __exit
imx2_wdt_remove(struct platform_device
*pdev
)
268 struct watchdog_device
*wdog
= platform_get_drvdata(pdev
);
269 struct imx2_wdt_device
*wdev
= watchdog_get_drvdata(wdog
);
271 watchdog_unregister_device(wdog
);
273 if (imx2_wdt_is_running(wdev
)) {
274 del_timer_sync(&wdev
->timer
);
276 dev_crit(&pdev
->dev
, "Device removed: Expect reboot!\n");
281 static void imx2_wdt_shutdown(struct platform_device
*pdev
)
283 struct watchdog_device
*wdog
= platform_get_drvdata(pdev
);
284 struct imx2_wdt_device
*wdev
= watchdog_get_drvdata(wdog
);
286 if (imx2_wdt_is_running(wdev
)) {
288 * We are running, we need to delete the timer but will
289 * give max timeout before reboot will take place
291 del_timer_sync(&wdev
->timer
);
292 imx2_wdt_set_timeout(wdog
, IMX2_WDT_MAX_TIME
);
294 dev_crit(&pdev
->dev
, "Device shutdown: Expect reboot!\n");
298 static const struct of_device_id imx2_wdt_dt_ids
[] = {
299 { .compatible
= "fsl,imx21-wdt", },
302 MODULE_DEVICE_TABLE(of
, imx2_wdt_dt_ids
);
304 static struct platform_driver imx2_wdt_driver
= {
305 .remove
= __exit_p(imx2_wdt_remove
),
306 .shutdown
= imx2_wdt_shutdown
,
309 .owner
= THIS_MODULE
,
310 .of_match_table
= imx2_wdt_dt_ids
,
314 module_platform_driver_probe(imx2_wdt_driver
, imx2_wdt_probe
);
316 MODULE_AUTHOR("Wolfram Sang");
317 MODULE_DESCRIPTION("Watchdog driver for IMX2 and later");
318 MODULE_LICENSE("GPL v2");
319 MODULE_ALIAS("platform:" DRIVER_NAME
);