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