thermal.c 38.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 38 39
#include <linux/init.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
40
#include <linux/jiffies.h>
L
Linus Torvalds 已提交
41 42
#include <linux/kmod.h>
#include <linux/seq_file.h>
43
#include <linux/reboot.h>
44
#include <linux/device.h>
L
Linus Torvalds 已提交
45
#include <asm/uaccess.h>
46
#include <linux/thermal.h>
L
Linus Torvalds 已提交
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>

#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
68
ACPI_MODULE_NAME("thermal");
L
Linus Torvalds 已提交
69

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

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

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

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

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

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

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

L
Len Brown 已提交
98 99
static int acpi_thermal_add(struct acpi_device *device);
static int acpi_thermal_remove(struct acpi_device *device, int type);
100
static int acpi_thermal_resume(struct acpi_device *device);
L
Linus Torvalds 已提交
101 102 103 104
static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file);
static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file);
static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file);
static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
L
Len Brown 已提交
105 106 107
static ssize_t acpi_thermal_write_cooling_mode(struct file *,
					       const char __user *, size_t,
					       loff_t *);
L
Linus Torvalds 已提交
108
static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
L
Len Brown 已提交
109 110
static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
					  size_t, loff_t *);
L
Linus Torvalds 已提交
111

112 113 114 115 116 117
static const struct acpi_device_id  thermal_device_ids[] = {
	{ACPI_THERMAL_HID, 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, thermal_device_ids);

L
Linus Torvalds 已提交
118
static struct acpi_driver acpi_thermal_driver = {
L
Len Brown 已提交
119
	.name = "thermal",
L
Len Brown 已提交
120
	.class = ACPI_THERMAL_CLASS,
121
	.ids = thermal_device_ids,
L
Len Brown 已提交
122 123 124
	.ops = {
		.add = acpi_thermal_add,
		.remove = acpi_thermal_remove,
125
		.resume = acpi_thermal_resume,
L
Len Brown 已提交
126
		},
L
Linus Torvalds 已提交
127 128 129
};

struct acpi_thermal_state {
L
Len Brown 已提交
130 131 132 133 134 135
	u8 critical:1;
	u8 hot:1;
	u8 passive:1;
	u8 active:1;
	u8 reserved:4;
	int active_index;
L
Linus Torvalds 已提交
136 137 138
};

struct acpi_thermal_state_flags {
L
Len Brown 已提交
139 140 141
	u8 valid:1;
	u8 enabled:1;
	u8 reserved:6;
L
Linus Torvalds 已提交
142 143 144 145
};

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

struct acpi_thermal_hot {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
151
	unsigned long temperature;
L
Linus Torvalds 已提交
152 153 154 155
};

struct acpi_thermal_passive {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
156 157 158 159 160
	unsigned long temperature;
	unsigned long tc1;
	unsigned long tc2;
	unsigned long tsp;
	struct acpi_handle_list devices;
L
Linus Torvalds 已提交
161 162 163 164
};

struct acpi_thermal_active {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
165 166
	unsigned long temperature;
	struct acpi_handle_list devices;
L
Linus Torvalds 已提交
167 168 169 170
};

struct acpi_thermal_trips {
	struct acpi_thermal_critical critical;
L
Len Brown 已提交
171
	struct acpi_thermal_hot hot;
L
Linus Torvalds 已提交
172 173 174 175 176
	struct acpi_thermal_passive passive;
	struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
};

struct acpi_thermal_flags {
L
Len Brown 已提交
177 178 179
	u8 cooling_mode:1;	/* _SCP */
	u8 devices:1;		/* _TZD */
	u8 reserved:6;
L
Linus Torvalds 已提交
180 181 182
};

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

198
static const struct file_operations acpi_thermal_state_fops = {
199
	.owner = THIS_MODULE,
L
Len Brown 已提交
200 201 202 203
	.open = acpi_thermal_state_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
204 205
};

206
static const struct file_operations acpi_thermal_temp_fops = {
207
	.owner = THIS_MODULE,
L
Len Brown 已提交
208 209 210 211
	.open = acpi_thermal_temp_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
212 213
};

214
static const struct file_operations acpi_thermal_trip_fops = {
215
	.owner = THIS_MODULE,
L
Len Brown 已提交
216 217 218 219
	.open = acpi_thermal_trip_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
220 221
};

222
static const struct file_operations acpi_thermal_cooling_fops = {
223
	.owner = THIS_MODULE,
L
Len Brown 已提交
224 225 226 227 228
	.open = acpi_thermal_cooling_open_fs,
	.read = seq_read,
	.write = acpi_thermal_write_cooling_mode,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
229 230
};

231
static const struct file_operations acpi_thermal_polling_fops = {
232
	.owner = THIS_MODULE,
L
Len Brown 已提交
233 234 235 236 237
	.open = acpi_thermal_polling_open_fs,
	.read = seq_read,
	.write = acpi_thermal_write_polling,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
238 239 240 241 242 243
};

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

L
Len Brown 已提交
244
static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
245
{
L
Len Brown 已提交
246
	acpi_status status = AE_OK;
247
	unsigned long long tmp;
L
Linus Torvalds 已提交
248 249

	if (!tz)
250
		return -EINVAL;
L
Linus Torvalds 已提交
251 252 253

	tz->last_temperature = tz->temperature;

254
	status = acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tmp);
L
Linus Torvalds 已提交
255
	if (ACPI_FAILURE(status))
256
		return -ENODEV;
L
Linus Torvalds 已提交
257

258
	tz->temperature = tmp;
L
Len Brown 已提交
259 260
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
			  tz->temperature));
