2 * drivers/watchdog/shwdt.c
4 * Watchdog driver for integrated watchdog in the SuperH processors.
6 * Copyright (C) 2001 - 2012 Paul Mundt <lethal@linux-sh.org>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
13 * 14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com>
14 * Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT
16 * 19-Apr-2002 Rob Radez <rob@osinvestor.com>
17 * Added expect close support, made emulated timeout runtime changeable
18 * general cleanups, add some ioctls
21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/platform_device.h>
26 #include <linux/init.h>
27 #include <linux/types.h>
28 #include <linux/spinlock.h>
29 #include <linux/miscdevice.h>
30 #include <linux/watchdog.h>
31 #include <linux/pm_runtime.h>
34 #include <linux/slab.h>
36 #include <linux/clk.h>
37 #include <asm/watchdog.h>
39 #define DRV_NAME "sh-wdt"
42 * Default clock division ratio is 5.25 msecs. For an additional table of
43 * values, consult the asm-sh/watchdog.h. Overload this at module load
46 * In order for this to work reliably we need to have HZ set to 1000 or
47 * something quite higher than 100 (or we need a proper high-res timer
48 * implementation that will deal with this properly), otherwise the 10ms
49 * resolution of a jiffy is enough to trigger the overflow. For things like
50 * the SH-4 and SH-5, this isn't necessarily that big of a problem, though
51 * for the SH-2 and SH-3, this isn't recommended unless the WDT is absolutely
54 * As a result of this timing problem, the only modes that are particularly
55 * feasible are the 4096 and the 2048 divisors, which yield 5.25 and 2.62ms
56 * overflow periods respectively.
58 * Also, since we can't really expect userspace to be responsive enough
59 * before the overflow happens, we maintain two separate timers .. One in
60 * the kernel for clearing out WOVF every 2ms or so (again, this depends on
61 * HZ == 1000), and another for monitoring userspace writes to the WDT device.
63 * As such, we currently use a configurable heartbeat interval which defaults
64 * to 30s. In this case, the userspace daemon is only responsible for periodic
65 * writes to the device before the next heartbeat is scheduled. If the daemon
66 * misses its deadline, the kernel timer will allow the WDT to overflow.
68 static int clock_division_ratio
= WTCSR_CKS_4096
;
69 #define next_ping_period(cks) (jiffies + msecs_to_jiffies(cks - 4))
71 #define WATCHDOG_HEARTBEAT 30 /* 30 sec default heartbeat */
72 static int heartbeat
= WATCHDOG_HEARTBEAT
; /* in seconds */
73 static bool nowayout
= WATCHDOG_NOWAYOUT
;
74 static unsigned long next_heartbeat
;
82 struct timer_list timer
;
85 static int sh_wdt_start(struct watchdog_device
*wdt_dev
)
87 struct sh_wdt
*wdt
= watchdog_get_drvdata(wdt_dev
);
91 pm_runtime_get_sync(wdt
->dev
);
93 spin_lock_irqsave(&wdt
->lock
, flags
);
95 next_heartbeat
= jiffies
+ (heartbeat
* HZ
);
96 mod_timer(&wdt
->timer
, next_ping_period(clock_division_ratio
));
98 csr
= sh_wdt_read_csr();
99 csr
|= WTCSR_WT
| clock_division_ratio
;
100 sh_wdt_write_csr(csr
);
105 * These processors have a bit of an inconsistent initialization
106 * process.. starting with SH-3, RSTS was moved to WTCSR, and the
107 * RSTCSR register was removed.
109 * On the SH-2 however, in addition with bits being in different
110 * locations, we must deal with RSTCSR outright..
112 csr
= sh_wdt_read_csr();
115 sh_wdt_write_csr(csr
);
117 #ifdef CONFIG_CPU_SH2
118 csr
= sh_wdt_read_rstcsr();
120 sh_wdt_write_rstcsr(csr
);
122 spin_unlock_irqrestore(&wdt
->lock
, flags
);
127 static int sh_wdt_stop(struct watchdog_device
*wdt_dev
)
129 struct sh_wdt
*wdt
= watchdog_get_drvdata(wdt_dev
);
133 spin_lock_irqsave(&wdt
->lock
, flags
);
135 del_timer(&wdt
->timer
);
137 csr
= sh_wdt_read_csr();
139 sh_wdt_write_csr(csr
);
141 spin_unlock_irqrestore(&wdt
->lock
, flags
);
143 pm_runtime_put_sync(wdt
->dev
);
148 static int sh_wdt_keepalive(struct watchdog_device
*wdt_dev
)
150 struct sh_wdt
*wdt
= watchdog_get_drvdata(wdt_dev
);
153 spin_lock_irqsave(&wdt
->lock
, flags
);
154 next_heartbeat
= jiffies
+ (heartbeat
* HZ
);
155 spin_unlock_irqrestore(&wdt
->lock
, flags
);
160 static int sh_wdt_set_heartbeat(struct watchdog_device
*wdt_dev
, unsigned t
)
162 struct sh_wdt
*wdt
= watchdog_get_drvdata(wdt_dev
);
165 if (unlikely(t
< 1 || t
> 3600)) /* arbitrary upper limit */
168 spin_lock_irqsave(&wdt
->lock
, flags
);
170 wdt_dev
->timeout
= t
;
171 spin_unlock_irqrestore(&wdt
->lock
, flags
);
176 static void sh_wdt_ping(unsigned long data
)
178 struct sh_wdt
*wdt
= (struct sh_wdt
*)data
;
181 spin_lock_irqsave(&wdt
->lock
, flags
);
182 if (time_before(jiffies
, next_heartbeat
)) {
185 csr
= sh_wdt_read_csr();
187 sh_wdt_write_csr(csr
);
191 mod_timer(&wdt
->timer
, next_ping_period(clock_division_ratio
));
193 dev_warn(wdt
->dev
, "Heartbeat lost! Will not ping "
195 spin_unlock_irqrestore(&wdt
->lock
, flags
);
198 static const struct watchdog_info sh_wdt_info
= {
199 .options
= WDIOF_KEEPALIVEPING
| WDIOF_SETTIMEOUT
|
201 .firmware_version
= 1,
202 .identity
= "SH WDT",
205 static const struct watchdog_ops sh_wdt_ops
= {
206 .owner
= THIS_MODULE
,
207 .start
= sh_wdt_start
,
209 .ping
= sh_wdt_keepalive
,
210 .set_timeout
= sh_wdt_set_heartbeat
,
213 static struct watchdog_device sh_wdt_dev
= {
214 .info
= &sh_wdt_info
,
218 static int __devinit
sh_wdt_probe(struct platform_device
*pdev
)
221 struct resource
*res
;
225 * As this driver only covers the global watchdog case, reject
226 * any attempts to register per-CPU watchdogs.
231 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
235 wdt
= devm_kzalloc(&pdev
->dev
, sizeof(struct sh_wdt
), GFP_KERNEL
);
239 wdt
->dev
= &pdev
->dev
;
241 wdt
->clk
= clk_get(&pdev
->dev
, NULL
);
242 if (IS_ERR(wdt
->clk
)) {
244 * Clock framework support is optional, continue on
245 * anyways if we don't find a matching clock.
250 clk_enable(wdt
->clk
);
252 wdt
->base
= devm_request_and_ioremap(wdt
->dev
, res
);
253 if (unlikely(!wdt
->base
)) {
258 watchdog_set_nowayout(&sh_wdt_dev
, nowayout
);
259 watchdog_set_drvdata(&sh_wdt_dev
, wdt
);
261 spin_lock_init(&wdt
->lock
);
263 rc
= sh_wdt_set_heartbeat(&sh_wdt_dev
, heartbeat
);
265 /* Default timeout if invalid */
266 sh_wdt_set_heartbeat(&sh_wdt_dev
, WATCHDOG_HEARTBEAT
);
269 "heartbeat value must be 1<=x<=3600, using %d\n",
273 dev_info(&pdev
->dev
, "configured with heartbeat=%d sec (nowayout=%d)\n",
274 sh_wdt_dev
.timeout
, nowayout
);
276 rc
= watchdog_register_device(&sh_wdt_dev
);
278 dev_err(&pdev
->dev
, "Can't register watchdog (err=%d)\n", rc
);
282 init_timer(&wdt
->timer
);
283 wdt
->timer
.function
= sh_wdt_ping
;
284 wdt
->timer
.data
= (unsigned long)wdt
;
285 wdt
->timer
.expires
= next_ping_period(clock_division_ratio
);
287 platform_set_drvdata(pdev
, wdt
);
289 dev_info(&pdev
->dev
, "initialized.\n");
291 pm_runtime_enable(&pdev
->dev
);
296 clk_disable(wdt
->clk
);
302 static int __devexit
sh_wdt_remove(struct platform_device
*pdev
)
304 struct sh_wdt
*wdt
= platform_get_drvdata(pdev
);
306 platform_set_drvdata(pdev
, NULL
);
308 watchdog_unregister_device(&sh_wdt_dev
);
310 pm_runtime_disable(&pdev
->dev
);
311 clk_disable(wdt
->clk
);
317 static void sh_wdt_shutdown(struct platform_device
*pdev
)
319 sh_wdt_stop(&sh_wdt_dev
);
322 static struct platform_driver sh_wdt_driver
= {
325 .owner
= THIS_MODULE
,
328 .probe
= sh_wdt_probe
,
329 .remove
= __devexit_p(sh_wdt_remove
),
330 .shutdown
= sh_wdt_shutdown
,
333 static int __init
sh_wdt_init(void)
335 if (unlikely(clock_division_ratio
< 0x5 ||
336 clock_division_ratio
> 0x7)) {
337 clock_division_ratio
= WTCSR_CKS_4096
;
339 pr_info("divisor must be 0x5<=x<=0x7, using %d\n",
340 clock_division_ratio
);
343 return platform_driver_register(&sh_wdt_driver
);
346 static void __exit
sh_wdt_exit(void)
348 platform_driver_unregister(&sh_wdt_driver
);
350 module_init(sh_wdt_init
);
351 module_exit(sh_wdt_exit
);
353 MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>");
354 MODULE_DESCRIPTION("SuperH watchdog driver");
355 MODULE_LICENSE("GPL");
356 MODULE_ALIAS("platform:" DRV_NAME
);
357 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR
);
359 module_param(clock_division_ratio
, int, 0);
360 MODULE_PARM_DESC(clock_division_ratio
,
361 "Clock division ratio. Valid ranges are from 0x5 (1.31ms) "
362 "to 0x7 (5.25ms). (default=" __MODULE_STRING(WTCSR_CKS_4096
) ")");
364 module_param(heartbeat
, int, 0);
365 MODULE_PARM_DESC(heartbeat
,
366 "Watchdog heartbeat in seconds. (1 <= heartbeat <= 3600, default="
367 __MODULE_STRING(WATCHDOG_HEARTBEAT
) ")");
369 module_param(nowayout
, bool, 0);
370 MODULE_PARM_DESC(nowayout
,
371 "Watchdog cannot be stopped once started (default="
372 __MODULE_STRING(WATCHDOG_NOWAYOUT
) ")");