thermal.c 30.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
/*
 *  acpi_thermal.c - ACPI Thermal Zone Driver ($Revision: 41 $)
 *
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  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.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This driver fully implements the ACPI thermal policy as described in the
 *  ACPI 2.0 Specification.
 *
 *  TBD: 1. Implement passive cooling hysteresis.
 *       2. Enhance passive cooling (CPU) states/limit interface to support
 *          concepts of 'multiple limiters', upper/lower limits, etc.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
36
#include <linux/dmi.h>
L
Linus Torvalds 已提交
37
#include <linux/init.h>
38
#include <linux/slab.h>
L
Linus Torvalds 已提交
39
#include <linux/types.h>
40
#include <linux/jiffies.h>
L
Linus Torvalds 已提交
41
#include <linux/kmod.h>
42
#include <linux/reboot.h>
43
#include <linux/device.h>
L
Linus Torvalds 已提交
44
#include <asm/uaccess.h>
45
#include <linux/thermal.h>
L
Linus Torvalds 已提交
46 47 48
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>

49 50
#define PREFIX "ACPI: "

L
Linus Torvalds 已提交
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
#define ACPI_THERMAL_CLASS		"thermal_zone"
#define ACPI_THERMAL_DEVICE_NAME	"Thermal Zone"
#define ACPI_THERMAL_FILE_STATE		"state"
#define ACPI_THERMAL_FILE_TEMPERATURE	"temperature"
#define ACPI_THERMAL_FILE_TRIP_POINTS	"trip_points"
#define ACPI_THERMAL_FILE_COOLING_MODE	"cooling_mode"
#define ACPI_THERMAL_FILE_POLLING_FREQ	"polling_frequency"
#define ACPI_THERMAL_NOTIFY_TEMPERATURE	0x80
#define ACPI_THERMAL_NOTIFY_THRESHOLDS	0x81
#define ACPI_THERMAL_NOTIFY_DEVICES	0x82
#define ACPI_THERMAL_NOTIFY_CRITICAL	0xF0
#define ACPI_THERMAL_NOTIFY_HOT		0xF1
#define ACPI_THERMAL_MODE_ACTIVE	0x00

#define ACPI_THERMAL_MAX_ACTIVE	10
#define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65

#define _COMPONENT		ACPI_THERMAL_COMPONENT
69
ACPI_MODULE_NAME("thermal");
L
Linus Torvalds 已提交
70

71
MODULE_AUTHOR("Paul Diefenbaugh");
72
MODULE_DESCRIPTION("ACPI Thermal Zone Driver");
L
Linus Torvalds 已提交
73 74
MODULE_LICENSE("GPL");

75 76
static int act;
module_param(act, int, 0644);
77
MODULE_PARM_DESC(act, "Disable or override all lowest active trip points.");
78

79 80 81 82
static int crt;
module_param(crt, int, 0644);
MODULE_PARM_DESC(crt, "Disable or lower all critical trip points.");

L
Linus Torvalds 已提交
83
static int tzp;
84
module_param(tzp, int, 0444);
85
MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.");
L
Linus Torvalds 已提交
86

87 88
static int nocrt;
module_param(nocrt, int, 0);
89
MODULE_PARM_DESC(nocrt, "Set to take no action upon ACPI thermal zone critical trips points.");
90

91 92
static int off;
module_param(off, int, 0);
93
MODULE_PARM_DESC(off, "Set to disable ACPI thermal support.");
94

95 96
static int psv;
module_param(psv, int, 0644);
97
MODULE_PARM_DESC(psv, "Disable or override all passive trip points.");
98

L
Len Brown 已提交
99 100
static int acpi_thermal_add(struct acpi_device *device);
static int acpi_thermal_remove(struct acpi_device *device, int type);
101
static void acpi_thermal_notify(struct acpi_device *device, u32 event);
L
Linus Torvalds 已提交
102

103 104 105 106 107 108
static const struct acpi_device_id  thermal_device_ids[] = {
	{ACPI_THERMAL_HID, 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, thermal_device_ids);

109 110 111
static int acpi_thermal_resume(struct device *dev);
static SIMPLE_DEV_PM_OPS(acpi_thermal_pm, NULL, acpi_thermal_resume);

L
Linus Torvalds 已提交
112
static struct acpi_driver acpi_thermal_driver = {
L
Len Brown 已提交
113
	.name = "thermal",
L
Len Brown 已提交
114
	.class = ACPI_THERMAL_CLASS,
115
	.ids = thermal_device_ids,
L
Len Brown 已提交
116 117 118
	.ops = {
		.add = acpi_thermal_add,
		.remove = acpi_thermal_remove,
119
		.notify = acpi_thermal_notify,
L
Len Brown 已提交
120
		},
121
	.drv.pm = &acpi_thermal_pm,
L
Linus Torvalds 已提交
122 123 124
};

struct acpi_thermal_state {
L
Len Brown 已提交
125 126 127 128 129 130
	u8 critical:1;
	u8 hot:1;
	u8 passive:1;
	u8 active:1;
	u8 reserved:4;
	int active_index;
L
Linus Torvalds 已提交
131 132 133
};

struct acpi_thermal_state_flags {
L
Len Brown 已提交
134 135 136
	u8 valid:1;
	u8 enabled:1;
	u8 reserved:6;
L
Linus Torvalds 已提交
137 138 139 140
};

struct acpi_thermal_critical {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
141
	unsigned long temperature;
L
Linus Torvalds 已提交
142 143 144 145
};

struct acpi_thermal_hot {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
146
	unsigned long temperature;
L
Linus Torvalds 已提交
147 148 149 150
};

struct acpi_thermal_passive {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
151 152 153 154 155
	unsigned long temperature;
	unsigned long tc1;
	unsigned long tc2;
	unsigned long tsp;
	struct acpi_handle_list devices;
L
Linus Torvalds 已提交
156 157 158 159
};

struct acpi_thermal_active {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
160 161
	unsigned long temperature;
	struct acpi_handle_list devices;
L
Linus Torvalds 已提交
162 163 164 165
};

struct acpi_thermal_trips {
	struct acpi_thermal_critical critical;
L
Len Brown 已提交
166
	struct acpi_thermal_hot hot;
L
Linus Torvalds 已提交
167 168 169 170 171
	struct acpi_thermal_passive passive;
	struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
};

struct acpi_thermal_flags {
L
Len Brown 已提交
172 173 174
	u8 cooling_mode:1;	/* _SCP */
	u8 devices:1;		/* _TZD */
	u8 reserved:6;