L
Linus Torvalds 已提交
261

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

L
Len Brown 已提交
265
static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
266
{
L
Len Brown 已提交
267
	acpi_status status = AE_OK;
268
	unsigned long long tmp;
L
Linus Torvalds 已提交
269 270

	if (!tz)
271
		return -EINVAL;
L
Linus Torvalds 已提交
272

273
	status = acpi_evaluate_integer(tz->device->handle, "_TZP", NULL, &tmp);
L
Linus Torvalds 已提交
274
	if (ACPI_FAILURE(status))
275
		return -ENODEV;
L
Linus Torvalds 已提交
276

277
	tz->polling_frequency = tmp;
L
Len Brown 已提交
278 279
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
			  tz->polling_frequency));
L
Linus Torvalds 已提交
280

281
	return 0;
L
Linus Torvalds 已提交
282 283
}

L
Len Brown 已提交
284
static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
L
Linus Torvalds 已提交
285 286 287
{

	if (!tz)
288
		return -EINVAL;
L
Linus Torvalds 已提交
289 290 291

	tz->polling_frequency = seconds * 10;	/* Convert value to deci-seconds */

292 293 294 295 296
	tz->thermal_zone->polling_delay = seconds * 1000;

	if (tz->tz_enabled)
		thermal_zone_device_update(tz->thermal_zone);

L
Len Brown 已提交
297 298
	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "Polling frequency set to %lu seconds\n",
299
			  tz->polling_frequency/10));
L
Linus Torvalds 已提交
300

301
	return 0;
L
Linus Torvalds 已提交
302 303
}

L
Len Brown 已提交
304
static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
L
Linus Torvalds 已提交
305
{
L
Len Brown 已提交
306 307 308 309
	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 已提交
310 311 312


	if (!tz)
313
		return -EINVAL;
L
Linus Torvalds 已提交
314

315
	status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
L
Linus Torvalds 已提交
316 317
	if (ACPI_FAILURE(status)) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
318
		return -ENODEV;
L
Linus Torvalds 已提交
319 320 321 322 323 324
	}

	arg0.integer.value = mode;

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

327
	return 0;
L
Linus Torvalds 已提交
328 329
}

330 331 332 333 334
#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 已提交
335

336 337
#define ACPI_TRIPS_REFRESH_THRESHOLDS	(ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE)
#define ACPI_TRIPS_REFRESH_DEVICES	ACPI_TRIPS_DEVICES
L
Linus Torvalds 已提交
338

339 340 341
#define ACPI_TRIPS_INIT      (ACPI_TRIPS_CRITICAL | ACPI_TRIPS_HOT |	\
			      ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE |	\
			      ACPI_TRIPS_DEVICES)
L
Linus Torvalds 已提交
342

343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
/*
 * 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;
361
	unsigned long long tmp;
362 363 364
	struct acpi_handle_list devices;
	int valid = 0;
	int i;
L
Linus Torvalds 已提交
365

366 367 368
	/* Critical Shutdown (required) */
	if (flag & ACPI_TRIPS_CRITICAL) {
		status = acpi_evaluate_integer(tz->device->handle,
369 370
				"_CRT", NULL, &tmp);
		tz->trips.critical.temperature = tmp;
371 372 373
		/*
		 * Treat freezing temperatures as invalid as well; some
		 * BIOSes return really low values and cause reboots at startup.
374
		 * Below zero (Celsius) values clearly aren't right for sure..
375 376 377 378
		 * ... so lets discard those as invalid.
		 */
		if (ACPI_FAILURE(status) ||
				tz->trips.critical.temperature <= 2732) {
379
			tz->trips.critical.flags.valid = 0;
380
			ACPI_EXCEPTION((AE_INFO, status,
381
					"No or invalid critical threshold"));
382 383 384 385 386 387 388 389 390 391 392 393 394
			return -ENODEV;
		} else {
			tz->trips.critical.flags.valid = 1;
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					"Found critical threshold [%lu]\n",
					tz->trips.critical.temperature));
		}
		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);
				/*
395
				 * Allow override critical threshold
396
				 */
397 398 399 400
				if (crt_k > tz->trips.critical.temperature)
					printk(KERN_WARNING PREFIX
						"Critical threshold %d C\n", crt);
				tz->trips.critical.temperature = crt_k;
401
			}
402 403 404
		}
	}

L
Linus Torvalds 已提交
405
	/* Critical Sleep (optional) */
406
	if (flag & ACPI_TRIPS_HOT) {
407
		status = acpi_evaluate_integer(tz->device->handle,
408
				"_HOT", NULL, &tmp);
409 410 411 412 413
		if (ACPI_FAILURE(status)) {
			tz->trips.hot.flags.valid = 0;
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					"No hot threshold\n"));
		} else {
414
			tz->trips.hot.temperature = tmp;
415 416 417 418 419
			tz->trips.hot.flags.valid = 1;
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					"Found hot threshold [%lu]\n",
					tz->trips.critical.temperature));
		}
420 421
	}

422
	/* Passive (optional) */
