[mirror_ubuntu-artful-kernel.git] / arch / ia64 / kernel / cpufreq / acpi-cpufreq.c

/*
 * arch/ia64/kernel/cpufreq/acpi-cpufreq.c
 * This file provides the ACPI based P-state support. This
 * module works with generic cpufreq infrastructure. Most of
 * the code is based on i386 version
 * (arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c)
 *
 * Copyright (C) 2005 Intel Corp
 *      Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
 */

#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 <asm/pal.h>

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

#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "acpi-cpufreq", msg)

MODULE_AUTHOR("Venkatesh Pallipadi");
MODULE_DESCRIPTION("ACPI Processor P-States Driver");
MODULE_LICENSE("GPL");


struct cpufreq_acpi_io {
	struct acpi_processor_performance	acpi_data;
	struct cpufreq_frequency_table		*freq_table;
	unsigned int				resume;
};

static struct cpufreq_acpi_io	*acpi_io_data[NR_CPUS];

static struct cpufreq_driver acpi_cpufreq_driver;


static int
processor_set_pstate (
	u32	value)
{
	s64 retval;

	dprintk("processor_set_pstate\n");

	retval = ia64_pal_set_pstate((u64)value);

	if (retval) {
		dprintk("Failed to set freq to 0x%x, with error 0x%x\n",
		        value, retval);
		return -ENODEV;
	}
	return (int)retval;
}


static int
processor_get_pstate (
	u32	*value)
{
	u64	pstate_index = 0;
	s64 	retval;

	dprintk("processor_get_pstate\n");

	retval = ia64_pal_get_pstate(&pstate_index);
	*value = (u32) pstate_index;

	if (retval)
		dprintk("Failed to get current freq with "
		        "error 0x%x, idx 0x%x\n", retval, *value);

	return (int)retval;
}


/* To be used only after data->acpi_data is initialized */
static unsigned
extract_clock (
	struct cpufreq_acpi_io *data,
	unsigned value,
	unsigned int cpu)
{
	unsigned long i;

	dprintk("extract_clock\n");

	for (i = 0; i < data->acpi_data.state_count; i++) {
		if (value >= data->acpi_data.states[i].control)
			return data->acpi_data.states[i].core_frequency;
	}
	return data->acpi_data.states[i-1].core_frequency;
}


static unsigned int
processor_get_freq (
	struct cpufreq_acpi_io	*data,
	unsigned int		cpu)
{
	int			ret = 0;
	u32			value = 0;
	cpumask_t		saved_mask;
	unsigned long 		clock_freq;

	dprintk("processor_get_freq\n");

	saved_mask = current->cpus_allowed;
	set_cpus_allowed(current, cpumask_of_cpu(cpu));
	if (smp_processor_id() != cpu) {
		ret = -EAGAIN;
		goto migrate_end;
	}

	/*
	 * processor_get_pstate gets the average frequency since the
	 * last get. So, do two PAL_get_freq()...
	 */
	ret = processor_get_pstate(&value);
	ret = processor_get_pstate(&value);

	if (ret) {
		set_cpus_allowed(current, saved_mask);
		printk(KERN_WARNING "get performance failed with error %d\n",
		       ret);
		ret = -EAGAIN;
		goto migrate_end;
	}
	clock_freq = extract_clock(data, value, cpu);
	ret = (clock_freq*1000);

migrate_end:
	set_cpus_allowed(current, saved_mask);
	return ret;
}


