Merge branch 'for-linus' of git://neil.brown.name/md
[linux-2.6] / drivers / watchdog / mpc8xxx_wdt.c
1 /*
2  * mpc8xxx_wdt.c - MPC8xx/MPC83xx/MPC86xx watchdog userspace interface
3  *
4  * Authors: Dave Updegraff <dave@cray.org>
5  *          Kumar Gala <galak@kernel.crashing.org>
6  *              Attribution: from 83xx_wst: Florian Schirmer <jolt@tuxbox.org>
7  *                              ..and from sc520_wdt
8  * Copyright (c) 2008  MontaVista Software, Inc.
9  *                     Anton Vorontsov <avorontsov@ru.mvista.com>
10  *
11  * Note: it appears that you can only actually ENABLE or DISABLE the thing
12  * once after POR. Once enabled, you cannot disable, and vice versa.
13  *
14  * This program is free software; you can redistribute  it and/or modify it
15  * under  the terms of  the GNU General  Public License as published by the
16  * Free Software Foundation;  either version 2 of the  License, or (at your
17  * option) any later version.
18  */
19
20 #include <linux/fs.h>
21 #include <linux/init.h>
22 #include <linux/kernel.h>
23 #include <linux/timer.h>
24 #include <linux/miscdevice.h>
25 #include <linux/of_platform.h>
26 #include <linux/module.h>
27 #include <linux/watchdog.h>
28 #include <linux/io.h>
29 #include <linux/uaccess.h>
30 #include <sysdev/fsl_soc.h>
31
32 struct mpc8xxx_wdt {
33         __be32 res0;
34         __be32 swcrr; /* System watchdog control register */
35 #define SWCRR_SWTC 0xFFFF0000 /* Software Watchdog Time Count. */
36 #define SWCRR_SWEN 0x00000004 /* Watchdog Enable bit. */
37 #define SWCRR_SWRI 0x00000002 /* Software Watchdog Reset/Interrupt Select bit.*/
38 #define SWCRR_SWPR 0x00000001 /* Software Watchdog Counter Prescale bit. */
39         __be32 swcnr; /* System watchdog count register */
40         u8 res1[2];
41         __be16 swsrr; /* System watchdog service register */
42         u8 res2[0xF0];
43 };
44
45 struct mpc8xxx_wdt_type {
46         int prescaler;
47         bool hw_enabled;
48 };
49
50 static struct mpc8xxx_wdt __iomem *wd_base;
51
52 static u16 timeout = 0xffff;
53 module_param(timeout, ushort, 0);
54 MODULE_PARM_DESC(timeout,
55         "Watchdog timeout in ticks. (0<timeout<65536, default=65535");
56
57 static int reset = 1;
58 module_param(reset, bool, 0);
59 MODULE_PARM_DESC(reset,
60         "Watchdog Interrupt/Reset Mode. 0 = interrupt, 1 = reset");
61
62 static int nowayout = WATCHDOG_NOWAYOUT;
63 module_param(nowayout, int, 0);
64 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
65                  "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
66
67 /*
68  * We always prescale, but if someone really doesn't want to they can set this
69  * to 0
70  */
71 static int prescale = 1;
72 static unsigned int timeout_sec;
73
74 static unsigned long wdt_is_open;
75 static DEFINE_SPINLOCK(wdt_spinlock);
76
77 static void mpc8xxx_wdt_keepalive(void)
78 {
79         /* Ping the WDT */
80         spin_lock(&wdt_spinlock);
81         out_be16(&wd_base->swsrr, 0x556c);
82         out_be16(&wd_base->swsrr, 0xaa39);
83         spin_unlock(&wdt_spinlock);
84 }
85
86 static void mpc8xxx_wdt_timer_ping(unsigned long arg);
87 static DEFINE_TIMER(wdt_timer, mpc8xxx_wdt_timer_ping, 0, 0);
88
89 static void mpc8xxx_wdt_timer_ping(unsigned long arg)
90 {
91         mpc8xxx_wdt_keepalive();
92         /* We're pinging it twice faster than needed, just to be sure. */
93         mod_timer(&wdt_timer, jiffies + HZ * timeout_sec / 2);
94 }
95
96 static void mpc8xxx_wdt_pr_warn(const char *msg)
97 {
98         pr_crit("mpc8xxx_wdt: %s, expect the %s soon!\n", msg,
99                 reset ? "reset" : "machine check exception");
100 }
101
102 static ssize_t mpc8xxx_wdt_write(struct file *file, const char __user *buf,
103                                  size_t count, loff_t *ppos)
104 {
105         if (count)
106                 mpc8xxx_wdt_keepalive();
107         return count;
108 }
109
110 static int mpc8xxx_wdt_open(struct inode *inode, struct file *file)
111 {
112         u32 tmp = SWCRR_SWEN;
113         if (test_and_set_bit(0, &wdt_is_open))
114                 return -EBUSY;
115
116         /* Once we start the watchdog we can't stop it */
117         if (nowayout)
118                 __module_get(THIS_MODULE);
119
120         /* Good, fire up the show */
121         if (prescale)
122                 tmp |= SWCRR_SWPR;
123         if (reset)
124                 tmp |= SWCRR_SWRI;
125
126         tmp |= timeout << 16;
127
128         out_be32(&wd_base->swcrr, tmp);
129
130         del_timer_sync(&wdt_timer);
131
132         return nonseekable_open(inode, file);
133 }
134
135 static int mpc8xxx_wdt_release(struct inode *inode, struct file *file)
136 {
137         if (!nowayout)
138                 mpc8xxx_wdt_timer_ping(0);
139         else
140                 mpc8xxx_wdt_pr_warn("watchdog closed");
141         clear_bit(0, &wdt_is_open);
142         return 0;
143 }
144
145 static long mpc8xxx_wdt_ioctl(struct file *file, unsigned int cmd,
146                                                         unsigned long arg)
147 {
148         void __user *argp = (void __user *)arg;
149         int __user *p = argp;
150         static struct watchdog_info ident = {
151                 .options = WDIOF_KEEPALIVEPING,
152                 .firmware_version = 1,
153                 .identity = "MPC8xxx",
154         };
155
156         switch (cmd) {
157         case WDIOC_GETSUPPORT:
158                 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
159         case WDIOC_GETSTATUS:
160         case WDIOC_GETBOOTSTATUS:
161                 return put_user(0, p);
162         case WDIOC_KEEPALIVE:
163                 mpc8xxx_wdt_keepalive();
164                 return 0;
165         case WDIOC_GETTIMEOUT:
166                 return put_user(timeout_sec, p);
167         default:
168                 return -ENOTTY;
169         }
170 }
171
172 static const struct file_operations mpc8xxx_wdt_fops = {
173         .owner          = THIS_MODULE,
174         .llseek         = no_llseek,
175         .write          = mpc8xxx_wdt_write,
176         .unlocked_ioctl = mpc8xxx_wdt_ioctl,
177         .open           = mpc8xxx_wdt_open,
178         .release        = mpc8xxx_wdt_release,
179 };
180
181 static struct miscdevice mpc8xxx_wdt_miscdev = {
182         .minor  = WATCHDOG_MINOR,
183         .name   = "watchdog",
184         .fops   = &mpc8xxx_wdt_fops,
185 };
186
187 static int __devinit mpc8xxx_wdt_probe(struct of_device *ofdev,
188                                        const struct of_device_id *match)
189 {
190         int ret;
191         struct device_node *np = ofdev->node;
192         struct mpc8xxx_wdt_type *wdt_type = match->data;
193         u32 freq = fsl_get_sys_freq();
194         bool enabled;
195
196         if (!freq || freq == -1)
197                 return -EINVAL;
198
199         wd_base = of_iomap(np, 0);
200         if (!wd_base)
201                 return -ENOMEM;
202
203         enabled = in_be32(&wd_base->swcrr) & SWCRR_SWEN;
204         if (!enabled && wdt_type->hw_enabled) {
205                 pr_info("mpc8xxx_wdt: could not be enabled in software\n");
206                 ret = -ENOSYS;
207                 goto err_unmap;
208         }
209
210         /* Calculate the timeout in seconds */
211         if (prescale)
212                 timeout_sec = (timeout * wdt_type->prescaler) / freq;
213         else
214                 timeout_sec = timeout / freq;
215
216         pr_info("WDT driver for MPC8xxx initialized. mode:%s timeout=%d "
217                 "(%d seconds)\n", reset ? "reset" : "interrupt", timeout,
218                 timeout_sec);
219
220         /*
221          * If the watchdog was previously enabled or we're running on
222          * MPC8xxx, we should ping the wdt from the kernel until the
223          * userspace handles it.
224          */
225         if (enabled)
226                 mpc8xxx_wdt_timer_ping(0);
227         return 0;
228 err_unmap:
229         iounmap(wd_base);
230         wd_base = NULL;
231         return ret;
232 }
233
234 static int __devexit mpc8xxx_wdt_remove(struct of_device *ofdev)
235 {
236         mpc8xxx_wdt_pr_warn("watchdog removed");
237         del_timer_sync(&wdt_timer);
238         misc_deregister(&mpc8xxx_wdt_miscdev);
239         iounmap(wd_base);
240
241         return 0;
242 }
243
244 static const struct of_device_id mpc8xxx_wdt_match[] = {
245         {
246                 .compatible = "mpc83xx_wdt",
247                 .data = &(struct mpc8xxx_wdt_type) {
248                         .prescaler = 0x10000,
249                 },
250         },
251         {
252                 .compatible = "fsl,mpc8610-wdt",
253                 .data = &(struct mpc8xxx_wdt_type) {
254                         .prescaler = 0x10000,
255                         .hw_enabled = true,
256                 },
257         },
258         {
259                 .compatible = "fsl,mpc823-wdt",
260                 .data = &(struct mpc8xxx_wdt_type) {
261                         .prescaler = 0x800,
262                 },
263         },
264         {},
265 };
266 MODULE_DEVICE_TABLE(of, mpc8xxx_wdt_match);
267
268 static struct of_platform_driver mpc8xxx_wdt_driver = {
269         .match_table    = mpc8xxx_wdt_match,
270         .probe          = mpc8xxx_wdt_probe,
271         .remove         = __devexit_p(mpc8xxx_wdt_remove),
272         .driver         = {
273                 .name   = "mpc8xxx_wdt",
274                 .owner  = THIS_MODULE,
275         },
276 };
277
278 /*
279  * We do wdt initialization in two steps: arch_initcall probes the wdt
280  * very early to start pinging the watchdog (misc devices are not yet
281  * available), and later module_init() just registers the misc device.
282  */
283 static int __init mpc8xxx_wdt_init_late(void)
284 {
285         int ret;
286
287         if (!wd_base)
288                 return -ENODEV;
289
290         ret = misc_register(&mpc8xxx_wdt_miscdev);
291         if (ret) {
292                 pr_err("cannot register miscdev on minor=%d (err=%d)\n",
293                         WATCHDOG_MINOR, ret);
294                 return ret;
295         }
296         return 0;
297 }
298 module_init(mpc8xxx_wdt_init_late);
299
300 static int __init mpc8xxx_wdt_init(void)
301 {
302         return of_register_platform_driver(&mpc8xxx_wdt_driver);
303 }
304 arch_initcall(mpc8xxx_wdt_init);
305
306 static void __exit mpc8xxx_wdt_exit(void)
307 {
308         of_unregister_platform_driver(&mpc8xxx_wdt_driver);
309 }
310 module_exit(mpc8xxx_wdt_exit);
311
312 MODULE_AUTHOR("Dave Updegraff, Kumar Gala");
313 MODULE_DESCRIPTION("Driver for watchdog timer in MPC8xx/MPC83xx/MPC86xx "
314                    "uProcessors");
315 MODULE_LICENSE("GPL");
316 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);