423 424
	if (((flag & ACPI_TRIPS_PASSIVE) && tz->trips.passive.flags.valid) ||
		(flag == ACPI_TRIPS_INIT)) {
425 426 427 428
		valid = tz->trips.passive.flags.valid;
		if (psv == -1) {
			status = AE_SUPPORT;
		} else if (psv > 0) {
429
			tmp = CELSIUS_TO_KELVIN(psv);
430 431 432
			status = AE_OK;
		} else {
			status = acpi_evaluate_integer(tz->device->handle,
433
				"_PSV", NULL, &tmp);
434
		}
L
Linus Torvalds 已提交
435 436 437

		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;
438
		else {
439
			tz->trips.passive.temperature = tmp;
440 441 442 443
			tz->trips.passive.flags.valid = 1;
			if (flag == ACPI_TRIPS_INIT) {
				status = acpi_evaluate_integer(
						tz->device->handle, "_TC1",
444
						NULL, &tmp);
445 446
				if (ACPI_FAILURE(status))
					tz->trips.passive.flags.valid = 0;
447 448
				else
					tz->trips.passive.tc1 = tmp;
449 450
				status = acpi_evaluate_integer(
						tz->device->handle, "_TC2",
451
						NULL, &tmp);
452 453
				if (ACPI_FAILURE(status))
					tz->trips.passive.flags.valid = 0;
454 455
				else
					tz->trips.passive.tc2 = tmp;
456 457
				status = acpi_evaluate_integer(
						tz->device->handle, "_TSP",
458
						NULL, &tmp);
459 460
				if (ACPI_FAILURE(status))
					tz->trips.passive.flags.valid = 0;
461 462
				else
					tz->trips.passive.tsp = tmp;
463 464 465 466 467 468 469
			}
		}
	}
	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);
470 471 472
		if (ACPI_FAILURE(status)) {
			printk(KERN_WARNING PREFIX
				"Invalid passive threshold\n");
L
Linus Torvalds 已提交
473
			tz->trips.passive.flags.valid = 0;
474
		}
L
Linus Torvalds 已提交
475
		else
476
			tz->trips.passive.flags.valid = 1;
L
Linus Torvalds 已提交
477

478 479 480 481 482 483 484 485 486 487 488
		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 已提交
489

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

495
		if (act == -1)
496 497
			break; /* disable all active trip points */

498 499
		if ((flag == ACPI_TRIPS_INIT) || ((flag & ACPI_TRIPS_ACTIVE) &&
			tz->trips.active[i].flags.valid)) {
500
			status = acpi_evaluate_integer(tz->device->handle,
501
							name, NULL, &tmp);
502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
			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));
521
				break;
522 523
			} else {
				tz->trips.active[i].temperature = tmp;
524
				tz->trips.active[i].flags.valid = 1;
525
			}
526
		}
L
Linus Torvalds 已提交
527 528

		name[2] = 'L';
529 530 531 532
		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);
533 534 535
			if (ACPI_FAILURE(status)) {
				printk(KERN_WARNING PREFIX
					"Invalid active%d threshold\n", i);
536
				tz->trips.active[i].flags.valid = 0;
537
			}
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
			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 已提交
566 567
	}

568
	return 0;
L
Linus Torvalds 已提交
569 570
}

571
static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
572
{
573
	return acpi_thermal_trips_update(tz, ACPI_TRIPS_INIT);
L
Linus Torvalds 已提交
574 575
}

L
Len Brown 已提交
576
static void acpi_thermal_check(void *data)
L
Linus Torvalds 已提交
577
{
578
	struct acpi_thermal *tz = data;
L
Linus Torvalds 已提交
579

580
	thermal_zone_device_update(tz->thermal_zone);
L
Linus Torvalds 已提交
581 582
}

583
/* sys I/F for generic thermal sysfs support */
584 585
#define KELVIN_TO_MILLICELSIUS(t) (t * 100 - 273200)

586 587
static int thermal_get_temp(struct thermal_zone_device *thermal,
			    unsigned long *temp)
588 589
{
	struct acpi_thermal *tz = thermal->devdata;
Z
Zhang, Rui 已提交
590
	int result;
591 592 593 594

	if (!tz)
		return -EINVAL;

Z
Zhang, Rui 已提交
595 596 597 598
	result = acpi_thermal_get_temperature(tz);
	if (result)
		return result;

599 600
	*temp = KELVIN_TO_MILLICELSIUS(tz->temperature);
	return 0;
601 602 603 604 605
}

static const char enabled[] = "kernel";
static const char disabled[] = "user";
static int thermal_get_mode(struct thermal_zone_device *thermal,
606
				enum thermal_device_mode *mode)
607 608 609 610 611 612
{
	struct acpi_thermal *tz = thermal->devdata;

	if (!tz)
		return -EINVAL;

613 614 615 616
	*mode = tz->tz_enabled ? THERMAL_DEVICE_ENABLED :
		THERMAL_DEVICE_DISABLED;

	return 0;
617 618 619
}

static int thermal_set_mode(struct thermal_zone_device *thermal,
620
				enum thermal_device_mode mode)
621 622 623 624 625 626 627 628 629 630
{
	struct acpi_thermal *tz = thermal->devdata;
	int enable;

	if (!tz)
		return -EINVAL;

	/*
	 * enable/disable thermal management from ACPI thermal driver
	 */
631
	if (mode == THERMAL_DEVICE_ENABLED)
632
		enable = 1;
633
	else if (mode == THERMAL_DEVICE_DISABLED)
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
		enable = 0;
	else
		return -EINVAL;

	if (enable != tz->tz_enabled) {
		tz->tz_enabled = enable;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			"%s ACPI thermal control\n",
			tz->tz_enabled ? enabled : disabled));
		acpi_thermal_check(tz);
	}
	return 0;
}

static int thermal_get_trip_type(struct thermal_zone_device *thermal,
649
				 int trip, enum thermal_trip_type *type)
