it87_wdt.c 18.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 *	Watchdog Timer Driver
 *	   for ITE IT87xx Environment Control - Low Pin Count Input / Output
 *
 *	(c) Copyright 2007  Oliver Schuster <olivers137@aol.com>
 *
 *	Based on softdog.c	by Alan Cox,
 *		 83977f_wdt.c	by Jose Goncalves,
 *		 it87.c		by Chris Gauthron, Jean Delvare
 *
 *	Data-sheets: Publicly available at the ITE website
 *		    http://www.ite.com.tw/
 *
 *	Support of the watchdog timers, which are available on
15
 *	IT8620, IT8702, IT8712, IT8716, IT8718, IT8720, IT8721, IT8726,
P
Paolo Teti 已提交
16
 *	IT8728 and IT8783.
17 18 19 20 21 22 23 24 25 26 27 28
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 *
 *	This program is distributed in the hope that it will be useful,
 *	but WITHOUT ANY WARRANTY; without even the implied warranty of
 *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *	GNU General Public License for more details.
 */

29 30
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/watchdog.h>
#include <linux/notifier.h>
#include <linux/reboot.h>
#include <linux/uaccess.h>
#include <linux/io.h>


46
#define WATCHDOG_VERSION	"1.14"
47 48 49 50 51 52
#define WATCHDOG_NAME		"IT87 WDT"
#define DRIVER_VERSION		WATCHDOG_NAME " driver, v" WATCHDOG_VERSION "\n"
#define WD_MAGIC		'V'

/* Defaults for Module Parameter */
#define DEFAULT_NOGAMEPORT	0
53
#define DEFAULT_NOCIR		0
54
#define DEFAULT_EXCLUSIVE	1
55
#define DEFAULT_TIMEOUT		60
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
#define DEFAULT_TESTMODE	0
#define DEFAULT_NOWAYOUT	WATCHDOG_NOWAYOUT

/* IO Ports */
#define REG		0x2e
#define VAL		0x2f

/* Logical device Numbers LDN */
#define GPIO		0x07
#define GAMEPORT	0x09
#define CIR		0x0a

/* Configuration Registers and Functions */
#define LDNREG		0x07
#define CHIPID		0x20
71
#define CHIPREV		0x22
72
#define ACTREG		0x30
73
#define BASEREG		0x60
74 75 76

/* Chip Id numbers */
#define NO_DEV_ID	0xffff
77
#define IT8620_ID	0x8620
78
#define IT8702_ID	0x8702
79 80 81 82
#define IT8705_ID	0x8705
#define IT8712_ID	0x8712
#define IT8716_ID	0x8716
#define IT8718_ID	0x8718
83
#define IT8720_ID	0x8720
84
#define IT8721_ID	0x8721
85
#define IT8726_ID	0x8726	/* the data sheet suggest wrongly 0x8716 */
86
#define IT8728_ID	0x8728
P
Paolo Teti 已提交
87
#define IT8783_ID	0x8783
88 89

/* GPIO Configuration Registers LDN=0x07 */
90
#define WDTCTRL		0x71
91 92 93 94 95 96 97 98
#define WDTCFG		0x72
#define WDTVALLSB	0x73
#define WDTVALMSB	0x74

/* GPIO Bits WDTCTRL */
#define WDT_CIRINT	0x80
#define WDT_MOUSEINT	0x40
#define WDT_KYBINT	0x20
99
#define WDT_GAMEPORT	0x10 /* not in it8718, it8720, it8721, it8728 */
100 101 102 103 104 105 106
#define WDT_FORCE	0x02
#define WDT_ZERO	0x01

/* GPIO Bits WDTCFG */
#define WDT_TOV1	0x80
#define WDT_KRST	0x40
#define WDT_TOVE	0x20
107
#define WDT_PWROK	0x10 /* not in it8721 */
108 109 110
#define WDT_INT_MASK	0x0f

/* CIR Configuration Register LDN=0x0a */
111
#define CIR_ILS		0x70
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137

/* The default Base address is not always available, we use this */
#define CIR_BASE	0x0208

/* CIR Controller */
#define CIR_DR(b)	(b)
#define CIR_IER(b)	(b + 1)
#define CIR_RCR(b)	(b + 2)
#define CIR_TCR1(b)	(b + 3)
#define CIR_TCR2(b)	(b + 4)
#define CIR_TSR(b)	(b + 5)
#define CIR_RSR(b)	(b + 6)
#define CIR_BDLR(b)	(b + 5)
#define CIR_BDHR(b)	(b + 6)
#define CIR_IIR(b)	(b + 7)

