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

/*
 * processor_throttling.c - Throttling 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 <asm/io.h>
#include <asm/uaccess.h>

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

#define ACPI_PROCESSOR_COMPONENT        0x01000000
#define ACPI_PROCESSOR_CLASS            "processor"
#define ACPI_PROCESSOR_DRIVER_NAME      "ACPI Processor Driver"
#define _COMPONENT              ACPI_PROCESSOR_COMPONENT
ACPI_MODULE_NAME("acpi_processor")

/* --------------------------------------------------------------------------
                              Throttling Control
   -------------------------------------------------------------------------- */
static int acpi_processor_get_throttling(struct acpi_processor *pr)
{
	int state = 0;
	u32 value = 0;
	u32 duty_mask = 0;
	u32 duty_value = 0;

	ACPI_FUNCTION_TRACE("acpi_processor_get_throttling");

	if (!pr)
		return_VALUE(-EINVAL);

	if (!pr->flags.throttling)
		return_VALUE(-ENODEV);

	pr->throttling.state = 0;

	duty_mask = pr->throttling.state_count - 1;

	duty_mask <<= pr->throttling.duty_offset;

	local_irq_disable();

	value = inl(pr->throttling.address);

	/*
	 * Compute the current throttling state when throttling is enabled
	 * (bit 4 is on).
	 */
	if (value & 0x10) {
		duty_value = value & duty_mask;
		duty_value >>= pr->throttling.duty_offset;

		if (duty_value)
			state = pr->throttling.state_count - duty_value;
	}

	pr->throttling.state = state;

	local_irq_enable();

	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "Throttling state is T%d (%d%% throttling applied)\n",
			  state, pr->throttling.states[state].performance));

	return_VALUE(0);
}

int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
{
	u32 value = 0;
	u32 duty_mask = 0;
	u32 duty_value = 0;

	ACPI_FUNCTION_TRACE("acpi_processor_set_throttling");

	if (!pr)
		return_VALUE(-EINVAL);

	if ((state < 0) || (state > (pr->throttling.state_count - 1)))
		return_VALUE(-EINVAL);

	if (!pr->flags.throttling)
		return_VALUE(-ENODEV);

	if (state == pr->throttling.state)
		return_VALUE(0);

	/*
	 * Calculate the duty_value and duty_mask.
	 */
	if (state) {
		duty_value = pr->throttling.state_count - state;

		duty_value <<= pr->throttling.duty_offset;

		/* Used to clear all duty_value bits */
		duty_mask = pr->throttling.state_count - 1;

		duty_mask <<= acpi_fadt.duty_offset;
		duty_mask = ~duty_mask;
	}

	local_irq_disable();

	/*
	 * Disable throttling by writing a 0 to bit 4.  Note that we must
	 * turn it off before you can change the duty_value.
	 */
	value = inl(pr->throttling.address);
	if (value & 0x10) {
		value &= 0xFFFFFFEF;
		outl(value, pr->throttling.address);
	}

	/*
	 * Write the new duty_value and then enable throttling.  Note
	 * that a state value of 0 leaves throttling disabled.
	 */
	if (state) {
		value &= duty_mask;
		value |= duty_value;
		outl(value, pr->throttling.address);

		value |= 0x00000010;
		outl(value, pr->throttling.address);
	}

	pr->throttling.state = state;

	local_irq_enable();

	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "Throttling state set to T%d (%d%%)\n", state,
			  (pr->throttling.states[state].performance ? pr->
			   throttling.states[state].performance / 10 : 0)));

	return_VALUE(0);
}

int acpi_processor_get_throttling_info(struct acpi_processor *pr)
{
	int result = 0;
	int step = 0;
	int i = 0;

	ACPI_FUNCTION_TRACE("acpi_processor_get_throttling_info");

	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
			  pr->throttling.address,
			  pr->throttling.duty_offset,
			  pr->throttling.duty_width));

	if (!pr)
		return_VALUE(-EINVAL);

	/* TBD: Support ACPI 2.0 objects */

	if (!pr->throttling.address) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
		return_VALUE(0);
	} else if (!pr->throttling.duty_width) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n"));
		return_VALUE(0);
	}
	/* TBD: Support duty_cycle values that span bit 4. */
	else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
		ACPI_DEBUG_PRINT((ACPI_DB_WARN, "duty_cycle spans bit 4\n"));
		return_VALUE(0);
	}

	/*
	 * PIIX4 Errata: We don't support throttling on the original PIIX4.
	 * This shouldn't be an issue as few (if any) mobile systems ever
	 * used this part.
	 */
	if (errata.piix4.throttle) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Throttling not supported on PIIX4 A- or B-step\n"));
		return_VALUE(0);
	}

	pr->throttling.state_count = 1 << acpi_fadt.duty_width;

	/*
	 * Compute state values. Note that throttling displays a linear power/
	 * performance relationship (at 50% performance the CPU will consume
	 * 50% power).  Values are in 1/10th of a percent to preserve accuracy.
	 */

	step = (1000 / pr->throttling.state_count);

	for (i = 0; i < pr->throttling.state_count; i++) {
		pr->throttling.states[i].performance = step * i;
		pr->throttling.states[i].power = step * i;
	}

	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
			  pr->throttling.state_count));

	pr->flags.throttling = 1;

	/*
	 * Disable throttling (if enabled).  We'll let subsequent policy (e.g.
	 * thermal) decide to lower performance if it so chooses, but for now
	 * we'll crank up the speed.
	 */

	result = acpi_processor_get_throttling(pr);
	if (result)
		goto end;

	if (pr->throttling.state) {
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Disabling throttling (was T%d)\n",
				  pr->throttling.state));
		result = acpi_processor_set_throttling(pr, 0);
		if (result)
			goto end;
	}

      end:
	if (result)
		pr->flags.throttling = 0;

	return_VALUE(result);
}