650 651 652 653 654 655 656 657
{
	struct acpi_thermal *tz = thermal->devdata;
	int i;

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

	if (tz->trips.critical.flags.valid) {
658 659 660 661
		if (!trip) {
			*type = THERMAL_TRIP_CRITICAL;
			return 0;
		}
662 663 664 665
		trip--;
	}

	if (tz->trips.hot.flags.valid) {
666 667 668 669
		if (!trip) {
			*type = THERMAL_TRIP_HOT;
			return 0;
		}
670 671 672 673
		trip--;
	}

	if (tz->trips.passive.flags.valid) {
674 675 676 677
		if (!trip) {
			*type = THERMAL_TRIP_PASSIVE;
			return 0;
		}
678 679 680 681 682
		trip--;
	}

	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
		tz->trips.active[i].flags.valid; i++) {
683 684 685 686
		if (!trip) {
			*type = THERMAL_TRIP_ACTIVE;
			return 0;
		}
687 688 689 690 691 692 693
		trip--;
	}

	return -EINVAL;
}

static int thermal_get_trip_temp(struct thermal_zone_device *thermal,
694
				 int trip, unsigned long *temp)
695 696 697 698 699 700 701 702
{
	struct acpi_thermal *tz = thermal->devdata;
	int i;

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

	if (tz->trips.critical.flags.valid) {
703 704 705 706 707
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
				tz->trips.critical.temperature);
			return 0;
		}
708 709 710 711
		trip--;
	}

	if (tz->trips.hot.flags.valid) {
712 713 714 715 716
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
				tz->trips.hot.temperature);
			return 0;
		}
717 718 719 720
		trip--;
	}

	if (tz->trips.passive.flags.valid) {
721 722 723 724 725
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
				tz->trips.passive.temperature);
			return 0;
		}
726 727 728 729 730
		trip--;
	}

	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
		tz->trips.active[i].flags.valid; i++) {
731 732 733 734 735
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
				tz->trips.active[i].temperature);
			return 0;
		}
736 737 738 739 740 741
		trip--;
	}

	return -EINVAL;
}

742 743 744 745 746 747 748 749 750 751 752 753
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(
				tz->trips.critical.temperature);
		return 0;
	} else
		return -EINVAL;
}

754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
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,
769
					dev_name(&tz->device->dev), type, 1);
770 771 772 773 774 775 776

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

	return 0;
}

777 778 779 780 781 782 783 784
typedef int (*cb)(struct thermal_zone_device *, int,
		  struct thermal_cooling_device *);
static int acpi_thermal_cooling_device_cb(struct thermal_zone_device *thermal,
					struct thermal_cooling_device *cdev,
					cb action)
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_thermal *tz = thermal->devdata;
Z
Zhang Rui 已提交
785 786 787
	struct acpi_device *dev;
	acpi_status status;
	acpi_handle handle;
788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
	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 已提交
803 804 805 806 807 808 809
			handle = tz->trips.passive.devices.handles[i];
			status = acpi_bus_get_device(handle, &dev);
			if (ACPI_SUCCESS(status) && (dev == device)) {
				result = action(thermal, trip, cdev);
				if (result)
					goto failed;
			}
810 811 812 813 814 815 816 817 818 819
		}
	}

	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 已提交
820 821 822 823 824 825 826
			handle = tz->trips.active[i].devices.handles[j];
			status = acpi_bus_get_device(handle, &dev);
			if (ACPI_SUCCESS(status) && (dev == device)) {
				result = action(thermal, trip, cdev);
				if (result)
					goto failed;
			}
827 828 829 830
		}
	}

	for (i = 0; i < tz->devices.count; i++) {
Z
Zhang Rui 已提交
831 832 833 834 835 836 837
		handle = tz->devices.handles[i];
		status = acpi_bus_get_device(handle, &dev);
		if (ACPI_SUCCESS(status) && (dev == device)) {
			result = action(thermal, -1, cdev);
			if (result)
				goto failed;
		}
838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
	}

failed:
	return result;
}

static int
acpi_thermal_bind_cooling_device(struct thermal_zone_device *thermal,
					struct thermal_cooling_device *cdev)
{
	return acpi_thermal_cooling_device_cb(thermal, cdev,
				thermal_zone_bind_cooling_device);
}

static int
acpi_thermal_unbind_cooling_device(struct thermal_zone_device *thermal,
					struct thermal_cooling_device *cdev)
{
	return acpi_thermal_cooling_device_cb(thermal, cdev,
				thermal_zone_unbind_cooling_device);
}

static struct thermal_zone_device_ops acpi_thermal_zone_ops = {
	.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,
868
	.get_crit_temp = thermal_get_crit_temp,
869
	.notify = thermal_notify,
870 871 872 873 874 875
};

static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
{
	int trips = 0;
	int result;
Z
Zhang Rui 已提交
876
	acpi_status status;
877 878 879 880 881 882 883 884 885 886 887 888 889
	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++);
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904

	if (tz->trips.passive.flags.valid)
		tz->thermal_zone =
			thermal_zone_device_register("acpitz", trips, tz,
						     &acpi_thermal_zone_ops,
						     tz->trips.passive.tc1,
						     tz->trips.passive.tc2,
						     tz->trips.passive.tsp*100,
						     tz->polling_frequency*100);
	else
		tz->thermal_zone =
			thermal_zone_device_register("acpitz", trips, tz,
						     &acpi_thermal_zone_ops,
						     0, 0, 0,
						     tz->polling_frequency);
