thermal.c 39.0 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);
101
static void acpi_thermal_notify(struct acpi_device *device, u32 event);
L
Linus Torvalds 已提交
102 103 104 105
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 已提交
106 107 108
static ssize_t acpi_thermal_write_cooling_mode(struct file *,
					       const char __user *, size_t,
					       loff_t *);
L
Linus Torvalds 已提交
109
static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
L
Len Brown 已提交
110 111
static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
					  size_t, loff_t *);
L
Linus Torvalds 已提交
112

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	if (!tz)
253
		return -EINVAL;
L
Linus Torvalds 已提交
254 255 256

	tz->last_temperature = tz->temperature;

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

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

265
	return 0;
L
Linus Torvalds 已提交
266 267
}

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

	if (!tz)
274
		return -EINVAL;
L
Linus Torvalds 已提交
275

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

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

284
	return 0;
L
Linus Torvalds 已提交
285 286
}

L
Len Brown 已提交
287
static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
L
Linus Torvalds 已提交
288 289 290
{

	if (!tz)
291
		return -EINVAL;
L
Linus Torvalds 已提交
292 293 294

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

295 296 297 298 299
	tz->thermal_zone->polling_delay = seconds * 1000;

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

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

304
	return 0;
L
Linus Torvalds 已提交
305 306
}

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


	if (!tz)
316
		return -EINVAL;
L
Linus Torvalds 已提交
317

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

	arg0.integer.value = mode;

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

330
	return 0;
L
Linus Torvalds 已提交
331 332
}

333 334 335 336 337
#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 已提交
338

339 340
#define ACPI_TRIPS_REFRESH_THRESHOLDS	(ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE)
#define ACPI_TRIPS_REFRESH_DEVICES	ACPI_TRIPS_DEVICES
L
Linus Torvalds 已提交
341

342 343 344
#define ACPI_TRIPS_INIT      (ACPI_TRIPS_CRITICAL | ACPI_TRIPS_HOT |	\
			      ACPI_TRIPS_PASSIVE | ACPI_TRIPS_ACTIVE |	\
			      ACPI_TRIPS_DEVICES)
L
Linus Torvalds 已提交
345

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

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

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

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

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

481 482 483 484 485 486 487 488 489 490 491
		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 已提交
492

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

498
		if (act == -1)
499 500
			break; /* disable all active trip points */

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

		name[2] = 'L';
532 533 534 535
		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);
536 537 538
			if (ACPI_FAILURE(status)) {
				printk(KERN_WARNING PREFIX
					"Invalid active%d threshold\n", i);
539
				tz->trips.active[i].flags.valid = 0;
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 566 567 568
			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 已提交
569 570
	}

571
	return 0;
L
Linus Torvalds 已提交
572 573
}

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

L
Len Brown 已提交
579
static void acpi_thermal_check(void *data)
L
Linus Torvalds 已提交
580
{
581
	struct acpi_thermal *tz = data;
L
Linus Torvalds 已提交
582

583
	thermal_zone_device_update(tz->thermal_zone);
L
Linus Torvalds 已提交
584 585
}

586
/* sys I/F for generic thermal sysfs support */
587
#define KELVIN_TO_MILLICELSIUS(t, off) (((t) - (off)) * 100)
588

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

	if (!tz)
		return -EINVAL;

Z
Zhang, Rui 已提交
598 599 600 601
	result = acpi_thermal_get_temperature(tz);
	if (result)
		return result;

602
	*temp = KELVIN_TO_MILLICELSIUS(tz->temperature, tz->kelvin_offset);
603
	return 0;
604 605 606 607 608
}

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

	if (!tz)
		return -EINVAL;

616 617 618 619
	*mode = tz->tz_enabled ? THERMAL_DEVICE_ENABLED :
		THERMAL_DEVICE_DISABLED;

	return 0;
620 621 622
}

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

	if (!tz)
		return -EINVAL;

	/*
	 * enable/disable thermal management from ACPI thermal driver
	 */
634
	if (mode == THERMAL_DEVICE_ENABLED)
635
		enable = 1;
636
	else if (mode == THERMAL_DEVICE_DISABLED)
637 638 639 640 641 642 643 644 645 646 647 648 649 650 651
		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,
652
				 int trip, enum thermal_trip_type *type)