static int
processor_set_freq (
	struct cpufreq_acpi_io	*data,
	unsigned int		cpu,
	int			state)
{
	int			ret = 0;
	u32			value = 0;
	struct cpufreq_freqs    cpufreq_freqs;
	cpumask_t		saved_mask;
	int			retval;

	dprintk("processor_set_freq\n");

	saved_mask = current->cpus_allowed;
	set_cpus_allowed(current, cpumask_of_cpu(cpu));
	if (smp_processor_id() != cpu) {
		retval = -EAGAIN;
		goto migrate_end;
	}

	if (state == data->acpi_data.state) {
		if (unlikely(data->resume)) {
			dprintk("Called after resume, resetting to P%d\n", state);
			data->resume = 0;
		} else {
			dprintk("Already at target state (P%d)\n", state);
			retval = 0;
			goto migrate_end;
		}
	}

	dprintk("Transitioning from P%d to P%d\n",
		data->acpi_data.state, state);

	/* cpufreq frequency struct */
	cpufreq_freqs.cpu = cpu;
	cpufreq_freqs.old = data->freq_table[data->acpi_data.state].frequency;
	cpufreq_freqs.new = data->freq_table[state].frequency;

	/* notify cpufreq */
	cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_PRECHANGE);

	/*
	 * First we write the target state's 'control' value to the
	 * control_register.
	 */

	value = (u32) data->acpi_data.states[state].control;

	dprintk("Transitioning to state: 0x%08x\n", value);

	ret = processor_set_pstate(value);
	if (ret) {
		unsigned int tmp = cpufreq_freqs.new;
		cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);
		cpufreq_freqs.new = cpufreq_freqs.old;
		cpufreq_freqs.old = tmp;
		cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_PRECHANGE);
		cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);
		printk(KERN_WARNING "Transition failed with error %d\n", ret);
		retval = -ENODEV;
		goto migrate_end;
	}

	cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);

	data->acpi_data.state = state;

	retval = 0;

migrate_end:
	set_cpus_allowed(current, saved_mask);
	return (retval);
}


static unsigned int
acpi_cpufreq_get (
	unsigned int		cpu)
{
	struct cpufreq_acpi_io *data = acpi_io_data[cpu];

	dprintk("acpi_cpufreq_get\n");

	return processor_get_freq(data, cpu);
}


static int
acpi_cpufreq_target (
	struct cpufreq_policy   *policy,
	unsigned int target_freq,
	unsigned int relation)
{
	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
	unsigned int next_state = 0;
	unsigned int result = 0;

	dprintk("acpi_cpufreq_setpolicy\n");

	result = cpufreq_frequency_table_target(policy,
			data->freq_table, target_freq, relation, &next_state);
	if (result)
		return (result);

	result = processor_set_freq(data, policy->cpu, next_state);

	return (result);
}


static int
acpi_cpufreq_verify (
	struct cpufreq_policy   *policy)
{
	unsigned int result = 0;
	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];

	dprintk("acpi_cpufreq_verify\n");

	result = cpufreq_frequency_table_verify(policy,
			data->freq_table);

	return (result);
}


static int
acpi_cpufreq_cpu_init (
	struct cpufreq_policy   *policy)
{
	unsigned int		i;
	unsigned int		cpu = policy->cpu;
	struct cpufreq_acpi_io	*data;
	unsigned int		result = 0;

	dprintk("acpi_cpufreq_cpu_init\n");

	data = kmalloc(sizeof(struct cpufreq_acpi_io), GFP_KERNEL);
	if (!data)
		return (-ENOMEM);

	memset(data, 0, sizeof(struct cpufreq_acpi_io));

	acpi_io_data[cpu] = data;

	result = acpi_processor_register_performance(&data->acpi_data, cpu);

	if (result)
		goto err_free;

	/* capability check */
	if (data->acpi_data.state_count <= 1) {
		dprintk("No P-States\n");
		result = -ENODEV;
		goto err_unreg;
	}

	if ((data->acpi_data.control_register.space_id !=
					ACPI_ADR_SPACE_FIXED_HARDWARE) ||
	    (data->acpi_data.status_register.space_id !=
					ACPI_ADR_SPACE_FIXED_HARDWARE)) {
		dprintk("Unsupported address space [%d, %d]\n",
			(u32) (data->acpi_data.control_register.space_id),
			(u32) (data->acpi_data.status_register.space_id));
		result = -ENODEV;
		goto err_unreg;
	}

