1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21
22#include <linux/fs.h>
23#include <linux/init.h>
24#include <linux/kernel.h>
25#include <linux/timer.h>
26#include <linux/miscdevice.h>
27#include <linux/of_platform.h>
28#include <linux/module.h>
29#include <linux/watchdog.h>
30#include <linux/io.h>
31#include <linux/uaccess.h>
32#include <sysdev/fsl_soc.h>
33
34struct mpc8xxx_wdt {
35 __be32 res0;
36 __be32 swcrr;
37#define SWCRR_SWTC 0xFFFF0000
38#define SWCRR_SWEN 0x00000004
39#define SWCRR_SWRI 0x00000002
40#define SWCRR_SWPR 0x00000001
41 __be32 swcnr;
42 u8 res1[2];
43 __be16 swsrr;
44 u8 res2[0xF0];
45};
46
47struct mpc8xxx_wdt_type {
48 int prescaler;
49 bool hw_enabled;
50};
51
52static struct mpc8xxx_wdt __iomem *wd_base;
53static int mpc8xxx_wdt_init_late(void);
54
55static u16 timeout = 0xffff;
56module_param(timeout, ushort, 0);
57MODULE_PARM_DESC(timeout,
58 "Watchdog timeout in ticks. (0<timeout<65536, default=65535)");
59
60static bool reset = 1;
61module_param(reset, bool, 0);
62MODULE_PARM_DESC(reset,
63 "Watchdog Interrupt/Reset Mode. 0 = interrupt, 1 = reset");
64
65static bool nowayout = WATCHDOG_NOWAYOUT;
66module_param(nowayout, bool, 0);
67MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
68 "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
69
70
71
72
73
74static int prescale = 1;
75static unsigned int timeout_sec;
76
77static unsigned long wdt_is_open;
78static DEFINE_SPINLOCK(wdt_spinlock);
79
80static void mpc8xxx_wdt_keepalive(void)
81{
82
83 spin_lock(&wdt_spinlock);
84 out_be16(&wd_base->swsrr, 0x556c);
85 out_be16(&wd_base->swsrr, 0xaa39);
86 spin_unlock(&wdt_spinlock);
87}
88
89static void mpc8xxx_wdt_timer_ping(unsigned long arg);
90static DEFINE_TIMER(wdt_timer, mpc8xxx_wdt_timer_ping, 0, 0);
91
92static void mpc8xxx_wdt_timer_ping(unsigned long arg)
93{
94 mpc8xxx_wdt_keepalive();
95
96 mod_timer(&wdt_timer, jiffies + HZ * timeout_sec / 2);
97}
98
99static void mpc8xxx_wdt_pr_warn(const char *msg)
100{
101 pr_crit("%s, expect the %s soon!\n", msg,
102 reset ? "reset" : "machine check exception");
103}
104
105static ssize_t mpc8xxx_wdt_write(struct file *file, const char __user *buf,
106 size_t count, loff_t *ppos)
107{
108 if (count)
109 mpc8xxx_wdt_keepalive();
110 return count;
111}
112
113static int mpc8xxx_wdt_open(struct inode *inode, struct file *file)
114{
115 u32 tmp = SWCRR_SWEN;
116 if (test_and_set_bit(0, &wdt_is_open))
117 return -EBUSY;
118
119
120 if (nowayout)
121 __module_get(THIS_MODULE);
122
123
124 if (prescale)
125 tmp |= SWCRR_SWPR;
126 if (reset)
127 tmp |= SWCRR_SWRI;
128
129 tmp |= timeout << 16;
130
131 out_be32(&wd_base->swcrr, tmp);
132
133 del_timer_sync(&wdt_timer);
134
135 return nonseekable_open(inode, file);
136}
137
138static int mpc8xxx_wdt_release(struct inode *inode, struct file *file)
139{
140 if (!nowayout)
141 mpc8xxx_wdt_timer_ping(0);
142 else
143 mpc8xxx_wdt_pr_warn("watchdog closed");
144 clear_bit(0, &wdt_is_open);
145 return 0;
146}
147
148static long mpc8xxx_wdt_ioctl(struct file *file, unsigned int cmd,
149 unsigned long arg)
150{
151 void __user *argp = (void __user *)arg;
152 int __user *p = argp;
153 static const struct watchdog_info ident = {
154 .options = WDIOF_KEEPALIVEPING,
155 .firmware_version = 1,
156 .identity = "MPC8xxx",
157 };
158
159 switch (cmd) {
160 case WDIOC_GETSUPPORT:
161 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
162 case WDIOC_GETSTATUS:
163 case WDIOC_GETBOOTSTATUS:
164 return put_user(0, p);
165 case WDIOC_KEEPALIVE:
166 mpc8xxx_wdt_keepalive();
167 return 0;
168 case WDIOC_GETTIMEOUT:
169 return put_user(timeout_sec, p);
170 default:
171 return -ENOTTY;
172 }
173}
174
175static const struct file_operations mpc8xxx_wdt_fops = {
176 .owner = THIS_MODULE,
177 .llseek = no_llseek,
178 .write = mpc8xxx_wdt_write,
179 .unlocked_ioctl = mpc8xxx_wdt_ioctl,
180 .open = mpc8xxx_wdt_open,
181 .release = mpc8xxx_wdt_release,
182};
183
184static struct miscdevice mpc8xxx_wdt_miscdev = {
185 .minor = WATCHDOG_MINOR,
186 .name = "watchdog",
187 .fops = &mpc8xxx_wdt_fops,
188};
189
190static const struct of_device_id mpc8xxx_wdt_match[];
191static int mpc8xxx_wdt_probe(struct platform_device *ofdev)
192{
193 int ret;
194 const struct of_device_id *match;
195 struct device_node *np = ofdev->dev.of_node;
196 const struct mpc8xxx_wdt_type *wdt_type;
197 u32 freq = fsl_get_sys_freq();
198 bool enabled;
199
200 match = of_match_device(mpc8xxx_wdt_match, &ofdev->dev);
201 if (!match)
202 return -EINVAL;
203 wdt_type = match->data;
204
205 if (!freq || freq == -1)
206 return -EINVAL;
207
208 wd_base = of_iomap(np, 0);
209 if (!wd_base)
210 return -ENOMEM;
211
212 enabled = in_be32(&wd_base->swcrr) & SWCRR_SWEN;
213 if (!enabled && wdt_type->hw_enabled) {
214 pr_info("could not be enabled in software\n");
215 ret = -ENOSYS;
216 goto err_unmap;
217 }
218
219
220 if (prescale)
221 timeout_sec = (timeout * wdt_type->prescaler) / freq;
222 else
223 timeout_sec = timeout / freq;
224
225#ifdef MODULE
226 ret = mpc8xxx_wdt_init_late();
227 if (ret)
228 goto err_unmap;
229#endif
230
231 pr_info("WDT driver for MPC8xxx initialized. mode:%s timeout=%d (%d seconds)\n",
232 reset ? "reset" : "interrupt", timeout, timeout_sec);
233
234
235
236
237
238
239 if (enabled)
240 mpc8xxx_wdt_timer_ping(0);
241 return 0;
242err_unmap:
243 iounmap(wd_base);
244 wd_base = NULL;
245 return ret;
246}
247
248static int mpc8xxx_wdt_remove(struct platform_device *ofdev)
249{
250 mpc8xxx_wdt_pr_warn("watchdog removed");
251 del_timer_sync(&wdt_timer);
252 misc_deregister(&mpc8xxx_wdt_miscdev);
253 iounmap(wd_base);
254
255 return 0;
256}
257
258static const struct of_device_id mpc8xxx_wdt_match[] = {
259 {
260 .compatible = "mpc83xx_wdt",
261 .data = &(struct mpc8xxx_wdt_type) {
262 .prescaler = 0x10000,
263 },
264 },
265 {
266 .compatible = "fsl,mpc8610-wdt",
267 .data = &(struct mpc8xxx_wdt_type) {
268 .prescaler = 0x10000,
269 .hw_enabled = true,
270 },
271 },
272 {
273 .compatible = "fsl,mpc823-wdt",
274 .data = &(struct mpc8xxx_wdt_type) {
275 .prescaler = 0x800,
276 },
277 },
278 {},
279};
280MODULE_DEVICE_TABLE(of, mpc8xxx_wdt_match);
281
282static struct platform_driver mpc8xxx_wdt_driver = {
283 .probe = mpc8xxx_wdt_probe,
284 .remove = mpc8xxx_wdt_remove,
285 .driver = {
286 .name = "mpc8xxx_wdt",
287 .owner = THIS_MODULE,
288 .of_match_table = mpc8xxx_wdt_match,
289 },
290};
291
292
293
294
295
296
297static int mpc8xxx_wdt_init_late(void)
298{
299 int ret;
300
301 if (!wd_base)
302 return -ENODEV;
303
304 ret = misc_register(&mpc8xxx_wdt_miscdev);
305 if (ret) {
306 pr_err("cannot register miscdev on minor=%d (err=%d)\n",
307 WATCHDOG_MINOR, ret);
308 return ret;
309 }
310 return 0;
311}
312#ifndef MODULE
313module_init(mpc8xxx_wdt_init_late);
314#endif
315
316static int __init mpc8xxx_wdt_init(void)
317{
318 return platform_driver_register(&mpc8xxx_wdt_driver);
319}
320arch_initcall(mpc8xxx_wdt_init);
321
322static void __exit mpc8xxx_wdt_exit(void)
323{
324 platform_driver_unregister(&mpc8xxx_wdt_driver);
325}
326module_exit(mpc8xxx_wdt_exit);
327
328MODULE_AUTHOR("Dave Updegraff, Kumar Gala");
329MODULE_DESCRIPTION("Driver for watchdog timer in MPC8xx/MPC83xx/MPC86xx "
330 "uProcessors");
331MODULE_LICENSE("GPL");
332MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
333