L
Linus Torvalds 已提交
175 176 177
};

struct acpi_thermal {
178
	struct acpi_device * device;
L
Len Brown 已提交
179 180 181 182 183
	acpi_bus_id name;
	unsigned long temperature;
	unsigned long last_temperature;
	unsigned long polling_frequency;
	volatile u8 zombie;
L
Linus Torvalds 已提交
184 185 186
	struct acpi_thermal_flags flags;
	struct acpi_thermal_state state;
	struct acpi_thermal_trips trips;
L
Len Brown 已提交
187
	struct acpi_handle_list devices;
188 189
	struct thermal_zone_device *thermal_zone;
	int tz_enabled;
190
	int kelvin_offset;
191
	struct mutex lock;
L
Linus Torvalds 已提交
192 193 194 195 196 197
};

/* --------------------------------------------------------------------------
                             Thermal Zone Management
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
198
static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
199
{
L
Len Brown 已提交
200
	acpi_status status = AE_OK;
201
	unsigned long long tmp;
L
Linus Torvalds 已提交
202 203

	if (!tz)
204
		return -EINVAL;
L
Linus Torvalds 已提交
205 206 207

	tz->last_temperature = tz->temperature;

208
	status = acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tmp);
L
Linus Torvalds 已提交
209
	if (ACPI_FAILURE(status))
210
		return -ENODEV;
L
Linus Torvalds 已提交
211

212
	tz->temperature = tmp;
L
Len Brown 已提交
213 214
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
			  tz->temperature));
L
Linus Torvalds 已提交
215

216
	return 0;
L
Linus Torvalds 已提交
217 218
}

L
Len Brown 已提交
219
static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
220
{
L
Len Brown 已提交
221
	acpi_status status = AE_OK;
222
	unsigned long long tmp;
L
Linus Torvalds 已提交
223 224

	if (!tz)
225
		return -EINVAL;
L
Linus Torvalds 已提交
226

227
	status = acpi_evaluate_integer(tz->device->handle, "_TZP", NULL, &tmp);
L
Linus Torvalds 已提交
228
	if (ACPI_FAILURE(status))
229
		return -ENODEV;
L
Linus Torvalds 已提交
230

231
	tz->polling_frequency = tmp;
L
Len Brown 已提交
232 233
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
			  tz->polling_frequency));
L
Linus Torvalds 已提交
234

235
	return 0;
L
Linus Torvalds 已提交
236 237
}

L
Len Brown 已提交
238
static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
L
Linus Torvalds 已提交
239
{
L
Len Brown 已提交
240 241 242 243
	acpi_status status = AE_OK;
	union acpi_object arg0 = { ACPI_TYPE_INTEGER };
	struct acpi_object_list arg_list = { 1, &arg0 };
	acpi_handle handle = NULL;
L
Linus Torvalds 已提交
244 245 246


	if (!tz)
247
		return -EINVAL;
L
Linus Torvalds 已提交
248

249
	status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
L
Linus Torvalds 已提交
250 251
	if (ACPI_FAILURE(status)) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
252
		return -ENODEV;
L
Linus Torvalds 已提交
253 254 255 256 257 258
	}

	arg0.integer.value = mode;

	status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
	if (ACPI_FAILURE(status))
259
		return -ENODEV;
L
Linus Torvalds 已提交
260

261
	return 0;
L
Linus Torvalds 已提交
262 263
}

264 265 266 267 268
#define ACPI_TRIPS_CRITICAL	0x01
#define ACPI_TRIPS_HOT		0x02
#define ACPI_TRIPS_PASSIVE	0x04
#define ACPI_TRIPS_ACTIVE	0x08
#define ACPI_TRIPS_DEVICES	0x10
L
Linus Torvalds 已提交
269

270 271
#define ACPI_TRIPS_REFRESH_THRESHOLDS	(ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE)
#define ACPI_TRIPS_REFRESH_DEVICES	ACPI_TRIPS_DEVICES
L
Linus Torvalds 已提交
272

273 274 275
#define ACPI_TRIPS_INIT      (ACPI_TRIPS_CRITICAL | ACPI_TRIPS_HOT |	\
			      ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE |	\
			      ACPI_TRIPS_DEVICES)
L
Linus Torvalds 已提交
276

277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
/*
 * This exception is thrown out in two cases:
 * 1.An invalid trip point becomes invalid or a valid trip point becomes invalid
 *   when re-evaluating the AML code.
 * 2.TODO: Devices listed in _PSL, _ALx, _TZD may change.
 *   We need to re-bind the cooling devices of a thermal zone when this occurs.
 */
#define ACPI_THERMAL_TRIPS_EXCEPTION(flags, str)	\
do {	\
	if (flags != ACPI_TRIPS_INIT)	\
		ACPI_EXCEPTION((AE_INFO, AE_ERROR,	\
		"ACPI thermal trip point %s changed\n"	\
		"Please send acpidump to linux-acpi@vger.kernel.org\n", str)); \
} while (0)