653 654 655 656 657 658 659 660
{
	struct acpi_thermal *tz = thermal->devdata;
	int i;

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

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

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

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

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

	return -EINVAL;
}

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

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

	if (tz->trips.critical.flags.valid) {
706 707
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
708 709
				tz->trips.critical.temperature,
				tz->kelvin_offset);
710 711
			return 0;
		}
712 713 714 715
		trip--;
	}

	if (tz->trips.hot.flags.valid) {
716 717
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
718 719
				tz->trips.hot.temperature,
				tz->kelvin_offset);
720 721
			return 0;
		}
722 723 724 725
		trip--;
	}

	if (tz->trips.passive.flags.valid) {
726 727
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
728 729
				tz->trips.passive.temperature,
				tz->kelvin_offset);
730 731
			return 0;
		}
732 733 734 735 736
		trip--;
	}

	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE &&
		tz->trips.active[i].flags.valid; i++) {
737 738
		if (!trip) {
			*temp = KELVIN_TO_MILLICELSIUS(
739 740
				tz->trips.active[i].temperature,
				tz->kelvin_offset);
741 742
			return 0;
		}
743 744 745 746 747 748
		trip--;
	}

	return -EINVAL;
}

749 750 751 752 753 754
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(
755 756
				tz->trips.critical.temperature,
				tz->kelvin_offset);
757 758 759 760 761
		return 0;
	} else
		return -EINVAL;
}

762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
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,
777
					dev_name(&tz->device->dev), type, 1);
778 779 780 781 782 783 784

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

	return 0;
}

785 786 787 788 789 790 791 792
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 已提交
793 794 795
	struct acpi_device *dev;
	acpi_status status;
	acpi_handle handle;
796 797 798 799 800 801 802 803 804 805 806 807 808 809 810
	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 已提交
811 812 813 814 815 816 817
			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;
			}
818 819 820 821 822 823 824 825 826 827
		}
	}

	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 已提交
828 829 830 831 832 833 834
			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;
			}
835 836 837 838
		}
	}

	for (i = 0; i < tz->devices.count; i++) {
Z
Zhang Rui 已提交
839 840 841 842 843 844 845
		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;
		}
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
	}

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,
876
	.get_crit_temp = thermal_get_crit_temp,
877
	.notify = thermal_notify,
878 879 880 881 882 883
};

static int acpi_thermal_register_thermal_zone(struct acpi_thermal *tz)
{
	int trips = 0;
	int result;
Z
Zhang Rui 已提交
884
	acpi_status status;
885 886 887 888 889 890 891 892 893 894 895 896 897
	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++);
898 899 900 901 902 903 904 905 906 907 908 909 910 911

	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,
912
						     tz->polling_frequency*100);
K
Krzysztof Helt 已提交
913
	if (IS_ERR(tz->thermal_zone))
914 915 916 917 918 919 920 921 922 923 924 925
		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 已提交
926 927 928 929
	status = acpi_attach_data(tz->device->handle,
				  acpi_bus_private_data_handler,
				  tz->thermal_zone);
	if (ACPI_FAILURE(status)) {
930 931
		printk(KERN_ERR PREFIX
				"Error attaching device data\n");
Z
Zhang Rui 已提交
932 933 934
		return -ENODEV;
	}

935 936
	tz->tz_enabled = 1;

937 938
	dev_info(&tz->device->dev, "registered as thermal_zone%d\n",
		 tz->thermal_zone->id);
939 940 941 942 943 944 945 946 947
	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 已提交
948
	acpi_detach_data(tz->device->handle, acpi_bus_private_data_handler);
949 950 951
}


L
Linus Torvalds 已提交
952 953 954 955
/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
956
static struct proc_dir_entry *acpi_thermal_dir;
L
Linus Torvalds 已提交
957 958 959

static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
{
960
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
961 962 963 964 965 966 967


	if (!tz)
		goto end;

	seq_puts(seq, "state:                   ");

L
Len Brown 已提交
968 969
	if (!tz->state.critical && !tz->state.hot && !tz->state.passive
	    && !tz->state.active)
L
Linus Torvalds 已提交
970 971 972 973 974 975 976 977 978 979 980 981 982
		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 已提交
983
      end:
984
	return 0;
L
Linus Torvalds 已提交
985 986 987 988 989 990 991 992 993
}

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 已提交
994
	int result = 0;
995
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
996 997 998 999 1000 1001 1002 1003 1004


	if (!tz)
		goto end;

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

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

L
Len Brown 已提交
1008
      end:
