[linux.git] / drivers / acpi / processor_thermal.c

/*
 * processor_thermal.c - Passive cooling submodule of the ACPI processor driver
 *
 *  Copyright (C) 2001, 2002 Andy Grover <[email protected]>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <[email protected]>
 *  Copyright (C) 2004       Dominik Brodowski <[email protected]>
 *  Copyright (C) 2004  Anil S Keshavamurthy <[email protected]>
 *  			- Added processor hotplug support
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  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.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/cpufreq.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/sysdev.h>

#include <asm/uaccess.h>

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

#define PREFIX "ACPI: "

#define ACPI_PROCESSOR_CLASS            "processor"
#define _COMPONENT              ACPI_PROCESSOR_COMPONENT
ACPI_MODULE_NAME("processor_thermal");

/* --------------------------------------------------------------------------
                                 Limit Interface
   -------------------------------------------------------------------------- */
static int acpi_processor_apply_limit(struct acpi_processor *pr)
{
	int result = 0;
	u16 px = 0;
	u16 tx = 0;


	if (!pr)
		return -EINVAL;

	if (!pr->flags.limit)
		return -ENODEV;

	if (pr->flags.throttling) {
		if (pr->limit.user.tx > tx)
			tx = pr->limit.user.tx;
		if (pr->limit.thermal.tx > tx)
			tx = pr->limit.thermal.tx;

		result = acpi_processor_set_throttling(pr, tx, false);
		if (result)
			goto end;
	}

	pr->limit.state.px = px;
	pr->limit.state.tx = tx;

	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "Processor [%d] limit set to (P%d:T%d)\n", pr->id,
			  pr->limit.state.px, pr->limit.state.tx));

      end:
	if (result)
		printk(KERN_ERR PREFIX "Unable to set limit\n");

	return result;
}

#ifdef CONFIG_CPU_FREQ

/* If a passive cooling situation is detected, primarily CPUfreq is used, as it
 * offers (in most cases) voltage scaling in addition to frequency scaling, and
 * thus a cubic (instead of linear) reduction of energy. Also, we allow for
 * _any_ cpufreq driver and not only the acpi-cpufreq driver.
 */

#define CPUFREQ_THERMAL_MIN_STEP 0
#define CPUFREQ_THERMAL_MAX_STEP 3

static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_pctg);
static unsigned int acpi_thermal_cpufreq_is_init = 0;

static int cpu_has_cpufreq(unsigned int cpu)
{
	struct cpufreq_policy policy;
	if (!acpi_thermal_cpufreq_is_init || cpufreq_get_policy(&policy, cpu))
		return 0;
	return 1;
}

static int acpi_thermal_cpufreq_increase(unsigned int cpu)
{
	if (!cpu_has_cpufreq(cpu))
		return -ENODEV;

	if (per_cpu(cpufreq_thermal_reduction_pctg, cpu) <
		CPUFREQ_THERMAL_MAX_STEP) {
		per_cpu(cpufreq_thermal_reduction_pctg, cpu)++;
		cpufreq_update_policy(cpu);
		return 0;
	}

	return -ERANGE;
}

static int acpi_thermal_cpufreq_decrease(unsigned int cpu)
{
	if (!cpu_has_cpufreq(cpu))
		return -ENODEV;

	if (per_cpu(cpufreq_thermal_reduction_pctg, cpu) >
		(CPUFREQ_THERMAL_MIN_STEP + 1))
		per_cpu(cpufreq_thermal_reduction_pctg, cpu)--;
	else
		per_cpu(cpufreq_thermal_reduction_pctg, cpu) = 0;
	cpufreq_update_policy(cpu);
	/* We reached max freq again and can leave passive mode */
	return !per_cpu(cpufreq_thermal_reduction_pctg, cpu);
}

static int acpi_thermal_cpufreq_notifier(struct notifier_block *nb,
					 unsigned long event, void *data)
{
	struct cpufreq_policy *policy = data;
	unsigned long max_freq = 0;

	if (event != CPUFREQ_ADJUST)
		goto out;

	max_freq = (
	    policy->cpuinfo.max_freq *
	    (100 - per_cpu(cpufreq_thermal_reduction_pctg, policy->cpu) * 20)
	) / 100;

	cpufreq_verify_within_limits(policy, 0, max_freq);

      out:
	return 0;
}

static struct notifier_block acpi_thermal_cpufreq_notifier_block = {
	.notifier_call = acpi_thermal_cpufreq_notifier,
};

