thermal.c 35.5 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 36 37 38
/*
 *  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>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
39 40
#include <linux/timer.h>
#include <linux/jiffies.h>
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
#include <linux/kmod.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>

#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>

#define ACPI_THERMAL_COMPONENT		0x04000000
#define ACPI_THERMAL_CLASS		"thermal_zone"
#define ACPI_THERMAL_DRIVER_NAME	"ACPI Thermal Zone Driver"
#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_MODE_PASSIVE	0x01
#define ACPI_THERMAL_MODE_CRITICAL   	0xff
#define ACPI_THERMAL_PATH_POWEROFF	"/sbin/poweroff"

#define ACPI_THERMAL_MAX_ACTIVE	10
#define ACPI_THERMAL_MAX_LIMIT_STR_LEN 65

#define KELVIN_TO_CELSIUS(t)    (long)(((long)t-2732>=0) ? ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
#define CELSIUS_TO_KELVIN(t)	((t+273)*10)

#define _COMPONENT		ACPI_THERMAL_COMPONENT
L
Len Brown 已提交
74
ACPI_MODULE_NAME("acpi_thermal")
L
Linus Torvalds 已提交
75

76
MODULE_AUTHOR("Paul Diefenbaugh");
L
Linus Torvalds 已提交
77 78 79 80 81 82 83
MODULE_DESCRIPTION(ACPI_THERMAL_DRIVER_NAME);
MODULE_LICENSE("GPL");

static int tzp;
module_param(tzp, int, 0);
MODULE_PARM_DESC(tzp, "Thermal zone polling frequency, in 1/10 seconds.\n");

L
Len Brown 已提交
84 85
static int acpi_thermal_add(struct acpi_device *device);
static int acpi_thermal_remove(struct acpi_device *device, int type);
86
static int acpi_thermal_resume(struct acpi_device *device);
L
Linus Torvalds 已提交
87 88 89
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);
L
Len Brown 已提交
90 91 92
static ssize_t acpi_thermal_write_trip_points(struct file *,
					      const char __user *, size_t,
					      loff_t *);
L
Linus Torvalds 已提交
93
static int acpi_thermal_cooling_open_fs(struct inode *inode, struct file *file);
L
Len Brown 已提交
94 95 96
static ssize_t acpi_thermal_write_cooling_mode(struct file *,
					       const char __user *, size_t,
					       loff_t *);
L
Linus Torvalds 已提交
97
static int acpi_thermal_polling_open_fs(struct inode *inode, struct file *file);
L
Len Brown 已提交
98 99
static ssize_t acpi_thermal_write_polling(struct file *, const char __user *,
					  size_t, loff_t *);
L
Linus Torvalds 已提交
100 101

static struct acpi_driver acpi_thermal_driver = {
L
Len Brown 已提交
102 103 104 105 106 107
	.name = ACPI_THERMAL_DRIVER_NAME,
	.class = ACPI_THERMAL_CLASS,
	.ids = ACPI_THERMAL_HID,
	.ops = {
		.add = acpi_thermal_add,
		.remove = acpi_thermal_remove,
108
		.resume = acpi_thermal_resume,
L
Len Brown 已提交
109
		},
L
Linus Torvalds 已提交
110 111 112
};

struct acpi_thermal_state {
L
Len Brown 已提交
113 114 115 116 117 118
	u8 critical:1;
	u8 hot:1;
	u8 passive:1;
	u8 active:1;
	u8 reserved:4;
	int active_index;
L
Linus Torvalds 已提交
119 120 121
};

struct acpi_thermal_state_flags {
L
Len Brown 已提交
122 123 124
	u8 valid:1;
	u8 enabled:1;
	u8 reserved:6;
L
Linus Torvalds 已提交
125 126 127 128
};

struct acpi_thermal_critical {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
129
	unsigned long temperature;
L
Linus Torvalds 已提交
130 131 132 133
};

struct acpi_thermal_hot {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
134
	unsigned long temperature;
L
Linus Torvalds 已提交
135 136 137 138
};

struct acpi_thermal_passive {
	struct acpi_thermal_state_flags flags;
L
Len Brown 已提交
139 140 141 142 143
	unsigned long temperature;
	unsigned long tc1;
	unsigned long tc2;
	unsigned long tsp;
	struct acpi_handle_list devices;
L
Linus Torvalds 已提交
144 145 146 147
};

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

struct acpi_thermal_trips {
	struct acpi_thermal_critical critical;
L
Len Brown 已提交
154
	struct acpi_thermal_hot hot;
L
Linus Torvalds 已提交
155 156 157 158 159
	struct acpi_thermal_passive passive;
	struct acpi_thermal_active active[ACPI_THERMAL_MAX_ACTIVE];
};

struct acpi_thermal_flags {
L
Len Brown 已提交
160 161 162
	u8 cooling_mode:1;	/* _SCP */
	u8 devices:1;		/* _TZD */
	u8 reserved:6;
L
Linus Torvalds 已提交
163 164 165
};

struct acpi_thermal {
166
	struct acpi_device * device;
L
Len Brown 已提交
167 168 169 170 171 172
	acpi_bus_id name;
	unsigned long temperature;
	unsigned long last_temperature;
	unsigned long polling_frequency;
	u8 cooling_mode;
	volatile u8 zombie;
L
Linus Torvalds 已提交
173 174 175
	struct acpi_thermal_flags flags;
	struct acpi_thermal_state state;
	struct acpi_thermal_trips trips;
L
Len Brown 已提交
176 177
	struct acpi_handle_list devices;
	struct timer_list timer;
L
Linus Torvalds 已提交
178 179
};

180
static const struct file_operations acpi_thermal_state_fops = {
L
Len Brown 已提交
181 182 183 184
	.open = acpi_thermal_state_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
185 186
};

187
static const struct file_operations acpi_thermal_temp_fops = {
L
Len Brown 已提交
188 189 190 191
	.open = acpi_thermal_temp_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
192 193
};

194
static const struct file_operations acpi_thermal_trip_fops = {
L
Len Brown 已提交
195 196 197 198 199
	.open = acpi_thermal_trip_open_fs,
	.read = seq_read,
	.write = acpi_thermal_write_trip_points,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
200 201
};

202
static const struct file_operations acpi_thermal_cooling_fops = {
L
Len Brown 已提交
203 204 205 206 207
	.open = acpi_thermal_cooling_open_fs,
	.read = seq_read,
	.write = acpi_thermal_write_cooling_mode,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
208 209
};