1009
	return 0;
L
Linus Torvalds 已提交
1010 1011 1012 1013 1014 1015 1016 1017 1018
}

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)
{
1019
	struct acpi_thermal *tz = seq->private;
1020
	struct acpi_device *device;
1021 1022
	acpi_status status;

L
Len Brown 已提交
1023 1024
	int i = 0;
	int j = 0;
L
Linus Torvalds 已提交
1025 1026 1027 1028 1029 1030


	if (!tz)
		goto end;

	if (tz->trips.critical.flags.valid)
1031 1032 1033
		seq_printf(seq, "critical (S5):           %ld C%s",
			   KELVIN_TO_CELSIUS(tz->trips.critical.temperature),
			   nocrt ? " <disabled>\n" : "\n");
L
Linus Torvalds 已提交
1034 1035

	if (tz->trips.hot.flags.valid)
1036 1037 1038
		seq_printf(seq, "hot (S4):                %ld C%s",
			   KELVIN_TO_CELSIUS(tz->trips.hot.temperature),
			   nocrt ? " <disabled>\n" : "\n");
L
Linus Torvalds 已提交
1039 1040

	if (tz->trips.passive.flags.valid) {
L
Len Brown 已提交
1041 1042 1043 1044 1045 1046
		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++) {
1047 1048 1049 1050
			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 已提交
1051 1052 1053 1054 1055 1056 1057 1058
		}
		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 已提交
1059 1060
			   i,
			   KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
1061
		for (j = 0; j < tz->trips.active[i].devices.count; j++){
1062 1063 1064 1065 1066
			status = acpi_bus_get_device(tz->trips.active[i].
						     devices.handles[j],
						     &device);
			seq_printf(seq, "%4.4s ", status ? "" :
				   acpi_device_bid(device));
1067
		}
L
Linus Torvalds 已提交
1068 1069 1070
		seq_puts(seq, "\n");
	}

L
Len Brown 已提交
1071
      end:
1072
	return 0;
L
Linus Torvalds 已提交
1073 1074 1075 1076 1077 1078 1079 1080 1081
}

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)
{
1082
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
1083 1084 1085 1086 1087


	if (!tz)
		goto end;

1088
	if (!tz->flags.cooling_mode)
L
Linus Torvalds 已提交
1089 1090
		seq_puts(seq, "<setting not supported>\n");
	else
1091
		seq_puts(seq, "0 - Active; 1 - Passive\n");
L
Linus Torvalds 已提交
1092

L
Len Brown 已提交
1093
      end:
1094
	return 0;
L
Linus Torvalds 已提交
1095 1096 1097 1098 1099
}

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 已提交
1100
			   PDE(inode)->data);
L
Linus Torvalds 已提交
1101 1102 1103
}

static ssize_t
L
Len Brown 已提交
1104 1105 1106
acpi_thermal_write_cooling_mode(struct file *file,
				const char __user * buffer,
				size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
1107
{
1108 1109
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Len Brown 已提交
1110 1111
	int result = 0;
	char mode_string[12] = { '\0' };
L
Linus Torvalds 已提交
1112 1113 1114


	if (!tz || (count > sizeof(mode_string) - 1))
1115
		return -EINVAL;
L
Linus Torvalds 已提交
1116 1117

	if (!tz->flags.cooling_mode)
1118
		return -ENODEV;
L
Linus Torvalds 已提交
1119 1120

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

L
Linus Torvalds 已提交
1123
	mode_string[count] = '\0';
L
Len Brown 已提交
1124 1125 1126 1127

	result = acpi_thermal_set_cooling_mode(tz,
					       simple_strtoul(mode_string, NULL,
							      0));
L
Linus Torvalds 已提交
1128
	if (result)
1129
		return result;
L
Linus Torvalds 已提交
1130 1131 1132

	acpi_thermal_check(tz);

1133
	return count;
L
Linus Torvalds 已提交
1134 1135 1136 1137
}

static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
{
1138
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
1139 1140 1141 1142 1143


	if (!tz)
		goto end;

1144
	if (!tz->thermal_zone->polling_delay) {
L
Linus Torvalds 已提交
1145 1146 1147 1148
		seq_puts(seq, "<polling disabled>\n");
		goto end;
	}

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

L
Len Brown 已提交
1152
      end:
1153
	return 0;
L
Linus Torvalds 已提交
1154 1155 1156 1157 1158
}

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 已提交
1159
			   PDE(inode)->data);
