2 * processor_perflib.c - ACPI Processor P-States Library ($Revision: 71 $)
4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 * Copyright (C) 2004 Dominik Brodowski <linux@brodo.de>
7 * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
8 * - Added processor hotplug support
11 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or (at
16 * your option) any later version.
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/init.h>
28 #include <linux/cpufreq.h>
29 #include <linux/slab.h>
30 #include <linux/acpi.h>
31 #include <acpi/processor.h>
33 #include <asm/cpufeature.h>
36 #define PREFIX "ACPI: "
38 #define ACPI_PROCESSOR_CLASS "processor"
39 #define ACPI_PROCESSOR_FILE_PERFORMANCE "performance"
40 #define _COMPONENT ACPI_PROCESSOR_COMPONENT
41 ACPI_MODULE_NAME("processor_perflib");
43 static DEFINE_MUTEX(performance_mutex
);
46 * _PPC support is implemented as a CPUfreq policy notifier:
47 * This means each time a CPUfreq driver registered also with
48 * the ACPI core is asked to change the speed policy, the maximum
49 * value is adjusted so that it is within the platform limit.
51 * Also, when a new platform limit value is detected, the CPUfreq
52 * policy is adjusted accordingly.
56 * -1 -> cpufreq low level drivers not initialized -> _PSS, etc. not called yet
58 * 0 -> cpufreq low level drivers initialized -> consider _PPC values
59 * 1 -> ignore _PPC totally -> forced by user through boot param
61 static int ignore_ppc
= -1;
62 module_param(ignore_ppc
, int, 0644);
63 MODULE_PARM_DESC(ignore_ppc
, "If the frequency of your machine gets wrongly" \
64 "limited by BIOS, this should help");
66 #define PPC_REGISTERED 1
69 static int acpi_processor_ppc_status
;
71 static int acpi_processor_ppc_notifier(struct notifier_block
*nb
,
72 unsigned long event
, void *data
)
74 struct cpufreq_policy
*policy
= data
;
75 struct acpi_processor
*pr
;
78 if (event
== CPUFREQ_START
&& ignore_ppc
<= 0) {
86 if (event
!= CPUFREQ_ADJUST
)
89 mutex_lock(&performance_mutex
);
91 pr
= per_cpu(processors
, policy
->cpu
);
92 if (!pr
|| !pr
->performance
)
95 ppc
= (unsigned int)pr
->performance_platform_limit
;
97 if (ppc
>= pr
->performance
->state_count
)
100 cpufreq_verify_within_limits(policy
, 0,
101 pr
->performance
->states
[ppc
].
102 core_frequency
* 1000);
105 mutex_unlock(&performance_mutex
);
110 static struct notifier_block acpi_ppc_notifier_block
= {
111 .notifier_call
= acpi_processor_ppc_notifier
,
114 static int acpi_processor_get_platform_limit(struct acpi_processor
*pr
)
116 acpi_status status
= 0;
117 unsigned long long ppc
= 0;
124 * _PPC indicates the maximum state currently supported by the platform
125 * (e.g. 0 = states 0..n; 1 = states 1..n; etc.
127 status
= acpi_evaluate_integer(pr
->handle
, "_PPC", NULL
, &ppc
);
129 if (status
!= AE_NOT_FOUND
)
130 acpi_processor_ppc_status
|= PPC_IN_USE
;
132 if (ACPI_FAILURE(status
) && status
!= AE_NOT_FOUND
) {
133 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PPC"));
137 pr_debug("CPU %d: _PPC is %d - frequency %s limited\n", pr
->id
,
138 (int)ppc
, ppc
? "" : "not");
140 pr
->performance_platform_limit
= (int)ppc
;
145 #define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80
147 * acpi_processor_ppc_ost: Notify firmware the _PPC evaluation status
148 * @handle: ACPI processor handle
149 * @status: the status code of _PPC evaluation
150 * 0: success. OSPM is now using the performance state specificed.
151 * 1: failure. OSPM has not changed the number of P-states in use
153 static void acpi_processor_ppc_ost(acpi_handle handle
, int status
)
155 if (acpi_has_method(handle
, "_OST"))
156 acpi_evaluate_ost(handle
, ACPI_PROCESSOR_NOTIFY_PERFORMANCE
,
160 void acpi_processor_ppc_has_changed(struct acpi_processor
*pr
, int event_flag
)
166 * Only when it is notification event, the _OST object
167 * will be evaluated. Otherwise it is skipped.
170 acpi_processor_ppc_ost(pr
->handle
, 1);
174 ret
= acpi_processor_get_platform_limit(pr
);
176 * Only when it is notification event, the _OST object
177 * will be evaluated. Otherwise it is skipped.
181 acpi_processor_ppc_ost(pr
->handle
, 1);
183 acpi_processor_ppc_ost(pr
->handle
, 0);
186 cpufreq_update_policy(pr
->id
);
189 int acpi_processor_get_bios_limit(int cpu
, unsigned int *limit
)
191 struct acpi_processor
*pr
;
193 pr
= per_cpu(processors
, cpu
);
194 if (!pr
|| !pr
->performance
|| !pr
->performance
->state_count
)
196 *limit
= pr
->performance
->states
[pr
->performance_platform_limit
].
197 core_frequency
* 1000;
200 EXPORT_SYMBOL(acpi_processor_get_bios_limit
);
202 void acpi_processor_ppc_init(void)
204 if (!cpufreq_register_notifier
205 (&acpi_ppc_notifier_block
, CPUFREQ_POLICY_NOTIFIER
))
206 acpi_processor_ppc_status
|= PPC_REGISTERED
;
209 "Warning: Processor Platform Limit not supported.\n");
212 void acpi_processor_ppc_exit(void)
214 if (acpi_processor_ppc_status
& PPC_REGISTERED
)
215 cpufreq_unregister_notifier(&acpi_ppc_notifier_block
,
216 CPUFREQ_POLICY_NOTIFIER
);
218 acpi_processor_ppc_status
&= ~PPC_REGISTERED
;
221 static int acpi_processor_get_performance_control(struct acpi_processor
*pr
)
224 acpi_status status
= 0;
225 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
226 union acpi_object
*pct
= NULL
;
227 union acpi_object obj
= { 0 };
230 status
= acpi_evaluate_object(pr
->handle
, "_PCT", NULL
, &buffer
);
231 if (ACPI_FAILURE(status
)) {
232 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PCT"));
236 pct
= (union acpi_object
*)buffer
.pointer
;
237 if (!pct
|| (pct
->type
!= ACPI_TYPE_PACKAGE
)
238 || (pct
->package
.count
!= 2)) {
239 printk(KERN_ERR PREFIX
"Invalid _PCT data\n");
248 obj
= pct
->package
.elements
[0];
250 if ((obj
.type
!= ACPI_TYPE_BUFFER
)
251 || (obj
.buffer
.length
< sizeof(struct acpi_pct_register
))
252 || (obj
.buffer
.pointer
== NULL
)) {
253 printk(KERN_ERR PREFIX
"Invalid _PCT data (control_register)\n");
257 memcpy(&pr
->performance
->control_register
, obj
.buffer
.pointer
,
258 sizeof(struct acpi_pct_register
));
264 obj
= pct
->package
.elements
[1];
266 if ((obj
.type
!= ACPI_TYPE_BUFFER
)
267 || (obj
.buffer
.length
< sizeof(struct acpi_pct_register
))
268 || (obj
.buffer
.pointer
== NULL
)) {
269 printk(KERN_ERR PREFIX
"Invalid _PCT data (status_register)\n");
274 memcpy(&pr
->performance
->status_register
, obj
.buffer
.pointer
,
275 sizeof(struct acpi_pct_register
));
278 kfree(buffer
.pointer
);
285 * Some AMDs have 50MHz frequency multiples, but only provide 100MHz rounding
286 * in their ACPI data. Calculate the real values and fix up the _PSS data.
288 static void amd_fixup_frequency(struct acpi_processor_px
*px
, int i
)
290 u32 hi
, lo
, fid
, did
;
291 int index
= px
->control
& 0x00000007;
293 if (boot_cpu_data
.x86_vendor
!= X86_VENDOR_AMD
)
296 if ((boot_cpu_data
.x86
== 0x10 && boot_cpu_data
.x86_model
< 10)
297 || boot_cpu_data
.x86
== 0x11) {
298 rdmsr(MSR_AMD_PSTATE_DEF_BASE
+ index
, lo
, hi
);
301 * Bit 63: PstateEn. Read-write. If set, the P-state is valid.
308 if (boot_cpu_data
.x86
== 0x10)
309 px
->core_frequency
= (100 * (fid
+ 0x10)) >> did
;
311 px
->core_frequency
= (100 * (fid
+ 8)) >> did
;
315 static void amd_fixup_frequency(struct acpi_processor_px
*px
, int i
) {};
318 static int acpi_processor_get_performance_states(struct acpi_processor
*pr
)
321 acpi_status status
= AE_OK
;
322 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
323 struct acpi_buffer format
= { sizeof("NNNNNN"), "NNNNNN" };
324 struct acpi_buffer state
= { 0, NULL
};
325 union acpi_object
*pss
= NULL
;
327 int last_invalid
= -1;
330 status
= acpi_evaluate_object(pr
->handle
, "_PSS", NULL
, &buffer
);
331 if (ACPI_FAILURE(status
)) {
332 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PSS"));
336 pss
= buffer
.pointer
;
337 if (!pss
|| (pss
->type
!= ACPI_TYPE_PACKAGE
)) {
338 printk(KERN_ERR PREFIX
"Invalid _PSS data\n");
343 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Found %d performance states\n",
344 pss
->package
.count
));
346 pr
->performance
->state_count
= pss
->package
.count
;
347 pr
->performance
->states
=
348 kmalloc(sizeof(struct acpi_processor_px
) * pss
->package
.count
,
350 if (!pr
->performance
->states
) {
355 for (i
= 0; i
< pr
->performance
->state_count
; i
++) {
357 struct acpi_processor_px
*px
= &(pr
->performance
->states
[i
]);
359 state
.length
= sizeof(struct acpi_processor_px
);
362 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Extracting state %d\n", i
));
364 status
= acpi_extract_package(&(pss
->package
.elements
[i
]),
366 if (ACPI_FAILURE(status
)) {
367 ACPI_EXCEPTION((AE_INFO
, status
, "Invalid _PSS data"));
369 kfree(pr
->performance
->states
);
373 amd_fixup_frequency(px
, i
);
375 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
376 "State [%d]: core_frequency[%d] power[%d] transition_latency[%d] bus_master_latency[%d] control[0x%x] status[0x%x]\n",
378 (u32
) px
->core_frequency
,
380 (u32
) px
->transition_latency
,
381 (u32
) px
->bus_master_latency
,
382 (u32
) px
->control
, (u32
) px
->status
));
385 * Check that ACPI's u64 MHz will be valid as u32 KHz in cpufreq
387 if (!px
->core_frequency
||
388 ((u32
)(px
->core_frequency
* 1000) !=
389 (px
->core_frequency
* 1000))) {
390 printk(KERN_ERR FW_BUG PREFIX
391 "Invalid BIOS _PSS frequency found for processor %d: 0x%llx MHz\n",
392 pr
->id
, px
->core_frequency
);
393 if (last_invalid
== -1)
396 if (last_invalid
!= -1) {
398 * Copy this valid entry over last_invalid entry
400 memcpy(&(pr
->performance
->states
[last_invalid
]),
401 px
, sizeof(struct acpi_processor_px
));
407 if (last_invalid
== 0) {
408 printk(KERN_ERR FW_BUG PREFIX
409 "No valid BIOS _PSS frequency found for processor %d\n", pr
->id
);
411 kfree(pr
->performance
->states
);
412 pr
->performance
->states
= NULL
;
415 if (last_invalid
> 0)
416 pr
->performance
->state_count
= last_invalid
;
419 kfree(buffer
.pointer
);
424 int acpi_processor_get_performance_info(struct acpi_processor
*pr
)
428 if (!pr
|| !pr
->performance
|| !pr
->handle
)
431 if (!acpi_has_method(pr
->handle
, "_PCT")) {
432 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
433 "ACPI-based processor performance control unavailable\n"));
437 result
= acpi_processor_get_performance_control(pr
);
441 result
= acpi_processor_get_performance_states(pr
);
445 /* We need to call _PPC once when cpufreq starts */
447 result
= acpi_processor_get_platform_limit(pr
);
452 * Having _PPC but missing frequencies (_PSS, _PCT) is a very good hint that
453 * the BIOS is older than the CPU and does not know its frequencies
457 if (acpi_has_method(pr
->handle
, "_PPC")) {
458 if(boot_cpu_has(X86_FEATURE_EST
))
459 printk(KERN_WARNING FW_BUG
"BIOS needs update for CPU "
460 "frequency support\n");
465 EXPORT_SYMBOL_GPL(acpi_processor_get_performance_info
);
467 int acpi_processor_pstate_control(void)
471 if (!acpi_gbl_FADT
.smi_command
|| !acpi_gbl_FADT
.pstate_control
)
474 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
475 "Writing pstate_control [0x%x] to smi_command [0x%x]\n",
476 acpi_gbl_FADT
.pstate_control
, acpi_gbl_FADT
.smi_command
));
478 status
= acpi_os_write_port(acpi_gbl_FADT
.smi_command
,
479 (u32
)acpi_gbl_FADT
.pstate_control
, 8);
480 if (ACPI_SUCCESS(status
))
483 ACPI_EXCEPTION((AE_INFO
, status
,
484 "Failed to write pstate_control [0x%x] to smi_command [0x%x]",
485 acpi_gbl_FADT
.pstate_control
, acpi_gbl_FADT
.smi_command
));
489 int acpi_processor_notify_smm(struct module
*calling_module
)
491 static int is_done
= 0;
494 if (!(acpi_processor_ppc_status
& PPC_REGISTERED
))
497 if (!try_module_get(calling_module
))
500 /* is_done is set to negative if an error occurred,
501 * and to postitive if _no_ error occurred, but SMM
502 * was already notified. This avoids double notification
503 * which might lead to unexpected results...
506 module_put(calling_module
);
508 } else if (is_done
< 0) {
509 module_put(calling_module
);
515 result
= acpi_processor_pstate_control();
517 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "No SMI port or pstate_control\n"));
518 module_put(calling_module
);
522 module_put(calling_module
);
526 /* Success. If there's no _PPC, we need to fear nothing, so
527 * we can allow the cpufreq driver to be rmmod'ed. */
530 if (!(acpi_processor_ppc_status
& PPC_IN_USE
))
531 module_put(calling_module
);
536 EXPORT_SYMBOL(acpi_processor_notify_smm
);
538 static int acpi_processor_get_psd(struct acpi_processor
*pr
)
541 acpi_status status
= AE_OK
;
542 struct acpi_buffer buffer
= {ACPI_ALLOCATE_BUFFER
, NULL
};
543 struct acpi_buffer format
= {sizeof("NNNNN"), "NNNNN"};
544 struct acpi_buffer state
= {0, NULL
};
545 union acpi_object
*psd
= NULL
;
546 struct acpi_psd_package
*pdomain
;
548 status
= acpi_evaluate_object(pr
->handle
, "_PSD", NULL
, &buffer
);
549 if (ACPI_FAILURE(status
)) {
553 psd
= buffer
.pointer
;
554 if (!psd
|| (psd
->type
!= ACPI_TYPE_PACKAGE
)) {
555 printk(KERN_ERR PREFIX
"Invalid _PSD data\n");
560 if (psd
->package
.count
!= 1) {
561 printk(KERN_ERR PREFIX
"Invalid _PSD data\n");
566 pdomain
= &(pr
->performance
->domain_info
);
568 state
.length
= sizeof(struct acpi_psd_package
);
569 state
.pointer
= pdomain
;
571 status
= acpi_extract_package(&(psd
->package
.elements
[0]),
573 if (ACPI_FAILURE(status
)) {
574 printk(KERN_ERR PREFIX
"Invalid _PSD data\n");
579 if (pdomain
->num_entries
!= ACPI_PSD_REV0_ENTRIES
) {
580 printk(KERN_ERR PREFIX
"Unknown _PSD:num_entries\n");
585 if (pdomain
->revision
!= ACPI_PSD_REV0_REVISION
) {
586 printk(KERN_ERR PREFIX
"Unknown _PSD:revision\n");
591 if (pdomain
->coord_type
!= DOMAIN_COORD_TYPE_SW_ALL
&&
592 pdomain
->coord_type
!= DOMAIN_COORD_TYPE_SW_ANY
&&
593 pdomain
->coord_type
!= DOMAIN_COORD_TYPE_HW_ALL
) {
594 printk(KERN_ERR PREFIX
"Invalid _PSD:coord_type\n");
599 kfree(buffer
.pointer
);
603 int acpi_processor_preregister_performance(
604 struct acpi_processor_performance __percpu
*performance
)
609 cpumask_var_t covered_cpus
;
610 struct acpi_processor
*pr
;
611 struct acpi_psd_package
*pdomain
;
612 struct acpi_processor
*match_pr
;
613 struct acpi_psd_package
*match_pdomain
;
615 if (!zalloc_cpumask_var(&covered_cpus
, GFP_KERNEL
))
618 mutex_lock(&performance_mutex
);
621 * Check if another driver has already registered, and abort before
622 * changing pr->performance if it has. Check input data as well.
624 for_each_possible_cpu(i
) {
625 pr
= per_cpu(processors
, i
);
627 /* Look only at processors in ACPI namespace */
631 if (pr
->performance
) {
636 if (!performance
|| !per_cpu_ptr(performance
, i
)) {
642 /* Call _PSD for all CPUs */
643 for_each_possible_cpu(i
) {
644 pr
= per_cpu(processors
, i
);
648 pr
->performance
= per_cpu_ptr(performance
, i
);
649 cpumask_set_cpu(i
, pr
->performance
->shared_cpu_map
);
650 if (acpi_processor_get_psd(pr
)) {
659 * Now that we have _PSD data from all CPUs, lets setup P-state
662 for_each_possible_cpu(i
) {
663 pr
= per_cpu(processors
, i
);
667 if (cpumask_test_cpu(i
, covered_cpus
))
670 pdomain
= &(pr
->performance
->domain_info
);
671 cpumask_set_cpu(i
, pr
->performance
->shared_cpu_map
);
672 cpumask_set_cpu(i
, covered_cpus
);
673 if (pdomain
->num_processors
<= 1)
676 /* Validate the Domain info */
677 count_target
= pdomain
->num_processors
;
678 if (pdomain
->coord_type
== DOMAIN_COORD_TYPE_SW_ALL
)
679 pr
->performance
->shared_type
= CPUFREQ_SHARED_TYPE_ALL
;
680 else if (pdomain
->coord_type
== DOMAIN_COORD_TYPE_HW_ALL
)
681 pr
->performance
->shared_type
= CPUFREQ_SHARED_TYPE_HW
;
682 else if (pdomain
->coord_type
== DOMAIN_COORD_TYPE_SW_ANY
)
683 pr
->performance
->shared_type
= CPUFREQ_SHARED_TYPE_ANY
;
685 for_each_possible_cpu(j
) {
689 match_pr
= per_cpu(processors
, j
);
693 match_pdomain
= &(match_pr
->performance
->domain_info
);
694 if (match_pdomain
->domain
!= pdomain
->domain
)
697 /* Here i and j are in the same domain */
699 if (match_pdomain
->num_processors
!= count_target
) {
704 if (pdomain
->coord_type
!= match_pdomain
->coord_type
) {
709 cpumask_set_cpu(j
, covered_cpus
);
710 cpumask_set_cpu(j
, pr
->performance
->shared_cpu_map
);
713 for_each_possible_cpu(j
) {
717 match_pr
= per_cpu(processors
, j
);
721 match_pdomain
= &(match_pr
->performance
->domain_info
);
722 if (match_pdomain
->domain
!= pdomain
->domain
)
725 match_pr
->performance
->shared_type
=
726 pr
->performance
->shared_type
;
727 cpumask_copy(match_pr
->performance
->shared_cpu_map
,
728 pr
->performance
->shared_cpu_map
);
733 for_each_possible_cpu(i
) {
734 pr
= per_cpu(processors
, i
);
735 if (!pr
|| !pr
->performance
)
738 /* Assume no coordination on any error parsing domain info */
740 cpumask_clear(pr
->performance
->shared_cpu_map
);
741 cpumask_set_cpu(i
, pr
->performance
->shared_cpu_map
);
742 pr
->performance
->shared_type
= CPUFREQ_SHARED_TYPE_ALL
;
744 pr
->performance
= NULL
; /* Will be set for real in register */
748 mutex_unlock(&performance_mutex
);
749 free_cpumask_var(covered_cpus
);
752 EXPORT_SYMBOL(acpi_processor_preregister_performance
);
755 acpi_processor_register_performance(struct acpi_processor_performance
756 *performance
, unsigned int cpu
)
758 struct acpi_processor
*pr
;
760 if (!(acpi_processor_ppc_status
& PPC_REGISTERED
))
763 mutex_lock(&performance_mutex
);
765 pr
= per_cpu(processors
, cpu
);
767 mutex_unlock(&performance_mutex
);
771 if (pr
->performance
) {
772 mutex_unlock(&performance_mutex
);
776 WARN_ON(!performance
);
778 pr
->performance
= performance
;
780 if (acpi_processor_get_performance_info(pr
)) {
781 pr
->performance
= NULL
;
782 mutex_unlock(&performance_mutex
);
786 mutex_unlock(&performance_mutex
);
790 EXPORT_SYMBOL(acpi_processor_register_performance
);
792 void acpi_processor_unregister_performance(unsigned int cpu
)
794 struct acpi_processor
*pr
;
796 mutex_lock(&performance_mutex
);
798 pr
= per_cpu(processors
, cpu
);
800 mutex_unlock(&performance_mutex
);
805 kfree(pr
->performance
->states
);
806 pr
->performance
= NULL
;
808 mutex_unlock(&performance_mutex
);
813 EXPORT_SYMBOL(acpi_processor_unregister_performance
);