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