/* proc interface */

static int acpi_processor_throttling_seq_show(struct seq_file *seq,
					      void *offset)
{
	struct acpi_processor *pr = (struct acpi_processor *)seq->private;
	int i = 0;
	int result = 0;

	ACPI_FUNCTION_TRACE("acpi_processor_throttling_seq_show");

	if (!pr)
		goto end;

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

	result = acpi_processor_get_throttling(pr);

	if (result) {
		seq_puts(seq,
			 "Could not determine current throttling state.\n");
		goto end;
	}

	seq_printf(seq, "state count:             %d\n"
		   "active state:            T%d\n",
		   pr->throttling.state_count, pr->throttling.state);

	seq_puts(seq, "states:\n");
	for (i = 0; i < pr->throttling.state_count; i++)
		seq_printf(seq, "   %cT%d:                  %02d%%\n",
			   (i == pr->throttling.state ? '*' : ' '), i,
			   (pr->throttling.states[i].performance ? pr->
			    throttling.states[i].performance / 10 : 0));

      end:
	return_VALUE(0);
}

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

ssize_t acpi_processor_write_throttling(struct file * file,
					const char __user * buffer,
					size_t count, loff_t * data)
{
	int result = 0;
	struct seq_file *m = (struct seq_file *)file->private_data;
	struct acpi_processor *pr = (struct acpi_processor *)m->private;
	char state_string[12] = { '\0' };

	ACPI_FUNCTION_TRACE("acpi_processor_write_throttling");

	if (!pr || (count > sizeof(state_string) - 1))
		return_VALUE(-EINVAL);

	if (copy_from_user(state_string, buffer, count))
		return_VALUE(-EFAULT);

	state_string[count] = '\0';

	result = acpi_processor_set_throttling(pr,
					       simple_strtoul(state_string,
							      NULL, 0));
	if (result)
		return_VALUE(result);

	return_VALUE(count);
}

struct file_operations acpi_processor_throttling_fops = {
	.open = acpi_processor_throttling_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* processor_throttling.c - Throttling 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>
	35
	36	#include <asm/io.h>
	37	#include <asm/uaccess.h>
	38
	39	#include <acpi/acpi_bus.h>
	40	#include <acpi/processor.h>
	41
	42	#define ACPI_PROCESSOR_COMPONENT 0x01000000
	43	#define ACPI_PROCESSOR_CLASS "processor"
	44	#define ACPI_PROCESSOR_DRIVER_NAME "ACPI Processor Driver"
	45	#define _COMPONENT ACPI_PROCESSOR_COMPONENT
4be44fcd	46	ACPI_MODULE_NAME("acpi_processor")
1da177e4 LT	47
	48	/* --------------------------------------------------------------------------
	49	Throttling Control
	50	-------------------------------------------------------------------------- */
4be44fcd	51	static int acpi_processor_get_throttling(struct acpi_processor *pr)
1da177e4	52	{
4be44fcd LB	53	int state = 0;
	54	u32 value = 0;
	55	u32 duty_mask = 0;
	56	u32 duty_value = 0;
1da177e4 LT	57
	58	ACPI_FUNCTION_TRACE("acpi_processor_get_throttling");
	59
	60	if (!pr)
	61	return_VALUE(-EINVAL);
	62
	63	if (!pr->flags.throttling)
	64	return_VALUE(-ENODEV);
	65
	66	pr->throttling.state = 0;
	67
	68	duty_mask = pr->throttling.state_count - 1;
	69
	70	duty_mask <<= pr->throttling.duty_offset;
	71
	72	local_irq_disable();
	73
	74	value = inl(pr->throttling.address);
	75
	76	/*
	77	* Compute the current throttling state when throttling is enabled
	78	* (bit 4 is on).
	79	*/
	80	if (value & 0x10) {
	81	duty_value = value & duty_mask;
	82	duty_value >>= pr->throttling.duty_offset;
	83
	84	if (duty_value)
4be44fcd	85	state = pr->throttling.state_count - duty_value;
1da177e4 LT	86	}
	87
	88	pr->throttling.state = state;
	89
	90	local_irq_enable();
	91
	92	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd LB	93	"Throttling state is T%d (%d%% throttling applied)\n",
4be44fcd LB	94	state, pr->throttling.states[state].performance));
1da177e4 LT	95
	96	return_VALUE(0);
	97	}
	98
