it87_wdt.c 18.3 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
P
Paolo Teti 已提交
15 16
 *	IT8702, IT8712, IT8716, IT8718, IT8720, IT8721, IT8726,
 *	IT8728 and IT8783.
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
 *
 *	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.
 *
 *	You should have received a copy of the GNU General Public License
 *	along with this program; if not, write to the Free Software
 *	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

33 34
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
#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>


50
#define WATCHDOG_VERSION	"1.14"
51 52 53 54 55 56
#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
57
#define DEFAULT_NOCIR		0
58
#define DEFAULT_EXCLUSIVE	1
59
#define DEFAULT_TIMEOUT		60
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
#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
75
#define CHIPREV		0x22
76
#define ACTREG		0x30
77
#define BASEREG		0x60
78 79 80

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

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

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

/* GPIO Bits WDTCFG */
#define WDT_TOV1	0x80
#define WDT_KRST	0x40
#define WDT_TOVE	0x20
110
#define WDT_PWROK	0x10 /* not in it8721 */
111 112 113
#define WDT_INT_MASK	0x0f

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

/* 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
141
#define WDTS_USE_CIR	6
142

143
static	unsigned int base, gpact, ciract, max_units, chip_type;
144 145 146
static	unsigned long wdt_status;

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

module_param(nogameport, int, 0);
MODULE_PARM_DESC(nogameport, "Forbid the activation of game port, default="
		__MODULE_STRING(DEFAULT_NOGAMEPORT));
156 157 158
module_param(nocir, int, 0);
MODULE_PARM_DESC(nocir, "Forbid the use of Consumer IR interrupts to reset timer, default="
		__MODULE_STRING(DEFAULT_NOCIR));
159 160 161 162 163 164 165 166 167
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 已提交
168
module_param(nowayout, bool, 0);
169 170 171 172 173
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started, default="
		__MODULE_STRING(WATCHDOG_NOWAYOUT));

/* Superio Chip */

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

182 183 184 185
	outb(0x87, REG);
	outb(0x01, REG);
	outb(0x55, REG);
	outb(0x55, REG);
186
	return 0;
187 188 189 190 191 192
}

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

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)
{
210 211
	outb(reg, REG);
	outb(val, VAL);
212 213 214 215 216 217 218 219 220 221 222 223 224 225
}

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)
{
226 227 228 229
	outb(reg++, REG);
	outb(val >> 8, VAL);
	outb(reg, REG);
	outb(val, VAL);
230 231
}

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

	if (testmode)
		cfg = 0;

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

246 247 248
	if (chip_type != IT8721_ID)
		cfg |= WDT_PWROK;

249 250 251 252 253 254 255 256 257 258 259 260 261
	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;
}

262 263 264 265 266 267
/* watchdog timer handling */

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

		superio_select(GPIO);
		wdt_update_timeout();
		superio_exit();
	}
279 280 281
	set_bit(WDTS_KEEPALIVE, &wdt_status);
}

282
static int wdt_start(void)
283
{
284 285 286
	int ret = superio_enter();
	if (ret)
		return ret;
287 288 289 290

	superio_select(GPIO);
	if (test_bit(WDTS_USE_GP, &wdt_status))
		superio_outb(WDT_GAMEPORT, WDTCTRL);
291
	else if (test_bit(WDTS_USE_CIR, &wdt_status))
292
		superio_outb(WDT_CIRINT, WDTCTRL);
293
	wdt_update_timeout();
294 295

	superio_exit();
296 297

	return 0;
298 299
}

300
static int wdt_stop(void)
301
{
302 303 304
	int ret = superio_enter();
	if (ret)
		return ret;
305 306 307 308 309

	superio_select(GPIO);
	superio_outb(0x00, WDTCTRL);
	superio_outb(WDT_TOV1, WDTCFG);
	superio_outb(0x00, WDTVALLSB);
310 311
	if (max_units > 255)
		superio_outb(0x00, WDTVALMSB);
312 313

	superio_exit();
314
	return 0;
315 316 317 318 319 320
}

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