static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
{
	acpi_status status = AE_OK;
295
	unsigned long long tmp;
296 297 298
	struct acpi_handle_list devices;
	int valid = 0;
	int i;
L
Linus Torvalds 已提交
299

300
	/* Critical Shutdown */
301 302
	if (flag & ACPI_TRIPS_CRITICAL) {
		status = acpi_evaluate_integer(tz->device->handle,
303 304
				"_CRT", NULL, &tmp);
		tz->trips.critical.temperature = tmp;
305 306 307
		/*
		 * Treat freezing temperatures as invalid as well; some
		 * BIOSes return really low values and cause reboots at startup.
308
		 * Below zero (Celsius) values clearly aren't right for sure..
309 310
		 * ... so lets discard those as invalid.
		 */
311 312 313 314 315 316 317
		if (ACPI_FAILURE(status)) {
			tz->trips.critical.flags.valid = 0;
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "No critical threshold\n"));
		} else if (tmp <= 2732) {
			printk(KERN_WARNING FW_BUG "Invalid critical threshold "
			       "(%llu)\n", tmp);
318
			tz->trips.critical.flags.valid = 0;
319 320 321
		} else {
			tz->trips.critical.flags.valid = 1;
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
322 323
					  "Found critical threshold [%lu]\n",
					  tz->trips.critical.temperature));
324 325 326 327 328 329 330
		}
		if (tz->trips.critical.flags.valid == 1) {
			if (crt == -1) {
				tz->trips.critical.flags.valid = 0;
			} else if (crt > 0) {
				unsigned long crt_k = CELSIUS_TO_KELVIN(crt);
				/*
331
				 * Allow override critical threshold
332
				 */
333 334 335 336
				if (crt_k > tz->trips.critical.temperature)
					printk(KERN_WARNING PREFIX
						"Critical threshold %d C\n", crt);
				tz->trips.critical.temperature = crt_k;
337
			}
338 339 340
		}
	}

L
Linus Torvalds 已提交
341
	/* Critical Sleep (optional) */
342
	if (flag & ACPI_TRIPS_HOT) {
343
		status = acpi_evaluate_integer(tz->device->handle,
344
				"_HOT", NULL, &tmp);
345 346 347 348 349
		if (ACPI_FAILURE(status)) {
			tz->trips.hot.flags.valid = 0;
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					"No hot threshold\n"));
		} else {
350
			tz->trips.hot.temperature = tmp;
351 352 353 354 355
			tz->trips.hot.flags.valid = 1;
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					"Found hot threshold [%lu]\n",
					tz->trips.critical.temperature));
		}
356 357
	}

358
	/* Passive (optional) */
359 360
	if (((flag & ACPI_TRIPS_PASSIVE) && tz->trips.passive.flags.valid) ||
		(flag == ACPI_TRIPS_INIT)) {
361 362 363 364
		valid = tz->trips.passive.flags.valid;
		if (psv == -1) {
			status = AE_SUPPORT;
		} else if (psv > 0) {
365
			tmp = CELSIUS_TO_KELVIN(psv);
366 367 368
			status = AE_OK;
		} else {
			status = acpi_evaluate_integer(tz->device->handle,
369
				"_PSV", NULL, &tmp);
370
		}
L
Linus Torvalds 已提交
371 372 373

		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;
374
		else {
375
			tz->trips.passive.temperature = tmp;
376 377 378 379
			tz->trips.passive.flags.valid = 1;
			if (flag == ACPI_TRIPS_INIT) {
				status = acpi_evaluate_integer(
						tz->device->handle, "_TC1",
380
						NULL, &tmp);
381 382
				if (ACPI_FAILURE(status))
					tz->trips.passive.flags.valid = 0;
383 384
				else
					tz->trips.passive.tc1 = tmp;
385 386
				status = acpi_evaluate_integer(
						tz->device->handle, "_TC2",
387
						NULL, &tmp);
388 389
				if (ACPI_FAILURE(status))
					tz->trips.passive.flags.valid = 0;
390 391
				else
					tz->trips.passive.tc2 = tmp;
392 393
				status = acpi_evaluate_integer(
						tz->device->handle, "_TSP",
394
						NULL, &tmp);
395 396
				if (ACPI_FAILURE(status))
					tz->trips.passive.flags.valid = 0;
397 398
				else
					tz->trips.passive.tsp = tmp;
399 400 401 402 403 404 405
			}
		}
	}
	if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.passive.flags.valid) {
		memset(&devices, 0, sizeof(struct acpi_handle_list));
		status = acpi_evaluate_reference(tz->device->handle, "_PSL",
							NULL, &devices);
406 407 408
		if (ACPI_FAILURE(status)) {
			printk(KERN_WARNING PREFIX
				"Invalid passive threshold\n");
L
Linus Torvalds 已提交
409
			tz->trips.passive.flags.valid = 0;
410
		}
L
Linus Torvalds 已提交
411
		else
412
			tz->trips.passive.flags.valid = 1;
L
Linus Torvalds 已提交
413

414 415 416 417 418 419 420 421 422 423 424
		if (memcmp(&tz->trips.passive.devices, &devices,
				sizeof(struct acpi_handle_list))) {
			memcpy(&tz->trips.passive.devices, &devices,
				sizeof(struct acpi_handle_list));
			ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
		}
	}
	if ((flag & ACPI_TRIPS_PASSIVE) || (flag & ACPI_TRIPS_DEVICES)) {
		if (valid != tz->trips.passive.flags.valid)
				ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");
	}
