1/*
2 * processor_throttling.c - Throttling submodule of the ACPI processor driver
3 *
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
9 *
10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11 *
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.
16 *
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.
21 *
22 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23 */
24
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>
33#include <asm/io.h>
34#include <linux/uaccess.h>
35
36#define PREFIX "ACPI: "
37
38#define ACPI_PROCESSOR_CLASS "processor"
39#define _COMPONENT ACPI_PROCESSOR_COMPONENT
40ACPI_MODULE_NAME("processor_throttling");
41
42/* ignore_tpc:
43 * 0 -> acpi processor driver doesn't ignore _TPC values
44 * 1 -> acpi processor driver ignores _TPC values
45 */
46static int ignore_tpc;
47module_param(ignore_tpc, int, 0644);
48MODULE_PARM_DESC(ignore_tpc, "Disable broken BIOS _TPC throttling support");
49
50struct throttling_tstate {
51 unsigned int cpu; /* cpu nr */
52 int target_state; /* target T-state */
53};
54
55struct acpi_processor_throttling_arg {
56 struct acpi_processor *pr;
57 int target_state;
58 bool force;
59};
60
61#define THROTTLING_PRECHANGE (1)
62#define THROTTLING_POSTCHANGE (2)
63
64static int acpi_processor_get_throttling(struct acpi_processor *pr);
65static int __acpi_processor_set_throttling(struct acpi_processor *pr,
66 int state, bool force, bool direct);
67
68static int acpi_processor_update_tsd_coord(void)
69{
70 int count, count_target;
71 int retval = 0;
72 unsigned int i, j;
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;
77
78 if (!zalloc_cpumask_var(&covered_cpus, GFP_KERNEL))
79 return -ENOMEM;
80
81 /*
82 * Now that we have _TSD data from all CPUs, lets setup T-state
83 * coordination between all CPUs.
84 */
85 for_each_possible_cpu(i) {
86 pr = per_cpu(processors, i);
87 if (!pr)
88 continue;
89
90 /* Basic validity check for domain info */
91 pthrottling = &(pr->throttling);
92
93 /*
94 * If tsd package for one cpu is invalid, the coordination
95 * among all CPUs is thought as invalid.
96 * Maybe it is ugly.
97 */
98 if (!pthrottling->tsd_valid_flag) {
99 retval = -EINVAL;
100 break;
101 }
102 }
103 if (retval)
104 goto err_ret;
105
106 for_each_possible_cpu(i) {
107 pr = per_cpu(processors, i);
108 if (!pr)
109 continue;
110
111 if (cpumask_test_cpu(i, covered_cpus))
112 continue;
113 pthrottling = &pr->throttling;
114
115 pdomain = &(pthrottling->domain_info);
116 cpumask_set_cpu(i, pthrottling->shared_cpu_map);
117 cpumask_set_cpu(i, covered_cpus);
118 /*
119 * If the number of processor in the TSD domain is 1, it is
120 * unnecessary to parse the coordination for this CPU.
121 */
122 if (pdomain->num_processors <= 1)
123 continue;
124
125 /* Validate the Domain info */
126 count_target = pdomain->num_processors;
127 count = 1;
128
129 for_each_possible_cpu(j) {
130 if (i == j)
131 continue;
132
133 match_pr = per_cpu(processors, j);
134 if (!match_pr)
135 continue;
136
137 match_pthrottling = &(match_pr->throttling);
138 match_pdomain = &(match_pthrottling->domain_info);
139 if (match_pdomain->domain != pdomain->domain)
140 continue;
141
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
146 * as illegal.
147 */
148 if (match_pdomain->num_processors != count_target) {
149 retval = -EINVAL;
150 goto err_ret;
151 }
152
153 if (pdomain->coord_type != match_pdomain->coord_type) {
154 retval = -EINVAL;
155 goto err_ret;
156 }
157
158 cpumask_set_cpu(j, covered_cpus);
159 cpumask_set_cpu(j, pthrottling->shared_cpu_map);
160 count++;
161 }
162 for_each_possible_cpu(j) {
163 if (i == j)
164 continue;
165
166 match_pr = per_cpu(processors, j);
167 if (!match_pr)
168 continue;
169
170 match_pthrottling = &(match_pr->throttling);
171 match_pdomain = &(match_pthrottling->domain_info);
172 if (match_pdomain->domain != pdomain->domain)
173 continue;
174
175 /*
176 * If some CPUS have the same domain, they
177 * will have the same shared_cpu_map.
178 */
179 cpumask_copy(match_pthrottling->shared_cpu_map,
180 pthrottling->shared_cpu_map);
181 }
182 }
183
184err_ret:
185 free_cpumask_var(covered_cpus);
186
187 for_each_possible_cpu(i) {
188 pr = per_cpu(processors, i);
189 if (!pr)
190 continue;
191
192 /*
193 * Assume no coordination on any error parsing domain info.
194 * The coordination type will be forced as SW_ALL.
195 */
196 if (retval) {
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;
201 }
202 }
203
204 return retval;
205}
206
207/*
208 * Update the T-state coordination after the _TSD
209 * data for all cpus is obtained.
210 */
211void acpi_processor_throttling_init(void)
212{
213 if (acpi_processor_update_tsd_coord()) {
214 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
215 "Assume no T-state coordination\n"));
216 }
217
218 return;
219}
220
221static int acpi_processor_throttling_notifier(unsigned long event, void *data)
222{
223 struct throttling_tstate *p_tstate = data;
224 struct acpi_processor *pr;
225 unsigned int cpu ;
226 int target_state;
227 struct acpi_processor_limit *p_limit;
228 struct acpi_processor_throttling *p_throttling;
229
230 cpu = p_tstate->cpu;
231 pr = per_cpu(processors, cpu);
232 if (!pr) {
233 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Invalid pr pointer\n"));
234 return 0;
235 }
236 if (!pr->flags.throttling) {
237 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Throttling control is "
238 "unsupported on CPU %d\n", cpu));
239 return 0;
240 }
241 target_state = p_tstate->target_state;
242 p_throttling = &(pr->throttling);
243 switch (event) {
244 case THROTTLING_PRECHANGE:
245 /*
246 * Prechange event is used to choose one proper t-state,
247 * which meets the limits of thermal, user and _TPC.
248 */
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) {
257 printk(KERN_WARNING
258 "Exceed the limit of T-state \n");
259 target_state = p_throttling->state_count - 1;
260 }
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",
264 cpu, target_state));
265 break;
266 case THROTTLING_POSTCHANGE:
267 /*
268 * Postchange event is only used to update the
269 * T-state flag of acpi_processor_throttling.
270 */
271 p_throttling->state = target_state;
272 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "PostChange Event:"
273 "CPU %d is switched to T%d\n",
274 cpu, target_state));
275 break;
276 default:
277 printk(KERN_WARNING
278 "Unsupported Throttling notifier event\n");
279 break;
280 }
281
282 return 0;
283}
284
285/*
286 * _TPC - Throttling Present Capabilities
287 */
288static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
289{
290 acpi_status status = 0;
291 unsigned long long tpc = 0;
292
293 if (!pr)
294 return -EINVAL;
295
296 if (ignore_tpc)
297 goto end;
298
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"));
303 }
304 return -ENODEV;
305 }
306
307end:
308 pr->throttling_platform_limit = (int)tpc;
309 return 0;
310}
311
312int acpi_processor_tstate_has_changed(struct acpi_processor *pr)
313{
314 int result = 0;
315 int throttling_limit;
316 int current_state;
317 struct acpi_processor_limit *limit;
318 int target_state;
319
320 if (ignore_tpc)
321 return 0;
322
323 result = acpi_processor_get_platform_limit(pr);
324 if (result) {
325 /* Throttling Limit is unsupported */
326 return result;
327 }
328
329 throttling_limit = pr->throttling_platform_limit;
330 if (throttling_limit >= pr->throttling.state_count) {
331 /* Uncorrect Throttling Limit */
332 return -EINVAL;
333 }
334
335 current_state = pr->throttling.state;
336 if (current_state > throttling_limit) {
337 /*
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.
343 */
344 limit = &pr->limit;
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) {
351 /*
352 * Unnecessary to change the throttling state
353 */
354 return 0;
355 } else {
356 /*
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.
362 */
363 target_state = throttling_limit;
364 }
365 return acpi_processor_set_throttling(pr, target_state, false);
366}
367
368/*
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
372 * the T-state.
373 * 1. Control method.
374 * 2. the number of supported T-state
375 * 3. TSD domain
376 */
377void acpi_processor_reevaluate_tstate(struct acpi_processor *pr,
378 bool is_dead)
379{
380 int result = 0;
381
382 if (is_dead) {
383 /* When one CPU is offline, the T-state throttling
384 * will be invalidated.
385 */
386 pr->flags.throttling = 0;
387 return;
388 }
389 /* the following is to recheck whether the T-state is valid for
390 * the online CPU
391 */
392 if (!pr->throttling.state_count) {
393 /* If the number of T-state is invalid, it is
394 * invalidated.
395 */
396 pr->flags.throttling = 0;
397 return;
398 }
399 pr->flags.throttling = 1;
400
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.
404 */
405
406 result = acpi_processor_get_throttling(pr);
407 if (result)
408 goto end;
409
410 if (pr->throttling.state) {
411 result = acpi_processor_set_throttling(pr, 0, false);
412 if (result)
413 goto end;
414 }
415
416end:
417 if (result)
418 pr->flags.throttling = 0;
419}
420/*
421 * _PTC - Processor Throttling Control (and status) register location
422 */
423static int acpi_processor_get_throttling_control(struct acpi_processor *pr)
424{
425 int result = 0;
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;
431
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"));
436 }
437 return -ENODEV;
438 }
439
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");
444 result = -EFAULT;
445 goto end;
446 }
447
448 /*
449 * control_register
450 */
451
452 obj = ptc->package.elements[0];
453
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");
459 result = -EFAULT;
460 goto end;
461 }
462 memcpy(&pr->throttling.control_register, obj.buffer.pointer,
463 sizeof(struct acpi_ptc_register));
464
465 /*
466 * status_register
467 */
468
469 obj = ptc->package.elements[1];
470
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");
475 result = -EFAULT;
476 goto end;
477 }
478
479 memcpy(&pr->throttling.status_register, obj.buffer.pointer,
480 sizeof(struct acpi_ptc_register));
481
482 throttling = &pr->throttling;
483
484 if ((throttling->control_register.bit_width +
485 throttling->control_register.bit_offset) > 32) {
486 printk(KERN_ERR PREFIX "Invalid _PTC control register\n");
487 result = -EFAULT;
488 goto end;
489 }
490
491 if ((throttling->status_register.bit_width +
492 throttling->status_register.bit_offset) > 32) {
493 printk(KERN_ERR PREFIX "Invalid _PTC status register\n");
494 result = -EFAULT;
495 goto end;
496 }
497
498 end:
499 kfree(buffer.pointer);
500
501 return result;
502}
503
504/*
505 * _TSS - Throttling Supported States
506 */
507static int acpi_processor_get_throttling_states(struct acpi_processor *pr)
508{
509 int result = 0;
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;
515 int i;
516
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"));
521 }
522 return -ENODEV;
523 }
524
525 tss = buffer.pointer;
526 if (!tss || (tss->type != ACPI_TYPE_PACKAGE)) {
527 printk(KERN_ERR PREFIX "Invalid _TSS data\n");
528 result = -EFAULT;
529 goto end;
530 }
531
532 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
533 tss->package.count));
534
535 pr->throttling.state_count = tss->package.count;
536 pr->throttling.states_tss =
537 kmalloc_array(tss->package.count,
538 sizeof(struct acpi_processor_tx_tss),
539 GFP_KERNEL);
540 if (!pr->throttling.states_tss) {
541 result = -ENOMEM;
542 goto end;
543 }
544
545 for (i = 0; i < pr->throttling.state_count; i++) {
546
547 struct acpi_processor_tx_tss *tx =
548 (struct acpi_processor_tx_tss *)&(pr->throttling.
549 states_tss[i]);
550
551 state.length = sizeof(struct acpi_processor_tx_tss);
552 state.pointer = tx;
553
554 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
555
556 status = acpi_extract_package(&(tss->package.elements[i]),
557 &format, &state);
558 if (ACPI_FAILURE(status)) {
559 ACPI_EXCEPTION((AE_INFO, status, "Invalid _TSS data"));
560 result = -EFAULT;
561 kfree(pr->throttling.states_tss);
562 goto end;
563 }
564
565 if (!tx->freqpercentage) {
566 printk(KERN_ERR PREFIX
567 "Invalid _TSS data: freq is zero\n");
568 result = -EFAULT;
569 kfree(pr->throttling.states_tss);
570 goto end;
571 }
572 }
573
574 end:
575 kfree(buffer.pointer);
576
577 return result;
578}
579
580/*
581 * _TSD - T-State Dependencies
582 */
583static int acpi_processor_get_tsd(struct acpi_processor *pr)
584{
585 int result = 0;
586 acpi_status status = AE_OK;
587 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
588 struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
589 struct acpi_buffer state = { 0, NULL };
590 union acpi_object *tsd = NULL;
591 struct acpi_tsd_package *pdomain;
592 struct acpi_processor_throttling *pthrottling;
593
594 pthrottling = &pr->throttling;
595 pthrottling->tsd_valid_flag = 0;
596
597 status = acpi_evaluate_object(pr->handle, "_TSD", NULL, &buffer);
598 if (ACPI_FAILURE(status)) {
599 if (status != AE_NOT_FOUND) {
600 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSD"));
601 }
602 return -ENODEV;
603 }
604
605 tsd = buffer.pointer;
606 if (!tsd || (tsd->type != ACPI_TYPE_PACKAGE)) {
607 printk(KERN_ERR PREFIX "Invalid _TSD data\n");
608 result = -EFAULT;
609 goto end;
610 }
611
612 if (tsd->package.count != 1) {
613 printk(KERN_ERR PREFIX "Invalid _TSD data\n");
614 result = -EFAULT;
615 goto end;
616 }
617
618 pdomain = &(pr->throttling.domain_info);
619
620 state.length = sizeof(struct acpi_tsd_package);
621 state.pointer = pdomain;
622
623 status = acpi_extract_package(&(tsd->package.elements[0]),
624 &format, &state);
625 if (ACPI_FAILURE(status)) {
626 printk(KERN_ERR PREFIX "Invalid _TSD data\n");
627 result = -EFAULT;
628 goto end;
629 }
630
631 if (pdomain->num_entries != ACPI_TSD_REV0_ENTRIES) {
632 printk(KERN_ERR PREFIX "Unknown _TSD:num_entries\n");
633 result = -EFAULT;
634 goto end;
635 }
636
637 if (pdomain->revision != ACPI_TSD_REV0_REVISION) {
638 printk(KERN_ERR PREFIX "Unknown _TSD:revision\n");
639 result = -EFAULT;
640 goto end;
641 }
642
643 pthrottling = &pr->throttling;
644 pthrottling->tsd_valid_flag = 1;
645 pthrottling->shared_type = pdomain->coord_type;
646 cpumask_set_cpu(pr->id, pthrottling->shared_cpu_map);
647 /*
648 * If the coordination type is not defined in ACPI spec,
649 * the tsd_valid_flag will be clear and coordination type
650 * will be forecd as DOMAIN_COORD_TYPE_SW_ALL.
651 */
652 if (pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ALL &&
653 pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ANY &&
654 pdomain->coord_type != DOMAIN_COORD_TYPE_HW_ALL) {
655 pthrottling->tsd_valid_flag = 0;
656 pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
657 }
658
659 end:
660 kfree(buffer.pointer);
661 return result;
662}
663
664/* --------------------------------------------------------------------------
665 Throttling Control
666 -------------------------------------------------------------------------- */
667static int acpi_processor_get_throttling_fadt(struct acpi_processor *pr)
668{
669 int state = 0;
670 u32 value = 0;
671 u32 duty_mask = 0;
672 u32 duty_value = 0;
673
674 if (!pr)
675 return -EINVAL;
676
677 if (!pr->flags.throttling)
678 return -ENODEV;
679
680 /*
681 * We don't care about error returns - we just try to mark
682 * these reserved so that nobody else is confused into thinking
683 * that this region might be unused..
684 *
685 * (In particular, allocating the IO range for Cardbus)
686 */
687 request_region(pr->throttling.address, 6, "ACPI CPU throttle");
688
689 pr->throttling.state = 0;
690
691 duty_mask = pr->throttling.state_count - 1;
692
693 duty_mask <<= pr->throttling.duty_offset;
694
695 local_irq_disable();
696
697 value = inl(pr->throttling.address);
698
699 /*
700 * Compute the current throttling state when throttling is enabled
701 * (bit 4 is on).
702 */
703 if (value & 0x10) {
704 duty_value = value & duty_mask;
705 duty_value >>= pr->throttling.duty_offset;
706
707 if (duty_value)
708 state = pr->throttling.state_count - duty_value;
709 }
710
711 pr->throttling.state = state;
712
713 local_irq_enable();
714
715 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
716 "Throttling state is T%d (%d%% throttling applied)\n",
717 state, pr->throttling.states[state].performance));
718
719 return 0;
720}
721
722#ifdef CONFIG_X86
723static int acpi_throttling_rdmsr(u64 *value)
724{
725 u64 msr_high, msr_low;
726 u64 msr = 0;
727 int ret = -1;
728
729 if ((this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_INTEL) ||
730 !this_cpu_has(X86_FEATURE_ACPI)) {
731 printk(KERN_ERR PREFIX
732 "HARDWARE addr space,NOT supported yet\n");
733 } else {
734 msr_low = 0;
735 msr_high = 0;
736 rdmsr_safe(MSR_IA32_THERM_CONTROL,
737 (u32 *)&msr_low , (u32 *) &msr_high);
738 msr = (msr_high << 32) | msr_low;
739 *value = (u64) msr;
740 ret = 0;
741 }
742 return ret;
743}
744
745static int acpi_throttling_wrmsr(u64 value)
746{
747 int ret = -1;
748 u64 msr;
749
750 if ((this_cpu_read(cpu_info.x86_vendor) != X86_VENDOR_INTEL) ||
751 !this_cpu_has(X86_FEATURE_ACPI)) {
752 printk(KERN_ERR PREFIX
753 "HARDWARE addr space,NOT supported yet\n");
754 } else {
755 msr = value;
756 wrmsr_safe(MSR_IA32_THERM_CONTROL,
757 msr & 0xffffffff, msr >> 32);
758 ret = 0;
759 }
760 return ret;
761}
762#else
763static int acpi_throttling_rdmsr(u64 *value)
764{
765 printk(KERN_ERR PREFIX
766 "HARDWARE addr space,NOT supported yet\n");
767 return -1;
768}
769
770static int acpi_throttling_wrmsr(u64 value)
771{
772 printk(KERN_ERR PREFIX
773 "HARDWARE addr space,NOT supported yet\n");
774 return -1;
775}
776#endif
777
778static int acpi_read_throttling_status(struct acpi_processor *pr,
779 u64 *value)
780{
781 u32 bit_width, bit_offset;
782 u32 ptc_value;
783 u64 ptc_mask;
784 struct acpi_processor_throttling *throttling;
785 int ret = -1;
786
787 throttling = &pr->throttling;
788 switch (throttling->status_register.space_id) {
789 case ACPI_ADR_SPACE_SYSTEM_IO:
790 bit_width = throttling->status_register.bit_width;
791 bit_offset = throttling->status_register.bit_offset;
792
793 acpi_os_read_port((acpi_io_address) throttling->status_register.
794 address, &ptc_value,
795 (u32) (bit_width + bit_offset));
796 ptc_mask = (1 << bit_width) - 1;
797 *value = (u64) ((ptc_value >> bit_offset) & ptc_mask);
798 ret = 0;
799 break;
800 case ACPI_ADR_SPACE_FIXED_HARDWARE:
801 ret = acpi_throttling_rdmsr(value);
802 break;
803 default:
804 printk(KERN_ERR PREFIX "Unknown addr space %d\n",
805 (u32) (throttling->status_register.space_id));
806 }
807 return ret;
808}
809
810static int acpi_write_throttling_state(struct acpi_processor *pr,
811 u64 value)
812{
813 u32 bit_width, bit_offset;
814 u64 ptc_value;
815 u64 ptc_mask;
816 struct acpi_processor_throttling *throttling;
817 int ret = -1;
818
819 throttling = &pr->throttling;
820 switch (throttling->control_register.space_id) {
821 case ACPI_ADR_SPACE_SYSTEM_IO:
822 bit_width = throttling->control_register.bit_width;
823 bit_offset = throttling->control_register.bit_offset;
824 ptc_mask = (1 << bit_width) - 1;
825 ptc_value = value & ptc_mask;
826
827 acpi_os_write_port((acpi_io_address) throttling->
828 control_register.address,
829 (u32) (ptc_value << bit_offset),
830 (u32) (bit_width + bit_offset));
831 ret = 0;
832 break;
833 case ACPI_ADR_SPACE_FIXED_HARDWARE:
834 ret = acpi_throttling_wrmsr(value);
835 break;
836 default:
837 printk(KERN_ERR PREFIX "Unknown addr space %d\n",
838 (u32) (throttling->control_register.space_id));
839 }
840 return ret;
841}
842
843static int acpi_get_throttling_state(struct acpi_processor *pr,
844 u64 value)
845{
846 int i;
847
848 for (i = 0; i < pr->throttling.state_count; i++) {
849 struct acpi_processor_tx_tss *tx =
850 (struct acpi_processor_tx_tss *)&(pr->throttling.
851 states_tss[i]);
852 if (tx->control == value)
853 return i;
854 }
855 return -1;
856}
857
858static int acpi_get_throttling_value(struct acpi_processor *pr,
859 int state, u64 *value)
860{
861 int ret = -1;
862
863 if (state >= 0 && state <= pr->throttling.state_count) {
864 struct acpi_processor_tx_tss *tx =
865 (struct acpi_processor_tx_tss *)&(pr->throttling.
866 states_tss[state]);
867 *value = tx->control;
868 ret = 0;
869 }
870 return ret;
871}
872
873static int acpi_processor_get_throttling_ptc(struct acpi_processor *pr)
874{
875 int state = 0;
876 int ret;
877 u64 value;
878
879 if (!pr)
880 return -EINVAL;
881
882 if (!pr->flags.throttling)
883 return -ENODEV;
884
885 pr->throttling.state = 0;
886
887 value = 0;
888 ret = acpi_read_throttling_status(pr, &value);
889 if (ret >= 0) {
890 state = acpi_get_throttling_state(pr, value);
891 if (state == -1) {
892 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
893 "Invalid throttling state, reset\n"));
894 state = 0;
895 ret = __acpi_processor_set_throttling(pr, state, true,
896 true);
897 if (ret)
898 return ret;
899 }
900 pr->throttling.state = state;
901 }
902
903 return 0;
904}
905
906static long __acpi_processor_get_throttling(void *data)
907{
908 struct acpi_processor *pr = data;
909
910 return pr->throttling.acpi_processor_get_throttling(pr);
911}
912
913static int call_on_cpu(int cpu, long (*fn)(void *), void *arg, bool direct)
914{
915 if (direct || (is_percpu_thread() && cpu == smp_processor_id()))
916 return fn(arg);
917 return work_on_cpu(cpu, fn, arg);
918}
919
920static int acpi_processor_get_throttling(struct acpi_processor *pr)
921{
922 if (!pr)
923 return -EINVAL;
924
925 if (!pr->flags.throttling)
926 return -ENODEV;
927
928 /*
929 * This is either called from the CPU hotplug callback of
930 * processor_driver or via the ACPI probe function. In the latter
931 * case the CPU is not guaranteed to be online. Both call sites are
932 * protected against CPU hotplug.
933 */
934 if (!cpu_online(pr->id))
935 return -ENODEV;
936
937 return call_on_cpu(pr->id, __acpi_processor_get_throttling, pr, false);
938}
939
940static int acpi_processor_get_fadt_info(struct acpi_processor *pr)
941{
942 int i, step;
943
944 if (!pr->throttling.address) {
945 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
946 return -EINVAL;
947 } else if (!pr->throttling.duty_width) {
948 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n"));
949 return -EINVAL;
950 }
951 /* TBD: Support duty_cycle values that span bit 4. */
952 else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
953 printk(KERN_WARNING PREFIX "duty_cycle spans bit 4\n");
954 return -EINVAL;
955 }
956
957 pr->throttling.state_count = 1 << acpi_gbl_FADT.duty_width;
958
959 /*
960 * Compute state values. Note that throttling displays a linear power
961 * performance relationship (at 50% performance the CPU will consume
962 * 50% power). Values are in 1/10th of a percent to preserve accuracy.
963 */
964
965 step = (1000 / pr->throttling.state_count);
966
967 for (i = 0; i < pr->throttling.state_count; i++) {
968 pr->throttling.states[i].performance = 1000 - step * i;
969 pr->throttling.states[i].power = 1000 - step * i;
970 }
971 return 0;
972}
973
974static int acpi_processor_set_throttling_fadt(struct acpi_processor *pr,
975 int state, bool force)
976{
977 u32 value = 0;
978 u32 duty_mask = 0;
979 u32 duty_value = 0;
980
981 if (!pr)
982 return -EINVAL;
983
984 if ((state < 0) || (state > (pr->throttling.state_count - 1)))
985 return -EINVAL;
986
987 if (!pr->flags.throttling)
988 return -ENODEV;
989
990 if (!force && (state == pr->throttling.state))
991 return 0;
992
993 if (state < pr->throttling_platform_limit)
994 return -EPERM;
995 /*
996 * Calculate the duty_value and duty_mask.
997 */
998 if (state) {
999 duty_value = pr->throttling.state_count - state;
1000
1001 duty_value <<= pr->throttling.duty_offset;
1002
1003 /* Used to clear all duty_value bits */
1004 duty_mask = pr->throttling.state_count - 1;
1005
1006 duty_mask <<= acpi_gbl_FADT.duty_offset;
1007 duty_mask = ~duty_mask;
1008 }
1009
1010 local_irq_disable();
1011
1012 /*
1013 * Disable throttling by writing a 0 to bit 4. Note that we must
1014 * turn it off before you can change the duty_value.
1015 */
1016 value = inl(pr->throttling.address);
1017 if (value & 0x10) {
1018 value &= 0xFFFFFFEF;
1019 outl(value, pr->throttling.address);
1020 }
1021
1022 /*
1023 * Write the new duty_value and then enable throttling. Note
1024 * that a state value of 0 leaves throttling disabled.
1025 */
1026 if (state) {
1027 value &= duty_mask;
1028 value |= duty_value;
1029 outl(value, pr->throttling.address);
1030
1031 value |= 0x00000010;
1032 outl(value, pr->throttling.address);
1033 }
1034
1035 pr->throttling.state = state;
1036
1037 local_irq_enable();
1038
1039 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1040 "Throttling state set to T%d (%d%%)\n", state,
1041 (pr->throttling.states[state].performance ? pr->
1042 throttling.states[state].performance / 10 : 0)));
1043
1044 return 0;
1045}
1046
1047static int acpi_processor_set_throttling_ptc(struct acpi_processor *pr,
1048 int state, bool force)
1049{
1050 int ret;
1051 u64 value;
1052
1053 if (!pr)
1054 return -EINVAL;
1055
1056 if ((state < 0) || (state > (pr->throttling.state_count - 1)))
1057 return -EINVAL;
1058
1059 if (!pr->flags.throttling)
1060 return -ENODEV;
1061
1062 if (!force && (state == pr->throttling.state))
1063 return 0;
1064
1065 if (state < pr->throttling_platform_limit)
1066 return -EPERM;
1067
1068 value = 0;
1069 ret = acpi_get_throttling_value(pr, state, &value);
1070 if (ret >= 0) {
1071 acpi_write_throttling_state(pr, value);
1072 pr->throttling.state = state;
1073 }
1074
1075 return 0;
1076}
1077
1078static long acpi_processor_throttling_fn(void *data)
1079{
1080 struct acpi_processor_throttling_arg *arg = data;
1081 struct acpi_processor *pr = arg->pr;
1082
1083 return pr->throttling.acpi_processor_set_throttling(pr,
1084 arg->target_state, arg->force);
1085}
1086
1087static int __acpi_processor_set_throttling(struct acpi_processor *pr,
1088 int state, bool force, bool direct)
1089{
1090 int ret = 0;
1091 unsigned int i;
1092 struct acpi_processor *match_pr;
1093 struct acpi_processor_throttling *p_throttling;
1094 struct acpi_processor_throttling_arg arg;
1095 struct throttling_tstate t_state;
1096
1097 if (!pr)
1098 return -EINVAL;
1099
1100 if (!pr->flags.throttling)
1101 return -ENODEV;
1102
1103 if ((state < 0) || (state > (pr->throttling.state_count - 1)))
1104 return -EINVAL;
1105
1106 if (cpu_is_offline(pr->id)) {
1107 /*
1108 * the cpu pointed by pr->id is offline. Unnecessary to change
1109 * the throttling state any more.
1110 */
1111 return -ENODEV;
1112 }
1113
1114 t_state.target_state = state;
1115 p_throttling = &(pr->throttling);
1116
1117 /*
1118 * The throttling notifier will be called for every
1119 * affected cpu in order to get one proper T-state.
1120 * The notifier event is THROTTLING_PRECHANGE.
1121 */
1122 for_each_cpu_and(i, cpu_online_mask, p_throttling->shared_cpu_map) {
1123 t_state.cpu = i;
1124 acpi_processor_throttling_notifier(THROTTLING_PRECHANGE,
1125 &t_state);
1126 }
1127 /*
1128 * The function of acpi_processor_set_throttling will be called
1129 * to switch T-state. If the coordination type is SW_ALL or HW_ALL,
1130 * it is necessary to call it for every affected cpu. Otherwise
1131 * it can be called only for the cpu pointed by pr.
1132 */
1133 if (p_throttling->shared_type == DOMAIN_COORD_TYPE_SW_ANY) {
1134 arg.pr = pr;
1135 arg.target_state = state;
1136 arg.force = force;
1137 ret = call_on_cpu(pr->id, acpi_processor_throttling_fn, &arg,
1138 direct);
1139 } else {
1140 /*
1141 * When the T-state coordination is SW_ALL or HW_ALL,
1142 * it is necessary to set T-state for every affected
1143 * cpus.
1144 */
1145 for_each_cpu_and(i, cpu_online_mask,
1146 p_throttling->shared_cpu_map) {
1147 match_pr = per_cpu(processors, i);
1148 /*
1149 * If the pointer is invalid, we will report the
1150 * error message and continue.
1151 */
1152 if (!match_pr) {
1153 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1154 "Invalid Pointer for CPU %d\n", i));
1155 continue;
1156 }
1157 /*
1158 * If the throttling control is unsupported on CPU i,
1159 * we will report the error message and continue.
1160 */
1161 if (!match_pr->flags.throttling) {
1162 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1163 "Throttling Control is unsupported "
1164 "on CPU %d\n", i));
1165 continue;
1166 }
1167
1168 arg.pr = match_pr;
1169 arg.target_state = state;
1170 arg.force = force;
1171 ret = call_on_cpu(pr->id, acpi_processor_throttling_fn,
1172 &arg, direct);
1173 }
1174 }
1175 /*
1176 * After the set_throttling is called, the
1177 * throttling notifier is called for every
1178 * affected cpu to update the T-states.
1179 * The notifier event is THROTTLING_POSTCHANGE
1180 */
1181 for_each_cpu_and(i, cpu_online_mask, p_throttling->shared_cpu_map) {
1182 t_state.cpu = i;
1183 acpi_processor_throttling_notifier(THROTTLING_POSTCHANGE,
1184 &t_state);
1185 }
1186
1187 return ret;
1188}
1189
1190int acpi_processor_set_throttling(struct acpi_processor *pr, int state,
1191 bool force)
1192{
1193 return __acpi_processor_set_throttling(pr, state, force, false);
1194}
1195
1196int acpi_processor_get_throttling_info(struct acpi_processor *pr)
1197{
1198 int result = 0;
1199 struct acpi_processor_throttling *pthrottling;
1200
1201 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1202 "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
1203 pr->throttling.address,
1204 pr->throttling.duty_offset,
1205 pr->throttling.duty_width));
1206
1207 /*
1208 * Evaluate _PTC, _TSS and _TPC
1209 * They must all be present or none of them can be used.
1210 */
1211 if (acpi_processor_get_throttling_control(pr) ||
1212 acpi_processor_get_throttling_states(pr) ||
1213 acpi_processor_get_platform_limit(pr))
1214 {
1215 pr->throttling.acpi_processor_get_throttling =
1216 &acpi_processor_get_throttling_fadt;
1217 pr->throttling.acpi_processor_set_throttling =
1218 &acpi_processor_set_throttling_fadt;
1219 if (acpi_processor_get_fadt_info(pr))
1220 return 0;
1221 } else {
1222 pr->throttling.acpi_processor_get_throttling =
1223 &acpi_processor_get_throttling_ptc;
1224 pr->throttling.acpi_processor_set_throttling =
1225 &acpi_processor_set_throttling_ptc;
1226 }
1227
1228 /*
1229 * If TSD package for one CPU can't be parsed successfully, it means
1230 * that this CPU will have no coordination with other CPUs.
1231 */
1232 if (acpi_processor_get_tsd(pr)) {
1233 pthrottling = &pr->throttling;
1234 pthrottling->tsd_valid_flag = 0;
1235 cpumask_set_cpu(pr->id, pthrottling->shared_cpu_map);
1236 pthrottling->shared_type = DOMAIN_COORD_TYPE_SW_ALL;
1237 }
1238
1239 /*
1240 * PIIX4 Errata: We don't support throttling on the original PIIX4.
1241 * This shouldn't be an issue as few (if any) mobile systems ever
1242 * used this part.
1243 */
1244 if (errata.piix4.throttle) {
1245 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1246 "Throttling not supported on PIIX4 A- or B-step\n"));
1247 return 0;
1248 }
1249
1250 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
1251 pr->throttling.state_count));
1252
1253 pr->flags.throttling = 1;
1254
1255 /*
1256 * Disable throttling (if enabled). We'll let subsequent policy (e.g.
1257 * thermal) decide to lower performance if it so chooses, but for now
1258 * we'll crank up the speed.
1259 */
1260
1261 result = acpi_processor_get_throttling(pr);
1262 if (result)
1263 goto end;
1264
1265 if (pr->throttling.state) {
1266 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1267 "Disabling throttling (was T%d)\n",
1268 pr->throttling.state));
1269 result = acpi_processor_set_throttling(pr, 0, false);
1270 if (result)
1271 goto end;
1272 }
1273
1274 end:
1275 if (result)
1276 pr->flags.throttling = 0;
1277
1278 return result;
1279}
1280
1281