/* Default Base address of Game port */
#define GP_BASE_DEFAULT	0x0201

/* wdt_status */
#define WDTS_TIMER_RUN	0
#define WDTS_DEV_OPEN	1
#define WDTS_KEEPALIVE	2
#define WDTS_LOCKED	3
#define WDTS_USE_GP	4
#define WDTS_EXPECTED	5
138
#define WDTS_USE_CIR	6
139

140
static	unsigned int base, gpact, ciract, max_units, chip_type;
141 142 143
static	unsigned long wdt_status;

static	int nogameport = DEFAULT_NOGAMEPORT;
144
static int nocir      = DEFAULT_NOCIR;
145 146 147
static	int exclusive  = DEFAULT_EXCLUSIVE;
static	int timeout    = DEFAULT_TIMEOUT;
static	int testmode   = DEFAULT_TESTMODE;
W
Wim Van Sebroeck 已提交
148
static	bool nowayout   = DEFAULT_NOWAYOUT;
149 150 151 152

module_param(nogameport, int, 0);
MODULE_PARM_DESC(nogameport, "Forbid the activation of game port, default="
		__MODULE_STRING(DEFAULT_NOGAMEPORT));
153 154 155
module_param(nocir, int, 0);
MODULE_PARM_DESC(nocir, "Forbid the use of Consumer IR interrupts to reset timer, default="
		__MODULE_STRING(DEFAULT_NOCIR));
156 157 158 159 160 161 162 163 164
module_param(exclusive, int, 0);
MODULE_PARM_DESC(exclusive, "Watchdog exclusive device open, default="
		__MODULE_STRING(DEFAULT_EXCLUSIVE));
module_param(timeout, int, 0);
MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds, default="
		__MODULE_STRING(DEFAULT_TIMEOUT));
module_param(testmode, int, 0);
MODULE_PARM_DESC(testmode, "Watchdog test mode (1 = no reboot), default="
		__MODULE_STRING(DEFAULT_TESTMODE));
W
Wim Van Sebroeck 已提交
165
module_param(nowayout, bool, 0);
166 167 168 169 170
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started, default="
		__MODULE_STRING(WATCHDOG_NOWAYOUT));

/* Superio Chip */

171
static inline int superio_enter(void)
172
{
173 174 175 176 177 178
	/*
	 * Try to reserve REG and REG + 1 for exclusive access.
	 */
	if (!request_muxed_region(REG, 2, WATCHDOG_NAME))
		return -EBUSY;

179 180 181 182
	outb(0x87, REG);
	outb(0x01, REG);
	outb(0x55, REG);
	outb(0x55, REG);
183
	return 0;
184 185 186 187 188 189
}

static inline void superio_exit(void)
{
	outb(0x02, REG);
	outb(0x02, VAL);
190
	release_region(REG, 2);
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
}

static inline void superio_select(int ldn)
{
	outb(LDNREG, REG);
	outb(ldn, VAL);
}

static inline int superio_inb(int reg)
{
	outb(reg, REG);
	return inb(VAL);
}

static inline void superio_outb(int val, int reg)
{
207 208
	outb(reg, REG);
	outb(val, VAL);
209 210 211 212 213 214 215 216 217 218 219 220 221 222
}

static inline int superio_inw(int reg)
{
	int val;
	outb(reg++, REG);
	val = inb(VAL) << 8;
	outb(reg, REG);
	val |= inb(VAL);
	return val;
}

static inline void superio_outw(int val, int reg)
{
223 224 225 226
	outb(reg++, REG);
	outb(val >> 8, VAL);
	outb(reg, REG);
	outb(val, VAL);
227 228
}

229 230 231
/* Internal function, should be called after superio_select(GPIO) */
static void wdt_update_timeout(void)
{
232
	unsigned char cfg = WDT_KRST;
233 234 235 236 237 238 239 240 241 242
	int tm = timeout;

	if (testmode)
		cfg = 0;

	if (tm <= max_units)
		cfg |= WDT_TOV1;
	else
		tm /= 60;

243 244 245
	if (chip_type != IT8721_ID)
		cfg |= WDT_PWROK;

246 247 248 249 250 251 252 253 254 255 256 257 258
	superio_outb(cfg, WDTCFG);
	superio_outb(tm, WDTVALLSB);
	if (max_units > 255)
		superio_outb(tm>>8, WDTVALMSB);
}