4be44fcd	99	int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
1da177e4	100	{
4be44fcd LB	101	u32 value = 0;
	102	u32 duty_mask = 0;
	103	u32 duty_value = 0;
1da177e4 LT	104
	105	ACPI_FUNCTION_TRACE("acpi_processor_set_throttling");
	106
	107	if (!pr)
	108	return_VALUE(-EINVAL);
	109
	110	if ((state < 0) \|\| (state > (pr->throttling.state_count - 1)))
	111	return_VALUE(-EINVAL);
	112
	113	if (!pr->flags.throttling)
	114	return_VALUE(-ENODEV);
	115
	116	if (state == pr->throttling.state)
	117	return_VALUE(0);
	118
	119	/*
	120	* Calculate the duty_value and duty_mask.
	121	*/
	122	if (state) {
	123	duty_value = pr->throttling.state_count - state;
	124
	125	duty_value <<= pr->throttling.duty_offset;
	126
	127	/* Used to clear all duty_value bits */
	128	duty_mask = pr->throttling.state_count - 1;
	129
	130	duty_mask <<= acpi_fadt.duty_offset;
	131	duty_mask = ~duty_mask;
	132	}
	133
	134	local_irq_disable();
	135
	136	/*
	137	* Disable throttling by writing a 0 to bit 4. Note that we must
	138	* turn it off before you can change the duty_value.
	139	*/
	140	value = inl(pr->throttling.address);
	141	if (value & 0x10) {
	142	value &= 0xFFFFFFEF;
	143	outl(value, pr->throttling.address);
	144	}
	145
	146	/*
	147	* Write the new duty_value and then enable throttling. Note
	148	* that a state value of 0 leaves throttling disabled.
	149	*/
	150	if (state) {
	151	value &= duty_mask;
	152	value \|= duty_value;
	153	outl(value, pr->throttling.address);
	154
	155	value \|= 0x00000010;
	156	outl(value, pr->throttling.address);
	157	}
	158
	159	pr->throttling.state = state;
	160
	161	local_irq_enable();
	162
	163	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd LB	164	"Throttling state set to T%d (%d%%)\n", state,
	165	(pr->throttling.states[state].performance ? pr->
	166	throttling.states[state].performance / 10 : 0)));
1da177e4 LT	167
	168	return_VALUE(0);
	169	}
	170
4be44fcd	171	int acpi_processor_get_throttling_info(struct acpi_processor *pr)
1da177e4	172	{
4be44fcd LB	173	int result = 0;
	174	int step = 0;
	175	int i = 0;
1da177e4 LT	176
	177	ACPI_FUNCTION_TRACE("acpi_processor_get_throttling_info");
	178
	179	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd LB	180	"pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
	181	pr->throttling.address,
	182	pr->throttling.duty_offset,
	183	pr->throttling.duty_width));
1da177e4 LT	184
	185	if (!pr)
	186	return_VALUE(-EINVAL);
	187
	188	/* TBD: Support ACPI 2.0 objects */
	189
	190	if (!pr->throttling.address) {
	191	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
	192	return_VALUE(0);
4be44fcd	193	} else if (!pr->throttling.duty_width) {
1da177e4 LT	194	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n"));
	195	return_VALUE(0);
	196	}
	197	/* TBD: Support duty_cycle values that span bit 4. */
4be44fcd	198	else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
1da177e4 LT	199	ACPI_DEBUG_PRINT((ACPI_DB_WARN, "duty_cycle spans bit 4\n"));
	200	return_VALUE(0);
	201	}
	202
	203	/*
	204	* PIIX4 Errata: We don't support throttling on the original PIIX4.
	205	* This shouldn't be an issue as few (if any) mobile systems ever
	206	* used this part.
	207	*/
	208	if (errata.piix4.throttle) {
	209	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
4be44fcd	210	"Throttling not supported on PIIX4 A- or B-step\n"));
1da177e4 LT	211	return_VALUE(0);
	212	}
	213
	214	pr->throttling.state_count = 1 << acpi_fadt.duty_width;
	215
	216	/*
	217	* Compute state values. Note that throttling displays a linear power/
	218	* performance relationship (at 50% performance the CPU will consume
	219	* 50% power). Values are in 1/10th of a percent to preserve accuracy.
	220	*/
	221
	222	step = (1000 / pr->throttling.state_count);
	223