L
Linus Torvalds 已提交
1160 1161 1162
}

static ssize_t
L
Len Brown 已提交
1163 1164 1165
acpi_thermal_write_polling(struct file *file,
			   const char __user * buffer,
			   size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
1166
{
1167 1168
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Len Brown 已提交
1169 1170 1171
	int result = 0;
	char polling_string[12] = { '\0' };
	int seconds = 0;
L
Linus Torvalds 已提交
1172 1173 1174


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

L
Linus Torvalds 已提交
1177
	if (copy_from_user(polling_string, buffer, count))
1178
		return -EFAULT;
L
Len Brown 已提交
1179

L
Linus Torvalds 已提交
1180 1181 1182
	polling_string[count] = '\0';

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

L
Linus Torvalds 已提交
1184 1185
	result = acpi_thermal_set_polling(tz, seconds);
	if (result)
1186
		return result;
L
Linus Torvalds 已提交
1187 1188 1189

	acpi_thermal_check(tz);

1190
	return count;
L
Linus Torvalds 已提交
1191 1192
}

L
Len Brown 已提交
1193
static int acpi_thermal_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1194
{
L
Len Brown 已提交
1195
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
1196 1197 1198 1199


	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
1200
						     acpi_thermal_dir);
L
Linus Torvalds 已提交
1201
		if (!acpi_device_dir(device))
1202
			return -ENODEV;
L
Linus Torvalds 已提交
1203 1204 1205
	}

	/* 'state' [R] */
1206 1207 1208 1209
	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 已提交
1210
	if (!entry)
1211
		return -ENODEV;
L
Linus Torvalds 已提交
1212 1213

	/* 'temperature' [R] */
1214 1215 1216 1217
	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 已提交
1218
	if (!entry)
1219
		return -ENODEV;
L
Linus Torvalds 已提交
1220

1221
	/* 'trip_points' [R] */
1222 1223 1224 1225 1226
	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 已提交
1227
	if (!entry)
1228
		return -ENODEV;
L
Linus Torvalds 已提交
1229 1230

	/* 'cooling_mode' [R/W] */
1231 1232 1233 1234 1235
	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 已提交
1236
	if (!entry)
1237
		return -ENODEV;
L
Linus Torvalds 已提交
1238 1239

	/* 'polling_frequency' [R/W] */
1240 1241 1242 1243 1244
	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 已提交
1245
	if (!entry)
1246 1247
		return -ENODEV;
	return 0;
L
Linus Torvalds 已提交
1248 1249
}

L
Len Brown 已提交
1250
static int acpi_thermal_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
{

	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;
	}

1268
	return 0;
L
Linus Torvalds 已提交
1269 1270 1271 1272 1273 1274
}

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

1275
static void acpi_thermal_notify(struct acpi_device *device, u32 event)
L
Linus Torvalds 已提交
1276
{
1277
	struct acpi_thermal *tz = acpi_driver_data(device);
L
Linus Torvalds 已提交
1278 1279 1280


	if (!tz)
1281
		return;
L
Linus Torvalds 已提交
1282 1283 1284 1285 1286 1287

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

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


	if (!tz)
1314
		return -EINVAL;
L
Linus Torvalds 已提交
1315 1316 1317 1318

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

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

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

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

1337
	return 0;
L
Linus Torvalds 已提交
1338 1339
}