static int wdt_round_time(int t)
{
	t += 59;
	t -= t % 60;
	return t;
}

259 260 261 262 263 264
/* watchdog timer handling */

static void wdt_keepalive(void)
{
	if (test_bit(WDTS_USE_GP, &wdt_status))
		inb(base);
265
	else if (test_bit(WDTS_USE_CIR, &wdt_status))
266 267
		/* The timer reloads with around 5 msec delay */
		outb(0x55, CIR_DR(base));
268 269 270 271 272 273 274 275
	else {
		if (superio_enter())
			return;

		superio_select(GPIO);
		wdt_update_timeout();
		superio_exit();
	}
276 277 278
	set_bit(WDTS_KEEPALIVE, &wdt_status);
}

279
static int wdt_start(void)
280
{
281 282 283
	int ret = superio_enter();
	if (ret)
		return ret;
284 285 286 287

	superio_select(GPIO);
	if (test_bit(WDTS_USE_GP, &wdt_status))
		superio_outb(WDT_GAMEPORT, WDTCTRL);
288
	else if (test_bit(WDTS_USE_CIR, &wdt_status))
289
		superio_outb(WDT_CIRINT, WDTCTRL);
290
	wdt_update_timeout();
291 292

	superio_exit();
293 294

	return 0;
295 296
}

297
static int wdt_stop(void)
298
{
299 300 301
	int ret = superio_enter();
	if (ret)
		return ret;
302 303 304 305 306

	superio_select(GPIO);
	superio_outb(0x00, WDTCTRL);
	superio_outb(WDT_TOV1, WDTCFG);
	superio_outb(0x00, WDTVALLSB);
307 308
	if (max_units > 255)
		superio_outb(0x00, WDTVALMSB);
309 310

	superio_exit();
311
	return 0;
312 313 314 315 316 317
}

/**
 *	wdt_set_timeout - set a new timeout value with watchdog ioctl
 *	@t: timeout value in seconds
 *
318 319
 *	The hardware device has a 8 or 16 bit watchdog timer (depends on
 *	chip version) that can be configured to count seconds or minutes.
320 321 322 323 324 325
 *
 *	Used within WDIOC_SETTIMEOUT watchdog device ioctl.
 */

static int wdt_set_timeout(int t)
{
326
	if (t < 1 || t > max_units * 60)
327 328
		return -EINVAL;

329 330 331 332
	if (t > max_units)
		timeout = wdt_round_time(t);
	else
		timeout = t;
333 334

	if (test_bit(WDTS_TIMER_RUN, &wdt_status)) {
335 336 337 338
		int ret = superio_enter();
		if (ret)
			return ret;

339
		superio_select(GPIO);
340
		wdt_update_timeout();
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
		superio_exit();
	}
	return 0;
}

/**
 *	wdt_get_status - determines the status supported by watchdog ioctl
 *	@status: status returned to user space
 *
 *	The status bit of the device does not allow to distinguish
 *	between a regular system reset and a watchdog forced reset.
 *	But, in test mode it is useful, so it is supported through
 *	WDIOC_GETSTATUS watchdog ioctl. Additionally the driver
 *	reports the keepalive signal and the acception of the magic.
 *
 *	Used within WDIOC_GETSTATUS watchdog device ioctl.
 */

static int wdt_get_status(int *status)
{
	*status = 0;
	if (testmode) {
363 364 365 366
		int ret = superio_enter();
		if (ret)
			return ret;

367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
		superio_select(GPIO);
		if (superio_inb(WDTCTRL) & WDT_ZERO) {
			superio_outb(0x00, WDTCTRL);
			clear_bit(WDTS_TIMER_RUN, &wdt_status);
			*status |= WDIOF_CARDRESET;
		}

		superio_exit();
	}
	if (test_and_clear_bit(WDTS_KEEPALIVE, &wdt_status))
		*status |= WDIOF_KEEPALIVEPING;
	if (test_bit(WDTS_EXPECTED, &wdt_status))
		*status |= WDIOF_MAGICCLOSE;
	return 0;
}

/* /dev/watchdog handling */

/**
 *	wdt_open - watchdog file_operations .open
 *	@inode: inode of the device
 *	@file: file handle to the device
 *
 *	The watchdog timer starts by opening the device.
 *
 *	Used within the file operation of the watchdog device.
 */