4be44fcd	224	for (i = 0; i < pr->throttling.state_count; i++) {
1da177e4 LT	225	pr->throttling.states[i].performance = step * i;
	226	pr->throttling.states[i].power = step * i;
	227	}
	228
	229	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
4be44fcd	230	pr->throttling.state_count));
1da177e4 LT	231
	232	pr->flags.throttling = 1;
	233
	234	/*
	235	* Disable throttling (if enabled). We'll let subsequent policy (e.g.
	236	* thermal) decide to lower performance if it so chooses, but for now
	237	* we'll crank up the speed.
	238	*/
	239
	240	result = acpi_processor_get_throttling(pr);
	241	if (result)
	242	goto end;
	243
	244	if (pr->throttling.state) {
4be44fcd LB	245	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
	246	"Disabling throttling (was T%d)\n",
	247	pr->throttling.state));
1da177e4 LT	248	result = acpi_processor_set_throttling(pr, 0);
	249	if (result)
	250	goto end;
	251	}
	252
4be44fcd	253	end:
1da177e4 LT	254	if (result)
	255	pr->flags.throttling = 0;
	256
	257	return_VALUE(result);
	258	}
	259
1da177e4 LT	260	/* proc interface */
1da177e4 LT	261
4be44fcd LB	262	static int acpi_processor_throttling_seq_show(struct seq_file *seq,
4be44fcd LB	263	void *offset)
1da177e4	264	{
4be44fcd LB	265	struct acpi_processor pr = (struct acpi_processor )seq->private;
	266	int i = 0;
	267	int result = 0;
1da177e4 LT	268
	269	ACPI_FUNCTION_TRACE("acpi_processor_throttling_seq_show");
	270
	271	if (!pr)
	272	goto end;
	273
	274	if (!(pr->throttling.state_count > 0)) {
	275	seq_puts(seq, "<not supported>\n");
	276	goto end;
	277	}
	278
	279	result = acpi_processor_get_throttling(pr);
	280
	281	if (result) {
4be44fcd LB	282	seq_puts(seq,
4be44fcd LB	283	"Could not determine current throttling state.\n");
1da177e4 LT	284	goto end;
	285	}
	286
	287	seq_printf(seq, "state count: %d\n"
4be44fcd LB	288	"active state: T%d\n",
4be44fcd LB	289	pr->throttling.state_count, pr->throttling.state);
1da177e4 LT	290
	291	seq_puts(seq, "states:\n");
	292	for (i = 0; i < pr->throttling.state_count; i++)
	293	seq_printf(seq, " %cT%d: %02d%%\n",
4be44fcd LB	294	(i == pr->throttling.state ? '*' : ' '), i,
	295	(pr->throttling.states[i].performance ? pr->
	296	throttling.states[i].performance / 10 : 0));
1da177e4	297
4be44fcd	298	end:
1da177e4 LT	299	return_VALUE(0);
	300	}
	301
4be44fcd LB	302	static int acpi_processor_throttling_open_fs(struct inode *inode,
4be44fcd LB	303	struct file *file)
1da177e4 LT	304	{
1da177e4 LT	305	return single_open(file, acpi_processor_throttling_seq_show,
4be44fcd	306	PDE(inode)->data);
1da177e4 LT	307	}
1da177e4 LT	308
4be44fcd LB	309	ssize_t acpi_processor_write_throttling(struct file * file,
	310	const char __user * buffer,
	311	size_t count, loff_t * data)
1da177e4	312	{
4be44fcd LB	313	int result = 0;
	314	struct seq_file m = (struct seq_file )file->private_data;
	315	struct acpi_processor pr = (struct acpi_processor )m->private;
	316	char state_string[12] = { '\0' };
1da177e4 LT	317
	318	ACPI_FUNCTION_TRACE("acpi_processor_write_throttling");
	319
	320	if (!pr \|\| (count > sizeof(state_string) - 1))
	321	return_VALUE(-EINVAL);
	322
	323	if (copy_from_user(state_string, buffer, count))
	324	return_VALUE(-EFAULT);
	325
	326	state_string[count] = '\0';
	327
	328	result = acpi_processor_set_throttling(pr,
4be44fcd LB	329	simple_strtoul(state_string,
4be44fcd LB	330	NULL, 0));
1da177e4 LT	331	if (result)
	332	return_VALUE(result);
	333
	334	return_VALUE(count);
	335	}
	336
	337	struct file_operations acpi_processor_throttling_fops = {
4be44fcd LB	338	.open = acpi_processor_throttling_open_fs,
	339	.read = seq_read,
	340	.llseek = seq_lseek,
	341	.release = single_release,
1da177e4	342	};