210
static const struct file_operations acpi_thermal_polling_fops = {
L
Len Brown 已提交
211 212 213 214 215
	.open = acpi_thermal_polling_open_fs,
	.read = seq_read,
	.write = acpi_thermal_write_polling,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
216 217 218 219 220 221
};

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

L
Len Brown 已提交
222
static int acpi_thermal_get_temperature(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
223
{
L
Len Brown 已提交
224
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
225 226 227


	if (!tz)
228
		return -EINVAL;
L
Linus Torvalds 已提交
229 230 231

	tz->last_temperature = tz->temperature;

L
Len Brown 已提交
232
	status =
233
	    acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tz->temperature);
L
Linus Torvalds 已提交
234
	if (ACPI_FAILURE(status))
235
		return -ENODEV;
L
Linus Torvalds 已提交
236

L
Len Brown 已提交
237 238
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n",
			  tz->temperature));
L
Linus Torvalds 已提交
239

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

L
Len Brown 已提交
243
static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
244
{
L
Len Brown 已提交
245
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
246 247 248


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

L
Len Brown 已提交
251
	status =
252
	    acpi_evaluate_integer(tz->device->handle, "_TZP", NULL,
L
Len Brown 已提交
253
				  &tz->polling_frequency);
L
Linus Torvalds 已提交
254
	if (ACPI_FAILURE(status))
255
		return -ENODEV;
L
Linus Torvalds 已提交
256

L
Len Brown 已提交
257 258
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n",
			  tz->polling_frequency));
L
Linus Torvalds 已提交
259

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

L
Len Brown 已提交
263
static int acpi_thermal_set_polling(struct acpi_thermal *tz, int seconds)
L
Linus Torvalds 已提交
264 265 266
{

	if (!tz)
267
		return -EINVAL;
L
Linus Torvalds 已提交
268 269 270

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

L
Len Brown 已提交
271 272 273
	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "Polling frequency set to %lu seconds\n",
			  tz->polling_frequency));
L
Linus Torvalds 已提交
274

275
	return 0;
L
Linus Torvalds 已提交
276 277
}

L
Len Brown 已提交
278
static int acpi_thermal_set_cooling_mode(struct acpi_thermal *tz, int mode)
L
Linus Torvalds 已提交
279
{
L
Len Brown 已提交
280 281 282 283
	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 已提交
284 285 286


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

289
	status = acpi_get_handle(tz->device->handle, "_SCP", &handle);
L
Linus Torvalds 已提交
290 291
	if (ACPI_FAILURE(status)) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n"));
292
		return -ENODEV;
L
Linus Torvalds 已提交
293 294 295 296 297 298
	}

	arg0.integer.value = mode;

	status = acpi_evaluate_object(handle, NULL, &arg_list, NULL);
	if (ACPI_FAILURE(status))
299
		return -ENODEV;
L
Linus Torvalds 已提交
300 301 302

	tz->cooling_mode = mode;

L
Len Brown 已提交
303 304
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cooling mode [%s]\n",
			  mode ? "passive" : "active"));
L
Linus Torvalds 已提交
305

306
	return 0;
L
Linus Torvalds 已提交
307 308
}

L
Len Brown 已提交
309
static int acpi_thermal_get_trip_points(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
310
{
L
Len Brown 已提交
311 312
	acpi_status status = AE_OK;
	int i = 0;
L
Linus Torvalds 已提交
313 314 315


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

	/* Critical Shutdown (required) */

320
	status = acpi_evaluate_integer(tz->device->handle, "_CRT", NULL,
L
Len Brown 已提交
321
				       &tz->trips.critical.temperature);
L
Linus Torvalds 已提交
322 323
	if (ACPI_FAILURE(status)) {
		tz->trips.critical.flags.valid = 0;
324
		ACPI_EXCEPTION((AE_INFO, status, "No critical threshold"));
325
		return -ENODEV;
L
Len Brown 已提交
326
	} else {
L
Linus Torvalds 已提交
327
		tz->trips.critical.flags.valid = 1;
L
Len Brown 已提交
328 329 330
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Found critical threshold [%lu]\n",
				  tz->trips.critical.temperature));
L
Linus Torvalds 已提交
331 332 333 334
	}

	/* Critical Sleep (optional) */

L
Len Brown 已提交
335
	status =
336
	    acpi_evaluate_integer(tz->device->handle, "_HOT", NULL,
L
Len Brown 已提交
337
				  &tz->trips.hot.temperature);
L
Linus Torvalds 已提交
338 339 340
	if (ACPI_FAILURE(status)) {
		tz->trips.hot.flags.valid = 0;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No hot threshold\n"));
L
Len Brown 已提交
341
	} else {
L
Linus Torvalds 已提交
342
		tz->trips.hot.flags.valid = 1;
L
Len Brown 已提交
343 344
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found hot threshold [%lu]\n",
				  tz->trips.hot.temperature));
L
Linus Torvalds 已提交
345 346 347 348
	}

	/* Passive: Processors (optional) */

L
Len Brown 已提交
349
	status =
350
	    acpi_evaluate_integer(tz->device->handle, "_PSV", NULL,
L
Len Brown 已提交
351
				  &tz->trips.passive.temperature);
L
Linus Torvalds 已提交
352 353 354
	if (ACPI_FAILURE(status)) {
		tz->trips.passive.flags.valid = 0;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No passive threshold\n"));
L
Len Brown 已提交
355
	} else {
L
Linus Torvalds 已提交
356 357
		tz->trips.passive.flags.valid = 1;

L
Len Brown 已提交
358
		status =
359
		    acpi_evaluate_integer(tz->device->handle, "_TC1", NULL,
L
Len Brown 已提交
360
					  &tz->trips.passive.tc1);
L
Linus Torvalds 已提交
361 362 363
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

L
Len Brown 已提交
364
		status =
365
		    acpi_evaluate_integer(tz->device->handle, "_TC2", NULL,
L
Len Brown 已提交
366
					  &tz->trips.passive.tc2);
L
Linus Torvalds 已提交
367 368 369
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

L
Len Brown 已提交
370
		status =
371
		    acpi_evaluate_integer(tz->device->handle, "_TSP", NULL,
L
Len Brown 已提交
372
					  &tz->trips.passive.tsp);
L
Linus Torvalds 已提交
373 374 375
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

L
Len Brown 已提交
376
		status =
377
		    acpi_evaluate_reference(tz->device->handle, "_PSL", NULL,
L
Len Brown 已提交
378
					    &tz->trips.passive.devices);
L
Linus Torvalds 已提交
379 380 381 382
		if (ACPI_FAILURE(status))
			tz->trips.passive.flags.valid = 0;

		if (!tz->trips.passive.flags.valid)
383
			printk(KERN_WARNING PREFIX "Invalid passive threshold\n");
L
Linus Torvalds 已提交
384
		else
L
Len Brown 已提交
385 386 387
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "Found passive threshold [%lu]\n",
					  tz->trips.passive.temperature));
