1 /* 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 #include <linux/kernel.h> 30 #include <linux/module.h> 31 #include <linux/init.h> 32 #include <linux/cpufreq.h> 33 34 #ifdef CONFIG_X86 35 #include <asm/cpufeature.h> 36 #endif 37 38 #include <acpi/acpi_bus.h> 39 #include <acpi/acpi_drivers.h> 40 #include <acpi/processor.h> 41 42 #define ACPI_PROCESSOR_CLASS "processor" 43 #define ACPI_PROCESSOR_FILE_PERFORMANCE "performance" 44 #define _COMPONENT ACPI_PROCESSOR_COMPONENT 45 ACPI_MODULE_NAME("processor_perflib"); 46 47 static DEFINE_MUTEX(performance_mutex); 48 49 /* Use cpufreq debug layer for _PPC changes. */ 50 #define cpufreq_printk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, \ 51 "cpufreq-core", msg) 52 53 /* 54 * _PPC support is implemented as a CPUfreq policy notifier: 55 * This means each time a CPUfreq driver registered also with 56 * the ACPI core is asked to change the speed policy, the maximum 57 * value is adjusted so that it is within the platform limit. 58 * 59 * Also, when a new platform limit value is detected, the CPUfreq 60 * policy is adjusted accordingly. 61 */ 62 63 /* ignore_ppc: 64 * -1 -> cpufreq low level drivers not initialized -> _PSS, etc. not called yet 65 * ignore _PPC 66 * 0 -> cpufreq low level drivers initialized -> consider _PPC values 67 * 1 -> ignore _PPC totally -> forced by user through boot param 68 */ 69 static int ignore_ppc = -1; 70 module_param(ignore_ppc, int, 0644); 71 MODULE_PARM_DESC(ignore_ppc, "If the frequency of your machine gets wrongly" \ 72 "limited by BIOS, this should help"); 73 74 #define PPC_REGISTERED 1 75 #define PPC_IN_USE 2 76 77 static int acpi_processor_ppc_status; 78 79 static int acpi_processor_ppc_notifier(struct notifier_block *nb, 80 unsigned long event, void *data) 81 { 82 struct cpufreq_policy *policy = data; 83 struct acpi_processor *pr; 84 unsigned int ppc = 0; 85 86 if (event == CPUFREQ_START && ignore_ppc <= 0) { 87 ignore_ppc = 0; 88 return 0; 89 } 90 91 if (ignore_ppc) 92 return 0; 93 94 if (event != CPUFREQ_INCOMPATIBLE) 95 return 0; 96 97 mutex_lock(&performance_mutex); 98 99 pr = per_cpu(processors, policy->cpu); 100 if (!pr || !pr->performance) 101 goto out; 102 103 ppc = (unsigned int)pr->performance_platform_limit; 104 105 if (ppc >= pr->performance->state_count) 106 goto out; 107 108 cpufreq_verify_within_limits(policy, 0, 109 pr->performance->states[ppc]. 110 core_frequency * 1000); 111 112 out: 113 mutex_unlock(&performance_mutex); 114 115 return 0; 116 } 117 118 static struct notifier_block acpi_ppc_notifier_block = { 119 .notifier_call = acpi_processor_ppc_notifier, 120 }; 121 122 static int acpi_processor_get_platform_limit(struct acpi_processor *pr) 123 { 124 acpi_status status = 0; 125 unsigned long long ppc = 0; 126 127 128 if (!pr) 129 return -EINVAL; 130 131 /* 132 * _PPC indicates the maximum state currently supported by the platform 133 * (e.g. 0 = states 0..n; 1 = states 1..n; etc. 134 */ 135 status = acpi_evaluate_integer(pr->handle, "_PPC", NULL, &ppc); 136 137 if (status != AE_NOT_FOUND) 138 acpi_processor_ppc_status |= PPC_IN_USE; 139 140 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 141 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PPC")); 142 return -ENODEV; 143 } 144 145 cpufreq_printk("CPU %d: _PPC is %d - frequency %s limited\n", pr->id, 146 (int)ppc, ppc ? "" : "not"); 147 148 pr->performance_platform_limit = (int)ppc; 149 150 return 0; 151 } 152 153 int acpi_processor_ppc_has_changed(struct acpi_processor *pr) 154 { 155 int ret; 156 157 if (ignore_ppc) 158 return 0; 159 160 ret = acpi_processor_get_platform_limit(pr); 161 162 if (ret < 0) 163 return (ret); 164 else 165 return cpufreq_update_policy(pr->id); 166 } 167 168 void acpi_processor_ppc_init(void) 169 { 170 if (!cpufreq_register_notifier 171 (&acpi_ppc_notifier_block, CPUFREQ_POLICY_NOTIFIER)) 172 acpi_processor_ppc_status |= PPC_REGISTERED; 173 else 174 printk(KERN_DEBUG 175 "Warning: Processor Platform Limit not supported.\n"); 176 } 177 178 void acpi_processor_ppc_exit(void) 179 { 180 if (acpi_processor_ppc_status & PPC_REGISTERED) 181 cpufreq_unregister_notifier(&acpi_ppc_notifier_block, 182 CPUFREQ_POLICY_NOTIFIER); 183 184 acpi_processor_ppc_status &= ~PPC_REGISTERED; 185 } 186 187 static int acpi_processor_get_performance_control(struct acpi_processor *pr) 188 { 189 int result = 0; 190 acpi_status status = 0; 191 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 192 union acpi_object *pct = NULL; 193 union acpi_object obj = { 0 }; 194 195 196 status = acpi_evaluate_object(pr->handle, "_PCT", NULL, &buffer); 197 if (ACPI_FAILURE(status)) { 198 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PCT")); 199 return -ENODEV; 200 } 201 202 pct = (union acpi_object *)buffer.pointer; 203 if (!pct || (pct->type != ACPI_TYPE_PACKAGE) 204 || (pct->package.count != 2)) { 205 printk(KERN_ERR PREFIX "Invalid _PCT data\n"); 206 result = -EFAULT; 207 goto end; 208 } 209 210 /* 211 * control_register 212 */ 213 214 obj = pct->package.elements[0]; 215 216 if ((obj.type != ACPI_TYPE_BUFFER) 217 || (obj.buffer.length < sizeof(struct acpi_pct_register)) 218 || (obj.buffer.pointer == NULL)) { 219 printk(KERN_ERR PREFIX "Invalid _PCT data (control_register)\n"); 220 result = -EFAULT; 221 goto end; 222 } 223 memcpy(&pr->performance->control_register, obj.buffer.pointer, 224 sizeof(struct acpi_pct_register)); 225 226 /* 227 * status_register 228 */ 229 230 obj = pct->package.elements[1]; 231 232 if ((obj.type != ACPI_TYPE_BUFFER) 233 || (obj.buffer.length < sizeof(struct acpi_pct_register)) 234 || (obj.buffer.pointer == NULL)) { 235 printk(KERN_ERR PREFIX "Invalid _PCT data (status_register)\n"); 236 result = -EFAULT; 237 goto end; 238 } 239 240 memcpy(&pr->performance->status_register, obj.buffer.pointer, 241 sizeof(struct acpi_pct_register)); 242 243 end: 244 kfree(buffer.pointer); 245 246 return result; 247 } 248 249 static int acpi_processor_get_performance_states(struct acpi_processor *pr) 250 { 251 int result = 0; 252 acpi_status status = AE_OK; 253 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 254 struct acpi_buffer format = { sizeof("NNNNNN"), "NNNNNN" }; 255 struct acpi_buffer state = { 0, NULL }; 256 union acpi_object *pss = NULL; 257 int i; 258 259 260 status = acpi_evaluate_object(pr->handle, "_PSS", NULL, &buffer); 261 if (ACPI_FAILURE(status)) { 262 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PSS")); 263 return -ENODEV; 264 } 265 266 pss = buffer.pointer; 267 if (!pss || (pss->type != ACPI_TYPE_PACKAGE)) { 268 printk(KERN_ERR PREFIX "Invalid _PSS data\n"); 269 result = -EFAULT; 270 goto end; 271 } 272 273 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d performance states\n", 274 pss->package.count)); 275 276 pr->performance->state_count = pss->package.count; 277 pr->performance->states = 278 kmalloc(sizeof(struct acpi_processor_px) * pss->package.count, 279 GFP_KERNEL); 280 if (!pr->performance->states) { 281 result = -ENOMEM; 282 goto end; 283 } 284 285 for (i = 0; i < pr->performance->state_count; i++) { 286 287 struct acpi_processor_px *px = &(pr->performance->states[i]); 288 289 state.length = sizeof(struct acpi_processor_px); 290 state.pointer = px; 291 292 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i)); 293 294 status = acpi_extract_package(&(pss->package.elements[i]), 295 &format, &state); 296 if (ACPI_FAILURE(status)) { 297 ACPI_EXCEPTION((AE_INFO, status, "Invalid _PSS data")); 298 result = -EFAULT; 299 kfree(pr->performance->states); 300 goto end; 301 } 302 303 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 304 "State [%d]: core_frequency[%d] power[%d] transition_latency[%d] bus_master_latency[%d] control[0x%x] status[0x%x]\n", 305 i, 306 (u32) px->core_frequency, 307 (u32) px->power, 308 (u32) px->transition_latency, 309 (u32) px->bus_master_latency, 310 (u32) px->control, (u32) px->status)); 311 312 if (!px->core_frequency) { 313 printk(KERN_ERR PREFIX 314 "Invalid _PSS data: freq is zero\n"); 315 result = -EFAULT; 316 kfree(pr->performance->states); 317 goto end; 318 } 319 } 320 321 end: 322 kfree(buffer.pointer); 323 324 return result; 325 } 326 327 static int acpi_processor_get_performance_info(struct acpi_processor *pr) 328 { 329 int result = 0; 330 acpi_status status = AE_OK; 331 acpi_handle handle = NULL; 332 333 if (!pr || !pr->performance || !pr->handle) 334 return -EINVAL; 335 336 status = acpi_get_handle(pr->handle, "_PCT", &handle); 337 if (ACPI_FAILURE(status)) { 338 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 339 "ACPI-based processor performance control unavailable\n")); 340 return -ENODEV; 341 } 342 343 result = acpi_processor_get_performance_control(pr); 344 if (result) 345 goto update_bios; 346 347 result = acpi_processor_get_performance_states(pr); 348 if (result) 349 goto update_bios; 350 351 return 0; 352 353 /* 354 * Having _PPC but missing frequencies (_PSS, _PCT) is a very good hint that 355 * the BIOS is older than the CPU and does not know its frequencies 356 */ 357 update_bios: 358 #ifdef CONFIG_X86 359 if (ACPI_SUCCESS(acpi_get_handle(pr->handle, "_PPC", &handle))){ 360 if(boot_cpu_has(X86_FEATURE_EST)) 361 printk(KERN_WARNING FW_BUG "BIOS needs update for CPU " 362 "frequency support\n"); 363 } 364 #endif 365 return result; 366 } 367 368 int acpi_processor_notify_smm(struct module *calling_module) 369 { 370 acpi_status status; 371 static int is_done = 0; 372 373 374 if (!(acpi_processor_ppc_status & PPC_REGISTERED)) 375 return -EBUSY; 376 377 if (!try_module_get(calling_module)) 378 return -EINVAL; 379 380 /* is_done is set to negative if an error occured, 381 * and to postitive if _no_ error occured, but SMM 382 * was already notified. This avoids double notification 383 * which might lead to unexpected results... 384 */ 385 if (is_done > 0) { 386 module_put(calling_module); 387 return 0; 388 } else if (is_done < 0) { 389 module_put(calling_module); 390 return is_done; 391 } 392 393 is_done = -EIO; 394 395 /* Can't write pstate_control to smi_command if either value is zero */ 396 if ((!acpi_gbl_FADT.smi_command) || (!acpi_gbl_FADT.pstate_control)) { 397 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No SMI port or pstate_control\n")); 398 module_put(calling_module); 399 return 0; 400 } 401 402 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 403 "Writing pstate_control [0x%x] to smi_command [0x%x]\n", 404 acpi_gbl_FADT.pstate_control, acpi_gbl_FADT.smi_command)); 405 406 status = acpi_os_write_port(acpi_gbl_FADT.smi_command, 407 (u32) acpi_gbl_FADT.pstate_control, 8); 408 if (ACPI_FAILURE(status)) { 409 ACPI_EXCEPTION((AE_INFO, status, 410 "Failed to write pstate_control [0x%x] to " 411 "smi_command [0x%x]", acpi_gbl_FADT.pstate_control, 412 acpi_gbl_FADT.smi_command)); 413 module_put(calling_module); 414 return status; 415 } 416 417 /* Success. If there's no _PPC, we need to fear nothing, so 418 * we can allow the cpufreq driver to be rmmod'ed. */ 419 is_done = 1; 420 421 if (!(acpi_processor_ppc_status & PPC_IN_USE)) 422 module_put(calling_module); 423 424 return 0; 425 } 426 427 EXPORT_SYMBOL(acpi_processor_notify_smm); 428 429 static int acpi_processor_get_psd(struct acpi_processor *pr) 430 { 431 int result = 0; 432 acpi_status status = AE_OK; 433 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; 434 struct acpi_buffer format = {sizeof("NNNNN"), "NNNNN"}; 435 struct acpi_buffer state = {0, NULL}; 436 union acpi_object *psd = NULL; 437 struct acpi_psd_package *pdomain; 438 439 status = acpi_evaluate_object(pr->handle, "_PSD", NULL, &buffer); 440 if (ACPI_FAILURE(status)) { 441 return -ENODEV; 442 } 443 444 psd = buffer.pointer; 445 if (!psd || (psd->type != ACPI_TYPE_PACKAGE)) { 446 printk(KERN_ERR PREFIX "Invalid _PSD data\n"); 447 result = -EFAULT; 448 goto end; 449 } 450 451 if (psd->package.count != 1) { 452 printk(KERN_ERR PREFIX "Invalid _PSD data\n"); 453 result = -EFAULT; 454 goto end; 455 } 456 457 pdomain = &(pr->performance->domain_info); 458 459 state.length = sizeof(struct acpi_psd_package); 460 state.pointer = pdomain; 461 462 status = acpi_extract_package(&(psd->package.elements[0]), 463 &format, &state); 464 if (ACPI_FAILURE(status)) { 465 printk(KERN_ERR PREFIX "Invalid _PSD data\n"); 466 result = -EFAULT; 467 goto end; 468 } 469 470 if (pdomain->num_entries != ACPI_PSD_REV0_ENTRIES) { 471 printk(KERN_ERR PREFIX "Unknown _PSD:num_entries\n"); 472 result = -EFAULT; 473 goto end; 474 } 475 476 if (pdomain->revision != ACPI_PSD_REV0_REVISION) { 477 printk(KERN_ERR PREFIX "Unknown _PSD:revision\n"); 478 result = -EFAULT; 479 goto end; 480 } 481 482 end: 483 kfree(buffer.pointer); 484 return result; 485 } 486 487 int acpi_processor_preregister_performance( 488 struct acpi_processor_performance *performance) 489 { 490 int count, count_target; 491 int retval = 0; 492 unsigned int i, j; 493 cpumask_var_t covered_cpus; 494 struct acpi_processor *pr; 495 struct acpi_psd_package *pdomain; 496 struct acpi_processor *match_pr; 497 struct acpi_psd_package *match_pdomain; 498 499 if (!alloc_cpumask_var(&covered_cpus, GFP_KERNEL)) 500 return -ENOMEM; 501 502 mutex_lock(&performance_mutex); 503 504 retval = 0; 505 506 /* Call _PSD for all CPUs */ 507 for_each_possible_cpu(i) { 508 pr = per_cpu(processors, i); 509 if (!pr) { 510 /* Look only at processors in ACPI namespace */ 511 continue; 512 } 513 514 if (pr->performance) { 515 retval = -EBUSY; 516 continue; 517 } 518 519 if (!performance || !per_cpu_ptr(performance, i)) { 520 retval = -EINVAL; 521 continue; 522 } 523 524 pr->performance = per_cpu_ptr(performance, i); 525 cpumask_set_cpu(i, pr->performance->shared_cpu_map); 526 if (acpi_processor_get_psd(pr)) { 527 retval = -EINVAL; 528 continue; 529 } 530 } 531 if (retval) 532 goto err_ret; 533 534 /* 535 * Now that we have _PSD data from all CPUs, lets setup P-state 536 * domain info. 537 */ 538 for_each_possible_cpu(i) { 539 pr = per_cpu(processors, i); 540 if (!pr) 541 continue; 542 543 /* Basic validity check for domain info */ 544 pdomain = &(pr->performance->domain_info); 545 if ((pdomain->revision != ACPI_PSD_REV0_REVISION) || 546 (pdomain->num_entries != ACPI_PSD_REV0_ENTRIES)) { 547 retval = -EINVAL; 548 goto err_ret; 549 } 550 if (pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ALL && 551 pdomain->coord_type != DOMAIN_COORD_TYPE_SW_ANY && 552 pdomain->coord_type != DOMAIN_COORD_TYPE_HW_ALL) { 553 retval = -EINVAL; 554 goto err_ret; 555 } 556 } 557 558 cpumask_clear(covered_cpus); 559 for_each_possible_cpu(i) { 560 pr = per_cpu(processors, i); 561 if (!pr) 562 continue; 563 564 if (cpumask_test_cpu(i, covered_cpus)) 565 continue; 566 567 pdomain = &(pr->performance->domain_info); 568 cpumask_set_cpu(i, pr->performance->shared_cpu_map); 569 cpumask_set_cpu(i, covered_cpus); 570 if (pdomain->num_processors <= 1) 571 continue; 572 573 /* Validate the Domain info */ 574 count_target = pdomain->num_processors; 575 count = 1; 576 if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ALL) 577 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL; 578 else if (pdomain->coord_type == DOMAIN_COORD_TYPE_HW_ALL) 579 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_HW; 580 else if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ANY) 581 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ANY; 582 583 for_each_possible_cpu(j) { 584 if (i == j) 585 continue; 586 587 match_pr = per_cpu(processors, j); 588 if (!match_pr) 589 continue; 590 591 match_pdomain = &(match_pr->performance->domain_info); 592 if (match_pdomain->domain != pdomain->domain) 593 continue; 594 595 /* Here i and j are in the same domain */ 596 597 if (match_pdomain->num_processors != count_target) { 598 retval = -EINVAL; 599 goto err_ret; 600 } 601 602 if (pdomain->coord_type != match_pdomain->coord_type) { 603 retval = -EINVAL; 604 goto err_ret; 605 } 606 607 cpumask_set_cpu(j, covered_cpus); 608 cpumask_set_cpu(j, pr->performance->shared_cpu_map); 609 count++; 610 } 611 612 for_each_possible_cpu(j) { 613 if (i == j) 614 continue; 615 616 match_pr = per_cpu(processors, j); 617 if (!match_pr) 618 continue; 619 620 match_pdomain = &(match_pr->performance->domain_info); 621 if (match_pdomain->domain != pdomain->domain) 622 continue; 623 624 match_pr->performance->shared_type = 625 pr->performance->shared_type; 626 cpumask_copy(match_pr->performance->shared_cpu_map, 627 pr->performance->shared_cpu_map); 628 } 629 } 630 631 err_ret: 632 for_each_possible_cpu(i) { 633 pr = per_cpu(processors, i); 634 if (!pr || !pr->performance) 635 continue; 636 637 /* Assume no coordination on any error parsing domain info */ 638 if (retval) { 639 cpumask_clear(pr->performance->shared_cpu_map); 640 cpumask_set_cpu(i, pr->performance->shared_cpu_map); 641 pr->performance->shared_type = CPUFREQ_SHARED_TYPE_ALL; 642 } 643 pr->performance = NULL; /* Will be set for real in register */ 644 } 645 646 mutex_unlock(&performance_mutex); 647 free_cpumask_var(covered_cpus); 648 return retval; 649 } 650 EXPORT_SYMBOL(acpi_processor_preregister_performance); 651 652 int 653 acpi_processor_register_performance(struct acpi_processor_performance 654 *performance, unsigned int cpu) 655 { 656 struct acpi_processor *pr; 657 658 if (!(acpi_processor_ppc_status & PPC_REGISTERED)) 659 return -EINVAL; 660 661 mutex_lock(&performance_mutex); 662 663 pr = per_cpu(processors, cpu); 664 if (!pr) { 665 mutex_unlock(&performance_mutex); 666 return -ENODEV; 667 } 668 669 if (pr->performance) { 670 mutex_unlock(&performance_mutex); 671 return -EBUSY; 672 } 673 674 WARN_ON(!performance); 675 676 pr->performance = performance; 677 678 if (acpi_processor_get_performance_info(pr)) { 679 pr->performance = NULL; 680 mutex_unlock(&performance_mutex); 681 return -EIO; 682 } 683 684 mutex_unlock(&performance_mutex); 685 return 0; 686 } 687 688 EXPORT_SYMBOL(acpi_processor_register_performance); 689 690 void 691 acpi_processor_unregister_performance(struct acpi_processor_performance 692 *performance, unsigned int cpu) 693 { 694 struct acpi_processor *pr; 695 696 mutex_lock(&performance_mutex); 697 698 pr = per_cpu(processors, cpu); 699 if (!pr) { 700 mutex_unlock(&performance_mutex); 701 return; 702 } 703 704 if (pr->performance) 705 kfree(pr->performance->states); 706 pr->performance = NULL; 707 708 mutex_unlock(&performance_mutex); 709 710 return; 711 } 712 713 EXPORT_SYMBOL(acpi_processor_unregister_performance); 714