blob: f1ae3729a19e2d85a2f78fa40f196bed75cca023 [file] [log] [blame]
Thomas Koeller825d3742006-08-14 21:55:29 +02001/*
2 * Watchdog implementation for GPI h/w found on PMC-Sierra RM9xxx
3 * chips.
4 *
5 * Copyright (C) 2004 by Basler Vision Technologies AG
6 * Author: Thomas Koeller <thomas.koeller@baslerweb.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23#include <linux/platform_device.h>
24#include <linux/module.h>
25#include <linux/moduleparam.h>
26#include <linux/interrupt.h>
27#include <linux/fs.h>
28#include <linux/reboot.h>
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +010029#include <linux/notifier.h>
Thomas Koeller825d3742006-08-14 21:55:29 +020030#include <linux/miscdevice.h>
31#include <linux/watchdog.h>
Alan Cox72d5c052008-05-19 14:07:54 +010032#include <linux/io.h>
33#include <linux/uaccess.h>
Thomas Koeller825d3742006-08-14 21:55:29 +020034#include <asm/atomic.h>
35#include <asm/processor.h>
Thomas Koeller825d3742006-08-14 21:55:29 +020036#include <asm/system.h>
37#include <asm/rm9k-ocd.h>
38
39#include <rm9k_wdt.h>
40
41
42#define CLOCK 125000000
43#define MAX_TIMEOUT_SECONDS 32
44#define CPCCR 0x0080
45#define CPGIG1SR 0x0044
46#define CPGIG1ER 0x0054
47
48
Thomas Koeller825d3742006-08-14 21:55:29 +020049/* Function prototypes */
Thomas Koeller74e86ab2006-12-06 01:45:39 +010050static irqreturn_t wdt_gpi_irqhdl(int, void *);
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +010051static void wdt_gpi_start(void);
52static void wdt_gpi_stop(void);
Thomas Koeller825d3742006-08-14 21:55:29 +020053static void wdt_gpi_set_timeout(unsigned int);
54static int wdt_gpi_open(struct inode *, struct file *);
55static int wdt_gpi_release(struct inode *, struct file *);
Alan Cox72d5c052008-05-19 14:07:54 +010056static ssize_t wdt_gpi_write(struct file *, const char __user *, size_t,
57 loff_t *);
Thomas Koeller825d3742006-08-14 21:55:29 +020058static long wdt_gpi_ioctl(struct file *, unsigned int, unsigned long);
Thomas Koeller825d3742006-08-14 21:55:29 +020059static int wdt_gpi_notify(struct notifier_block *, unsigned long, void *);
Alan Cox72d5c052008-05-19 14:07:54 +010060static const struct resource *wdt_gpi_get_resource(struct platform_device *,
61 const char *, unsigned int);
Wim Van Sebroeck97846e32006-11-17 23:15:48 +010062static int __init wdt_gpi_probe(struct device *);
63static int __exit wdt_gpi_remove(struct device *);
Thomas Koeller825d3742006-08-14 21:55:29 +020064
65
Thomas Koeller825d3742006-08-14 21:55:29 +020066static const char wdt_gpi_name[] = "wdt_gpi";
67static atomic_t opencnt;
68static int expect_close;
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +010069static int locked;
Thomas Koeller825d3742006-08-14 21:55:29 +020070
71
Thomas Koeller825d3742006-08-14 21:55:29 +020072/* These are set from device resources */
Alan Cox72d5c052008-05-19 14:07:54 +010073static void __iomem *wd_regs;
Thomas Koeller825d3742006-08-14 21:55:29 +020074static unsigned int wd_irq, wd_ctr;
75
76
Thomas Koeller825d3742006-08-14 21:55:29 +020077/* Module arguments */
78static int timeout = MAX_TIMEOUT_SECONDS;
79module_param(timeout, int, 0444);
Wim Van Sebroeckcd57eea2006-11-17 21:51:35 +010080MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds");
81
Thomas Koeller825d3742006-08-14 21:55:29 +020082static unsigned long resetaddr = 0xbffdc200;
83module_param(resetaddr, ulong, 0444);
Wim Van Sebroeckcd57eea2006-11-17 21:51:35 +010084MODULE_PARM_DESC(resetaddr, "Address to write to to force a reset");
85
Thomas Koeller825d3742006-08-14 21:55:29 +020086static unsigned long flagaddr = 0xbffdc104;
87module_param(flagaddr, ulong, 0444);
Wim Van Sebroeckcd57eea2006-11-17 21:51:35 +010088MODULE_PARM_DESC(flagaddr, "Address to write to boot flags to");
89
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +010090static int powercycle;
Thomas Koeller825d3742006-08-14 21:55:29 +020091module_param(powercycle, bool, 0444);
Wim Van Sebroeckcd57eea2006-11-17 21:51:35 +010092MODULE_PARM_DESC(powercycle, "Cycle power if watchdog expires");
Thomas Koeller825d3742006-08-14 21:55:29 +020093
94static int nowayout = WATCHDOG_NOWAYOUT;
95module_param(nowayout, bool, 0444);
Wim Van Sebroeckcd57eea2006-11-17 21:51:35 +010096MODULE_PARM_DESC(nowayout, "Watchdog cannot be disabled once started");
Thomas Koeller825d3742006-08-14 21:55:29 +020097
98
Thomas Koellerbec4f742006-12-06 01:45:26 +010099/* Kernel interfaces */
Arjan van de Ven2b8693c2007-02-12 00:55:32 -0800100static const struct file_operations fops = {
Thomas Koellerbec4f742006-12-06 01:45:26 +0100101 .owner = THIS_MODULE,
102 .open = wdt_gpi_open,
103 .release = wdt_gpi_release,
104 .write = wdt_gpi_write,
105 .unlocked_ioctl = wdt_gpi_ioctl,
106};
107
108static struct miscdevice miscdev = {
109 .minor = WATCHDOG_MINOR,
110 .name = wdt_gpi_name,
111 .fops = &fops,
112};
113
114static struct notifier_block wdt_gpi_shutdown = {
115 .notifier_call = wdt_gpi_notify,
116};
117
118
Wim Van Sebroeck97846e32006-11-17 23:15:48 +0100119/* Interrupt handler */
Thomas Koeller74e86ab2006-12-06 01:45:39 +0100120static irqreturn_t wdt_gpi_irqhdl(int irq, void *ctxt)
Thomas Koeller825d3742006-08-14 21:55:29 +0200121{
Wim Van Sebroeck97846e32006-11-17 23:15:48 +0100122 if (!unlikely(__raw_readl(wd_regs + 0x0008) & 0x1))
123 return IRQ_NONE;
124 __raw_writel(0x1, wd_regs + 0x0008);
125
126
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100127 printk(KERN_CRIT "%s: watchdog expired - resetting system\n",
Wim Van Sebroeck97846e32006-11-17 23:15:48 +0100128 wdt_gpi_name);
129
130 *(volatile char *) flagaddr |= 0x01;
131 *(volatile char *) resetaddr = powercycle ? 0x01 : 0x2;
132 iob();
133 while (1)
134 cpu_relax();
Thomas Koeller825d3742006-08-14 21:55:29 +0200135}
136
137
Wim Van Sebroeck97846e32006-11-17 23:15:48 +0100138/* Watchdog functions */
Wim Van Sebroeck414a67592006-11-17 23:36:08 +0100139static void wdt_gpi_start(void)
140{
141 u32 reg;
142
143 lock_titan_regs();
144 reg = titan_readl(CPGIG1ER);
145 titan_writel(reg | (0x100 << wd_ctr), CPGIG1ER);
146 iob();
147 unlock_titan_regs();
148}
149
150static void wdt_gpi_stop(void)
151{
152 u32 reg;
153
154 lock_titan_regs();
155 reg = titan_readl(CPCCR) & ~(0xf << (wd_ctr * 4));
156 titan_writel(reg, CPCCR);
157 reg = titan_readl(CPGIG1ER);
158 titan_writel(reg & ~(0x100 << wd_ctr), CPGIG1ER);
159 iob();
160 unlock_titan_regs();
161}
162
Thomas Koeller825d3742006-08-14 21:55:29 +0200163static void wdt_gpi_set_timeout(unsigned int to)
164{
165 u32 reg;
166 const u32 wdval = (to * CLOCK) & ~0x0000000f;
167
168 lock_titan_regs();
169 reg = titan_readl(CPCCR) & ~(0xf << (wd_ctr * 4));
170 titan_writel(reg, CPCCR);
171 wmb();
172 __raw_writel(wdval, wd_regs + 0x0000);
173 wmb();
174 titan_writel(reg | (0x2 << (wd_ctr * 4)), CPCCR);
175 wmb();
176 titan_writel(reg | (0x5 << (wd_ctr * 4)), CPCCR);
177 iob();
178 unlock_titan_regs();
179}
180
181
Wim Van Sebroeck97846e32006-11-17 23:15:48 +0100182/* /dev/watchdog operations */
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100183static int wdt_gpi_open(struct inode *inode, struct file *file)
Thomas Koeller825d3742006-08-14 21:55:29 +0200184{
185 int res;
Thomas Koeller825d3742006-08-14 21:55:29 +0200186
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100187 if (unlikely(atomic_dec_if_positive(&opencnt) < 0))
Thomas Koeller825d3742006-08-14 21:55:29 +0200188 return -EBUSY;
189
190 expect_close = 0;
191 if (locked) {
192 module_put(THIS_MODULE);
193 free_irq(wd_irq, &miscdev);
194 locked = 0;
195 }
196
Thomas Gleixner38515e92007-02-14 00:33:16 -0800197 res = request_irq(wd_irq, wdt_gpi_irqhdl, IRQF_SHARED | IRQF_DISABLED,
Thomas Koeller825d3742006-08-14 21:55:29 +0200198 wdt_gpi_name, &miscdev);
199 if (unlikely(res))
200 return res;
201
202 wdt_gpi_set_timeout(timeout);
Wim Van Sebroeck414a67592006-11-17 23:36:08 +0100203 wdt_gpi_start();
Thomas Koeller825d3742006-08-14 21:55:29 +0200204
205 printk(KERN_INFO "%s: watchdog started, timeout = %u seconds\n",
206 wdt_gpi_name, timeout);
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100207 return nonseekable_open(inode, file);
Thomas Koeller825d3742006-08-14 21:55:29 +0200208}
209
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100210static int wdt_gpi_release(struct inode *inode, struct file *file)
Thomas Koeller825d3742006-08-14 21:55:29 +0200211{
212 if (nowayout) {
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100213 printk(KERN_INFO "%s: no way out - watchdog left running\n",
Thomas Koeller825d3742006-08-14 21:55:29 +0200214 wdt_gpi_name);
215 __module_get(THIS_MODULE);
216 locked = 1;
217 } else {
218 if (expect_close) {
Wim Van Sebroeck414a67592006-11-17 23:36:08 +0100219 wdt_gpi_stop();
Thomas Koeller825d3742006-08-14 21:55:29 +0200220 free_irq(wd_irq, &miscdev);
Alan Cox72d5c052008-05-19 14:07:54 +0100221 printk(KERN_INFO "%s: watchdog stopped\n",
222 wdt_gpi_name);
Thomas Koeller825d3742006-08-14 21:55:29 +0200223 } else {
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100224 printk(KERN_CRIT "%s: unexpected close() -"
Thomas Koeller825d3742006-08-14 21:55:29 +0200225 " watchdog left running\n",
226 wdt_gpi_name);
227 wdt_gpi_set_timeout(timeout);
228 __module_get(THIS_MODULE);
229 locked = 1;
230 }
231 }
232
233 atomic_inc(&opencnt);
234 return 0;
235}
236
Wim Van Sebroeck7944d3a2008-08-06 20:19:41 +0000237static ssize_t wdt_gpi_write(struct file *f, const char __user *d, size_t s,
238 loff_t *o)
Thomas Koeller825d3742006-08-14 21:55:29 +0200239{
240 char val;
241
242 wdt_gpi_set_timeout(timeout);
243 expect_close = (s > 0) && !get_user(val, d) && (val == 'V');
244 return s ? 1 : 0;
245}
246
Alan Cox72d5c052008-05-19 14:07:54 +0100247static long wdt_gpi_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
Thomas Koeller825d3742006-08-14 21:55:29 +0200248{
249 long res = -ENOTTY;
250 const long size = _IOC_SIZE(cmd);
251 int stat;
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100252 void __user *argp = (void __user *)arg;
Thomas Koeller825d3742006-08-14 21:55:29 +0200253 static struct watchdog_info wdinfo = {
254 .identity = "RM9xxx/GPI watchdog",
255 .firmware_version = 0,
256 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING
257 };
258
259 if (unlikely(_IOC_TYPE(cmd) != WATCHDOG_IOCTL_BASE))
260 return -ENOTTY;
261
262 if ((_IOC_DIR(cmd) & _IOC_READ)
263 && !access_ok(VERIFY_WRITE, arg, size))
264 return -EFAULT;
265
266 if ((_IOC_DIR(cmd) & _IOC_WRITE)
267 && !access_ok(VERIFY_READ, arg, size))
268 return -EFAULT;
269
270 expect_close = 0;
271
272 switch (cmd) {
273 case WDIOC_GETSUPPORT:
274 wdinfo.options = nowayout ?
275 WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING :
Alan Cox72d5c052008-05-19 14:07:54 +0100276 WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
277 WDIOF_MAGICCLOSE;
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100278 res = __copy_to_user(argp, &wdinfo, size) ? -EFAULT : size;
Thomas Koeller825d3742006-08-14 21:55:29 +0200279 break;
280
281 case WDIOC_GETSTATUS:
282 break;
283
284 case WDIOC_GETBOOTSTATUS:
285 stat = (*(volatile char *) flagaddr & 0x01)
286 ? WDIOF_CARDRESET : 0;
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100287 res = __copy_to_user(argp, &stat, size) ?
Thomas Koeller825d3742006-08-14 21:55:29 +0200288 -EFAULT : size;
289 break;
290
291 case WDIOC_SETOPTIONS:
292 break;
293
294 case WDIOC_KEEPALIVE:
295 wdt_gpi_set_timeout(timeout);
296 res = size;
297 break;
298
299 case WDIOC_SETTIMEOUT:
300 {
301 int val;
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100302 if (unlikely(__copy_from_user(&val, argp, size))) {
Thomas Koeller825d3742006-08-14 21:55:29 +0200303 res = -EFAULT;
304 break;
305 }
306
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100307 if (val > MAX_TIMEOUT_SECONDS)
308 val = MAX_TIMEOUT_SECONDS;
Thomas Koeller825d3742006-08-14 21:55:29 +0200309 timeout = val;
310 wdt_gpi_set_timeout(val);
311 res = size;
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100312 printk(KERN_INFO "%s: timeout set to %u seconds\n",
Thomas Koeller825d3742006-08-14 21:55:29 +0200313 wdt_gpi_name, timeout);
314 }
315 break;
316
317 case WDIOC_GETTIMEOUT:
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100318 res = __copy_to_user(argp, &timeout, size) ?
Thomas Koeller825d3742006-08-14 21:55:29 +0200319 -EFAULT : size;
320 break;
321 }
322
323 return res;
324}
325
326
Wim Van Sebroeckd5d06ff2006-11-17 23:50:06 +0100327/* Shutdown notifier */
Wim Van Sebroeck7944d3a2008-08-06 20:19:41 +0000328static int wdt_gpi_notify(struct notifier_block *this, unsigned long code,
329 void *unused)
Thomas Koeller825d3742006-08-14 21:55:29 +0200330{
Wim Van Sebroeck414a67592006-11-17 23:36:08 +0100331 if (code == SYS_DOWN || code == SYS_HALT)
332 wdt_gpi_stop();
Thomas Koeller825d3742006-08-14 21:55:29 +0200333
Thomas Koeller825d3742006-08-14 21:55:29 +0200334 return NOTIFY_DONE;
335}
336
337
Wim Van Sebroeck97846e32006-11-17 23:15:48 +0100338/* Init & exit procedures */
Wim Van Sebroeck7944d3a2008-08-06 20:19:41 +0000339static const struct resource *wdt_gpi_get_resource(struct platform_device *pdv,
340 const char *name, unsigned int type)
Wim Van Sebroeck97846e32006-11-17 23:15:48 +0100341{
342 char buf[80];
343 if (snprintf(buf, sizeof buf, "%s_0", name) >= sizeof buf)
344 return NULL;
345 return platform_get_resource_byname(pdv, type, buf);
346}
347
348/* No hotplugging on the platform bus - use __init */
349static int __init wdt_gpi_probe(struct device *dev)
350{
351 int res;
352 struct platform_device * const pdv = to_platform_device(dev);
353 const struct resource
354 * const rr = wdt_gpi_get_resource(pdv, WDT_RESOURCE_REGS,
355 IORESOURCE_MEM),
356 * const ri = wdt_gpi_get_resource(pdv, WDT_RESOURCE_IRQ,
357 IORESOURCE_IRQ),
358 * const rc = wdt_gpi_get_resource(pdv, WDT_RESOURCE_COUNTER,
359 0);
360
361 if (unlikely(!rr || !ri || !rc))
362 return -ENXIO;
363
364 wd_regs = ioremap_nocache(rr->start, rr->end + 1 - rr->start);
365 if (unlikely(!wd_regs))
366 return -ENOMEM;
367 wd_irq = ri->start;
368 wd_ctr = rc->start;
369 res = misc_register(&miscdev);
370 if (res)
371 iounmap(wd_regs);
372 else
373 register_reboot_notifier(&wdt_gpi_shutdown);
374 return res;
375}
376
377static int __exit wdt_gpi_remove(struct device *dev)
378{
379 int res;
380
381 unregister_reboot_notifier(&wdt_gpi_shutdown);
382 res = misc_deregister(&miscdev);
383 iounmap(wd_regs);
384 wd_regs = NULL;
385 return res;
386}
387
388
389/* Device driver init & exit */
390static struct device_driver wdt_gpi_driver = {
391 .name = (char *) wdt_gpi_name,
392 .bus = &platform_bus_type,
393 .owner = THIS_MODULE,
394 .probe = wdt_gpi_probe,
395 .remove = __exit_p(wdt_gpi_remove),
396 .shutdown = NULL,
397 .suspend = NULL,
398 .resume = NULL,
399};
Thomas Koeller825d3742006-08-14 21:55:29 +0200400
401static int __init wdt_gpi_init_module(void)
402{
403 atomic_set(&opencnt, 1);
404 if (timeout > MAX_TIMEOUT_SECONDS)
405 timeout = MAX_TIMEOUT_SECONDS;
406 return driver_register(&wdt_gpi_driver);
407}
408
Thomas Koeller825d3742006-08-14 21:55:29 +0200409static void __exit wdt_gpi_cleanup_module(void)
410{
411 driver_unregister(&wdt_gpi_driver);
412}
413
414module_init(wdt_gpi_init_module);
415module_exit(wdt_gpi_cleanup_module);
416
Thomas Koeller825d3742006-08-14 21:55:29 +0200417MODULE_AUTHOR("Thomas Koeller <thomas.koeller@baslerweb.com>");
418MODULE_DESCRIPTION("Basler eXcite watchdog driver for gpi devices");
419MODULE_VERSION("0.1");
420MODULE_LICENSE("GPL");
421MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
Wim Van Sebroeckcd57eea2006-11-17 21:51:35 +0100422