L
Linus Torvalds 已提交
388 389 390 391
	}

	/* Active: Fans, etc. (optional) */

L
Len Brown 已提交
392
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
L
Linus Torvalds 已提交
393

L
Len Brown 已提交
394
		char name[5] = { '_', 'A', 'C', ('0' + i), '\0' };
L
Linus Torvalds 已提交
395

L
Len Brown 已提交
396
		status =
397
		    acpi_evaluate_integer(tz->device->handle, name, NULL,
L
Len Brown 已提交
398
					  &tz->trips.active[i].temperature);
L
Linus Torvalds 已提交
399 400 401 402
		if (ACPI_FAILURE(status))
			break;

		name[2] = 'L';
L
Len Brown 已提交
403
		status =
404
		    acpi_evaluate_reference(tz->device->handle, name, NULL,
L
Len Brown 已提交
405
					    &tz->trips.active[i].devices);
L
Linus Torvalds 已提交
406 407
		if (ACPI_SUCCESS(status)) {
			tz->trips.active[i].flags.valid = 1;
L
Len Brown 已提交
408 409 410 411
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "Found active threshold [%d]:[%lu]\n",
					  i, tz->trips.active[i].temperature));
		} else
412 413
			ACPI_EXCEPTION((AE_INFO, status,
					"Invalid active threshold [%d]", i));
L
Linus Torvalds 已提交
414 415
	}

416
	return 0;
L
Linus Torvalds 已提交
417 418
}