static int cpufreq_get_max_state(unsigned int cpu)
{
	if (!cpu_has_cpufreq(cpu))
		return 0;

	return CPUFREQ_THERMAL_MAX_STEP;
}

static int cpufreq_get_cur_state(unsigned int cpu)
{
	if (!cpu_has_cpufreq(cpu))
		return 0;

	return per_cpu(cpufreq_thermal_reduction_pctg, cpu);
}

static int cpufreq_set_cur_state(unsigned int cpu, int state)
{
	if (!cpu_has_cpufreq(cpu))
		return 0;

	per_cpu(cpufreq_thermal_reduction_pctg, cpu) = state;
	cpufreq_update_policy(cpu);
	return 0;
}

void acpi_thermal_cpufreq_init(void)
{
	int i;

	for (i = 0; i < nr_cpu_ids; i++)
		if (cpu_present(i))
			per_cpu(cpufreq_thermal_reduction_pctg, i) = 0;

	i = cpufreq_register_notifier(&acpi_thermal_cpufreq_notifier_block,
				      CPUFREQ_POLICY_NOTIFIER);
	if (!i)
		acpi_thermal_cpufreq_is_init = 1;
}

void acpi_thermal_cpufreq_exit(void)
{
	if (acpi_thermal_cpufreq_is_init)
		cpufreq_unregister_notifier
		    (&acpi_thermal_cpufreq_notifier_block,
		     CPUFREQ_POLICY_NOTIFIER);

	acpi_thermal_cpufreq_is_init = 0;
}

#else				/* ! CONFIG_CPU_FREQ */
static int cpufreq_get_max_state(unsigned int cpu)
{
	return 0;
}

static int cpufreq_get_cur_state(unsigned int cpu)
{
	return 0;
}

static int cpufreq_set_cur_state(unsigned int cpu, int state)
{
	return 0;
}

static int acpi_thermal_cpufreq_increase(unsigned int cpu)
{
	return -ENODEV;
}
static int acpi_thermal_cpufreq_decrease(unsigned int cpu)
{
	return -ENODEV;
}

#endif

int acpi_processor_set_thermal_limit(acpi_handle handle, int type)
{
	int result = 0;
	struct acpi_processor *pr = NULL;
	struct acpi_device *device = NULL;
	int tx = 0, max_tx_px = 0;


	if ((type < ACPI_PROCESSOR_LIMIT_NONE)
	    || (type > ACPI_PROCESSOR_LIMIT_DECREMENT))
		return -EINVAL;

	result = acpi_bus_get_device(handle, &device);
	if (result)
		return result;

	pr = acpi_driver_data(device);
	if (!pr)
		return -ENODEV;

	/* Thermal limits are always relative to the current Px/Tx state. */
	if (pr->flags.throttling)
		pr->limit.thermal.tx = pr->throttling.state;

	/*
	 * Our default policy is to only use throttling at the lowest
	 * performance state.
	 */

	tx = pr->limit.thermal.tx;

	switch (type) {

	case ACPI_PROCESSOR_LIMIT_NONE:
		do {
			result = acpi_thermal_cpufreq_decrease(pr->id);
		} while (!result);
		tx = 0;
		break;

	case ACPI_PROCESSOR_LIMIT_INCREMENT:
		/* if going up: P-states first, T-states later */

		result = acpi_thermal_cpufreq_increase(pr->id);
		if (!result)
			goto end;
		else if (result == -ERANGE)
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "At maximum performance state\n"));

		if (pr->flags.throttling) {
			if (tx == (pr->throttling.state_count - 1))
				ACPI_DEBUG_PRINT((ACPI_DB_INFO,
						  "At maximum throttling state\n"));
			else
				tx++;
		}
		break;

	case ACPI_PROCESSOR_LIMIT_DECREMENT:
		/* if going down: T-states first, P-states later */

		if (pr->flags.throttling) {
			if (tx == 0) {
				max_tx_px = 1;
				ACPI_DEBUG_PRINT((ACPI_DB_INFO,
						  "At minimum throttling state\n"));
			} else {
				tx--;
				goto end;
			}
		}

		result = acpi_thermal_cpufreq_decrease(pr->id);
		if (result) {
			/*
			 * We only could get -ERANGE, 1 or 0.
			 * In the first two cases we reached max freq again.
			 */
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "At minimum performance state\n"));
			max_tx_px = 1;
		} else
			max_tx_px = 0;

		break;
	}

      end:
	if (pr->flags.throttling) {
		pr->limit.thermal.px = 0;
		pr->limit.thermal.tx = tx;

		result = acpi_processor_apply_limit(pr);
		if (result)
			printk(KERN_ERR PREFIX "Unable to set thermal limit\n");

		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Thermal limit now (P%d:T%d)\n",
				  pr->limit.thermal.px, pr->limit.thermal.tx));
	} else
		result = 0;
	if (max_tx_px)
		return 1;
	else
		return result;
}