K
Krzysztof Helt 已提交
905
	if (IS_ERR(tz->thermal_zone))
906 907 908 909 910 911 912 913 914 915 916 917
		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 已提交
918 919 920 921
	status = acpi_attach_data(tz->device->handle,
				  acpi_bus_private_data_handler,
				  tz->thermal_zone);
	if (ACPI_FAILURE(status)) {
922 923
		printk(KERN_ERR PREFIX
				"Error attaching device data\n");
Z
Zhang Rui 已提交
924 925 926
		return -ENODEV;
	}

927 928
	tz->tz_enabled = 1;

929 930
	dev_info(&tz->device->dev, "registered as thermal_zone%d\n",
		 tz->thermal_zone->id);
931 932 933 934 935 936 937 938 939
	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 已提交
940
	acpi_detach_data(tz->device->handle, acpi_bus_private_data_handler);
941 942 943
}


L
Linus Torvalds 已提交
944 945 946 947
/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
948
static struct proc_dir_entry *acpi_thermal_dir;
L
Linus Torvalds 已提交
949 950 951

static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
{
952
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
953 954 955 956 957 958 959


	if (!tz)
		goto end;

	seq_puts(seq, "state:                   ");

L
Len Brown 已提交
960 961
	if (!tz->state.critical && !tz->state.hot && !tz->state.passive
	    && !tz->state.active)
L
Linus Torvalds 已提交
962 963 964 965 966 967 968 969 970 971 972 973 974
		seq_puts(seq, "ok\n");
	else {
		if (tz->state.critical)
			seq_puts(seq, "critical ");
		if (tz->state.hot)
			seq_puts(seq, "hot ");
		if (tz->state.passive)
			seq_puts(seq, "passive ");
		if (tz->state.active)
			seq_printf(seq, "active[%d]", tz->state.active_index);
		seq_puts(seq, "\n");
	}

L
Len Brown 已提交
975
      end:
976
	return 0;
L
Linus Torvalds 已提交
977 978 979 980 981 982 983 984 985
}

static int acpi_thermal_state_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_thermal_state_seq_show, PDE(inode)->data);
}

static int acpi_thermal_temp_seq_show(struct seq_file *seq, void *offset)
{
L
Len Brown 已提交
986
	int result = 0;
987
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
988 989 990 991 992 993 994 995 996


	if (!tz)
		goto end;

	result = acpi_thermal_get_temperature(tz);
	if (result)
		goto end;

L
Len Brown 已提交
997 998
	seq_printf(seq, "temperature:             %ld C\n",
		   KELVIN_TO_CELSIUS(tz->temperature));
L
Linus Torvalds 已提交
999

L
Len Brown 已提交
1000
      end:
1001
	return 0;
L
Linus Torvalds 已提交
1002 1003 1004 1005 1006 1007 1008 1009 1010
}

static int acpi_thermal_temp_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_thermal_temp_seq_show, PDE(inode)->data);
}

static int acpi_thermal_trip_seq_show(struct seq_file *seq, void *offset)
{
1011
	struct acpi_thermal *tz = seq->private;
1012
	struct acpi_device *device;
1013 1014
	acpi_status status;

L
Len Brown 已提交
1015 1016
	int i = 0;
	int j = 0;
L
Linus Torvalds 已提交
1017 1018 1019 1020 1021 1022


	if (!tz)
		goto end;

	if (tz->trips.critical.flags.valid)
1023 1024 1025
		seq_printf(seq, "critical (S5):           %ld C%s",
			   KELVIN_TO_CELSIUS(tz->trips.critical.temperature),
			   nocrt ? " <disabled>\n" : "\n");
L
Linus Torvalds 已提交
1026 1027

	if (tz->trips.hot.flags.valid)
1028 1029 1030
		seq_printf(seq, "hot (S4):                %ld C%s",
			   KELVIN_TO_CELSIUS(tz->trips.hot.temperature),
			   nocrt ? " <disabled>\n" : "\n");
L
Linus Torvalds 已提交
1031 1032

	if (tz->trips.passive.flags.valid) {
L
Len Brown 已提交
1033 1034 1035 1036 1037 1038
		seq_printf(seq,
			   "passive:                 %ld C: tc1=%lu tc2=%lu tsp=%lu devices=",
			   KELVIN_TO_CELSIUS(tz->trips.passive.temperature),
			   tz->trips.passive.tc1, tz->trips.passive.tc2,
			   tz->trips.passive.tsp);
		for (j = 0; j < tz->trips.passive.devices.count; j++) {
1039 1040 1041 1042
			status = acpi_bus_get_device(tz->trips.passive.devices.
						     handles[j], &device);
			seq_printf(seq, "%4.4s ", status ? "" :
				   acpi_device_bid(device));
L
Linus Torvalds 已提交
1043 1044 1045 1046 1047 1048 1049 1050
		}
		seq_puts(seq, "\n");
	}

	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
		if (!(tz->trips.active[i].flags.valid))
			break;
		seq_printf(seq, "active[%d]:               %ld C: devices=",
L
Len Brown 已提交
1051 1052
			   i,
			   KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
1053
		for (j = 0; j < tz->trips.active[i].devices.count; j++){
1054 1055 1056 1057 1058
			status = acpi_bus_get_device(tz->trips.active[i].
						     devices.handles[j],
						     &device);
			seq_printf(seq, "%4.4s ", status ? "" :
				   acpi_device_bid(device));
1059
		}
L
Linus Torvalds 已提交
1060 1061 1062
		seq_puts(seq, "\n");
	}

L
Len Brown 已提交
1063
      end:
1064
	return 0;
L
Linus Torvalds 已提交
1065 1066 1067 1068 1069 1070 1071 1072 1073
}

