blob: 1f0d6256302fc61afee4a9b631b710ab2a07d395 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * processor_perflib.c - ACPI Processor P-States Library ($Revision: 71 $)
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 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or (at
16 * your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License along
24 * with this program; if not, write to the Free Software Foundation, Inc.,
25 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
26 *
27 */
28
29
30#include <linux/kernel.h>
31#include <linux/module.h>
32#include <linux/init.h>
33#include <linux/cpufreq.h>
34
35#ifdef CONFIG_X86_ACPI_CPUFREQ_PROC_INTF
36#include <linux/proc_fs.h>
37#include <linux/seq_file.h>
38
39#include <asm/uaccess.h>
40#endif
41
42#include <acpi/acpi_bus.h>
43#include <acpi/processor.h>
44
45
46#define ACPI_PROCESSOR_COMPONENT 0x01000000
47#define ACPI_PROCESSOR_CLASS "processor"
48#define ACPI_PROCESSOR_DRIVER_NAME "ACPI Processor Driver"
49#define ACPI_PROCESSOR_FILE_PERFORMANCE "performance"
50#define _COMPONENT ACPI_PROCESSOR_COMPONENT
51ACPI_MODULE_NAME ("acpi_processor")
52
53
54static DECLARE_MUTEX(performance_sem);
55
56/*
57 * _PPC support is implemented as a CPUfreq policy notifier:
58 * This means each time a CPUfreq driver registered also with
59 * the ACPI core is asked to change the speed policy, the maximum
60 * value is adjusted so that it is within the platform limit.
61 *
62 * Also, when a new platform limit value is detected, the CPUfreq
63 * policy is adjusted accordingly.
64 */
65
66#define PPC_REGISTERED 1
67#define PPC_IN_USE 2
68
69static int acpi_processor_ppc_status = 0;
70
71static int acpi_processor_ppc_notifier(struct notifier_block *nb,
72 unsigned long event,
73 void *data)
74{
75 struct cpufreq_policy *policy = data;
76 struct acpi_processor *pr;
77 unsigned int ppc = 0;
78
79 down(&performance_sem);
80
81 if (event != CPUFREQ_INCOMPATIBLE)
82 goto out;
83
84 pr = processors[policy->cpu];
85 if (!pr || !pr->performance)
86 goto out;
87
88 ppc = (unsigned int) pr->performance_platform_limit;
89 if (!ppc)
90 goto out;
91
92 if (ppc > pr->performance->state_count)
93 goto out;
94
95 cpufreq_verify_within_limits(policy, 0,
96 pr->performance->states[ppc].core_frequency * 1000);
97
98 out:
99 up(&performance_sem);
100
101 return 0;
102}
103
104
105static struct notifier_block acpi_ppc_notifier_block = {
106 .notifier_call = acpi_processor_ppc_notifier,
107};
108
109
110static int
111acpi_processor_get_platform_limit (
112 struct acpi_processor* pr)
113{
114 acpi_status status = 0;
115 unsigned long ppc = 0;
116
117 ACPI_FUNCTION_TRACE("acpi_processor_get_platform_limit");
118
119 if (!pr)
120 return_VALUE(-EINVAL);
121
122 /*
123 * _PPC indicates the maximum state currently supported by the platform
124 * (e.g. 0 = states 0..n; 1 = states 1..n; etc.
125 */
126 status = acpi_evaluate_integer(pr->handle, "_PPC", NULL, &ppc);
127
128 if (status != AE_NOT_FOUND)
129 acpi_processor_ppc_status |= PPC_IN_USE;
130
131 if(ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
132 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PPC\n"));
133 return_VALUE(-ENODEV);
134 }
135
136 pr->performance_platform_limit = (int) ppc;
137
138 return_VALUE(0);
139}
140
141
142int acpi_processor_ppc_has_changed(
143 struct acpi_processor *pr)
144{
145 int ret = acpi_processor_get_platform_limit(pr);
146 if (ret < 0)
147 return (ret);
148 else
149 return cpufreq_update_policy(pr->id);
150}
151
152
153void acpi_processor_ppc_init(void) {
154 if (!cpufreq_register_notifier(&acpi_ppc_notifier_block, CPUFREQ_POLICY_NOTIFIER))
155 acpi_processor_ppc_status |= PPC_REGISTERED;
156 else
157 printk(KERN_DEBUG "Warning: Processor Platform Limit not supported.\n");
158}
159
160
161void acpi_processor_ppc_exit(void) {
162 if (acpi_processor_ppc_status & PPC_REGISTERED)
163 cpufreq_unregister_notifier(&acpi_ppc_notifier_block, CPUFREQ_POLICY_NOTIFIER);
164
165 acpi_processor_ppc_status &= ~PPC_REGISTERED;
166}
167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
169static int
170acpi_processor_get_performance_control (
171 struct acpi_processor *pr)
172{
173 int result = 0;
174 acpi_status status = 0;
175 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
176 union acpi_object *pct = NULL;
177 union acpi_object obj = {0};
178
179 ACPI_FUNCTION_TRACE("acpi_processor_get_performance_control");
180
181 status = acpi_evaluate_object(pr->handle, "_PCT", NULL, &buffer);
182 if(ACPI_FAILURE(status)) {
183 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PCT\n"));
184 return_VALUE(-ENODEV);
185 }
186
187 pct = (union acpi_object *) buffer.pointer;
188 if (!pct || (pct->type != ACPI_TYPE_PACKAGE)
189 || (pct->package.count != 2)) {
190 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PCT data\n"));
191 result = -EFAULT;
192 goto end;
193 }
194
195 /*
196 * control_register
197 */
198
199 obj = pct->package.elements[0];
200
201 if ((obj.type != ACPI_TYPE_BUFFER)
202 || (obj.buffer.length < sizeof(struct acpi_pct_register))
203 || (obj.buffer.pointer == NULL)) {
204 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
205 "Invalid _PCT data (control_register)\n"));
206 result = -EFAULT;
207 goto end;
208 }
209 memcpy(&pr->performance->control_register, obj.buffer.pointer, sizeof(struct acpi_pct_register));
210
211
212 /*
213 * status_register
214 */
215
216 obj = pct->package.elements[1];
217
218 if ((obj.type != ACPI_TYPE_BUFFER)
219 || (obj.buffer.length < sizeof(struct acpi_pct_register))
220 || (obj.buffer.pointer == NULL)) {
221 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
222 "Invalid _PCT data (status_register)\n"));
223 result = -EFAULT;
224 goto end;
225 }
226
227 memcpy(&pr->performance->status_register, obj.buffer.pointer, sizeof(struct acpi_pct_register));
228
229end:
230 acpi_os_free(buffer.pointer);
231
232 return_VALUE(result);
233}
234
235
236static int
237acpi_processor_get_performance_states (
238 struct acpi_processor *pr)
239{
240 int result = 0;
241 acpi_status status = AE_OK;
242 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
243 struct acpi_buffer format = {sizeof("NNNNNN"), "NNNNNN"};
244 struct acpi_buffer state = {0, NULL};
245 union acpi_object *pss = NULL;
246 int i;
247
248 ACPI_FUNCTION_TRACE("acpi_processor_get_performance_states");
249
250 status = acpi_evaluate_object(pr->handle, "_PSS", NULL, &buffer);
251 if(ACPI_FAILURE(status)) {
252 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PSS\n"));
253 return_VALUE(-ENODEV);
254 }
255
256 pss = (union acpi_object *) buffer.pointer;
257 if (!pss || (pss->type != ACPI_TYPE_PACKAGE)) {
258 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSS data\n"));
259 result = -EFAULT;
260 goto end;
261 }
262
263 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d performance states\n",
264 pss->package.count));
265
266 pr->performance->state_count = pss->package.count;
267 pr->performance->states = kmalloc(sizeof(struct acpi_processor_px) * pss->package.count, GFP_KERNEL);
268 if (!pr->performance->states) {
269 result = -ENOMEM;
270 goto end;
271 }
272
273 for (i = 0; i < pr->performance->state_count; i++) {
274
275 struct acpi_processor_px *px = &(pr->performance->states[i]);
276
277 state.length = sizeof(struct acpi_processor_px);
278 state.pointer = px;
279
280 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
281
282 status = acpi_extract_package(&(pss->package.elements[i]),
283 &format, &state);
284 if (ACPI_FAILURE(status)) {
285 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSS data\n"));
286 result = -EFAULT;
287 kfree(pr->performance->states);
288 goto end;
289 }
290
291 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
292 "State [%d]: core_frequency[%d] power[%d] transition_latency[%d] bus_master_latency[%d] control[0x%x] status[0x%x]\n",
293 i,
294 (u32) px->core_frequency,
295 (u32) px->power,
296 (u32) px->transition_latency,
297 (u32) px->bus_master_latency,
298 (u32) px->control,
299 (u32) px->status));
300
301 if (!px->core_frequency) {
302 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _PSS data: freq is zero\n"));
303 result = -EFAULT;
304 kfree(pr->performance->states);
305 goto end;
306 }
307 }
308
309end:
310 acpi_os_free(buffer.pointer);
311
312 return_VALUE(result);
313}
314
315
316static int
317acpi_processor_get_performance_info (
318 struct acpi_processor *pr)
319{
320 int result = 0;
321 acpi_status status = AE_OK;
322 acpi_handle handle = NULL;
323
324 ACPI_FUNCTION_TRACE("acpi_processor_get_performance_info");
325
326 if (!pr || !pr->performance || !pr->handle)
327 return_VALUE(-EINVAL);
328
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400329 acpi_processor_set_pdc(pr, pr->performance->pdc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330
331 status = acpi_get_handle(pr->handle, "_PCT", &handle);
332 if (ACPI_FAILURE(status)) {
333 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
334 "ACPI-based processor performance control unavailable\n"));
335 return_VALUE(-ENODEV);
336 }
337
338 result = acpi_processor_get_performance_control(pr);
339 if (result)
340 return_VALUE(result);
341
342 result = acpi_processor_get_performance_states(pr);
343 if (result)
344 return_VALUE(result);
345
346 result = acpi_processor_get_platform_limit(pr);
347 if (result)
348 return_VALUE(result);
349
350 return_VALUE(0);
351}
352
353
354int acpi_processor_notify_smm(struct module *calling_module) {
355 acpi_status status;
356 static int is_done = 0;
357
358 ACPI_FUNCTION_TRACE("acpi_processor_notify_smm");
359
360 if (!(acpi_processor_ppc_status & PPC_REGISTERED))
361 return_VALUE(-EBUSY);
362
363 if (!try_module_get(calling_module))
364 return_VALUE(-EINVAL);
365
366 /* is_done is set to negative if an error occured,
367 * and to postitive if _no_ error occured, but SMM
368 * was already notified. This avoids double notification
369 * which might lead to unexpected results...
370 */
371 if (is_done > 0) {
372 module_put(calling_module);
373 return_VALUE(0);
374 }
375 else if (is_done < 0) {
376 module_put(calling_module);
377 return_VALUE(is_done);
378 }
379
380 is_done = -EIO;
381
382 /* Can't write pstate_cnt to smi_cmd if either value is zero */
383 if ((!acpi_fadt.smi_cmd) ||
384 (!acpi_fadt.pstate_cnt)) {
385 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
386 "No SMI port or pstate_cnt\n"));
387 module_put(calling_module);
388 return_VALUE(0);
389 }
390
391 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Writing pstate_cnt [0x%x] to smi_cmd [0x%x]\n", acpi_fadt.pstate_cnt, acpi_fadt.smi_cmd));
392
393 /* FADT v1 doesn't support pstate_cnt, many BIOS vendors use
394 * it anyway, so we need to support it... */
395 if (acpi_fadt_is_v1) {
396 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Using v1.0 FADT reserved value for pstate_cnt\n"));
397 }
398
399 status = acpi_os_write_port (acpi_fadt.smi_cmd,
400 (u32) acpi_fadt.pstate_cnt, 8);
401 if (ACPI_FAILURE (status)) {
402 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
403 "Failed to write pstate_cnt [0x%x] to "
404 "smi_cmd [0x%x]\n", acpi_fadt.pstate_cnt, acpi_fadt.smi_cmd));
405 module_put(calling_module);
406 return_VALUE(status);
407 }
408
409 /* Success. If there's no _PPC, we need to fear nothing, so
410 * we can allow the cpufreq driver to be rmmod'ed. */
411 is_done = 1;
412
413 if (!(acpi_processor_ppc_status & PPC_IN_USE))
414 module_put(calling_module);
415
416 return_VALUE(0);
417}
418EXPORT_SYMBOL(acpi_processor_notify_smm);
419
420
421#ifdef CONFIG_X86_ACPI_CPUFREQ_PROC_INTF
422/* /proc/acpi/processor/../performance interface (DEPRECATED) */
423
424static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file);
425static struct file_operations acpi_processor_perf_fops = {
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 = (struct acpi_processor *)seq->private;
435 int i;
436
437 ACPI_FUNCTION_TRACE("acpi_processor_perf_seq_show");
438
439 if (!pr)
440 goto end;
441
442 if (!pr->performance) {
443 seq_puts(seq, "<not supported>\n");
444 goto end;
445 }
446
447 seq_printf(seq, "state count: %d\n"
448 "active state: P%d\n",
449 pr->performance->state_count,
450 pr->performance->state);
451
452 seq_puts(seq, "states:\n");
453 for (i = 0; i < pr->performance->state_count; i++)
454 seq_printf(seq, " %cP%d: %d MHz, %d mW, %d uS\n",
455 (i == pr->performance->state?'*':' '), i,
456 (u32) pr->performance->states[i].core_frequency,
457 (u32) pr->performance->states[i].power,
458 (u32) pr->performance->states[i].transition_latency);
459
460end:
461 return_VALUE(0);
462}
463
464static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file)
465{
466 return single_open(file, acpi_processor_perf_seq_show,
467 PDE(inode)->data);
468}
469
470static ssize_t
471acpi_processor_write_performance (
472 struct file *file,
473 const char __user *buffer,
474 size_t count,
475 loff_t *data)
476{
477 int result = 0;
478 struct seq_file *m = (struct seq_file *) file->private_data;
479 struct acpi_processor *pr = (struct acpi_processor *) m->private;
480 struct acpi_processor_performance *perf;
481 char state_string[12] = {'\0'};
482 unsigned int new_state = 0;
483 struct cpufreq_policy policy;
484
485 ACPI_FUNCTION_TRACE("acpi_processor_write_performance");
486
487 if (!pr || (count > sizeof(state_string) - 1))
488 return_VALUE(-EINVAL);
489
490 perf = pr->performance;
491 if (!perf)
492 return_VALUE(-EINVAL);
493
494 if (copy_from_user(state_string, buffer, count))
495 return_VALUE(-EFAULT);
496
497 state_string[count] = '\0';
498 new_state = simple_strtoul(state_string, NULL, 0);
499
500 if (new_state >= perf->state_count)
501 return_VALUE(-EINVAL);
502
503 cpufreq_get_policy(&policy, pr->id);
504
505 policy.cpu = pr->id;
506 policy.min = perf->states[new_state].core_frequency * 1000;
507 policy.max = perf->states[new_state].core_frequency * 1000;
508
509 result = cpufreq_set_policy(&policy);
510 if (result)
511 return_VALUE(result);
512
513 return_VALUE(count);
514}
515
516static void
517acpi_cpufreq_add_file (
518 struct acpi_processor *pr)
519{
520 struct proc_dir_entry *entry = NULL;
521 struct acpi_device *device = NULL;
522
523 ACPI_FUNCTION_TRACE("acpi_cpufreq_addfile");
524
525 if (acpi_bus_get_device(pr->handle, &device))
526 return_VOID;
527
528 /* add file 'performance' [R/W] */
529 entry = create_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE,
530 S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device));
531 if (!entry)
532 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
533 "Unable to create '%s' fs entry\n",
534 ACPI_PROCESSOR_FILE_PERFORMANCE));
535 else {
536 entry->proc_fops = &acpi_processor_perf_fops;
537 entry->proc_fops->write = acpi_processor_write_performance;
538 entry->data = acpi_driver_data(device);
539 entry->owner = THIS_MODULE;
540 }
541 return_VOID;
542}
543
544static void
545acpi_cpufreq_remove_file (
546 struct acpi_processor *pr)
547{
548 struct acpi_device *device = NULL;
549
550 ACPI_FUNCTION_TRACE("acpi_cpufreq_addfile");
551
552 if (acpi_bus_get_device(pr->handle, &device))
553 return_VOID;
554
555 /* remove file 'performance' */
556 remove_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE,
557 acpi_device_dir(device));
558
559 return_VOID;
560}
561
562#else
563static void acpi_cpufreq_add_file (struct acpi_processor *pr) { return; }
564static void acpi_cpufreq_remove_file (struct acpi_processor *pr) { return; }
565#endif /* CONFIG_X86_ACPI_CPUFREQ_PROC_INTF */
566
567
568int
569acpi_processor_register_performance (
570 struct acpi_processor_performance * performance,
571 unsigned int cpu)
572{
573 struct acpi_processor *pr;
574
575 ACPI_FUNCTION_TRACE("acpi_processor_register_performance");
576
577 if (!(acpi_processor_ppc_status & PPC_REGISTERED))
578 return_VALUE(-EINVAL);
579
580 down(&performance_sem);
581
582 pr = processors[cpu];
583 if (!pr) {
584 up(&performance_sem);
585 return_VALUE(-ENODEV);
586 }
587
588 if (pr->performance) {
589 up(&performance_sem);
590 return_VALUE(-EBUSY);
591 }
592
593 pr->performance = performance;
594
595 if (acpi_processor_get_performance_info(pr)) {
596 pr->performance = NULL;
597 up(&performance_sem);
598 return_VALUE(-EIO);
599 }
600
601 acpi_cpufreq_add_file(pr);
602
603 up(&performance_sem);
604 return_VALUE(0);
605}
606EXPORT_SYMBOL(acpi_processor_register_performance);
607
608
609void
610acpi_processor_unregister_performance (
611 struct acpi_processor_performance * performance,
612 unsigned int cpu)
613{
614 struct acpi_processor *pr;
615
616 ACPI_FUNCTION_TRACE("acpi_processor_unregister_performance");
617
618 down(&performance_sem);
619
620 pr = processors[cpu];
621 if (!pr) {
622 up(&performance_sem);
623 return_VOID;
624 }
625
626 kfree(pr->performance->states);
627 pr->performance = NULL;
628
629 acpi_cpufreq_remove_file(pr);
630
631 up(&performance_sem);
632
633 return_VOID;
634}
635EXPORT_SYMBOL(acpi_processor_unregister_performance);