static int wdt_open(struct inode *inode, struct file *file)
{
	if (exclusive && test_and_set_bit(WDTS_DEV_OPEN, &wdt_status))
		return -EBUSY;
	if (!test_and_set_bit(WDTS_TIMER_RUN, &wdt_status)) {
400
		int ret;
401 402
		if (nowayout && !test_and_set_bit(WDTS_LOCKED, &wdt_status))
			__module_get(THIS_MODULE);
403 404 405 406 407 408 409 410

		ret = wdt_start();
		if (ret) {
			clear_bit(WDTS_LOCKED, &wdt_status);
			clear_bit(WDTS_TIMER_RUN, &wdt_status);
			clear_bit(WDTS_DEV_OPEN, &wdt_status);
			return ret;
		}
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
	}
	return nonseekable_open(inode, file);
}

/**
 *	wdt_release - watchdog file_operations .release
 *	@inode: inode of the device
 *	@file: file handle to the device
 *
 *	Closing the watchdog device either stops the watchdog timer
 *	or in the case, that nowayout is set or the magic character
 *	wasn't written, a critical warning about an running watchdog
 *	timer is given.
 *
 *	Used within the file operation of the watchdog device.
 */

static int wdt_release(struct inode *inode, struct file *file)
{
	if (test_bit(WDTS_TIMER_RUN, &wdt_status)) {
		if (test_and_clear_bit(WDTS_EXPECTED, &wdt_status)) {
432 433 434 435 436 437 438 439 440 441
			int ret = wdt_stop();
			if (ret) {
				/*
				 * Stop failed. Just keep the watchdog alive
				 * and hope nothing bad happens.
				 */
				set_bit(WDTS_EXPECTED, &wdt_status);
				wdt_keepalive();
				return ret;
			}
442 443 444
			clear_bit(WDTS_TIMER_RUN, &wdt_status);
		} else {
			wdt_keepalive();
445
			pr_crit("unexpected close, not stopping watchdog!\n");
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
		}
	}
	clear_bit(WDTS_DEV_OPEN, &wdt_status);
	return 0;
}

/**
 *	wdt_write - watchdog file_operations .write
 *	@file: file handle to the watchdog
 *	@buf: buffer to write
 *	@count: count of bytes
 *	@ppos: pointer to the position to write. No seeks allowed
 *
 *	A write to a watchdog device is defined as a keepalive signal. Any
 *	write of data will do, as we don't define content meaning.
 *
 *	Used within the file operation of the watchdog device.
 */

static ssize_t wdt_write(struct file *file, const char __user *buf,
			    size_t count, loff_t *ppos)
{
	if (count) {
		clear_bit(WDTS_EXPECTED, &wdt_status);
		wdt_keepalive();
	}
	if (!nowayout) {
		size_t ofs;

	/* note: just in case someone wrote the magic character long ago */
		for (ofs = 0; ofs != count; ofs++) {
			char c;
			if (get_user(c, buf + ofs))
				return -EFAULT;
			if (c == WD_MAGIC)
				set_bit(WDTS_EXPECTED, &wdt_status);
		}
	}
	return count;
}

487
static const struct watchdog_info ident = {
488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
	.options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
	.firmware_version =	1,
	.identity = WATCHDOG_NAME,
};

/**
 *	wdt_ioctl - watchdog file_operations .unlocked_ioctl
 *	@file: file handle to the device
 *	@cmd: watchdog command
 *	@arg: argument pointer
 *
 *	The watchdog API defines a common set of functions for all watchdogs
 *	according to their available features.
 *
 *	Used within the file operation of the watchdog device.
 */

static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	int rc = 0, status, new_options, new_timeout;
	union {
		struct watchdog_info __user *ident;
		int __user *i;
	} uarg;

	uarg.i = (int __user *)arg;

	switch (cmd) {
	case WDIOC_GETSUPPORT:
		return copy_to_user(uarg.ident,
				    &ident, sizeof(ident)) ? -EFAULT : 0;

	case WDIOC_GETSTATUS:
521 522 523
		rc = wdt_get_status(&status);
		if (rc)
			return rc;
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
		return put_user(status, uarg.i);

	case WDIOC_GETBOOTSTATUS:
		return put_user(0, uarg.i);

	case WDIOC_KEEPALIVE:
		wdt_keepalive();
		return 0;

	case WDIOC_SETOPTIONS:
		if (get_user(new_options, uarg.i))
			return -EFAULT;

		switch (new_options) {
		case WDIOS_DISABLECARD:
539 540 541 542 543
			if (test_bit(WDTS_TIMER_RUN, &wdt_status)) {
				rc = wdt_stop();
				if (rc)
					return rc;
			}
544 545 546 547
			clear_bit(WDTS_TIMER_RUN, &wdt_status);
			return 0;

		case WDIOS_ENABLECARD:
548 549 550 551 552 553 554
			if (!test_and_set_bit(WDTS_TIMER_RUN, &wdt_status)) {
				rc = wdt_start();
				if (rc) {
					clear_bit(WDTS_TIMER_RUN, &wdt_status);
					return rc;
				}
			}
555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
			return 0;

		default:
			return -EFAULT;
		}

	case WDIOC_SETTIMEOUT:
		if (get_user(new_timeout, uarg.i))
			return -EFAULT;
		rc = wdt_set_timeout(new_timeout);
	case WDIOC_GETTIMEOUT:
		if (put_user(timeout, uarg.i))
			return -EFAULT;
		return rc;

	default:
		return -ENOTTY;
	}
}