static int acpi_thermal_trip_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_thermal_trip_seq_show, PDE(inode)->data);
}

static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
{
1074
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
1075 1076 1077 1078 1079


	if (!tz)
		goto end;

1080
	if (!tz->flags.cooling_mode)
L
Linus Torvalds 已提交
1081 1082
		seq_puts(seq, "<setting not supported>\n");
	else
1083
		seq_puts(seq, "0 - Active; 1 - Passive\n");
L
Linus Torvalds 已提交
1084

L
Len Brown 已提交
1085
      end:
1086
	return 0;
L
Linus Torvalds 已提交
1087 1088 1089 1090 1091
}

static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_thermal_cooling_seq_show,
L
Len Brown 已提交
1092
			   PDE(inode)->data);
L
Linus Torvalds 已提交
1093 1094 1095
}

static ssize_t
L
Len Brown 已提交
1096 1097 1098
acpi_thermal_write_cooling_mode(struct file *file,
				const char __user * buffer,
				size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
1099
{
1100 1101
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Len Brown 已提交
1102 1103
	int result = 0;
	char mode_string[12] = { '\0' };
L
Linus Torvalds 已提交
1104 1105 1106


	if (!tz || (count > sizeof(mode_string) - 1))
1107
		return -EINVAL;
L
Linus Torvalds 已提交
1108 1109

	if (!tz->flags.cooling_mode)
1110
		return -ENODEV;
L
Linus Torvalds 已提交
1111 1112

	if (copy_from_user(mode_string, buffer, count))
1113
		return -EFAULT;
L
Len Brown 已提交
1114

L
Linus Torvalds 已提交
1115
	mode_string[count] = '\0';
L
Len Brown 已提交
1116 1117 1118 1119

	result = acpi_thermal_set_cooling_mode(tz,
					       simple_strtoul(mode_string, NULL,
							      0));
L
Linus Torvalds 已提交
1120
	if (result)
1121
		return result;
L
Linus Torvalds 已提交
1122 1123 1124

	acpi_thermal_check(tz);

1125
	return count;
L
Linus Torvalds 已提交
1126 1127 1128 1129
}

static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
{
1130
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
1131 1132 1133 1134 1135


	if (!tz)
		goto end;

1136
	if (!tz->thermal_zone->polling_delay) {
L
Linus Torvalds 已提交
1137 1138 1139 1140
		seq_puts(seq, "<polling disabled>\n");
		goto end;
	}

1141 1142
	seq_printf(seq, "polling frequency:       %d seconds\n",
		   (tz->thermal_zone->polling_delay / 1000));
L
Linus Torvalds 已提交
1143

L
Len Brown 已提交
1144
      end:
1145
	return 0;
L
Linus Torvalds 已提交
1146 1147 1148 1149 1150
}

static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_thermal_polling_seq_show,
L
Len Brown 已提交
1151
			   PDE(inode)->data);
L
Linus Torvalds 已提交
1152 1153 1154
}

static ssize_t
L
Len Brown 已提交
1155 1156 1157
acpi_thermal_write_polling(struct file *file,
			   const char __user * buffer,
			   size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
1158
{
1159 1160
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Len Brown 已提交
1161 1162 1163
	int result = 0;
	char polling_string[12] = { '\0' };
	int seconds = 0;
L
Linus Torvalds 已提交
1164 1165 1166


	if (!tz || (count > sizeof(polling_string) - 1))
1167
		return -EINVAL;
L
Len Brown 已提交
1168

L
Linus Torvalds 已提交
1169
	if (copy_from_user(polling_string, buffer, count))
1170
		return -EFAULT;
L
Len Brown 已提交
1171

L
Linus Torvalds 已提交
1172 1173 1174
	polling_string[count] = '\0';

	seconds = simple_strtoul(polling_string, NULL, 0);
L
Len Brown 已提交
1175

L
Linus Torvalds 已提交
1176 1177
	result = acpi_thermal_set_polling(tz, seconds);
	if (result)
1178
		return result;
L
Linus Torvalds 已提交
1179 1180 1181

	acpi_thermal_check(tz);

1182
	return count;
L
Linus Torvalds 已提交
1183 1184
}

L
Len Brown 已提交
1185
static int acpi_thermal_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1186
{
L
Len Brown 已提交
1187
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
1188 1189 1190 1191


	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
1192
						     acpi_thermal_dir);
L
Linus Torvalds 已提交
1193
		if (!acpi_device_dir(device))
1194
			return -ENODEV;
L
Linus Torvalds 已提交
1195 1196 1197
	}

	/* 'state' [R] */
