1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * processor_perflib.c - ACPI Processor P-States Library ($Revision: 71 $)
5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7 * Copyright (C) 2004 Dominik Brodowski <linux@brodo.de>
8 * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
9 * - Added processor hotplug support
12 #define pr_fmt(fmt) "ACPI: " fmt
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/cpufreq.h>
18 #include <linux/slab.h>
19 #include <linux/acpi.h>
20 #include <acpi/processor.h>
22 #include <asm/cpufeature.h>
25 #define ACPI_PROCESSOR_FILE_PERFORMANCE "performance"
27 static DEFINE_MUTEX(performance_mutex
);
30 * _PPC support is implemented as a CPUfreq policy notifier:
31 * This means each time a CPUfreq driver registered also with
32 * the ACPI core is asked to change the speed policy, the maximum
33 * value is adjusted so that it is within the platform limit.
35 * Also, when a new platform limit value is detected, the CPUfreq
36 * policy is adjusted accordingly.
40 * -1 -> cpufreq low level drivers not initialized -> _PSS, etc. not called yet
42 * 0 -> cpufreq low level drivers initialized -> consider _PPC values
43 * 1 -> ignore _PPC totally -> forced by user through boot param
45 static int ignore_ppc
= -1;
46 module_param(ignore_ppc
, int, 0644);
47 MODULE_PARM_DESC(ignore_ppc
, "If the frequency of your machine gets wrongly" \
48 "limited by BIOS, this should help");
50 static bool acpi_processor_ppc_in_use
;
52 static int acpi_processor_get_platform_limit(struct acpi_processor
*pr
)
54 acpi_status status
= 0;
55 unsigned long long ppc
= 0;
62 * _PPC indicates the maximum state currently supported by the platform
63 * (e.g. 0 = states 0..n; 1 = states 1..n; etc.
65 status
= acpi_evaluate_integer(pr
->handle
, "_PPC", NULL
, &ppc
);
66 if (status
!= AE_NOT_FOUND
) {
67 acpi_processor_ppc_in_use
= true;
69 if (ACPI_FAILURE(status
)) {
70 acpi_evaluation_failure_warn(pr
->handle
, "_PPC", status
);
75 pr_debug("CPU %d: _PPC is %d - frequency %s limited\n", pr
->id
,
76 (int)ppc
, ppc
? "" : "not");
78 pr
->performance_platform_limit
= (int)ppc
;
80 if (ppc
>= pr
->performance
->state_count
||
81 unlikely(!freq_qos_request_active(&pr
->perflib_req
)))
84 ret
= freq_qos_update_request(&pr
->perflib_req
,
85 pr
->performance
->states
[ppc
].core_frequency
* 1000);
87 pr_warn("Failed to update perflib freq constraint: CPU%d (%d)\n",
94 #define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80
96 * acpi_processor_ppc_ost: Notify firmware the _PPC evaluation status
97 * @handle: ACPI processor handle
98 * @status: the status code of _PPC evaluation
99 * 0: success. OSPM is now using the performance state specified.
100 * 1: failure. OSPM has not changed the number of P-states in use
102 static void acpi_processor_ppc_ost(acpi_handle handle
, int status
)
104 if (acpi_has_method(handle
, "_OST"))
105 acpi_evaluate_ost(handle
, ACPI_PROCESSOR_NOTIFY_PERFORMANCE
,
109 void acpi_processor_ppc_has_changed(struct acpi_processor
*pr
, int event_flag
)
113 if (ignore_ppc
|| !pr
->performance
) {
115 * Only when it is notification event, the _OST object
116 * will be evaluated. Otherwise it is skipped.
119 acpi_processor_ppc_ost(pr
->handle
, 1);
123 ret
= acpi_processor_get_platform_limit(pr
);
125 * Only when it is notification event, the _OST object
126 * will be evaluated. Otherwise it is skipped.
130 acpi_processor_ppc_ost(pr
->handle
, 1);
132 acpi_processor_ppc_ost(pr
->handle
, 0);
135 cpufreq_update_limits(pr
->id
);
138 int acpi_processor_get_bios_limit(int cpu
, unsigned int *limit
)
140 struct acpi_processor
*pr
;
142 pr
= per_cpu(processors
, cpu
);
143 if (!pr
|| !pr
->performance
|| !pr
->performance
->state_count
)
145 *limit
= pr
->performance
->states
[pr
->performance_platform_limit
].
146 core_frequency
* 1000;
149 EXPORT_SYMBOL(acpi_processor_get_bios_limit
);
151 void acpi_processor_ignore_ppc_init(void)
157 void acpi_processor_ppc_init(struct cpufreq_policy
*policy
)
161 for_each_cpu(cpu
, policy
->related_cpus
) {
162 struct acpi_processor
*pr
= per_cpu(processors
, cpu
);
168 ret
= freq_qos_add_request(&policy
->constraints
,
170 FREQ_QOS_MAX
, INT_MAX
);
172 pr_err("Failed to add freq constraint for CPU%d (%d)\n",
177 void acpi_processor_ppc_exit(struct cpufreq_policy
*policy
)
181 for_each_cpu(cpu
, policy
->related_cpus
) {
182 struct acpi_processor
*pr
= per_cpu(processors
, cpu
);
185 freq_qos_remove_request(&pr
->perflib_req
);
189 static int acpi_processor_get_performance_control(struct acpi_processor
*pr
)
192 acpi_status status
= 0;
193 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
194 union acpi_object
*pct
= NULL
;
195 union acpi_object obj
= { 0 };
197 status
= acpi_evaluate_object(pr
->handle
, "_PCT", NULL
, &buffer
);
198 if (ACPI_FAILURE(status
)) {
199 acpi_evaluation_failure_warn(pr
->handle
, "_PCT", status
);
203 pct
= (union acpi_object
*)buffer
.pointer
;
204 if (!pct
|| (pct
->type
!= ACPI_TYPE_PACKAGE
)
205 || (pct
->package
.count
!= 2)) {
206 pr_err("Invalid _PCT data\n");
215 obj
= pct
->package
.elements
[0];
217 if ((obj
.type
!= ACPI_TYPE_BUFFER
)
218 || (obj
.buffer
.length
< sizeof(struct acpi_pct_register
))
219 || (obj
.buffer
.pointer
== NULL
)) {
220 pr_err("Invalid _PCT data (control_register)\n");
224 memcpy(&pr
->performance
->control_register
, obj
.buffer
.pointer
,
225 sizeof(struct acpi_pct_register
));
231 obj
= pct
->package
.elements
[1];
233 if ((obj
.type
!= ACPI_TYPE_BUFFER
)
234 || (obj
.buffer
.length
< sizeof(struct acpi_pct_register
))
235 || (obj
.buffer
.pointer
== NULL
)) {
236 pr_err("Invalid _PCT data (status_register)\n");
241 memcpy(&pr
->performance
->status_register
, obj
.buffer
.pointer
,
242 sizeof(struct acpi_pct_register
));
245 kfree(buffer
.pointer
);
252 * Some AMDs have 50MHz frequency multiples, but only provide 100MHz rounding
253 * in their ACPI data. Calculate the real values and fix up the _PSS data.
255 static void amd_fixup_frequency(struct acpi_processor_px
*px
, int i
)
257 u32 hi
, lo
, fid
, did
;
258 int index
= px
->control
& 0x00000007;
260 if (boot_cpu_data
.x86_vendor
!= X86_VENDOR_AMD
)
263 if ((boot_cpu_data
.x86
== 0x10 && boot_cpu_data
.x86_model
< 10)
264 || boot_cpu_data
.x86
== 0x11) {
265 rdmsr(MSR_AMD_PSTATE_DEF_BASE
+ index
, lo
, hi
);
268 * Bit 63: PstateEn. Read-write. If set, the P-state is valid.
275 if (boot_cpu_data
.x86
== 0x10)
276 px
->core_frequency
= (100 * (fid
+ 0x10)) >> did
;
278 px
->core_frequency
= (100 * (fid
+ 8)) >> did
;
282 static void amd_fixup_frequency(struct acpi_processor_px
*px
, int i
) {};
285 static int acpi_processor_get_performance_states(struct acpi_processor
*pr
)
288 acpi_status status
= AE_OK
;
289 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
290 struct acpi_buffer format
= { sizeof("NNNNNN"), "NNNNNN" };
291 struct acpi_buffer state
= { 0, NULL
};
292 union acpi_object
*pss
= NULL
;
294 int last_invalid
= -1;
296 status
= acpi_evaluate_object(pr
->handle
, "_PSS", NULL
, &buffer
);
297 if (ACPI_FAILURE(status
)) {
298 acpi_evaluation_failure_warn(pr
->handle
, "_PSS", status
);
302 pss
= buffer
.pointer
;
303 if (!pss
|| (pss
->type
!= ACPI_TYPE_PACKAGE
)) {
304 pr_err("Invalid _PSS data\n");
309 acpi_handle_debug(pr
->handle
, "Found %d performance states\n",
312 pr
->performance
->state_count
= pss
->package
.count
;
313 pr
->performance
->states
=
314 kmalloc_array(pss
->package
.count
,
315 sizeof(struct acpi_processor_px
),
317 if (!pr
->performance
->states
) {
322 for (i
= 0; i
< pr
->performance
->state_count
; i
++) {
324 struct acpi_processor_px
*px
= &(pr
->performance
->states
[i
]);
326 state
.length
= sizeof(struct acpi_processor_px
);
329 acpi_handle_debug(pr
->handle
, "Extracting state %d\n", i
);
331 status
= acpi_extract_package(&(pss
->package
.elements
[i
]),
333 if (ACPI_FAILURE(status
)) {
334 acpi_handle_warn(pr
->handle
, "Invalid _PSS data: %s\n",
335 acpi_format_exception(status
));
337 kfree(pr
->performance
->states
);
341 amd_fixup_frequency(px
, i
);
343 acpi_handle_debug(pr
->handle
,
344 "State [%d]: core_frequency[%d] power[%d] transition_latency[%d] bus_master_latency[%d] control[0x%x] status[0x%x]\n",
346 (u32
) px
->core_frequency
,
348 (u32
) px
->transition_latency
,
349 (u32
) px
->bus_master_latency
,
350 (u32
) px
->control
, (u32
) px
->status
);
353 * Check that ACPI's u64 MHz will be valid as u32 KHz in cpufreq
355 if (!px
->core_frequency
||
356 ((u32
)(px
->core_frequency
* 1000) !=
357 (px
->core_frequency
* 1000))) {
359 "Invalid BIOS _PSS frequency found for processor %d: 0x%llx MHz\n",
360 pr
->id
, px
->core_frequency
);
361 if (last_invalid
== -1)
364 if (last_invalid
!= -1) {
366 * Copy this valid entry over last_invalid entry
368 memcpy(&(pr
->performance
->states
[last_invalid
]),
369 px
, sizeof(struct acpi_processor_px
));
375 if (last_invalid
== 0) {
377 "No valid BIOS _PSS frequency found for processor %d\n", pr
->id
);
379 kfree(pr
->performance
->states
);
380 pr
->performance
->states
= NULL
;
383 if (last_invalid
> 0)
384 pr
->performance
->state_count
= last_invalid
;
387 kfree(buffer
.pointer
);
392 int acpi_processor_get_performance_info(struct acpi_processor
*pr
)
396 if (!pr
|| !pr
->performance
|| !pr
->handle
)
399 if (!acpi_has_method(pr
->handle
, "_PCT")) {
400 acpi_handle_debug(pr
->handle
,
401 "ACPI-based processor performance control unavailable\n");
405 result
= acpi_processor_get_performance_control(pr
);
409 result
= acpi_processor_get_performance_states(pr
);
413 /* We need to call _PPC once when cpufreq starts */
415 result
= acpi_processor_get_platform_limit(pr
);
420 * Having _PPC but missing frequencies (_PSS, _PCT) is a very good hint that
421 * the BIOS is older than the CPU and does not know its frequencies
425 if (acpi_has_method(pr
->handle
, "_PPC")) {
426 if(boot_cpu_has(X86_FEATURE_EST
))
427 pr_warn(FW_BUG
"BIOS needs update for CPU "
428 "frequency support\n");
433 EXPORT_SYMBOL_GPL(acpi_processor_get_performance_info
);
435 int acpi_processor_pstate_control(void)
439 if (!acpi_gbl_FADT
.smi_command
|| !acpi_gbl_FADT
.pstate_control
)
442 pr_debug("Writing pstate_control [0x%x] to smi_command [0x%x]\n",
443 acpi_gbl_FADT
.pstate_control
, acpi_gbl_FADT
.smi_command
);
445 status
= acpi_os_write_port(acpi_gbl_FADT
.smi_command
,
446 (u32
)acpi_gbl_FADT
.pstate_control
, 8);
447 if (ACPI_SUCCESS(status
))
450 pr_warn("Failed to write pstate_control [0x%x] to smi_command [0x%x]: %s\n",
451 acpi_gbl_FADT
.pstate_control
, acpi_gbl_FADT
.smi_command
,
452 acpi_format_exception(status
));
456 int acpi_processor_notify_smm(struct module
*calling_module
)
461 if (!acpi_processor_cpufreq_init
)
464 if (!try_module_get(calling_module
))
467 /* is_done is set to negative if an error occurred,
468 * and to postitive if _no_ error occurred, but SMM
469 * was already notified. This avoids double notification
470 * which might lead to unexpected results...
473 module_put(calling_module
);
475 } else if (is_done
< 0) {
476 module_put(calling_module
);
482 result
= acpi_processor_pstate_control();
484 pr_debug("No SMI port or pstate_control\n");
485 module_put(calling_module
);
489 module_put(calling_module
);
493 /* Success. If there's no _PPC, we need to fear nothing, so
494 * we can allow the cpufreq driver to be rmmod'ed. */
497 if (!acpi_processor_ppc_in_use
)
498 module_put(calling_module
);
503 EXPORT_SYMBOL(acpi_processor_notify_smm
);
505 int acpi_processor_get_psd(acpi_handle handle
, struct acpi_psd_package
*pdomain
)
508 acpi_status status
= AE_OK
;
509 struct acpi_buffer buffer
= {ACPI_ALLOCATE_BUFFER
, NULL
};
510 struct acpi_buffer format
= {sizeof("NNNNN"), "NNNNN"};
511 struct acpi_buffer state
= {0, NULL
};
512 union acpi_object
*psd
= NULL
;
514 status
= acpi_evaluate_object(handle
, "_PSD", NULL
, &buffer
);
515 if (ACPI_FAILURE(status
)) {
519 psd
= buffer
.pointer
;
520 if (!psd
|| (psd
->type
!= ACPI_TYPE_PACKAGE
)) {
521 pr_err("Invalid _PSD data\n");
526 if (psd
->package
.count
!= 1) {
527 pr_err("Invalid _PSD data\n");
532 state
.length
= sizeof(struct acpi_psd_package
);
533 state
.pointer
= pdomain
;
535 status
= acpi_extract_package(&(psd
->package
.elements
[0]),
537 if (ACPI_FAILURE(status
)) {
538 pr_err("Invalid _PSD data\n");
543 if (pdomain
->num_entries
!= ACPI_PSD_REV0_ENTRIES
) {
544 pr_err("Unknown _PSD:num_entries\n");
549 if (pdomain
->revision
!= ACPI_PSD_REV0_REVISION
) {
550 pr_err("Unknown _PSD:revision\n");
555 if (pdomain
->coord_type
!= DOMAIN_COORD_TYPE_SW_ALL
&&
556 pdomain
->coord_type
!= DOMAIN_COORD_TYPE_SW_ANY
&&
557 pdomain
->coord_type
!= DOMAIN_COORD_TYPE_HW_ALL
) {
558 pr_err("Invalid _PSD:coord_type\n");
563 kfree(buffer
.pointer
);
566 EXPORT_SYMBOL(acpi_processor_get_psd
);
568 int acpi_processor_preregister_performance(
569 struct acpi_processor_performance __percpu
*performance
)
574 cpumask_var_t covered_cpus
;
575 struct acpi_processor
*pr
;
576 struct acpi_psd_package
*pdomain
;
577 struct acpi_processor
*match_pr
;
578 struct acpi_psd_package
*match_pdomain
;
580 if (!zalloc_cpumask_var(&covered_cpus
, GFP_KERNEL
))
583 mutex_lock(&performance_mutex
);
586 * Check if another driver has already registered, and abort before
587 * changing pr->performance if it has. Check input data as well.
589 for_each_possible_cpu(i
) {
590 pr
= per_cpu(processors
, i
);
592 /* Look only at processors in ACPI namespace */
596 if (pr
->performance
) {
601 if (!performance
|| !per_cpu_ptr(performance
, i
)) {
607 /* Call _PSD for all CPUs */
608 for_each_possible_cpu(i
) {
609 pr
= per_cpu(processors
, i
);
613 pr
->performance
= per_cpu_ptr(performance
, i
);
614 pdomain
= &(pr
->performance
->domain_info
);
615 if (acpi_processor_get_psd(pr
->handle
, pdomain
)) {
624 * Now that we have _PSD data from all CPUs, lets setup P-state
627 for_each_possible_cpu(i
) {
628 pr
= per_cpu(processors
, i
);
632 if (cpumask_test_cpu(i
, covered_cpus
))
635 pdomain
= &(pr
->performance
->domain_info
);
636 cpumask_set_cpu(i
, pr
->performance
->shared_cpu_map
);
637 cpumask_set_cpu(i
, covered_cpus
);
638 if (pdomain
->num_processors
<= 1)
641 /* Validate the Domain info */
642 count_target
= pdomain
->num_processors
;
643 if (pdomain
->coord_type
== DOMAIN_COORD_TYPE_SW_ALL
)
644 pr
->performance
->shared_type
= CPUFREQ_SHARED_TYPE_ALL
;
645 else if (pdomain
->coord_type
== DOMAIN_COORD_TYPE_HW_ALL
)
646 pr
->performance
->shared_type
= CPUFREQ_SHARED_TYPE_HW
;
647 else if (pdomain
->coord_type
== DOMAIN_COORD_TYPE_SW_ANY
)
648 pr
->performance
->shared_type
= CPUFREQ_SHARED_TYPE_ANY
;
650 for_each_possible_cpu(j
) {
654 match_pr
= per_cpu(processors
, j
);
658 match_pdomain
= &(match_pr
->performance
->domain_info
);
659 if (match_pdomain
->domain
!= pdomain
->domain
)
662 /* Here i and j are in the same domain */
664 if (match_pdomain
->num_processors
!= count_target
) {
669 if (pdomain
->coord_type
!= match_pdomain
->coord_type
) {
674 cpumask_set_cpu(j
, covered_cpus
);
675 cpumask_set_cpu(j
, pr
->performance
->shared_cpu_map
);
678 for_each_possible_cpu(j
) {
682 match_pr
= per_cpu(processors
, j
);
686 match_pdomain
= &(match_pr
->performance
->domain_info
);
687 if (match_pdomain
->domain
!= pdomain
->domain
)
690 match_pr
->performance
->shared_type
=
691 pr
->performance
->shared_type
;
692 cpumask_copy(match_pr
->performance
->shared_cpu_map
,
693 pr
->performance
->shared_cpu_map
);
698 for_each_possible_cpu(i
) {
699 pr
= per_cpu(processors
, i
);
700 if (!pr
|| !pr
->performance
)
703 /* Assume no coordination on any error parsing domain info */
705 cpumask_clear(pr
->performance
->shared_cpu_map
);
706 cpumask_set_cpu(i
, pr
->performance
->shared_cpu_map
);
707 pr
->performance
->shared_type
= CPUFREQ_SHARED_TYPE_NONE
;
709 pr
->performance
= NULL
; /* Will be set for real in register */
713 mutex_unlock(&performance_mutex
);
714 free_cpumask_var(covered_cpus
);
717 EXPORT_SYMBOL(acpi_processor_preregister_performance
);
720 acpi_processor_register_performance(struct acpi_processor_performance
721 *performance
, unsigned int cpu
)
723 struct acpi_processor
*pr
;
725 if (!acpi_processor_cpufreq_init
)
728 mutex_lock(&performance_mutex
);
730 pr
= per_cpu(processors
, cpu
);
732 mutex_unlock(&performance_mutex
);
736 if (pr
->performance
) {
737 mutex_unlock(&performance_mutex
);
741 WARN_ON(!performance
);
743 pr
->performance
= performance
;
745 if (acpi_processor_get_performance_info(pr
)) {
746 pr
->performance
= NULL
;
747 mutex_unlock(&performance_mutex
);
751 mutex_unlock(&performance_mutex
);
755 EXPORT_SYMBOL(acpi_processor_register_performance
);
757 void acpi_processor_unregister_performance(unsigned int cpu
)
759 struct acpi_processor
*pr
;
761 mutex_lock(&performance_mutex
);
763 pr
= per_cpu(processors
, cpu
);
765 mutex_unlock(&performance_mutex
);
770 kfree(pr
->performance
->states
);
771 pr
->performance
= NULL
;
773 mutex_unlock(&performance_mutex
);
778 EXPORT_SYMBOL(acpi_processor_unregister_performance
);