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/miscdevice.h>
20 #include <linux/platform_device.h>
21 #include <linux/watchdog.h>
22 #include <linux/init.h>
24 #include <linux/spinlock.h>
25 #include <linux/clk.h>
26 #include <linux/err.h>
27 #include <mach/bridge-regs.h>
30 * Watchdog timer block registers.
32 #define TIMER_CTRL 0x0000
34 #define WDT_VAL 0x0024
36 #define WDT_MAX_CYCLE_COUNT 0xffffffff
38 #define WDT_OK_TO_CLOSE 1
40 static bool nowayout
= WATCHDOG_NOWAYOUT
;
41 static int heartbeat
= -1; /* module parameter (seconds) */
42 static unsigned int wdt_max_duration
; /* (seconds) */
43 static struct clk
*clk
;
44 static unsigned int wdt_tclk
;
45 static void __iomem
*wdt_reg
;
46 static DEFINE_SPINLOCK(wdt_lock
);
48 static int orion_wdt_ping(struct watchdog_device
*wdt_dev
)
52 /* Reload watchdog duration */
53 writel(wdt_tclk
* wdt_dev
->timeout
, wdt_reg
+ WDT_VAL
);
55 spin_unlock(&wdt_lock
);
59 static int orion_wdt_start(struct watchdog_device
*wdt_dev
)
65 /* Set watchdog duration */
66 writel(wdt_tclk
* wdt_dev
->timeout
, wdt_reg
+ WDT_VAL
);
68 /* Clear watchdog timer interrupt */
69 reg
= readl(BRIDGE_CAUSE
);
71 writel(reg
, 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
,
144 static int __devinit
orion_wdt_probe(struct platform_device
*pdev
)
146 struct resource
*res
;
149 clk
= devm_clk_get(&pdev
->dev
, NULL
);
151 dev_err(&pdev
->dev
, "Orion Watchdog missing clock\n");
154 clk_prepare_enable(clk
);
155 wdt_tclk
= clk_get_rate(clk
);
157 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
158 wdt_reg
= devm_ioremap(&pdev
->dev
, res
->start
, resource_size(res
));
162 wdt_max_duration
= WDT_MAX_CYCLE_COUNT
/ wdt_tclk
;
164 if ((heartbeat
< 1) || (heartbeat
> wdt_max_duration
))
165 heartbeat
= wdt_max_duration
;
167 orion_wdt
.timeout
= heartbeat
;
168 orion_wdt
.min_timeout
= 1;
169 orion_wdt
.max_timeout
= wdt_max_duration
;
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 heartbeat
, nowayout
? ", nowayout" : "");
183 static int __devexit
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 struct platform_driver orion_wdt_driver
= {
196 .probe
= orion_wdt_probe
,
197 .remove
= __devexit_p(orion_wdt_remove
),
198 .shutdown
= orion_wdt_shutdown
,
200 .owner
= THIS_MODULE
,
205 module_platform_driver(orion_wdt_driver
);
207 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
208 MODULE_DESCRIPTION("Orion Processor Watchdog");
210 module_param(heartbeat
, int, 0);
211 MODULE_PARM_DESC(heartbeat
, "Initial watchdog heartbeat in seconds");
213 module_param(nowayout
, bool, 0);
214 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started (default="
215 __MODULE_STRING(WATCHDOG_NOWAYOUT
) ")");
217 MODULE_LICENSE("GPL");
218 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR
);