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>
20 #include <linux/miscdevice.h>
21 #include <linux/platform_device.h>
22 #include <linux/watchdog.h>
23 #include <linux/init.h>
24 #include <linux/uaccess.h>
26 #include <linux/spinlock.h>
27 #include <linux/clk.h>
28 #include <mach/bridge-regs.h>
31 * Watchdog timer block registers.
33 #define TIMER_CTRL 0x0000
35 #define WDT_VAL 0x0024
37 #define WDT_MAX_CYCLE_COUNT 0xffffffff
39 #define WDT_OK_TO_CLOSE 1
41 static bool nowayout
= WATCHDOG_NOWAYOUT
;
42 static int heartbeat
= -1; /* module parameter (seconds) */
43 static unsigned int wdt_max_duration
; /* (seconds) */
44 static struct clk
*clk
;
45 static unsigned int wdt_tclk
;
46 static void __iomem
*wdt_reg
;
47 static unsigned long wdt_status
;
48 static DEFINE_SPINLOCK(wdt_lock
);
50 static void orion_wdt_ping(void)
54 /* Reload watchdog duration */
55 writel(wdt_tclk
* heartbeat
, wdt_reg
+ WDT_VAL
);
57 spin_unlock(&wdt_lock
);
60 static void orion_wdt_enable(void)
66 /* Set watchdog duration */
67 writel(wdt_tclk
* heartbeat
, wdt_reg
+ WDT_VAL
);
69 /* Clear watchdog timer interrupt */
70 reg
= readl(BRIDGE_CAUSE
);
72 writel(reg
, BRIDGE_CAUSE
);
74 /* Enable watchdog timer */
75 reg
= readl(wdt_reg
+ TIMER_CTRL
);
77 writel(reg
, wdt_reg
+ TIMER_CTRL
);
79 /* Enable reset on watchdog */
80 reg
= readl(RSTOUTn_MASK
);
81 reg
|= WDT_RESET_OUT_EN
;
82 writel(reg
, RSTOUTn_MASK
);
84 spin_unlock(&wdt_lock
);
87 static void orion_wdt_disable(void)
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
);
106 static int orion_wdt_get_timeleft(int *time_left
)
108 spin_lock(&wdt_lock
);
109 *time_left
= readl(wdt_reg
+ WDT_VAL
) / wdt_tclk
;
110 spin_unlock(&wdt_lock
);
114 static int orion_wdt_open(struct inode
*inode
, struct file
*file
)
116 if (test_and_set_bit(WDT_IN_USE
, &wdt_status
))
118 clear_bit(WDT_OK_TO_CLOSE
, &wdt_status
);
120 return nonseekable_open(inode
, file
);
123 static ssize_t
orion_wdt_write(struct file
*file
, const char *data
,
124 size_t len
, loff_t
*ppos
)
130 clear_bit(WDT_OK_TO_CLOSE
, &wdt_status
);
131 for (i
= 0; i
!= len
; i
++) {
134 if (get_user(c
, data
+ i
))
137 set_bit(WDT_OK_TO_CLOSE
, &wdt_status
);
145 static int orion_wdt_settimeout(int new_time
)
147 if ((new_time
<= 0) || (new_time
> wdt_max_duration
))
150 /* Set new watchdog time to be used when
151 * orion_wdt_enable() or orion_wdt_ping() is called. */
152 heartbeat
= new_time
;
156 static const struct watchdog_info ident
= {
157 .options
= WDIOF_MAGICCLOSE
| WDIOF_SETTIMEOUT
|
159 .identity
= "Orion Watchdog",
162 static long orion_wdt_ioctl(struct file
*file
, unsigned int cmd
,
169 case WDIOC_GETSUPPORT
:
170 ret
= copy_to_user((struct watchdog_info
*)arg
, &ident
,
171 sizeof(ident
)) ? -EFAULT
: 0;
174 case WDIOC_GETSTATUS
:
175 case WDIOC_GETBOOTSTATUS
:
176 ret
= put_user(0, (int *)arg
);
179 case WDIOC_KEEPALIVE
:
184 case WDIOC_SETTIMEOUT
:
185 ret
= get_user(time
, (int *)arg
);
189 if (orion_wdt_settimeout(time
)) {
196 case WDIOC_GETTIMEOUT
:
197 ret
= put_user(heartbeat
, (int *)arg
);
200 case WDIOC_GETTIMELEFT
:
201 if (orion_wdt_get_timeleft(&time
)) {
205 ret
= put_user(time
, (int *)arg
);
211 static int orion_wdt_release(struct inode
*inode
, struct file
*file
)
213 if (test_bit(WDT_OK_TO_CLOSE
, &wdt_status
))
216 pr_crit("Device closed unexpectedly - timer will not stop\n");
217 clear_bit(WDT_IN_USE
, &wdt_status
);
218 clear_bit(WDT_OK_TO_CLOSE
, &wdt_status
);
224 static const struct file_operations orion_wdt_fops
= {
225 .owner
= THIS_MODULE
,
227 .write
= orion_wdt_write
,
228 .unlocked_ioctl
= orion_wdt_ioctl
,
229 .open
= orion_wdt_open
,
230 .release
= orion_wdt_release
,
233 static struct miscdevice orion_wdt_miscdev
= {
234 .minor
= WATCHDOG_MINOR
,
236 .fops
= &orion_wdt_fops
,
239 static int __devinit
orion_wdt_probe(struct platform_device
*pdev
)
241 struct resource
*res
;
244 clk
= clk_get(&pdev
->dev
, NULL
);
246 printk(KERN_ERR
"Orion Watchdog missing clock\n");
249 clk_prepare_enable(clk
);
250 wdt_tclk
= clk_get_rate(clk
);
252 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
254 wdt_reg
= ioremap(res
->start
, resource_size(res
));
256 if (orion_wdt_miscdev
.parent
)
258 orion_wdt_miscdev
.parent
= &pdev
->dev
;
260 wdt_max_duration
= WDT_MAX_CYCLE_COUNT
/ wdt_tclk
;
261 if (orion_wdt_settimeout(heartbeat
))
262 heartbeat
= wdt_max_duration
;
264 ret
= misc_register(&orion_wdt_miscdev
);
268 pr_info("Initial timeout %d sec%s\n",
269 heartbeat
, nowayout
? ", nowayout" : "");
273 static int __devexit
orion_wdt_remove(struct platform_device
*pdev
)
277 if (test_bit(WDT_IN_USE
, &wdt_status
)) {
279 clear_bit(WDT_IN_USE
, &wdt_status
);
282 ret
= misc_deregister(&orion_wdt_miscdev
);
284 orion_wdt_miscdev
.parent
= NULL
;
286 clk_disable_unprepare(clk
);
292 static void orion_wdt_shutdown(struct platform_device
*pdev
)
294 if (test_bit(WDT_IN_USE
, &wdt_status
))
298 static struct platform_driver orion_wdt_driver
= {
299 .probe
= orion_wdt_probe
,
300 .remove
= __devexit_p(orion_wdt_remove
),
301 .shutdown
= orion_wdt_shutdown
,
303 .owner
= THIS_MODULE
,
308 module_platform_driver(orion_wdt_driver
);
310 MODULE_AUTHOR("Sylver Bruneau <sylver.bruneau@googlemail.com>");
311 MODULE_DESCRIPTION("Orion Processor Watchdog");
313 module_param(heartbeat
, int, 0);
314 MODULE_PARM_DESC(heartbeat
, "Initial watchdog heartbeat in seconds");
316 module_param(nowayout
, bool, 0);
317 MODULE_PARM_DESC(nowayout
, "Watchdog cannot be stopped once started (default="
318 __MODULE_STRING(WATCHDOG_NOWAYOUT
) ")");
320 MODULE_LICENSE("GPL");
321 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR
);