static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
	void *unused)
{
	if (code == SYS_DOWN || code == SYS_HALT)
		wdt_stop();
	return NOTIFY_DONE;
}

static const struct file_operations wdt_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.write		= wdt_write,
	.unlocked_ioctl	= wdt_ioctl,
	.open		= wdt_open,
	.release	= wdt_release,
};

static struct miscdevice wdt_miscdev = {
	.minor		= WATCHDOG_MINOR,
	.name		= "watchdog",
	.fops		= &wdt_fops,
};

static struct notifier_block wdt_notifier = {
	.notifier_call = wdt_notify_sys,
};

static int __init it87_wdt_init(void)
{
	int rc = 0;
605
	int try_gameport = !nogameport;
606
	u8  chip_rev;
607
	int gp_rreq_fail = 0;
608

609 610
	wdt_status = 0;

611 612 613 614
	rc = superio_enter();
	if (rc)
		return rc;

615 616 617 618 619
	chip_type = superio_inw(CHIPID);
	chip_rev  = superio_inb(CHIPREV) & 0x0f;
	superio_exit();

	switch (chip_type) {
620 621 622 623 624 625
	case IT8702_ID:
		max_units = 255;
		break;
	case IT8712_ID:
		max_units = (chip_rev < 8) ? 255 : 65535;
		break;
626 627
	case IT8716_ID:
	case IT8726_ID:
628
		max_units = 65535;
629
		break;
630
	case IT8620_ID:
631 632
	case IT8718_ID:
	case IT8720_ID:
633
	case IT8721_ID:
634
	case IT8728_ID:
P
Paolo Teti 已提交
635
	case IT8783_ID:
636
		max_units = 65535;
637 638
		try_gameport = 0;
		break;
639
	case IT8705_ID:
640
		pr_err("Unsupported Chip found, Chip %04x Revision %02x\n",
641 642 643
		       chip_type, chip_rev);
		return -ENODEV;
	case NO_DEV_ID:
644
		pr_err("no device\n");
645 646
		return -ENODEV;
	default:
647
		pr_err("Unknown Chip found, Chip %04x Revision %04x\n",
648 649 650 651
		       chip_type, chip_rev);
		return -ENODEV;
	}

652 653 654
	rc = superio_enter();
	if (rc)
		return rc;
655 656 657 658 659 660

	superio_select(GPIO);
	superio_outb(WDT_TOV1, WDTCFG);
	superio_outb(0x00, WDTCTRL);

	/* First try to get Gameport support */
661
	if (try_gameport) {
662 663 664 665 666 667 668 669 670 671 672
		superio_select(GAMEPORT);
		base = superio_inw(BASEREG);
		if (!base) {
			base = GP_BASE_DEFAULT;
			superio_outw(base, BASEREG);
		}
		gpact = superio_inb(ACTREG);
		superio_outb(0x01, ACTREG);
		if (request_region(base, 1, WATCHDOG_NAME))
			set_bit(WDTS_USE_GP, &wdt_status);
		else
673
			gp_rreq_fail = 1;
674 675 676
	}

	/* If we haven't Gameport support, try to get CIR support */
677
	if (!nocir && !test_bit(WDTS_USE_GP, &wdt_status)) {
678
		if (!request_region(CIR_BASE, 8, WATCHDOG_NAME)) {
679
			if (gp_rreq_fail)
680 681
				pr_err("I/O Address 0x%04x and 0x%04x already in use\n",
				       base, CIR_BASE);
682
			else
683 684
				pr_err("I/O Address 0x%04x already in use\n",
				       CIR_BASE);
685 686 687 688 689 690 691 692 693 694
			rc = -EIO;
			goto err_out;
		}
		base = CIR_BASE;

		superio_select(CIR);
		superio_outw(base, BASEREG);
		superio_outb(0x00, CIR_ILS);
		ciract = superio_inb(ACTREG);
		superio_outb(0x01, ACTREG);
695
		if (gp_rreq_fail) {
696 697 698
			superio_select(GAMEPORT);
			superio_outb(gpact, ACTREG);
		}
699
		set_bit(WDTS_USE_CIR, &wdt_status);
700 701
	}

702
	if (timeout < 1 || timeout > max_units * 60) {
703
		timeout = DEFAULT_TIMEOUT;
704 705
		pr_warn("Timeout value out of range, use default %d sec\n",
			DEFAULT_TIMEOUT);
706 707
	}

708 709 710
	if (timeout > max_units)
		timeout = wdt_round_time(timeout);

711 712
	rc = register_reboot_notifier(&wdt_notifier);
	if (rc) {
713
		pr_err("Cannot register reboot notifier (err=%d)\n", rc);
714 715 716 717 718
		goto err_out_region;
	}

	rc = misc_register(&wdt_miscdev);
	if (rc) {
719 720
		pr_err("Cannot register miscdev on minor=%d (err=%d)\n",
		       wdt_miscdev.minor, rc);
721 722 723 724
		goto err_out_reboot;
	}

	/* Initialize CIR to use it as keepalive source */
725
	if (test_bit(WDTS_USE_CIR, &wdt_status)) {
726 727 728 729 730 731 732 733 734
		outb(0x00, CIR_RCR(base));
		outb(0xc0, CIR_TCR1(base));
		outb(0x5c, CIR_TCR2(base));
		outb(0x10, CIR_IER(base));
		outb(0x00, CIR_BDHR(base));
		outb(0x01, CIR_BDLR(base));
		outb(0x09, CIR_IER(base));
	}

735
	pr_info("Chip IT%04x revision %d initialized. timeout=%d sec (nowayout=%d testmode=%d exclusive=%d nogameport=%d nocir=%d)\n",
736
		chip_type, chip_rev, timeout,
737
		nowayout, testmode, exclusive, nogameport, nocir);
738

739
	superio_exit();
740 741 742 743 744
	return 0;

err_out_reboot:
	unregister_reboot_notifier(&wdt_notifier);
err_out_region:
745 746 747 748
	if (test_bit(WDTS_USE_GP, &wdt_status))
		release_region(base, 1);
	else if (test_bit(WDTS_USE_CIR, &wdt_status)) {
		release_region(base, 8);
749 750 751 752
		superio_select(CIR);
		superio_outb(ciract, ACTREG);
	}
err_out:
753
	if (try_gameport) {
754 755 756 757
		superio_select(GAMEPORT);
		superio_outb(gpact, ACTREG);
	}

758
	superio_exit();
759 760 761 762 763
	return rc;
}

