2 * drivers/watchdog/orion_wdt.c
4 * Watchdog driver for Orion/Kirkwood processors
6 * Author: Sylver Bruneau <sylver.bruneau@googlemail.com>
8 * This file is licensed under the terms of the GNU General Public
9 * License version 2. This program is licensed "as is" without any
10 * warranty of any kind, whether express or implied.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/platform_device.h>
20 #include <linux/watchdog.h>
22 #include <linux/spinlock.h>
23 #include <linux/clk.h>
24 #include <linux/err.h>
26 #include <mach/bridge-regs.h>
29 * Watchdog timer block registers.
31 #define TIMER_CTRL 0x0000
33 #define WDT_VAL 0x0024
35 #define WDT_MAX_CYCLE_COUNT 0xffffffff
37 #define WDT_OK_TO_CLOSE 1
39 #define WDT_RESET_OUT_EN BIT(1)
40 #define WDT_INT_REQ BIT(3)
42 static bool nowayout
= WATCHDOG_NOWAYOUT
;
43 static int heartbeat
= -1; /* module parameter (seconds) */
44 static unsigned int wdt_max_duration
; /* (seconds) */
45 static struct clk
*clk
;
46 static unsigned int wdt_tclk
;
47 static void __iomem
*wdt_reg
;
48 static DEFINE_SPINLOCK(wdt_lock
);
50 static int orion_wdt_ping(struct watchdog_device
*wdt_dev
)
54 /* Reload watchdog duration */
55 writel(wdt_tclk
* wdt_dev
->timeout
, wdt_reg
+ WDT_VAL
);
57 spin_unlock(&wdt_lock
);
61 static int orion_wdt_start(struct watchdog_device
*wdt_dev
)
67 /* Set watchdog duration */
68 writel(wdt_tclk
* wdt_dev
->timeout
, wdt_reg
+ WDT_VAL
);
70 /* Clear watchdog timer interrupt */
71 writel(~WDT_INT_REQ
, BRIDGE_CAUSE
);
73 /* Enable watchdog timer */
74 reg
= readl(wdt_reg
+ TIMER_CTRL
);
76 writel(reg
, wdt_reg
+ TIMER_CTRL
);
78 /* Enable reset on watchdog */
79 reg
= readl(RSTOUTn_MASK
);
80 reg
|= WDT_RESET_OUT_EN
;
81 writel(reg
, RSTOUTn_MASK
);
83 spin_unlock(&wdt_lock
);
87 static int orion_wdt_stop(struct watchdog_device
*wdt_dev
)
93 /* Disable reset on watchdog */
94 reg
= readl(RSTOUTn_MASK
);
95 reg
&= ~WDT_RESET_OUT_EN
;
96 writel(reg
, RSTOUTn_MASK
);
98 /* Disable watchdog timer */
99 reg
= readl(wdt_reg
+ TIMER_CTRL
);
101 writel(reg
, wdt_reg
+ TIMER_CTRL
);
103 spin_unlock(&wdt_lock
);
107 static unsigned int orion_wdt_get_timeleft(struct watchdog_device
*wdt_dev
)
109 unsigned int time_left
;
111 spin_lock(&wdt_lock
);
112 time_left
= readl(wdt_reg
+ WDT_VAL
) / wdt_tclk
;
113 spin_unlock(&wdt_lock
);
118 static int orion_wdt_set_timeout(struct watchdog_device
*wdt_dev
,
119 unsigned int timeout
)
121 wdt_dev
->timeout
= timeout
;
125 static const struct watchdog_info orion_wdt_info
= {
126 .options
= WDIOF_SETTIMEOUT
| WDIOF_KEEPALIVEPING
| WDIOF_MAGICCLOSE
,
127 .identity
= "Orion Watchdog",
130 static const struct watchdog_ops orion_wdt_ops
= {
131 .owner
= THIS_MODULE
,
132 .start
= orion_wdt_start
,
133 .stop
= orion_wdt_stop
,
134 .ping
= orion_wdt_ping
,
135 .set_timeout
= orion_wdt_set_timeout
,
136 .get_timeleft
= orion_wdt_get_timeleft
,
139 static struct watchdog_device orion_wdt
= {
140 .info
= &orion_wdt_info
,
141 .ops
= &orion_wdt_ops
,
145 static int orion_wdt_probe(struct platform_device
*pdev
)
147 struct resource
*res
;
150 clk
= devm_clk_get(&pdev
->dev
, NULL
);
152 dev_err(&pdev
->dev
, "Orion Watchdog missing clock\n");
155 clk_prepare_enable(clk
);
156 wdt_tclk
= clk_get_rate(clk
);
158 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
161 wdt_reg
= devm_ioremap(&pdev
->dev
, res
->start
, resource_size(res
));
165 wdt_max_duration
= WDT_MAX_CYCLE_COUNT
/ wdt_tclk
;
167 orion_wdt
.timeout
= wdt_max_duration
;
168 orion_wdt
.max_timeout
= wdt_max_duration
;
169 watchdog_init_timeout(&orion_wdt
, heartbeat
, &pdev
->dev
);
171 watchdog_set_nowayout(&orion_wdt
, nowayout
);
172 ret
= watchdog_register_device(&orion_wdt
);
174 clk_disable_unprepare(clk
);
178 pr_info("Initial timeout %d sec%s\n",
179 orion_wdt
.timeout
, nowayout
? ", nowayout" : "");
183 static int orion_wdt_remove(struct platform_device
*pdev
)
185 watchdog_unregister_device(&orion_wdt
);
186 clk_disable_unprepare(clk
);
190 static void orion_wdt_shutdown(struct platform_device
*pdev
)
192 orion_wdt_stop(&orion_wdt
);
195 static const struct of_device_id orion_wdt_of_match_table
[] = {
196 { .compatible
= "marvell,orion-wdt", },
199 MODULE_DEVICE_TABLE(of
, orion_wdt_of_match_table
);
201 static struct platform_driver orion_wdt_driver
= {
202 .probe
= orion_wdt_probe
,
203 .remove
= orion_wdt_remove
,
204 .shutdown
= orion_wdt_shutdown
,
206 .owner
= THIS_MODULE
,
208 .of_match_table
= orion_wdt_of_match_table
,
212 module_platform_driver(orion_wdt_driver
);
214 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
215 MODULE_DESCRIPTION("Orion Processor Watchdog");
217 module_param(heartbeat
, int, 0);
218 MODULE_PARM_DESC(heartbeat
, "Initial watchdog heartbeat in seconds");
220 module_param(nowayout
, bool, 0);
221 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started (default="
222 __MODULE_STRING(WATCHDOG_NOWAYOUT
) ")");
224 MODULE_LICENSE("GPL");
225 MODULE_ALIAS("platform:orion_wdt");