1198 1199 1200 1201
	entry = proc_create_data(ACPI_THERMAL_FILE_STATE,
				 S_IRUGO, acpi_device_dir(device),
				 &acpi_thermal_state_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1202
	if (!entry)
1203
		return -ENODEV;
L
Linus Torvalds 已提交
1204 1205

	/* 'temperature' [R] */
1206 1207 1208 1209
	entry = proc_create_data(ACPI_THERMAL_FILE_TEMPERATURE,
				 S_IRUGO, acpi_device_dir(device),
				 &acpi_thermal_temp_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1210
	if (!entry)
1211
		return -ENODEV;
L
Linus Torvalds 已提交
1212

1213
	/* 'trip_points' [R] */
1214 1215 1216 1217 1218
	entry = proc_create_data(ACPI_THERMAL_FILE_TRIP_POINTS,
				 S_IRUGO,
				 acpi_device_dir(device),
				 &acpi_thermal_trip_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1219
	if (!entry)
1220
		return -ENODEV;
L
Linus Torvalds 已提交
1221 1222

	/* 'cooling_mode' [R/W] */
1223 1224 1225 1226 1227
	entry = proc_create_data(ACPI_THERMAL_FILE_COOLING_MODE,
				 S_IFREG | S_IRUGO | S_IWUSR,
				 acpi_device_dir(device),
				 &acpi_thermal_cooling_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1228
	if (!entry)
1229
		return -ENODEV;
L
Linus Torvalds 已提交
1230 1231

	/* 'polling_frequency' [R/W] */
1232 1233 1234 1235 1236
	entry = proc_create_data(ACPI_THERMAL_FILE_POLLING_FREQ,
				 S_IFREG | S_IRUGO | S_IWUSR,
				 acpi_device_dir(device),
				 &acpi_thermal_polling_fops,
				 acpi_driver_data(device));
L
Linus Torvalds 已提交
1237
	if (!entry)
1238 1239
		return -ENODEV;
	return 0;
L
Linus Torvalds 已提交
1240 1241
}

L
Len Brown 已提交
1242
static int acpi_thermal_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
{

	if (acpi_device_dir(device)) {
		remove_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
				  acpi_device_dir(device));
		remove_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
				  acpi_device_dir(device));
		remove_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
				  acpi_device_dir(device));
		remove_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
				  acpi_device_dir(device));
		remove_proc_entry(ACPI_THERMAL_FILE_STATE,
				  acpi_device_dir(device));
		remove_proc_entry(acpi_device_bid(device), acpi_thermal_dir);
		acpi_device_dir(device) = NULL;
	}

1260
	return 0;
L
Linus Torvalds 已提交
1261 1262 1263 1264 1265 1266
}

/* --------------------------------------------------------------------------
                                 Driver Interface
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
1267
static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
1268
{
1269
	struct acpi_thermal *tz = data;
L
Len Brown 已提交
1270
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
1271 1272 1273


	if (!tz)
1274
		return;
L
Linus Torvalds 已提交
1275

1276
	device = tz->device;
L
Linus Torvalds 已提交
1277 1278 1279 1280 1281 1282

	switch (event) {
	case ACPI_THERMAL_NOTIFY_TEMPERATURE:
		acpi_thermal_check(tz);
		break;
	case ACPI_THERMAL_NOTIFY_THRESHOLDS:
1283
		acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_THRESHOLDS);
L
Linus Torvalds 已提交
1284
		acpi_thermal_check(tz);
1285
		acpi_bus_generate_proc_event(device, event, 0);
1286
		acpi_bus_generate_netlink_event(device->pnp.device_class,
1287
						  dev_name(&device->dev), event, 0);
L
Linus Torvalds 已提交
1288 1289
		break;
	case ACPI_THERMAL_NOTIFY_DEVICES:
1290 1291
		acpi_thermal_trips_update(tz, ACPI_TRIPS_REFRESH_DEVICES);
		acpi_thermal_check(tz);
1292
		acpi_bus_generate_proc_event(device, event, 0);
1293
		acpi_bus_generate_netlink_event(device->pnp.device_class,
1294
						  dev_name(&device->dev), event, 0);
L
Linus Torvalds 已提交
1295 1296 1297
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
1298
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
1299 1300 1301
		break;
	}

1302
	return;
L
Linus Torvalds 已提交
1303 1304
}

L
Len Brown 已提交
1305
static int acpi_thermal_get_info(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
1306
{
L
Len Brown 已提交
1307
	int result = 0;
L
Linus Torvalds 已提交
1308 1309 1310


	if (!tz)
1311
		return -EINVAL;
L
Linus Torvalds 已提交
1312 1313 1314 1315

	/* Get temperature [_TMP] (required) */
	result = acpi_thermal_get_temperature(tz);
	if (result)
1316
		return result;
L
Linus Torvalds 已提交
1317 1318 1319 1320

	/* Get trip points [_CRT, _PSV, etc.] (required) */
	result = acpi_thermal_get_trip_points(tz);
	if (result)
1321
		return result;
L
Linus Torvalds 已提交
1322 1323 1324

	/* Set the cooling mode [_SCP] to active cooling (default) */
	result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
L
Len Brown 已提交
1325
	if (!result)
L
Linus Torvalds 已提交
1326 1327 1328 1329 1330 1331 1332 1333
		tz->flags.cooling_mode = 1;

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

1334
	return 0;
L
Linus Torvalds 已提交
1335 1336
}