L
Len Brown 已提交
419
static int acpi_thermal_get_devices(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
420
{
L
Len Brown 已提交
421
	acpi_status status = AE_OK;
L
Linus Torvalds 已提交
422 423 424


	if (!tz)
425
		return -EINVAL;
L
Linus Torvalds 已提交
426

L
Len Brown 已提交
427
	status =
428
	    acpi_evaluate_reference(tz->device->handle, "_TZD", NULL, &tz->devices);
L
Linus Torvalds 已提交
429
	if (ACPI_FAILURE(status))
430
		return -ENODEV;
L
Linus Torvalds 已提交
431

432
	return 0;
L
Linus Torvalds 已提交
433 434
}

L
Len Brown 已提交
435
static int acpi_thermal_call_usermode(char *path)
L
Linus Torvalds 已提交
436
{
L
Len Brown 已提交
437 438
	char *argv[2] = { NULL, NULL };
	char *envp[3] = { NULL, NULL, NULL };
L
Linus Torvalds 已提交
439 440 441


	if (!path)
442
		return -EINVAL;
L
Linus Torvalds 已提交
443 444 445 446 447 448

	argv[0] = path;

	/* minimal command environment */
	envp[0] = "HOME=/";
	envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
L
Len Brown 已提交
449

L
Linus Torvalds 已提交
450 451
	call_usermodehelper(argv[0], argv, envp, 0);

452
	return 0;
L
Linus Torvalds 已提交
453 454
}

L
Len Brown 已提交
455
static int acpi_thermal_critical(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
456 457
{
	if (!tz || !tz->trips.critical.flags.valid)
458
		return -EINVAL;
L
Linus Torvalds 已提交
459 460

	if (tz->temperature >= tz->trips.critical.temperature) {
461
		printk(KERN_WARNING PREFIX "Critical trip point\n");
L
Linus Torvalds 已提交
462
		tz->trips.critical.flags.enabled = 1;
L
Len Brown 已提交
463
	} else if (tz->trips.critical.flags.enabled)
L
Linus Torvalds 已提交
464 465
		tz->trips.critical.flags.enabled = 0;

L
Len Brown 已提交
466 467 468
	printk(KERN_EMERG
	       "Critical temperature reached (%ld C), shutting down.\n",
	       KELVIN_TO_CELSIUS(tz->temperature));
469
	acpi_bus_generate_event(tz->device, ACPI_THERMAL_NOTIFY_CRITICAL,
L
Len Brown 已提交
470
				tz->trips.critical.flags.enabled);
L
Linus Torvalds 已提交
471 472 473

	acpi_thermal_call_usermode(ACPI_THERMAL_PATH_POWEROFF);

474
	return 0;
L
Linus Torvalds 已提交
475 476
}

L
Len Brown 已提交
477
static int acpi_thermal_hot(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
478 479
{
	if (!tz || !tz->trips.hot.flags.valid)
480
		return -EINVAL;
L
Linus Torvalds 已提交
481 482

	if (tz->temperature >= tz->trips.hot.temperature) {
483
		printk(KERN_WARNING PREFIX "Hot trip point\n");
L
Linus Torvalds 已提交
484
		tz->trips.hot.flags.enabled = 1;
L
Len Brown 已提交
485
	} else if (tz->trips.hot.flags.enabled)
L
Linus Torvalds 已提交
486 487
		tz->trips.hot.flags.enabled = 0;

488
	acpi_bus_generate_event(tz->device, ACPI_THERMAL_NOTIFY_HOT,
L
Len Brown 已提交
489
				tz->trips.hot.flags.enabled);
L
Linus Torvalds 已提交
490 491 492

	/* TBD: Call user-mode "sleep(S4)" function */

493
	return 0;
L
Linus Torvalds 已提交
494 495
}

496
static void acpi_thermal_passive(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
497
{
498
	int result = 1;
L
Linus Torvalds 已提交
499
	struct acpi_thermal_passive *passive = NULL;
L
Len Brown 已提交
500 501
	int trend = 0;
	int i = 0;
L
Linus Torvalds 已提交
502 503 504


	if (!tz || !tz->trips.passive.flags.valid)
505
		return;
L
Linus Torvalds 已提交
506 507 508 509 510 511 512 513 514 515 516

	passive = &(tz->trips.passive);

	/*
	 * Above Trip?
	 * -----------
	 * Calculate the thermal trend (using the passive cooling equation)
	 * and modify the performance limit for all passive cooling devices
	 * accordingly.  Note that we assume symmetry.
	 */
	if (tz->temperature >= passive->temperature) {
L
Len Brown 已提交
517 518 519 520 521 522 523 524
		trend =
		    (passive->tc1 * (tz->temperature - tz->last_temperature)) +
		    (passive->tc2 * (tz->temperature - passive->temperature));
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "trend[%d]=(tc1[%lu]*(tmp[%lu]-last[%lu]))+(tc2[%lu]*(tmp[%lu]-psv[%lu]))\n",
				  trend, passive->tc1, tz->temperature,
				  tz->last_temperature, passive->tc2,
				  tz->temperature, passive->temperature));
525
		passive->flags.enabled = 1;
L
Linus Torvalds 已提交
526 527
		/* Heating up? */
		if (trend > 0)
L
Len Brown 已提交
528 529 530 531 532
			for (i = 0; i < passive->devices.count; i++)
				acpi_processor_set_thermal_limit(passive->
								 devices.
								 handles[i],
								 ACPI_PROCESSOR_LIMIT_INCREMENT);
L
Linus Torvalds 已提交
533
		/* Cooling off? */
534
		else if (trend < 0) {
L
Len Brown 已提交
535
			for (i = 0; i < passive->devices.count; i++)
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
				/*
				 * assume that we are on highest
				 * freq/lowest thrott and can leave
				 * passive mode, even in error case
				 */
				if (!acpi_processor_set_thermal_limit
				    (passive->devices.handles[i],
				     ACPI_PROCESSOR_LIMIT_DECREMENT))
					result = 0;
			/*
			 * Leave cooling mode, even if the temp might
			 * higher than trip point This is because some
			 * machines might have long thermal polling
			 * frequencies (tsp) defined. We will fall back
			 * into passive mode in next cycle (probably quicker)
			 */
			if (result) {
				passive->flags.enabled = 0;
				ACPI_DEBUG_PRINT((ACPI_DB_INFO,
						  "Disabling passive cooling, still above threshold,"
						  " but we are cooling down\n"));
			}
		}
		return;
L
Linus Torvalds 已提交
560 561 562 563 564 565 566 567 568
	}

	/*
	 * Below Trip?
	 * -----------
	 * Implement passive cooling hysteresis to slowly increase performance
	 * and avoid thrashing around the passive trip point.  Note that we
	 * assume symmetry.
	 */
569 570 571 572 573 574 575 576 577 578 579
	if (!passive->flags.enabled)
		return;
	for (i = 0; i < passive->devices.count; i++)
		if (!acpi_processor_set_thermal_limit
		    (passive->devices.handles[i],
		     ACPI_PROCESSOR_LIMIT_DECREMENT))
			result = 0;
	if (result) {
		passive->flags.enabled = 0;
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Disabling passive cooling (zone is cool)\n"));
L
Linus Torvalds 已提交
580 581 582
	}
}

583
static void acpi_thermal_active(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
584
{
L
Len Brown 已提交
585
	int result = 0;
L
Linus Torvalds 已提交
586
	struct acpi_thermal_active *active = NULL;
L
Len Brown 已提交
587 588 589
	int i = 0;
	int j = 0;
	unsigned long maxtemp = 0;
L
Linus Torvalds 已提交
590 591 592


	if (!tz)
593
		return;
L
Linus Torvalds 已提交
594

L
Len Brown 已提交
595
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++) {
L
Linus Torvalds 已提交
596 597 598 599
		active = &(tz->trips.active[i]);
		if (!active || !active->flags.valid)
			break;
		if (tz->temperature >= active->temperature) {
600 601 602 603 604 605
			/*
			 * Above Threshold?
			 * ----------------
			 * If not already enabled, turn ON all cooling devices
			 * associated with this active threshold.
			 */
L
Linus Torvalds 已提交
606
			if (active->temperature > maxtemp)
607 608 609 610
				tz->state.active_index = i;
			maxtemp = active->temperature;
			if (active->flags.enabled)
				continue;
L
Linus Torvalds 已提交
611
			for (j = 0; j < active->devices.count; j++) {
L
Len Brown 已提交
612 613 614
				result =
				    acpi_bus_set_power(active->devices.
						       handles[j],
615
						       ACPI_STATE_D0);
L
Linus Torvalds 已提交
616
				if (result) {
617 618
					printk(KERN_WARNING PREFIX
						      "Unable to turn cooling device [%p] 'on'\n",
619
						      active->devices.
620
						      handles[j]);
L
Linus Torvalds 已提交
621 622
					continue;
				}
623
				active->flags.enabled = 1;
L
Len Brown 已提交
624
				ACPI_DEBUG_PRINT((ACPI_DB_INFO,
625
						  "Cooling device [%p] now 'on'\n",
L
Len Brown 已提交
626
						  active->devices.handles[j]));
L
Linus Torvalds 已提交
627
			}
628 629 630 631 632 633 634 635 636 637 638 639 640 641
			continue;
		}
		if (!active->flags.enabled)
			continue;
		/*
		 * Below Threshold?
		 * ----------------
		 * Turn OFF all cooling devices associated with this
		 * threshold.
		 */
		for (j = 0; j < active->devices.count; j++) {
			result = acpi_bus_set_power(active->devices.handles[j],
						    ACPI_STATE_D3);
			if (result) {
642 643 644
				printk(KERN_WARNING PREFIX
					      "Unable to turn cooling device [%p] 'off'\n",
					      active->devices.handles[j]);
645 646 647 648 649 650
				continue;
			}
			active->flags.enabled = 0;
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "Cooling device [%p] now 'off'\n",
					  active->devices.handles[j]));
L
Linus Torvalds 已提交
651 652 653 654
		}
	}
}

L
Len Brown 已提交
655
static void acpi_thermal_check(void *context);
L
Linus Torvalds 已提交
656

L
Len Brown 已提交
657
static void acpi_thermal_run(unsigned long data)
L
Linus Torvalds 已提交
658 659 660
{
	struct acpi_thermal *tz = (struct acpi_thermal *)data;
	if (!tz->zombie)
661
		acpi_os_execute(OSL_GPE_HANDLER, acpi_thermal_check, (void *)data);
L
Linus Torvalds 已提交
662 663
}

