blob: 85b93e15d01122aefad8c9433221670041afde97 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* linux/drivers/char/watchdog/s3c2410_wdt.c
2 *
3 * Copyright (c) 2004 Simtec Electronics
4 * Ben Dooks <ben@simtec.co.uk>
5 *
6 * S3C2410 Watchdog Timer Support
7 *
8 * Based on, softdog.c by Alan Cox,
Alan Cox29fa0582008-10-27 15:17:56 +00009 * (c) Copyright 1996 Alan Cox <alan@lxorguk.ukuu.org.uk>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070024*/
25
26#include <linux/module.h>
27#include <linux/moduleparam.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/types.h>
29#include <linux/timer.h>
30#include <linux/miscdevice.h>
31#include <linux/watchdog.h>
32#include <linux/fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/init.h>
Russell Kingd052d1b2005-10-29 19:07:23 +010034#include <linux/platform_device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/interrupt.h>
Russell Kingf8ce2542006-01-07 16:15:52 +000036#include <linux/clk.h>
Alan Cox41dc8b72008-08-04 17:54:46 +010037#include <linux/uaccess.h>
38#include <linux/io.h>
Ben Dookse02f8382009-10-30 00:30:25 +000039#include <linux/cpufreq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Russell Kinga09e64f2008-08-05 16:14:15 +010041#include <mach/map.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Ben Dooksb4307082007-07-24 13:28:01 +010043#undef S3C_VA_WATCHDOG
44#define S3C_VA_WATCHDOG (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Ben Dooks180ee702008-10-30 10:14:32 +000046#include <plat/regs-watchdog.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
48#define PFX "s3c2410-wdt: "
49
50#define CONFIG_S3C2410_WATCHDOG_ATBOOT (0)
51#define CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME (15)
52
Ben Dooks25ff3782006-09-06 12:24:35 +010053static int nowayout = WATCHDOG_NOWAYOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054static int tmr_margin = CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME;
55static int tmr_atboot = CONFIG_S3C2410_WATCHDOG_ATBOOT;
Alan Cox41dc8b72008-08-04 17:54:46 +010056static int soft_noboot;
57static int debug;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59module_param(tmr_margin, int, 0);
60module_param(tmr_atboot, int, 0);
61module_param(nowayout, int, 0);
62module_param(soft_noboot, int, 0);
63module_param(debug, int, 0);
64
Alan Cox41dc8b72008-08-04 17:54:46 +010065MODULE_PARM_DESC(tmr_margin, "Watchdog tmr_margin in seconds. default="
66 __MODULE_STRING(CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME) ")");
67MODULE_PARM_DESC(tmr_atboot,
68 "Watchdog is started at boot time if set to 1, default="
69 __MODULE_STRING(CONFIG_S3C2410_WATCHDOG_ATBOOT));
70MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
71 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
Wim Van Sebroecka77dba72009-04-14 20:20:07 +000072MODULE_PARM_DESC(soft_noboot, "Watchdog action, set to 1 to ignore reboots, "
73 "0 to reboot (default depends on ONLY_TESTING)");
Linus Torvalds1da177e2005-04-16 15:20:36 -070074MODULE_PARM_DESC(debug, "Watchdog debug, set to >1 for debug, (default 0)");
75
Alan Cox41dc8b72008-08-04 17:54:46 +010076static unsigned long open_lock;
Ben Dookse8ef92b2007-06-14 12:08:55 +010077static struct device *wdt_dev; /* platform device attached to */
Linus Torvalds1da177e2005-04-16 15:20:36 -070078static struct resource *wdt_mem;
79static struct resource *wdt_irq;
80static struct clk *wdt_clock;
81static void __iomem *wdt_base;
82static unsigned int wdt_count;
Wim Van Sebroecka77dba72009-04-14 20:20:07 +000083static char expect_close;
Alan Cox41dc8b72008-08-04 17:54:46 +010084static DEFINE_SPINLOCK(wdt_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86/* watchdog control routines */
87
88#define DBG(msg...) do { \
89 if (debug) \
90 printk(KERN_INFO msg); \
Alan Cox41dc8b72008-08-04 17:54:46 +010091 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
93/* functions */
94
Alan Cox41dc8b72008-08-04 17:54:46 +010095static void s3c2410wdt_keepalive(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070096{
Alan Cox41dc8b72008-08-04 17:54:46 +010097 spin_lock(&wdt_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 writel(wdt_count, wdt_base + S3C2410_WTCNT);
Alan Cox41dc8b72008-08-04 17:54:46 +010099 spin_unlock(&wdt_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100}
101
Alan Cox41dc8b72008-08-04 17:54:46 +0100102static void __s3c2410wdt_stop(void)
103{
104 unsigned long wtcon;
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 wtcon = readl(wdt_base + S3C2410_WTCON);
107 wtcon &= ~(S3C2410_WTCON_ENABLE | S3C2410_WTCON_RSTEN);
108 writel(wtcon, wdt_base + S3C2410_WTCON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109}
110
Alan Cox41dc8b72008-08-04 17:54:46 +0100111static void s3c2410wdt_stop(void)
112{
113 spin_lock(&wdt_lock);
114 __s3c2410wdt_stop();
115 spin_unlock(&wdt_lock);
116}
117
118static void s3c2410wdt_start(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
120 unsigned long wtcon;
121
Alan Cox41dc8b72008-08-04 17:54:46 +0100122 spin_lock(&wdt_lock);
123
124 __s3c2410wdt_stop();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126 wtcon = readl(wdt_base + S3C2410_WTCON);
127 wtcon |= S3C2410_WTCON_ENABLE | S3C2410_WTCON_DIV128;
128
129 if (soft_noboot) {
130 wtcon |= S3C2410_WTCON_INTEN;
131 wtcon &= ~S3C2410_WTCON_RSTEN;
132 } else {
133 wtcon &= ~S3C2410_WTCON_INTEN;
134 wtcon |= S3C2410_WTCON_RSTEN;
135 }
136
137 DBG("%s: wdt_count=0x%08x, wtcon=%08lx\n",
Harvey Harrisonfa9363c2008-03-05 18:24:58 -0800138 __func__, wdt_count, wtcon);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
140 writel(wdt_count, wdt_base + S3C2410_WTDAT);
141 writel(wdt_count, wdt_base + S3C2410_WTCNT);
142 writel(wtcon, wdt_base + S3C2410_WTCON);
Alan Cox41dc8b72008-08-04 17:54:46 +0100143 spin_unlock(&wdt_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144}
145
Ben Dookse02f8382009-10-30 00:30:25 +0000146static inline int s3c2410wdt_is_running(void)
147{
148 return readl(wdt_base + S3C2410_WTCON) & S3C2410_WTCON_ENABLE;
149}
150
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151static int s3c2410wdt_set_heartbeat(int timeout)
152{
Ben Dookse02f8382009-10-30 00:30:25 +0000153 unsigned long freq = clk_get_rate(wdt_clock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 unsigned int count;
155 unsigned int divisor = 1;
156 unsigned long wtcon;
157
158 if (timeout < 1)
159 return -EINVAL;
160
161 freq /= 128;
162 count = timeout * freq;
163
Ben Dookse02f8382009-10-30 00:30:25 +0000164 DBG("%s: count=%d, timeout=%d, freq=%lu\n",
Harvey Harrisonfa9363c2008-03-05 18:24:58 -0800165 __func__, count, timeout, freq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
167 /* if the count is bigger than the watchdog register,
168 then work out what we need to do (and if) we can
169 actually make this value
170 */
171
172 if (count >= 0x10000) {
173 for (divisor = 1; divisor <= 0x100; divisor++) {
174 if ((count / divisor) < 0x10000)
175 break;
176 }
177
178 if ((count / divisor) >= 0x10000) {
Ben Dookse8ef92b2007-06-14 12:08:55 +0100179 dev_err(wdt_dev, "timeout %d too big\n", timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 return -EINVAL;
181 }
182 }
183
184 tmr_margin = timeout;
185
186 DBG("%s: timeout=%d, divisor=%d, count=%d (%08x)\n",
Harvey Harrisonfa9363c2008-03-05 18:24:58 -0800187 __func__, timeout, divisor, count, count/divisor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
189 count /= divisor;
190 wdt_count = count;
191
192 /* update the pre-scaler */
193 wtcon = readl(wdt_base + S3C2410_WTCON);
194 wtcon &= ~S3C2410_WTCON_PRESCALE_MASK;
195 wtcon |= S3C2410_WTCON_PRESCALE(divisor-1);
196
197 writel(count, wdt_base + S3C2410_WTDAT);
198 writel(wtcon, wdt_base + S3C2410_WTCON);
199
200 return 0;
201}
202
203/*
204 * /dev/watchdog handling
205 */
206
207static int s3c2410wdt_open(struct inode *inode, struct file *file)
208{
Alan Cox41dc8b72008-08-04 17:54:46 +0100209 if (test_and_set_bit(0, &open_lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 return -EBUSY;
211
Ben Dooks25ff3782006-09-06 12:24:35 +0100212 if (nowayout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 __module_get(THIS_MODULE);
Ben Dooks25ff3782006-09-06 12:24:35 +0100214
Wim Van Sebroecka77dba72009-04-14 20:20:07 +0000215 expect_close = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
217 /* start the timer */
218 s3c2410wdt_start();
219 return nonseekable_open(inode, file);
220}
221
222static int s3c2410wdt_release(struct inode *inode, struct file *file)
223{
224 /*
225 * Shut off the timer.
226 * Lock it in if it's a module and we set nowayout
227 */
Ben Dooks25ff3782006-09-06 12:24:35 +0100228
Wim Van Sebroecka77dba72009-04-14 20:20:07 +0000229 if (expect_close == 42)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 s3c2410wdt_stop();
Alan Cox41dc8b72008-08-04 17:54:46 +0100231 else {
Ben Dookse8ef92b2007-06-14 12:08:55 +0100232 dev_err(wdt_dev, "Unexpected close, not stopping watchdog\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 s3c2410wdt_keepalive();
234 }
Wim Van Sebroecka77dba72009-04-14 20:20:07 +0000235 expect_close = 0;
Alan Cox41dc8b72008-08-04 17:54:46 +0100236 clear_bit(0, &open_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 return 0;
238}
239
240static ssize_t s3c2410wdt_write(struct file *file, const char __user *data,
241 size_t len, loff_t *ppos)
242{
243 /*
244 * Refresh the timer.
245 */
Alan Cox41dc8b72008-08-04 17:54:46 +0100246 if (len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 if (!nowayout) {
248 size_t i;
249
250 /* In case it was set long ago */
Wim Van Sebroecka77dba72009-04-14 20:20:07 +0000251 expect_close = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 for (i = 0; i != len; i++) {
254 char c;
255
256 if (get_user(c, data + i))
257 return -EFAULT;
258 if (c == 'V')
Wim Van Sebroecka77dba72009-04-14 20:20:07 +0000259 expect_close = 42;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 }
261 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 s3c2410wdt_keepalive();
263 }
264 return len;
265}
266
Wim Van Sebroecka77dba72009-04-14 20:20:07 +0000267#define OPTIONS (WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
Alan Cox41dc8b72008-08-04 17:54:46 +0100269static const struct watchdog_info s3c2410_wdt_ident = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 .options = OPTIONS,
271 .firmware_version = 0,
272 .identity = "S3C2410 Watchdog",
273};
274
275
Alan Cox41dc8b72008-08-04 17:54:46 +0100276static long s3c2410wdt_ioctl(struct file *file, unsigned int cmd,
277 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278{
279 void __user *argp = (void __user *)arg;
280 int __user *p = argp;
281 int new_margin;
282
283 switch (cmd) {
Alan Cox41dc8b72008-08-04 17:54:46 +0100284 case WDIOC_GETSUPPORT:
285 return copy_to_user(argp, &s3c2410_wdt_ident,
286 sizeof(s3c2410_wdt_ident)) ? -EFAULT : 0;
287 case WDIOC_GETSTATUS:
288 case WDIOC_GETBOOTSTATUS:
289 return put_user(0, p);
290 case WDIOC_KEEPALIVE:
291 s3c2410wdt_keepalive();
292 return 0;
293 case WDIOC_SETTIMEOUT:
294 if (get_user(new_margin, p))
295 return -EFAULT;
296 if (s3c2410wdt_set_heartbeat(new_margin))
297 return -EINVAL;
298 s3c2410wdt_keepalive();
299 return put_user(tmr_margin, p);
300 case WDIOC_GETTIMEOUT:
301 return put_user(tmr_margin, p);
Wim Van Sebroeck0c060902008-07-18 11:41:17 +0000302 default:
303 return -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 }
305}
306
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307/* kernel interface */
308
Arjan van de Ven62322d22006-07-03 00:24:21 -0700309static const struct file_operations s3c2410wdt_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 .owner = THIS_MODULE,
311 .llseek = no_llseek,
312 .write = s3c2410wdt_write,
Alan Cox41dc8b72008-08-04 17:54:46 +0100313 .unlocked_ioctl = s3c2410wdt_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 .open = s3c2410wdt_open,
315 .release = s3c2410wdt_release,
316};
317
318static struct miscdevice s3c2410wdt_miscdev = {
319 .minor = WATCHDOG_MINOR,
320 .name = "watchdog",
321 .fops = &s3c2410wdt_fops,
322};
323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324/* interrupt handler code */
325
David Howells7d12e782006-10-05 14:55:46 +0100326static irqreturn_t s3c2410wdt_irq(int irqno, void *param)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
Ben Dookse8ef92b2007-06-14 12:08:55 +0100328 dev_info(wdt_dev, "watchdog timer expired (irq)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
330 s3c2410wdt_keepalive();
331 return IRQ_HANDLED;
332}
Ben Dookse02f8382009-10-30 00:30:25 +0000333
334
335#ifdef CONFIG_CPU_FREQ
336
337static int s3c2410wdt_cpufreq_transition(struct notifier_block *nb,
338 unsigned long val, void *data)
339{
340 int ret;
341
342 if (!s3c2410wdt_is_running())
343 goto done;
344
345 if (val == CPUFREQ_PRECHANGE) {
346 /* To ensure that over the change we don't cause the
347 * watchdog to trigger, we perform an keep-alive if
348 * the watchdog is running.
349 */
350
351 s3c2410wdt_keepalive();
352 } else if (val == CPUFREQ_POSTCHANGE) {
353 s3c2410wdt_stop();
354
355 ret = s3c2410wdt_set_heartbeat(tmr_margin);
356
357 if (ret >= 0)
358 s3c2410wdt_start();
359 else
360 goto err;
361 }
362
363done:
364 return 0;
365
366 err:
367 dev_err(wdt_dev, "cannot set new value for timeout %d\n", tmr_margin);
368 return ret;
369}
370
371static struct notifier_block s3c2410wdt_cpufreq_transition_nb = {
372 .notifier_call = s3c2410wdt_cpufreq_transition,
373};
374
375static inline int s3c2410wdt_cpufreq_register(void)
376{
377 return cpufreq_register_notifier(&s3c2410wdt_cpufreq_transition_nb,
378 CPUFREQ_TRANSITION_NOTIFIER);
379}
380
381static inline void s3c2410wdt_cpufreq_deregister(void)
382{
383 cpufreq_unregister_notifier(&s3c2410wdt_cpufreq_transition_nb,
384 CPUFREQ_TRANSITION_NOTIFIER);
385}
386
387#else
388static inline int s3c2410wdt_cpufreq_register(void)
389{
390 return 0;
391}
392
393static inline void s3c2410wdt_cpufreq_deregister(void)
394{
395}
396#endif
397
398
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400/* device interface */
401
Wim Van Sebroecka77dba72009-04-14 20:20:07 +0000402static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 struct resource *res;
Ben Dookse8ef92b2007-06-14 12:08:55 +0100405 struct device *dev;
Ben Dooks46b814d2007-06-14 12:08:54 +0100406 unsigned int wtcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 int started = 0;
408 int ret;
409 int size;
410
Harvey Harrisonfa9363c2008-03-05 18:24:58 -0800411 DBG("%s: probe=%p\n", __func__, pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
Ben Dookse8ef92b2007-06-14 12:08:55 +0100413 dev = &pdev->dev;
414 wdt_dev = &pdev->dev;
415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 /* get the memory region for the watchdog timer */
417
418 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
419 if (res == NULL) {
Ben Dookse8ef92b2007-06-14 12:08:55 +0100420 dev_err(dev, "no memory resource specified\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 return -ENOENT;
422 }
423
Ben Dooks0e65fb22008-06-22 22:36:51 +0100424 size = (res->end - res->start) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 wdt_mem = request_mem_region(res->start, size, pdev->name);
426 if (wdt_mem == NULL) {
Ben Dookse8ef92b2007-06-14 12:08:55 +0100427 dev_err(dev, "failed to get memory region\n");
Ben Dooks0b6dd8a2006-12-18 10:31:32 +0000428 ret = -ENOENT;
429 goto err_req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 }
431
432 wdt_base = ioremap(res->start, size);
Ben Dooksb4253f82008-06-22 22:36:49 +0100433 if (wdt_base == NULL) {
Ben Dookse8ef92b2007-06-14 12:08:55 +0100434 dev_err(dev, "failed to ioremap() region\n");
Ben Dooks0b6dd8a2006-12-18 10:31:32 +0000435 ret = -EINVAL;
436 goto err_req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 }
438
439 DBG("probe: mapped wdt_base=%p\n", wdt_base);
440
Arnaud Patard62be07412007-05-05 15:53:15 +0200441 wdt_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
442 if (wdt_irq == NULL) {
Ben Dookse8ef92b2007-06-14 12:08:55 +0100443 dev_err(dev, "no irq resource specified\n");
Ben Dooks0b6dd8a2006-12-18 10:31:32 +0000444 ret = -ENOENT;
445 goto err_map;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 }
447
Arnaud Patard62be07412007-05-05 15:53:15 +0200448 ret = request_irq(wdt_irq->start, s3c2410wdt_irq, 0, pdev->name, pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 if (ret != 0) {
Ben Dookse8ef92b2007-06-14 12:08:55 +0100450 dev_err(dev, "failed to install irq (%d)\n", ret);
Ben Dooks0b6dd8a2006-12-18 10:31:32 +0000451 goto err_map;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
453
Russell King3ae5eae2005-11-09 22:32:44 +0000454 wdt_clock = clk_get(&pdev->dev, "watchdog");
Akinobu Mita9cd44612006-12-19 17:51:44 +0900455 if (IS_ERR(wdt_clock)) {
Ben Dookse8ef92b2007-06-14 12:08:55 +0100456 dev_err(dev, "failed to find watchdog clock source\n");
Akinobu Mita9cd44612006-12-19 17:51:44 +0900457 ret = PTR_ERR(wdt_clock);
Ben Dooks0b6dd8a2006-12-18 10:31:32 +0000458 goto err_irq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 }
460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 clk_enable(wdt_clock);
462
Ben Dookse02f8382009-10-30 00:30:25 +0000463 if (s3c2410wdt_cpufreq_register() < 0) {
464 printk(KERN_ERR PFX "failed to register cpufreq\n");
465 goto err_clk;
466 }
467
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 /* see if we can actually set the requested timer margin, and if
469 * not, try the default value */
470
471 if (s3c2410wdt_set_heartbeat(tmr_margin)) {
Alan Cox41dc8b72008-08-04 17:54:46 +0100472 started = s3c2410wdt_set_heartbeat(
473 CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Alan Cox41dc8b72008-08-04 17:54:46 +0100475 if (started == 0)
476 dev_info(dev,
477 "tmr_margin value out of range, default %d used\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME);
Alan Cox41dc8b72008-08-04 17:54:46 +0100479 else
Wim Van Sebroecka77dba72009-04-14 20:20:07 +0000480 dev_info(dev, "default timer value is out of range, "
481 "cannot start\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 }
483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 ret = misc_register(&s3c2410wdt_miscdev);
485 if (ret) {
Ben Dookse8ef92b2007-06-14 12:08:55 +0100486 dev_err(dev, "cannot register miscdev on minor=%d (%d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 WATCHDOG_MINOR, ret);
Ben Dookse02f8382009-10-30 00:30:25 +0000488 goto err_cpufreq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 }
490
491 if (tmr_atboot && started == 0) {
Ben Dookse8ef92b2007-06-14 12:08:55 +0100492 dev_info(dev, "starting watchdog timer\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 s3c2410wdt_start();
Ben Dooks655516c2006-04-19 23:02:56 +0100494 } else if (!tmr_atboot) {
495 /* if we're not enabling the watchdog, then ensure it is
496 * disabled if it has been left running from the bootloader
497 * or other source */
498
499 s3c2410wdt_stop();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 }
501
Ben Dooks46b814d2007-06-14 12:08:54 +0100502 /* print out a statement of readiness */
503
504 wtcon = readl(wdt_base + S3C2410_WTCON);
505
Ben Dookse8ef92b2007-06-14 12:08:55 +0100506 dev_info(dev, "watchdog %sactive, reset %sabled, irq %sabled\n",
Ben Dooks46b814d2007-06-14 12:08:54 +0100507 (wtcon & S3C2410_WTCON_ENABLE) ? "" : "in",
508 (wtcon & S3C2410_WTCON_RSTEN) ? "" : "dis",
509 (wtcon & S3C2410_WTCON_INTEN) ? "" : "en");
Alan Cox41dc8b72008-08-04 17:54:46 +0100510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 return 0;
Ben Dooks0b6dd8a2006-12-18 10:31:32 +0000512
Ben Dookse02f8382009-10-30 00:30:25 +0000513 err_cpufreq:
514 s3c2410wdt_cpufreq_deregister();
515
Ben Dooks0b6dd8a2006-12-18 10:31:32 +0000516 err_clk:
517 clk_disable(wdt_clock);
518 clk_put(wdt_clock);
519
520 err_irq:
521 free_irq(wdt_irq->start, pdev);
522
523 err_map:
524 iounmap(wdt_base);
525
526 err_req:
527 release_resource(wdt_mem);
528 kfree(wdt_mem);
529
530 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531}
532
Wim Van Sebroecka77dba72009-04-14 20:20:07 +0000533static int __devexit s3c2410wdt_remove(struct platform_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534{
Ben Dookse02f8382009-10-30 00:30:25 +0000535 s3c2410wdt_cpufreq_deregister();
536
Ben Dooks0b6dd8a2006-12-18 10:31:32 +0000537 release_resource(wdt_mem);
538 kfree(wdt_mem);
539 wdt_mem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
Ben Dooks0b6dd8a2006-12-18 10:31:32 +0000541 free_irq(wdt_irq->start, dev);
542 wdt_irq = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Ben Dooks0b6dd8a2006-12-18 10:31:32 +0000544 clk_disable(wdt_clock);
545 clk_put(wdt_clock);
546 wdt_clock = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
Amol Lade34477e2006-10-06 13:41:12 -0700548 iounmap(wdt_base);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 misc_deregister(&s3c2410wdt_miscdev);
550 return 0;
551}
552
Russell King3ae5eae2005-11-09 22:32:44 +0000553static void s3c2410wdt_shutdown(struct platform_device *dev)
Ben Dooks94f1e9f2005-08-17 09:04:52 +0200554{
Alan Cox41dc8b72008-08-04 17:54:46 +0100555 s3c2410wdt_stop();
Ben Dooks94f1e9f2005-08-17 09:04:52 +0200556}
557
Ben Dooksaf4bb822005-08-17 09:03:23 +0200558#ifdef CONFIG_PM
559
560static unsigned long wtcon_save;
561static unsigned long wtdat_save;
562
Russell King3ae5eae2005-11-09 22:32:44 +0000563static int s3c2410wdt_suspend(struct platform_device *dev, pm_message_t state)
Ben Dooksaf4bb822005-08-17 09:03:23 +0200564{
Russell King9480e302005-10-28 09:52:56 -0700565 /* Save watchdog state, and turn it off. */
566 wtcon_save = readl(wdt_base + S3C2410_WTCON);
567 wtdat_save = readl(wdt_base + S3C2410_WTDAT);
Ben Dooksaf4bb822005-08-17 09:03:23 +0200568
Russell King9480e302005-10-28 09:52:56 -0700569 /* Note that WTCNT doesn't need to be saved. */
570 s3c2410wdt_stop();
Ben Dooksaf4bb822005-08-17 09:03:23 +0200571
572 return 0;
573}
574
Russell King3ae5eae2005-11-09 22:32:44 +0000575static int s3c2410wdt_resume(struct platform_device *dev)
Ben Dooksaf4bb822005-08-17 09:03:23 +0200576{
Russell King9480e302005-10-28 09:52:56 -0700577 /* Restore watchdog state. */
Ben Dooksaf4bb822005-08-17 09:03:23 +0200578
Russell King9480e302005-10-28 09:52:56 -0700579 writel(wtdat_save, wdt_base + S3C2410_WTDAT);
580 writel(wtdat_save, wdt_base + S3C2410_WTCNT); /* Reset count */
581 writel(wtcon_save, wdt_base + S3C2410_WTCON);
Ben Dooksaf4bb822005-08-17 09:03:23 +0200582
Russell King9480e302005-10-28 09:52:56 -0700583 printk(KERN_INFO PFX "watchdog %sabled\n",
584 (wtcon_save & S3C2410_WTCON_ENABLE) ? "en" : "dis");
Ben Dooksaf4bb822005-08-17 09:03:23 +0200585
586 return 0;
587}
588
589#else
590#define s3c2410wdt_suspend NULL
591#define s3c2410wdt_resume NULL
592#endif /* CONFIG_PM */
593
594
Russell King3ae5eae2005-11-09 22:32:44 +0000595static struct platform_driver s3c2410wdt_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 .probe = s3c2410wdt_probe,
Wim Van Sebroecka77dba72009-04-14 20:20:07 +0000597 .remove = __devexit_p(s3c2410wdt_remove),
Ben Dooks94f1e9f2005-08-17 09:04:52 +0200598 .shutdown = s3c2410wdt_shutdown,
Ben Dooksaf4bb822005-08-17 09:03:23 +0200599 .suspend = s3c2410wdt_suspend,
600 .resume = s3c2410wdt_resume,
Russell King3ae5eae2005-11-09 22:32:44 +0000601 .driver = {
602 .owner = THIS_MODULE,
603 .name = "s3c2410-wdt",
604 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605};
606
607
Alan Cox41dc8b72008-08-04 17:54:46 +0100608static char banner[] __initdata =
609 KERN_INFO "S3C2410 Watchdog Timer, (c) 2004 Simtec Electronics\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
611static int __init watchdog_init(void)
612{
613 printk(banner);
Russell King3ae5eae2005-11-09 22:32:44 +0000614 return platform_driver_register(&s3c2410wdt_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615}
616
617static void __exit watchdog_exit(void)
618{
Russell King3ae5eae2005-11-09 22:32:44 +0000619 platform_driver_unregister(&s3c2410wdt_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620}
621
622module_init(watchdog_init);
623module_exit(watchdog_exit);
624
Ben Dooksaf4bb822005-08-17 09:03:23 +0200625MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>, "
626 "Dimitry Andric <dimitry.andric@tomtom.com>");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627MODULE_DESCRIPTION("S3C2410 Watchdog Device Driver");
628MODULE_LICENSE("GPL");
629MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
Kay Sieversf37d1932008-04-10 21:29:23 -0700630MODULE_ALIAS("platform:s3c2410-wdt");