	/* alloc freq_table */
	data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) *
	                           (data->acpi_data.state_count + 1),
	                           GFP_KERNEL);
	if (!data->freq_table) {
		result = -ENOMEM;
		goto err_unreg;
	}

	/* detect transition latency */
	policy->cpuinfo.transition_latency = 0;
	for (i=0; i<data->acpi_data.state_count; i++) {
		if ((data->acpi_data.states[i].transition_latency * 1000) >
		    policy->cpuinfo.transition_latency) {
			policy->cpuinfo.transition_latency =
			    data->acpi_data.states[i].transition_latency * 1000;
		}
	}
	policy->governor = CPUFREQ_DEFAULT_GOVERNOR;

	policy->cur = processor_get_freq(data, policy->cpu);

	/* table init */
	for (i = 0; i <= data->acpi_data.state_count; i++)
	{
		data->freq_table[i].index = i;
		if (i < data->acpi_data.state_count) {
			data->freq_table[i].frequency =
			      data->acpi_data.states[i].core_frequency * 1000;
		} else {
			data->freq_table[i].frequency = CPUFREQ_TABLE_END;
		}
	}

	result = cpufreq_frequency_table_cpuinfo(policy, data->freq_table);
	if (result) {
		goto err_freqfree;
	}

	/* notify BIOS that we exist */
	acpi_processor_notify_smm(THIS_MODULE);

	printk(KERN_INFO "acpi-cpufreq: CPU%u - ACPI performance management "
	       "activated.\n", cpu);

	for (i = 0; i < data->acpi_data.state_count; i++)
		dprintk("     %cP%d: %d MHz, %d mW, %d uS, %d uS, 0x%x 0x%x\n",
			(i == data->acpi_data.state?'*':' '), i,
			(u32) data->acpi_data.states[i].core_frequency,
			(u32) data->acpi_data.states[i].power,
			(u32) data->acpi_data.states[i].transition_latency,
			(u32) data->acpi_data.states[i].bus_master_latency,
			(u32) data->acpi_data.states[i].status,
			(u32) data->acpi_data.states[i].control);

	cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu);

	/* the first call to ->target() should result in us actually
	 * writing something to the appropriate registers. */
	data->resume = 1;

	return (result);

 err_freqfree:
	kfree(data->freq_table);
 err_unreg:
	acpi_processor_unregister_performance(&data->acpi_data, cpu);
 err_free:
	kfree(data);
	acpi_io_data[cpu] = NULL;

	return (result);
}


static int
acpi_cpufreq_cpu_exit (
	struct cpufreq_policy   *policy)
{
	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];

	dprintk("acpi_cpufreq_cpu_exit\n");

	if (data) {
		cpufreq_frequency_table_put_attr(policy->cpu);
		acpi_io_data[policy->cpu] = NULL;
		acpi_processor_unregister_performance(&data->acpi_data,
		                                      policy->cpu);
		kfree(data);
	}

	return (0);
}


static struct freq_attr* acpi_cpufreq_attr[] = {
	&cpufreq_freq_attr_scaling_available_freqs,
	NULL,
};


static struct cpufreq_driver acpi_cpufreq_driver = {
	.verify 	= acpi_cpufreq_verify,
	.target 	= acpi_cpufreq_target,
	.get 		= acpi_cpufreq_get,
	.init		= acpi_cpufreq_cpu_init,
	.exit		= acpi_cpufreq_cpu_exit,
	.name		= "acpi-cpufreq",
	.owner		= THIS_MODULE,
	.attr           = acpi_cpufreq_attr,
};


static int __init
acpi_cpufreq_init (void)
{
	dprintk("acpi_cpufreq_init\n");

 	return cpufreq_register_driver(&acpi_cpufreq_driver);
}


static void __exit
acpi_cpufreq_exit (void)
{
	dprintk("acpi_cpufreq_exit\n");

	cpufreq_unregister_driver(&acpi_cpufreq_driver);
	return;
}


late_initcall(acpi_cpufreq_init);
module_exit(acpi_cpufreq_exit);
Commit	Line	Data
4db8699b VP	1	/*
	2	* arch/ia64/kernel/cpufreq/acpi-cpufreq.c
	3	* This file provides the ACPI based P-state support. This
	4	* module works with generic cpufreq infrastructure. Most of
	5	* the code is based on i386 version
	6	* (arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c)
	7	*
	8	* Copyright (C) 2005 Intel Corp
	9	* Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
	10	*/
	11