int acpi_processor_get_limit_info(struct acpi_processor *pr)
{

	if (!pr)
		return -EINVAL;

	if (pr->flags.throttling)
		pr->flags.limit = 1;

	return 0;
}

/* thermal coolign device callbacks */
static int acpi_processor_max_state(struct acpi_processor *pr)
{
	int max_state = 0;

	/*
	 * There exists four states according to
	 * cpufreq_thermal_reduction_ptg. 0, 1, 2, 3
	 */
	max_state += cpufreq_get_max_state(pr->id);
	if (pr->flags.throttling)
		max_state += (pr->throttling.state_count -1);

	return max_state;
}
static int
processor_get_max_state(struct thermal_cooling_device *cdev,
			unsigned long *state)
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_processor *pr = acpi_driver_data(device);

	if (!device || !pr)
		return -EINVAL;

	*state = acpi_processor_max_state(pr);
	return 0;
}

static int
processor_get_cur_state(struct thermal_cooling_device *cdev,
			unsigned long *cur_state)
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_processor *pr = acpi_driver_data(device);

	if (!device || !pr)
		return -EINVAL;

	*cur_state = cpufreq_get_cur_state(pr->id);
	if (pr->flags.throttling)
		*cur_state += pr->throttling.state;
	return 0;
}

static int
processor_set_cur_state(struct thermal_cooling_device *cdev,
			unsigned long state)
{
	struct acpi_device *device = cdev->devdata;
	struct acpi_processor *pr = acpi_driver_data(device);
	int result = 0;
	int max_pstate;

	if (!device || !pr)
		return -EINVAL;

	max_pstate = cpufreq_get_max_state(pr->id);

	if (state > acpi_processor_max_state(pr))
		return -EINVAL;

	if (state <= max_pstate) {
		if (pr->flags.throttling && pr->throttling.state)
			result = acpi_processor_set_throttling(pr, 0, false);
		cpufreq_set_cur_state(pr->id, state);
	} else {
		cpufreq_set_cur_state(pr->id, max_pstate);
		result = acpi_processor_set_throttling(pr,
				state - max_pstate, false);
	}
	return result;
}

struct thermal_cooling_device_ops processor_cooling_ops = {
	.get_max_state = processor_get_max_state,
	.get_cur_state = processor_get_cur_state,
	.set_cur_state = processor_set_cur_state,
};

/* /proc interface */
#ifdef CONFIG_ACPI_PROCFS
static int acpi_processor_limit_seq_show(struct seq_file *seq, void *offset)
{
	struct acpi_processor *pr = seq->private;

	if (!pr)
		goto end;

	if (!pr->flags.limit) {
		seq_puts(seq, "<not supported>\n");
		goto end;
	}

	seq_printf(seq, "active limit:            P%d:T%d\n"
		   "user limit:              P%d:T%d\n"
		   "thermal limit:           P%d:T%d\n",
		   pr->limit.state.px, pr->limit.state.tx,
		   pr->limit.user.px, pr->limit.user.tx,
		   pr->limit.thermal.px, pr->limit.thermal.tx);

      end:
	return 0;
}

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

static ssize_t acpi_processor_write_limit(struct file * file,
					  const char __user * buffer,
					  size_t count, loff_t * data)
{
	int result = 0;
	struct seq_file *m = file->private_data;
	struct acpi_processor *pr = m->private;
	char limit_string[25] = { '\0' };
	int px = 0;
	int tx = 0;


	if (!pr || (count > sizeof(limit_string) - 1)) {
		return -EINVAL;
	}

	if (copy_from_user(limit_string, buffer, count)) {
		return -EFAULT;
	}

	limit_string[count] = '\0';

	if (sscanf(limit_string, "%d:%d", &px, &tx) != 2) {
		printk(KERN_ERR PREFIX "Invalid data format\n");
		return -EINVAL;
	}

	if (pr->flags.throttling) {
		if ((tx < 0) || (tx > (pr->throttling.state_count - 1))) {
			printk(KERN_ERR PREFIX "Invalid tx\n");
			return -EINVAL;
		}
		pr->limit.user.tx = tx;
	}

	result = acpi_processor_apply_limit(pr);

	return count;
}