L
Linus Torvalds 已提交
425

426
	/* Active (optional) */
L
Len Brown 已提交
427 428
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
		char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
429
		valid = tz->trips.active[i].flags.valid;
L
Linus Torvalds 已提交
430

431
		if (act == -1)
432 433
			break; /* disable all active trip points */

434 435
		if ((flag == ACPI_TRIPS_INIT) || ((flag & ACPI_TRIPS_ACTIVE) &&
			tz->trips.active[i].flags.valid)) {
436
			status = acpi_evaluate_integer(tz->device->handle,
437
							name, NULL, &tmp);
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
			if (ACPI_FAILURE(status)) {
				tz->trips.active[i].flags.valid = 0;
				if (i == 0)
					break;
				if (act <= 0)
					break;
				if (i == 1)
					tz->trips.active[0].temperature =
						CELSIUS_TO_KELVIN(act);
				else
					/*
					 * Don't allow override higher than
					 * the next higher trip point
					 */
					tz->trips.active[i - 1].temperature =
						(tz->trips.active[i - 2].temperature <
						CELSIUS_TO_KELVIN(act) ?
						tz->trips.active[i - 2].temperature :
						CELSIUS_TO_KELVIN(act));
457
				break;
458 459
			} else {
				tz->trips.active[i].temperature = tmp;
460
				tz->trips.active[i].flags.valid = 1;
461
			}
462
		}
L
Linus Torvalds 已提交
463 464

		name[2] = 'L';
465 466 467 468
		if ((flag & ACPI_TRIPS_DEVICES) && tz->trips.active[i].flags.valid ) {
			memset(&devices, 0, sizeof(struct acpi_handle_list));
			status = acpi_evaluate_reference(tz->device->handle,
						name, NULL, &devices);
469 470 471
			if (ACPI_FAILURE(status)) {
				printk(KERN_WARNING PREFIX
					"Invalid active%d threshold\n", i);
472
				tz->trips.active[i].flags.valid = 0;
473
			}
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
			else
				tz->trips.active[i].flags.valid = 1;

			if (memcmp(&tz->trips.active[i].devices, &devices,
					sizeof(struct acpi_handle_list))) {
				memcpy(&tz->trips.active[i].devices, &devices,
					sizeof(struct acpi_handle_list));
				ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
			}
		}
		if ((flag & ACPI_TRIPS_ACTIVE) || (flag & ACPI_TRIPS_DEVICES))
			if (valid != tz->trips.active[i].flags.valid)
				ACPI_THERMAL_TRIPS_EXCEPTION(flag, "state");

		if (!tz->trips.active[i].flags.valid)
			break;
	}

	if (flag & ACPI_TRIPS_DEVICES) {
		memset(&devices, 0, sizeof(struct acpi_handle_list));
		status = acpi_evaluate_reference(tz->device->handle, "_TZD",
						NULL, &devices);
		if (memcmp(&tz->devices, &devices,
				sizeof(struct acpi_handle_list))) {
			memcpy(&tz->devices, &devices,
				sizeof(struct acpi_handle_list));
			ACPI_THERMAL_TRIPS_EXCEPTION(flag, "device");
		}
L
Linus Torvalds 已提交
502 503
	}

504
	return 0;
L
Linus Torvalds 已提交
505 506
}

507
static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
508
{
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
	int i, valid, ret = acpi_thermal_trips_update(tz, ACPI_TRIPS_INIT);

	if (ret)
		return ret;

	valid = tz->trips.critical.flags.valid |
		tz->trips.hot.flags.valid |
		tz->trips.passive.flags.valid;

	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
		valid |= tz->trips.active[i].flags.valid;

	if (!valid) {
		printk(KERN_WARNING FW_BUG "No valid trip found\n");
		return -ENODEV;
	}
	return 0;
L
Linus Torvalds 已提交
526 527
}

L
Len Brown 已提交
528
static void acpi_thermal_check(void *data)
L
Linus Torvalds 已提交
529
{
530
	struct acpi_thermal *tz = data;
L
Linus Torvalds 已提交
531

532
	thermal_zone_device_update(tz->thermal_zone);
L
Linus Torvalds 已提交
533 534
}

535
/* sys I/F for generic thermal sysfs support */
536
#define KELVIN_TO_MILLICELSIUS(t, off) (((t) - (off)) * 100)
537

538 539
static int thermal_get_temp(struct thermal_zone_device *thermal,
			    unsigned long *temp)
540 541
{
	struct acpi_thermal *tz = thermal->devdata;
Z
Zhang, Rui 已提交
542
	int result;
543 544 545 546

	if (!tz)
		return -EINVAL;

Z
Zhang, Rui 已提交
547 548 549 550
	result = acpi_thermal_get_temperature(tz);
	if (result)
		return result;

551
	*temp = KELVIN_TO_MILLICELSIUS(tz->temperature, tz->kelvin_offset);
552
	return 0;
553 554 555
}

static int thermal_get_mode(struct thermal_zone_device *thermal,
556
				enum thermal_device_mode *mode)
557 558 559 560 561 562
{
	struct acpi_thermal *tz = thermal->devdata;

	if (!tz)
		return -EINVAL;

563 564 565 566
	*mode = tz->tz_enabled ? THERMAL_DEVICE_ENABLED :
		THERMAL_DEVICE_DISABLED;

	return 0;
567 568 569
}

static int thermal_set_mode(struct thermal_zone_device *thermal,
570
				enum thermal_device_mode mode)