static int wdt_set_timeout(int t)
{
329
	if (t < 1 || t > max_units * 60)
330 331
		return -EINVAL;

332 333 334 335
	if (t > max_units)
		timeout = wdt_round_time(t);
	else
		timeout = t;
336 337

	if (test_bit(WDTS_TIMER_RUN, &wdt_status)) {
338 339 340 341
		int ret = superio_enter();
		if (ret)
			return ret;

342
		superio_select(GPIO);
343
		wdt_update_timeout();
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
		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) {
366 367 368 369
		int ret = superio_enter();
		if (ret)
			return ret;

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 400 401 402
		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)) {
403
		int ret;
404 405
		if (nowayout && !test_and_set_bit(WDTS_LOCKED, &wdt_status))
			__module_get(THIS_MODULE);
406 407 408 409 410 411 412 413

		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;
		}
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
	}
	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)) {
435 436 437 438 439 440 441 442 443 444
			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;
			}
445 446 447
			clear_bit(WDTS_TIMER_RUN, &wdt_status);
		} else {
			wdt_keepalive();
448
			pr_crit("unexpected close, not stopping watchdog!\n");
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 487 488 489
		}
	}
	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;
}

490
static const struct watchdog_info ident = {
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 521 522 523
	.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:
524 525 526
		rc = wdt_get_status(&status);
		if (rc)
			return rc;
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
		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:
542 543 544 545 546
			if (test_bit(WDTS_TIMER_RUN, &wdt_status)) {
				rc = wdt_stop();
				if (rc)
					return rc;
			}
547 548 549 550
			clear_bit(WDTS_TIMER_RUN, &wdt_status);
			return 0;

		case WDIOS_ENABLECARD:
551 552 553 554 555 556 557
			if (!test_and_set_bit(WDTS_TIMER_RUN, &wdt_status)) {
				rc = wdt_start();
				if (rc) {
					clear_bit(WDTS_TIMER_RUN, &wdt_status);
					return rc;
				}
			}
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 605 606 607
			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;
608
	int try_gameport = !nogameport;
609
	u8  chip_rev;
610
	int gp_rreq_fail = 0;
611

612 613
	wdt_status = 0;

614 615 616 617
	rc = superio_enter();
	if (rc)
		return rc;

618 619 620 621 622
	chip_type = superio_inw(CHIPID);
	chip_rev  = superio_inb(CHIPREV) & 0x0f;
	superio_exit();

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

654 655 656
	rc = superio_enter();
	if (rc)
		return rc;
657 658 659 660 661 662

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

	/* First try to get Gameport support */
663
	if (try_gameport) {
664 665 666 667 668 669 670 671 672 673 674
		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
675
			gp_rreq_fail = 1;
676 677 678
	}

	/* If we haven't Gameport support, try to get CIR support */
679
	if (!nocir && !test_bit(WDTS_USE_GP, &wdt_status)) {
680
		if (!request_region(CIR_BASE, 8, WATCHDOG_NAME)) {
681
			if (gp_rreq_fail)
682 683
				pr_err("I/O Address 0x%04x and 0x%04x already in use\n",
				       base, CIR_BASE);
684
			else
685 686
				pr_err("I/O Address 0x%04x already in use\n",
				       CIR_BASE);
687 688 689 690 691 692 693 694 695 696
			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);
697
		if (gp_rreq_fail) {
698 699 700
			superio_select(GAMEPORT);
			superio_outb(gpact, ACTREG);
		}
701
		set_bit(WDTS_USE_CIR, &wdt_status);
702 703
	}

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

710 711 712
	if (timeout > max_units)
		timeout = wdt_round_time(timeout);

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

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

	/* Initialize CIR to use it as keepalive source */
727
	if (test_bit(WDTS_USE_CIR, &wdt_status)) {
728 729 730 731 732 733 734 735 736
		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));
	}

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

741
	superio_exit();
742 743 744 745 746
	return 0;

err_out_reboot:
	unregister_reboot_notifier(&wdt_notifier);
err_out_region:
747 748 749 750
	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);
751 752 753 754
		superio_select(CIR);
		superio_outb(ciract, ACTREG);
	}
err_out:
755
	if (try_gameport) {
756 757 758 759
		superio_select(GAMEPORT);
		superio_outb(gpact, ACTREG);
	}

760
	superio_exit();
761 762 763 764 765
	return rc;
}

static void __exit it87_wdt_exit(void)
{
766 767 768 769 770 771 772 773 774 775
	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);
776
		} else if (test_bit(WDTS_USE_CIR, &wdt_status)) {
777 778 779 780
			superio_select(CIR);
			superio_outb(ciract, ACTREG);
		}
		superio_exit();
781 782 783 784
	}

	misc_deregister(&wdt_miscdev);
	unregister_reboot_notifier(&wdt_notifier);
785 786 787 788 789

	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);
790 791 792 793 794 795 796 797
}

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");