static void __exit it87_wdt_exit(void)
{
764 765 766 767 768 769 770 771 772 773
	if (superio_enter() == 0) {
		superio_select(GPIO);
		superio_outb(0x00, WDTCTRL);
		superio_outb(0x00, WDTCFG);
		superio_outb(0x00, WDTVALLSB);
		if (max_units > 255)
			superio_outb(0x00, WDTVALMSB);
		if (test_bit(WDTS_USE_GP, &wdt_status)) {
			superio_select(GAMEPORT);
			superio_outb(gpact, ACTREG);
774
		} else if (test_bit(WDTS_USE_CIR, &wdt_status)) {
775 776 777 778
			superio_select(CIR);
			superio_outb(ciract, ACTREG);
		}
		superio_exit();
779 780 781 782
	}

	misc_deregister(&wdt_miscdev);
	unregister_reboot_notifier(&wdt_notifier);
783 784 785 786 787

	if (test_bit(WDTS_USE_GP, &wdt_status))
		release_region(base, 1);
	else if (test_bit(WDTS_USE_CIR, &wdt_status))
		release_region(base, 8);
788 789 790 791 792 793 794 795
}

module_init(it87_wdt_init);
module_exit(it87_wdt_exit);

MODULE_AUTHOR("Oliver Schuster");
MODULE_DESCRIPTION("Hardware Watchdog Device Driver for IT87xx EC-LPC I/O");
MODULE_LICENSE("GPL");