w83627hf_wdt.c 10.5 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3
 *	w83627hf/thf WDT driver
 *
4 5 6
 *	(c) Copyright 2013 Guenter Roeck
 *		converted to watchdog infrastructure
 *
7 8
 *	(c) Copyright 2007 Vlad Drukker <vlad@storewiz.com>
 *		added support for W83627THF.
L
Linus Torvalds 已提交
9
 *
A
Al Viro 已提交
10
 *	(c) Copyright 2003,2007 Pádraig Brady <P@draigBrady.com>
L
Linus Torvalds 已提交
11 12 13 14 15 16
 *
 *	Based on advantechwdt.c which is based on wdt.c.
 *	Original copyright messages:
 *
 *	(c) Copyright 2000-2001 Marek Michalkiewicz <marekm@linux.org.pl>
 *
17 18
 *	(c) Copyright 1996 Alan Cox <alan@lxorguk.ukuu.org.uk>,
 *						All Rights Reserved.
L
Linus Torvalds 已提交
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.
 *
 *	Neither Alan Cox nor CymruNet Ltd. admit liability nor provide
 *	warranty for any of this software. This material is provided
 *	"AS-IS" and at no charge.
 *
29
 *	(c) Copyright 1995    Alan Cox <alan@lxorguk.ukuu.org.uk>
L
Linus Torvalds 已提交
30 31
 */

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

L
Linus Torvalds 已提交
34 35 36 37 38 39 40 41
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/types.h>
#include <linux/watchdog.h>
#include <linux/ioport.h>
#include <linux/notifier.h>
#include <linux/reboot.h>
#include <linux/init.h>
42
#include <linux/io.h>
L
Linus Torvalds 已提交
43

44
#define WATCHDOG_NAME "w83627hf/thf/hg/dhg WDT"
L
Linus Torvalds 已提交
45 46
#define WATCHDOG_TIMEOUT 60		/* 60 sec default timeout */

47
static int wdt_io;
48 49
static int cr_wdt_timeout;	/* WDT timeout register */
static int cr_wdt_control;	/* WDT control register */
50

51 52
enum chips { w83627hf, w83627s, w83697hf, w83697ug, w83637hf, w83627thf,
	     w83687thf, w83627ehf, w83627dhg, w83627uhg, w83667hg, w83627dhg_p,
53
	     w83667hg_b, nct6775, nct6776, nct6779, nct6791, nct6792 };
L
Linus Torvalds 已提交
54

55
static int timeout;			/* in seconds */
L
Linus Torvalds 已提交
56
module_param(timeout, int, 0);
57 58 59
MODULE_PARM_DESC(timeout,
		"Watchdog timeout in seconds. 1 <= timeout <= 255, default="
				__MODULE_STRING(WATCHDOG_TIMEOUT) ".");
L
Linus Torvalds 已提交
60