const struct file_operations acpi_processor_limit_fops = {
	.owner = THIS_MODULE,
	.open = acpi_processor_limit_open_fs,
	.read = seq_read,
	.write = acpi_processor_write_limit,
	.llseek = seq_lseek,
	.release = single_release,
};
#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* processor_thermal.c - Passive cooling submodule of the ACPI processor driver
	3	*
	4	* Copyright (C) 2001, 2002 Andy Grover <[email protected]>
	5	* Copyright (C) 2001, 2002 Paul Diefenbaugh <[email protected]>
	6	* Copyright (C) 2004 Dominik Brodowski <[email protected]>
	7	* Copyright (C) 2004 Anil S Keshavamurthy <[email protected]>
	8	* - Added processor hotplug support
	9	*
	10	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	11	*
	12	* This program is free software; you can redistribute it and/or modify
	13	* it under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; either version 2 of the License, or (at
	15	* your option) any later version.
	16	*
	17	* This program is distributed in the hope that it will be useful, but
	18	* WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	20	* General Public License for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License along
	23	* with this program; if not, write to the Free Software Foundation, Inc.,
	24	* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
	25	*
	26	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	27	*/
	28
	29	#include <linux/kernel.h>
	30	#include <linux/module.h>
	31	#include <linux/init.h>
	32	#include <linux/cpufreq.h>
	33	#include <linux/proc_fs.h>
	34	#include <linux/seq_file.h>
d9460fd2	35	#include <linux/sysdev.h>
1da177e4 LT	36
	37	#include <asm/uaccess.h>
	38
	39	#include <acpi/acpi_bus.h>
	40	#include <acpi/processor.h>
	41	#include <acpi/acpi_drivers.h>
	42
a192a958 LB	43	#define PREFIX "ACPI: "
a192a958 LB	44
1da177e4	45	#define ACPI_PROCESSOR_CLASS "processor"
1da177e4	46	#define _COMPONENT ACPI_PROCESSOR_COMPONENT
f52fd66d	47	ACPI_MODULE_NAME("processor_thermal");
1da177e4 LT	48
	49	/* --------------------------------------------------------------------------
	50	Limit Interface
	51	-------------------------------------------------------------------------- */
4be44fcd	52	static int acpi_processor_apply_limit(struct acpi_processor *pr)
1da177e4	53	{
4be44fcd LB	54	int result = 0;
	55	u16 px = 0;
	56	u16 tx = 0;
1da177e4	57
1da177e4 LT	58
1da177e4 LT	59	if (!pr)
d550d98d	60	return -EINVAL;
1da177e4 LT	61
1da177e4 LT	62	if (!pr->flags.limit)
d550d98d	63	return -ENODEV;
1da177e4 LT	64
	65	if (pr->flags.throttling) {
	66	if (pr->limit.user.tx > tx)
	67	tx = pr->limit.user.tx;
	68	if (pr->limit.thermal.tx > tx)
	69	tx = pr->limit.thermal.tx;
	70
2a908002	71	result = acpi_processor_set_throttling(pr, tx, false);
1da177e4 LT	72	if (result)
	73	goto end;
	74	}
	75
	76	pr->limit.state.px = px;
	77	pr->limit.state.tx = tx;
	78
4be44fcd LB	79	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
	80	"Processor [%d] limit set to (P%d:T%d)\n", pr->id,
	81	pr->limit.state.px, pr->limit.state.tx));
1da177e4	82
4be44fcd	83	end:
1da177e4	84	if (result)
6468463a	85	printk(KERN_ERR PREFIX "Unable to set limit\n");
1da177e4	86
d550d98d	87	return result;
1da177e4 LT	88	}
1da177e4 LT	89
1da177e4 LT	90	#ifdef CONFIG_CPU_FREQ
	91
	92	/* If a passive cooling situation is detected, primarily CPUfreq is used, as it
	93	* offers (in most cases) voltage scaling in addition to frequency scaling, and
	94	* thus a cubic (instead of linear) reduction of energy. Also, we allow for
	95	* _any_ cpufreq driver and not only the acpi-cpufreq driver.
	96	*/
	97