571 572 573 574 575 576 577 578 579 580
{
	struct acpi_thermal *tz = thermal->devdata;
	int enable;

	if (!tz)
		return -EINVAL;

	/*
	 * enable/disable thermal management from ACPI thermal driver
	 */
581
	if (mode == THERMAL_DEVICE_ENABLED)
582
		enable = 1;
583
	else if (mode == THERMAL_DEVICE_DISABLED)
584 585 586 587 588 589 590
		enable = 0;
	else
		return -EINVAL;

	if (enable != tz->tz_enabled) {
		tz->tz_enabled = enable;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Z
Zhang Rui 已提交
591 592
			"%s kernel ACPI thermal control\n",
			tz->tz_enabled ? "Enable" : "Disable"));
593 594 595 596 597 598
		acpi_thermal_check(tz);
	}
	return 0;
}

static int thermal_get_trip_type(struct thermal_zone_device *thermal,
599
				 int trip, enum thermal_trip_type *type)
600 601 602 603 604 605 606 607
{
	struct acpi_thermal *tz = thermal->devdata;
	int i;

	if (!tz || trip < 0)
		return -EINVAL;

	if (tz->trips.critical.flags.valid) {
608 609 610 611
		if (!trip) {
			*type = THERMAL_TRIP_CRITICAL;
			return 0;
		}
612 613 614 615
		trip--;
	}

	if (tz->trips.hot.flags.valid) {
616 617 618 619
		if (!trip) {
			*type = THERMAL_TRIP_HOT;
			return 0;
		}
620 621 622 623
		trip--;
	}

	if (tz->trips.passive.flags.valid) {
624 625 626 627
		if (!trip) {
			*type = THERMAL_TRIP_PASSIVE;
			return 0;
		}
628 629 630 631 632
		trip--;
	}

	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
		tz->trips.active[i].flags.valid; i++) {
633 634 635 636
		if (!trip) {
			*type = THERMAL_TRIP_ACTIVE;
			return 0;
		}
637 638 639 640 641 642 643
		trip--;
	}

	return -EINVAL;
}

static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
644
				 int trip, unsigned long *temp)
645 646 647 648 649 650 651 652
{
	struct acpi_thermal *tz = thermal->devdata;
	int i;

	if (!tz || trip < 0)
		return -EINVAL;

	if (tz->trips.critical.flags.valid) {
653 654
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
655 656
				tz->trips.critical.temperature,
				tz->kelvin_offset);
657 658
			return 0;
		}
659 660 661 662
		trip--;
	}

	if (tz->trips.hot.flags.valid) {
663 664
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
665 666
				tz->trips.hot.temperature,
				tz->kelvin_offset);
667 668
			return 0;
		}
669 670 671 672
		trip--;
	}

	if (tz->trips.passive.flags.valid) {
673 674
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
675 676
				tz->trips.passive.temperature,
				tz->kelvin_offset);
677 678
			return 0;
		}
679 680 681 682 683
		trip--;
	}

	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
		tz->trips.active[i].flags.valid; i++) {
684 685
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
686 687
				tz->trips.active[i].temperature,
				tz->kelvin_offset);
688 689
			return 0;
		}
690 691 692 693 694 695
		trip--;
	}

	return -EINVAL;
}

696 697 698 699 700 701
static int thermal_get_crit_temp(struct thermal_zone_device *thermal,
				unsigned long *temperature) {
	struct acpi_thermal *tz = thermal->devdata;

	if (tz->trips.critical.flags.valid) {
		*temperature = KELVIN_TO_MILLICELSIUS(
702 703
				tz->trips.critical.temperature,
				tz->kelvin_offset);
704 705 706 707 708
		return 0;
	} else
		return -EINVAL;
}

709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740
static int thermal_get_trend(struct thermal_zone_device *thermal,
				int trip, enum thermal_trend *trend)
{
	struct acpi_thermal *tz = thermal->devdata;
	enum thermal_trip_type type;
	int i;

	if (thermal_get_trip_type(thermal, trip, &type))
		return -EINVAL;

	/* Only PASSIVE trip points need TREND */
	if (type != THERMAL_TRIP_PASSIVE)
		return -EINVAL;

	/*
	 * tz->temperature has already been updated by generic thermal layer,
	 * before this callback being invoked
	 */
	i = (tz->trips.passive.tc1 * (tz->temperature - tz->last_temperature))
		+ (tz->trips.passive.tc2
		* (tz->temperature - tz->trips.passive.temperature));

	if (i > 0)
		*trend = THERMAL_TREND_RAISING;
	else if (i < 0)
		*trend = THERMAL_TREND_DROPPING;
	else
		*trend = THERMAL_TREND_STABLE;
	return 0;
}


741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
static int thermal_notify(struct thermal_zone_device *thermal, int trip,
			   enum thermal_trip_type trip_type)
{
	u8 type = 0;
	struct acpi_thermal *tz = thermal->devdata;

	if (trip_type == THERMAL_TRIP_CRITICAL)
		type = ACPI_THERMAL_NOTIFY_CRITICAL;
	else if (trip_type == THERMAL_TRIP_HOT)
		type = ACPI_THERMAL_NOTIFY_HOT;
	else
		return 0;

	acpi_bus_generate_proc_event(tz->device, type, 1);
	acpi_bus_generate_netlink_event(tz->device->pnp.device_class,
756
					dev_name(&tz->device->dev), type, 1);
757 758 759 760 761 762 763

	if (trip_type == THERMAL_TRIP_CRITICAL && nocrt)
		return 1;

	return 0;
}

764 765
static int acpi_thermal_cooling_device_cb(struct thermal_zone_device *thermal,
					struct thermal_cooling_device *cdev,
Z
Zhang Rui 已提交
766
					bool bind)
