2 * processor_throttling.c - Throttling submodule of the ACPI processor driver
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
10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or (at
15 * your option) any later version.
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/slab.h>
28 #include <linux/init.h>
29 #include <linux/sched.h>
30 #include <linux/cpufreq.h>
31 #include <linux/acpi.h>
32 #include <acpi/processor.h>
34 #include <asm/uaccess.h>
36 #define PREFIX "ACPI: "
38 #define ACPI_PROCESSOR_CLASS "processor"
39 #define _COMPONENT ACPI_PROCESSOR_COMPONENT
40 ACPI_MODULE_NAME("processor_throttling");
43 * 0 -> acpi processor driver doesn't ignore _TPC values
44 * 1 -> acpi processor driver ignores _TPC values
46 static int ignore_tpc
;
47 module_param(ignore_tpc
, int, 0644);
48 MODULE_PARM_DESC(ignore_tpc
, "Disable broken BIOS _TPC throttling support");
50 struct throttling_tstate
{
51 unsigned int cpu
; /* cpu nr */
52 int target_state
; /* target T-state */
55 struct acpi_processor_throttling_arg
{
56 struct acpi_processor
*pr
;
61 #define THROTTLING_PRECHANGE (1)
62 #define THROTTLING_POSTCHANGE (2)
64 static int acpi_processor_get_throttling(struct acpi_processor
*pr
);
65 static int __acpi_processor_set_throttling(struct acpi_processor
*pr
,
66 int state
, bool force
, bool direct
);
68 static int acpi_processor_update_tsd_coord(void)
70 int count
, count_target
;
73 cpumask_var_t covered_cpus
;
74 struct acpi_processor
*pr
, *match_pr
;
75 struct acpi_tsd_package
*pdomain
, *match_pdomain
;
76 struct acpi_processor_throttling
*pthrottling
, *match_pthrottling
;
78 if (!zalloc_cpumask_var(&covered_cpus
, GFP_KERNEL
))
82 * Now that we have _TSD data from all CPUs, lets setup T-state
83 * coordination between all CPUs.
85 for_each_possible_cpu(i
) {
86 pr
= per_cpu(processors
, i
);
90 /* Basic validity check for domain info */
91 pthrottling
= &(pr
->throttling
);
94 * If tsd package for one cpu is invalid, the coordination
95 * among all CPUs is thought as invalid.
98 if (!pthrottling
->tsd_valid_flag
) {
106 for_each_possible_cpu(i
) {
107 pr
= per_cpu(processors
, i
);
111 if (cpumask_test_cpu(i
, covered_cpus
))
113 pthrottling
= &pr
->throttling
;
115 pdomain
= &(pthrottling
->domain_info
);
116 cpumask_set_cpu(i
, pthrottling
->shared_cpu_map
);
117 cpumask_set_cpu(i
, covered_cpus
);
119 * If the number of processor in the TSD domain is 1, it is
120 * unnecessary to parse the coordination for this CPU.
122 if (pdomain
->num_processors
<= 1)
125 /* Validate the Domain info */
126 count_target
= pdomain
->num_processors
;
129 for_each_possible_cpu(j
) {
133 match_pr
= per_cpu(processors
, j
);
137 match_pthrottling
= &(match_pr
->throttling
);
138 match_pdomain
= &(match_pthrottling
->domain_info
);
139 if (match_pdomain
->domain
!= pdomain
->domain
)
142 /* Here i and j are in the same domain.
143 * If two TSD packages have the same domain, they
144 * should have the same num_porcessors and
145 * coordination type. Otherwise it will be regarded
148 if (match_pdomain
->num_processors
!= count_target
) {
153 if (pdomain
->coord_type
!= match_pdomain
->coord_type
) {
158 cpumask_set_cpu(j
, covered_cpus
);
159 cpumask_set_cpu(j
, pthrottling
->shared_cpu_map
);
162 for_each_possible_cpu(j
) {
166 match_pr
= per_cpu(processors
, j
);
170 match_pthrottling
= &(match_pr
->throttling
);
171 match_pdomain
= &(match_pthrottling
->domain_info
);
172 if (match_pdomain
->domain
!= pdomain
->domain
)
176 * If some CPUS have the same domain, they
177 * will have the same shared_cpu_map.
179 cpumask_copy(match_pthrottling
->shared_cpu_map
,
180 pthrottling
->shared_cpu_map
);
185 free_cpumask_var(covered_cpus
);
187 for_each_possible_cpu(i
) {
188 pr
= per_cpu(processors
, i
);
193 * Assume no coordination on any error parsing domain info.
194 * The coordination type will be forced as SW_ALL.
197 pthrottling
= &(pr
->throttling
);
198 cpumask_clear(pthrottling
->shared_cpu_map
);
199 cpumask_set_cpu(i
, pthrottling
->shared_cpu_map
);
200 pthrottling
->shared_type
= DOMAIN_COORD_TYPE_SW_ALL
;
208 * Update the T-state coordination after the _TSD
209 * data for all cpus is obtained.
211 void acpi_processor_throttling_init(void)
213 if (acpi_processor_update_tsd_coord()) {
214 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
215 "Assume no T-state coordination\n"));
221 static int acpi_processor_throttling_notifier(unsigned long event
, void *data
)
223 struct throttling_tstate
*p_tstate
= data
;
224 struct acpi_processor
*pr
;
227 struct acpi_processor_limit
*p_limit
;
228 struct acpi_processor_throttling
*p_throttling
;
231 pr
= per_cpu(processors
, cpu
);
233 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Invalid pr pointer\n"));
236 if (!pr
->flags
.throttling
) {
237 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Throttling control is "
238 "unsupported on CPU %d\n", cpu
));
241 target_state
= p_tstate
->target_state
;
242 p_throttling
= &(pr
->throttling
);
244 case THROTTLING_PRECHANGE
:
246 * Prechange event is used to choose one proper t-state,
247 * which meets the limits of thermal, user and _TPC.
249 p_limit
= &pr
->limit
;
250 if (p_limit
->thermal
.tx
> target_state
)
251 target_state
= p_limit
->thermal
.tx
;
252 if (p_limit
->user
.tx
> target_state
)
253 target_state
= p_limit
->user
.tx
;
254 if (pr
->throttling_platform_limit
> target_state
)
255 target_state
= pr
->throttling_platform_limit
;
256 if (target_state
>= p_throttling
->state_count
) {
258 "Exceed the limit of T-state \n");
259 target_state
= p_throttling
->state_count
- 1;
261 p_tstate
->target_state
= target_state
;
262 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "PreChange Event:"
263 "target T-state of CPU %d is T%d\n",
266 case THROTTLING_POSTCHANGE
:
268 * Postchange event is only used to update the
269 * T-state flag of acpi_processor_throttling.
271 p_throttling
->state
= target_state
;
272 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "PostChange Event:"
273 "CPU %d is switched to T%d\n",
278 "Unsupported Throttling notifier event\n");
286 * _TPC - Throttling Present Capabilities
288 static int acpi_processor_get_platform_limit(struct acpi_processor
*pr
)
290 acpi_status status
= 0;
291 unsigned long long tpc
= 0;
299 status
= acpi_evaluate_integer(pr
->handle
, "_TPC", NULL
, &tpc
);
300 if (ACPI_FAILURE(status
)) {
301 if (status
!= AE_NOT_FOUND
) {
302 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _TPC"));
308 pr
->throttling_platform_limit
= (int)tpc
;
312 int acpi_processor_tstate_has_changed(struct acpi_processor
*pr
)
315 int throttling_limit
;
317 struct acpi_processor_limit
*limit
;
323 result
= acpi_processor_get_platform_limit(pr
);
325 /* Throttling Limit is unsupported */
329 throttling_limit
= pr
->throttling_platform_limit
;
330 if (throttling_limit
>= pr
->throttling
.state_count
) {
331 /* Uncorrect Throttling Limit */
335 current_state
= pr
->throttling
.state
;
336 if (current_state
> throttling_limit
) {
338 * The current state can meet the requirement of
339 * _TPC limit. But it is reasonable that OSPM changes
340 * t-states from high to low for better performance.
341 * Of course the limit condition of thermal
342 * and user should be considered.
345 target_state
= throttling_limit
;
346 if (limit
->thermal
.tx
> target_state
)
347 target_state
= limit
->thermal
.tx
;
348 if (limit
->user
.tx
> target_state
)
349 target_state
= limit
->user
.tx
;
350 } else if (current_state
== throttling_limit
) {
352 * Unnecessary to change the throttling state
357 * If the current state is lower than the limit of _TPC, it
358 * will be forced to switch to the throttling state defined
359 * by throttling_platfor_limit.
360 * Because the previous state meets with the limit condition
361 * of thermal and user, it is unnecessary to check it again.
363 target_state
= throttling_limit
;
365 return acpi_processor_set_throttling(pr
, target_state
, false);
369 * This function is used to reevaluate whether the T-state is valid
370 * after one CPU is onlined/offlined.
371 * It is noted that it won't reevaluate the following properties for
374 * 2. the number of supported T-state
377 void acpi_processor_reevaluate_tstate(struct acpi_processor
*pr
,
378 unsigned long action
)
382 if (action
== CPU_DEAD
) {
383 /* When one CPU is offline, the T-state throttling
384 * will be invalidated.
386 pr
->flags
.throttling
= 0;
389 /* the following is to recheck whether the T-state is valid for
392 if (!pr
->throttling
.state_count
) {
393 /* If the number of T-state is invalid, it is
396 pr
->flags
.throttling
= 0;
399 pr
->flags
.throttling
= 1;
401 /* Disable throttling (if enabled). We'll let subsequent
402 * policy (e.g.thermal) decide to lower performance if it
403 * so chooses, but for now we'll crank up the speed.
406 result
= acpi_processor_get_throttling(pr
);
410 if (pr
->throttling
.state
) {
411 result
= acpi_processor_set_throttling(pr
, 0, false);
418 pr
->flags
.throttling
= 0;
421 * _PTC - Processor Throttling Control (and status) register location
423 static int acpi_processor_get_throttling_control(struct acpi_processor
*pr
)
426 acpi_status status
= 0;
427 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
428 union acpi_object
*ptc
= NULL
;
429 union acpi_object obj
= { 0 };
430 struct acpi_processor_throttling
*throttling
;
432 status
= acpi_evaluate_object(pr
->handle
, "_PTC", NULL
, &buffer
);
433 if (ACPI_FAILURE(status
)) {
434 if (status
!= AE_NOT_FOUND
) {
435 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _PTC"));
440 ptc
= (union acpi_object
*)buffer
.pointer
;
441 if (!ptc
|| (ptc
->type
!= ACPI_TYPE_PACKAGE
)
442 || (ptc
->package
.count
!= 2)) {
443 printk(KERN_ERR PREFIX
"Invalid _PTC data\n");
452 obj
= ptc
->package
.elements
[0];
454 if ((obj
.type
!= ACPI_TYPE_BUFFER
)
455 || (obj
.buffer
.length
< sizeof(struct acpi_ptc_register
))
456 || (obj
.buffer
.pointer
== NULL
)) {
457 printk(KERN_ERR PREFIX
458 "Invalid _PTC data (control_register)\n");
462 memcpy(&pr
->throttling
.control_register
, obj
.buffer
.pointer
,
463 sizeof(struct acpi_ptc_register
));
469 obj
= ptc
->package
.elements
[1];
471 if ((obj
.type
!= ACPI_TYPE_BUFFER
)
472 || (obj
.buffer
.length
< sizeof(struct acpi_ptc_register
))
473 || (obj
.buffer
.pointer
== NULL
)) {
474 printk(KERN_ERR PREFIX
"Invalid _PTC data (status_register)\n");
479 memcpy(&pr
->throttling
.status_register
, obj
.buffer
.pointer
,
480 sizeof(struct acpi_ptc_register
));
482 throttling
= &pr
->throttling
;
484 if ((throttling
->control_register
.bit_width
+
485 throttling
->control_register
.bit_offset
) > 32) {
486 printk(KERN_ERR PREFIX
"Invalid _PTC control register\n");
491 if ((throttling
->status_register
.bit_width
+
492 throttling
->status_register
.bit_offset
) > 32) {
493 printk(KERN_ERR PREFIX
"Invalid _PTC status register\n");
499 kfree(buffer
.pointer
);
505 * _TSS - Throttling Supported States
507 static int acpi_processor_get_throttling_states(struct acpi_processor
*pr
)
510 acpi_status status
= AE_OK
;
511 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
512 struct acpi_buffer format
= { sizeof("NNNNN"), "NNNNN" };
513 struct acpi_buffer state
= { 0, NULL
};
514 union acpi_object
*tss
= NULL
;
517 status
= acpi_evaluate_object(pr
->handle
, "_TSS", NULL
, &buffer
);
518 if (ACPI_FAILURE(status
)) {
519 if (status
!= AE_NOT_FOUND
) {
520 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _TSS"));
525 tss
= buffer
.pointer
;
526 if (!tss
|| (tss
->type
!= ACPI_TYPE_PACKAGE
)) {
527 printk(KERN_ERR PREFIX
"Invalid _TSS data\n");
532 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Found %d throttling states\n",
533 tss
->package
.count
));
535 pr
->throttling
.state_count
= tss
->package
.count
;
536 pr
->throttling
.states_tss
=
537 kmalloc(sizeof(struct acpi_processor_tx_tss
) * tss
->package
.count
,
539 if (!pr
->throttling
.states_tss
) {
544 for (i
= 0; i
< pr
->throttling
.state_count
; i
++) {
546 struct acpi_processor_tx_tss
*tx
=
547 (struct acpi_processor_tx_tss
*)&(pr
->throttling
.
550 state
.length
= sizeof(struct acpi_processor_tx_tss
);
553 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Extracting state %d\n", i
));
555 status
= acpi_extract_package(&(tss
->package
.elements
[i
]),
557 if (ACPI_FAILURE(status
)) {
558 ACPI_EXCEPTION((AE_INFO
, status
, "Invalid _TSS data"));
560 kfree(pr
->throttling
.states_tss
);
564 if (!tx
->freqpercentage
) {
565 printk(KERN_ERR PREFIX
566 "Invalid _TSS data: freq is zero\n");
568 kfree(pr
->throttling
.states_tss
);
574 kfree(buffer
.pointer
);
580 * _TSD - T-State Dependencies
582 static int acpi_processor_get_tsd(struct acpi_processor
*pr
)
585 acpi_status status
= AE_OK
;
586 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
587 struct acpi_buffer format
= { sizeof("NNNNN"), "NNNNN" };
588 struct acpi_buffer state
= { 0, NULL
};
589 union acpi_object
*tsd
= NULL
;
590 struct acpi_tsd_package
*pdomain
;
591 struct acpi_processor_throttling
*pthrottling
;
593 pthrottling
= &pr
->throttling
;
594 pthrottling
->tsd_valid_flag
= 0;
596 status
= acpi_evaluate_object(pr
->handle
, "_TSD", NULL
, &buffer
);
597 if (ACPI_FAILURE(status
)) {
598 if (status
!= AE_NOT_FOUND
) {
599 ACPI_EXCEPTION((AE_INFO
, status
, "Evaluating _TSD"));
604 tsd
= buffer
.pointer
;
605 if (!tsd
|| (tsd
->type
!= ACPI_TYPE_PACKAGE
)) {
606 printk(KERN_ERR PREFIX
"Invalid _TSD data\n");
611 if (tsd
->package
.count
!= 1) {
612 printk(KERN_ERR PREFIX
"Invalid _TSD data\n");
617 pdomain
= &(pr
->throttling
.domain_info
);
619 state
.length
= sizeof(struct acpi_tsd_package
);
620 state
.pointer
= pdomain
;
622 status
= acpi_extract_package(&(tsd
->package
.elements
[0]),
624 if (ACPI_FAILURE(status
)) {
625 printk(KERN_ERR PREFIX
"Invalid _TSD data\n");
630 if (pdomain
->num_entries
!= ACPI_TSD_REV0_ENTRIES
) {
631 printk(KERN_ERR PREFIX
"Unknown _TSD:num_entries\n");
636 if (pdomain
->revision
!= ACPI_TSD_REV0_REVISION
) {
637 printk(KERN_ERR PREFIX
"Unknown _TSD:revision\n");
642 pthrottling
= &pr
->throttling
;
643 pthrottling
->tsd_valid_flag
= 1;
644 pthrottling
->shared_type
= pdomain
->coord_type
;
645 cpumask_set_cpu(pr
->id
, pthrottling
->shared_cpu_map
);
647 * If the coordination type is not defined in ACPI spec,
648 * the tsd_valid_flag will be clear and coordination type
649 * will be forecd as DOMAIN_COORD_TYPE_SW_ALL.
651 if (pdomain
->coord_type
!= DOMAIN_COORD_TYPE_SW_ALL
&&
652 pdomain
->coord_type
!= DOMAIN_COORD_TYPE_SW_ANY
&&
653 pdomain
->coord_type
!= DOMAIN_COORD_TYPE_HW_ALL
) {
654 pthrottling
->tsd_valid_flag
= 0;
655 pthrottling
->shared_type
= DOMAIN_COORD_TYPE_SW_ALL
;
659 kfree(buffer
.pointer
);
663 /* --------------------------------------------------------------------------
665 -------------------------------------------------------------------------- */
666 static int acpi_processor_get_throttling_fadt(struct acpi_processor
*pr
)
676 if (!pr
->flags
.throttling
)
680 * We don't care about error returns - we just try to mark
681 * these reserved so that nobody else is confused into thinking
682 * that this region might be unused..
684 * (In particular, allocating the IO range for Cardbus)
686 request_region(pr
->throttling
.address
, 6, "ACPI CPU throttle");
688 pr
->throttling
.state
= 0;
690 duty_mask
= pr
->throttling
.state_count
- 1;
692 duty_mask
<<= pr
->throttling
.duty_offset
;
696 value
= inl(pr
->throttling
.address
);
699 * Compute the current throttling state when throttling is enabled
703 duty_value
= value
& duty_mask
;
704 duty_value
>>= pr
->throttling
.duty_offset
;
707 state
= pr
->throttling
.state_count
- duty_value
;
710 pr
->throttling
.state
= state
;
714 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
715 "Throttling state is T%d (%d%% throttling applied)\n",
716 state
, pr
->throttling
.states
[state
].performance
));
722 static int acpi_throttling_rdmsr(u64
*value
)
724 u64 msr_high
, msr_low
;
728 if ((this_cpu_read(cpu_info
.x86_vendor
) != X86_VENDOR_INTEL
) ||
729 !this_cpu_has(X86_FEATURE_ACPI
)) {
730 printk(KERN_ERR PREFIX
731 "HARDWARE addr space,NOT supported yet\n");
735 rdmsr_safe(MSR_IA32_THERM_CONTROL
,
736 (u32
*)&msr_low
, (u32
*) &msr_high
);
737 msr
= (msr_high
<< 32) | msr_low
;
744 static int acpi_throttling_wrmsr(u64 value
)
749 if ((this_cpu_read(cpu_info
.x86_vendor
) != X86_VENDOR_INTEL
) ||
750 !this_cpu_has(X86_FEATURE_ACPI
)) {
751 printk(KERN_ERR PREFIX
752 "HARDWARE addr space,NOT supported yet\n");
755 wrmsr_safe(MSR_IA32_THERM_CONTROL
,
756 msr
& 0xffffffff, msr
>> 32);
762 static int acpi_throttling_rdmsr(u64
*value
)
764 printk(KERN_ERR PREFIX
765 "HARDWARE addr space,NOT supported yet\n");
769 static int acpi_throttling_wrmsr(u64 value
)
771 printk(KERN_ERR PREFIX
772 "HARDWARE addr space,NOT supported yet\n");
777 static int acpi_read_throttling_status(struct acpi_processor
*pr
,
780 u32 bit_width
, bit_offset
;
783 struct acpi_processor_throttling
*throttling
;
786 throttling
= &pr
->throttling
;
787 switch (throttling
->status_register
.space_id
) {
788 case ACPI_ADR_SPACE_SYSTEM_IO
:
789 bit_width
= throttling
->status_register
.bit_width
;
790 bit_offset
= throttling
->status_register
.bit_offset
;
792 acpi_os_read_port((acpi_io_address
) throttling
->status_register
.
794 (u32
) (bit_width
+ bit_offset
));
795 ptc_mask
= (1 << bit_width
) - 1;
796 *value
= (u64
) ((ptc_value
>> bit_offset
) & ptc_mask
);
799 case ACPI_ADR_SPACE_FIXED_HARDWARE
:
800 ret
= acpi_throttling_rdmsr(value
);
803 printk(KERN_ERR PREFIX
"Unknown addr space %d\n",
804 (u32
) (throttling
->status_register
.space_id
));
809 static int acpi_write_throttling_state(struct acpi_processor
*pr
,
812 u32 bit_width
, bit_offset
;
815 struct acpi_processor_throttling
*throttling
;
818 throttling
= &pr
->throttling
;
819 switch (throttling
->control_register
.space_id
) {
820 case ACPI_ADR_SPACE_SYSTEM_IO
:
821 bit_width
= throttling
->control_register
.bit_width
;
822 bit_offset
= throttling
->control_register
.bit_offset
;
823 ptc_mask
= (1 << bit_width
) - 1;
824 ptc_value
= value
& ptc_mask
;
826 acpi_os_write_port((acpi_io_address
) throttling
->
827 control_register
.address
,
828 (u32
) (ptc_value
<< bit_offset
),
829 (u32
) (bit_width
+ bit_offset
));
832 case ACPI_ADR_SPACE_FIXED_HARDWARE
:
833 ret
= acpi_throttling_wrmsr(value
);
836 printk(KERN_ERR PREFIX
"Unknown addr space %d\n",
837 (u32
) (throttling
->control_register
.space_id
));
842 static int acpi_get_throttling_state(struct acpi_processor
*pr
,
847 for (i
= 0; i
< pr
->throttling
.state_count
; i
++) {
848 struct acpi_processor_tx_tss
*tx
=
849 (struct acpi_processor_tx_tss
*)&(pr
->throttling
.
851 if (tx
->control
== value
)
857 static int acpi_get_throttling_value(struct acpi_processor
*pr
,
858 int state
, u64
*value
)
862 if (state
>= 0 && state
<= pr
->throttling
.state_count
) {
863 struct acpi_processor_tx_tss
*tx
=
864 (struct acpi_processor_tx_tss
*)&(pr
->throttling
.
866 *value
= tx
->control
;
872 static int acpi_processor_get_throttling_ptc(struct acpi_processor
*pr
)
881 if (!pr
->flags
.throttling
)
884 pr
->throttling
.state
= 0;
887 ret
= acpi_read_throttling_status(pr
, &value
);
889 state
= acpi_get_throttling_state(pr
, value
);
891 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
892 "Invalid throttling state, reset\n"));
894 ret
= __acpi_processor_set_throttling(pr
, state
, true,
899 pr
->throttling
.state
= state
;
905 static long __acpi_processor_get_throttling(void *data
)
907 struct acpi_processor
*pr
= data
;
909 return pr
->throttling
.acpi_processor_get_throttling(pr
);
912 static int acpi_processor_get_throttling(struct acpi_processor
*pr
)
917 if (!pr
->flags
.throttling
)
921 * This is either called from the CPU hotplug callback of
922 * processor_driver or via the ACPI probe function. In the latter
923 * case the CPU is not guaranteed to be online. Both call sites are
924 * protected against CPU hotplug.
926 if (!cpu_online(pr
->id
))
929 return work_on_cpu(pr
->id
, __acpi_processor_get_throttling
, pr
);
932 static int acpi_processor_get_fadt_info(struct acpi_processor
*pr
)
936 if (!pr
->throttling
.address
) {
937 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "No throttling register\n"));
939 } else if (!pr
->throttling
.duty_width
) {
940 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "No throttling states\n"));
943 /* TBD: Support duty_cycle values that span bit 4. */
944 else if ((pr
->throttling
.duty_offset
+ pr
->throttling
.duty_width
) > 4) {
945 printk(KERN_WARNING PREFIX
"duty_cycle spans bit 4\n");
949 pr
->throttling
.state_count
= 1 << acpi_gbl_FADT
.duty_width
;
952 * Compute state values. Note that throttling displays a linear power
953 * performance relationship (at 50% performance the CPU will consume
954 * 50% power). Values are in 1/10th of a percent to preserve accuracy.
957 step
= (1000 / pr
->throttling
.state_count
);
959 for (i
= 0; i
< pr
->throttling
.state_count
; i
++) {
960 pr
->throttling
.states
[i
].performance
= 1000 - step
* i
;
961 pr
->throttling
.states
[i
].power
= 1000 - step
* i
;
966 static int acpi_processor_set_throttling_fadt(struct acpi_processor
*pr
,
967 int state
, bool force
)
976 if ((state
< 0) || (state
> (pr
->throttling
.state_count
- 1)))
979 if (!pr
->flags
.throttling
)
982 if (!force
&& (state
== pr
->throttling
.state
))
985 if (state
< pr
->throttling_platform_limit
)
988 * Calculate the duty_value and duty_mask.
991 duty_value
= pr
->throttling
.state_count
- state
;
993 duty_value
<<= pr
->throttling
.duty_offset
;
995 /* Used to clear all duty_value bits */
996 duty_mask
= pr
->throttling
.state_count
- 1;
998 duty_mask
<<= acpi_gbl_FADT
.duty_offset
;
999 duty_mask
= ~duty_mask
;
1002 local_irq_disable();
1005 * Disable throttling by writing a 0 to bit 4. Note that we must
1006 * turn it off before you can change the duty_value.
1008 value
= inl(pr
->throttling
.address
);
1010 value
&= 0xFFFFFFEF;
1011 outl(value
, pr
->throttling
.address
);
1015 * Write the new duty_value and then enable throttling. Note
1016 * that a state value of 0 leaves throttling disabled.
1020 value
|= duty_value
;
1021 outl(value
, pr
->throttling
.address
);
1023 value
|= 0x00000010;
1024 outl(value
, pr
->throttling
.address
);
1027 pr
->throttling
.state
= state
;
1031 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
1032 "Throttling state set to T%d (%d%%)\n", state
,
1033 (pr
->throttling
.states
[state
].performance
? pr
->
1034 throttling
.states
[state
].performance
/ 10 : 0)));
1039 static int acpi_processor_set_throttling_ptc(struct acpi_processor
*pr
,
1040 int state
, bool force
)
1048 if ((state
< 0) || (state
> (pr
->throttling
.state_count
- 1)))
1051 if (!pr
->flags
.throttling
)
1054 if (!force
&& (state
== pr
->throttling
.state
))
1057 if (state
< pr
->throttling_platform_limit
)
1061 ret
= acpi_get_throttling_value(pr
, state
, &value
);
1063 acpi_write_throttling_state(pr
, value
);
1064 pr
->throttling
.state
= state
;
1070 static long acpi_processor_throttling_fn(void *data
)
1072 struct acpi_processor_throttling_arg
*arg
= data
;
1073 struct acpi_processor
*pr
= arg
->pr
;
1075 return pr
->throttling
.acpi_processor_set_throttling(pr
,
1076 arg
->target_state
, arg
->force
);
1079 static int call_on_cpu(int cpu
, long (*fn
)(void *), void *arg
, bool direct
)
1083 return work_on_cpu(cpu
, fn
, arg
);
1086 static int __acpi_processor_set_throttling(struct acpi_processor
*pr
,
1087 int state
, bool force
, bool direct
)
1091 struct acpi_processor
*match_pr
;
1092 struct acpi_processor_throttling
*p_throttling
;
1093 struct acpi_processor_throttling_arg arg
;
1094 struct throttling_tstate t_state
;
1099 if (!pr
->flags
.throttling
)
1102 if ((state
< 0) || (state
> (pr
->throttling
.state_count
- 1)))
1105 if (cpu_is_offline(pr
->id
)) {
1107 * the cpu pointed by pr->id is offline. Unnecessary to change
1108 * the throttling state any more.
1113 t_state
.target_state
= state
;
1114 p_throttling
= &(pr
->throttling
);
1117 * The throttling notifier will be called for every
1118 * affected cpu in order to get one proper T-state.
1119 * The notifier event is THROTTLING_PRECHANGE.
1121 for_each_cpu_and(i
, cpu_online_mask
, p_throttling
->shared_cpu_map
) {
1123 acpi_processor_throttling_notifier(THROTTLING_PRECHANGE
,
1127 * The function of acpi_processor_set_throttling will be called
1128 * to switch T-state. If the coordination type is SW_ALL or HW_ALL,
1129 * it is necessary to call it for every affected cpu. Otherwise
1130 * it can be called only for the cpu pointed by pr.
1132 if (p_throttling
->shared_type
== DOMAIN_COORD_TYPE_SW_ANY
) {
1134 arg
.target_state
= state
;
1136 ret
= call_on_cpu(pr
->id
, acpi_processor_throttling_fn
, &arg
,
1140 * When the T-state coordination is SW_ALL or HW_ALL,
1141 * it is necessary to set T-state for every affected
1144 for_each_cpu_and(i
, cpu_online_mask
,
1145 p_throttling
->shared_cpu_map
) {
1146 match_pr
= per_cpu(processors
, i
);
1148 * If the pointer is invalid, we will report the
1149 * error message and continue.
1152 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
1153 "Invalid Pointer for CPU %d\n", i
));
1157 * If the throttling control is unsupported on CPU i,
1158 * we will report the error message and continue.
1160 if (!match_pr
->flags
.throttling
) {
1161 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
1162 "Throttling Control is unsupported "
1168 arg
.target_state
= state
;
1170 ret
= call_on_cpu(pr
->id
, acpi_processor_throttling_fn
,
1175 * After the set_throttling is called, the
1176 * throttling notifier is called for every
1177 * affected cpu to update the T-states.
1178 * The notifier event is THROTTLING_POSTCHANGE
1180 for_each_cpu_and(i
, cpu_online_mask
, p_throttling
->shared_cpu_map
) {
1182 acpi_processor_throttling_notifier(THROTTLING_POSTCHANGE
,
1189 int acpi_processor_set_throttling(struct acpi_processor
*pr
, int state
,
1192 return __acpi_processor_set_throttling(pr
, state
, force
, false);
1195 int acpi_processor_get_throttling_info(struct acpi_processor
*pr
)
1198 struct acpi_processor_throttling
*pthrottling
;
1200 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
1201 "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
1202 pr
->throttling
.address
,
1203 pr
->throttling
.duty_offset
,
1204 pr
->throttling
.duty_width
));
1207 * Evaluate _PTC, _TSS and _TPC
1208 * They must all be present or none of them can be used.
1210 if (acpi_processor_get_throttling_control(pr
) ||
1211 acpi_processor_get_throttling_states(pr
) ||
1212 acpi_processor_get_platform_limit(pr
))
1214 pr
->throttling
.acpi_processor_get_throttling
=
1215 &acpi_processor_get_throttling_fadt
;
1216 pr
->throttling
.acpi_processor_set_throttling
=
1217 &acpi_processor_set_throttling_fadt
;
1218 if (acpi_processor_get_fadt_info(pr
))
1221 pr
->throttling
.acpi_processor_get_throttling
=
1222 &acpi_processor_get_throttling_ptc
;
1223 pr
->throttling
.acpi_processor_set_throttling
=
1224 &acpi_processor_set_throttling_ptc
;
1228 * If TSD package for one CPU can't be parsed successfully, it means
1229 * that this CPU will have no coordination with other CPUs.
1231 if (acpi_processor_get_tsd(pr
)) {
1232 pthrottling
= &pr
->throttling
;
1233 pthrottling
->tsd_valid_flag
= 0;
1234 cpumask_set_cpu(pr
->id
, pthrottling
->shared_cpu_map
);
1235 pthrottling
->shared_type
= DOMAIN_COORD_TYPE_SW_ALL
;
1239 * PIIX4 Errata: We don't support throttling on the original PIIX4.
1240 * This shouldn't be an issue as few (if any) mobile systems ever
1243 if (errata
.piix4
.throttle
) {
1244 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
1245 "Throttling not supported on PIIX4 A- or B-step\n"));
1249 ACPI_DEBUG_PRINT((ACPI_DB_INFO
, "Found %d throttling states\n",
1250 pr
->throttling
.state_count
));
1252 pr
->flags
.throttling
= 1;
1255 * Disable throttling (if enabled). We'll let subsequent policy (e.g.
1256 * thermal) decide to lower performance if it so chooses, but for now
1257 * we'll crank up the speed.
1260 result
= acpi_processor_get_throttling(pr
);
1264 if (pr
->throttling
.state
) {
1265 ACPI_DEBUG_PRINT((ACPI_DB_INFO
,
1266 "Disabling throttling (was T%d)\n",
1267 pr
->throttling
.state
));
1268 result
= acpi_processor_set_throttling(pr
, 0, false);
1275 pr
->flags
.throttling
= 0;