d9460fd2 ZR	98	#define CPUFREQ_THERMAL_MIN_STEP 0
	99	#define CPUFREQ_THERMAL_MAX_STEP 3
	100
c938ac21	101	static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_pctg);
1da177e4 LT	102	static unsigned int acpi_thermal_cpufreq_is_init = 0;
1da177e4 LT	103
1da177e4 LT	104	static int cpu_has_cpufreq(unsigned int cpu)
	105	{
	106	struct cpufreq_policy policy;
1cbf4c56	107	if (!acpi_thermal_cpufreq_is_init \|\| cpufreq_get_policy(&policy, cpu))
75b245b3 TR	108	return 0;
75b245b3 TR	109	return 1;
1da177e4 LT	110	}
1da177e4 LT	111
1da177e4 LT	112	static int acpi_thermal_cpufreq_increase(unsigned int cpu)
	113	{
	114	if (!cpu_has_cpufreq(cpu))
	115	return -ENODEV;
	116
c938ac21	117	if (per_cpu(cpufreq_thermal_reduction_pctg, cpu) <
d9460fd2	118	CPUFREQ_THERMAL_MAX_STEP) {
c938ac21	119	per_cpu(cpufreq_thermal_reduction_pctg, cpu)++;
1da177e4 LT	120	cpufreq_update_policy(cpu);
	121	return 0;
	122	}
	123
	124	return -ERANGE;
	125	}
	126
1da177e4 LT	127	static int acpi_thermal_cpufreq_decrease(unsigned int cpu)
	128	{
	129	if (!cpu_has_cpufreq(cpu))
	130	return -ENODEV;
	131
c938ac21	132	if (per_cpu(cpufreq_thermal_reduction_pctg, cpu) >
d9460fd2	133	(CPUFREQ_THERMAL_MIN_STEP + 1))
c938ac21	134	per_cpu(cpufreq_thermal_reduction_pctg, cpu)--;
1cbf4c56	135	else
c938ac21	136	per_cpu(cpufreq_thermal_reduction_pctg, cpu) = 0;
1cbf4c56 TR	137	cpufreq_update_policy(cpu);
1cbf4c56 TR	138	/* We reached max freq again and can leave passive mode */
c938ac21	139	return !per_cpu(cpufreq_thermal_reduction_pctg, cpu);
1da177e4 LT	140	}
1da177e4 LT	141
4be44fcd LB	142	static int acpi_thermal_cpufreq_notifier(struct notifier_block *nb,
4be44fcd LB	143	unsigned long event, void *data)
1da177e4 LT	144	{
	145	struct cpufreq_policy *policy = data;
	146	unsigned long max_freq = 0;
	147
	148	if (event != CPUFREQ_ADJUST)
	149	goto out;
	150
c938ac21 MT	151	max_freq = (
	152	policy->cpuinfo.max_freq *
	153	(100 - per_cpu(cpufreq_thermal_reduction_pctg, policy->cpu) * 20)
	154	) / 100;
1da177e4 LT	155
	156	cpufreq_verify_within_limits(policy, 0, max_freq);
	157
4be44fcd	158	out:
1da177e4 LT	159	return 0;
	160	}
	161
1da177e4 LT	162	static struct notifier_block acpi_thermal_cpufreq_notifier_block = {
	163	.notifier_call = acpi_thermal_cpufreq_notifier,
	164	};
	165
d9460fd2 ZR	166	static int cpufreq_get_max_state(unsigned int cpu)
	167	{
	168	if (!cpu_has_cpufreq(cpu))
	169	return 0;
	170
	171	return CPUFREQ_THERMAL_MAX_STEP;
	172	}
	173
	174	static int cpufreq_get_cur_state(unsigned int cpu)
	175	{
	176	if (!cpu_has_cpufreq(cpu))
	177	return 0;
	178
c938ac21	179	return per_cpu(cpufreq_thermal_reduction_pctg, cpu);
d9460fd2 ZR	180	}
	181
	182	static int cpufreq_set_cur_state(unsigned int cpu, int state)
	183	{
	184	if (!cpu_has_cpufreq(cpu))
	185	return 0;
	186
c938ac21	187	per_cpu(cpufreq_thermal_reduction_pctg, cpu) = state;
d9460fd2 ZR	188	cpufreq_update_policy(cpu);
	189	return 0;
	190	}
	191