767 768 769
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_thermal *tz = thermal->devdata;
Z
Zhang Rui 已提交
770 771 772
	struct acpi_device *dev;
	acpi_status status;
	acpi_handle handle;
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787
	int i;
	int j;
	int trip = -1;
	int result = 0;

	if (tz->trips.critical.flags.valid)
		trip++;

	if (tz->trips.hot.flags.valid)
		trip++;

	if (tz->trips.passive.flags.valid) {
		trip++;
		for (i = 0; i < tz->trips.passive.devices.count;
		    i++) {
Z
Zhang Rui 已提交
788 789
			handle = tz->trips.passive.devices.handles[i];
			status = acpi_bus_get_device(handle, &dev);
Z
Zhang Rui 已提交
790 791 792 793 794 795 796 797 798 799 800 801 802
			if (ACPI_FAILURE(status) || dev != device)
				continue;
			if (bind)
				result =
					thermal_zone_bind_cooling_device
					(thermal, trip, cdev,
					 THERMAL_NO_LIMIT, THERMAL_NO_LIMIT);
			else
				result =
					thermal_zone_unbind_cooling_device
					(thermal, trip, cdev);
			if (result)
				goto failed;
803 804 805 806 807 808 809 810 811 812
		}
	}

	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
		if (!tz->trips.active[i].flags.valid)
			break;
		trip++;
		for (j = 0;
		    j < tz->trips.active[i].devices.count;
		    j++) {
Z
Zhang Rui 已提交
813 814
			handle = tz->trips.active[i].devices.handles[j];
			status = acpi_bus_get_device(handle, &dev);
Z
Zhang Rui 已提交
815 816 817 818 819 820 821 822 823 824 825
			if (ACPI_FAILURE(status) || dev != device)
				continue;
			if (bind)
				result = thermal_zone_bind_cooling_device
					(thermal, trip, cdev,
					 THERMAL_NO_LIMIT, THERMAL_NO_LIMIT);
			else
				result = thermal_zone_unbind_cooling_device
					(thermal, trip, cdev);
			if (result)
				goto failed;
826 827 828 829
		}
	}

	for (i = 0; i < tz->devices.count; i++) {
Z
Zhang Rui 已提交
830 831 832
		handle = tz->devices.handles[i];
		status = acpi_bus_get_device(handle, &dev);
		if (ACPI_SUCCESS(status) && (dev == device)) {
Z
Zhang Rui 已提交
833 834 835 836 837 838 839 840
			if (bind)
				result = thermal_zone_bind_cooling_device
						(thermal, -1, cdev,
						 THERMAL_NO_LIMIT,
						 THERMAL_NO_LIMIT);
			else
				result = thermal_zone_unbind_cooling_device
						(thermal, -1, cdev);
Z
Zhang Rui 已提交
841 842 843
			if (result)
				goto failed;
		}
844 845 846 847 848 849 850 851 852 853
	}

failed:
	return result;
}

static int
acpi_thermal_bind_cooling_device(struct thermal_zone_device *thermal,
					struct thermal_cooling_device *cdev)
{
Z
Zhang Rui 已提交
854
	return acpi_thermal_cooling_device_cb(thermal, cdev, true);
855 856 857 858 859 860
}

static int
acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal,
					struct thermal_cooling_device *cdev)
{
Z
Zhang Rui 已提交
861
	return acpi_thermal_cooling_device_cb(thermal, cdev, false);
862 863
}

V
Vasiliy Kulikov 已提交
864
static const struct thermal_zone_device_ops acpi_thermal_zone_ops = {
865 866 867 868 869 870 871
	.bind = acpi_thermal_bind_cooling_device,
	.unbind	= acpi_thermal_unbind_cooling_device,
	.get_temp = thermal_get_temp,
	.get_mode = thermal_get_mode,
	.set_mode = thermal_set_mode,
	.get_trip_type = thermal_get_trip_type,
	.get_trip_temp = thermal_get_trip_temp,
872
	.get_crit_temp = thermal_get_crit_temp,
873
	.get_trend = thermal_get_trend,
874
	.notify = thermal_notify,
875 876 877 878 879 880
};

static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
{
	int trips = 0;
	int result;
Z
Zhang Rui 已提交
881
	acpi_status status;
882 883 884 885 886 887 888 889 890 891 892 893 894
	int i;

	if (tz->trips.critical.flags.valid)
		trips++;

	if (tz->trips.hot.flags.valid)
		trips++;

	if (tz->trips.passive.flags.valid)
		trips++;

	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
			tz->trips.active[i].flags.valid; i++, trips++);
895 896 897

	if (tz->trips.passive.flags.valid)
		tz->thermal_zone =
898
			thermal_zone_device_register("acpitz", trips, 0, tz,
899 900 901 902 903
						     &acpi_thermal_zone_ops,
						     tz->trips.passive.tsp*100,
						     tz->polling_frequency*100);
	else
		tz->thermal_zone =
904
			thermal_zone_device_register("acpitz", trips, 0, tz,
905
						     &acpi_thermal_zone_ops, 0,
906
						     tz->polling_frequency*100);
K
Krzysztof Helt 已提交
907
	if (IS_ERR(tz->thermal_zone))
908 909 910 911 912 913 914 915 916 917 918 919
		return -ENODEV;

	result = sysfs_create_link(&tz->device->dev.kobj,
				   &tz->thermal_zone->device.kobj, "thermal_zone");
	if (result)
		return result;

	result = sysfs_create_link(&tz->thermal_zone->device.kobj,
				   &tz->device->dev.kobj, "device");
	if (result)
		return result;

