xref: /linux/drivers/watchdog/wdt977.c (revision d00ab2fdd4dc4361c97777bc1fef7234329d4659)
1 /*
2  *	Wdt977	0.04:	A Watchdog Device for Netwinder W83977AF chip
3  *
4  *	(c) Copyright 1998 Rebel.com (Woody Suwalski <woody@netwinder.org>)
5  *
6  *			-----------------------
7  *
8  *	This program is free software; you can redistribute it and/or
9  *	modify it under the terms of the GNU General Public License
10  *	as published by the Free Software Foundation; either version
11  *	2 of the License, or (at your option) any later version.
12  *
13  *			-----------------------
14  *      14-Dec-2001 Matt Domsch <Matt_Domsch@dell.com>
15  *           Added nowayout module option to override CONFIG_WATCHDOG_NOWAYOUT
16  *	19-Dec-2001 Woody Suwalski: Netwinder fixes, ioctl interface
17  *	06-Jan-2002 Woody Suwalski: For compatibility, convert all timeouts
18  *				    from minutes to seconds.
19  *      07-Jul-2003 Daniele Bellucci: Audit return code of misc_register in
20  *                                    nwwatchdog_init.
21  *      25-Oct-2005 Woody Suwalski: Convert addresses to #defs, add spinlocks
22  *				    remove limitiation to be used on
23  *				    Netwinders only
24  */
25 
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/types.h>
29 #include <linux/kernel.h>
30 #include <linux/fs.h>
31 #include <linux/miscdevice.h>
32 #include <linux/init.h>
33 #include <linux/ioport.h>
34 #include <linux/watchdog.h>
35 #include <linux/notifier.h>
36 #include <linux/reboot.h>
37 #include <linux/io.h>
38 #include <linux/uaccess.h>
39 
40 #include <asm/system.h>
41 #include <asm/mach-types.h>
42 
43 #define WATCHDOG_VERSION  "0.04"
44 #define WATCHDOG_NAME     "Wdt977"
45 #define PFX WATCHDOG_NAME ": "
46 #define DRIVER_VERSION    WATCHDOG_NAME " driver, v" WATCHDOG_VERSION "\n"
47 
48 #define IO_INDEX_PORT	0x370		/* on some systems it can be 0x3F0 */
49 #define IO_DATA_PORT	(IO_INDEX_PORT + 1)
50 
51 #define UNLOCK_DATA	0x87
52 #define LOCK_DATA	0xAA
53 #define DEVICE_REGISTER	0x07
54 
55 
56 #define	DEFAULT_TIMEOUT	60			/* default timeout in seconds */
57 
58 static	int timeout = DEFAULT_TIMEOUT;
59 static	int timeoutM;				/* timeout in minutes */
60 static	unsigned long timer_alive;
61 static	int testmode;
62 static	char expect_close;
63 static	DEFINE_SPINLOCK(spinlock);
64 
65 module_param(timeout, int, 0);
66 MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds (60..15300), default="
67 				__MODULE_STRING(DEFAULT_TIMEOUT) ")");
68 module_param(testmode, int, 0);
69 MODULE_PARM_DESC(testmode, "Watchdog testmode (1 = no reboot), default=0");
70 
71 static int nowayout = WATCHDOG_NOWAYOUT;
72 module_param(nowayout, int, 0);
73 MODULE_PARM_DESC(nowayout,
74 		"Watchdog cannot be stopped once started (default="
75 				__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
76 
77 /*
78  * Start the watchdog
79  */
80 
81 static int wdt977_start(void)
82 {
83 	unsigned long flags;
84 
85 	spin_lock_irqsave(&spinlock, flags);
86 
87 	/* unlock the SuperIO chip */
88 	outb_p(UNLOCK_DATA, IO_INDEX_PORT);
89 	outb_p(UNLOCK_DATA, IO_INDEX_PORT);
90 
91 	/* select device Aux2 (device=8) and set watchdog regs F2, F3 and F4
92 	 * F2 has the timeout in minutes
93 	 * F3 could be set to the POWER LED blink (with GP17 set to PowerLed)
94 	 *   at timeout, and to reset timer on kbd/mouse activity (not impl.)
95 	 * F4 is used to just clear the TIMEOUT'ed state (bit 0)
96 	 */
97 	outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
98 	outb_p(0x08, IO_DATA_PORT);
99 	outb_p(0xF2, IO_INDEX_PORT);
100 	outb_p(timeoutM, IO_DATA_PORT);
101 	outb_p(0xF3, IO_INDEX_PORT);
102 	outb_p(0x00, IO_DATA_PORT);	/* another setting is 0E for
103 					   kbd/mouse/LED */
104 	outb_p(0xF4, IO_INDEX_PORT);
105 	outb_p(0x00, IO_DATA_PORT);
106 
107 	/* At last select device Aux1 (dev=7) and set GP16 as a
108 	 * watchdog output. In test mode watch the bit 1 on F4 to
109 	 * indicate "triggered"
110 	 */
111 	if (!testmode) {
112 		outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
113 		outb_p(0x07, IO_DATA_PORT);
114 		outb_p(0xE6, IO_INDEX_PORT);
115 		outb_p(0x08, IO_DATA_PORT);
116 	}
117 
118 	/* lock the SuperIO chip */
119 	outb_p(LOCK_DATA, IO_INDEX_PORT);
120 
121 	spin_unlock_irqrestore(&spinlock, flags);
122 	printk(KERN_INFO PFX "activated.\n");
123 
124 	return 0;
125 }
126 
127 /*
128  * Stop the watchdog
129  */
130 
131 static int wdt977_stop(void)
132 {
133 	unsigned long flags;
134 	spin_lock_irqsave(&spinlock, flags);
135 
136 	/* unlock the SuperIO chip */
137 	outb_p(UNLOCK_DATA, IO_INDEX_PORT);
138 	outb_p(UNLOCK_DATA, IO_INDEX_PORT);
139 
140 	/* select device Aux2 (device=8) and set watchdog regs F2,F3 and F4
141 	* F3 is reset to its default state
142 	* F4 can clear the TIMEOUT'ed state (bit 0) - back to default
143 	* We can not use GP17 as a PowerLed, as we use its usage as a RedLed
144 	*/
145 	outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
146 	outb_p(0x08, IO_DATA_PORT);
147 	outb_p(0xF2, IO_INDEX_PORT);
148 	outb_p(0xFF, IO_DATA_PORT);
149 	outb_p(0xF3, IO_INDEX_PORT);
150 	outb_p(0x00, IO_DATA_PORT);
151 	outb_p(0xF4, IO_INDEX_PORT);
152 	outb_p(0x00, IO_DATA_PORT);
153 	outb_p(0xF2, IO_INDEX_PORT);
154 	outb_p(0x00, IO_DATA_PORT);
155 
156 	/* at last select device Aux1 (dev=7) and set
157 	   GP16 as a watchdog output */
158 	outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
159 	outb_p(0x07, IO_DATA_PORT);
160 	outb_p(0xE6, IO_INDEX_PORT);
161 	outb_p(0x08, IO_DATA_PORT);
162 
163 	/* lock the SuperIO chip */
164 	outb_p(LOCK_DATA, IO_INDEX_PORT);
165 
166 	spin_unlock_irqrestore(&spinlock, flags);
167 	printk(KERN_INFO PFX "shutdown.\n");
168 
169 	return 0;
170 }
171 
172 /*
173  * Send a keepalive ping to the watchdog
174  * This is done by simply re-writing the timeout to reg. 0xF2
175  */
176 
177 static int wdt977_keepalive(void)
178 {
179 	unsigned long flags;
180 	spin_lock_irqsave(&spinlock, flags);
181 
182 	/* unlock the SuperIO chip */
183 	outb_p(UNLOCK_DATA, IO_INDEX_PORT);
184 	outb_p(UNLOCK_DATA, IO_INDEX_PORT);
185 
186 	/* select device Aux2 (device=8) and kicks watchdog reg F2 */
187 	/* F2 has the timeout in minutes */
188 	outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
189 	outb_p(0x08, IO_DATA_PORT);
190 	outb_p(0xF2, IO_INDEX_PORT);
191 	outb_p(timeoutM, IO_DATA_PORT);
192 
193 	/* lock the SuperIO chip */
194 	outb_p(LOCK_DATA, IO_INDEX_PORT);
195 	spin_unlock_irqrestore(&spinlock, flags);
196 
197 	return 0;
198 }
199 
200 /*
201  * Set the watchdog timeout value
202  */
203 
204 static int wdt977_set_timeout(int t)
205 {
206 	int tmrval;
207 
208 	/* convert seconds to minutes, rounding up */
209 	tmrval = (t + 59) / 60;
210 
211 	if (machine_is_netwinder()) {
212 		/* we have a hw bug somewhere, so each 977 minute is actually
213 		 * only 30sec. This limits the max timeout to half of device
214 		 * max of 255 minutes...
215 		 */
216 		tmrval += tmrval;
217 	}
218 
219 	if (tmrval < 1 || tmrval > 255)
220 		return -EINVAL;
221 
222 	/* timeout is the timeout in seconds, timeoutM is
223 	   the timeout in minutes) */
224 	timeout = t;
225 	timeoutM = tmrval;
226 	return 0;
227 }
228 
229 /*
230  * Get the watchdog status
231  */
232 
233 static int wdt977_get_status(int *status)
234 {
235 	int new_status;
236 	unsigned long flags;
237 
238 	spin_lock_irqsave(&spinlock, flags);
239 
240 	/* unlock the SuperIO chip */
241 	outb_p(UNLOCK_DATA, IO_INDEX_PORT);
242 	outb_p(UNLOCK_DATA, IO_INDEX_PORT);
243 
244 	/* select device Aux2 (device=8) and read watchdog reg F4 */
245 	outb_p(DEVICE_REGISTER, IO_INDEX_PORT);
246 	outb_p(0x08, IO_DATA_PORT);
247 	outb_p(0xF4, IO_INDEX_PORT);
248 	new_status = inb_p(IO_DATA_PORT);
249 
250 	/* lock the SuperIO chip */
251 	outb_p(LOCK_DATA, IO_INDEX_PORT);
252 
253 	spin_unlock_irqrestore(&spinlock, flags);
254 
255 	*status = 0;
256 	if (new_status & 1)
257 		*status |= WDIOF_CARDRESET;
258 
259 	return 0;
260 }
261 
262 
263 /*
264  *	/dev/watchdog handling
265  */
266 
267 static int wdt977_open(struct inode *inode, struct file *file)
268 {
269 	/* If the watchdog is alive we don't need to start it again */
270 	if (test_and_set_bit(0, &timer_alive))
271 		return -EBUSY;
272 
273 	if (nowayout)
274 		__module_get(THIS_MODULE);
275 
276 	wdt977_start();
277 	return nonseekable_open(inode, file);
278 }
279 
280 static int wdt977_release(struct inode *inode, struct file *file)
281 {
282 	/*
283 	 *	Shut off the timer.
284 	 * 	Lock it in if it's a module and we set nowayout
285 	 */
286 	if (expect_close == 42) {
287 		wdt977_stop();
288 		clear_bit(0, &timer_alive);
289 	} else {
290 		wdt977_keepalive();
291 		printk(KERN_CRIT PFX
292 			"Unexpected close, not stopping watchdog!\n");
293 	}
294 	expect_close = 0;
295 	return 0;
296 }
297 
298 
299 /*
300  *      wdt977_write:
301  *      @file: file handle to the watchdog
302  *      @buf: buffer to write (unused as data does not matter here
303  *      @count: count of bytes
304  *      @ppos: pointer to the position to write. No seeks allowed
305  *
306  *      A write to a watchdog device is defined as a keepalive signal. Any
307  *      write of data will do, as we we don't define content meaning.
308  */
309 
310 static ssize_t wdt977_write(struct file *file, const char __user *buf,
311 			    size_t count, loff_t *ppos)
312 {
313 	if (count) {
314 		if (!nowayout) {
315 			size_t i;
316 
317 			/* In case it was set long ago */
318 			expect_close = 0;
319 
320 			for (i = 0; i != count; i++) {
321 				char c;
322 				if (get_user(c, buf + i))
323 					return -EFAULT;
324 				if (c == 'V')
325 					expect_close = 42;
326 			}
327 		}
328 
329 		/* someone wrote to us, we should restart timer */
330 		wdt977_keepalive();
331 	}
332 	return count;
333 }
334 
335 static const struct watchdog_info ident = {
336 	.options =		WDIOF_SETTIMEOUT |
337 				WDIOF_MAGICCLOSE |
338 				WDIOF_KEEPALIVEPING,
339 	.firmware_version =	1,
340 	.identity =		WATCHDOG_NAME,
341 };
342 
343 /*
344  *      wdt977_ioctl:
345  *      @inode: inode of the device
346  *      @file: file handle to the device
347  *      @cmd: watchdog command
348  *      @arg: argument pointer
349  *
350  *      The watchdog API defines a common set of functions for all watchdogs
351  *      according to their available features.
352  */
353 
354 static long wdt977_ioctl(struct file *file, unsigned int cmd,
355 							unsigned long arg)
356 {
357 	int status;
358 	int new_options, retval = -EINVAL;
359 	int new_timeout;
360 	union {
361 		struct watchdog_info __user *ident;
362 		int __user *i;
363 	} uarg;
364 
365 	uarg.i = (int __user *)arg;
366 
367 	switch (cmd) {
368 	case WDIOC_GETSUPPORT:
369 		return copy_to_user(uarg.ident, &ident,
370 			sizeof(ident)) ? -EFAULT : 0;
371 
372 	case WDIOC_GETSTATUS:
373 		wdt977_get_status(&status);
374 		return put_user(status, uarg.i);
375 
376 	case WDIOC_GETBOOTSTATUS:
377 		return put_user(0, uarg.i);
378 
379 	case WDIOC_SETOPTIONS:
380 		if (get_user(new_options, uarg.i))
381 			return -EFAULT;
382 
383 		if (new_options & WDIOS_DISABLECARD) {
384 			wdt977_stop();
385 			retval = 0;
386 		}
387 
388 		if (new_options & WDIOS_ENABLECARD) {
389 			wdt977_start();
390 			retval = 0;
391 		}
392 
393 		return retval;
394 
395 	case WDIOC_KEEPALIVE:
396 		wdt977_keepalive();
397 		return 0;
398 
399 	case WDIOC_SETTIMEOUT:
400 		if (get_user(new_timeout, uarg.i))
401 			return -EFAULT;
402 
403 		if (wdt977_set_timeout(new_timeout))
404 			return -EINVAL;
405 
406 		wdt977_keepalive();
407 		/* Fall */
408 
409 	case WDIOC_GETTIMEOUT:
410 		return put_user(timeout, uarg.i);
411 
412 	default:
413 		return -ENOTTY;
414 
415 	}
416 }
417 
418 static int wdt977_notify_sys(struct notifier_block *this, unsigned long code,
419 	void *unused)
420 {
421 	if (code == SYS_DOWN || code == SYS_HALT)
422 		wdt977_stop();
423 	return NOTIFY_DONE;
424 }
425 
426 static const struct file_operations wdt977_fops = {
427 	.owner		= THIS_MODULE,
428 	.llseek		= no_llseek,
429 	.write		= wdt977_write,
430 	.unlocked_ioctl	= wdt977_ioctl,
431 	.open		= wdt977_open,
432 	.release	= wdt977_release,
433 };
434 
435 static struct miscdevice wdt977_miscdev = {
436 	.minor		= WATCHDOG_MINOR,
437 	.name		= "watchdog",
438 	.fops		= &wdt977_fops,
439 };
440 
441 static struct notifier_block wdt977_notifier = {
442 	.notifier_call = wdt977_notify_sys,
443 };
444 
445 static int __init wd977_init(void)
446 {
447 	int rc;
448 
449 	printk(KERN_INFO PFX DRIVER_VERSION);
450 
451 	/* Check that the timeout value is within its range;
452 	   if not reset to the default */
453 	if (wdt977_set_timeout(timeout)) {
454 		wdt977_set_timeout(DEFAULT_TIMEOUT);
455 		printk(KERN_INFO PFX
456 		      "timeout value must be 60 < timeout < 15300, using %d\n",
457 							DEFAULT_TIMEOUT);
458 	}
459 
460 	/* on Netwinder the IOports are already reserved by
461 	 * arch/arm/mach-footbridge/netwinder-hw.c
462 	 */
463 	if (!machine_is_netwinder()) {
464 		if (!request_region(IO_INDEX_PORT, 2, WATCHDOG_NAME)) {
465 			printk(KERN_ERR PFX
466 				"I/O address 0x%04x already in use\n",
467 								IO_INDEX_PORT);
468 			rc = -EIO;
469 			goto err_out;
470 		}
471 	}
472 
473 	rc = register_reboot_notifier(&wdt977_notifier);
474 	if (rc) {
475 		printk(KERN_ERR PFX
476 			"cannot register reboot notifier (err=%d)\n", rc);
477 		goto err_out_region;
478 	}
479 
480 	rc = misc_register(&wdt977_miscdev);
481 	if (rc) {
482 		printk(KERN_ERR PFX
483 			"cannot register miscdev on minor=%d (err=%d)\n",
484 						wdt977_miscdev.minor, rc);
485 		goto err_out_reboot;
486 	}
487 
488 	printk(KERN_INFO PFX
489 		"initialized. timeout=%d sec (nowayout=%d, testmode=%i)\n",
490 						timeout, nowayout, testmode);
491 
492 	return 0;
493 
494 err_out_reboot:
495 	unregister_reboot_notifier(&wdt977_notifier);
496 err_out_region:
497 	if (!machine_is_netwinder())
498 		release_region(IO_INDEX_PORT, 2);
499 err_out:
500 	return rc;
501 }
502 
503 static void __exit wd977_exit(void)
504 {
505 	wdt977_stop();
506 	misc_deregister(&wdt977_miscdev);
507 	unregister_reboot_notifier(&wdt977_notifier);
508 	release_region(IO_INDEX_PORT, 2);
509 }
510 
511 module_init(wd977_init);
512 module_exit(wd977_exit);
513 
514 MODULE_AUTHOR("Woody Suwalski <woodys@xandros.com>");
515 MODULE_DESCRIPTION("W83977AF Watchdog driver");
516 MODULE_LICENSE("GPL");
517 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
518