4be44fcd LB	192	void acpi_thermal_cpufreq_init(void)
4be44fcd LB	193	{
1da177e4 LT	194	int i;
1da177e4 LT	195
c938ac21 MT	196	for (i = 0; i < nr_cpu_ids; i++)
	197	if (cpu_present(i))
	198	per_cpu(cpufreq_thermal_reduction_pctg, i) = 0;
1da177e4	199
4be44fcd LB	200	i = cpufreq_register_notifier(&acpi_thermal_cpufreq_notifier_block,
4be44fcd LB	201	CPUFREQ_POLICY_NOTIFIER);
1da177e4 LT	202	if (!i)
	203	acpi_thermal_cpufreq_is_init = 1;
	204	}
	205
4be44fcd LB	206	void acpi_thermal_cpufreq_exit(void)
4be44fcd LB	207	{
1da177e4	208	if (acpi_thermal_cpufreq_is_init)
4be44fcd LB	209	cpufreq_unregister_notifier
	210	(&acpi_thermal_cpufreq_notifier_block,
	211	CPUFREQ_POLICY_NOTIFIER);
1da177e4 LT	212
	213	acpi_thermal_cpufreq_is_init = 0;
	214	}
	215
4be44fcd	216	#else /* ! CONFIG_CPU_FREQ */
d9460fd2 ZR	217	static int cpufreq_get_max_state(unsigned int cpu)
	218	{
	219	return 0;
	220	}
	221
	222	static int cpufreq_get_cur_state(unsigned int cpu)
	223	{
	224	return 0;
	225	}
	226
	227	static int cpufreq_set_cur_state(unsigned int cpu, int state)
	228	{
	229	return 0;
	230	}
1da177e4	231
4be44fcd LB	232	static int acpi_thermal_cpufreq_increase(unsigned int cpu)
	233	{
	234	return -ENODEV;
	235	}
	236	static int acpi_thermal_cpufreq_decrease(unsigned int cpu)
	237	{
	238	return -ENODEV;
	239	}
1da177e4 LT	240
	241	#endif
	242
4be44fcd	243	int acpi_processor_set_thermal_limit(acpi_handle handle, int type)
1da177e4	244	{
4be44fcd LB	245	int result = 0;
	246	struct acpi_processor *pr = NULL;
	247	struct acpi_device *device = NULL;
1cbf4c56	248	int tx = 0, max_tx_px = 0;
1da177e4	249
1da177e4 LT	250
1da177e4 LT	251	if ((type < ACPI_PROCESSOR_LIMIT_NONE)
4be44fcd	252	\|\| (type > ACPI_PROCESSOR_LIMIT_DECREMENT))
d550d98d	253	return -EINVAL;
1da177e4 LT	254
	255	result = acpi_bus_get_device(handle, &device);
	256	if (result)
d550d98d	257	return result;
1da177e4	258
50dd0969	259	pr = acpi_driver_data(device);
1da177e4	260	if (!pr)
d550d98d	261	return -ENODEV;
1da177e4 LT	262
	263	/* Thermal limits are always relative to the current Px/Tx state. */
	264	if (pr->flags.throttling)
	265	pr->limit.thermal.tx = pr->throttling.state;
	266
	267	/*
	268	* Our default policy is to only use throttling at the lowest
	269	* performance state.
	270	*/
	271
	272	tx = pr->limit.thermal.tx;
	273
	274	switch (type) {
	275
	276	case ACPI_PROCESSOR_LIMIT_NONE:
	277	do {
	278	result = acpi_thermal_cpufreq_decrease(pr->id);
	279	} while (!result);
	280	tx = 0;
	281	break;
	282
	283	case ACPI_PROCESSOR_LIMIT_INCREMENT:
	284	/* if going up: P-states first, T-states later */
	285
	286	result = acpi_thermal_cpufreq_increase(pr->id);
	287	if (!result)
	288	goto end;
	289	else if (result == -ERANGE)
	290	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd	291	"At maximum performance state\n"));
1da177e4 LT	292
	293	if (pr->flags.throttling) {
	294	if (tx == (pr->throttling.state_count - 1))
	295	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd	296	"At maximum throttling state\n"));
