1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * acpi_processor.c - ACPI processor enumeration support 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 * Copyright (C) 2013, Intel Corporation 10 * Rafael J. Wysocki <rafael.j.wysocki@intel.com> 11 */ 12 13 #include <linux/acpi.h> 14 #include <linux/device.h> 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/pci.h> 18 19 #include <acpi/processor.h> 20 21 #include <asm/cpu.h> 22 23 #include "internal.h" 24 25 #define _COMPONENT ACPI_PROCESSOR_COMPONENT 26 27 ACPI_MODULE_NAME("processor"); 28 29 DEFINE_PER_CPU(struct acpi_processor *, processors); 30 EXPORT_PER_CPU_SYMBOL(processors); 31 32 /* -------------------------------------------------------------------------- 33 Errata Handling 34 -------------------------------------------------------------------------- */ 35 36 struct acpi_processor_errata errata __read_mostly; 37 EXPORT_SYMBOL_GPL(errata); 38 39 static int acpi_processor_errata_piix4(struct pci_dev *dev) 40 { 41 u8 value1 = 0; 42 u8 value2 = 0; 43 44 45 if (!dev) 46 return -EINVAL; 47 48 /* 49 * Note that 'dev' references the PIIX4 ACPI Controller. 50 */ 51 52 switch (dev->revision) { 53 case 0: 54 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 A-step\n")); 55 break; 56 case 1: 57 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4 B-step\n")); 58 break; 59 case 2: 60 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4E\n")); 61 break; 62 case 3: 63 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found PIIX4M\n")); 64 break; 65 default: 66 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found unknown PIIX4\n")); 67 break; 68 } 69 70 switch (dev->revision) { 71 72 case 0: /* PIIX4 A-step */ 73 case 1: /* PIIX4 B-step */ 74 /* 75 * See specification changes #13 ("Manual Throttle Duty Cycle") 76 * and #14 ("Enabling and Disabling Manual Throttle"), plus 77 * erratum #5 ("STPCLK# Deassertion Time") from the January 78 * 2002 PIIX4 specification update. Applies to only older 79 * PIIX4 models. 80 */ 81 errata.piix4.throttle = 1; 82 fallthrough; 83 84 case 2: /* PIIX4E */ 85 case 3: /* PIIX4M */ 86 /* 87 * See erratum #18 ("C3 Power State/BMIDE and Type-F DMA 88 * Livelock") from the January 2002 PIIX4 specification update. 89 * Applies to all PIIX4 models. 90 */ 91 92 /* 93 * BM-IDE 94 * ------ 95 * Find the PIIX4 IDE Controller and get the Bus Master IDE 96 * Status register address. We'll use this later to read 97 * each IDE controller's DMA status to make sure we catch all 98 * DMA activity. 99 */ 100 dev = pci_get_subsys(PCI_VENDOR_ID_INTEL, 101 PCI_DEVICE_ID_INTEL_82371AB, 102 PCI_ANY_ID, PCI_ANY_ID, NULL); 103 if (dev) { 104 errata.piix4.bmisx = pci_resource_start(dev, 4); 105 pci_dev_put(dev); 106 } 107 108 /* 109 * Type-F DMA 110 * ---------- 111 * Find the PIIX4 ISA Controller and read the Motherboard 112 * DMA controller's status to see if Type-F (Fast) DMA mode 113 * is enabled (bit 7) on either channel. Note that we'll 114 * disable C3 support if this is enabled, as some legacy 115 * devices won't operate well if fast DMA is disabled. 116 */ 117 dev = pci_get_subsys(PCI_VENDOR_ID_INTEL, 118 PCI_DEVICE_ID_INTEL_82371AB_0, 119 PCI_ANY_ID, PCI_ANY_ID, NULL); 120 if (dev) { 121 pci_read_config_byte(dev, 0x76, &value1); 122 pci_read_config_byte(dev, 0x77, &value2); 123 if ((value1 & 0x80) || (value2 & 0x80)) 124 errata.piix4.fdma = 1; 125 pci_dev_put(dev); 126 } 127 128 break; 129 } 130 131 if (errata.piix4.bmisx) 132 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 133 "Bus master activity detection (BM-IDE) erratum enabled\n")); 134 if (errata.piix4.fdma) 135 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 136 "Type-F DMA livelock erratum (C3 disabled)\n")); 137 138 return 0; 139 } 140 141 static int acpi_processor_errata(void) 142 { 143 int result = 0; 144 struct pci_dev *dev = NULL; 145 146 /* 147 * PIIX4 148 */ 149 dev = pci_get_subsys(PCI_VENDOR_ID_INTEL, 150 PCI_DEVICE_ID_INTEL_82371AB_3, PCI_ANY_ID, 151 PCI_ANY_ID, NULL); 152 if (dev) { 153 result = acpi_processor_errata_piix4(dev); 154 pci_dev_put(dev); 155 } 156 157 return result; 158 } 159 160 /* -------------------------------------------------------------------------- 161 Initialization 162 -------------------------------------------------------------------------- */ 163 164 #ifdef CONFIG_ACPI_HOTPLUG_CPU 165 int __weak acpi_map_cpu(acpi_handle handle, 166 phys_cpuid_t physid, u32 acpi_id, int *pcpu) 167 { 168 return -ENODEV; 169 } 170 171 int __weak acpi_unmap_cpu(int cpu) 172 { 173 return -ENODEV; 174 } 175 176 int __weak arch_register_cpu(int cpu) 177 { 178 return -ENODEV; 179 } 180 181 void __weak arch_unregister_cpu(int cpu) {} 182 183 static int acpi_processor_hotadd_init(struct acpi_processor *pr) 184 { 185 unsigned long long sta; 186 acpi_status status; 187 int ret; 188 189 if (invalid_phys_cpuid(pr->phys_id)) 190 return -ENODEV; 191 192 status = acpi_evaluate_integer(pr->handle, "_STA", NULL, &sta); 193 if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_PRESENT)) 194 return -ENODEV; 195 196 cpu_maps_update_begin(); 197 cpu_hotplug_begin(); 198 199 ret = acpi_map_cpu(pr->handle, pr->phys_id, pr->acpi_id, &pr->id); 200 if (ret) 201 goto out; 202 203 ret = arch_register_cpu(pr->id); 204 if (ret) { 205 acpi_unmap_cpu(pr->id); 206 goto out; 207 } 208 209 /* 210 * CPU got hot-added, but cpu_data is not initialized yet. Set a flag 211 * to delay cpu_idle/throttling initialization and do it when the CPU 212 * gets online for the first time. 213 */ 214 pr_info("CPU%d has been hot-added\n", pr->id); 215 pr->flags.need_hotplug_init = 1; 216 217 out: 218 cpu_hotplug_done(); 219 cpu_maps_update_done(); 220 return ret; 221 } 222 #else 223 static inline int acpi_processor_hotadd_init(struct acpi_processor *pr) 224 { 225 return -ENODEV; 226 } 227 #endif /* CONFIG_ACPI_HOTPLUG_CPU */ 228 229 static int acpi_processor_get_info(struct acpi_device *device) 230 { 231 union acpi_object object = { 0 }; 232 struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; 233 struct acpi_processor *pr = acpi_driver_data(device); 234 int device_declaration = 0; 235 acpi_status status = AE_OK; 236 static int cpu0_initialized; 237 unsigned long long value; 238 239 acpi_processor_errata(); 240 241 /* 242 * Check to see if we have bus mastering arbitration control. This 243 * is required for proper C3 usage (to maintain cache coherency). 244 */ 245 if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) { 246 pr->flags.bm_control = 1; 247 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 248 "Bus mastering arbitration control present\n")); 249 } else 250 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 251 "No bus mastering arbitration control\n")); 252 253 if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) { 254 /* Declared with "Processor" statement; match ProcessorID */ 255 status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer); 256 if (ACPI_FAILURE(status)) { 257 dev_err(&device->dev, 258 "Failed to evaluate processor object (0x%x)\n", 259 status); 260 return -ENODEV; 261 } 262 263 pr->acpi_id = object.processor.proc_id; 264 } else { 265 /* 266 * Declared with "Device" statement; match _UID. 267 */ 268 status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID, 269 NULL, &value); 270 if (ACPI_FAILURE(status)) { 271 dev_err(&device->dev, 272 "Failed to evaluate processor _UID (0x%x)\n", 273 status); 274 return -ENODEV; 275 } 276 device_declaration = 1; 277 pr->acpi_id = value; 278 } 279 280 if (acpi_duplicate_processor_id(pr->acpi_id)) { 281 if (pr->acpi_id == 0xff) 282 dev_info_once(&device->dev, 283 "Entry not well-defined, consider updating BIOS\n"); 284 else 285 dev_err(&device->dev, 286 "Failed to get unique processor _UID (0x%x)\n", 287 pr->acpi_id); 288 return -ENODEV; 289 } 290 291 pr->phys_id = acpi_get_phys_id(pr->handle, device_declaration, 292 pr->acpi_id); 293 if (invalid_phys_cpuid(pr->phys_id)) 294 acpi_handle_debug(pr->handle, "failed to get CPU physical ID.\n"); 295 296 pr->id = acpi_map_cpuid(pr->phys_id, pr->acpi_id); 297 if (!cpu0_initialized && !acpi_has_cpu_in_madt()) { 298 cpu0_initialized = 1; 299 /* 300 * Handle UP system running SMP kernel, with no CPU 301 * entry in MADT 302 */ 303 if (invalid_logical_cpuid(pr->id) && (num_online_cpus() == 1)) 304 pr->id = 0; 305 } 306 307 /* 308 * Extra Processor objects may be enumerated on MP systems with 309 * less than the max # of CPUs. They should be ignored _iff 310 * they are physically not present. 311 * 312 * NOTE: Even if the processor has a cpuid, it may not be present 313 * because cpuid <-> apicid mapping is persistent now. 314 */ 315 if (invalid_logical_cpuid(pr->id) || !cpu_present(pr->id)) { 316 int ret = acpi_processor_hotadd_init(pr); 317 if (ret) 318 return ret; 319 } 320 321 /* 322 * On some boxes several processors use the same processor bus id. 323 * But they are located in different scope. For example: 324 * \_SB.SCK0.CPU0 325 * \_SB.SCK1.CPU0 326 * Rename the processor device bus id. And the new bus id will be 327 * generated as the following format: 328 * CPU+CPU ID. 329 */ 330 sprintf(acpi_device_bid(device), "CPU%X", pr->id); 331 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id, 332 pr->acpi_id)); 333 334 if (!object.processor.pblk_address) 335 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n")); 336 else if (object.processor.pblk_length != 6) 337 dev_err(&device->dev, "Invalid PBLK length [%d]\n", 338 object.processor.pblk_length); 339 else { 340 pr->throttling.address = object.processor.pblk_address; 341 pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset; 342 pr->throttling.duty_width = acpi_gbl_FADT.duty_width; 343 344 pr->pblk = object.processor.pblk_address; 345 } 346 347 /* 348 * If ACPI describes a slot number for this CPU, we can use it to 349 * ensure we get the right value in the "physical id" field 350 * of /proc/cpuinfo 351 */ 352 status = acpi_evaluate_integer(pr->handle, "_SUN", NULL, &value); 353 if (ACPI_SUCCESS(status)) 354 arch_fix_phys_package_id(pr->id, value); 355 356 return 0; 357 } 358 359 /* 360 * Do not put anything in here which needs the core to be online. 361 * For example MSR access or setting up things which check for cpuinfo_x86 362 * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc. 363 * Such things have to be put in and set up by the processor driver's .probe(). 364 */ 365 static DEFINE_PER_CPU(void *, processor_device_array); 366 367 static int acpi_processor_add(struct acpi_device *device, 368 const struct acpi_device_id *id) 369 { 370 struct acpi_processor *pr; 371 struct device *dev; 372 int result = 0; 373 374 pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL); 375 if (!pr) 376 return -ENOMEM; 377 378 if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) { 379 result = -ENOMEM; 380 goto err_free_pr; 381 } 382 383 pr->handle = device->handle; 384 strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME); 385 strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS); 386 device->driver_data = pr; 387 388 result = acpi_processor_get_info(device); 389 if (result) /* Processor is not physically present or unavailable */ 390 return 0; 391 392 BUG_ON(pr->id >= nr_cpu_ids); 393 394 /* 395 * Buggy BIOS check. 396 * ACPI id of processors can be reported wrongly by the BIOS. 397 * Don't trust it blindly 398 */ 399 if (per_cpu(processor_device_array, pr->id) != NULL && 400 per_cpu(processor_device_array, pr->id) != device) { 401 dev_warn(&device->dev, 402 "BIOS reported wrong ACPI id %d for the processor\n", 403 pr->id); 404 /* Give up, but do not abort the namespace scan. */ 405 goto err; 406 } 407 /* 408 * processor_device_array is not cleared on errors to allow buggy BIOS 409 * checks. 410 */ 411 per_cpu(processor_device_array, pr->id) = device; 412 per_cpu(processors, pr->id) = pr; 413 414 dev = get_cpu_device(pr->id); 415 if (!dev) { 416 result = -ENODEV; 417 goto err; 418 } 419 420 result = acpi_bind_one(dev, device); 421 if (result) 422 goto err; 423 424 pr->dev = dev; 425 426 /* Trigger the processor driver's .probe() if present. */ 427 if (device_attach(dev) >= 0) 428 return 1; 429 430 dev_err(dev, "Processor driver could not be attached\n"); 431 acpi_unbind_one(dev); 432 433 err: 434 free_cpumask_var(pr->throttling.shared_cpu_map); 435 device->driver_data = NULL; 436 per_cpu(processors, pr->id) = NULL; 437 err_free_pr: 438 kfree(pr); 439 return result; 440 } 441 442 #ifdef CONFIG_ACPI_HOTPLUG_CPU 443 /* -------------------------------------------------------------------------- 444 Removal 445 -------------------------------------------------------------------------- */ 446 447 static void acpi_processor_remove(struct acpi_device *device) 448 { 449 struct acpi_processor *pr; 450 451 if (!device || !acpi_driver_data(device)) 452 return; 453 454 pr = acpi_driver_data(device); 455 if (pr->id >= nr_cpu_ids) 456 goto out; 457 458 /* 459 * The only reason why we ever get here is CPU hot-removal. The CPU is 460 * already offline and the ACPI device removal locking prevents it from 461 * being put back online at this point. 462 * 463 * Unbind the driver from the processor device and detach it from the 464 * ACPI companion object. 465 */ 466 device_release_driver(pr->dev); 467 acpi_unbind_one(pr->dev); 468 469 /* Clean up. */ 470 per_cpu(processor_device_array, pr->id) = NULL; 471 per_cpu(processors, pr->id) = NULL; 472 473 cpu_maps_update_begin(); 474 cpu_hotplug_begin(); 475 476 /* Remove the CPU. */ 477 arch_unregister_cpu(pr->id); 478 acpi_unmap_cpu(pr->id); 479 480 cpu_hotplug_done(); 481 cpu_maps_update_done(); 482 483 try_offline_node(cpu_to_node(pr->id)); 484 485 out: 486 free_cpumask_var(pr->throttling.shared_cpu_map); 487 kfree(pr); 488 } 489 #endif /* CONFIG_ACPI_HOTPLUG_CPU */ 490 491 #ifdef CONFIG_X86 492 static bool acpi_hwp_native_thermal_lvt_set; 493 static acpi_status __init acpi_hwp_native_thermal_lvt_osc(acpi_handle handle, 494 u32 lvl, 495 void *context, 496 void **rv) 497 { 498 u8 sb_uuid_str[] = "4077A616-290C-47BE-9EBD-D87058713953"; 499 u32 capbuf[2]; 500 struct acpi_osc_context osc_context = { 501 .uuid_str = sb_uuid_str, 502 .rev = 1, 503 .cap.length = 8, 504 .cap.pointer = capbuf, 505 }; 506 507 if (acpi_hwp_native_thermal_lvt_set) 508 return AE_CTRL_TERMINATE; 509 510 capbuf[0] = 0x0000; 511 capbuf[1] = 0x1000; /* set bit 12 */ 512 513 if (ACPI_SUCCESS(acpi_run_osc(handle, &osc_context))) { 514 if (osc_context.ret.pointer && osc_context.ret.length > 1) { 515 u32 *capbuf_ret = osc_context.ret.pointer; 516 517 if (capbuf_ret[1] & 0x1000) { 518 acpi_handle_info(handle, 519 "_OSC native thermal LVT Acked\n"); 520 acpi_hwp_native_thermal_lvt_set = true; 521 } 522 } 523 kfree(osc_context.ret.pointer); 524 } 525 526 return AE_OK; 527 } 528 529 void __init acpi_early_processor_osc(void) 530 { 531 if (boot_cpu_has(X86_FEATURE_HWP)) { 532 acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, 533 ACPI_UINT32_MAX, 534 acpi_hwp_native_thermal_lvt_osc, 535 NULL, NULL, NULL); 536 acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, 537 acpi_hwp_native_thermal_lvt_osc, 538 NULL, NULL); 539 } 540 } 541 #endif 542 543 /* 544 * The following ACPI IDs are known to be suitable for representing as 545 * processor devices. 546 */ 547 static const struct acpi_device_id processor_device_ids[] = { 548 549 { ACPI_PROCESSOR_OBJECT_HID, }, 550 { ACPI_PROCESSOR_DEVICE_HID, }, 551 552 { } 553 }; 554 555 static struct acpi_scan_handler processor_handler = { 556 .ids = processor_device_ids, 557 .attach = acpi_processor_add, 558 #ifdef CONFIG_ACPI_HOTPLUG_CPU 559 .detach = acpi_processor_remove, 560 #endif 561 .hotplug = { 562 .enabled = true, 563 }, 564 }; 565 566 static int acpi_processor_container_attach(struct acpi_device *dev, 567 const struct acpi_device_id *id) 568 { 569 return 1; 570 } 571 572 static const struct acpi_device_id processor_container_ids[] = { 573 { ACPI_PROCESSOR_CONTAINER_HID, }, 574 { } 575 }; 576 577 static struct acpi_scan_handler processor_container_handler = { 578 .ids = processor_container_ids, 579 .attach = acpi_processor_container_attach, 580 }; 581 582 /* The number of the unique processor IDs */ 583 static int nr_unique_ids __initdata; 584 585 /* The number of the duplicate processor IDs */ 586 static int nr_duplicate_ids; 587 588 /* Used to store the unique processor IDs */ 589 static int unique_processor_ids[] __initdata = { 590 [0 ... NR_CPUS - 1] = -1, 591 }; 592 593 /* Used to store the duplicate processor IDs */ 594 static int duplicate_processor_ids[] = { 595 [0 ... NR_CPUS - 1] = -1, 596 }; 597 598 static void __init processor_validated_ids_update(int proc_id) 599 { 600 int i; 601 602 if (nr_unique_ids == NR_CPUS||nr_duplicate_ids == NR_CPUS) 603 return; 604 605 /* 606 * Firstly, compare the proc_id with duplicate IDs, if the proc_id is 607 * already in the IDs, do nothing. 608 */ 609 for (i = 0; i < nr_duplicate_ids; i++) { 610 if (duplicate_processor_ids[i] == proc_id) 611 return; 612 } 613 614 /* 615 * Secondly, compare the proc_id with unique IDs, if the proc_id is in 616 * the IDs, put it in the duplicate IDs. 617 */ 618 for (i = 0; i < nr_unique_ids; i++) { 619 if (unique_processor_ids[i] == proc_id) { 620 duplicate_processor_ids[nr_duplicate_ids] = proc_id; 621 nr_duplicate_ids++; 622 return; 623 } 624 } 625 626 /* 627 * Lastly, the proc_id is a unique ID, put it in the unique IDs. 628 */ 629 unique_processor_ids[nr_unique_ids] = proc_id; 630 nr_unique_ids++; 631 } 632 633 static acpi_status __init acpi_processor_ids_walk(acpi_handle handle, 634 u32 lvl, 635 void *context, 636 void **rv) 637 { 638 acpi_status status; 639 acpi_object_type acpi_type; 640 unsigned long long uid; 641 union acpi_object object = { 0 }; 642 struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; 643 644 status = acpi_get_type(handle, &acpi_type); 645 if (ACPI_FAILURE(status)) 646 return status; 647 648 switch (acpi_type) { 649 case ACPI_TYPE_PROCESSOR: 650 status = acpi_evaluate_object(handle, NULL, NULL, &buffer); 651 if (ACPI_FAILURE(status)) 652 goto err; 653 uid = object.processor.proc_id; 654 break; 655 656 case ACPI_TYPE_DEVICE: 657 status = acpi_evaluate_integer(handle, "_UID", NULL, &uid); 658 if (ACPI_FAILURE(status)) 659 goto err; 660 break; 661 default: 662 goto err; 663 } 664 665 processor_validated_ids_update(uid); 666 return AE_OK; 667 668 err: 669 /* Exit on error, but don't abort the namespace walk */ 670 acpi_handle_info(handle, "Invalid processor object\n"); 671 return AE_OK; 672 673 } 674 675 static void __init acpi_processor_check_duplicates(void) 676 { 677 /* check the correctness for all processors in ACPI namespace */ 678 acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, 679 ACPI_UINT32_MAX, 680 acpi_processor_ids_walk, 681 NULL, NULL, NULL); 682 acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, acpi_processor_ids_walk, 683 NULL, NULL); 684 } 685 686 bool acpi_duplicate_processor_id(int proc_id) 687 { 688 int i; 689 690 /* 691 * compare the proc_id with duplicate IDs, if the proc_id is already 692 * in the duplicate IDs, return true, otherwise, return false. 693 */ 694 for (i = 0; i < nr_duplicate_ids; i++) { 695 if (duplicate_processor_ids[i] == proc_id) 696 return true; 697 } 698 return false; 699 } 700 701 void __init acpi_processor_init(void) 702 { 703 acpi_processor_check_duplicates(); 704 acpi_scan_add_handler_with_hotplug(&processor_handler, "processor"); 705 acpi_scan_add_handler(&processor_container_handler); 706 } 707 708 #ifdef CONFIG_ACPI_PROCESSOR_CSTATE 709 /** 710 * acpi_processor_claim_cst_control - Request _CST control from the platform. 711 */ 712 bool acpi_processor_claim_cst_control(void) 713 { 714 static bool cst_control_claimed; 715 acpi_status status; 716 717 if (!acpi_gbl_FADT.cst_control || cst_control_claimed) 718 return true; 719 720 status = acpi_os_write_port(acpi_gbl_FADT.smi_command, 721 acpi_gbl_FADT.cst_control, 8); 722 if (ACPI_FAILURE(status)) { 723 pr_warn("ACPI: Failed to claim processor _CST control\n"); 724 return false; 725 } 726 727 cst_control_claimed = true; 728 return true; 729 } 730 EXPORT_SYMBOL_GPL(acpi_processor_claim_cst_control); 731 732 /** 733 * acpi_processor_evaluate_cst - Evaluate the processor _CST control method. 734 * @handle: ACPI handle of the processor object containing the _CST. 735 * @cpu: The numeric ID of the target CPU. 736 * @info: Object write the C-states information into. 737 * 738 * Extract the C-state information for the given CPU from the output of the _CST 739 * control method under the corresponding ACPI processor object (or processor 740 * device object) and populate @info with it. 741 * 742 * If any ACPI_ADR_SPACE_FIXED_HARDWARE C-states are found, invoke 743 * acpi_processor_ffh_cstate_probe() to verify them and update the 744 * cpu_cstate_entry data for @cpu. 745 */ 746 int acpi_processor_evaluate_cst(acpi_handle handle, u32 cpu, 747 struct acpi_processor_power *info) 748 { 749 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 750 union acpi_object *cst; 751 acpi_status status; 752 u64 count; 753 int last_index = 0; 754 int i, ret = 0; 755 756 status = acpi_evaluate_object(handle, "_CST", NULL, &buffer); 757 if (ACPI_FAILURE(status)) { 758 acpi_handle_debug(handle, "No _CST\n"); 759 return -ENODEV; 760 } 761 762 cst = buffer.pointer; 763 764 /* There must be at least 2 elements. */ 765 if (!cst || cst->type != ACPI_TYPE_PACKAGE || cst->package.count < 2) { 766 acpi_handle_warn(handle, "Invalid _CST output\n"); 767 ret = -EFAULT; 768 goto end; 769 } 770 771 count = cst->package.elements[0].integer.value; 772 773 /* Validate the number of C-states. */ 774 if (count < 1 || count != cst->package.count - 1) { 775 acpi_handle_warn(handle, "Inconsistent _CST data\n"); 776 ret = -EFAULT; 777 goto end; 778 } 779 780 for (i = 1; i <= count; i++) { 781 union acpi_object *element; 782 union acpi_object *obj; 783 struct acpi_power_register *reg; 784 struct acpi_processor_cx cx; 785 786 /* 787 * If there is not enough space for all C-states, skip the 788 * excess ones and log a warning. 789 */ 790 if (last_index >= ACPI_PROCESSOR_MAX_POWER - 1) { 791 acpi_handle_warn(handle, 792 "No room for more idle states (limit: %d)\n", 793 ACPI_PROCESSOR_MAX_POWER - 1); 794 break; 795 } 796 797 memset(&cx, 0, sizeof(cx)); 798 799 element = &cst->package.elements[i]; 800 if (element->type != ACPI_TYPE_PACKAGE) { 801 acpi_handle_info(handle, "_CST C%d type(%x) is not package, skip...\n", 802 i, element->type); 803 continue; 804 } 805 806 if (element->package.count != 4) { 807 acpi_handle_info(handle, "_CST C%d package count(%d) is not 4, skip...\n", 808 i, element->package.count); 809 continue; 810 } 811 812 obj = &element->package.elements[0]; 813 814 if (obj->type != ACPI_TYPE_BUFFER) { 815 acpi_handle_info(handle, "_CST C%d package element[0] type(%x) is not buffer, skip...\n", 816 i, obj->type); 817 continue; 818 } 819 820 reg = (struct acpi_power_register *)obj->buffer.pointer; 821 822 obj = &element->package.elements[1]; 823 if (obj->type != ACPI_TYPE_INTEGER) { 824 acpi_handle_info(handle, "_CST C[%d] package element[1] type(%x) is not integer, skip...\n", 825 i, obj->type); 826 continue; 827 } 828 829 cx.type = obj->integer.value; 830 /* 831 * There are known cases in which the _CST output does not 832 * contain C1, so if the type of the first state found is not 833 * C1, leave an empty slot for C1 to be filled in later. 834 */ 835 if (i == 1 && cx.type != ACPI_STATE_C1) 836 last_index = 1; 837 838 cx.address = reg->address; 839 cx.index = last_index + 1; 840 841 if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { 842 if (!acpi_processor_ffh_cstate_probe(cpu, &cx, reg)) { 843 /* 844 * In the majority of cases _CST describes C1 as 845 * a FIXED_HARDWARE C-state, but if the command 846 * line forbids using MWAIT, use CSTATE_HALT for 847 * C1 regardless. 848 */ 849 if (cx.type == ACPI_STATE_C1 && 850 boot_option_idle_override == IDLE_NOMWAIT) { 851 cx.entry_method = ACPI_CSTATE_HALT; 852 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 853 } else { 854 cx.entry_method = ACPI_CSTATE_FFH; 855 } 856 } else if (cx.type == ACPI_STATE_C1) { 857 /* 858 * In the special case of C1, FIXED_HARDWARE can 859 * be handled by executing the HLT instruction. 860 */ 861 cx.entry_method = ACPI_CSTATE_HALT; 862 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 863 } else { 864 acpi_handle_info(handle, "_CST C%d declares FIXED_HARDWARE C-state but not supported in hardware, skip...\n", 865 i); 866 continue; 867 } 868 } else if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO) { 869 cx.entry_method = ACPI_CSTATE_SYSTEMIO; 870 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x", 871 cx.address); 872 } else { 873 acpi_handle_info(handle, "_CST C%d space_id(%x) neither FIXED_HARDWARE nor SYSTEM_IO, skip...\n", 874 i, reg->space_id); 875 continue; 876 } 877 878 if (cx.type == ACPI_STATE_C1) 879 cx.valid = 1; 880 881 obj = &element->package.elements[2]; 882 if (obj->type != ACPI_TYPE_INTEGER) { 883 acpi_handle_info(handle, "_CST C%d package element[2] type(%x) not integer, skip...\n", 884 i, obj->type); 885 continue; 886 } 887 888 cx.latency = obj->integer.value; 889 890 obj = &element->package.elements[3]; 891 if (obj->type != ACPI_TYPE_INTEGER) { 892 acpi_handle_info(handle, "_CST C%d package element[3] type(%x) not integer, skip...\n", 893 i, obj->type); 894 continue; 895 } 896 897 memcpy(&info->states[++last_index], &cx, sizeof(cx)); 898 } 899 900 acpi_handle_info(handle, "Found %d idle states\n", last_index); 901 902 info->count = last_index; 903 904 end: 905 kfree(buffer.pointer); 906 907 return ret; 908 } 909 EXPORT_SYMBOL_GPL(acpi_processor_evaluate_cst); 910 #endif /* CONFIG_ACPI_PROCESSOR_CSTATE */ 911