Z
Zhang Rui 已提交
920 921 922 923
	status = acpi_attach_data(tz->device->handle,
				  acpi_bus_private_data_handler,
				  tz->thermal_zone);
	if (ACPI_FAILURE(status)) {
924 925
		printk(KERN_ERR PREFIX
				"Error attaching device data\n");
Z
Zhang Rui 已提交
926 927 928
		return -ENODEV;
	}

929 930
	tz->tz_enabled = 1;

931 932
	dev_info(&tz->device->dev, "registered as thermal_zone%d\n",
		 tz->thermal_zone->id);
933 934 935 936 937 938 939 940 941
	return 0;
}

static void acpi_thermal_unregister_thermal_zone(struct acpi_thermal *tz)
{
	sysfs_remove_link(&tz->device->dev.kobj, "thermal_zone");
	sysfs_remove_link(&tz->thermal_zone->device.kobj, "device");
	thermal_zone_device_unregister(tz->thermal_zone);
	tz->thermal_zone = NULL;
Z
Zhang Rui 已提交
942
	acpi_detach_data(tz->device->handle, acpi_bus_private_data_handler);
943 944 945
}


L
Linus Torvalds 已提交
946 947 948 949
/* --------------------------------------------------------------------------
                                 Driver Interface
   -------------------------------------------------------------------------- */

950
static void acpi_thermal_notify(struct acpi_device *device, u32 event)
L
Linus Torvalds 已提交
951
{
952
	struct acpi_thermal *tz = acpi_driver_data(device);
L
Linus Torvalds 已提交
953 954 955


	if (!tz)
956
		return;
L
Linus Torvalds 已提交
957 958 959 960 961 962

	switch (event) {
	case ACPI_THERMAL_NOTIFY_TEMPERATURE:
		acpi_thermal_check(tz);
		break;
	case ACPI_THERMAL_NOTIFY_THRESHOLDS:
963
		acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_THRESHOLDS);
L
Linus Torvalds 已提交
964
		acpi_thermal_check(tz);
965
		acpi_bus_generate_proc_event(device, event, 0);
966
		acpi_bus_generate_netlink_event(device->pnp.device_class,
967
						  dev_name(&device->dev), event, 0);
L
Linus Torvalds 已提交
968 969
		break;
	case ACPI_THERMAL_NOTIFY_DEVICES:
970 971
		acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_DEVICES);
		acpi_thermal_check(tz);
972
		acpi_bus_generate_proc_event(device, event, 0);
973
		acpi_bus_generate_netlink_event(device->pnp.device_class,
974
						  dev_name(&device->dev), event, 0);
L
Linus Torvalds 已提交
975 976 977
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
978
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
979 980 981 982
		break;
	}
}

L
Len Brown 已提交
983
static int acpi_thermal_get_info(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
984
{
L
Len Brown 已提交
985
	int result = 0;
L
Linus Torvalds 已提交
986 987 988


	if (!tz)
989
		return -EINVAL;
L
Linus Torvalds 已提交
990

991 992
	/* Get trip points [_CRT, _PSV, etc.] (required) */
	result = acpi_thermal_get_trip_points(tz);
L
Linus Torvalds 已提交
993
	if (result)
994
		return result;
L
Linus Torvalds 已提交
995

996 997
	/* Get temperature [_TMP] (required) */
	result = acpi_thermal_get_temperature(tz);
L
Linus Torvalds 已提交
998
	if (result)
999
		return result;
L
Linus Torvalds 已提交
1000 1001 1002

	/* Set the cooling mode [_SCP] to active cooling (default) */
	result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
L
Len Brown 已提交
1003
	if (!result)
L
Linus Torvalds 已提交
1004 1005 1006 1007 1008 1009 1010 1011
		tz->flags.cooling_mode = 1;

	/* Get default polling frequency [_TZP] (optional) */
	if (tzp)
		tz->polling_frequency = tzp;
	else
		acpi_thermal_get_polling_frequency(tz);

1012
	return 0;
L
Linus Torvalds 已提交
1013 1014
}

1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
/*
 * The exact offset between Kelvin and degree Celsius is 273.15. However ACPI
 * handles temperature values with a single decimal place. As a consequence,
 * some implementations use an offset of 273.1 and others use an offset of
 * 273.2. Try to find out which one is being used, to present the most
 * accurate and visually appealing number.
 *
 * The heuristic below should work for all ACPI thermal zones which have a
 * critical trip point with a value being a multiple of 0.5 degree Celsius.
 */
static void acpi_thermal_guess_offset(struct acpi_thermal *tz)
{
	if (tz->trips.critical.flags.valid &&
	    (tz->trips.critical.temperature % 5) == 1)
		tz->kelvin_offset = 2731;
	else
		tz->kelvin_offset = 2732;
}

L
Len Brown 已提交
1034
static int acpi_thermal_add(struct acpi_device *device)
L
Linus Torvalds 已提交
1035
{
L
Len Brown 已提交
1036 1037
	int result = 0;
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1038 1039 1040


	if (!device)
1041
		return -EINVAL;
L
Linus Torvalds 已提交
1042

1043
	tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
L
Linus Torvalds 已提交
1044
	if (!tz)
1045
		return -ENOMEM;
L
Linus Torvalds 已提交
1046

1047
	tz->device = device;
L
Linus Torvalds 已提交
1048 1049 1050
	strcpy(tz->name, device->pnp.bus_id);
	strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
1051
	device->driver_data = tz;
1052
	mutex_init(&tz->lock);
1053 1054


L
Linus Torvalds 已提交
1055 1056
	result = acpi_thermal_get_info(tz);
	if (result)
1057 1058
		goto free_memory;

1059 1060
	acpi_thermal_guess_offset(tz);

1061 1062 1063
	result = acpi_thermal_register_thermal_zone(tz);
	if (result)
		goto free_memory;
L
Linus Torvalds 已提交
1064 1065

	printk(KERN_INFO PREFIX "%s [%s] (%ld C)\n",
L
Len Brown 已提交
1066 1067
	       acpi_device_name(device), acpi_device_bid(device),
	       KELVIN_TO_CELSIUS(tz->temperature));
1068
	goto end;
L
Linus Torvalds 已提交
1069

1070 1071 1072
free_memory:
	kfree(tz);
end:
1073
	return result;
L
Linus Torvalds 已提交
1074 1075
}

L
Len Brown 已提交
1076
static int acpi_thermal_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
1077
{
L
Len Brown 已提交
1078
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1079 1080

	if (!device || !acpi_driver_data(device))
1081
		return -EINVAL;
L
Linus Torvalds 已提交
1082

1083
	tz = acpi_driver_data(device);
L
Linus Torvalds 已提交
1084

1085
	acpi_thermal_unregister_thermal_zone(tz);
1086
	mutex_destroy(&tz->lock);
L
Linus Torvalds 已提交
1087
	kfree(tz);
1088
	return 0;
L
Linus Torvalds 已提交
1089 1090
}

1091
static int acpi_thermal_resume(struct device *dev)
1092
{
1093
	struct acpi_thermal *tz;
1094 1095
	int i, j, power_state, result;

1096
	if (!dev)
1097
		return -EINVAL;
1098

1099 1100 1101
	tz = acpi_driver_data(to_acpi_device(dev));
	if (!tz)
		return -EINVAL;
1102

1103
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1104 1105 1106 1107 1108 1109
		if (!(&tz->trips.active[i]))
			break;
		if (!tz->trips.active[i].flags.valid)
			break;
		tz->trips.active[i].flags.enabled = 1;
		for (j = 0; j < tz->trips.active[i].devices.count; j++) {
1110 1111 1112
			result = acpi_bus_update_power(
					tz->trips.active[i].devices.handles[j],
					&power_state);
1113 1114 1115 1116
			if (result || (power_state != ACPI_STATE_D0)) {
				tz->trips.active[i].flags.enabled = 0;
				break;
			}
1117
		}
1118
		tz->state.active |= tz->trips.active[i].flags.enabled;
1119 1120
	}

1121
	acpi_thermal_check(tz);
1122 1123 1124 1125

	return AE_OK;
}