W
Wim Van Sebroeck 已提交
61 62
static bool nowayout = WATCHDOG_NOWAYOUT;
module_param(nowayout, bool, 0);
63 64 65
MODULE_PARM_DESC(nowayout,
		"Watchdog cannot be stopped once started (default="
				__MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
L
Linus Torvalds 已提交
66

67 68 69 70
static int early_disable;
module_param(early_disable, int, 0);
MODULE_PARM_DESC(early_disable, "Disable watchdog at boot time (default=0)");

L
Linus Torvalds 已提交
71 72 73 74 75
/*
 *	Kernel methods.
 */

#define WDT_EFER (wdt_io+0)   /* Extended Function Enable Registers */
76 77
#define WDT_EFIR (wdt_io+0)   /* Extended Function Index Register
							(same as EFER) */
L
Linus Torvalds 已提交
78 79
#define WDT_EFDR (WDT_EFIR+1) /* Extended Function Data Register */

80 81
#define W83627HF_LD_WDT		0x08

82 83
#define W83627HF_ID		0x52
#define W83627S_ID		0x59
84 85
#define W83697HF_ID		0x60
#define W83697UG_ID		0x68
86 87 88 89 90 91 92 93 94 95 96 97
#define W83637HF_ID		0x70
#define W83627THF_ID		0x82
#define W83687THF_ID		0x85
#define W83627EHF_ID		0x88
#define W83627DHG_ID		0xa0
#define W83627UHG_ID		0xa2
#define W83667HG_ID		0xa5
#define W83627DHG_P_ID		0xb0
#define W83667HG_B_ID		0xb3
#define NCT6775_ID		0xb4
#define NCT6776_ID		0xc3
#define NCT6779_ID		0xc5
98 99
#define NCT6791_ID		0xc8
#define NCT6792_ID		0xc9
100

101 102 103 104 105 106
#define W83627HF_WDT_TIMEOUT	0xf6
#define W83697HF_WDT_TIMEOUT	0xf4

#define W83627HF_WDT_CONTROL	0xf5
#define W83697HF_WDT_CONTROL	0xf3

107 108 109 110 111 112 113 114 115 116 117 118 119
static void superio_outb(int reg, int val)
{
	outb(reg, WDT_EFER);
	outb(val, WDT_EFDR);
}

static inline int superio_inb(int reg)
{
	outb(reg, WDT_EFER);
	return inb(WDT_EFDR);
}

static int superio_enter(void)
L
Linus Torvalds 已提交
120
{
121 122 123
	if (!request_muxed_region(wdt_io, 2, WATCHDOG_NAME))
		return -EBUSY;

L
Linus Torvalds 已提交
124 125
	outb_p(0x87, WDT_EFER); /* Enter extended function mode */
	outb_p(0x87, WDT_EFER); /* Again according to manual */
126 127

	return 0;
L
Linus Torvalds 已提交
128 129
}

130 131 132 133 134 135
static void superio_select(int ld)
{
	superio_outb(0x07, ld);
}

static void superio_exit(void)
L
Linus Torvalds 已提交
136 137
{
	outb_p(0xAA, WDT_EFER); /* Leave extended function mode */
138
	release_region(wdt_io, 2);
L
Linus Torvalds 已提交
139 140
}

141
static int w83627hf_init(struct watchdog_device *wdog, enum chips chip)
L
Linus Torvalds 已提交
142
{
143
	int ret;
L
Linus Torvalds 已提交
144 145
	unsigned char t;

146 147 148
	ret = superio_enter();
	if (ret)
		return ret;
L
Linus Torvalds 已提交
149

150
	superio_select(W83627HF_LD_WDT);
151

152 153
	/* set CR30 bit 0 to activate GPIO2 */
	t = superio_inb(0x30);
154
	if (!(t & 0x01))
155
		superio_outb(0x30, t | 0x01);
156

157 158 159 160 161 162
	switch (chip) {
	case w83627hf:
	case w83627s:
		t = superio_inb(0x2B) & ~0x10;
		superio_outb(0x2B, t); /* set GPIO24 to WDT0 */
		break;
163 164 165 166 167 168 169 170 171 172 173
	case w83697hf:
		/* Set pin 119 to WDTO# mode (= CR29, WDT0) */
		t = superio_inb(0x29) & ~0x60;
		t |= 0x20;
		superio_outb(0x29, t);
		break;
	case w83697ug:
		/* Set pin 118 to WDTO# mode */
		t = superio_inb(0x2b) & ~0x04;
		superio_outb(0x2b, t);
		break;
174 175 176 177 178 179 180 181
	case w83627thf:
		t = (superio_inb(0x2B) & ~0x08) | 0x04;
		superio_outb(0x2B, t); /* set GPIO3 to WDT0 */
		break;
	case w83627dhg:
	case w83627dhg_p:
		t = superio_inb(0x2D) & ~0x01; /* PIN77 -> WDT0# */
		superio_outb(0x2D, t); /* set GPIO5 to WDT0 */
182
		t = superio_inb(cr_wdt_control);
183 184
		t |= 0x02;	/* enable the WDTO# output low pulse
				 * to the KBRST# pin */
185
		superio_outb(cr_wdt_control, t);
186 187 188 189 190 191 192 193 194 195 196 197 198 199
		break;
	case w83637hf:
		break;
	case w83687thf:
		t = superio_inb(0x2C) & ~0x80; /* PIN47 -> WDT0# */
		superio_outb(0x2C, t);
		break;
	case w83627ehf:
	case w83627uhg:
	case w83667hg:
	case w83667hg_b:
	case nct6775:
	case nct6776:
	case nct6779:
200 201
	case nct6791:
	case nct6792:
202 203 204 205 206 207
		/*
		 * These chips have a fixed WDTO# output pin (W83627UHG),
		 * or support more than one WDTO# output pin.
		 * Don't touch its configuration, and hope the BIOS
		 * does the right thing.
		 */
208
		t = superio_inb(cr_wdt_control);
209 210
		t |= 0x02;	/* enable the WDTO# output low pulse
				 * to the KBRST# pin */
211
		superio_outb(cr_wdt_control, t);
212 213 214 215 216
		break;
	default:
		break;
	}

217
	t = superio_inb(cr_wdt_timeout);
218
	if (t != 0) {
219 220 221 222 223 224 225 226
		if (early_disable) {
			pr_warn("Stopping previously enabled watchdog until userland kicks in\n");
			superio_outb(cr_wdt_timeout, 0);
		} else {
			pr_info("Watchdog already running. Resetting timeout to %d sec\n",
				wdog->timeout);
			superio_outb(cr_wdt_timeout, wdog->timeout);
		}
227
	}
228

229
	/* set second mode & disable keyboard turning off watchdog */
230 231
	t = superio_inb(cr_wdt_control) & ~0x0C;
	superio_outb(cr_wdt_control, t);
232

233 234
	/* reset trigger, disable keyboard & mouse turning off watchdog */
	t = superio_inb(0xF7) & ~0xD0;
235 236 237 238 239
	superio_outb(0xF7, t);

	superio_exit();

	return 0;
L
Linus Torvalds 已提交
240 241
}

242
static int wdt_set_time(unsigned int timeout)
L
Linus Torvalds 已提交
243
{
244
	int ret;
L
Linus Torvalds 已提交
245

246 247 248
	ret = superio_enter();
	if (ret)
		return ret;
L
Linus Torvalds 已提交
249

250
	superio_select(W83627HF_LD_WDT);
251
	superio_outb(cr_wdt_timeout, timeout);
252
	superio_exit();
253

254
	return 0;
L
Linus Torvalds 已提交
255 256
}

257
static int wdt_start(struct watchdog_device *wdog)
L
Linus Torvalds 已提交
258
{
259
	return wdt_set_time(wdog->timeout);
L
Linus Torvalds 已提交
260 261
}

262
static int wdt_stop(struct watchdog_device *wdog)
L
Linus Torvalds 已提交
263
{
264
	return wdt_set_time(0);
L
Linus Torvalds 已提交
265 266
}

267
static int wdt_set_timeout(struct watchdog_device *wdog, unsigned int timeout)
L
Linus Torvalds 已提交
268
{
269 270
	wdog->timeout = timeout;

L
Linus Torvalds 已提交
271 272 273
	return 0;
}

274
static unsigned int wdt_get_time(struct watchdog_device *wdog)
275
{
276
	unsigned int timeleft;
277
	int ret;
278

279 280 281
	ret = superio_enter();
	if (ret)
		return 0;
282

283
	superio_select(W83627HF_LD_WDT);
284
	timeleft = superio_inb(cr_wdt_timeout);
285
	superio_exit();
286 287 288 289

	return timeleft;
}

L
Linus Torvalds 已提交
290 291 292
/*
 *	Notifier for system down
 */
293
static int wdt_notify_sys(struct notifier_block *this, unsigned long code,
L
Linus Torvalds 已提交
294 295
	void *unused)
{
296
	if (code == SYS_DOWN || code == SYS_HALT)
297
		wdt_set_time(0);	/* Turn the WDT off */
298

L
Linus Torvalds 已提交
299 300 301 302 303 304 305
	return NOTIFY_DONE;
}

/*
 *	Kernel Interfaces
 */

306 307 308
static struct watchdog_info wdt_info = {
	.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
	.identity = "W83627HF Watchdog",
L
Linus Torvalds 已提交
309 310
};

311 312 313 314 315 316 317 318 319 320 321 322 323 324
static struct watchdog_ops wdt_ops = {
	.owner = THIS_MODULE,
	.start = wdt_start,
	.stop = wdt_stop,
	.set_timeout = wdt_set_timeout,
	.get_timeleft = wdt_get_time,
};

static struct watchdog_device wdt_dev = {
	.info = &wdt_info,
	.ops = &wdt_ops,
	.timeout = WATCHDOG_TIMEOUT,
	.min_timeout = 1,
	.max_timeout = 255,
L
Linus Torvalds 已提交
325 326 327 328 329 330 331 332 333 334 335
};

/*
 *	The WDT needs to learn about soft shutdowns in order to
 *	turn the timebomb registers off.
 */

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

336 337 338 339 340
static int wdt_find(int addr)
{
	u8 val;
	int ret;

341 342 343
	cr_wdt_timeout = W83627HF_WDT_TIMEOUT;
	cr_wdt_control = W83627HF_WDT_CONTROL;

344 345 346 347 348 349 350 351 352 353 354 355
	ret = superio_enter();
	if (ret)
		return ret;
	superio_select(W83627HF_LD_WDT);
	val = superio_inb(0x20);
	switch (val) {
	case W83627HF_ID:
		ret = w83627hf;
		break;
	case W83627S_ID:
		ret = w83627s;
		break;
356 357 358 359 360 361 362 363 364 365
	case W83697HF_ID:
		ret = w83697hf;
		cr_wdt_timeout = W83697HF_WDT_TIMEOUT;
		cr_wdt_control = W83697HF_WDT_CONTROL;
		break;
	case W83697UG_ID:
		ret = w83697ug;
		cr_wdt_timeout = W83697HF_WDT_TIMEOUT;
		cr_wdt_control = W83697HF_WDT_CONTROL;
		break;
366 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 400 401
	case W83637HF_ID:
		ret = w83637hf;
		break;
	case W83627THF_ID:
		ret = w83627thf;
		break;
	case W83687THF_ID:
		ret = w83687thf;
		break;
	case W83627EHF_ID:
		ret = w83627ehf;
		break;
	case W83627DHG_ID:
		ret = w83627dhg;
		break;
	case W83627DHG_P_ID:
		ret = w83627dhg_p;
		break;
	case W83627UHG_ID:
		ret = w83627uhg;
		break;
	case W83667HG_ID:
		ret = w83667hg;
		break;
	case W83667HG_B_ID:
		ret = w83667hg_b;
		break;
	case NCT6775_ID:
		ret = nct6775;
		break;
	case NCT6776_ID:
		ret = nct6776;
		break;
	case NCT6779_ID:
		ret = nct6779;
		break;
402 403 404 405 406 407
	case NCT6791_ID:
		ret = nct6791;
		break;
	case NCT6792_ID:
		ret = nct6792;
		break;
408 409 410 411 412 413 414 415 416 417 418 419
	case 0xff:
		ret = -ENODEV;
		break;
	default:
		ret = -ENODEV;
		pr_err("Unsupported chip ID: 0x%02x\n", val);
		break;
	}
	superio_exit();
	return ret;
}

420
static int __init wdt_init(void)
L
Linus Torvalds 已提交
421 422
{
	int ret;
423 424 425 426
	int chip;
	const char * const chip_name[] = {
		"W83627HF",
		"W83627S",
427 428
		"W83697HF",
		"W83697UG",
429 430 431 432 433 434 435 436 437 438 439 440
		"W83637HF",
		"W83627THF",
		"W83687THF",
		"W83627EHF",
		"W83627DHG",
		"W83627UHG",
		"W83667HG",
		"W83667DHG-P",
		"W83667HG-B",
		"NCT6775",
		"NCT6776",
		"NCT6779",
441 442
		"NCT6791",
		"NCT6792",
443 444 445 446 447 448 449 450 451 452
	};

	wdt_io = 0x2e;
	chip = wdt_find(0x2e);
	if (chip < 0) {
		wdt_io = 0x4e;
		chip = wdt_find(0x4e);
		if (chip < 0)
			return chip;
	}
L
Linus Torvalds 已提交
453

454 455
	pr_info("WDT driver for %s Super I/O chip initialising\n",
		chip_name[chip]);
L
Linus Torvalds 已提交
456

457 458 459
	watchdog_init_timeout(&wdt_dev, timeout, NULL);
	watchdog_set_nowayout(&wdt_dev, nowayout);

460
	ret = w83627hf_init(&wdt_dev, chip);
461 462 463 464
	if (ret) {
		pr_err("failed to initialize watchdog (err=%d)\n", ret);
		return ret;
	}
L
Linus Torvalds 已提交
465 466 467

	ret = register_reboot_notifier(&wdt_notifier);
	if (ret != 0) {
468
		pr_err("cannot register reboot notifier (err=%d)\n", ret);
469
		return ret;
L
Linus Torvalds 已提交
470 471
	}

472 473
	ret = watchdog_register_device(&wdt_dev);
	if (ret)
L
Linus Torvalds 已提交
474 475
		goto unreg_reboot;

476
	pr_info("initialized. timeout=%d sec (nowayout=%d)\n",
477
		wdt_dev.timeout, nowayout);
L
Linus Torvalds 已提交
478 479

	return ret;
480

L
Linus Torvalds 已提交
481 482
unreg_reboot:
	unregister_reboot_notifier(&wdt_notifier);
483
	return ret;
L
Linus Torvalds 已提交
484 485
}

486
static void __exit wdt_exit(void)
L
Linus Torvalds 已提交
487
{
488
	watchdog_unregister_device(&wdt_dev);
L
Linus Torvalds 已提交
489 490 491 492 493 494 495
	unregister_reboot_notifier(&wdt_notifier);
}

module_init(wdt_init);
module_exit(wdt_exit);

MODULE_LICENSE("GPL");
A
Al Viro 已提交
496
MODULE_AUTHOR("Pádraig  Brady <P@draigBrady.com>");
497
MODULE_DESCRIPTION("w83627hf/thf WDT driver");