L
Len Brown 已提交
664
static void acpi_thermal_check(void *data)
L
Linus Torvalds 已提交
665
{
L
Len Brown 已提交
666
	int result = 0;
667
	struct acpi_thermal *tz = data;
L
Len Brown 已提交
668 669
	unsigned long sleep_time = 0;
	int i = 0;
L
Linus Torvalds 已提交
670 671 672 673
	struct acpi_thermal_state state;


	if (!tz) {
674
		printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
675
		return;
L
Linus Torvalds 已提交
676 677 678 679 680 681
	}

	state = tz->state;

	result = acpi_thermal_get_temperature(tz);
	if (result)
682
		return;
L
Len Brown 已提交
683

L
Linus Torvalds 已提交
684
	memset(&tz->state, 0, sizeof(tz->state));
L
Len Brown 已提交
685

L
Linus Torvalds 已提交
686 687 688 689 690 691 692 693 694
	/*
	 * Check Trip Points
	 * -----------------
	 * Compare the current temperature to the trip point values to see
	 * if we've entered one of the thermal policy states.  Note that
	 * this function determines when a state is entered, but the 
	 * individual policy decides when it is exited (e.g. hysteresis).
	 */
	if (tz->trips.critical.flags.valid)
L
Len Brown 已提交
695 696
		state.critical |=
		    (tz->temperature >= tz->trips.critical.temperature);
L
Linus Torvalds 已提交
697 698 699
	if (tz->trips.hot.flags.valid)
		state.hot |= (tz->temperature >= tz->trips.hot.temperature);
	if (tz->trips.passive.flags.valid)
L
Len Brown 已提交
700 701 702
		state.passive |=
		    (tz->temperature >= tz->trips.passive.temperature);
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
L
Linus Torvalds 已提交
703
		if (tz->trips.active[i].flags.valid)
L
Len Brown 已提交
704 705 706
			state.active |=
			    (tz->temperature >=
			     tz->trips.active[i].temperature);
L
Linus Torvalds 已提交
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728

	/*
	 * Invoke Policy
	 * -------------
	 * Separated from the above check to allow individual policy to 
	 * determine when to exit a given state.
	 */
	if (state.critical)
		acpi_thermal_critical(tz);
	if (state.hot)
		acpi_thermal_hot(tz);
	if (state.passive)
		acpi_thermal_passive(tz);
	if (state.active)
		acpi_thermal_active(tz);

	/*
	 * Calculate State
	 * ---------------
	 * Again, separated from the above two to allow independent policy
	 * decisions.
	 */
729 730 731 732
	tz->state.critical = tz->trips.critical.flags.enabled;
	tz->state.hot = tz->trips.hot.flags.enabled;
	tz->state.passive = tz->trips.passive.flags.enabled;
	tz->state.active = 0;
L
Len Brown 已提交
733
	for (i = 0; i < ACPI_THERMAL_MAX_ACTIVE; i++)
734
		tz->state.active |= tz->trips.active[i].flags.enabled;
L
Linus Torvalds 已提交
735 736 737 738 739 740 741 742 743 744 745 746 747 748 749

	/*
	 * Calculate Sleep Time
	 * --------------------
	 * If we're in the passive state, use _TSP's value.  Otherwise
	 * use the default polling frequency (e.g. _TZP).  If no polling
	 * frequency is specified then we'll wait forever (at least until
	 * a thermal event occurs).  Note that _TSP and _TZD values are
	 * given in 1/10th seconds (we must covert to milliseconds).
	 */
	if (tz->state.passive)
		sleep_time = tz->trips.passive.tsp * 100;
	else if (tz->polling_frequency > 0)
		sleep_time = tz->polling_frequency * 100;

L
Len Brown 已提交
750 751
	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s: temperature[%lu] sleep[%lu]\n",
			  tz->name, tz->temperature, sleep_time));
L
Linus Torvalds 已提交
752 753 754 755 756 757 758 759

	/*
	 * Schedule Next Poll
	 * ------------------
	 */
	if (!sleep_time) {
		if (timer_pending(&(tz->timer)))
			del_timer(&(tz->timer));
L
Len Brown 已提交
760
	} else {
L
Linus Torvalds 已提交
761 762 763
		if (timer_pending(&(tz->timer)))
			mod_timer(&(tz->timer), (HZ * sleep_time) / 1000);
		else {
L
Len Brown 已提交
764
			tz->timer.data = (unsigned long)tz;
L
Linus Torvalds 已提交
765 766 767 768 769 770
			tz->timer.function = acpi_thermal_run;
			tz->timer.expires = jiffies + (HZ * sleep_time) / 1000;
			add_timer(&(tz->timer));
		}
	}

771
	return;
L
Linus Torvalds 已提交
772 773 774 775 776 777
}

/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
778
static struct proc_dir_entry *acpi_thermal_dir;
L
Linus Torvalds 已提交
779 780 781

static int acpi_thermal_state_seq_show(struct seq_file *seq, void *offset)
{
782
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
783 784 785 786 787 788 789


	if (!tz)
		goto end;

	seq_puts(seq, "state:                   ");

L
Len Brown 已提交
790 791
	if (!tz->state.critical && !tz->state.hot && !tz->state.passive
	    && !tz->state.active)
L
Linus Torvalds 已提交
792 793 794 795 796 797 798 799 800 801 802 803 804
		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 已提交
805
      end:
806
	return 0;
L
Linus Torvalds 已提交
807 808 809 810 811 812 813 814 815
}

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 已提交
816
	int result = 0;
817
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
818 819 820 821 822 823 824 825 826


	if (!tz)
		goto end;

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

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

L
Len Brown 已提交
830
      end:
831
	return 0;
L
Linus Torvalds 已提交
832 833 834 835 836 837 838 839 840
}

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)
{
841
	struct acpi_thermal *tz = seq->private;
L
Len Brown 已提交
842 843
	int i = 0;
	int j = 0;
L
Linus Torvalds 已提交
844 845 846 847 848 849 850


	if (!tz)
		goto end;

	if (tz->trips.critical.flags.valid)
		seq_printf(seq, "critical (S5):           %ld C\n",
L
Len Brown 已提交
851
			   KELVIN_TO_CELSIUS(tz->trips.critical.temperature));
L
Linus Torvalds 已提交
852 853 854

	if (tz->trips.hot.flags.valid)
		seq_printf(seq, "hot (S4):                %ld C\n",
L
Len Brown 已提交
855
			   KELVIN_TO_CELSIUS(tz->trips.hot.temperature));
L
Linus Torvalds 已提交
856 857

	if (tz->trips.passive.flags.valid) {
L
Len Brown 已提交
858 859 860 861 862 863 864 865 866
		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++) {

			seq_printf(seq, "0x%p ",
				   tz->trips.passive.devices.handles[j]);
L
Linus Torvalds 已提交
867 868 869 870 871 872 873 874
		}
		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 已提交
875 876 877
			   i,
			   KELVIN_TO_CELSIUS(tz->trips.active[i].temperature));
		for (j = 0; j < tz->trips.active[i].devices.count; j++)
L
Linus Torvalds 已提交
878
			seq_printf(seq, "0x%p ",
L
Len Brown 已提交
879
				   tz->trips.active[i].devices.handles[j]);
