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/slab.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/cpufreq.h>
17 #include <linux/proc_fs.h>
18 #include <linux/seq_file.h>
20 #include <asm/uaccess.h>
23 #include <linux/acpi.h>
24 #include <acpi/processor.h>
26 MODULE_AUTHOR("Venkatesh Pallipadi");
27 MODULE_DESCRIPTION("ACPI Processor P-States Driver");
28 MODULE_LICENSE("GPL");
31 struct cpufreq_acpi_io
{
32 struct acpi_processor_performance acpi_data
;
33 struct cpufreq_frequency_table
*freq_table
;
37 static struct cpufreq_acpi_io
*acpi_io_data
[NR_CPUS
];
39 static struct cpufreq_driver acpi_cpufreq_driver
;
43 processor_set_pstate (
48 pr_debug("processor_set_pstate\n");
50 retval
= ia64_pal_set_pstate((u64
)value
);
53 pr_debug("Failed to set freq to 0x%x, with error 0x%lx\n",
62 processor_get_pstate (
68 pr_debug("processor_get_pstate\n");
70 retval
= ia64_pal_get_pstate(&pstate_index
,
71 PAL_GET_PSTATE_TYPE_INSTANT
);
72 *value
= (u32
) pstate_index
;
75 pr_debug("Failed to get current freq with "
76 "error 0x%lx, idx 0x%x\n", retval
, *value
);
82 /* To be used only after data->acpi_data is initialized */
85 struct cpufreq_acpi_io
*data
,
91 pr_debug("extract_clock\n");
93 for (i
= 0; i
< data
->acpi_data
.state_count
; i
++) {
94 if (value
== data
->acpi_data
.states
[i
].status
)
95 return data
->acpi_data
.states
[i
].core_frequency
;
97 return data
->acpi_data
.states
[i
-1].core_frequency
;
103 struct cpufreq_acpi_io
*data
,
108 cpumask_t saved_mask
;
109 unsigned long clock_freq
;
111 pr_debug("processor_get_freq\n");
113 saved_mask
= current
->cpus_allowed
;
114 set_cpus_allowed_ptr(current
, cpumask_of(cpu
));
115 if (smp_processor_id() != cpu
)
118 /* processor_get_pstate gets the instantaneous frequency */
119 ret
= processor_get_pstate(&value
);
122 set_cpus_allowed_ptr(current
, &saved_mask
);
123 printk(KERN_WARNING
"get performance failed with error %d\n",
128 clock_freq
= extract_clock(data
, value
, cpu
);
129 ret
= (clock_freq
*1000);
132 set_cpus_allowed_ptr(current
, &saved_mask
);
139 struct cpufreq_acpi_io
*data
,
140 struct cpufreq_policy
*policy
,
145 struct cpufreq_freqs cpufreq_freqs
;
146 cpumask_t saved_mask
;
149 pr_debug("processor_set_freq\n");
151 saved_mask
= current
->cpus_allowed
;
152 set_cpus_allowed_ptr(current
, cpumask_of(policy
->cpu
));
153 if (smp_processor_id() != policy
->cpu
) {
158 if (state
== data
->acpi_data
.state
) {
159 if (unlikely(data
->resume
)) {
160 pr_debug("Called after resume, resetting to P%d\n", state
);
163 pr_debug("Already at target state (P%d)\n", state
);
169 pr_debug("Transitioning from P%d to P%d\n",
170 data
->acpi_data
.state
, state
);
172 /* cpufreq frequency struct */
173 cpufreq_freqs
.old
= data
->freq_table
[data
->acpi_data
.state
].frequency
;
174 cpufreq_freqs
.new = data
->freq_table
[state
].frequency
;
177 cpufreq_notify_transition(policy
, &cpufreq_freqs
, CPUFREQ_PRECHANGE
);
180 * First we write the target state's 'control' value to the
184 value
= (u32
) data
->acpi_data
.states
[state
].control
;
186 pr_debug("Transitioning to state: 0x%08x\n", value
);
188 ret
= processor_set_pstate(value
);
190 unsigned int tmp
= cpufreq_freqs
.new;
191 cpufreq_notify_transition(policy
, &cpufreq_freqs
,
193 cpufreq_freqs
.new = cpufreq_freqs
.old
;
194 cpufreq_freqs
.old
= tmp
;
195 cpufreq_notify_transition(policy
, &cpufreq_freqs
,
197 cpufreq_notify_transition(policy
, &cpufreq_freqs
,
199 printk(KERN_WARNING
"Transition failed with error %d\n", ret
);
204 cpufreq_notify_transition(policy
, &cpufreq_freqs
, CPUFREQ_POSTCHANGE
);
206 data
->acpi_data
.state
= state
;
211 set_cpus_allowed_ptr(current
, &saved_mask
);
220 struct cpufreq_acpi_io
*data
= acpi_io_data
[cpu
];
222 pr_debug("acpi_cpufreq_get\n");
224 return processor_get_freq(data
, cpu
);
229 acpi_cpufreq_target (
230 struct cpufreq_policy
*policy
,
231 unsigned int target_freq
,
232 unsigned int relation
)
234 struct cpufreq_acpi_io
*data
= acpi_io_data
[policy
->cpu
];
235 unsigned int next_state
= 0;
236 unsigned int result
= 0;
238 pr_debug("acpi_cpufreq_setpolicy\n");
240 result
= cpufreq_frequency_table_target(policy
,
241 data
->freq_table
, target_freq
, relation
, &next_state
);
245 result
= processor_set_freq(data
, policy
, next_state
);
252 acpi_cpufreq_verify (
253 struct cpufreq_policy
*policy
)
255 unsigned int result
= 0;
256 struct cpufreq_acpi_io
*data
= acpi_io_data
[policy
->cpu
];
258 pr_debug("acpi_cpufreq_verify\n");
260 result
= cpufreq_frequency_table_verify(policy
,
268 acpi_cpufreq_cpu_init (
269 struct cpufreq_policy
*policy
)
272 unsigned int cpu
= policy
->cpu
;
273 struct cpufreq_acpi_io
*data
;
274 unsigned int result
= 0;
276 pr_debug("acpi_cpufreq_cpu_init\n");
278 data
= kzalloc(sizeof(struct cpufreq_acpi_io
), GFP_KERNEL
);
282 acpi_io_data
[cpu
] = data
;
284 result
= acpi_processor_register_performance(&data
->acpi_data
, cpu
);
289 /* capability check */
290 if (data
->acpi_data
.state_count
<= 1) {
291 pr_debug("No P-States\n");
296 if ((data
->acpi_data
.control_register
.space_id
!=
297 ACPI_ADR_SPACE_FIXED_HARDWARE
) ||
298 (data
->acpi_data
.status_register
.space_id
!=
299 ACPI_ADR_SPACE_FIXED_HARDWARE
)) {
300 pr_debug("Unsupported address space [%d, %d]\n",
301 (u32
) (data
->acpi_data
.control_register
.space_id
),
302 (u32
) (data
->acpi_data
.status_register
.space_id
));
307 /* alloc freq_table */
308 data
->freq_table
= kmalloc(sizeof(struct cpufreq_frequency_table
) *
309 (data
->acpi_data
.state_count
+ 1),
311 if (!data
->freq_table
) {
316 /* detect transition latency */
317 policy
->cpuinfo
.transition_latency
= 0;
318 for (i
=0; i
<data
->acpi_data
.state_count
; i
++) {
319 if ((data
->acpi_data
.states
[i
].transition_latency
* 1000) >
320 policy
->cpuinfo
.transition_latency
) {
321 policy
->cpuinfo
.transition_latency
=
322 data
->acpi_data
.states
[i
].transition_latency
* 1000;
325 policy
->cur
= processor_get_freq(data
, policy
->cpu
);
328 for (i
= 0; i
<= data
->acpi_data
.state_count
; i
++)
330 data
->freq_table
[i
].index
= i
;
331 if (i
< data
->acpi_data
.state_count
) {
332 data
->freq_table
[i
].frequency
=
333 data
->acpi_data
.states
[i
].core_frequency
* 1000;
335 data
->freq_table
[i
].frequency
= CPUFREQ_TABLE_END
;
339 result
= cpufreq_frequency_table_cpuinfo(policy
, data
->freq_table
);
344 /* notify BIOS that we exist */
345 acpi_processor_notify_smm(THIS_MODULE
);
347 printk(KERN_INFO
"acpi-cpufreq: CPU%u - ACPI performance management "
348 "activated.\n", cpu
);
350 for (i
= 0; i
< data
->acpi_data
.state_count
; i
++)
351 pr_debug(" %cP%d: %d MHz, %d mW, %d uS, %d uS, 0x%x 0x%x\n",
352 (i
== data
->acpi_data
.state
?'*':' '), i
,
353 (u32
) data
->acpi_data
.states
[i
].core_frequency
,
354 (u32
) data
->acpi_data
.states
[i
].power
,
355 (u32
) data
->acpi_data
.states
[i
].transition_latency
,
356 (u32
) data
->acpi_data
.states
[i
].bus_master_latency
,
357 (u32
) data
->acpi_data
.states
[i
].status
,
358 (u32
) data
->acpi_data
.states
[i
].control
);
360 cpufreq_frequency_table_get_attr(data
->freq_table
, policy
->cpu
);
362 /* the first call to ->target() should result in us actually
363 * writing something to the appropriate registers. */
369 kfree(data
->freq_table
);
371 acpi_processor_unregister_performance(&data
->acpi_data
, cpu
);
374 acpi_io_data
[cpu
] = NULL
;
381 acpi_cpufreq_cpu_exit (
382 struct cpufreq_policy
*policy
)
384 struct cpufreq_acpi_io
*data
= acpi_io_data
[policy
->cpu
];
386 pr_debug("acpi_cpufreq_cpu_exit\n");
389 cpufreq_frequency_table_put_attr(policy
->cpu
);
390 acpi_io_data
[policy
->cpu
] = NULL
;
391 acpi_processor_unregister_performance(&data
->acpi_data
,
400 static struct freq_attr
* acpi_cpufreq_attr
[] = {
401 &cpufreq_freq_attr_scaling_available_freqs
,
406 static struct cpufreq_driver acpi_cpufreq_driver
= {
407 .verify
= acpi_cpufreq_verify
,
408 .target
= acpi_cpufreq_target
,
409 .get
= acpi_cpufreq_get
,
410 .init
= acpi_cpufreq_cpu_init
,
411 .exit
= acpi_cpufreq_cpu_exit
,
412 .name
= "acpi-cpufreq",
413 .owner
= THIS_MODULE
,
414 .attr
= acpi_cpufreq_attr
,
419 acpi_cpufreq_init (void)
421 pr_debug("acpi_cpufreq_init\n");
423 return cpufreq_register_driver(&acpi_cpufreq_driver
);
428 acpi_cpufreq_exit (void)
430 pr_debug("acpi_cpufreq_exit\n");
432 cpufreq_unregister_driver(&acpi_cpufreq_driver
);
437 late_initcall(acpi_cpufreq_init
);
438 module_exit(acpi_cpufreq_exit
);