1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
/*
 * 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 已提交
1359
static int acpi_thermal_add(struct acpi_device *device)
L
Linus Torvalds 已提交
1360
{
L
Len Brown 已提交
1361 1362
	int result = 0;
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1363 1364 1365


	if (!device)
1366
		return -EINVAL;
L
Linus Torvalds 已提交
1367

1368
	tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
L
Linus Torvalds 已提交
1369
	if (!tz)
1370
		return -ENOMEM;
L
Linus Torvalds 已提交
1371

1372
	tz->device = device;
L
Linus Torvalds 已提交
1373 1374 1375
	strcpy(tz->name, device->pnp.bus_id);
	strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
1376
	device->driver_data = tz;
1377
	mutex_init(&tz->lock);
1378 1379


L
Linus Torvalds 已提交
1380 1381
	result = acpi_thermal_get_info(tz);
	if (result)
1382 1383
		goto free_memory;

1384 1385
	acpi_thermal_guess_offset(tz);

1386 1387 1388
	result = acpi_thermal_register_thermal_zone(tz);
	if (result)
		goto free_memory;
L
Linus Torvalds 已提交
1389 1390 1391

	result = acpi_thermal_add_fs(device);
	if (result)
1392
		goto unregister_thermal_zone;
L
Linus Torvalds 已提交
1393 1394

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

1399 1400 1401 1402 1403
unregister_thermal_zone:
	thermal_zone_device_unregister(tz->thermal_zone);
free_memory:
	kfree(tz);
end:
1404
	return result;
L
Linus Torvalds 已提交
1405 1406
}

L
Len Brown 已提交
1407
static int acpi_thermal_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
1408
{
L
Len Brown 已提交
1409
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1410 1411

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

1414
	tz = acpi_driver_data(device);
L
Linus Torvalds 已提交
1415 1416

	acpi_thermal_remove_fs(device);
1417
	acpi_thermal_unregister_thermal_zone(tz);
1418
	mutex_destroy(&tz->lock);
L
Linus Torvalds 已提交
1419
	kfree(tz);
1420
	return 0;
L
Linus Torvalds 已提交
1421 1422
}

1423
static int acpi_thermal_resume(struct acpi_device *device)
1424 1425
{
	struct acpi_thermal *tz = NULL;
1426 1427
	int i, j, power_state, result;

1428 1429

	if (!device || !acpi_driver_data(device))
1430
		return -EINVAL;
1431

1432
	tz = acpi_driver_data(device);
1433

1434
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446
		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;
			}
1447
		}
1448
		tz->state.active |= tz->trips.active[i].flags.enabled;
1449 1450
	}

1451
	acpi_thermal_check(tz);
1452 1453 1454 1455

	return AE_OK;
}

1456
static int thermal_act(const struct dmi_system_id *d) {
1457 1458 1459 1460 1461 1462 1463 1464

	if (act == 0) {
		printk(KERN_NOTICE "ACPI: %s detected: "
			"disabling all active thermal trip points\n", d->ident);
		act = -1;
	}
	return 0;
}
1465
static int thermal_nocrt(const struct dmi_system_id *d) {
1466 1467 1468 1469 1470 1471

	printk(KERN_NOTICE "ACPI: %s detected: "
		"disabling all critical thermal trip point actions.\n", d->ident);
	nocrt = 1;
	return 0;
}
1472
static int thermal_tzp(const struct dmi_system_id *d) {
1473 1474 1475 1476 1477 1478 1479 1480

	if (tzp == 0) {
		printk(KERN_NOTICE "ACPI: %s detected: "
			"enabling thermal zone polling\n", d->ident);
		tzp = 300;	/* 300 dS = 30 Seconds */
	}
	return 0;
}
1481
static int thermal_psv(const struct dmi_system_id *d) {
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 1512 1513 1514 1515 1516 1517 1518 1519

	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"),
		},
	},
1520 1521 1522 1523 1524 1525 1526 1527
	{
	 .callback = thermal_nocrt,
	 .ident = "Gigabyte GA-7ZX",
	 .matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co., Ltd."),
		DMI_MATCH(DMI_BOARD_NAME, "7ZX"),
		},
	},
1528 1529 1530
	{}
};

L
Len Brown 已提交
1531
static int __init acpi_thermal_init(void)
L
Linus Torvalds 已提交
1532
{
L
Len Brown 已提交
1533
	int result = 0;
L
Linus Torvalds 已提交
1534

1535 1536
	dmi_check_system(thermal_dmi_table);

1537 1538 1539 1540
	if (off) {
		printk(KERN_NOTICE "ACPI: thermal control disabled\n");
		return -ENODEV;
	}
L
Linus Torvalds 已提交
1541 1542
	acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
	if (!acpi_thermal_dir)
1543
		return -ENODEV;
L
Linus Torvalds 已提交
1544 1545 1546 1547

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

1551
	return 0;
L
Linus Torvalds 已提交
1552 1553
}

L
Len Brown 已提交
1554
static void __exit acpi_thermal_exit(void)
L
Linus Torvalds 已提交
1555 1556 1557 1558 1559 1560
{

	acpi_bus_unregister_driver(&acpi_thermal_driver);

	remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);

1561
	return;
L
Linus Torvalds 已提交
1562 1563 1564 1565
}

module_init(acpi_thermal_init);
module_exit(acpi_thermal_exit);