4db8699b VP	12	#include <linux/kernel.h>
	13	#include <linux/module.h>
	14	#include <linux/init.h>
	15	#include <linux/cpufreq.h>
	16	#include <linux/proc_fs.h>
	17	#include <linux/seq_file.h>
	18	#include <asm/io.h>
	19	#include <asm/uaccess.h>
	20	#include <asm/pal.h>
	21
	22	#include <linux/acpi.h>
	23	#include <acpi/processor.h>
	24
	25	#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "acpi-cpufreq", msg)
	26
	27	MODULE_AUTHOR("Venkatesh Pallipadi");
	28	MODULE_DESCRIPTION("ACPI Processor P-States Driver");
	29	MODULE_LICENSE("GPL");
	30
	31
	32	struct cpufreq_acpi_io {
	33	struct acpi_processor_performance acpi_data;
	34	struct cpufreq_frequency_table *freq_table;
	35	unsigned int resume;
	36	};
	37
	38	static struct cpufreq_acpi_io *acpi_io_data[NR_CPUS];
	39
	40	static struct cpufreq_driver acpi_cpufreq_driver;
	41
	42
	43	static int
	44	processor_set_pstate (
	45	u32 value)
	46	{
	47	s64 retval;
	48
	49	dprintk("processor_set_pstate\n");
	50
	51	retval = ia64_pal_set_pstate((u64)value);
	52
	53	if (retval) {
	54	dprintk("Failed to set freq to 0x%x, with error 0x%x\n",
	55	value, retval);
	56	return -ENODEV;
	57	}
	58	return (int)retval;
	59	}
	60
	61
	62	static int
	63	processor_get_pstate (
	64	u32 *value)
	65	{
	66	u64 pstate_index = 0;
	67	s64 retval;
	68
	69	dprintk("processor_get_pstate\n");
	70
	71	retval = ia64_pal_get_pstate(&pstate_index);
	72	*value = (u32) pstate_index;
	73
	74	if (retval)
	75	dprintk("Failed to get current freq with "
76	"error 0x%x, idx 0x%x\n", retval, *value);
77
78	return (int)retval;
79	}
80
81
82	/* To be used only after data->acpi_data is initialized */
83	static unsigned
84	extract_clock (
85	struct cpufreq_acpi_io *data,
86	unsigned value,
87	unsigned int cpu)
88	{
89	unsigned long i;
90
91	dprintk("extract_clock\n");
92
93	for (i = 0; i < data->acpi_data.state_count; i++) {
94	if (value >= data->acpi_data.states[i].control)
95	return data->acpi_data.states[i].core_frequency;
96	}
97	return data->acpi_data.states[i-1].core_frequency;
98	}
99
100
101	static unsigned int
102	processor_get_freq (
103	struct cpufreq_acpi_io *data,
104	unsigned int cpu)
105	{
106	int ret = 0;
107	u32 value = 0;
108	cpumask_t saved_mask;
109	unsigned long clock_freq;
110
111	dprintk("processor_get_freq\n");
112
113	saved_mask = current->cpus_allowed;
114	set_cpus_allowed(current, cpumask_of_cpu(cpu));
115	if (smp_processor_id() != cpu) {
116	ret = -EAGAIN;
117	goto migrate_end;
118	}
119
120	/*
121	* processor_get_pstate gets the average frequency since the
122	* last get. So, do two PAL_get_freq()...
123	*/
124	ret = processor_get_pstate(&value);
125	ret = processor_get_pstate(&value);
126
127	if (ret) {
128	set_cpus_allowed(current, saved_mask);
129	printk(KERN_WARNING "get performance failed with error %d\n",
130	ret);
131	ret = -EAGAIN;
132	goto migrate_end;
133	}
134	clock_freq = extract_clock(data, value, cpu);
135	ret = (clock_freq*1000);
136
137	migrate_end:
138	set_cpus_allowed(current, saved_mask);
139	return ret;
140	}
141
142
143	static int
144	processor_set_freq (
145	struct cpufreq_acpi_io *data,
146	unsigned int cpu,
147	int state)
148	{
149	int ret = 0;
150	u32 value = 0;
151	struct cpufreq_freqs cpufreq_freqs;
152	cpumask_t saved_mask;
153	int retval;
154
155	dprintk("processor_set_freq\n");
156
157	saved_mask = current->cpus_allowed;
158	set_cpus_allowed(current, cpumask_of_cpu(cpu));
159	if (smp_processor_id() != cpu) {
160	retval = -EAGAIN;
161	goto migrate_end;
162	}
163
164	if (state == data->acpi_data.state) {
165	if (unlikely(data->resume)) {
166	dprintk("Called after resume, resetting to P%d\n", state);
167	data->resume = 0;
168	} else {
169	dprintk("Already at target state (P%d)\n", state);
170	retval = 0;
171	goto migrate_end;
172	}
173	}
174
175	dprintk("Transitioning from P%d to P%d\n",
176	data->acpi_data.state, state);
177
178	/* cpufreq frequency struct */
179	cpufreq_freqs.cpu = cpu;
180	cpufreq_freqs.old = data->freq_table[data->acpi_data.state].frequency;
181	cpufreq_freqs.new = data->freq_table[state].frequency;
182
183	/* notify cpufreq */
184	cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_PRECHANGE);
185
186	/*
187	* First we write the target state's 'control' value to the
188	* control_register.
189	*/
190
191	value = (u32) data->acpi_data.states[state].control;
192
193	dprintk("Transitioning to state: 0x%08x\n", value);
194
195	ret = processor_set_pstate(value);
196	if (ret) {
197	unsigned int tmp = cpufreq_freqs.new;
198	cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);
199	cpufreq_freqs.new = cpufreq_freqs.old;
200	cpufreq_freqs.old = tmp;
201	cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_PRECHANGE);
202	cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);
203	printk(KERN_WARNING "Transition failed with error %d\n", ret);
204	retval = -ENODEV;
205	goto migrate_end;
206	}
207
208	cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE);
209
210	data->acpi_data.state = state;
211
212	retval = 0;
213
214	migrate_end:
215	set_cpus_allowed(current, saved_mask);
216	return (retval);
217	}
218
219
220	static unsigned int
221	acpi_cpufreq_get (
222	unsigned int cpu)
223	{
224	struct cpufreq_acpi_io *data = acpi_io_data[cpu];
225
226	dprintk("acpi_cpufreq_get\n");
227
228	return processor_get_freq(data, cpu);
229	}
230
231
232	static int
233	acpi_cpufreq_target (
234	struct cpufreq_policy *policy,
235	unsigned int target_freq,
236	unsigned int relation)
237	{
238	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
239	unsigned int next_state = 0;
240	unsigned int result = 0;
241
242	dprintk("acpi_cpufreq_setpolicy\n");
243
244	result = cpufreq_frequency_table_target(policy,
245	data->freq_table, target_freq, relation, &next_state);
246	if (result)
247	return (result);
248
249	result = processor_set_freq(data, policy->cpu, next_state);
250
251	return (result);
252	}
253
254
255	static int
256	acpi_cpufreq_verify (
257	struct cpufreq_policy *policy)
258	{
259	unsigned int result = 0;
260	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
261
262	dprintk("acpi_cpufreq_verify\n");
263
264	result = cpufreq_frequency_table_verify(policy,
265	data->freq_table);
266
267	return (result);
268	}
269
270
4db8699b VP	271	static int
	272	acpi_cpufreq_cpu_init (
	273	struct cpufreq_policy *policy)
	274	{
	275	unsigned int i;
	276	unsigned int cpu = policy->cpu;
	277	struct cpufreq_acpi_io *data;
	278	unsigned int result = 0;
	279
4db8699b	280	dprintk("acpi_cpufreq_cpu_init\n");
4db8699b VP	281
	282	data = kmalloc(sizeof(struct cpufreq_acpi_io), GFP_KERNEL);
	283	if (!data)
	284	return (-ENOMEM);
	285
	286	memset(data, 0, sizeof(struct cpufreq_acpi_io));
	287
	288	acpi_io_data[cpu] = data;
	289
4db8699b	290	result = acpi_processor_register_performance(&data->acpi_data, cpu);
4db8699b VP	291
	292	if (result)
	293	goto err_free;
	294
	295	/* capability check */
	296	if (data->acpi_data.state_count <= 1) {
	297	dprintk("No P-States\n");
	298	result = -ENODEV;
	299	goto err_unreg;
	300	}
	301
	302	if ((data->acpi_data.control_register.space_id !=
	303	ACPI_ADR_SPACE_FIXED_HARDWARE) \|\|
	304	(data->acpi_data.status_register.space_id !=
	305	ACPI_ADR_SPACE_FIXED_HARDWARE)) {
	306	dprintk("Unsupported address space [%d, %d]\n",
	307	(u32) (data->acpi_data.control_register.space_id),
	308	(u32) (data->acpi_data.status_register.space_id));
	309	result = -ENODEV;
	310	goto err_unreg;
	311	}
	312
	313	/* alloc freq_table */
	314	data->freq_table = kmalloc(sizeof(struct cpufreq_frequency_table) *
	315	(data->acpi_data.state_count + 1),
	316	GFP_KERNEL);
	317	if (!data->freq_table) {
	318	result = -ENOMEM;
	319	goto err_unreg;
	320	}
	321
	322	/* detect transition latency */
	323	policy->cpuinfo.transition_latency = 0;
	324	for (i=0; i<data->acpi_data.state_count; i++) {
	325	if ((data->acpi_data.states[i].transition_latency * 1000) >
	326	policy->cpuinfo.transition_latency) {
	327	policy->cpuinfo.transition_latency =
	328	data->acpi_data.states[i].transition_latency * 1000;
	329	}
	330	}
	331	policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
	332
	333	policy->cur = processor_get_freq(data, policy->cpu);
	334
	335	/* table init */
	336	for (i = 0; i <= data->acpi_data.state_count; i++)
	337	{
	338	data->freq_table[i].index = i;
	339	if (i < data->acpi_data.state_count) {
	340	data->freq_table[i].frequency =
	341	data->acpi_data.states[i].core_frequency * 1000;
	342	} else {
	343	data->freq_table[i].frequency = CPUFREQ_TABLE_END;
	344	}
	345	}
	346
	347	result = cpufreq_frequency_table_cpuinfo(policy, data->freq_table);
	348	if (result) {
	349	goto err_freqfree;
	350	}
	351
	352	/* notify BIOS that we exist */
	353	acpi_processor_notify_smm(THIS_MODULE);
	354
355	printk(KERN_INFO "acpi-cpufreq: CPU%u - ACPI performance management "
356	"activated.\n", cpu);
357
358	for (i = 0; i < data->acpi_data.state_count; i++)
359	dprintk(" %cP%d: %d MHz, %d mW, %d uS, %d uS, 0x%x 0x%x\n",
360	(i == data->acpi_data.state?'*':' '), i,
361	(u32) data->acpi_data.states[i].core_frequency,
362	(u32) data->acpi_data.states[i].power,
363	(u32) data->acpi_data.states[i].transition_latency,
364	(u32) data->acpi_data.states[i].bus_master_latency,
365	(u32) data->acpi_data.states[i].status,
366	(u32) data->acpi_data.states[i].control);
367
368	cpufreq_frequency_table_get_attr(data->freq_table, policy->cpu);
369
370	/* the first call to ->target() should result in us actually
371	* writing something to the appropriate registers. */
372	data->resume = 1;
373
374	return (result);
375
376	err_freqfree:
377	kfree(data->freq_table);
378	err_unreg:
379	acpi_processor_unregister_performance(&data->acpi_data, cpu);
380	err_free:
381	kfree(data);
382	acpi_io_data[cpu] = NULL;
383
384	return (result);
385	}
386
387
388	static int
389	acpi_cpufreq_cpu_exit (
390	struct cpufreq_policy *policy)
391	{
392	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
393
394	dprintk("acpi_cpufreq_cpu_exit\n");
395
396	if (data) {
397	cpufreq_frequency_table_put_attr(policy->cpu);
398	acpi_io_data[policy->cpu] = NULL;
399	acpi_processor_unregister_performance(&data->acpi_data,
400	policy->cpu);
401	kfree(data);
402	}
403
404	return (0);
405	}
406
407
408	static struct freq_attr* acpi_cpufreq_attr[] = {
409	&cpufreq_freq_attr_scaling_available_freqs,
410	NULL,
411	};
412
413
414	static struct cpufreq_driver acpi_cpufreq_driver = {
415	.verify = acpi_cpufreq_verify,
416	.target = acpi_cpufreq_target,
417	.get = acpi_cpufreq_get,
418	.init = acpi_cpufreq_cpu_init,
419	.exit = acpi_cpufreq_cpu_exit,
420	.name = "acpi-cpufreq",
421	.owner = THIS_MODULE,
422	.attr = acpi_cpufreq_attr,
423	};
424
425
426	static int __init
427	acpi_cpufreq_init (void)
428	{
429	dprintk("acpi_cpufreq_init\n");
430
431	return cpufreq_register_driver(&acpi_cpufreq_driver);
432	}
433
434
435	static void __exit
436	acpi_cpufreq_exit (void)
437	{
438	dprintk("acpi_cpufreq_exit\n");
439
440	cpufreq_unregister_driver(&acpi_cpufreq_driver);
441	return;
442	}
443
444
445	late_initcall(acpi_cpufreq_init);
446	module_exit(acpi_cpufreq_exit);
447