1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * processor_throttling.c - Throttling submodule of the ACPI processor driver
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 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <linux/init.h>
16 #include <linux/sched.h>
17 #include <linux/cpufreq.h>
18 #include <linux/acpi.h>
19 #include <acpi/processor.h>
21 #include <linux/uaccess.h>
23 #define PREFIX "ACPI: "
26 * 0 -> acpi processor driver doesn't ignore _TPC values
27 * 1 -> acpi processor driver ignores _TPC values
29 static int ignore_tpc;
30 module_param(ignore_tpc, int, 0644);
31 MODULE_PARM_DESC(ignore_tpc, "Disable broken BIOS _TPC throttling support");
33 struct throttling_tstate {
34 unsigned int cpu; /* cpu nr */
35 int target_state; /* target T-state */
38 struct acpi_processor_throttling_arg {
39 struct acpi_processor *pr;
44 #define THROTTLING_PRECHANGE (1)
45 #define THROTTLING_POSTCHANGE (2)
47 static int acpi_processor_get_throttling(struct acpi_processor *pr);
48 static int __acpi_processor_set_throttling(struct acpi_processor *pr,
49 int state, bool force, bool direct);
51 static int acpi_processor_update_tsd_coord(void)
53 int count, count_target;
56 cpumask_var_t covered_cpus;
57 struct acpi_processor *pr, *match_pr;
58 struct acpi_tsd_package *pdomain, *match_pdomain;
59 struct acpi_processor_throttling *pthrottling, *match_pthrottling;
61 if (!zalloc_cpumask_var(&covered_cpus, GFP_KERNEL))
65 * Now that we have _TSD data from all CPUs, lets setup T-state
66 * coordination between all CPUs.
68 for_each_possible_cpu(i) {
69 pr = per_cpu(processors, i);
73 /* Basic validity check for domain info */
74 pthrottling = &(pr->throttling);
77 * If tsd package for one cpu is invalid, the coordination
78 * among all CPUs is thought as invalid.
81 if (!pthrottling->tsd_valid_flag) {
89 for_each_possible_cpu(i) {
90 pr = per_cpu(processors, i);
94 if (cpumask_test_cpu(i, covered_cpus))
96 pthrottling = &pr->throttling;
98 pdomain = &(pthrottling->domain_info);
99 cpumask_set_cpu(i, pthrottling->shared_cpu_map);
100 cpumask_set_cpu(i, covered_cpus);
102 * If the number of processor in the TSD domain is 1, it is
103 * unnecessary to parse the coordination for this CPU.
105 if (pdomain->num_processors <= 1)
108 /* Validate the Domain info */
109 count_target = pdomain->num_processors;
112 for_each_possible_cpu(j) {
116 match_pr = per_cpu(processors, j);
120 match_pthrottling = &(match_pr->throttling);
121 match_pdomain = &(match_pthrottling->domain_info);
122 if (match_pdomain->domain != pdomain->domain)
125 /* Here i and j are in the same domain.
126 * If two TSD packages have the same domain, they
127 * should have the same num_porcessors and
128 * coordination type. Otherwise it will be regarded
131 if (match_pdomain->num_processors != count_target) {
136 if (pdomain->coord_type != match_pdomain->coord_type) {
141 cpumask_set_cpu(j, covered_cpus);
142 cpumask_set_cpu(j, pthrottling->shared_cpu_map);
145 for_each_possible_cpu(j) {
149 match_pr = per_cpu(processors, j);
153 match_pthrottling = &(match_pr->throttling);
154 match_pdomain = &(match_pthrottling->domain_info);
155 if (match_pdomain->domain != pdomain->domain)
159 * If some CPUS have the same domain, they
160 * will have the same shared_cpu_map.
162 cpumask_copy(match_pthrottling->shared_cpu_map,
163 pthrottling->shared_cpu_map);
168 free_cpumask_var(covered_cpus);
170 for_each_possible_cpu(i) {
171 pr = per_cpu(processors, i);
176 * Assume no coordination on any error parsing domain info.
177 * The coordination type will be forced as SW_ALL.
180 pthrottling = &(pr->throttling);
181 cpumask_clear(pthrottling->shared_cpu_map);
182 cpumask_set_cpu(i, pthrottling->shared_cpu_map);
183 pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
191 * Update the T-state coordination after the _TSD
192 * data for all cpus is obtained.
194 void acpi_processor_throttling_init(void)
196 if (acpi_processor_update_tsd_coord())
197 pr_debug("Assume no T-state coordination\n");
202 static int acpi_processor_throttling_notifier(unsigned long event, void *data)
204 struct throttling_tstate *p_tstate = data;
205 struct acpi_processor *pr;
208 struct acpi_processor_limit *p_limit;
209 struct acpi_processor_throttling *p_throttling;
212 pr = per_cpu(processors, cpu);
214 pr_debug("Invalid pr pointer\n");
217 if (!pr->flags.throttling) {
218 acpi_handle_debug(pr->handle,
219 "Throttling control unsupported on CPU %d\n",
223 target_state = p_tstate->target_state;
224 p_throttling = &(pr->throttling);
226 case THROTTLING_PRECHANGE:
228 * Prechange event is used to choose one proper t-state,
229 * which meets the limits of thermal, user and _TPC.
231 p_limit = &pr->limit;
232 if (p_limit->thermal.tx > target_state)
233 target_state = p_limit->thermal.tx;
234 if (p_limit->user.tx > target_state)
235 target_state = p_limit->user.tx;
236 if (pr->throttling_platform_limit > target_state)
237 target_state = pr->throttling_platform_limit;
238 if (target_state >= p_throttling->state_count) {
240 "Exceed the limit of T-state \n");
241 target_state = p_throttling->state_count - 1;
243 p_tstate->target_state = target_state;
244 acpi_handle_debug(pr->handle,
245 "PreChange Event: target T-state of CPU %d is T%d\n",
248 case THROTTLING_POSTCHANGE:
250 * Postchange event is only used to update the
251 * T-state flag of acpi_processor_throttling.
253 p_throttling->state = target_state;
254 acpi_handle_debug(pr->handle,
255 "PostChange Event: CPU %d is switched to T%d\n",
260 "Unsupported Throttling notifier event\n");
268 * _TPC - Throttling Present Capabilities
270 static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
272 acpi_status status = 0;
273 unsigned long long tpc = 0;
281 status = acpi_evaluate_integer(pr->handle, "_TPC", NULL, &tpc);
282 if (ACPI_FAILURE(status)) {
283 if (status != AE_NOT_FOUND)
284 acpi_evaluation_failure_warn(pr->handle, "_TPC", status);
290 pr->throttling_platform_limit = (int)tpc;
294 int acpi_processor_tstate_has_changed(struct acpi_processor *pr)
297 int throttling_limit;
299 struct acpi_processor_limit *limit;
305 result = acpi_processor_get_platform_limit(pr);
307 /* Throttling Limit is unsupported */
311 throttling_limit = pr->throttling_platform_limit;
312 if (throttling_limit >= pr->throttling.state_count) {
313 /* Uncorrect Throttling Limit */
317 current_state = pr->throttling.state;
318 if (current_state > throttling_limit) {
320 * The current state can meet the requirement of
321 * _TPC limit. But it is reasonable that OSPM changes
322 * t-states from high to low for better performance.
323 * Of course the limit condition of thermal
324 * and user should be considered.
327 target_state = throttling_limit;
328 if (limit->thermal.tx > target_state)
329 target_state = limit->thermal.tx;
330 if (limit->user.tx > target_state)
331 target_state = limit->user.tx;
332 } else if (current_state == throttling_limit) {
334 * Unnecessary to change the throttling state
339 * If the current state is lower than the limit of _TPC, it
340 * will be forced to switch to the throttling state defined
341 * by throttling_platfor_limit.
342 * Because the previous state meets with the limit condition
343 * of thermal and user, it is unnecessary to check it again.
345 target_state = throttling_limit;
347 return acpi_processor_set_throttling(pr, target_state, false);
351 * This function is used to reevaluate whether the T-state is valid
352 * after one CPU is onlined/offlined.
353 * It is noted that it won't reevaluate the following properties for
356 * 2. the number of supported T-state
359 void acpi_processor_reevaluate_tstate(struct acpi_processor *pr,
365 /* When one CPU is offline, the T-state throttling
366 * will be invalidated.
368 pr->flags.throttling = 0;
371 /* the following is to recheck whether the T-state is valid for
374 if (!pr->throttling.state_count) {
375 /* If the number of T-state is invalid, it is
378 pr->flags.throttling = 0;
381 pr->flags.throttling = 1;
383 /* Disable throttling (if enabled). We'll let subsequent
384 * policy (e.g.thermal) decide to lower performance if it
385 * so chooses, but for now we'll crank up the speed.
388 result = acpi_processor_get_throttling(pr);
392 if (pr->throttling.state) {
393 result = acpi_processor_set_throttling(pr, 0, false);
400 pr->flags.throttling = 0;
403 * _PTC - Processor Throttling Control (and status) register location
405 static int acpi_processor_get_throttling_control(struct acpi_processor *pr)
408 acpi_status status = 0;
409 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
410 union acpi_object *ptc = NULL;
411 union acpi_object obj = { 0 };
412 struct acpi_processor_throttling *throttling;
414 status = acpi_evaluate_object(pr->handle, "_PTC", NULL, &buffer);
415 if (ACPI_FAILURE(status)) {
416 if (status != AE_NOT_FOUND)
417 acpi_evaluation_failure_warn(pr->handle, "_PTC", status);
422 ptc = (union acpi_object *)buffer.pointer;
423 if (!ptc || (ptc->type != ACPI_TYPE_PACKAGE)
424 || (ptc->package.count != 2)) {
425 printk(KERN_ERR PREFIX "Invalid _PTC data\n");
434 obj = ptc->package.elements[0];
436 if ((obj.type != ACPI_TYPE_BUFFER)
437 || (obj.buffer.length < sizeof(struct acpi_ptc_register))
438 || (obj.buffer.pointer == NULL)) {
439 printk(KERN_ERR PREFIX
440 "Invalid _PTC data (control_register)\n");
444 memcpy(&pr->throttling.control_register, obj.buffer.pointer,
445 sizeof(struct acpi_ptc_register));
451 obj = ptc->package.elements[1];
453 if ((obj.type != ACPI_TYPE_BUFFER)
454 || (obj.buffer.length < sizeof(struct acpi_ptc_register))
455 || (obj.buffer.pointer == NULL)) {
456 printk(KERN_ERR PREFIX "Invalid _PTC data (status_register)\n");
461 memcpy(&pr->throttling.status_register, obj.buffer.pointer,
462 sizeof(struct acpi_ptc_register));
464 throttling = &pr->throttling;
466 if ((throttling->control_register.bit_width +
467 throttling->control_register.bit_offset) > 32) {
468 printk(KERN_ERR PREFIX "Invalid _PTC control register\n");
473 if ((throttling->status_register.bit_width +
474 throttling->status_register.bit_offset) > 32) {
475 printk(KERN_ERR PREFIX "Invalid _PTC status register\n");
481 kfree(buffer.pointer);
487 * _TSS - Throttling Supported States
489 static int acpi_processor_get_throttling_states(struct acpi_processor *pr)
492 acpi_status status = AE_OK;
493 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
494 struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
495 struct acpi_buffer state = { 0, NULL };
496 union acpi_object *tss = NULL;
499 status = acpi_evaluate_object(pr->handle, "_TSS", NULL, &buffer);
500 if (ACPI_FAILURE(status)) {
501 if (status != AE_NOT_FOUND)
502 acpi_evaluation_failure_warn(pr->handle, "_TSS", status);
507 tss = buffer.pointer;
508 if (!tss || (tss->type != ACPI_TYPE_PACKAGE)) {
509 printk(KERN_ERR PREFIX "Invalid _TSS data\n");
514 acpi_handle_debug(pr->handle, "Found %d throttling states\n",
517 pr->throttling.state_count = tss->package.count;
518 pr->throttling.states_tss =
519 kmalloc_array(tss->package.count,
520 sizeof(struct acpi_processor_tx_tss),
522 if (!pr->throttling.states_tss) {
527 for (i = 0; i < pr->throttling.state_count; i++) {
529 struct acpi_processor_tx_tss *tx =
530 (struct acpi_processor_tx_tss *)&(pr->throttling.
533 state.length = sizeof(struct acpi_processor_tx_tss);
536 acpi_handle_debug(pr->handle, "Extracting state %d\n", i);
538 status = acpi_extract_package(&(tss->package.elements[i]),
540 if (ACPI_FAILURE(status)) {
541 acpi_handle_warn(pr->handle, "Invalid _TSS data: %s\n",
542 acpi_format_exception(status));
544 kfree(pr->throttling.states_tss);
548 if (!tx->freqpercentage) {
549 printk(KERN_ERR PREFIX
550 "Invalid _TSS data: freq is zero\n");
552 kfree(pr->throttling.states_tss);
558 kfree(buffer.pointer);
564 * _TSD - T-State Dependencies
566 static int acpi_processor_get_tsd(struct acpi_processor *pr)
569 acpi_status status = AE_OK;
570 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
571 struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
572 struct acpi_buffer state = { 0, NULL };
573 union acpi_object *tsd = NULL;
574 struct acpi_tsd_package *pdomain;
575 struct acpi_processor_throttling *pthrottling;
577 pthrottling = &pr->throttling;
578 pthrottling->tsd_valid_flag = 0;
580 status = acpi_evaluate_object(pr->handle, "_TSD", NULL, &buffer);
581 if (ACPI_FAILURE(status)) {
582 if (status != AE_NOT_FOUND)
583 acpi_evaluation_failure_warn(pr->handle, "_TSD", status);
588 tsd = buffer.pointer;
589 if (!tsd || (tsd->type != ACPI_TYPE_PACKAGE)) {
590 printk(KERN_ERR PREFIX "Invalid _TSD data\n");
595 if (tsd->package.count != 1) {
596 printk(KERN_ERR PREFIX "Invalid _TSD data\n");
601 pdomain = &(pr->throttling.domain_info);
603 state.length = sizeof(struct acpi_tsd_package);
604 state.pointer = pdomain;
606 status = acpi_extract_package(&(tsd->package.elements[0]),
608 if (ACPI_FAILURE(status)) {
609 printk(KERN_ERR PREFIX "Invalid _TSD data\n");
614 if (pdomain->num_entries != ACPI_TSD_REV0_ENTRIES) {
615 printk(KERN_ERR PREFIX "Unknown _TSD:num_entries\n");
620 if (pdomain->revision != ACPI_TSD_REV0_REVISION) {
621 printk(KERN_ERR PREFIX "Unknown _TSD:revision\n");
626 pthrottling = &pr->throttling;
627 pthrottling->tsd_valid_flag = 1;
628 pthrottling->shared_type = pdomain->coord_type;
629 cpumask_set_cpu(pr->id, pthrottling->shared_cpu_map);
631 * If the coordination type is not defined in ACPI spec,
632 * the tsd_valid_flag will be clear and coordination type
633 * will be forecd as DOMAIN_COORD_TYPE_SW_ALL.
635 if (pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ALL &&
636 pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ANY &&
637 pdomain->coord_type != DOMAIN_COORD_TYPE_HW_ALL) {
638 pthrottling->tsd_valid_flag = 0;
639 pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
643 kfree(buffer.pointer);
647 /* --------------------------------------------------------------------------
649 -------------------------------------------------------------------------- */
650 static int acpi_processor_get_throttling_fadt(struct acpi_processor *pr)
660 if (!pr->flags.throttling)
664 * We don't care about error returns - we just try to mark
665 * these reserved so that nobody else is confused into thinking
666 * that this region might be unused..
668 * (In particular, allocating the IO range for Cardbus)
670 request_region(pr->throttling.address, 6, "ACPI CPU throttle");
672 pr->throttling.state = 0;
674 duty_mask = pr->throttling.state_count - 1;
676 duty_mask <<= pr->throttling.duty_offset;
680 value = inl(pr->throttling.address);
683 * Compute the current throttling state when throttling is enabled
687 duty_value = value & duty_mask;
688 duty_value >>= pr->throttling.duty_offset;
691 state = pr->throttling.state_count - duty_value;
694 pr->throttling.state = state;
698 acpi_handle_debug(pr->handle,
699 "Throttling state is T%d (%d%% throttling applied)\n",
700 state, pr->throttling.states[state].performance);
706 static int acpi_throttling_rdmsr(u64 *value)
708 u64 msr_high, msr_low;
712 if ((this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_INTEL) ||
713 !this_cpu_has(X86_FEATURE_ACPI)) {
714 printk(KERN_ERR PREFIX
715 "HARDWARE addr space,NOT supported yet\n");
719 rdmsr_safe(MSR_IA32_THERM_CONTROL,
720 (u32 *)&msr_low , (u32 *) &msr_high);
721 msr = (msr_high << 32) | msr_low;
728 static int acpi_throttling_wrmsr(u64 value)
733 if ((this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_INTEL) ||
734 !this_cpu_has(X86_FEATURE_ACPI)) {
735 printk(KERN_ERR PREFIX
736 "HARDWARE addr space,NOT supported yet\n");
739 wrmsr_safe(MSR_IA32_THERM_CONTROL,
740 msr & 0xffffffff, msr >> 32);
746 static int acpi_throttling_rdmsr(u64 *value)
748 printk(KERN_ERR PREFIX
749 "HARDWARE addr space,NOT supported yet\n");
753 static int acpi_throttling_wrmsr(u64 value)
755 printk(KERN_ERR PREFIX
756 "HARDWARE addr space,NOT supported yet\n");
761 static int acpi_read_throttling_status(struct acpi_processor *pr,
764 u32 bit_width, bit_offset;
767 struct acpi_processor_throttling *throttling;
770 throttling = &pr->throttling;
771 switch (throttling->status_register.space_id) {
772 case ACPI_ADR_SPACE_SYSTEM_IO:
773 bit_width = throttling->status_register.bit_width;
774 bit_offset = throttling->status_register.bit_offset;
776 acpi_os_read_port((acpi_io_address) throttling->status_register.
778 (u32) (bit_width + bit_offset));
779 ptc_mask = (1 << bit_width) - 1;
780 *value = (u64) ((ptc_value >> bit_offset) & ptc_mask);
783 case ACPI_ADR_SPACE_FIXED_HARDWARE:
784 ret = acpi_throttling_rdmsr(value);
787 printk(KERN_ERR PREFIX "Unknown addr space %d\n",
788 (u32) (throttling->status_register.space_id));
793 static int acpi_write_throttling_state(struct acpi_processor *pr,
796 u32 bit_width, bit_offset;
799 struct acpi_processor_throttling *throttling;
802 throttling = &pr->throttling;
803 switch (throttling->control_register.space_id) {
804 case ACPI_ADR_SPACE_SYSTEM_IO:
805 bit_width = throttling->control_register.bit_width;
806 bit_offset = throttling->control_register.bit_offset;
807 ptc_mask = (1 << bit_width) - 1;
808 ptc_value = value & ptc_mask;
810 acpi_os_write_port((acpi_io_address) throttling->
811 control_register.address,
812 (u32) (ptc_value << bit_offset),
813 (u32) (bit_width + bit_offset));
816 case ACPI_ADR_SPACE_FIXED_HARDWARE:
817 ret = acpi_throttling_wrmsr(value);
820 printk(KERN_ERR PREFIX "Unknown addr space %d\n",
821 (u32) (throttling->control_register.space_id));
826 static int acpi_get_throttling_state(struct acpi_processor *pr,
831 for (i = 0; i < pr->throttling.state_count; i++) {
832 struct acpi_processor_tx_tss *tx =
833 (struct acpi_processor_tx_tss *)&(pr->throttling.
835 if (tx->control == value)
841 static int acpi_get_throttling_value(struct acpi_processor *pr,
842 int state, u64 *value)
846 if (state >= 0 && state <= pr->throttling.state_count) {
847 struct acpi_processor_tx_tss *tx =
848 (struct acpi_processor_tx_tss *)&(pr->throttling.
850 *value = tx->control;
856 static int acpi_processor_get_throttling_ptc(struct acpi_processor *pr)
865 if (!pr->flags.throttling)
868 pr->throttling.state = 0;
871 ret = acpi_read_throttling_status(pr, &value);
873 state = acpi_get_throttling_state(pr, value);
875 acpi_handle_debug(pr->handle,
876 "Invalid throttling state, reset\n");
878 ret = __acpi_processor_set_throttling(pr, state, true,
883 pr->throttling.state = state;
889 static long __acpi_processor_get_throttling(void *data)
891 struct acpi_processor *pr = data;
893 return pr->throttling.acpi_processor_get_throttling(pr);
896 static int acpi_processor_get_throttling(struct acpi_processor *pr)
901 if (!pr->flags.throttling)
905 * This is either called from the CPU hotplug callback of
906 * processor_driver or via the ACPI probe function. In the latter
907 * case the CPU is not guaranteed to be online. Both call sites are
908 * protected against CPU hotplug.
910 if (!cpu_online(pr->id))
913 return call_on_cpu(pr->id, __acpi_processor_get_throttling, pr, false);
916 static int acpi_processor_get_fadt_info(struct acpi_processor *pr)
920 if (!pr->throttling.address) {
921 acpi_handle_debug(pr->handle, "No throttling register\n");
923 } else if (!pr->throttling.duty_width) {
924 acpi_handle_debug(pr->handle, "No throttling states\n");
927 /* TBD: Support duty_cycle values that span bit 4. */
928 else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
929 printk(KERN_WARNING PREFIX "duty_cycle spans bit 4\n");
933 pr->throttling.state_count = 1 << acpi_gbl_FADT.duty_width;
936 * Compute state values. Note that throttling displays a linear power
937 * performance relationship (at 50% performance the CPU will consume
938 * 50% power). Values are in 1/10th of a percent to preserve accuracy.
941 step = (1000 / pr->throttling.state_count);
943 for (i = 0; i < pr->throttling.state_count; i++) {
944 pr->throttling.states[i].performance = 1000 - step * i;
945 pr->throttling.states[i].power = 1000 - step * i;
950 static int acpi_processor_set_throttling_fadt(struct acpi_processor *pr,
951 int state, bool force)
960 if ((state < 0) || (state > (pr->throttling.state_count - 1)))
963 if (!pr->flags.throttling)
966 if (!force && (state == pr->throttling.state))
969 if (state < pr->throttling_platform_limit)
972 * Calculate the duty_value and duty_mask.
975 duty_value = pr->throttling.state_count - state;
977 duty_value <<= pr->throttling.duty_offset;
979 /* Used to clear all duty_value bits */
980 duty_mask = pr->throttling.state_count - 1;
982 duty_mask <<= acpi_gbl_FADT.duty_offset;
983 duty_mask = ~duty_mask;
989 * Disable throttling by writing a 0 to bit 4. Note that we must
990 * turn it off before you can change the duty_value.
992 value = inl(pr->throttling.address);
995 outl(value, pr->throttling.address);
999 * Write the new duty_value and then enable throttling. Note
1000 * that a state value of 0 leaves throttling disabled.
1004 value |= duty_value;
1005 outl(value, pr->throttling.address);
1007 value |= 0x00000010;
1008 outl(value, pr->throttling.address);
1011 pr->throttling.state = state;
1015 acpi_handle_debug(pr->handle,
1016 "Throttling state set to T%d (%d%%)\n", state,
1017 (pr->throttling.states[state].performance ? pr->
1018 throttling.states[state].performance / 10 : 0));
1023 static int acpi_processor_set_throttling_ptc(struct acpi_processor *pr,
1024 int state, bool force)
1032 if ((state < 0) || (state > (pr->throttling.state_count - 1)))
1035 if (!pr->flags.throttling)
1038 if (!force && (state == pr->throttling.state))
1041 if (state < pr->throttling_platform_limit)
1045 ret = acpi_get_throttling_value(pr, state, &value);
1047 acpi_write_throttling_state(pr, value);
1048 pr->throttling.state = state;
1054 static long acpi_processor_throttling_fn(void *data)
1056 struct acpi_processor_throttling_arg *arg = data;
1057 struct acpi_processor *pr = arg->pr;
1059 return pr->throttling.acpi_processor_set_throttling(pr,
1060 arg->target_state, arg->force);
1063 static int __acpi_processor_set_throttling(struct acpi_processor *pr,
1064 int state, bool force, bool direct)
1068 struct acpi_processor *match_pr;
1069 struct acpi_processor_throttling *p_throttling;
1070 struct acpi_processor_throttling_arg arg;
1071 struct throttling_tstate t_state;
1076 if (!pr->flags.throttling)
1079 if ((state < 0) || (state > (pr->throttling.state_count - 1)))
1082 if (cpu_is_offline(pr->id)) {
1084 * the cpu pointed by pr->id is offline. Unnecessary to change
1085 * the throttling state any more.
1090 t_state.target_state = state;
1091 p_throttling = &(pr->throttling);
1094 * The throttling notifier will be called for every
1095 * affected cpu in order to get one proper T-state.
1096 * The notifier event is THROTTLING_PRECHANGE.
1098 for_each_cpu_and(i, cpu_online_mask, p_throttling->shared_cpu_map) {
1100 acpi_processor_throttling_notifier(THROTTLING_PRECHANGE,
1104 * The function of acpi_processor_set_throttling will be called
1105 * to switch T-state. If the coordination type is SW_ALL or HW_ALL,
1106 * it is necessary to call it for every affected cpu. Otherwise
1107 * it can be called only for the cpu pointed by pr.
1109 if (p_throttling->shared_type == DOMAIN_COORD_TYPE_SW_ANY) {
1111 arg.target_state = state;
1113 ret = call_on_cpu(pr->id, acpi_processor_throttling_fn, &arg,
1117 * When the T-state coordination is SW_ALL or HW_ALL,
1118 * it is necessary to set T-state for every affected
1121 for_each_cpu_and(i, cpu_online_mask,
1122 p_throttling->shared_cpu_map) {
1123 match_pr = per_cpu(processors, i);
1125 * If the pointer is invalid, we will report the
1126 * error message and continue.
1129 acpi_handle_debug(pr->handle,
1130 "Invalid Pointer for CPU %d\n", i);
1134 * If the throttling control is unsupported on CPU i,
1135 * we will report the error message and continue.
1137 if (!match_pr->flags.throttling) {
1138 acpi_handle_debug(pr->handle,
1139 "Throttling Control unsupported on CPU %d\n", i);
1144 arg.target_state = state;
1146 ret = call_on_cpu(pr->id, acpi_processor_throttling_fn,
1151 * After the set_throttling is called, the
1152 * throttling notifier is called for every
1153 * affected cpu to update the T-states.
1154 * The notifier event is THROTTLING_POSTCHANGE
1156 for_each_cpu_and(i, cpu_online_mask, p_throttling->shared_cpu_map) {
1158 acpi_processor_throttling_notifier(THROTTLING_POSTCHANGE,
1165 int acpi_processor_set_throttling(struct acpi_processor *pr, int state,
1168 return __acpi_processor_set_throttling(pr, state, force, false);
1171 int acpi_processor_get_throttling_info(struct acpi_processor *pr)
1174 struct acpi_processor_throttling *pthrottling;
1176 acpi_handle_debug(pr->handle,
1177 "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
1178 pr->throttling.address,
1179 pr->throttling.duty_offset,
1180 pr->throttling.duty_width);
1183 * Evaluate _PTC, _TSS and _TPC
1184 * They must all be present or none of them can be used.
1186 if (acpi_processor_get_throttling_control(pr) ||
1187 acpi_processor_get_throttling_states(pr) ||
1188 acpi_processor_get_platform_limit(pr))
1190 pr->throttling.acpi_processor_get_throttling =
1191 &acpi_processor_get_throttling_fadt;
1192 pr->throttling.acpi_processor_set_throttling =
1193 &acpi_processor_set_throttling_fadt;
1194 if (acpi_processor_get_fadt_info(pr))
1197 pr->throttling.acpi_processor_get_throttling =
1198 &acpi_processor_get_throttling_ptc;
1199 pr->throttling.acpi_processor_set_throttling =
1200 &acpi_processor_set_throttling_ptc;
1204 * If TSD package for one CPU can't be parsed successfully, it means
1205 * that this CPU will have no coordination with other CPUs.
1207 if (acpi_processor_get_tsd(pr)) {
1208 pthrottling = &pr->throttling;
1209 pthrottling->tsd_valid_flag = 0;
1210 cpumask_set_cpu(pr->id, pthrottling->shared_cpu_map);
1211 pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
1215 * PIIX4 Errata: We don't support throttling on the original PIIX4.
1216 * This shouldn't be an issue as few (if any) mobile systems ever
1219 if (errata.piix4.throttle) {
1220 acpi_handle_debug(pr->handle,
1221 "Throttling not supported on PIIX4 A- or B-step\n");
1225 acpi_handle_debug(pr->handle, "Found %d throttling states\n",
1226 pr->throttling.state_count);
1228 pr->flags.throttling = 1;
1231 * Disable throttling (if enabled). We'll let subsequent policy (e.g.
1232 * thermal) decide to lower performance if it so chooses, but for now
1233 * we'll crank up the speed.
1236 result = acpi_processor_get_throttling(pr);
1240 if (pr->throttling.state) {
1241 acpi_handle_debug(pr->handle,
1242 "Disabling throttling (was T%d)\n",
1243 pr->throttling.state);
1244 result = acpi_processor_set_throttling(pr, 0, false);
1251 pr->flags.throttling = 0;