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)
8 * Copyright (C) 2005 Intel Corp
9 * Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
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>
19 #include <asm/uaccess.h>
22 #include <linux/acpi.h>
23 #include <acpi/processor.h>
25 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_DRIVER, "acpi-cpufreq", msg)
27 MODULE_AUTHOR("Venkatesh Pallipadi");
28 MODULE_DESCRIPTION("ACPI Processor P-States Driver");
29 MODULE_LICENSE("GPL");
32 struct cpufreq_acpi_io
{
33 struct acpi_processor_performance acpi_data
;
34 struct cpufreq_frequency_table
*freq_table
;
38 static struct cpufreq_acpi_io
*acpi_io_data
[NR_CPUS
];
40 static struct cpufreq_driver acpi_cpufreq_driver
;
44 processor_set_pstate (
49 dprintk("processor_set_pstate\n");
51 retval
= ia64_pal_set_pstate((u64
)value
);
54 dprintk("Failed to set freq to 0x%x, with error 0x%x\n",
63 processor_get_pstate (
69 dprintk("processor_get_pstate\n");
71 retval
= ia64_pal_get_pstate(&pstate_index
,
72 PAL_GET_PSTATE_TYPE_INSTANT
);
73 *value
= (u32
) pstate_index
;
76 dprintk("Failed to get current freq with "
77 "error 0x%x, idx 0x%x\n", retval
, *value
);
83 /* To be used only after data->acpi_data is initialized */
86 struct cpufreq_acpi_io
*data
,
92 dprintk("extract_clock\n");
94 for (i
= 0; i
< data
->acpi_data
.state_count
; i
++) {
95 if (value
== data
->acpi_data
.states
[i
].status
)
96 return data
->acpi_data
.states
[i
].core_frequency
;
98 return data
->acpi_data
.states
[i
-1].core_frequency
;
104 struct cpufreq_acpi_io
*data
,
109 cpumask_t saved_mask
;
110 unsigned long clock_freq
;
112 dprintk("processor_get_freq\n");
114 saved_mask
= current
->cpus_allowed
;
115 set_cpus_allowed(current
, cpumask_of_cpu(cpu
));
116 if (smp_processor_id() != cpu
) {
121 /* processor_get_pstate gets the instantaneous frequency */
122 ret
= processor_get_pstate(&value
);
125 set_cpus_allowed(current
, saved_mask
);
126 printk(KERN_WARNING
"get performance failed with error %d\n",
131 clock_freq
= extract_clock(data
, value
, cpu
);
132 ret
= (clock_freq
*1000);
135 set_cpus_allowed(current
, saved_mask
);
142 struct cpufreq_acpi_io
*data
,
148 struct cpufreq_freqs cpufreq_freqs
;
149 cpumask_t saved_mask
;
152 dprintk("processor_set_freq\n");
154 saved_mask
= current
->cpus_allowed
;
155 set_cpus_allowed(current
, cpumask_of_cpu(cpu
));
156 if (smp_processor_id() != cpu
) {
161 if (state
== data
->acpi_data
.state
) {
162 if (unlikely(data
->resume
)) {
163 dprintk("Called after resume, resetting to P%d\n", state
);
166 dprintk("Already at target state (P%d)\n", state
);
172 dprintk("Transitioning from P%d to P%d\n",
173 data
->acpi_data
.state
, state
);
175 /* cpufreq frequency struct */
176 cpufreq_freqs
.cpu
= cpu
;
177 cpufreq_freqs
.old
= data
->freq_table
[data
->acpi_data
.state
].frequency
;
178 cpufreq_freqs
.new = data
->freq_table
[state
].frequency
;
181 cpufreq_notify_transition(&cpufreq_freqs
, CPUFREQ_PRECHANGE
);
184 * First we write the target state's 'control' value to the
188 value
= (u32
) data
->acpi_data
.states
[state
].control
;
190 dprintk("Transitioning to state: 0x%08x\n", value
);
192 ret
= processor_set_pstate(value
);
194 unsigned int tmp
= cpufreq_freqs
.new;
195 cpufreq_notify_transition(&cpufreq_freqs
, CPUFREQ_POSTCHANGE
);
196 cpufreq_freqs
.new = cpufreq_freqs
.old
;
197 cpufreq_freqs
.old
= tmp
;
198 cpufreq_notify_transition(&cpufreq_freqs
, CPUFREQ_PRECHANGE
);
199 cpufreq_notify_transition(&cpufreq_freqs
, CPUFREQ_POSTCHANGE
);
200 printk(KERN_WARNING
"Transition failed with error %d\n", ret
);
205 cpufreq_notify_transition(&cpufreq_freqs
, CPUFREQ_POSTCHANGE
);
207 data
->acpi_data
.state
= state
;
212 set_cpus_allowed(current
, saved_mask
);
221 struct cpufreq_acpi_io
*data
= acpi_io_data
[cpu
];
223 dprintk("acpi_cpufreq_get\n");
225 return processor_get_freq(data
, cpu
);
230 acpi_cpufreq_target (
231 struct cpufreq_policy
*policy
,
232 unsigned int target_freq
,
233 unsigned int relation
)
235 struct cpufreq_acpi_io
*data
= acpi_io_data
[policy
->cpu
];
236 unsigned int next_state
= 0;
237 unsigned int result
= 0;
239 dprintk("acpi_cpufreq_setpolicy\n");
241 result
= cpufreq_frequency_table_target(policy
,
242 data
->freq_table
, target_freq
, relation
, &next_state
);
246 result
= processor_set_freq(data
, policy
->cpu
, next_state
);
253 acpi_cpufreq_verify (
254 struct cpufreq_policy
*policy
)
256 unsigned int result
= 0;
257 struct cpufreq_acpi_io
*data
= acpi_io_data
[policy
->cpu
];
259 dprintk("acpi_cpufreq_verify\n");
261 result
= cpufreq_frequency_table_verify(policy
,
269 acpi_cpufreq_cpu_init (
270 struct cpufreq_policy
*policy
)
273 unsigned int cpu
= policy
->cpu
;
274 struct cpufreq_acpi_io
*data
;
275 unsigned int result
= 0;
277 dprintk("acpi_cpufreq_cpu_init\n");
279 data
= kzalloc(sizeof(struct cpufreq_acpi_io
), GFP_KERNEL
);
283 acpi_io_data
[cpu
] = data
;
285 result
= acpi_processor_register_performance(&data
->acpi_data
, cpu
);
290 /* capability check */
291 if (data
->acpi_data
.state_count
<= 1) {
292 dprintk("No P-States\n");
297 if ((data
->acpi_data
.control_register
.space_id
!=
298 ACPI_ADR_SPACE_FIXED_HARDWARE
) ||
299 (data
->acpi_data
.status_register
.space_id
!=
300 ACPI_ADR_SPACE_FIXED_HARDWARE
)) {
301 dprintk("Unsupported address space [%d, %d]\n",
302 (u32
) (data
->acpi_data
.control_register
.space_id
),
303 (u32
) (data
->acpi_data
.status_register
.space_id
));
308 /* alloc freq_table */
309 data
->freq_table
= kmalloc(sizeof(struct cpufreq_frequency_table
) *
310 (data
->acpi_data
.state_count
+ 1),
312 if (!data
->freq_table
) {
317 /* detect transition latency */
318 policy
->cpuinfo
.transition_latency
= 0;
319 for (i
=0; i
<data
->acpi_data
.state_count
; i
++) {
320 if ((data
->acpi_data
.states
[i
].transition_latency
* 1000) >
321 policy
->cpuinfo
.transition_latency
) {
322 policy
->cpuinfo
.transition_latency
=
323 data
->acpi_data
.states
[i
].transition_latency
* 1000;
326 policy
->governor
= CPUFREQ_DEFAULT_GOVERNOR
;
328 policy
->cur
= processor_get_freq(data
, policy
->cpu
);
331 for (i
= 0; i
<= data
->acpi_data
.state_count
; i
++)
333 data
->freq_table
[i
].index
= i
;
334 if (i
< data
->acpi_data
.state_count
) {
335 data
->freq_table
[i
].frequency
=
336 data
->acpi_data
.states
[i
].core_frequency
* 1000;
338 data
->freq_table
[i
].frequency
= CPUFREQ_TABLE_END
;
342 result
= cpufreq_frequency_table_cpuinfo(policy
, data
->freq_table
);
347 /* notify BIOS that we exist */
348 acpi_processor_notify_smm(THIS_MODULE
);
350 printk(KERN_INFO
"acpi-cpufreq: CPU%u - ACPI performance management "
351 "activated.\n", cpu
);
353 for (i
= 0; i
< data
->acpi_data
.state_count
; i
++)
354 dprintk(" %cP%d: %d MHz, %d mW, %d uS, %d uS, 0x%x 0x%x\n",
355 (i
== data
->acpi_data
.state
?'*':' '), i
,
356 (u32
) data
->acpi_data
.states
[i
].core_frequency
,
357 (u32
) data
->acpi_data
.states
[i
].power
,
358 (u32
) data
->acpi_data
.states
[i
].transition_latency
,
359 (u32
) data
->acpi_data
.states
[i
].bus_master_latency
,
360 (u32
) data
->acpi_data
.states
[i
].status
,
361 (u32
) data
->acpi_data
.states
[i
].control
);
363 cpufreq_frequency_table_get_attr(data
->freq_table
, policy
->cpu
);
365 /* the first call to ->target() should result in us actually
366 * writing something to the appropriate registers. */
372 kfree(data
->freq_table
);
374 acpi_processor_unregister_performance(&data
->acpi_data
, cpu
);
377 acpi_io_data
[cpu
] = NULL
;
384 acpi_cpufreq_cpu_exit (
385 struct cpufreq_policy
*policy
)
387 struct cpufreq_acpi_io
*data
= acpi_io_data
[policy
->cpu
];
389 dprintk("acpi_cpufreq_cpu_exit\n");
392 cpufreq_frequency_table_put_attr(policy
->cpu
);
393 acpi_io_data
[policy
->cpu
] = NULL
;
394 acpi_processor_unregister_performance(&data
->acpi_data
,
403 static struct freq_attr
* acpi_cpufreq_attr
[] = {
404 &cpufreq_freq_attr_scaling_available_freqs
,
409 static struct cpufreq_driver acpi_cpufreq_driver
= {
410 .verify
= acpi_cpufreq_verify
,
411 .target
= acpi_cpufreq_target
,
412 .get
= acpi_cpufreq_get
,
413 .init
= acpi_cpufreq_cpu_init
,
414 .exit
= acpi_cpufreq_cpu_exit
,
415 .name
= "acpi-cpufreq",
416 .owner
= THIS_MODULE
,
417 .attr
= acpi_cpufreq_attr
,
422 acpi_cpufreq_init (void)
424 dprintk("acpi_cpufreq_init\n");
426 return cpufreq_register_driver(&acpi_cpufreq_driver
);
431 acpi_cpufreq_exit (void)
433 dprintk("acpi_cpufreq_exit\n");
435 cpufreq_unregister_driver(&acpi_cpufreq_driver
);
440 late_initcall(acpi_cpufreq_init
);
441 module_exit(acpi_cpufreq_exit
);