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 * Note that we don't handle string _UIDs yet. 268 */ 269 status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID, 270 NULL, &value); 271 if (ACPI_FAILURE(status)) { 272 dev_err(&device->dev, 273 "Failed to evaluate processor _UID (0x%x)\n", 274 status); 275 return -ENODEV; 276 } 277 device_declaration = 1; 278 pr->acpi_id = value; 279 } 280 281 if (acpi_duplicate_processor_id(pr->acpi_id)) { 282 if (pr->acpi_id == 0xff) 283 dev_info_once(&device->dev, 284 "Entry not well-defined, consider updating BIOS\n"); 285 else 286 dev_err(&device->dev, 287 "Failed to get unique processor _UID (0x%x)\n", 288 pr->acpi_id); 289 return -ENODEV; 290 } 291 292 pr->phys_id = acpi_get_phys_id(pr->handle, device_declaration, 293 pr->acpi_id); 294 if (invalid_phys_cpuid(pr->phys_id)) 295 acpi_handle_debug(pr->handle, "failed to get CPU physical ID.\n"); 296 297 pr->id = acpi_map_cpuid(pr->phys_id, pr->acpi_id); 298 if (!cpu0_initialized && !acpi_has_cpu_in_madt()) { 299 cpu0_initialized = 1; 300 /* 301 * Handle UP system running SMP kernel, with no CPU 302 * entry in MADT 303 */ 304 if (invalid_logical_cpuid(pr->id) && (num_online_cpus() == 1)) 305 pr->id = 0; 306 } 307 308 /* 309 * Extra Processor objects may be enumerated on MP systems with 310 * less than the max # of CPUs. They should be ignored _iff 311 * they are physically not present. 312 * 313 * NOTE: Even if the processor has a cpuid, it may not be present 314 * because cpuid <-> apicid mapping is persistent now. 315 */ 316 if (invalid_logical_cpuid(pr->id) || !cpu_present(pr->id)) { 317 int ret = acpi_processor_hotadd_init(pr); 318 if (ret) 319 return ret; 320 } 321 322 /* 323 * On some boxes several processors use the same processor bus id. 324 * But they are located in different scope. For example: 325 * \_SB.SCK0.CPU0 326 * \_SB.SCK1.CPU0 327 * Rename the processor device bus id. And the new bus id will be 328 * generated as the following format: 329 * CPU+CPU ID. 330 */ 331 sprintf(acpi_device_bid(device), "CPU%X", pr->id); 332 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id, 333 pr->acpi_id)); 334 335 if (!object.processor.pblk_address) 336 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n")); 337 else if (object.processor.pblk_length != 6) 338 dev_err(&device->dev, "Invalid PBLK length [%d]\n", 339 object.processor.pblk_length); 340 else { 341 pr->throttling.address = object.processor.pblk_address; 342 pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset; 343 pr->throttling.duty_width = acpi_gbl_FADT.duty_width; 344 345 pr->pblk = object.processor.pblk_address; 346 } 347 348 /* 349 * If ACPI describes a slot number for this CPU, we can use it to 350 * ensure we get the right value in the "physical id" field 351 * of /proc/cpuinfo 352 */ 353 status = acpi_evaluate_integer(pr->handle, "_SUN", NULL, &value); 354 if (ACPI_SUCCESS(status)) 355 arch_fix_phys_package_id(pr->id, value); 356 357 return 0; 358 } 359 360 /* 361 * Do not put anything in here which needs the core to be online. 362 * For example MSR access or setting up things which check for cpuinfo_x86 363 * (cpu_data(cpu)) values, like CPU feature flags, family, model, etc. 364 * Such things have to be put in and set up by the processor driver's .probe(). 365 */ 366 static DEFINE_PER_CPU(void *, processor_device_array); 367 368 static int acpi_processor_add(struct acpi_device *device, 369 const struct acpi_device_id *id) 370 { 371 struct acpi_processor *pr; 372 struct device *dev; 373 int result = 0; 374 375 pr = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL); 376 if (!pr) 377 return -ENOMEM; 378 379 if (!zalloc_cpumask_var(&pr->throttling.shared_cpu_map, GFP_KERNEL)) { 380 result = -ENOMEM; 381 goto err_free_pr; 382 } 383 384 pr->handle = device->handle; 385 strcpy(acpi_device_name(device), ACPI_PROCESSOR_DEVICE_NAME); 386 strcpy(acpi_device_class(device), ACPI_PROCESSOR_CLASS); 387 device->driver_data = pr; 388 389 result = acpi_processor_get_info(device); 390 if (result) /* Processor is not physically present or unavailable */ 391 return 0; 392 393 BUG_ON(pr->id >= nr_cpu_ids); 394 395 /* 396 * Buggy BIOS check. 397 * ACPI id of processors can be reported wrongly by the BIOS. 398 * Don't trust it blindly 399 */ 400 if (per_cpu(processor_device_array, pr->id) != NULL && 401 per_cpu(processor_device_array, pr->id) != device) { 402 dev_warn(&device->dev, 403 "BIOS reported wrong ACPI id %d for the processor\n", 404 pr->id); 405 /* Give up, but do not abort the namespace scan. */ 406 goto err; 407 } 408 /* 409 * processor_device_array is not cleared on errors to allow buggy BIOS 410 * checks. 411 */ 412 per_cpu(processor_device_array, pr->id) = device; 413 per_cpu(processors, pr->id) = pr; 414 415 dev = get_cpu_device(pr->id); 416 if (!dev) { 417 result = -ENODEV; 418 goto err; 419 } 420 421 result = acpi_bind_one(dev, device); 422 if (result) 423 goto err; 424 425 pr->dev = dev; 426 427 /* Trigger the processor driver's .probe() if present. */ 428 if (device_attach(dev) >= 0) 429 return 1; 430 431 dev_err(dev, "Processor driver could not be attached\n"); 432 acpi_unbind_one(dev); 433 434 err: 435 free_cpumask_var(pr->throttling.shared_cpu_map); 436 device->driver_data = NULL; 437 per_cpu(processors, pr->id) = NULL; 438 err_free_pr: 439 kfree(pr); 440 return result; 441 } 442 443 #ifdef CONFIG_ACPI_HOTPLUG_CPU 444 /* -------------------------------------------------------------------------- 445 Removal 446 -------------------------------------------------------------------------- */ 447 448 static void acpi_processor_remove(struct acpi_device *device) 449 { 450 struct acpi_processor *pr; 451 452 if (!device || !acpi_driver_data(device)) 453 return; 454 455 pr = acpi_driver_data(device); 456 if (pr->id >= nr_cpu_ids) 457 goto out; 458 459 /* 460 * The only reason why we ever get here is CPU hot-removal. The CPU is 461 * already offline and the ACPI device removal locking prevents it from 462 * being put back online at this point. 463 * 464 * Unbind the driver from the processor device and detach it from the 465 * ACPI companion object. 466 */ 467 device_release_driver(pr->dev); 468 acpi_unbind_one(pr->dev); 469 470 /* Clean up. */ 471 per_cpu(processor_device_array, pr->id) = NULL; 472 per_cpu(processors, pr->id) = NULL; 473 474 cpu_maps_update_begin(); 475 cpu_hotplug_begin(); 476 477 /* Remove the CPU. */ 478 arch_unregister_cpu(pr->id); 479 acpi_unmap_cpu(pr->id); 480 481 cpu_hotplug_done(); 482 cpu_maps_update_done(); 483 484 try_offline_node(cpu_to_node(pr->id)); 485 486 out: 487 free_cpumask_var(pr->throttling.shared_cpu_map); 488 kfree(pr); 489 } 490 #endif /* CONFIG_ACPI_HOTPLUG_CPU */ 491 492 #ifdef CONFIG_X86 493 static bool acpi_hwp_native_thermal_lvt_set; 494 static acpi_status __init acpi_hwp_native_thermal_lvt_osc(acpi_handle handle, 495 u32 lvl, 496 void *context, 497 void **rv) 498 { 499 u8 sb_uuid_str[] = "4077A616-290C-47BE-9EBD-D87058713953"; 500 u32 capbuf[2]; 501 struct acpi_osc_context osc_context = { 502 .uuid_str = sb_uuid_str, 503 .rev = 1, 504 .cap.length = 8, 505 .cap.pointer = capbuf, 506 }; 507 508 if (acpi_hwp_native_thermal_lvt_set) 509 return AE_CTRL_TERMINATE; 510 511 capbuf[0] = 0x0000; 512 capbuf[1] = 0x1000; /* set bit 12 */ 513 514 if (ACPI_SUCCESS(acpi_run_osc(handle, &osc_context))) { 515 if (osc_context.ret.pointer && osc_context.ret.length > 1) { 516 u32 *capbuf_ret = osc_context.ret.pointer; 517 518 if (capbuf_ret[1] & 0x1000) { 519 acpi_handle_info(handle, 520 "_OSC native thermal LVT Acked\n"); 521 acpi_hwp_native_thermal_lvt_set = true; 522 } 523 } 524 kfree(osc_context.ret.pointer); 525 } 526 527 return AE_OK; 528 } 529 530 void __init acpi_early_processor_osc(void) 531 { 532 if (boot_cpu_has(X86_FEATURE_HWP)) { 533 acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, 534 ACPI_UINT32_MAX, 535 acpi_hwp_native_thermal_lvt_osc, 536 NULL, NULL, NULL); 537 acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, 538 acpi_hwp_native_thermal_lvt_osc, 539 NULL, NULL); 540 } 541 } 542 #endif 543 544 /* 545 * The following ACPI IDs are known to be suitable for representing as 546 * processor devices. 547 */ 548 static const struct acpi_device_id processor_device_ids[] = { 549 550 { ACPI_PROCESSOR_OBJECT_HID, }, 551 { ACPI_PROCESSOR_DEVICE_HID, }, 552 553 { } 554 }; 555 556 static struct acpi_scan_handler processor_handler = { 557 .ids = processor_device_ids, 558 .attach = acpi_processor_add, 559 #ifdef CONFIG_ACPI_HOTPLUG_CPU 560 .detach = acpi_processor_remove, 561 #endif 562 .hotplug = { 563 .enabled = true, 564 }, 565 }; 566 567 static int acpi_processor_container_attach(struct acpi_device *dev, 568 const struct acpi_device_id *id) 569 { 570 return 1; 571 } 572 573 static const struct acpi_device_id processor_container_ids[] = { 574 { ACPI_PROCESSOR_CONTAINER_HID, }, 575 { } 576 }; 577 578 static struct acpi_scan_handler processor_container_handler = { 579 .ids = processor_container_ids, 580 .attach = acpi_processor_container_attach, 581 }; 582 583 /* The number of the unique processor IDs */ 584 static int nr_unique_ids __initdata; 585 586 /* The number of the duplicate processor IDs */ 587 static int nr_duplicate_ids; 588 589 /* Used to store the unique processor IDs */ 590 static int unique_processor_ids[] __initdata = { 591 [0 ... NR_CPUS - 1] = -1, 592 }; 593 594 /* Used to store the duplicate processor IDs */ 595 static int duplicate_processor_ids[] = { 596 [0 ... NR_CPUS - 1] = -1, 597 }; 598 599 static void __init processor_validated_ids_update(int proc_id) 600 { 601 int i; 602 603 if (nr_unique_ids == NR_CPUS||nr_duplicate_ids == NR_CPUS) 604 return; 605 606 /* 607 * Firstly, compare the proc_id with duplicate IDs, if the proc_id is 608 * already in the IDs, do nothing. 609 */ 610 for (i = 0; i < nr_duplicate_ids; i++) { 611 if (duplicate_processor_ids[i] == proc_id) 612 return; 613 } 614 615 /* 616 * Secondly, compare the proc_id with unique IDs, if the proc_id is in 617 * the IDs, put it in the duplicate IDs. 618 */ 619 for (i = 0; i < nr_unique_ids; i++) { 620 if (unique_processor_ids[i] == proc_id) { 621 duplicate_processor_ids[nr_duplicate_ids] = proc_id; 622 nr_duplicate_ids++; 623 return; 624 } 625 } 626 627 /* 628 * Lastly, the proc_id is a unique ID, put it in the unique IDs. 629 */ 630 unique_processor_ids[nr_unique_ids] = proc_id; 631 nr_unique_ids++; 632 } 633 634 static acpi_status __init acpi_processor_ids_walk(acpi_handle handle, 635 u32 lvl, 636 void *context, 637 void **rv) 638 { 639 acpi_status status; 640 acpi_object_type acpi_type; 641 unsigned long long uid; 642 union acpi_object object = { 0 }; 643 struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; 644 645 status = acpi_get_type(handle, &acpi_type); 646 if (ACPI_FAILURE(status)) 647 return status; 648 649 switch (acpi_type) { 650 case ACPI_TYPE_PROCESSOR: 651 status = acpi_evaluate_object(handle, NULL, NULL, &buffer); 652 if (ACPI_FAILURE(status)) 653 goto err; 654 uid = object.processor.proc_id; 655 break; 656 657 case ACPI_TYPE_DEVICE: 658 status = acpi_evaluate_integer(handle, "_UID", NULL, &uid); 659 if (ACPI_FAILURE(status)) 660 goto err; 661 break; 662 default: 663 goto err; 664 } 665 666 processor_validated_ids_update(uid); 667 return AE_OK; 668 669 err: 670 /* Exit on error, but don't abort the namespace walk */ 671 acpi_handle_info(handle, "Invalid processor object\n"); 672 return AE_OK; 673 674 } 675 676 static void __init acpi_processor_check_duplicates(void) 677 { 678 /* check the correctness for all processors in ACPI namespace */ 679 acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT, 680 ACPI_UINT32_MAX, 681 acpi_processor_ids_walk, 682 NULL, NULL, NULL); 683 acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID, acpi_processor_ids_walk, 684 NULL, NULL); 685 } 686 687 bool acpi_duplicate_processor_id(int proc_id) 688 { 689 int i; 690 691 /* 692 * compare the proc_id with duplicate IDs, if the proc_id is already 693 * in the duplicate IDs, return true, otherwise, return false. 694 */ 695 for (i = 0; i < nr_duplicate_ids; i++) { 696 if (duplicate_processor_ids[i] == proc_id) 697 return true; 698 } 699 return false; 700 } 701 702 void __init acpi_processor_init(void) 703 { 704 acpi_processor_check_duplicates(); 705 acpi_scan_add_handler_with_hotplug(&processor_handler, "processor"); 706 acpi_scan_add_handler(&processor_container_handler); 707 } 708 709 #ifdef CONFIG_ACPI_PROCESSOR_CSTATE 710 /** 711 * acpi_processor_claim_cst_control - Request _CST control from the platform. 712 */ 713 bool acpi_processor_claim_cst_control(void) 714 { 715 static bool cst_control_claimed; 716 acpi_status status; 717 718 if (!acpi_gbl_FADT.cst_control || cst_control_claimed) 719 return true; 720 721 status = acpi_os_write_port(acpi_gbl_FADT.smi_command, 722 acpi_gbl_FADT.cst_control, 8); 723 if (ACPI_FAILURE(status)) { 724 pr_warn("ACPI: Failed to claim processor _CST control\n"); 725 return false; 726 } 727 728 cst_control_claimed = true; 729 return true; 730 } 731 EXPORT_SYMBOL_GPL(acpi_processor_claim_cst_control); 732 733 /** 734 * acpi_processor_evaluate_cst - Evaluate the processor _CST control method. 735 * @handle: ACPI handle of the processor object containing the _CST. 736 * @cpu: The numeric ID of the target CPU. 737 * @info: Object write the C-states information into. 738 * 739 * Extract the C-state information for the given CPU from the output of the _CST 740 * control method under the corresponding ACPI processor object (or processor 741 * device object) and populate @info with it. 742 * 743 * If any ACPI_ADR_SPACE_FIXED_HARDWARE C-states are found, invoke 744 * acpi_processor_ffh_cstate_probe() to verify them and update the 745 * cpu_cstate_entry data for @cpu. 746 */ 747 int acpi_processor_evaluate_cst(acpi_handle handle, u32 cpu, 748 struct acpi_processor_power *info) 749 { 750 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 751 union acpi_object *cst; 752 acpi_status status; 753 u64 count; 754 int last_index = 0; 755 int i, ret = 0; 756 757 status = acpi_evaluate_object(handle, "_CST", NULL, &buffer); 758 if (ACPI_FAILURE(status)) { 759 acpi_handle_debug(handle, "No _CST\n"); 760 return -ENODEV; 761 } 762 763 cst = buffer.pointer; 764 765 /* There must be at least 2 elements. */ 766 if (!cst || cst->type != ACPI_TYPE_PACKAGE || cst->package.count < 2) { 767 acpi_handle_warn(handle, "Invalid _CST output\n"); 768 ret = -EFAULT; 769 goto end; 770 } 771 772 count = cst->package.elements[0].integer.value; 773 774 /* Validate the number of C-states. */ 775 if (count < 1 || count != cst->package.count - 1) { 776 acpi_handle_warn(handle, "Inconsistent _CST data\n"); 777 ret = -EFAULT; 778 goto end; 779 } 780 781 for (i = 1; i <= count; i++) { 782 union acpi_object *element; 783 union acpi_object *obj; 784 struct acpi_power_register *reg; 785 struct acpi_processor_cx cx; 786 787 /* 788 * If there is not enough space for all C-states, skip the 789 * excess ones and log a warning. 790 */ 791 if (last_index >= ACPI_PROCESSOR_MAX_POWER - 1) { 792 acpi_handle_warn(handle, 793 "No room for more idle states (limit: %d)\n", 794 ACPI_PROCESSOR_MAX_POWER - 1); 795 break; 796 } 797 798 memset(&cx, 0, sizeof(cx)); 799 800 element = &cst->package.elements[i]; 801 if (element->type != ACPI_TYPE_PACKAGE) 802 continue; 803 804 if (element->package.count != 4) 805 continue; 806 807 obj = &element->package.elements[0]; 808 809 if (obj->type != ACPI_TYPE_BUFFER) 810 continue; 811 812 reg = (struct acpi_power_register *)obj->buffer.pointer; 813 814 obj = &element->package.elements[1]; 815 if (obj->type != ACPI_TYPE_INTEGER) 816 continue; 817 818 cx.type = obj->integer.value; 819 /* 820 * There are known cases in which the _CST output does not 821 * contain C1, so if the type of the first state found is not 822 * C1, leave an empty slot for C1 to be filled in later. 823 */ 824 if (i == 1 && cx.type != ACPI_STATE_C1) 825 last_index = 1; 826 827 cx.address = reg->address; 828 cx.index = last_index + 1; 829 830 if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { 831 if (!acpi_processor_ffh_cstate_probe(cpu, &cx, reg)) { 832 /* 833 * In the majority of cases _CST describes C1 as 834 * a FIXED_HARDWARE C-state, but if the command 835 * line forbids using MWAIT, use CSTATE_HALT for 836 * C1 regardless. 837 */ 838 if (cx.type == ACPI_STATE_C1 && 839 boot_option_idle_override == IDLE_NOMWAIT) { 840 cx.entry_method = ACPI_CSTATE_HALT; 841 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 842 } else { 843 cx.entry_method = ACPI_CSTATE_FFH; 844 } 845 } else if (cx.type == ACPI_STATE_C1) { 846 /* 847 * In the special case of C1, FIXED_HARDWARE can 848 * be handled by executing the HLT instruction. 849 */ 850 cx.entry_method = ACPI_CSTATE_HALT; 851 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 852 } else { 853 continue; 854 } 855 } else if (reg->space_id == ACPI_ADR_SPACE_SYSTEM_IO) { 856 cx.entry_method = ACPI_CSTATE_SYSTEMIO; 857 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x", 858 cx.address); 859 } else { 860 continue; 861 } 862 863 if (cx.type == ACPI_STATE_C1) 864 cx.valid = 1; 865 866 obj = &element->package.elements[2]; 867 if (obj->type != ACPI_TYPE_INTEGER) 868 continue; 869 870 cx.latency = obj->integer.value; 871 872 obj = &element->package.elements[3]; 873 if (obj->type != ACPI_TYPE_INTEGER) 874 continue; 875 876 memcpy(&info->states[++last_index], &cx, sizeof(cx)); 877 } 878 879 acpi_handle_info(handle, "Found %d idle states\n", last_index); 880 881 info->count = last_index; 882 883 end: 884 kfree(buffer.pointer); 885 886 return ret; 887 } 888 EXPORT_SYMBOL_GPL(acpi_processor_evaluate_cst); 889 #endif /* CONFIG_ACPI_PROCESSOR_CSTATE */ 890