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 27ACPI_MODULE_NAME("processor"); 28 29DEFINE_PER_CPU(struct acpi_processor *, processors); 30EXPORT_PER_CPU_SYMBOL(processors); 31 32/* -------------------------------------------------------------------------- 33 Errata Handling 34 -------------------------------------------------------------------------- */ 35 36struct acpi_processor_errata errata __read_mostly; 37EXPORT_SYMBOL_GPL(errata); 38 39static 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 141static 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 165int __weak acpi_map_cpu(acpi_handle handle, 166 phys_cpuid_t physid, u32 acpi_id, int *pcpu) 167{ 168 return -ENODEV; 169} 170 171int __weak acpi_unmap_cpu(int cpu) 172{ 173 return -ENODEV; 174} 175 176int __weak arch_register_cpu(int cpu) 177{ 178 return -ENODEV; 179} 180 181void __weak arch_unregister_cpu(int cpu) {} 182 183static 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 217out: 218 cpu_hotplug_done(); 219 cpu_maps_update_done(); 220 return ret; 221} 222#else 223static inline int acpi_processor_hotadd_init(struct acpi_processor *pr) 224{ 225 return -ENODEV; 226} 227#endif /* CONFIG_ACPI_HOTPLUG_CPU */ 228 229static 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 */ 365static DEFINE_PER_CPU(void *, processor_device_array); 366 367static 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 447static 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 492static bool acpi_hwp_native_thermal_lvt_set; 493static 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 529void __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 */ 547static const struct acpi_device_id processor_device_ids[] = { 548 549 { ACPI_PROCESSOR_OBJECT_HID, }, 550 { ACPI_PROCESSOR_DEVICE_HID, }, 551 552 { } 553}; 554 555static 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 566static int acpi_processor_container_attach(struct acpi_device *dev, 567 const struct acpi_device_id *id) 568{ 569 return 1; 570} 571 572static const struct acpi_device_id processor_container_ids[] = { 573 { ACPI_PROCESSOR_CONTAINER_HID, }, 574 { } 575}; 576 577static 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 */ 583static int nr_unique_ids __initdata; 584 585/* The number of the duplicate processor IDs */ 586static int nr_duplicate_ids; 587 588/* Used to store the unique processor IDs */ 589static int unique_processor_ids[] __initdata = { 590 [0 ... NR_CPUS - 1] = -1, 591}; 592 593/* Used to store the duplicate processor IDs */ 594static int duplicate_processor_ids[] = { 595 [0 ... NR_CPUS - 1] = -1, 596}; 597 598static 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 633static 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 668err: 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 675static 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 686bool 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 701void __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 */ 712bool 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} 730EXPORT_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 */ 746int 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} 909EXPORT_SYMBOL_GPL(acpi_processor_evaluate_cst); 910#endif /* CONFIG_ACPI_PROCESSOR_CSTATE */ 911