L
Linus Torvalds 已提交
880 881 882
		seq_puts(seq, "\n");
	}

L
Len Brown 已提交
883
      end:
884
	return 0;
L
Linus Torvalds 已提交
885 886 887 888 889 890 891 892
}

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 ssize_t
L
Len Brown 已提交
893 894 895
acpi_thermal_write_trip_points(struct file *file,
			       const char __user * buffer,
			       size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
896
{
897 898
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Linus Torvalds 已提交
899

L
Len Brown 已提交
900 901 902 903
	char *limit_string;
	int num, critical, hot, passive;
	int *active;
	int i = 0;
L
Linus Torvalds 已提交
904 905


906
	limit_string = kzalloc(ACPI_THERMAL_MAX_LIMIT_STR_LEN, GFP_KERNEL);
L
Len Brown 已提交
907
	if (!limit_string)
908
		return -ENOMEM;
L
Linus Torvalds 已提交
909

L
Len Brown 已提交
910
	active = kmalloc(ACPI_THERMAL_MAX_ACTIVE * sizeof(int), GFP_KERNEL);
911 912
	if (!active) {
		kfree(limit_string);
913
		return -ENOMEM;
914
	}
L
Linus Torvalds 已提交
915 916 917 918 919

	if (!tz || (count > ACPI_THERMAL_MAX_LIMIT_STR_LEN - 1)) {
		count = -EINVAL;
		goto end;
	}
L
Len Brown 已提交
920

L
Linus Torvalds 已提交
921 922 923 924
	if (copy_from_user(limit_string, buffer, count)) {
		count = -EFAULT;
		goto end;
	}
L
Len Brown 已提交
925

L
Linus Torvalds 已提交
926 927 928
	limit_string[count] = '\0';

	num = sscanf(limit_string, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d",
L
Len Brown 已提交
929 930 931 932 933
		     &critical, &hot, &passive,
		     &active[0], &active[1], &active[2], &active[3], &active[4],
		     &active[5], &active[6], &active[7], &active[8],
		     &active[9]);
	if (!(num >= 5 && num < (ACPI_THERMAL_MAX_ACTIVE + 3))) {
L
Linus Torvalds 已提交
934 935 936 937 938 939 940 941 942 943 944 945
		count = -EINVAL;
		goto end;
	}

	tz->trips.critical.temperature = CELSIUS_TO_KELVIN(critical);
	tz->trips.hot.temperature = CELSIUS_TO_KELVIN(hot);
	tz->trips.passive.temperature = CELSIUS_TO_KELVIN(passive);
	for (i = 0; i < num - 3; i++) {
		if (!(tz->trips.active[i].flags.valid))
			break;
		tz->trips.active[i].temperature = CELSIUS_TO_KELVIN(active[i]);
	}
L
Len Brown 已提交
946 947

      end:
L
Linus Torvalds 已提交
948 949
	kfree(active);
	kfree(limit_string);
950
	return count;
L
Linus Torvalds 已提交
951 952 953 954
}

static int acpi_thermal_cooling_seq_show(struct seq_file *seq, void *offset)
{
955
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
956 957 958 959 960 961 962 963 964


	if (!tz)
		goto end;

	if (!tz->flags.cooling_mode) {
		seq_puts(seq, "<setting not supported>\n");
	}

L
Len Brown 已提交
965
	if (tz->cooling_mode == ACPI_THERMAL_MODE_CRITICAL)
L
Linus Torvalds 已提交
966 967 968
		seq_printf(seq, "cooling mode:	critical\n");
	else
		seq_printf(seq, "cooling mode:	%s\n",
L
Len Brown 已提交
969
			   tz->cooling_mode ? "passive" : "active");
L
Linus Torvalds 已提交
970

L
Len Brown 已提交
971
      end:
972
	return 0;
L
Linus Torvalds 已提交
973 974 975 976 977
}

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 已提交
978
			   PDE(inode)->data);
L
Linus Torvalds 已提交
979 980 981
}

static ssize_t
L
Len Brown 已提交
982 983 984
acpi_thermal_write_cooling_mode(struct file *file,
				const char __user * buffer,
				size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
985
{
986 987
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Len Brown 已提交
988 989
	int result = 0;
	char mode_string[12] = { '\0' };
L
Linus Torvalds 已提交
990 991 992


	if (!tz || (count > sizeof(mode_string) - 1))
993
		return -EINVAL;
L
Linus Torvalds 已提交
994 995

	if (!tz->flags.cooling_mode)
996
		return -ENODEV;
L
Linus Torvalds 已提交
997 998

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

L
Linus Torvalds 已提交
1001
	mode_string[count] = '\0';
L
Len Brown 已提交
1002 1003 1004 1005

	result = acpi_thermal_set_cooling_mode(tz,
					       simple_strtoul(mode_string, NULL,
							      0));
L
Linus Torvalds 已提交
1006
	if (result)
1007
		return result;
L
Linus Torvalds 已提交
1008 1009 1010

	acpi_thermal_check(tz);

1011
	return count;
L
Linus Torvalds 已提交
1012 1013 1014 1015
}

static int acpi_thermal_polling_seq_show(struct seq_file *seq, void *offset)
{
1016
	struct acpi_thermal *tz = seq->private;
L
Linus Torvalds 已提交
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027


	if (!tz)
		goto end;

	if (!tz->polling_frequency) {
		seq_puts(seq, "<polling disabled>\n");
		goto end;
	}

	seq_printf(seq, "polling frequency:       %lu seconds\n",
L
Len Brown 已提交
1028
		   (tz->polling_frequency / 10));
L
Linus Torvalds 已提交
1029

L
Len Brown 已提交
1030
      end:
1031
	return 0;
L
Linus Torvalds 已提交
1032 1033 1034 1035 1036
}

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 已提交
1037
			   PDE(inode)->data);
L
Linus Torvalds 已提交
1038 1039 1040
}

static ssize_t
L
Len Brown 已提交
1041 1042 1043
acpi_thermal_write_polling(struct file *file,
			   const char __user * buffer,
			   size_t count, loff_t * ppos)
