?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI : Check parameter when calling acpi_processor_get/set_throttling
[linux-2.6/mini2440.git] / drivers / acpi / processor_throttling.c
blob5d2eae20788638a49eebf4ec8e11934639477c7d
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 * You should have received a copy of the GNU General Public License along
23 * with this program; if not, write to the Free Software Foundation, Inc.,
24 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
25 *
26 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27 */
28
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/sched.h>
33 #include <linux/cpufreq.h>
34 #include <linux/proc_fs.h>
35 #include <linux/seq_file.h>
36
37 #include <asm/io.h>
38 #include <asm/uaccess.h>
39
40 #include <acpi/acpi_bus.h>
41 #include <acpi/processor.h>
42
43 #define ACPI_PROCESSOR_COMPONENT 0x01000000
44 #define ACPI_PROCESSOR_CLASS "processor"
45 #define _COMPONENT ACPI_PROCESSOR_COMPONENT
46 ACPI_MODULE_NAME("processor_throttling");
47
48 static int acpi_processor_get_throttling(struct acpi_processor *pr);
49 int acpi_processor_set_throttling(struct acpi_processor *pr, int state);
50
51 /*
52 * _TPC - Throttling Present Capabilities
53 */
54 static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
55 {
56 acpi_status status = 0;
57 unsigned long tpc = 0;
58
59 if (!pr)
60 return -EINVAL;
61 status = acpi_evaluate_integer(pr->handle, "_TPC", NULL, &tpc);
62 if (ACPI_FAILURE(status)) {
63 if (status != AE_NOT_FOUND) {
64 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TPC"));
65 }
66 return -ENODEV;
67 }
68 pr->throttling_platform_limit = (int)tpc;
69 return 0;
70 }
71
72 int acpi_processor_tstate_has_changed(struct acpi_processor *pr)
73 {
74 int result = 0;
75 int throttling_limit;
76 int current_state;
77 struct acpi_processor_limit *limit;
78 int target_state;
79
80 result = acpi_processor_get_platform_limit(pr);
81 if (result) {
82 /* Throttling Limit is unsupported */
83 return result;
84 }
85
86 throttling_limit = pr->throttling_platform_limit;
87 if (throttling_limit >= pr->throttling.state_count) {
88 /* Uncorrect Throttling Limit */
89 return -EINVAL;
90 }
91
92 current_state = pr->throttling.state;
93 if (current_state > throttling_limit) {
94 /*
95 * The current state can meet the requirement of
96 * _TPC limit. But it is reasonable that OSPM changes
97 * t-states from high to low for better performance.
98 * Of course the limit condition of thermal
99 * and user should be considered.
100 */
101 limit = &pr->limit;
102 target_state = throttling_limit;
103 if (limit->thermal.tx > target_state)
104 target_state = limit->thermal.tx;
105 if (limit->user.tx > target_state)
106 target_state = limit->user.tx;
107 } else if (current_state == throttling_limit) {
108 /*
109 * Unnecessary to change the throttling state
110 */
111 return 0;
112 } else {
113 /*
114 * If the current state is lower than the limit of _TPC, it
115 * will be forced to switch to the throttling state defined
116 * by throttling_platfor_limit.
117 * Because the previous state meets with the limit condition
118 * of thermal and user, it is unnecessary to check it again.
119 */
120 target_state = throttling_limit;
121 }
122 return acpi_processor_set_throttling(pr, target_state);
123 }
124
125 /*
126 * _PTC - Processor Throttling Control (and status) register location
127 */
128 static int acpi_processor_get_throttling_control(struct acpi_processor *pr)
129 {
130 int result = 0;
131 acpi_status status = 0;
132 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
133 union acpi_object *ptc = NULL;
134 union acpi_object obj = { 0 };
135 struct acpi_processor_throttling *throttling;
136
137 status = acpi_evaluate_object(pr->handle, "_PTC", NULL, &buffer);
138 if (ACPI_FAILURE(status)) {
139 if (status != AE_NOT_FOUND) {
140 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PTC"));
141 }
142 return -ENODEV;
143 }
144
145 ptc = (union acpi_object *)buffer.pointer;
146 if (!ptc || (ptc->type != ACPI_TYPE_PACKAGE)
147 || (ptc->package.count != 2)) {
148 printk(KERN_ERR PREFIX "Invalid _PTC data\n");
149 result = -EFAULT;
150 goto end;
151 }
152
153 /*
154 * control_register
155 */
156
157 obj = ptc->package.elements[0];
158
159 if ((obj.type != ACPI_TYPE_BUFFER)
160 || (obj.buffer.length < sizeof(struct acpi_ptc_register))
161 || (obj.buffer.pointer == NULL)) {
162 printk(KERN_ERR PREFIX
163 "Invalid _PTC data (control_register)\n");
164 result = -EFAULT;
165 goto end;
166 }
167 memcpy(&pr->throttling.control_register, obj.buffer.pointer,
168 sizeof(struct acpi_ptc_register));
169
170 /*
171 * status_register
172 */
173
174 obj = ptc->package.elements[1];
175
176 if ((obj.type != ACPI_TYPE_BUFFER)
177 || (obj.buffer.length < sizeof(struct acpi_ptc_register))
178 || (obj.buffer.pointer == NULL)) {
179 printk(KERN_ERR PREFIX "Invalid _PTC data (status_register)\n");
180 result = -EFAULT;
181 goto end;
182 }
183
184 memcpy(&pr->throttling.status_register, obj.buffer.pointer,
185 sizeof(struct acpi_ptc_register));
186
187 throttling = &pr->throttling;
188
189 if ((throttling->control_register.bit_width +
190 throttling->control_register.bit_offset) > 32) {
191 printk(KERN_ERR PREFIX "Invalid _PTC control register\n");
192 result = -EFAULT;
193 goto end;
194 }
195
196 if ((throttling->status_register.bit_width +
197 throttling->status_register.bit_offset) > 32) {
198 printk(KERN_ERR PREFIX "Invalid _PTC status register\n");
199 result = -EFAULT;
200 goto end;
201 }
202
203 end:
204 kfree(buffer.pointer);
205
206 return result;
207 }
208
209 /*
210 * _TSS - Throttling Supported States
211 */
212 static int acpi_processor_get_throttling_states(struct acpi_processor *pr)
213 {
214 int result = 0;
215 acpi_status status = AE_OK;
216 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
217 struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
218 struct acpi_buffer state = { 0, NULL };
219 union acpi_object *tss = NULL;
220 int i;
221
222 status = acpi_evaluate_object(pr->handle, "_TSS", NULL, &buffer);
223 if (ACPI_FAILURE(status)) {
224 if (status != AE_NOT_FOUND) {
225 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSS"));
226 }
227 return -ENODEV;
228 }
229
230 tss = buffer.pointer;
231 if (!tss || (tss->type != ACPI_TYPE_PACKAGE)) {
232 printk(KERN_ERR PREFIX "Invalid _TSS data\n");
233 result = -EFAULT;
234 goto end;
235 }
236
237 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
238 tss->package.count));
239
240 pr->throttling.state_count = tss->package.count;
241 pr->throttling.states_tss =
242 kmalloc(sizeof(struct acpi_processor_tx_tss) * tss->package.count,
243 GFP_KERNEL);
244 if (!pr->throttling.states_tss) {
245 result = -ENOMEM;
246 goto end;
247 }
248
249 for (i = 0; i < pr->throttling.state_count; i++) {
250
251 struct acpi_processor_tx_tss *tx =
252 (struct acpi_processor_tx_tss *)&(pr->throttling.
253 states_tss[i]);
254
255 state.length = sizeof(struct acpi_processor_tx_tss);
256 state.pointer = tx;
257
258 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
259
260 status = acpi_extract_package(&(tss->package.elements[i]),
261 &format, &state);
262 if (ACPI_FAILURE(status)) {
263 ACPI_EXCEPTION((AE_INFO, status, "Invalid _TSS data"));
264 result = -EFAULT;
265 kfree(pr->throttling.states_tss);
266 goto end;
267 }
268
269 if (!tx->freqpercentage) {
270 printk(KERN_ERR PREFIX
271 "Invalid _TSS data: freq is zero\n");
272 result = -EFAULT;
273 kfree(pr->throttling.states_tss);
274 goto end;
275 }
276 }
277
278 end:
279 kfree(buffer.pointer);
280
281 return result;
282 }
283
284 /*
285 * _TSD - T-State Dependencies
286 */
287 static int acpi_processor_get_tsd(struct acpi_processor *pr)
288 {
289 int result = 0;
290 acpi_status status = AE_OK;
291 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
292 struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
293 struct acpi_buffer state = { 0, NULL };
294 union acpi_object *tsd = NULL;
295 struct acpi_tsd_package *pdomain;
296
297 status = acpi_evaluate_object(pr->handle, "_TSD", NULL, &buffer);
298 if (ACPI_FAILURE(status)) {
299 if (status != AE_NOT_FOUND) {
300 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSD"));
301 }
302 return -ENODEV;
303 }
304
305 tsd = buffer.pointer;
306 if (!tsd || (tsd->type != ACPI_TYPE_PACKAGE)) {
307 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _TSD data\n"));
308 result = -EFAULT;
309 goto end;
310 }
311
312 if (tsd->package.count != 1) {
313 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _TSD data\n"));
314 result = -EFAULT;
315 goto end;
316 }
317
318 pdomain = &(pr->throttling.domain_info);
319
320 state.length = sizeof(struct acpi_tsd_package);
321 state.pointer = pdomain;
322
323 status = acpi_extract_package(&(tsd->package.elements[0]),
324 &format, &state);
325 if (ACPI_FAILURE(status)) {
326 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _TSD data\n"));
327 result = -EFAULT;
328 goto end;
329 }
330
331 if (pdomain->num_entries != ACPI_TSD_REV0_ENTRIES) {
332 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unknown _TSD:num_entries\n"));
333 result = -EFAULT;
334 goto end;
335 }
336
337 if (pdomain->revision != ACPI_TSD_REV0_REVISION) {
338 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unknown _TSD:revision\n"));
339 result = -EFAULT;
340 goto end;
341 }
342
343 end:
344 kfree(buffer.pointer);
345 return result;
346 }
347
348 /* --------------------------------------------------------------------------
349 Throttling Control
350 -------------------------------------------------------------------------- */
351 static int acpi_processor_get_throttling_fadt(struct acpi_processor *pr)
352 {
353 int state = 0;
354 u32 value = 0;
355 u32 duty_mask = 0;
356 u32 duty_value = 0;
357
358 if (!pr)
359 return -EINVAL;
360
361 if (!pr->flags.throttling)
362 return -ENODEV;
363
364 pr->throttling.state = 0;
365
366 duty_mask = pr->throttling.state_count - 1;
367
368 duty_mask <<= pr->throttling.duty_offset;
369
370 local_irq_disable();
371
372 value = inl(pr->throttling.address);
373
374 /*
375 * Compute the current throttling state when throttling is enabled
376 * (bit 4 is on).
377 */
378 if (value & 0x10) {
379 duty_value = value & duty_mask;
380 duty_value >>= pr->throttling.duty_offset;
381
382 if (duty_value)
383 state = pr->throttling.state_count - duty_value;
384 }
385
386 pr->throttling.state = state;
387
388 local_irq_enable();
389
390 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
391 "Throttling state is T%d (%d%% throttling applied)\n",
392 state, pr->throttling.states[state].performance));
393
394 return 0;
395 }
396
397 #ifdef CONFIG_X86
398 static int acpi_throttling_rdmsr(struct acpi_processor *pr,
399 acpi_integer * value)
400 {
401 struct cpuinfo_x86 *c;
402 u64 msr_high, msr_low;
403 unsigned int cpu;
404 u64 msr = 0;
405 int ret = -1;
406
407 cpu = pr->id;
408 c = &cpu_data(cpu);
409
410 if ((c->x86_vendor != X86_VENDOR_INTEL) ||
411 !cpu_has(c, X86_FEATURE_ACPI)) {
412 printk(KERN_ERR PREFIX
413 "HARDWARE addr space,NOT supported yet\n");
414 } else {
415 msr_low = 0;
416 msr_high = 0;
417 rdmsr_safe(MSR_IA32_THERM_CONTROL,
418 (u32 *)&msr_low , (u32 *) &msr_high);
419 msr = (msr_high << 32) | msr_low;
420 *value = (acpi_integer) msr;
421 ret = 0;
422 }
423 return ret;
424 }
425
426 static int acpi_throttling_wrmsr(struct acpi_processor *pr, acpi_integer value)
427 {
428 struct cpuinfo_x86 *c;
429 unsigned int cpu;
430 int ret = -1;
431 u64 msr;
432
433 cpu = pr->id;
434 c = &cpu_data(cpu);
435
436 if ((c->x86_vendor != X86_VENDOR_INTEL) ||
437 !cpu_has(c, X86_FEATURE_ACPI)) {
438 printk(KERN_ERR PREFIX
439 "HARDWARE addr space,NOT supported yet\n");
440 } else {
441 msr = value;
442 wrmsr_safe(MSR_IA32_THERM_CONTROL,
443 msr & 0xffffffff, msr >> 32);
444 ret = 0;
445 }
446 return ret;
447 }
448 #else
449 static int acpi_throttling_rdmsr(struct acpi_processor *pr,
450 acpi_integer * value)
451 {
452 printk(KERN_ERR PREFIX
453 "HARDWARE addr space,NOT supported yet\n");
454 return -1;
455 }
456
457 static int acpi_throttling_wrmsr(struct acpi_processor *pr, acpi_integer value)
458 {
459 printk(KERN_ERR PREFIX
460 "HARDWARE addr space,NOT supported yet\n");
461 return -1;
462 }
463 #endif
464
465 static int acpi_read_throttling_status(struct acpi_processor *pr,
466 acpi_integer *value)
467 {
468 u32 bit_width, bit_offset;
469 u64 ptc_value;
470 u64 ptc_mask;
471 struct acpi_processor_throttling *throttling;
472 int ret = -1;
473
474 throttling = &pr->throttling;
475 switch (throttling->status_register.space_id) {
476 case ACPI_ADR_SPACE_SYSTEM_IO:
477 ptc_value = 0;
478 bit_width = throttling->status_register.bit_width;
479 bit_offset = throttling->status_register.bit_offset;
480
481 acpi_os_read_port((acpi_io_address) throttling->status_register.
482 address, (u32 *) &ptc_value,
483 (u32) (bit_width + bit_offset));
484 ptc_mask = (1 << bit_width) - 1;
485 *value = (acpi_integer) ((ptc_value >> bit_offset) & ptc_mask);
486 ret = 0;
487 break;
488 case ACPI_ADR_SPACE_FIXED_HARDWARE:
489 ret = acpi_throttling_rdmsr(pr, value);
490 break;
491 default:
492 printk(KERN_ERR PREFIX "Unknown addr space %d\n",
493 (u32) (throttling->status_register.space_id));
494 }
495 return ret;
496 }
497
498 static int acpi_write_throttling_state(struct acpi_processor *pr,
499 acpi_integer value)
500 {
501 u32 bit_width, bit_offset;
502 u64 ptc_value;
503 u64 ptc_mask;
504 struct acpi_processor_throttling *throttling;
505 int ret = -1;
506
507 throttling = &pr->throttling;
508 switch (throttling->control_register.space_id) {
509 case ACPI_ADR_SPACE_SYSTEM_IO:
510 bit_width = throttling->control_register.bit_width;
511 bit_offset = throttling->control_register.bit_offset;
512 ptc_mask = (1 << bit_width) - 1;
513 ptc_value = value & ptc_mask;
514
515 acpi_os_write_port((acpi_io_address) throttling->
516 control_register.address,
517 (u32) (ptc_value << bit_offset),
518 (u32) (bit_width + bit_offset));
519 ret = 0;
520 break;
521 case ACPI_ADR_SPACE_FIXED_HARDWARE:
522 ret = acpi_throttling_wrmsr(pr, value);
523 break;
524 default:
525 printk(KERN_ERR PREFIX "Unknown addr space %d\n",
526 (u32) (throttling->control_register.space_id));
527 }
528 return ret;
529 }
530
531 static int acpi_get_throttling_state(struct acpi_processor *pr,
532 acpi_integer value)
533 {
534 int i;
535
536 for (i = 0; i < pr->throttling.state_count; i++) {
537 struct acpi_processor_tx_tss *tx =
538 (struct acpi_processor_tx_tss *)&(pr->throttling.
539 states_tss[i]);
540 if (tx->control == value)
541 break;
542 }
543 if (i > pr->throttling.state_count)
544 i = -1;
545 return i;
546 }
547
548 static int acpi_get_throttling_value(struct acpi_processor *pr,
549 int state, acpi_integer *value)
550 {
551 int ret = -1;
552
553 if (state >= 0 && state <= pr->throttling.state_count) {
554 struct acpi_processor_tx_tss *tx =
555 (struct acpi_processor_tx_tss *)&(pr->throttling.
556 states_tss[state]);
557 *value = tx->control;
558 ret = 0;
559 }
560 return ret;
561 }
562
563 static int acpi_processor_get_throttling_ptc(struct acpi_processor *pr)
564 {
565 int state = 0;
566 int ret;
567 acpi_integer value;
568
569 if (!pr)
570 return -EINVAL;
571
572 if (!pr->flags.throttling)
573 return -ENODEV;
574
575 pr->throttling.state = 0;
576
577 value = 0;
578 ret = acpi_read_throttling_status(pr, &value);
579 if (ret >= 0) {
580 state = acpi_get_throttling_state(pr, value);
581 pr->throttling.state = state;
582 }
583
584 return 0;
585 }
586
587 static int acpi_processor_get_throttling(struct acpi_processor *pr)
588 {
589 cpumask_t saved_mask;
590 int ret;
591
592 if (!pr)
593 return -EINVAL;
594
595 if (!pr->flags.throttling)
596 return -ENODEV;
597 /*
598 * Migrate task to the cpu pointed by pr.
599 */
600 saved_mask = current->cpus_allowed;
601 set_cpus_allowed(current, cpumask_of_cpu(pr->id));
602 ret = pr->throttling.acpi_processor_get_throttling(pr);
603 /* restore the previous state */
604 set_cpus_allowed(current, saved_mask);
605
606 return ret;
607 }
608
609 static int acpi_processor_get_fadt_info(struct acpi_processor *pr)
610 {
611 int i, step;
612
613 if (!pr->throttling.address) {
614 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
615 return -EINVAL;
616 } else if (!pr->throttling.duty_width) {
617 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n"));
618 return -EINVAL;
619 }
620 /* TBD: Support duty_cycle values that span bit 4. */
621 else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
622 printk(KERN_WARNING PREFIX "duty_cycle spans bit 4\n");
623 return -EINVAL;
624 }
625
626 pr->throttling.state_count = 1 << acpi_gbl_FADT.duty_width;
627
628 /*
629 * Compute state values. Note that throttling displays a linear power
630 * performance relationship (at 50% performance the CPU will consume
631 * 50% power). Values are in 1/10th of a percent to preserve accuracy.
632 */
633
634 step = (1000 / pr->throttling.state_count);
635
636 for (i = 0; i < pr->throttling.state_count; i++) {
637 pr->throttling.states[i].performance = 1000 - step * i;
638 pr->throttling.states[i].power = 1000 - step * i;
639 }
640 return 0;
641 }
642
643 static int acpi_processor_set_throttling_fadt(struct acpi_processor *pr,
644 int state)
645 {
646 u32 value = 0;
647 u32 duty_mask = 0;
648 u32 duty_value = 0;
649
650 if (!pr)
651 return -EINVAL;
652
653 if ((state < 0) || (state > (pr->throttling.state_count - 1)))
654 return -EINVAL;
655
656 if (!pr->flags.throttling)
657 return -ENODEV;
658
659 if (state == pr->throttling.state)
660 return 0;
661
662 if (state < pr->throttling_platform_limit)
663 return -EPERM;
664 /*
665 * Calculate the duty_value and duty_mask.
666 */
667 if (state) {
668 duty_value = pr->throttling.state_count - state;
669
670 duty_value <<= pr->throttling.duty_offset;
671
672 /* Used to clear all duty_value bits */
673 duty_mask = pr->throttling.state_count - 1;
674
675 duty_mask <<= acpi_gbl_FADT.duty_offset;
676 duty_mask = ~duty_mask;
677 }
678
679 local_irq_disable();
680
681 /*
682 * Disable throttling by writing a 0 to bit 4. Note that we must
683 * turn it off before you can change the duty_value.
684 */
685 value = inl(pr->throttling.address);
686 if (value & 0x10) {
687 value &= 0xFFFFFFEF;
688 outl(value, pr->throttling.address);
689 }
690
691 /*
692 * Write the new duty_value and then enable throttling. Note
693 * that a state value of 0 leaves throttling disabled.
694 */
695 if (state) {
696 value &= duty_mask;
697 value |= duty_value;
698 outl(value, pr->throttling.address);
699
700 value |= 0x00000010;
701 outl(value, pr->throttling.address);
702 }
703
704 pr->throttling.state = state;
705
706 local_irq_enable();
707
708 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
709 "Throttling state set to T%d (%d%%)\n", state,
710 (pr->throttling.states[state].performance ? pr->
711 throttling.states[state].performance / 10 : 0)));
712
713 return 0;
714 }
715
716 static int acpi_processor_set_throttling_ptc(struct acpi_processor *pr,
717 int state)
718 {
719 int ret;
720 acpi_integer value;
721
722 if (!pr)
723 return -EINVAL;
724
725 if ((state < 0) || (state > (pr->throttling.state_count - 1)))
726 return -EINVAL;
727
728 if (!pr->flags.throttling)
729 return -ENODEV;
730
731 if (state == pr->throttling.state)
732 return 0;
733
734 if (state < pr->throttling_platform_limit)
735 return -EPERM;
736
737 value = 0;
738 ret = acpi_get_throttling_value(pr, state, &value);
739 if (ret >= 0) {
740 acpi_write_throttling_state(pr, value);
741 pr->throttling.state = state;
742 }
743
744 return 0;
745 }
746
747 int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
748 {
749 cpumask_t saved_mask;
750 int ret;
751
752 if (!pr)
753 return -EINVAL;
754
755 if (!pr->flags.throttling)
756 return -ENODEV;
757
758 if ((state < 0) || (state > (pr->throttling.state_count - 1)))
759 return -EINVAL;
760
761 /*
762 * Migrate task to the cpu pointed by pr.
763 */
764 saved_mask = current->cpus_allowed;
765 set_cpus_allowed(current, cpumask_of_cpu(pr->id));
766 ret = pr->throttling.acpi_processor_set_throttling(pr, state);
767 /* restore the previous state */
768 set_cpus_allowed(current, saved_mask);
769 return ret;
770 }
771
772 int acpi_processor_get_throttling_info(struct acpi_processor *pr)
773 {
774 int result = 0;
775
776 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
777 "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
778 pr->throttling.address,
779 pr->throttling.duty_offset,
780 pr->throttling.duty_width));
781
782 if (!pr)
783 return -EINVAL;
784
785 /*
786 * Evaluate _PTC, _TSS and _TPC
787 * They must all be present or none of them can be used.
788 */
789 if (acpi_processor_get_throttling_control(pr) ||
790 acpi_processor_get_throttling_states(pr) ||
791 acpi_processor_get_platform_limit(pr))
792 {
793 pr->throttling.acpi_processor_get_throttling =
794 &acpi_processor_get_throttling_fadt;
795 pr->throttling.acpi_processor_set_throttling =
796 &acpi_processor_set_throttling_fadt;
797 if (acpi_processor_get_fadt_info(pr))
798 return 0;
799 } else {
800 pr->throttling.acpi_processor_get_throttling =
801 &acpi_processor_get_throttling_ptc;
802 pr->throttling.acpi_processor_set_throttling =
803 &acpi_processor_set_throttling_ptc;
804 }
805
806 acpi_processor_get_tsd(pr);
807
808 /*
809 * PIIX4 Errata: We don't support throttling on the original PIIX4.
810 * This shouldn't be an issue as few (if any) mobile systems ever
811 * used this part.
812 */
813 if (errata.piix4.throttle) {
814 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
815 "Throttling not supported on PIIX4 A- or B-step\n"));
816 return 0;
817 }
818
819 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
820 pr->throttling.state_count));
821
822 pr->flags.throttling = 1;
823
824 /*
825 * Disable throttling (if enabled). We'll let subsequent policy (e.g.
826 * thermal) decide to lower performance if it so chooses, but for now
827 * we'll crank up the speed.
828 */
829
830 result = acpi_processor_get_throttling(pr);
831 if (result)
832 goto end;
833
834 if (pr->throttling.state) {
835 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
836 "Disabling throttling (was T%d)\n",
837 pr->throttling.state));
838 result = acpi_processor_set_throttling(pr, 0);
839 if (result)
840 goto end;
841 }
842
843 end:
844 if (result)
845 pr->flags.throttling = 0;
846
847 return result;
848 }
849
850 /* proc interface */
851
852 static int acpi_processor_throttling_seq_show(struct seq_file *seq,
853 void *offset)
854 {
855 struct acpi_processor *pr = seq->private;
856 int i = 0;
857 int result = 0;
858
859 if (!pr)
860 goto end;
861
862 if (!(pr->throttling.state_count > 0)) {
863 seq_puts(seq, "<not supported>\n");
864 goto end;
865 }
866
867 result = acpi_processor_get_throttling(pr);
868
869 if (result) {
870 seq_puts(seq,
871 "Could not determine current throttling state.\n");
872 goto end;
873 }
874
875 seq_printf(seq, "state count: %d\n"
876 "active state: T%d\n"
877 "state available: T%d to T%d\n",
878 pr->throttling.state_count, pr->throttling.state,
879 pr->throttling_platform_limit,
880 pr->throttling.state_count - 1);
881
882 seq_puts(seq, "states:\n");
883 if (pr->throttling.acpi_processor_get_throttling ==
884 acpi_processor_get_throttling_fadt) {
885 for (i = 0; i < pr->throttling.state_count; i++)
886 seq_printf(seq, " %cT%d: %02d%%\n",
887 (i == pr->throttling.state ? '*' : ' '), i,
888 (pr->throttling.states[i].performance ? pr->
889 throttling.states[i].performance / 10 : 0));
890 } else {
891 for (i = 0; i < pr->throttling.state_count; i++)
892 seq_printf(seq, " %cT%d: %02d%%\n",
893 (i == pr->throttling.state ? '*' : ' '), i,
894 (int)pr->throttling.states_tss[i].
895 freqpercentage);
896 }
897
898 end:
899 return 0;
900 }
901
902 static int acpi_processor_throttling_open_fs(struct inode *inode,
903 struct file *file)
904 {
905 return single_open(file, acpi_processor_throttling_seq_show,
906 PDE(inode)->data);
907 }
908
909 static ssize_t acpi_processor_write_throttling(struct file *file,
910 const char __user * buffer,
911 size_t count, loff_t * data)
912 {
913 int result = 0;
914 struct seq_file *m = file->private_data;
915 struct acpi_processor *pr = m->private;
916 char state_string[12] = { '\0' };
917
918 if (!pr || (count > sizeof(state_string) - 1))
919 return -EINVAL;
920
921 if (copy_from_user(state_string, buffer, count))
922 return -EFAULT;
923
924 state_string[count] = '\0';
925
926 result = acpi_processor_set_throttling(pr,
927 simple_strtoul(state_string,
928 NULL, 0));
929 if (result)
930 return result;
931
932 return count;
933 }
934
935 struct file_operations acpi_processor_throttling_fops = {
936 .open = acpi_processor_throttling_open_fs,
937 .read = seq_read,
938 .write = acpi_processor_write_throttling,
939 .llseek = seq_lseek,
940 .release = single_release,
941 };
Support for the Chinese Samsung S3C2440 based development boards