1/*
  2 * This file provides the ACPI based P-state support. This
  3 * module works with generic cpufreq infrastructure. Most of
  4 * the code is based on i386 version
  5 * (arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c)
  6 *
  7 * Copyright (C) 2005 Intel Corp
  8 *      Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
  9 */
 10
 11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 12
 13#include <linux/kernel.h>
 14#include <linux/slab.h>
 15#include <linux/module.h>
 16#include <linux/init.h>
 17#include <linux/cpufreq.h>
 18#include <linux/proc_fs.h>
 19#include <linux/seq_file.h>
 20#include <asm/io.h>
 21#include <linux/uaccess.h>
 22#include <asm/pal.h>
 23
 24#include <linux/acpi.h>
 25#include <acpi/processor.h>
 26
 27MODULE_AUTHOR("Venkatesh Pallipadi");
 28MODULE_DESCRIPTION("ACPI Processor P-States Driver");
 29MODULE_LICENSE("GPL");
 30
 31
 32struct cpufreq_acpi_io {
 33	struct acpi_processor_performance	acpi_data;
 34	unsigned int				resume;
 35};
 36
 37struct cpufreq_acpi_req {
 38	unsigned int		cpu;
 39	unsigned int		state;
 40};
 41
 42static struct cpufreq_acpi_io	*acpi_io_data[NR_CPUS];
 43
 44static struct cpufreq_driver acpi_cpufreq_driver;
 45
 46
 47static int
 48processor_set_pstate (
 49	u32	value)
 50{
 51	s64 retval;
 52
 53	pr_debug("processor_set_pstate\n");
 54
 55	retval = ia64_pal_set_pstate((u64)value);
 56
 57	if (retval) {
 58		pr_debug("Failed to set freq to 0x%x, with error 0x%lx\n",
 59		        value, retval);
 60		return -ENODEV;
 61	}
 62	return (int)retval;
 63}
 64
 65
 66static int
 67processor_get_pstate (
 68	u32	*value)
 69{
 70	u64	pstate_index = 0;
 71	s64 	retval;
 72
 73	pr_debug("processor_get_pstate\n");
 74
 75	retval = ia64_pal_get_pstate(&pstate_index,
 76	                             PAL_GET_PSTATE_TYPE_INSTANT);
 77	*value = (u32) pstate_index;
 78
 79	if (retval)
 80		pr_debug("Failed to get current freq with "
 81			"error 0x%lx, idx 0x%x\n", retval, *value);
 82
 83	return (int)retval;
 84}
 85
 86
 87/* To be used only after data->acpi_data is initialized */
 88static unsigned
 89extract_clock (
 90	struct cpufreq_acpi_io *data,
 91	unsigned value)
 92{
 93	unsigned long i;
 94
 95	pr_debug("extract_clock\n");
 96
 97	for (i = 0; i < data->acpi_data.state_count; i++) {
 98		if (value == data->acpi_data.states[i].status)
 99			return data->acpi_data.states[i].core_frequency;
100	}
101	return data->acpi_data.states[i-1].core_frequency;
102}
103
104
105static long
106processor_get_freq (
107	void *arg)
108{
109	struct cpufreq_acpi_req *req = arg;
110	unsigned int		cpu = req->cpu;
111	struct cpufreq_acpi_io	*data = acpi_io_data[cpu];
112	u32			value;
113	int			ret;
114
115	pr_debug("processor_get_freq\n");
116	if (smp_processor_id() != cpu)
117		return -EAGAIN;
118
119	/* processor_get_pstate gets the instantaneous frequency */
120	ret = processor_get_pstate(&value);
121	if (ret) {
122		pr_warn("get performance failed with error %d\n", ret);
123		return ret;
124	}
125	return 1000 * extract_clock(data, value);
126}
127
128
129static long
130processor_set_freq (
131	void *arg)
132{
133	struct cpufreq_acpi_req *req = arg;
134	unsigned int		cpu = req->cpu;
135	struct cpufreq_acpi_io	*data = acpi_io_data[cpu];
136	int			ret, state = req->state;
137	u32			value;
138
139	pr_debug("processor_set_freq\n");
140	if (smp_processor_id() != cpu)
141		return -EAGAIN;
142
143	if (state == data->acpi_data.state) {
144		if (unlikely(data->resume)) {
145			pr_debug("Called after resume, resetting to P%d\n", state);
146			data->resume = 0;
147		} else {
148			pr_debug("Already at target state (P%d)\n", state);
149			return 0;
150		}
151	}
152
153	pr_debug("Transitioning from P%d to P%d\n",
154		data->acpi_data.state, state);
155
156	/*
157	 * First we write the target state's 'control' value to the
158	 * control_register.
159	 */
160	value = (u32) data->acpi_data.states[state].control;
161
162	pr_debug("Transitioning to state: 0x%08x\n", value);
163
164	ret = processor_set_pstate(value);
165	if (ret) {
166		pr_warn("Transition failed with error %d\n", ret);
167		return -ENODEV;
168	}
169
170	data->acpi_data.state = state;
171	return 0;
172}
173
174
175static unsigned int
176acpi_cpufreq_get (
177	unsigned int		cpu)
178{
179	struct cpufreq_acpi_req req;
180	long ret;
181
182	req.cpu = cpu;
183	ret = work_on_cpu(cpu, processor_get_freq, &req);
184
185	return ret > 0 ? (unsigned int) ret : 0;
186}
187
188
189static int
190acpi_cpufreq_target (
191	struct cpufreq_policy   *policy,
192	unsigned int index)
193{
194	struct cpufreq_acpi_req req;
195
196	req.cpu = policy->cpu;
197	req.state = index;
198
199	return work_on_cpu(req.cpu, processor_set_freq, &req);
200}
201
202static int
203acpi_cpufreq_cpu_init (
204	struct cpufreq_policy   *policy)
205{
206	unsigned int		i;
207	unsigned int		cpu = policy->cpu;
208	struct cpufreq_acpi_io	*data;
209	unsigned int		result = 0;
210	struct cpufreq_frequency_table *freq_table;
211
212	pr_debug("acpi_cpufreq_cpu_init\n");
213
214	data = kzalloc(sizeof(*data), GFP_KERNEL);
215	if (!data)
216		return (-ENOMEM);
217
218	acpi_io_data[cpu] = data;
219
220	result = acpi_processor_register_performance(&data->acpi_data, cpu);
221
222	if (result)
223		goto err_free;
224
225	/* capability check */
226	if (data->acpi_data.state_count <= 1) {
227		pr_debug("No P-States\n");
228		result = -ENODEV;
229		goto err_unreg;
230	}
231
232	if ((data->acpi_data.control_register.space_id !=
233					ACPI_ADR_SPACE_FIXED_HARDWARE) ||
234	    (data->acpi_data.status_register.space_id !=
235					ACPI_ADR_SPACE_FIXED_HARDWARE)) {
236		pr_debug("Unsupported address space [%d, %d]\n",
237			(u32) (data->acpi_data.control_register.space_id),
238			(u32) (data->acpi_data.status_register.space_id));
239		result = -ENODEV;
240		goto err_unreg;
241	}
242
243	/* alloc freq_table */
244	freq_table = kzalloc(sizeof(*freq_table) *
245	                           (data->acpi_data.state_count + 1),
246	                           GFP_KERNEL);
247	if (!freq_table) {
248		result = -ENOMEM;
249		goto err_unreg;
250	}
251
252	/* detect transition latency */
253	policy->cpuinfo.transition_latency = 0;
254	for (i=0; i<data->acpi_data.state_count; i++) {
255		if ((data->acpi_data.states[i].transition_latency * 1000) >
256		    policy->cpuinfo.transition_latency) {
257			policy->cpuinfo.transition_latency =
258			    data->acpi_data.states[i].transition_latency * 1000;
259		}
260	}
261
262	/* table init */
263	for (i = 0; i <= data->acpi_data.state_count; i++)
264	{
265		if (i < data->acpi_data.state_count) {
266			freq_table[i].frequency =
267			      data->acpi_data.states[i].core_frequency * 1000;
268		} else {
269			freq_table[i].frequency = CPUFREQ_TABLE_END;
270		}
271	}
272
273	policy->freq_table = freq_table;
274
275	/* notify BIOS that we exist */
276	acpi_processor_notify_smm(THIS_MODULE);
277
278	pr_info("CPU%u - ACPI performance management activated\n", cpu);
279
280	for (i = 0; i < data->acpi_data.state_count; i++)
281		pr_debug("     %cP%d: %d MHz, %d mW, %d uS, %d uS, 0x%x 0x%x\n",
282			(i == data->acpi_data.state?'*':' '), i,
283			(u32) data->acpi_data.states[i].core_frequency,
284			(u32) data->acpi_data.states[i].power,
285			(u32) data->acpi_data.states[i].transition_latency,
286			(u32) data->acpi_data.states[i].bus_master_latency,
287			(u32) data->acpi_data.states[i].status,
288			(u32) data->acpi_data.states[i].control);
289
290	/* the first call to ->target() should result in us actually
291	 * writing something to the appropriate registers. */
292	data->resume = 1;
293
294	return (result);
295
296 err_unreg:
297	acpi_processor_unregister_performance(cpu);
298 err_free:
299	kfree(data);
300	acpi_io_data[cpu] = NULL;
301
302	return (result);
303}
304
305
306static int
307acpi_cpufreq_cpu_exit (
308	struct cpufreq_policy   *policy)
309{
310	struct cpufreq_acpi_io *data = acpi_io_data[policy->cpu];
311
312	pr_debug("acpi_cpufreq_cpu_exit\n");
313
314	if (data) {
315		acpi_io_data[policy->cpu] = NULL;
316		acpi_processor_unregister_performance(policy->cpu);
317		kfree(policy->freq_table);
318		kfree(data);
319	}
320
321	return (0);
322}
323
324
325static struct cpufreq_driver acpi_cpufreq_driver = {
326	.verify 	= cpufreq_generic_frequency_table_verify,
327	.target_index	= acpi_cpufreq_target,
328	.get 		= acpi_cpufreq_get,
329	.init		= acpi_cpufreq_cpu_init,
330	.exit		= acpi_cpufreq_cpu_exit,
331	.name		= "acpi-cpufreq",
332	.attr		= cpufreq_generic_attr,
333};
334
335
336static int __init
337acpi_cpufreq_init (void)
338{
339	pr_debug("acpi_cpufreq_init\n");
340
341 	return cpufreq_register_driver(&acpi_cpufreq_driver);
342}
343
344
345static void __exit
346acpi_cpufreq_exit (void)
347{
348	pr_debug("acpi_cpufreq_exit\n");
349
350	cpufreq_unregister_driver(&acpi_cpufreq_driver);
351	return;
352}
353
354
355late_initcall(acpi_cpufreq_init);
356module_exit(acpi_cpufreq_exit);
357