1126
static int thermal_act(const struct dmi_system_id *d) {
1127 1128 1129 1130 1131 1132 1133 1134

	if (act == 0) {
		printk(KERN_NOTICE "ACPI: %s detected: "
			"disabling all active thermal trip points\n", d->ident);
		act = -1;
	}
	return 0;
}
1135
static int thermal_nocrt(const struct dmi_system_id *d) {
1136 1137 1138 1139 1140 1141

	printk(KERN_NOTICE "ACPI: %s detected: "
		"disabling all critical thermal trip point actions.\n", d->ident);
	nocrt = 1;
	return 0;
}
1142
static int thermal_tzp(const struct dmi_system_id *d) {
1143 1144 1145 1146 1147 1148 1149 1150

	if (tzp == 0) {
		printk(KERN_NOTICE "ACPI: %s detected: "
			"enabling thermal zone polling\n", d->ident);
		tzp = 300;	/* 300 dS = 30 Seconds */
	}
	return 0;
}
1151
static int thermal_psv(const struct dmi_system_id *d) {
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189

	if (psv == 0) {
		printk(KERN_NOTICE "ACPI: %s detected: "
			"disabling all passive thermal trip points\n", d->ident);
		psv = -1;
	}
	return 0;
}

static struct dmi_system_id thermal_dmi_table[] __initdata = {
	/*
	 * Award BIOS on this AOpen makes thermal control almost worthless.
	 * http://bugzilla.kernel.org/show_bug.cgi?id=8842
	 */
	{
	 .callback = thermal_act,
	 .ident = "AOpen i915GMm-HFS",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
		DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
		},
	},
	{
	 .callback = thermal_psv,
	 .ident = "AOpen i915GMm-HFS",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
		DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
		},
	},
	{
	 .callback = thermal_tzp,
	 .ident = "AOpen i915GMm-HFS",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "AOpen"),
		DMI_MATCH(DMI_BOARD_NAME, "i915GMm-HFS"),
		},
	},
1190 1191 1192 1193 1194 1195 1196 1197
	{
	 .callback = thermal_nocrt,
	 .ident = "Gigabyte GA-7ZX",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
		DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
		},
	},
1198 1199 1200
	{}
};

L
Len Brown 已提交
1201
static int __init acpi_thermal_init(void)
L
Linus Torvalds 已提交
1202
{
L
Len Brown 已提交
1203
	int result = 0;
L
Linus Torvalds 已提交
1204

1205 1206
	dmi_check_system(thermal_dmi_table);

1207 1208 1209 1210
	if (off) {
		printk(KERN_NOTICE "ACPI: thermal control disabled\n");
		return -ENODEV;
	}
1211

L
Linus Torvalds 已提交
1212
	result = acpi_bus_register_driver(&acpi_thermal_driver);
1213
	if (result < 0)
1214
		return -ENODEV;
L
Linus Torvalds 已提交
1215

1216
	return 0;
L
Linus Torvalds 已提交
1217 1218
}

L
Len Brown 已提交
1219
static void __exit acpi_thermal_exit(void)
L
Linus Torvalds 已提交
1220 1221 1222 1223
{

	acpi_bus_unregister_driver(&acpi_thermal_driver);

1224
	return;
L
Linus Torvalds 已提交
1225 1226 1227 1228
}

module_init(acpi_thermal_init);
module_exit(acpi_thermal_exit);