1/*
2 *	National Semiconductor PC87307/PC97307 (ala SC1200) WDT driver
3 *	(c) Copyright 2002 Zwane Mwaikambo <zwane@commfireservices.com>,
4 *			All Rights Reserved.
5 *	Based on wdt.c and wdt977.c by Alan Cox and Woody Suwalski respectively.
6 *
7 *	This program is free software; you can redistribute it and/or
8 *	modify it under the terms of the GNU General Public License
9 *	as published by the Free Software Foundation; either version
10 *	2 of the License, or (at your option) any later version.
11 *
12 *	The author(s) of this software shall not be held liable for damages
13 *	of any nature resulting due to the use of this software. This
14 *	software is provided AS-IS with no warranties.
15 *
16 *	Changelog:
17 *	20020220 Zwane Mwaikambo	Code based on datasheet, no hardware.
18 *	20020221 Zwane Mwaikambo	Cleanups as suggested by Jeff Garzik
19 *					and Alan Cox.
20 *	20020222 Zwane Mwaikambo	Added probing.
21 *	20020225 Zwane Mwaikambo	Added ISAPNP support.
22 *	20020412 Rob Radez		Broke out start/stop functions
23 *		 <rob@osinvestor.com>	Return proper status instead of
24 *					temperature warning
25 *					Add WDIOC_GETBOOTSTATUS and
26 *					WDIOC_SETOPTIONS ioctls
27 *					Fix CONFIG_WATCHDOG_NOWAYOUT
28 *	20020530 Joel Becker		Add Matt Domsch's nowayout module
29 *					option
30 *	20030116 Adam Belay		Updated to the latest pnp code
31 *
32 */
33
34#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
35
36#include <linux/module.h>
37#include <linux/moduleparam.h>
38#include <linux/miscdevice.h>
39#include <linux/watchdog.h>
40#include <linux/ioport.h>
41#include <linux/spinlock.h>
42#include <linux/notifier.h>
43#include <linux/reboot.h>
44#include <linux/init.h>
45#include <linux/pnp.h>
46#include <linux/fs.h>
47#include <linux/semaphore.h>
48#include <linux/io.h>
49#include <linux/uaccess.h>
50
51#define SC1200_MODULE_VER	"build 20020303"
52#define SC1200_MODULE_NAME	"sc1200wdt"
53
54#define	MAX_TIMEOUT	255	/* 255 minutes */
55#define PMIR		(io)	/* Power Management Index Register */
56#define PMDR		(io+1)	/* Power Management Data Register */
57
58/* Data Register indexes */
59#define FER1		0x00	/* Function enable register 1 */
60#define FER2		0x01	/* Function enable register 2 */
61#define PMC1		0x02	/* Power Management Ctrl 1 */
62#define PMC2		0x03	/* Power Management Ctrl 2 */
63#define PMC3		0x04	/* Power Management Ctrl 3 */
64#define WDTO		0x05	/* Watchdog timeout register */
65#define	WDCF		0x06	/* Watchdog config register */
66#define WDST		0x07	/* Watchdog status register */
67
68/* WDCF bitfields - which devices assert WDO */
69#define KBC_IRQ		0x01	/* Keyboard Controller */
70#define MSE_IRQ		0x02	/* Mouse */
71#define UART1_IRQ	0x03	/* Serial0 */
72#define UART2_IRQ	0x04	/* Serial1 */
73/* 5 -7 are reserved */
74
75static int timeout = 1;
76static int io = -1;
77static int io_len = 2;		/* for non plug and play */
78static unsigned long open_flag;
79static char expect_close;
80static DEFINE_SPINLOCK(sc1200wdt_lock);	/* io port access serialisation */
81
82#if defined CONFIG_PNP
83static int isapnp = 1;
84static struct pnp_dev *wdt_dev;
85
86module_param(isapnp, int, 0);
87MODULE_PARM_DESC(isapnp,
88	"When set to 0 driver ISA PnP support will be disabled");
89#endif
90
91module_param(io, int, 0);
92MODULE_PARM_DESC(io, "io port");
93module_param(timeout, int, 0);
94MODULE_PARM_DESC(timeout, "range is 0-255 minutes, default is 1");
95
96static bool nowayout = WATCHDOG_NOWAYOUT;
97module_param(nowayout, bool, 0);
98MODULE_PARM_DESC(nowayout,
99	"Watchdog cannot be stopped once started (default="
100				__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
101
102
103
104/* Read from Data Register */
105static inline void __sc1200wdt_read_data(unsigned char index,
106						unsigned char *data)
107{
108	outb_p(index, PMIR);
109	*data = inb(PMDR);
110}
111
112static void sc1200wdt_read_data(unsigned char index, unsigned char *data)
113{
114	spin_lock(&sc1200wdt_lock);
115	__sc1200wdt_read_data(index, data);
116	spin_unlock(&sc1200wdt_lock);
117}
118
119/* Write to Data Register */
120static inline void __sc1200wdt_write_data(unsigned char index,
121						unsigned char data)
122{
123	outb_p(index, PMIR);
124	outb(data, PMDR);
125}
126
127static inline void sc1200wdt_write_data(unsigned char index,
128						unsigned char data)
129{
130	spin_lock(&sc1200wdt_lock);
131	__sc1200wdt_write_data(index, data);
132	spin_unlock(&sc1200wdt_lock);
133}
134
135
136static void sc1200wdt_start(void)
137{
138	unsigned char reg;
139	spin_lock(&sc1200wdt_lock);
140
141	__sc1200wdt_read_data(WDCF, &reg);
142	/* assert WDO when any of the following interrupts are triggered too */
143	reg |= (KBC_IRQ | MSE_IRQ | UART1_IRQ | UART2_IRQ);
144	__sc1200wdt_write_data(WDCF, reg);
145	/* set the timeout and get the ball rolling */
146	__sc1200wdt_write_data(WDTO, timeout);
147
148	spin_unlock(&sc1200wdt_lock);
149}
150
151static void sc1200wdt_stop(void)
152{
153	sc1200wdt_write_data(WDTO, 0);
154}
155
156/* This returns the status of the WDO signal, inactive high. */
157static inline int sc1200wdt_status(void)
158{
159	unsigned char ret;
160
161	sc1200wdt_read_data(WDST, &ret);
162	/* If the bit is inactive, the watchdog is enabled, so return
163	 * KEEPALIVEPING which is a bit of a kludge because there's nothing
164	 * else for enabled/disabled status
165	 */
166	return (ret & 0x01) ? 0 : WDIOF_KEEPALIVEPING;
167}
168
169static int sc1200wdt_open(struct inode *inode, struct file *file)
170{
171	/* allow one at a time */
172	if (test_and_set_bit(0, &open_flag))
173		return -EBUSY;
174
175	if (timeout > MAX_TIMEOUT)
176		timeout = MAX_TIMEOUT;
177
178	sc1200wdt_start();
179	pr_info("Watchdog enabled, timeout = %d min(s)", timeout);
180
181	return nonseekable_open(inode, file);
182}
183
184
185static long sc1200wdt_ioctl(struct file *file, unsigned int cmd,
186						unsigned long arg)
187{
188	int new_timeout;
189	void __user *argp = (void __user *)arg;
190	int __user *p = argp;
191	static const struct watchdog_info ident = {
192		.options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
193							WDIOF_MAGICCLOSE,
194		.firmware_version = 0,
195		.identity = "PC87307/PC97307",
196	};
197
198	switch (cmd) {
199	case WDIOC_GETSUPPORT:
200		if (copy_to_user(argp, &ident, sizeof(ident)))
201			return -EFAULT;
202		return 0;
203
204	case WDIOC_GETSTATUS:
205		return put_user(sc1200wdt_status(), p);
206
207	case WDIOC_GETBOOTSTATUS:
208		return put_user(0, p);
209
210	case WDIOC_SETOPTIONS:
211	{
212		int options, retval = -EINVAL;
213
214		if (get_user(options, p))
215			return -EFAULT;
216
217		if (options & WDIOS_DISABLECARD) {
218			sc1200wdt_stop();
219			retval = 0;
220		}
221
222		if (options & WDIOS_ENABLECARD) {
223			sc1200wdt_start();
224			retval = 0;
225		}
226
227		return retval;
228	}
229	case WDIOC_KEEPALIVE:
230		sc1200wdt_write_data(WDTO, timeout);
231		return 0;
232
233	case WDIOC_SETTIMEOUT:
234		if (get_user(new_timeout, p))
235			return -EFAULT;
236		/* the API states this is given in secs */
237		new_timeout /= 60;
238		if (new_timeout < 0 || new_timeout > MAX_TIMEOUT)
239			return -EINVAL;
240		timeout = new_timeout;
241		sc1200wdt_write_data(WDTO, timeout);
242		/* fall through and return the new timeout */
243
244	case WDIOC_GETTIMEOUT:
245		return put_user(timeout * 60, p);
246
247	default:
248		return -ENOTTY;
249	}
250}
251
252
253static int sc1200wdt_release(struct inode *inode, struct file *file)
254{
255	if (expect_close == 42) {
256		sc1200wdt_stop();
257		pr_info("Watchdog disabled\n");
258	} else {
259		sc1200wdt_write_data(WDTO, timeout);
260		pr_crit("Unexpected close!, timeout = %d min(s)\n", timeout);
261	}
262	clear_bit(0, &open_flag);
263	expect_close = 0;
264
265	return 0;
266}
267
268
269static ssize_t sc1200wdt_write(struct file *file, const char __user *data,
270						size_t len, loff_t *ppos)
271{
272	if (len) {
273		if (!nowayout) {
274			size_t i;
275
276			expect_close = 0;
277
278			for (i = 0; i != len; i++) {
279				char c;
280
281				if (get_user(c, data + i))
282					return -EFAULT;
283				if (c == 'V')
284					expect_close = 42;
285			}
286		}
287
288		sc1200wdt_write_data(WDTO, timeout);
289		return len;
290	}
291
292	return 0;
293}
294
295
296static int sc1200wdt_notify_sys(struct notifier_block *this,
297					unsigned long code, void *unused)
298{
299	if (code == SYS_DOWN || code == SYS_HALT)
300		sc1200wdt_stop();
301
302	return NOTIFY_DONE;
303}
304
305
306static struct notifier_block sc1200wdt_notifier = {
307	.notifier_call =	sc1200wdt_notify_sys,
308};
309
310static const struct file_operations sc1200wdt_fops = {
311	.owner		= THIS_MODULE,
312	.llseek		= no_llseek,
313	.write		= sc1200wdt_write,
314	.unlocked_ioctl = sc1200wdt_ioctl,
315	.open		= sc1200wdt_open,
316	.release	= sc1200wdt_release,
317};
318
319static struct miscdevice sc1200wdt_miscdev = {
320	.minor		= WATCHDOG_MINOR,
321	.name		= "watchdog",
322	.fops		= &sc1200wdt_fops,
323};
324
325
326static int __init sc1200wdt_probe(void)
327{
328	/* The probe works by reading the PMC3 register's default value of 0x0e
329	 * there is one caveat, if the device disables the parallel port or any
330	 * of the UARTs we won't be able to detect it.
331	 * NB. This could be done with accuracy by reading the SID registers,
332	 * but we don't have access to those io regions.
333	 */
334
335	unsigned char reg;
336
337	sc1200wdt_read_data(PMC3, &reg);
338	reg &= 0x0f;		/* we don't want the UART busy bits */
339	return (reg == 0x0e) ? 0 : -ENODEV;
340}
341
342
343#if defined CONFIG_PNP
344
345static struct pnp_device_id scl200wdt_pnp_devices[] = {
346	/* National Semiconductor PC87307/PC97307 watchdog component */
347	{.id = "NSC0800", .driver_data = 0},
348	{.id = ""},
349};
350
351static int scl200wdt_pnp_probe(struct pnp_dev *dev,
352					const struct pnp_device_id *dev_id)
353{
354	/* this driver only supports one card at a time */
355	if (wdt_dev || !isapnp)
356		return -EBUSY;
357
358	wdt_dev = dev;
359	io = pnp_port_start(wdt_dev, 0);
360	io_len = pnp_port_len(wdt_dev, 0);
361
362	if (!request_region(io, io_len, SC1200_MODULE_NAME)) {
363		pr_err("Unable to register IO port %#x\n", io);
364		return -EBUSY;
365	}
366
367	pr_info("PnP device found at io port %#x/%d\n", io, io_len);
368	return 0;
369}
370
371static void scl200wdt_pnp_remove(struct pnp_dev *dev)
372{
373	if (wdt_dev) {
374		release_region(io, io_len);
375		wdt_dev = NULL;
376	}
377}
378
379static struct pnp_driver scl200wdt_pnp_driver = {
380	.name		= "scl200wdt",
381	.id_table	= scl200wdt_pnp_devices,
382	.probe		= scl200wdt_pnp_probe,
383	.remove		= scl200wdt_pnp_remove,
384};
385
386#endif /* CONFIG_PNP */
387
388
389static int __init sc1200wdt_init(void)
390{
391	int ret;
392
393	pr_info("%s\n", SC1200_MODULE_VER);
394
395#if defined CONFIG_PNP
396	if (isapnp) {
397		ret = pnp_register_driver(&scl200wdt_pnp_driver);
398		if (ret)
399			goto out_clean;
400	}
401#endif
402
403	if (io == -1) {
404		pr_err("io parameter must be specified\n");
405		ret = -EINVAL;
406		goto out_pnp;
407	}
408
409#if defined CONFIG_PNP
410	/* now that the user has specified an IO port and we haven't detected
411	 * any devices, disable pnp support */
412	if (isapnp)
413		pnp_unregister_driver(&scl200wdt_pnp_driver);
414	isapnp = 0;
415#endif
416
417	if (!request_region(io, io_len, SC1200_MODULE_NAME)) {
418		pr_err("Unable to register IO port %#x\n", io);
419		ret = -EBUSY;
420		goto out_pnp;
421	}
422
423	ret = sc1200wdt_probe();
424	if (ret)
425		goto out_io;
426
427	ret = register_reboot_notifier(&sc1200wdt_notifier);
428	if (ret) {
429		pr_err("Unable to register reboot notifier err = %d\n", ret);
430		goto out_io;
431	}
432
433	ret = misc_register(&sc1200wdt_miscdev);
434	if (ret) {
435		pr_err("Unable to register miscdev on minor %d\n",
436		       WATCHDOG_MINOR);
437		goto out_rbt;
438	}
439
440	/* ret = 0 */
441
442out_clean:
443	return ret;
444
445out_rbt:
446	unregister_reboot_notifier(&sc1200wdt_notifier);
447
448out_io:
449	release_region(io, io_len);
450
451out_pnp:
452#if defined CONFIG_PNP
453	if (isapnp)
454		pnp_unregister_driver(&scl200wdt_pnp_driver);
455#endif
456	goto out_clean;
457}
458
459
460static void __exit sc1200wdt_exit(void)
461{
462	misc_deregister(&sc1200wdt_miscdev);
463	unregister_reboot_notifier(&sc1200wdt_notifier);
464
465#if defined CONFIG_PNP
466	if (isapnp)
467		pnp_unregister_driver(&scl200wdt_pnp_driver);
468	else
469#endif
470	release_region(io, io_len);
471}
472
473module_init(sc1200wdt_init);
474module_exit(sc1200wdt_exit);
475
476MODULE_AUTHOR("Zwane Mwaikambo <zwane@commfireservices.com>");
477MODULE_DESCRIPTION(
478	"Driver for National Semiconductor PC87307/PC97307 watchdog component");
479MODULE_LICENSE("GPL");
480