1da177e4 LT	297	else
	298	tx++;
	299	}
	300	break;
	301
	302	case ACPI_PROCESSOR_LIMIT_DECREMENT:
	303	/* if going down: T-states first, P-states later */
	304
	305	if (pr->flags.throttling) {
1cbf4c56 TR	306	if (tx == 0) {
1cbf4c56 TR	307	max_tx_px = 1;
1da177e4	308	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd	309	"At minimum throttling state\n"));
1cbf4c56	310	} else {
1da177e4 LT	311	tx--;
	312	goto end;
	313	}
	314	}
	315
	316	result = acpi_thermal_cpufreq_decrease(pr->id);
1cbf4c56 TR	317	if (result) {
	318	/*
	319	* We only could get -ERANGE, 1 or 0.
	320	* In the first two cases we reached max freq again.
	321	*/
1da177e4	322	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd	323	"At minimum performance state\n"));
1cbf4c56 TR	324	max_tx_px = 1;
	325	} else
	326	max_tx_px = 0;
1da177e4 LT	327
	328	break;
	329	}
	330
4be44fcd	331	end:
1da177e4 LT	332	if (pr->flags.throttling) {
	333	pr->limit.thermal.px = 0;
	334	pr->limit.thermal.tx = tx;
	335
	336	result = acpi_processor_apply_limit(pr);
	337	if (result)
6468463a	338	printk(KERN_ERR PREFIX "Unable to set thermal limit\n");
1da177e4 LT	339
1da177e4 LT	340	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Thermal limit now (P%d:T%d)\n",
4be44fcd	341	pr->limit.thermal.px, pr->limit.thermal.tx));
1da177e4 LT	342	} else
1da177e4 LT	343	result = 0;
1cbf4c56	344	if (max_tx_px)
d550d98d	345	return 1;
1cbf4c56	346	else
d550d98d	347	return result;
1da177e4 LT	348	}
1da177e4 LT	349
4be44fcd	350	int acpi_processor_get_limit_info(struct acpi_processor *pr)
1da177e4	351	{
1da177e4 LT	352
1da177e4 LT	353	if (!pr)
d550d98d	354	return -EINVAL;
1da177e4 LT	355
	356	if (pr->flags.throttling)
	357	pr->flags.limit = 1;
	358
d550d98d	359	return 0;
1da177e4 LT	360	}
1da177e4 LT	361
d9460fd2 ZR	362	/* thermal coolign device callbacks */
	363	static int acpi_processor_max_state(struct acpi_processor *pr)
	364	{
	365	int max_state = 0;
	366
	367	/*
	368	* There exists four states according to
	369	* cpufreq_thermal_reduction_ptg. 0, 1, 2, 3
	370	*/
	371	max_state += cpufreq_get_max_state(pr->id);
	372	if (pr->flags.throttling)
	373	max_state += (pr->throttling.state_count -1);
	374
	375	return max_state;
	376	}
	377	static int
6503e5df MG	378	processor_get_max_state(struct thermal_cooling_device *cdev,
6503e5df MG	379	unsigned long *state)
d9460fd2 ZR	380	{
	381	struct acpi_device *device = cdev->devdata;
	382	struct acpi_processor *pr = acpi_driver_data(device);
	383
	384	if (!device \|\| !pr)
	385	return -EINVAL;
	386
6503e5df MG	387	*state = acpi_processor_max_state(pr);
6503e5df MG	388	return 0;
d9460fd2 ZR	389	}
	390
	391	static int
6503e5df MG	392	processor_get_cur_state(struct thermal_cooling_device *cdev,
6503e5df MG	393	unsigned long *cur_state)
d9460fd2 ZR	394	{
	395	struct acpi_device *device = cdev->devdata;
	396	struct acpi_processor *pr = acpi_driver_data(device);
d9460fd2 ZR	397
	398	if (!device \|\| !pr)
	399	return -EINVAL;
	400
6503e5df	401	*cur_state = cpufreq_get_cur_state(pr->id);
d9460fd2	402	if (pr->flags.throttling)
6503e5df MG	403	*cur_state += pr->throttling.state;
6503e5df MG	404	return 0;
d9460fd2 ZR	405	}
	406
	407	static int