L
Linus Torvalds 已提交
1044
{
1045 1046
	struct seq_file *m = file->private_data;
	struct acpi_thermal *tz = m->private;
L
Len Brown 已提交
1047 1048 1049
	int result = 0;
	char polling_string[12] = { '\0' };
	int seconds = 0;
L
Linus Torvalds 已提交
1050 1051 1052


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

L
Linus Torvalds 已提交
1055
	if (copy_from_user(polling_string, buffer, count))
1056
		return -EFAULT;
L
Len Brown 已提交
1057

L
Linus Torvalds 已提交
1058 1059 1060
	polling_string[count] = '\0';

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

L
Linus Torvalds 已提交
1062 1063
	result = acpi_thermal_set_polling(tz, seconds);
	if (result)
1064
		return result;
L
Linus Torvalds 已提交
1065 1066 1067

	acpi_thermal_check(tz);

1068
	return count;
L
Linus Torvalds 已提交
1069 1070
}

L
Len Brown 已提交
1071
static int acpi_thermal_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1072
{
L
Len Brown 已提交
1073
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
1074 1075 1076 1077


	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
1078
						     acpi_thermal_dir);
L
Linus Torvalds 已提交
1079
		if (!acpi_device_dir(device))
1080
			return -ENODEV;
L
Linus Torvalds 已提交
1081 1082 1083 1084 1085
		acpi_device_dir(device)->owner = THIS_MODULE;
	}

	/* 'state' [R] */
	entry = create_proc_entry(ACPI_THERMAL_FILE_STATE,
L
Len Brown 已提交
1086
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
1087
	if (!entry)
1088
		return -ENODEV;
L
Linus Torvalds 已提交
1089 1090 1091 1092 1093 1094 1095 1096
	else {
		entry->proc_fops = &acpi_thermal_state_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

	/* 'temperature' [R] */
	entry = create_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
L
Len Brown 已提交
1097
				  S_IRUGO, acpi_device_dir(device));
L
Linus Torvalds 已提交
1098
	if (!entry)
1099
		return -ENODEV;
L
Linus Torvalds 已提交
1100 1101 1102 1103 1104 1105 1106 1107
	else {
		entry->proc_fops = &acpi_thermal_temp_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

	/* 'trip_points' [R/W] */
	entry = create_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
L
Len Brown 已提交
1108 1109
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
1110
	if (!entry)
1111
		return -ENODEV;
L
Linus Torvalds 已提交
1112 1113 1114 1115 1116 1117 1118 1119
	else {
		entry->proc_fops = &acpi_thermal_trip_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

	/* 'cooling_mode' [R/W] */
	entry = create_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
L
Len Brown 已提交
1120 1121
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
1122
	if (!entry)
1123
		return -ENODEV;
L
Linus Torvalds 已提交
1124 1125 1126 1127 1128 1129 1130 1131
	else {
		entry->proc_fops = &acpi_thermal_cooling_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

	/* 'polling_frequency' [R/W] */
	entry = create_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
L
Len Brown 已提交
1132 1133
				  S_IFREG | S_IRUGO | S_IWUSR,
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
1134
	if (!entry)
1135
		return -ENODEV;
L
Linus Torvalds 已提交
1136 1137 1138 1139 1140 1141
	else {
		entry->proc_fops = &acpi_thermal_polling_fops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

1142
	return 0;
L
Linus Torvalds 已提交
1143 1144
}

L
Len Brown 已提交
1145
static int acpi_thermal_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
{

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

1163
	return 0;
L
Linus Torvalds 已提交
1164 1165 1166 1167 1168 1169
}

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

L
Len Brown 已提交
1170
static void acpi_thermal_notify(acpi_handle handle, u32 event, void *data)
L
Linus Torvalds 已提交
1171
{
1172
	struct acpi_thermal *tz = data;
L
Len Brown 已提交
1173
	struct acpi_device *device = NULL;
L
Linus Torvalds 已提交
1174 1175 1176


	if (!tz)
1177
		return;
L
Linus Torvalds 已提交
1178

1179
	device = tz->device;
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196

	switch (event) {
	case ACPI_THERMAL_NOTIFY_TEMPERATURE:
		acpi_thermal_check(tz);
		break;
	case ACPI_THERMAL_NOTIFY_THRESHOLDS:
		acpi_thermal_get_trip_points(tz);
		acpi_thermal_check(tz);
		acpi_bus_generate_event(device, event, 0);
		break;
	case ACPI_THERMAL_NOTIFY_DEVICES:
		if (tz->flags.devices)
			acpi_thermal_get_devices(tz);
		acpi_bus_generate_event(device, event, 0);
		break;
	default:
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
L
Len Brown 已提交
1197
				  "Unsupported event [0x%x]\n", event));
L
Linus Torvalds 已提交
1198 1199 1200
		break;
	}

1201
	return;
L
Linus Torvalds 已提交
1202 1203
}

L
Len Brown 已提交
1204
static int acpi_thermal_get_info(struct acpi_thermal *tz)
L
Linus Torvalds 已提交
1205
{
L
Len Brown 已提交
1206
	int result = 0;
L
Linus Torvalds 已提交
1207 1208 1209


	if (!tz)
1210
		return -EINVAL;
L
Linus Torvalds 已提交
1211 1212 1213 1214

	/* Get temperature [_TMP] (required) */
	result = acpi_thermal_get_temperature(tz);
	if (result)
1215
		return result;
L
Linus Torvalds 已提交
1216 1217 1218 1219

	/* Get trip points [_CRT, _PSV, etc.] (required) */
	result = acpi_thermal_get_trip_points(tz);
	if (result)
1220
		return result;
L
Linus Torvalds 已提交
1221 1222 1223

	/* Set the cooling mode [_SCP] to active cooling (default) */
	result = acpi_thermal_set_cooling_mode(tz, ACPI_THERMAL_MODE_ACTIVE);
L
Len Brown 已提交
1224
	if (!result)
L
Linus Torvalds 已提交
1225
		tz->flags.cooling_mode = 1;
L
Len Brown 已提交
1226
	else {
L
Linus Torvalds 已提交
1227
		/* Oh,we have not _SCP method.
L
Len Brown 已提交
1228
		   Generally show cooling_mode by _ACx, _PSV,spec 12.2 */
L
Linus Torvalds 已提交
1229
		tz->flags.cooling_mode = 0;
L
Len Brown 已提交
1230 1231 1232 1233
		if (tz->trips.active[0].flags.valid
		    && tz->trips.passive.flags.valid) {
			if (tz->trips.passive.temperature >
			    tz->trips.active[0].temperature)
L
Linus Torvalds 已提交
1234
				tz->cooling_mode = ACPI_THERMAL_MODE_ACTIVE;
L
Len Brown 已提交
1235
			else
L
Linus Torvalds 已提交
1236
				tz->cooling_mode = ACPI_THERMAL_MODE_PASSIVE;
L
Len Brown 已提交
1237 1238
		} else if (!tz->trips.active[0].flags.valid
			   && tz->trips.passive.flags.valid) {
L
Linus Torvalds 已提交
1239
			tz->cooling_mode = ACPI_THERMAL_MODE_PASSIVE;
L
Len Brown 已提交
1240 1241
		} else if (tz->trips.active[0].flags.valid
			   && !tz->trips.passive.flags.valid) {
L
Linus Torvalds 已提交
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
			tz->cooling_mode = ACPI_THERMAL_MODE_ACTIVE;
		} else {
			/* _ACx and _PSV are optional, but _CRT is required */
			tz->cooling_mode = ACPI_THERMAL_MODE_CRITICAL;
		}
	}

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

	/* Get devices in this thermal zone [_TZD] (optional) */
	result = acpi_thermal_get_devices(tz);
	if (!result)
		tz->flags.devices = 1;

1260
	return 0;
L
Linus Torvalds 已提交
1261 1262
}

L
Len Brown 已提交
1263
static int acpi_thermal_add(struct acpi_device *device)
L
Linus Torvalds 已提交
1264
{
L
Len Brown 已提交
1265 1266 1267
	int result = 0;
	acpi_status status = AE_OK;
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1268 1269 1270


	if (!device)
1271
		return -EINVAL;
L
Linus Torvalds 已提交
1272

1273
	tz = kzalloc(sizeof(struct acpi_thermal), GFP_KERNEL);
L
Linus Torvalds 已提交
1274
	if (!tz)
1275
		return -ENOMEM;
L
Linus Torvalds 已提交
1276

1277
	tz->device = device;
L
Linus Torvalds 已提交
1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
	strcpy(tz->name, device->pnp.bus_id);
	strcpy(acpi_device_name(device), ACPI_THERMAL_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_THERMAL_CLASS);
	acpi_driver_data(device) = tz;

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

	result = acpi_thermal_add_fs(device);
	if (result)
1289
		goto end;
L
Linus Torvalds 已提交
1290 1291 1292 1293 1294

	init_timer(&tz->timer);

	acpi_thermal_check(tz);

1295
	status = acpi_install_notify_handler(device->handle,
L
Len Brown 已提交
1296 1297
					     ACPI_DEVICE_NOTIFY,
					     acpi_thermal_notify, tz);
L
Linus Torvalds 已提交
1298 1299 1300 1301 1302 1303
	if (ACPI_FAILURE(status)) {
		result = -ENODEV;
		goto end;
	}

	printk(KERN_INFO PREFIX "%s [%s] (%ld C)\n",
L
Len Brown 已提交
1304 1305
	       acpi_device_name(device), acpi_device_bid(device),
	       KELVIN_TO_CELSIUS(tz->temperature));
L
Linus Torvalds 已提交
1306

L
Len Brown 已提交
1307
      end:
L
Linus Torvalds 已提交
1308 1309 1310 1311 1312
	if (result) {
		acpi_thermal_remove_fs(device);
		kfree(tz);
	}

1313
	return result;
L
Linus Torvalds 已提交
1314 1315
}

L
Len Brown 已提交
1316
static int acpi_thermal_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
1317
{
L
Len Brown 已提交
1318 1319
	acpi_status status = AE_OK;
	struct acpi_thermal *tz = NULL;
L
Linus Torvalds 已提交
1320 1321 1322


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

1325
	tz = acpi_driver_data(device);
L
Linus Torvalds 已提交
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335

	/* avoid timer adding new defer task */
	tz->zombie = 1;
	/* wait for running timer (on other CPUs) finish */
	del_timer_sync(&(tz->timer));
	/* synchronize deferred task */
	acpi_os_wait_events_complete(NULL);
	/* deferred task may reinsert timer */
	del_timer_sync(&(tz->timer));

1336
	status = acpi_remove_notify_handler(device->handle,
L
Len Brown 已提交
1337 1338
					    ACPI_DEVICE_NOTIFY,
					    acpi_thermal_notify);
L
Linus Torvalds 已提交
1339 1340

	/* Terminate policy */
L
Len Brown 已提交
1341
	if (tz->trips.passive.flags.valid && tz->trips.passive.flags.enabled) {
L
Linus Torvalds 已提交
1342 1343 1344 1345
		tz->trips.passive.flags.enabled = 0;
		acpi_thermal_passive(tz);
	}
	if (tz->trips.active[0].flags.valid
L
Len Brown 已提交
1346
	    && tz->trips.active[0].flags.enabled) {
L
Linus Torvalds 已提交
1347 1348 1349 1350 1351 1352 1353
		tz->trips.active[0].flags.enabled = 0;
		acpi_thermal_active(tz);
	}

	acpi_thermal_remove_fs(device);

	kfree(tz);
1354
	return 0;
L
Linus Torvalds 已提交
1355 1356
}

1357
static int acpi_thermal_resume(struct acpi_device *device)
1358 1359
{
	struct acpi_thermal *tz = NULL;
1360
	int i;
1361 1362

	if (!device || !acpi_driver_data(device))
1363
		return -EINVAL;
1364

1365
	tz = acpi_driver_data(device);
1366

1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
	acpi_thermal_get_temperature(tz);

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

			acpi_thermal_active(tz);

			tz->state.active |= tz->trips.active[i].flags.enabled;
			tz->state.active_index = i;
		}
	}

 	acpi_thermal_check(tz);
1382 1383 1384 1385

	return AE_OK;
}

L
Len Brown 已提交
1386
static int __init acpi_thermal_init(void)
L
Linus Torvalds 已提交
1387
{
L
Len Brown 已提交
1388
	int result = 0;
L
Linus Torvalds 已提交
1389 1390 1391 1392


	acpi_thermal_dir = proc_mkdir(ACPI_THERMAL_CLASS, acpi_root_dir);
	if (!acpi_thermal_dir)
1393
		return -ENODEV;
L
Linus Torvalds 已提交
1394 1395 1396 1397 1398
	acpi_thermal_dir->owner = THIS_MODULE;

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

1402
	return 0;
L
Linus Torvalds 已提交
1403 1404
}

L
Len Brown 已提交
1405
static void __exit acpi_thermal_exit(void)
L
Linus Torvalds 已提交
1406 1407 1408 1409 1410 1411
{

	acpi_bus_unregister_driver(&acpi_thermal_driver);

	remove_proc_entry(ACPI_THERMAL_CLASS, acpi_root_dir);

1412
	return;
L
Linus Torvalds 已提交
1413 1414 1415 1416
}

module_init(acpi_thermal_init);
module_exit(acpi_thermal_exit);