L
Len Brown 已提交
1337
static int acpi_thermal_add(struct acpi_device *device)
L
Linus Torvalds 已提交
1338
{
L
Len Brown 已提交
1339 1340 1341
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1342 1343 1344


	if (!device)
1345
		return -EINVAL;
L
Linus Torvalds 已提交
1346

1347
	tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
L
Linus Torvalds 已提交
1348
	if (!tz)
1349
		return -ENOMEM;
L
Linus Torvalds 已提交
1350

1351
	tz->device = device;
L
Linus Torvalds 已提交
1352 1353 1354
	strcpy(tz->name, device->pnp.bus_id);
	strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
1355
	device->driver_data = tz;
1356
	mutex_init(&tz->lock);
1357 1358


L
Linus Torvalds 已提交
1359 1360
	result = acpi_thermal_get_info(tz);
	if (result)
1361 1362 1363 1364 1365
		goto free_memory;

	result = acpi_thermal_register_thermal_zone(tz);
	if (result)
		goto free_memory;
L
Linus Torvalds 已提交
1366 1367 1368

	result = acpi_thermal_add_fs(device);
	if (result)
1369
		goto unregister_thermal_zone;
L
Linus Torvalds 已提交
1370

1371
	status = acpi_install_notify_handler(device->handle,
L
Len Brown 已提交
1372 1373
					     ACPI_DEVICE_NOTIFY,
					     acpi_thermal_notify, tz);
L
Linus Torvalds 已提交
1374 1375
	if (ACPI_FAILURE(status)) {
		result = -ENODEV;
1376
		goto remove_fs;
L
Linus Torvalds 已提交
1377 1378 1379
	}

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

1384 1385 1386 1387 1388 1389 1390
remove_fs:
	acpi_thermal_remove_fs(device);
unregister_thermal_zone:
	thermal_zone_device_unregister(tz->thermal_zone);
free_memory:
	kfree(tz);
end:
1391
	return result;
L
Linus Torvalds 已提交
1392 1393
}

L
Len Brown 已提交
1394
static int acpi_thermal_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
1395
{
L
Len Brown 已提交
1396 1397
	acpi_status status = AE_OK;
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1398 1399

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

1402
	tz = acpi_driver_data(device);
L
Linus Torvalds 已提交
1403

1404
	status = acpi_remove_notify_handler(device->handle,
L
Len Brown 已提交
1405 1406
					    ACPI_DEVICE_NOTIFY,
					    acpi_thermal_notify);
L
Linus Torvalds 已提交
1407 1408

	acpi_thermal_remove_fs(device);
1409
	acpi_thermal_unregister_thermal_zone(tz);
1410
	mutex_destroy(&tz->lock);
L
Linus Torvalds 已提交
1411
	kfree(tz);
1412
	return 0;
L
Linus Torvalds 已提交
1413 1414
}

1415
static int acpi_thermal_resume(struct acpi_device *device)
1416 1417
{
	struct acpi_thermal *tz = NULL;
1418 1419
	int i, j, power_state, result;

1420 1421

	if (!device || !acpi_driver_data(device))
1422
		return -EINVAL;
1423

1424
	tz = acpi_driver_data(device);
1425

1426
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438
		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++) {
			result = acpi_bus_get_power(tz->trips.active[i].devices.
			    handles[j], &power_state);
			if (result || (power_state != ACPI_STATE_D0)) {
				tz->trips.active[i].flags.enabled = 0;
				break;
			}
1439
		}
1440
		tz->state.active |= tz->trips.active[i].flags.enabled;
1441 1442
	}

1443
	acpi_thermal_check(tz);
1444 1445 1446 1447

	return AE_OK;
}

1448
static int thermal_act(const struct dmi_system_id *d) {
1449 1450 1451 1452 1453 1454 1455 1456

	if (act == 0) {
		printk(KERN_NOTICE "ACPI: %s detected: "
			"disabling all active thermal trip points\n", d->ident);
		act = -1;
	}
	return 0;
}
1457
static int thermal_nocrt(const struct dmi_system_id *d) {
1458 1459 1460 1461 1462 1463

	printk(KERN_NOTICE "ACPI: %s detected: "
		"disabling all critical thermal trip point actions.\n", d->ident);
	nocrt = 1;
	return 0;
}
1464
static int thermal_tzp(const struct dmi_system_id *d) {
1465 1466 1467 1468 1469 1470 1471 1472

	if (tzp == 0) {
		printk(KERN_NOTICE "ACPI: %s detected: "
			"enabling thermal zone polling\n", d->ident);
		tzp = 300;	/* 300 dS = 30 Seconds */
	}
	return 0;
}
1473
static int thermal_psv(const struct dmi_system_id *d) {
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511

	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"),
		},
	},
1512 1513 1514 1515 1516 1517 1518 1519
	{
	 .callback = thermal_nocrt,
	 .ident = "Gigabyte GA-7ZX",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
		DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
		},
	},
1520 1521 1522
	{}
};

L
Len Brown 已提交
1523
static int __init acpi_thermal_init(void)
L
Linus Torvalds 已提交
1524
{
L
Len Brown 已提交
1525
	int result = 0;
L
Linus Torvalds 已提交
1526

1527 1528
	dmi_check_system(thermal_dmi_table);

1529 1530 1531 1532
	if (off) {
		printk(KERN_NOTICE "ACPI: thermal control disabled\n");
		return -ENODEV;
	}
L
Linus Torvalds 已提交
1533 1534
	acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
	if (!acpi_thermal_dir)
1535
		return -ENODEV;
L
Linus Torvalds 已提交
1536 1537 1538 1539

	result = acpi_bus_register_driver(&acpi_thermal_driver);
	if (result < 0) {
		remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);
1540
		return -ENODEV;
L
Linus Torvalds 已提交
1541 1542
	}

1543
	return 0;
L
Linus Torvalds 已提交
1544 1545
}

L
Len Brown 已提交
1546
static void __exit acpi_thermal_exit(void)
L
Linus Torvalds 已提交
1547 1548 1549 1550 1551 1552
{

	acpi_bus_unregister_driver(&acpi_thermal_driver);

	remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);

1553
	return;
L
Linus Torvalds 已提交
1554 1555 1556 1557
}

module_init(acpi_thermal_init);
module_exit(acpi_thermal_exit);