6503e5df MG	408	processor_set_cur_state(struct thermal_cooling_device *cdev,
6503e5df MG	409	unsigned long state)
d9460fd2 ZR	410	{
	411	struct acpi_device *device = cdev->devdata;
	412	struct acpi_processor *pr = acpi_driver_data(device);
	413	int result = 0;
	414	int max_pstate;
	415
	416	if (!device \|\| !pr)
	417	return -EINVAL;
	418
	419	max_pstate = cpufreq_get_max_state(pr->id);
	420
	421	if (state > acpi_processor_max_state(pr))
	422	return -EINVAL;
	423
	424	if (state <= max_pstate) {
	425	if (pr->flags.throttling && pr->throttling.state)
2a908002	426	result = acpi_processor_set_throttling(pr, 0, false);
d9460fd2 ZR	427	cpufreq_set_cur_state(pr->id, state);
	428	} else {
	429	cpufreq_set_cur_state(pr->id, max_pstate);
	430	result = acpi_processor_set_throttling(pr,
2a908002	431	state - max_pstate, false);
d9460fd2 ZR	432	}
	433	return result;
	434	}
	435
	436	struct thermal_cooling_device_ops processor_cooling_ops = {
	437	.get_max_state = processor_get_max_state,
	438	.get_cur_state = processor_get_cur_state,
	439	.set_cur_state = processor_set_cur_state,
	440	};
	441
1da177e4	442	/* /proc interface */
74cad4ee	443	#ifdef CONFIG_ACPI_PROCFS
1da177e4 LT	444	static int acpi_processor_limit_seq_show(struct seq_file seq, void offset)
1da177e4 LT	445	{
070a24f4	446	struct acpi_processor *pr = seq->private;
1da177e4 LT	447
	448	if (!pr)
	449	goto end;
	450
	451	if (!pr->flags.limit) {
	452	seq_puts(seq, "<not supported>\n");
	453	goto end;
	454	}
	455
	456	seq_printf(seq, "active limit: P%d:T%d\n"
4be44fcd LB	457	"user limit: P%d:T%d\n"
	458	"thermal limit: P%d:T%d\n",
	459	pr->limit.state.px, pr->limit.state.tx,
	460	pr->limit.user.px, pr->limit.user.tx,
	461	pr->limit.thermal.px, pr->limit.thermal.tx);
1da177e4	462
4be44fcd	463	end:
d550d98d	464	return 0;
1da177e4 LT	465	}
	466
	467	static int acpi_processor_limit_open_fs(struct inode inode, struct file file)
	468	{
	469	return single_open(file, acpi_processor_limit_seq_show,
4be44fcd	470	PDE(inode)->data);
1da177e4 LT	471	}
1da177e4 LT	472
757b1866 AB	473	static ssize_t acpi_processor_write_limit(struct file * file,
	474	const char __user * buffer,
	475	size_t count, loff_t * data)
1da177e4	476	{
4be44fcd	477	int result = 0;
50dd0969 JE	478	struct seq_file *m = file->private_data;
50dd0969 JE	479	struct acpi_processor *pr = m->private;
4be44fcd LB	480	char limit_string[25] = { '\0' };
	481	int px = 0;
	482	int tx = 0;
1da177e4	483
1da177e4 LT	484
1da177e4 LT	485	if (!pr \|\| (count > sizeof(limit_string) - 1)) {
d550d98d	486	return -EINVAL;
1da177e4 LT	487	}
	488
	489	if (copy_from_user(limit_string, buffer, count)) {
d550d98d	490	return -EFAULT;
1da177e4 LT	491	}
	492
	493	limit_string[count] = '\0';
	494
	495	if (sscanf(limit_string, "%d:%d", &px, &tx) != 2) {
6468463a	496	printk(KERN_ERR PREFIX "Invalid data format\n");
d550d98d	497	return -EINVAL;
1da177e4 LT	498	}
	499
	500	if (pr->flags.throttling) {
	501	if ((tx < 0) \|\| (tx > (pr->throttling.state_count - 1))) {
6468463a	502	printk(KERN_ERR PREFIX "Invalid tx\n");
d550d98d	503	return -EINVAL;
1da177e4 LT	504	}
	505	pr->limit.user.tx = tx;
	506	}
	507
	508	result = acpi_processor_apply_limit(pr);
	509
d550d98d	510	return count;
1da177e4 LT	511	}
1da177e4 LT	512
070d8eb1	513	const struct file_operations acpi_processor_limit_fops = {
cf7acfab	514	.owner = THIS_MODULE,
4be44fcd LB	515	.open = acpi_processor_limit_open_fs,
4be44fcd LB	516	.read = seq_read,
d479e908	517	.write = acpi_processor_write_limit,
4be44fcd LB	518	.llseek = seq_lseek,
4be44fcd LB	519	.release = single_release,
1da177e4	520	};
74cad4ee	521	#endif