1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <linux/kernel.h>
30#include <linux/module.h>
31#include <linux/init.h>
32#include <linux/cpufreq.h>
33
34#ifdef CONFIG_X86_ACPI_CPUFREQ_PROC_INTF
35#include <linux/proc_fs.h>
36#include <linux/seq_file.h>
37#include <linux/mutex.h>
38
39#include <asm/uaccess.h>
40#endif
41
42#include <acpi/acpi_bus.h>
43#include <acpi/processor.h>
44
45#define ACPI_PROCESSOR_COMPONENT 0x01000000
46#define ACPI_PROCESSOR_CLASS "processor"
47#define ACPI_PROCESSOR_FILE_PERFORMANCE "performance"
48#define _COMPONENT ACPI_PROCESSOR_COMPONENT
49ACPI_MODULE_NAME("processor_perflib");
50
51static DEFINE_MUTEX(performance_mutex);
52
53
54#define cpufreq_printk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \
55 "cpufreq-core", msg)
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73static int ignore_ppc = -1;
74module_param(ignore_ppc, int, 0644);
75MODULE_PARM_DESC(ignore_ppc, "If the frequency of your machine gets wrongly" \
76 "limited by BIOS, this should help");
77
78#define PPC_REGISTERED 1
79#define PPC_IN_USE 2
80
81static int acpi_processor_ppc_status;
82
83static int acpi_processor_ppc_notifier(struct notifier_block *nb,
84 unsigned long event, void *data)
85{
86 struct cpufreq_policy *policy = data;
87 struct acpi_processor *pr;
88 unsigned int ppc = 0;
89
90 if (event == CPUFREQ_START && ignore_ppc <= 0) {
91 ignore_ppc = 0;
92 return 0;
93 }
94
95 if (ignore_ppc)
96 return 0;
97
98 if (event != CPUFREQ_INCOMPATIBLE)
99 return 0;
100
101 mutex_lock(&performance_mutex);
102
103 pr = per_cpu(processors, policy->cpu);
104 if (!pr || !pr->performance)
105 goto out;
106
107 ppc = (unsigned int)pr->performance_platform_limit;
108
109 if (ppc >= pr->performance->state_count)
110 goto out;
111
112 cpufreq_verify_within_limits(policy, 0,
113 pr->performance->states[ppc].
114 core_frequency * 1000);
115
116 out:
117 mutex_unlock(&performance_mutex);
118
119 return 0;
120}
121
122static struct notifier_block acpi_ppc_notifier_block = {
123 .notifier_call = acpi_processor_ppc_notifier,
124};
125
126static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
127{
128 acpi_status status = 0;
129 unsigned long long ppc = 0;
130
131
132 if (!pr)
133 return -EINVAL;
134
135
136
137
138
139 status = acpi_evaluate_integer(pr->handle, "_PPC", NULL, &ppc);
140
141 if (status != AE_NOT_FOUND)
142 acpi_processor_ppc_status |= PPC_IN_USE;
143
144 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
145 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PPC"));
146 return -ENODEV;
147 }
148
149 cpufreq_printk("CPU %d: _PPC is %d - frequency %s limited\n", pr->id,
150 (int)ppc, ppc ? "" : "not");
151
152 pr->performance_platform_limit = (int)ppc;
153
154 return 0;
155}
156
157int acpi_processor_ppc_has_changed(struct acpi_processor *pr)
158{
159 int ret;
160
161 if (ignore_ppc)
162 return 0;
163
164 ret = acpi_processor_get_platform_limit(pr);
165
166 if (ret < 0)
167 return (ret);
168 else
169 return cpufreq_update_policy(pr->id);
170}
171
172void acpi_processor_ppc_init(void)
173{
174 if (!cpufreq_register_notifier
175 (&acpi_ppc_notifier_block, CPUFREQ_POLICY_NOTIFIER))
176 acpi_processor_ppc_status |= PPC_REGISTERED;
177 else
178 printk(KERN_DEBUG
179 "Warning: Processor Platform Limit not supported.\n");
180}
181
182void acpi_processor_ppc_exit(void)
183{
184 if (acpi_processor_ppc_status & PPC_REGISTERED)
185 cpufreq_unregister_notifier(&acpi_ppc_notifier_block,
186 CPUFREQ_POLICY_NOTIFIER);
187
188 acpi_processor_ppc_status &= ~PPC_REGISTERED;
189}
190
191static int acpi_processor_get_performance_control(struct acpi_processor *pr)
192{
193 int result = 0;
194 acpi_status status = 0;
195 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
196 union acpi_object *pct = NULL;
197 union acpi_object obj = { 0 };
198
199
200 status = acpi_evaluate_object(pr->handle, "_PCT", NULL, &buffer);
201 if (ACPI_FAILURE(status)) {
202 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PCT"));
203 return -ENODEV;
204 }
205
206 pct = (union acpi_object *)buffer.pointer;
207 if (!pct || (pct->type != ACPI_TYPE_PACKAGE)
208 || (pct->package.count != 2)) {
209 printk(KERN_ERR PREFIX "Invalid _PCT data\n");
210 result = -EFAULT;
211 goto end;
212 }
213
214
215
216
217
218 obj = pct->package.elements[0];
219
220 if ((obj.type != ACPI_TYPE_BUFFER)
221 || (obj.buffer.length < sizeof(struct acpi_pct_register))
222 || (obj.buffer.pointer == NULL)) {
223 printk(KERN_ERR PREFIX "Invalid _PCT data (control_register)\n");
224 result = -EFAULT;
225 goto end;
226 }
227 memcpy(&pr->performance->control_register, obj.buffer.pointer,
228 sizeof(struct acpi_pct_register));
229
230
231
232
233
234 obj = pct->package.elements[1];
235
236 if ((obj.type != ACPI_TYPE_BUFFER)
237 || (obj.buffer.length < sizeof(struct acpi_pct_register))
238 || (obj.buffer.pointer == NULL)) {
239 printk(KERN_ERR PREFIX "Invalid _PCT data (status_register)\n");
240 result = -EFAULT;
241 goto end;
242 }
243
244 memcpy(&pr->performance->status_register, obj.buffer.pointer,
245 sizeof(struct acpi_pct_register));
246
247 end:
248 kfree(buffer.pointer);
249
250 return result;
251}
252
253static int acpi_processor_get_performance_states(struct acpi_processor *pr)
254{
255 int result = 0;
256 acpi_status status = AE_OK;
257 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
258 struct acpi_buffer format = { sizeof("NNNNNN"), "NNNNNN" };
259 struct acpi_buffer state = { 0, NULL };
260 union acpi_object *pss = NULL;
261 int i;
262
263
264 status = acpi_evaluate_object(pr->handle, "_PSS", NULL, &buffer);
265 if (ACPI_FAILURE(status)) {
266 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PSS"));
267 return -ENODEV;
268 }
269
270 pss = buffer.pointer;
271 if (!pss || (pss->type != ACPI_TYPE_PACKAGE)) {
272 printk(KERN_ERR PREFIX "Invalid _PSS data\n");
273 result = -EFAULT;
274 goto end;
275 }
276
277 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d performance states\n",
278 pss->package.count));
279
280 pr->performance->state_count = pss->package.count;
281 pr->performance->states =
282 kmalloc(sizeof(struct acpi_processor_px) * pss->package.count,
283 GFP_KERNEL);
284 if (!pr->performance->states) {
285 result = -ENOMEM;
286 goto end;
287 }
288
289 for (i = 0; i < pr->performance->state_count; i++) {
290
291 struct acpi_processor_px *px = &(pr->performance->states[i]);
292
293 state.length = sizeof(struct acpi_processor_px);
294 state.pointer = px;
295
296 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
297
298 status = acpi_extract_package(&(pss->package.elements[i]),
299 &format, &state);
300 if (ACPI_FAILURE(status)) {
301 ACPI_EXCEPTION((AE_INFO, status, "Invalid _PSS data"));
302 result = -EFAULT;
303 kfree(pr->performance->states);
304 goto end;
305 }
306
307 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
308 "State [%d]: core_frequency[%d] power[%d] transition_latency[%d] bus_master_latency[%d] control[0x%x] status[0x%x]\n",
309 i,
310 (u32) px->core_frequency,
311 (u32) px->power,
312 (u32) px->transition_latency,
313 (u32) px->bus_master_latency,
314 (u32) px->control, (u32) px->status));
315
316 if (!px->core_frequency) {
317 printk(KERN_ERR PREFIX
318 "Invalid _PSS data: freq is zero\n");
319 result = -EFAULT;
320 kfree(pr->performance->states);
321 goto end;
322 }
323 }
324
325 end:
326 kfree(buffer.pointer);
327
328 return result;
329}
330
331static int acpi_processor_get_performance_info(struct acpi_processor *pr)
332{
333 int result = 0;
334 acpi_status status = AE_OK;
335 acpi_handle handle = NULL;
336
337
338 if (!pr || !pr->performance || !pr->handle)
339 return -EINVAL;
340
341 status = acpi_get_handle(pr->handle, "_PCT", &handle);
342 if (ACPI_FAILURE(status)) {
343 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
344 "ACPI-based processor performance control unavailable\n"));
345 return -ENODEV;
346 }
347
348 result = acpi_processor_get_performance_control(pr);
349 if (result)
350 return result;
351
352 result = acpi_processor_get_performance_states(pr);
353 if (result)
354 return result;
355
356 return 0;
357}
358
359int acpi_processor_notify_smm(struct module *calling_module)
360{
361 acpi_status status;
362 static int is_done = 0;
363
364
365 if (!(acpi_processor_ppc_status & PPC_REGISTERED))
366 return -EBUSY;
367
368 if (!try_module_get(calling_module))
369 return -EINVAL;
370
371
372
373
374
375
376 if (is_done > 0) {
377 module_put(calling_module);
378 return 0;
379 } else if (is_done < 0) {
380 module_put(calling_module);
381 return is_done;
382 }
383
384 is_done = -EIO;
385
386
387 if ((!acpi_gbl_FADT.smi_command) || (!acpi_gbl_FADT.pstate_control)) {
388 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No SMI port or pstate_control\n"));
389 module_put(calling_module);
390 return 0;
391 }
392
393 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
394 "Writing pstate_control [0x%x] to smi_command [0x%x]\n",
395 acpi_gbl_FADT.pstate_control, acpi_gbl_FADT.smi_command));
396
397 status = acpi_os_write_port(acpi_gbl_FADT.smi_command,
398 (u32) acpi_gbl_FADT.pstate_control, 8);
399 if (ACPI_FAILURE(status)) {
400 ACPI_EXCEPTION((AE_INFO, status,
401 "Failed to write pstate_control [0x%x] to "
402 "smi_command [0x%x]", acpi_gbl_FADT.pstate_control,
403 acpi_gbl_FADT.smi_command));
404 module_put(calling_module);
405 return status;
406 }
407
408
409
410 is_done = 1;
411
412 if (!(acpi_processor_ppc_status & PPC_IN_USE))
413 module_put(calling_module);
414
415 return 0;
416}
417
418EXPORT_SYMBOL(acpi_processor_notify_smm);
419
420#ifdef CONFIG_X86_ACPI_CPUFREQ_PROC_INTF
421
422
423static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file);
424static struct file_operations acpi_processor_perf_fops = {
425 .owner = THIS_MODULE,
426 .open = acpi_processor_perf_open_fs,
427 .read = seq_read,
428 .llseek = seq_lseek,
429 .release = single_release,
430};
431
432static int acpi_processor_perf_seq_show(struct seq_file *seq, void *offset)
433{
434 struct acpi_processor *pr = seq->private;
435 int i;
436
437
438 if (!pr)
439 goto end;
440
441 if (!pr->performance) {
442 seq_puts(seq, "<not supported>\n");
443 goto end;
444 }
445
446 seq_printf(seq, "state count: %d\n"
447 "active state: P%d\n",
448 pr->performance->state_count, pr->performance->state);
449
450 seq_puts(seq, "states:\n");
451 for (i = 0; i < pr->performance->state_count; i++)
452 seq_printf(seq,
453 " %cP%d: %d MHz, %d mW, %d uS\n",
454 (i == pr->performance->state ? '*' : ' '), i,
455 (u32) pr->performance->states[i].core_frequency,
456 (u32) pr->performance->states[i].power,
457 (u32) pr->performance->states[i].transition_latency);
458
459 end:
460 return 0;
461}
462
463static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file)
464{
465 return single_open(file, acpi_processor_perf_seq_show,
466 PDE(inode)->data);
467}
468
469static void acpi_cpufreq_add_file(struct acpi_processor *pr)
470{
471 struct acpi_device *device = NULL;
472
473
474 if (acpi_bus_get_device(pr->handle, &device))
475 return;
476
477
478 proc_create_data(ACPI_PROCESSOR_FILE_PERFORMANCE, S_IFREG | S_IRUGO,
479 acpi_device_dir(device),
480 &acpi_processor_perf_fops, acpi_driver_data(device));
481 return;
482}
483
484static void acpi_cpufreq_remove_file(struct acpi_processor *pr)
485{
486 struct acpi_device *device = NULL;
487
488
489 if (acpi_bus_get_device(pr->handle, &device))
490 return;
491
492
493 remove_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE,
494 acpi_device_dir(device));
495
496 return;
497}
498
499#else
500static void acpi_cpufreq_add_file(struct acpi_processor *pr)
501{
502 return;
503}
504static void acpi_cpufreq_remove_file(struct acpi_processor *pr)
505{
506 return;
507}
508#endif
509
510static int acpi_processor_get_psd(struct acpi_processor *pr)
511{
512 int result = 0;
513 acpi_status status = AE_OK;
514 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
515 struct acpi_buffer format = {sizeof("NNNNN"), "NNNNN"};
516 struct acpi_buffer state = {0, NULL};
517 union acpi_object *psd = NULL;
518 struct acpi_psd_package *pdomain;
519
520 status = acpi_evaluate_object(pr->handle, "_PSD", NULL, &buffer);
521 if (ACPI_FAILURE(status)) {
522 return -ENODEV;
523 }
524
525 psd = buffer.pointer;
526 if (!psd || (psd->type != ACPI_TYPE_PACKAGE)) {
527 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSD data\n"));
528 result = -EFAULT;
529 goto end;
530 }
531
532 if (psd->package.count != 1) {
533 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSD data\n"));
534 result = -EFAULT;
535 goto end;
536 }
537
538 pdomain = &(pr->performance->domain_info);
539
540 state.length = sizeof(struct acpi_psd_package);
541 state.pointer = pdomain;
542
543 status = acpi_extract_package(&(psd->package.elements[0]),
544 &format, &state);
545 if (ACPI_FAILURE(status)) {
546 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSD data\n"));
547 result = -EFAULT;
548 goto end;
549 }
550
551 if (pdomain->num_entries != ACPI_PSD_REV0_ENTRIES) {
552 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unknown _PSD:num_entries\n"));
553 result = -EFAULT;
554 goto end;
555 }
556
557 if (pdomain->revision != ACPI_PSD_REV0_REVISION) {
558 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unknown _PSD:revision\n"));
559 result = -EFAULT;
560 goto end;
561 }
562
563end:
564 kfree(buffer.pointer);
565 return result;
566}
567
568int acpi_processor_preregister_performance(
569 struct acpi_processor_performance *performance)
570{
571 int count, count_target;
572 int retval = 0;
573 unsigned int i, j;
574 cpumask_t covered_cpus;
575 struct acpi_processor *pr;
576 struct acpi_psd_package *pdomain;
577 struct acpi_processor *match_pr;
578 struct acpi_psd_package *match_pdomain;
579
580 mutex_lock(&performance_mutex);
581
582 retval = 0;
583
584
585 for_each_possible_cpu(i) {
586 pr = per_cpu(processors, i);
587 if (!pr) {
588
589 continue;
590 }
591
592 if (pr->performance) {
593 retval = -EBUSY;
594 continue;
595 }
596
597 if (!performance || !percpu_ptr(performance, i)) {
598 retval = -EINVAL;
599 continue;
600 }
601
602 pr->performance = percpu_ptr(performance, i);
603 cpu_set(i, pr->performance->shared_cpu_map);
604 if (acpi_processor_get_psd(pr)) {
605 retval = -EINVAL;
606 continue;
607 }
608 }
609 if (retval)
610 goto err_ret;
611
612
613
614
615
616 for_each_possible_cpu(i) {
617 pr = per_cpu(processors, i);
618 if (!pr)
619 continue;
620
621
622 pdomain = &(pr->performance->domain_info);
623 if ((pdomain->revision != ACPI_PSD_REV0_REVISION) ||
624 (pdomain->num_entries != ACPI_PSD_REV0_ENTRIES)) {
625 retval = -EINVAL;
626 goto err_ret;
627 }
628 if (pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ALL &&
629 pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ANY &&
630 pdomain->coord_type != DOMAIN_COORD_TYPE_HW_ALL) {
631 retval = -EINVAL;
632 goto err_ret;
633 }
634 }
635
636 cpus_clear(covered_cpus);
637 for_each_possible_cpu(i) {
638 pr = per_cpu(processors, i);
639 if (!pr)
640 continue;
641
642 if (cpu_isset(i, covered_cpus))
643 continue;
644
645 pdomain = &(pr->performance->domain_info);
646 cpu_set(i, pr->performance->shared_cpu_map);
647 cpu_set(i, covered_cpus);
648 if (pdomain->num_processors <= 1)
649 continue;
650
651
652 count_target = pdomain->num_processors;
653 count = 1;
654 if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ALL)
655 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL;
656 else if (pdomain->coord_type == DOMAIN_COORD_TYPE_HW_ALL)
657 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_HW;
658 else if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ANY)
659 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ANY;
660
661 for_each_possible_cpu(j) {
662 if (i == j)
663 continue;
664
665 match_pr = per_cpu(processors, j);
666 if (!match_pr)
667 continue;
668
669 match_pdomain = &(match_pr->performance->domain_info);
670 if (match_pdomain->domain != pdomain->domain)
671 continue;
672
673
674
675 if (match_pdomain->num_processors != count_target) {
676 retval = -EINVAL;
677 goto err_ret;
678 }
679
680 if (pdomain->coord_type != match_pdomain->coord_type) {
681 retval = -EINVAL;
682 goto err_ret;
683 }
684
685 cpu_set(j, covered_cpus);
686 cpu_set(j, pr->performance->shared_cpu_map);
687 count++;
688 }
689
690 for_each_possible_cpu(j) {
691 if (i == j)
692 continue;
693
694 match_pr = per_cpu(processors, j);
695 if (!match_pr)
696 continue;
697
698 match_pdomain = &(match_pr->performance->domain_info);
699 if (match_pdomain->domain != pdomain->domain)
700 continue;
701
702 match_pr->performance->shared_type =
703 pr->performance->shared_type;
704 match_pr->performance->shared_cpu_map =
705 pr->performance->shared_cpu_map;
706 }
707 }
708
709err_ret:
710 for_each_possible_cpu(i) {
711 pr = per_cpu(processors, i);
712 if (!pr || !pr->performance)
713 continue;
714
715
716 if (retval) {
717 cpus_clear(pr->performance->shared_cpu_map);
718 cpu_set(i, pr->performance->shared_cpu_map);
719 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL;
720 }
721 pr->performance = NULL;
722 }
723
724 mutex_unlock(&performance_mutex);
725 return retval;
726}
727EXPORT_SYMBOL(acpi_processor_preregister_performance);
728
729
730int
731acpi_processor_register_performance(struct acpi_processor_performance
732 *performance, unsigned int cpu)
733{
734 struct acpi_processor *pr;
735
736
737 if (!(acpi_processor_ppc_status & PPC_REGISTERED))
738 return -EINVAL;
739
740 mutex_lock(&performance_mutex);
741
742 pr = per_cpu(processors, cpu);
743 if (!pr) {
744 mutex_unlock(&performance_mutex);
745 return -ENODEV;
746 }
747
748 if (pr->performance) {
749 mutex_unlock(&performance_mutex);
750 return -EBUSY;
751 }
752
753 WARN_ON(!performance);
754
755 pr->performance = performance;
756
757 if (acpi_processor_get_performance_info(pr)) {
758 pr->performance = NULL;
759 mutex_unlock(&performance_mutex);
760 return -EIO;
761 }
762
763 acpi_cpufreq_add_file(pr);
764
765 mutex_unlock(&performance_mutex);
766 return 0;
767}
768
769EXPORT_SYMBOL(acpi_processor_register_performance);
770
771void
772acpi_processor_unregister_performance(struct acpi_processor_performance
773 *performance, unsigned int cpu)
774{
775 struct acpi_processor *pr;
776
777
778 mutex_lock(&performance_mutex);
779
780 pr = per_cpu(processors, cpu);
781 if (!pr) {
782 mutex_unlock(&performance_mutex);
783 return;
784 }
785
786 if (pr->performance)
787 kfree(pr->performance->states);
788 pr->performance = NULL;
789
790 acpi_cpufreq_remove_file(pr);
791
792 mutex_unlock(&performance_mutex);
793
794 return;
795}
796
797EXPORT_SYMBOL(acpi_processor_unregister_performance);
798
