1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * 4 * Copyright (C) 2015 ARM Limited 5 */ 6 7#define pr_fmt(fmt) "psci: " fmt 8 9#include <linux/acpi.h> 10#include <linux/arm-smccc.h> 11#include <linux/cpuidle.h> 12#include <linux/debugfs.h> 13#include <linux/errno.h> 14#include <linux/linkage.h> 15#include <linux/of.h> 16#include <linux/pm.h> 17#include <linux/printk.h> 18#include <linux/psci.h> 19#include <linux/reboot.h> 20#include <linux/slab.h> 21#include <linux/suspend.h> 22 23#include <uapi/linux/psci.h> 24 25#include <asm/cpuidle.h> 26#include <asm/cputype.h> 27#include <asm/hypervisor.h> 28#include <asm/system_misc.h> 29#include <asm/smp_plat.h> 30#include <asm/suspend.h> 31 32/* 33 * While a 64-bit OS can make calls with SMC32 calling conventions, for some 34 * calls it is necessary to use SMC64 to pass or return 64-bit values. 35 * For such calls PSCI_FN_NATIVE(version, name) will choose the appropriate 36 * (native-width) function ID. 37 */ 38#ifdef CONFIG_64BIT 39#define PSCI_FN_NATIVE(version, name) PSCI_##version##_FN64_##name 40#else 41#define PSCI_FN_NATIVE(version, name) PSCI_##version##_FN_##name 42#endif 43 44/* 45 * The CPU any Trusted OS is resident on. The trusted OS may reject CPU_OFF 46 * calls to its resident CPU, so we must avoid issuing those. We never migrate 47 * a Trusted OS even if it claims to be capable of migration -- doing so will 48 * require cooperation with a Trusted OS driver. 49 */ 50static int resident_cpu = -1; 51struct psci_operations psci_ops; 52static enum arm_smccc_conduit psci_conduit = SMCCC_CONDUIT_NONE; 53 54bool psci_tos_resident_on(int cpu) 55{ 56 return cpu == resident_cpu; 57} 58 59typedef unsigned long (psci_fn)(unsigned long, unsigned long, 60 unsigned long, unsigned long); 61static psci_fn *invoke_psci_fn; 62 63static struct psci_0_1_function_ids psci_0_1_function_ids; 64 65struct psci_0_1_function_ids get_psci_0_1_function_ids(void) 66{ 67 return psci_0_1_function_ids; 68} 69 70#define PSCI_0_2_POWER_STATE_MASK \ 71 (PSCI_0_2_POWER_STATE_ID_MASK | \ 72 PSCI_0_2_POWER_STATE_TYPE_MASK | \ 73 PSCI_0_2_POWER_STATE_AFFL_MASK) 74 75#define PSCI_1_0_EXT_POWER_STATE_MASK \ 76 (PSCI_1_0_EXT_POWER_STATE_ID_MASK | \ 77 PSCI_1_0_EXT_POWER_STATE_TYPE_MASK) 78 79static u32 psci_cpu_suspend_feature; 80static bool psci_system_reset2_supported; 81 82static inline bool psci_has_ext_power_state(void) 83{ 84 return psci_cpu_suspend_feature & 85 PSCI_1_0_FEATURES_CPU_SUSPEND_PF_MASK; 86} 87 88bool psci_has_osi_support(void) 89{ 90 return psci_cpu_suspend_feature & PSCI_1_0_OS_INITIATED; 91} 92 93static inline bool psci_power_state_loses_context(u32 state) 94{ 95 const u32 mask = psci_has_ext_power_state() ? 96 PSCI_1_0_EXT_POWER_STATE_TYPE_MASK : 97 PSCI_0_2_POWER_STATE_TYPE_MASK; 98 99 return state & mask; 100} 101 102bool psci_power_state_is_valid(u32 state) 103{ 104 const u32 valid_mask = psci_has_ext_power_state() ? 105 PSCI_1_0_EXT_POWER_STATE_MASK : 106 PSCI_0_2_POWER_STATE_MASK; 107 108 return !(state & ~valid_mask); 109} 110 111static __always_inline unsigned long 112__invoke_psci_fn_hvc(unsigned long function_id, 113 unsigned long arg0, unsigned long arg1, 114 unsigned long arg2) 115{ 116 struct arm_smccc_res res; 117 118 arm_smccc_hvc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res); 119 return res.a0; 120} 121 122static __always_inline unsigned long 123__invoke_psci_fn_smc(unsigned long function_id, 124 unsigned long arg0, unsigned long arg1, 125 unsigned long arg2) 126{ 127 struct arm_smccc_res res; 128 129 arm_smccc_smc(function_id, arg0, arg1, arg2, 0, 0, 0, 0, &res); 130 return res.a0; 131} 132 133static __always_inline int psci_to_linux_errno(int errno) 134{ 135 switch (errno) { 136 case PSCI_RET_SUCCESS: 137 return 0; 138 case PSCI_RET_NOT_SUPPORTED: 139 return -EOPNOTSUPP; 140 case PSCI_RET_INVALID_PARAMS: 141 case PSCI_RET_INVALID_ADDRESS: 142 return -EINVAL; 143 case PSCI_RET_DENIED: 144 return -EPERM; 145 } 146 147 return -EINVAL; 148} 149 150static u32 psci_0_1_get_version(void) 151{ 152 return PSCI_VERSION(0, 1); 153} 154 155static u32 psci_0_2_get_version(void) 156{ 157 return invoke_psci_fn(PSCI_0_2_FN_PSCI_VERSION, 0, 0, 0); 158} 159 160int psci_set_osi_mode(bool enable) 161{ 162 unsigned long suspend_mode; 163 int err; 164 165 suspend_mode = enable ? PSCI_1_0_SUSPEND_MODE_OSI : 166 PSCI_1_0_SUSPEND_MODE_PC; 167 168 err = invoke_psci_fn(PSCI_1_0_FN_SET_SUSPEND_MODE, suspend_mode, 0, 0); 169 if (err < 0) 170 pr_info(FW_BUG "failed to set %s mode: %d\n", 171 enable ? "OSI" : "PC", err); 172 return psci_to_linux_errno(err); 173} 174 175static __always_inline int 176__psci_cpu_suspend(u32 fn, u32 state, unsigned long entry_point) 177{ 178 int err; 179 180 err = invoke_psci_fn(fn, state, entry_point, 0); 181 return psci_to_linux_errno(err); 182} 183 184static __always_inline int 185psci_0_1_cpu_suspend(u32 state, unsigned long entry_point) 186{ 187 return __psci_cpu_suspend(psci_0_1_function_ids.cpu_suspend, 188 state, entry_point); 189} 190 191static __always_inline int 192psci_0_2_cpu_suspend(u32 state, unsigned long entry_point) 193{ 194 return __psci_cpu_suspend(PSCI_FN_NATIVE(0_2, CPU_SUSPEND), 195 state, entry_point); 196} 197 198static int __psci_cpu_off(u32 fn, u32 state) 199{ 200 int err; 201 202 err = invoke_psci_fn(fn, state, 0, 0); 203 return psci_to_linux_errno(err); 204} 205 206static int psci_0_1_cpu_off(u32 state) 207{ 208 return __psci_cpu_off(psci_0_1_function_ids.cpu_off, state); 209} 210 211static int psci_0_2_cpu_off(u32 state) 212{ 213 return __psci_cpu_off(PSCI_0_2_FN_CPU_OFF, state); 214} 215 216static int __psci_cpu_on(u32 fn, unsigned long cpuid, unsigned long entry_point) 217{ 218 int err; 219 220 err = invoke_psci_fn(fn, cpuid, entry_point, 0); 221 return psci_to_linux_errno(err); 222} 223 224static int psci_0_1_cpu_on(unsigned long cpuid, unsigned long entry_point) 225{ 226 return __psci_cpu_on(psci_0_1_function_ids.cpu_on, cpuid, entry_point); 227} 228 229static int psci_0_2_cpu_on(unsigned long cpuid, unsigned long entry_point) 230{ 231 return __psci_cpu_on(PSCI_FN_NATIVE(0_2, CPU_ON), cpuid, entry_point); 232} 233 234static int __psci_migrate(u32 fn, unsigned long cpuid) 235{ 236 int err; 237 238 err = invoke_psci_fn(fn, cpuid, 0, 0); 239 return psci_to_linux_errno(err); 240} 241 242static int psci_0_1_migrate(unsigned long cpuid) 243{ 244 return __psci_migrate(psci_0_1_function_ids.migrate, cpuid); 245} 246 247static int psci_0_2_migrate(unsigned long cpuid) 248{ 249 return __psci_migrate(PSCI_FN_NATIVE(0_2, MIGRATE), cpuid); 250} 251 252static int psci_affinity_info(unsigned long target_affinity, 253 unsigned long lowest_affinity_level) 254{ 255 return invoke_psci_fn(PSCI_FN_NATIVE(0_2, AFFINITY_INFO), 256 target_affinity, lowest_affinity_level, 0); 257} 258 259static int psci_migrate_info_type(void) 260{ 261 return invoke_psci_fn(PSCI_0_2_FN_MIGRATE_INFO_TYPE, 0, 0, 0); 262} 263 264static unsigned long psci_migrate_info_up_cpu(void) 265{ 266 return invoke_psci_fn(PSCI_FN_NATIVE(0_2, MIGRATE_INFO_UP_CPU), 267 0, 0, 0); 268} 269 270static void set_conduit(enum arm_smccc_conduit conduit) 271{ 272 switch (conduit) { 273 case SMCCC_CONDUIT_HVC: 274 invoke_psci_fn = __invoke_psci_fn_hvc; 275 break; 276 case SMCCC_CONDUIT_SMC: 277 invoke_psci_fn = __invoke_psci_fn_smc; 278 break; 279 default: 280 WARN(1, "Unexpected PSCI conduit %d\n", conduit); 281 } 282 283 psci_conduit = conduit; 284} 285 286static int get_set_conduit_method(const struct device_node *np) 287{ 288 const char *method; 289 290 pr_info("probing for conduit method from DT.\n"); 291 292 if (of_property_read_string(np, "method", &method)) { 293 pr_warn("missing \"method\" property\n"); 294 return -ENXIO; 295 } 296 297 if (!strcmp("hvc", method)) { 298 set_conduit(SMCCC_CONDUIT_HVC); 299 } else if (!strcmp("smc", method)) { 300 set_conduit(SMCCC_CONDUIT_SMC); 301 } else { 302 pr_warn("invalid \"method\" property: %s\n", method); 303 return -EINVAL; 304 } 305 return 0; 306} 307 308static int psci_sys_reset(struct notifier_block *nb, unsigned long action, 309 void *data) 310{ 311 if ((reboot_mode == REBOOT_WARM || reboot_mode == REBOOT_SOFT) && 312 psci_system_reset2_supported) { 313 /* 314 * reset_type[31] = 0 (architectural) 315 * reset_type[30:0] = 0 (SYSTEM_WARM_RESET) 316 * cookie = 0 (ignored by the implementation) 317 */ 318 invoke_psci_fn(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2), 0, 0, 0); 319 } else { 320 invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET, 0, 0, 0); 321 } 322 323 return NOTIFY_DONE; 324} 325 326static struct notifier_block psci_sys_reset_nb = { 327 .notifier_call = psci_sys_reset, 328 .priority = 129, 329}; 330 331static void psci_sys_poweroff(void) 332{ 333 invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0); 334} 335 336static int psci_features(u32 psci_func_id) 337{ 338 return invoke_psci_fn(PSCI_1_0_FN_PSCI_FEATURES, 339 psci_func_id, 0, 0); 340} 341 342#ifdef CONFIG_DEBUG_FS 343 344#define PSCI_ID(ver, _name) \ 345 { .fn = PSCI_##ver##_FN_##_name, .name = #_name, } 346#define PSCI_ID_NATIVE(ver, _name) \ 347 { .fn = PSCI_FN_NATIVE(ver, _name), .name = #_name, } 348 349/* A table of all optional functions */ 350static const struct { 351 u32 fn; 352 const char *name; 353} psci_fn_ids[] = { 354 PSCI_ID_NATIVE(0_2, MIGRATE), 355 PSCI_ID(0_2, MIGRATE_INFO_TYPE), 356 PSCI_ID_NATIVE(0_2, MIGRATE_INFO_UP_CPU), 357 PSCI_ID(1_0, CPU_FREEZE), 358 PSCI_ID_NATIVE(1_0, CPU_DEFAULT_SUSPEND), 359 PSCI_ID_NATIVE(1_0, NODE_HW_STATE), 360 PSCI_ID_NATIVE(1_0, SYSTEM_SUSPEND), 361 PSCI_ID(1_0, SET_SUSPEND_MODE), 362 PSCI_ID_NATIVE(1_0, STAT_RESIDENCY), 363 PSCI_ID_NATIVE(1_0, STAT_COUNT), 364 PSCI_ID_NATIVE(1_1, SYSTEM_RESET2), 365 PSCI_ID(1_1, MEM_PROTECT), 366 PSCI_ID_NATIVE(1_1, MEM_PROTECT_CHECK_RANGE), 367}; 368 369static int psci_debugfs_read(struct seq_file *s, void *data) 370{ 371 int feature, type, i; 372 u32 ver; 373 374 ver = psci_ops.get_version(); 375 seq_printf(s, "PSCIv%d.%d\n", 376 PSCI_VERSION_MAJOR(ver), 377 PSCI_VERSION_MINOR(ver)); 378 379 /* PSCI_FEATURES is available only starting from 1.0 */ 380 if (PSCI_VERSION_MAJOR(ver) < 1) 381 return 0; 382 383 feature = psci_features(ARM_SMCCC_VERSION_FUNC_ID); 384 if (feature != PSCI_RET_NOT_SUPPORTED) { 385 ver = invoke_psci_fn(ARM_SMCCC_VERSION_FUNC_ID, 0, 0, 0); 386 seq_printf(s, "SMC Calling Convention v%d.%d\n", 387 PSCI_VERSION_MAJOR(ver), 388 PSCI_VERSION_MINOR(ver)); 389 } else { 390 seq_puts(s, "SMC Calling Convention v1.0 is assumed\n"); 391 } 392 393 feature = psci_features(PSCI_FN_NATIVE(0_2, CPU_SUSPEND)); 394 if (feature < 0) { 395 seq_printf(s, "PSCI_FEATURES(CPU_SUSPEND) error (%d)\n", feature); 396 } else { 397 seq_printf(s, "OSI is %ssupported\n", 398 (feature & BIT(0)) ? "" : "not "); 399 seq_printf(s, "%s StateID format is used\n", 400 (feature & BIT(1)) ? "Extended" : "Original"); 401 } 402 403 type = psci_ops.migrate_info_type(); 404 if (type == PSCI_0_2_TOS_UP_MIGRATE || 405 type == PSCI_0_2_TOS_UP_NO_MIGRATE) { 406 unsigned long cpuid; 407 408 seq_printf(s, "Trusted OS %smigrate capable\n", 409 type == PSCI_0_2_TOS_UP_NO_MIGRATE ? "not " : ""); 410 cpuid = psci_migrate_info_up_cpu(); 411 seq_printf(s, "Trusted OS resident on physical CPU 0x%lx (#%d)\n", 412 cpuid, resident_cpu); 413 } else if (type == PSCI_0_2_TOS_MP) { 414 seq_puts(s, "Trusted OS migration not required\n"); 415 } else { 416 if (type != PSCI_RET_NOT_SUPPORTED) 417 seq_printf(s, "MIGRATE_INFO_TYPE returned unknown type (%d)\n", type); 418 } 419 420 for (i = 0; i < ARRAY_SIZE(psci_fn_ids); i++) { 421 feature = psci_features(psci_fn_ids[i].fn); 422 if (feature == PSCI_RET_NOT_SUPPORTED) 423 continue; 424 if (feature < 0) 425 seq_printf(s, "PSCI_FEATURES(%s) error (%d)\n", 426 psci_fn_ids[i].name, feature); 427 else 428 seq_printf(s, "%s is supported\n", psci_fn_ids[i].name); 429 } 430 431 return 0; 432} 433 434static int psci_debugfs_open(struct inode *inode, struct file *f) 435{ 436 return single_open(f, psci_debugfs_read, NULL); 437} 438 439static const struct file_operations psci_debugfs_ops = { 440 .owner = THIS_MODULE, 441 .open = psci_debugfs_open, 442 .release = single_release, 443 .read = seq_read, 444 .llseek = seq_lseek 445}; 446 447static int __init psci_debugfs_init(void) 448{ 449 if (!invoke_psci_fn || !psci_ops.get_version) 450 return 0; 451 452 return PTR_ERR_OR_ZERO(debugfs_create_file("psci", 0444, NULL, NULL, 453 &psci_debugfs_ops)); 454} 455late_initcall(psci_debugfs_init) 456#endif 457 458#ifdef CONFIG_CPU_IDLE 459static noinstr int psci_suspend_finisher(unsigned long state) 460{ 461 u32 power_state = state; 462 phys_addr_t pa_cpu_resume; 463 464 pa_cpu_resume = __pa_symbol_nodebug((unsigned long)cpu_resume); 465 466 return psci_ops.cpu_suspend(power_state, pa_cpu_resume); 467} 468 469int psci_cpu_suspend_enter(u32 state) 470{ 471 int ret; 472 473 if (!psci_power_state_loses_context(state)) { 474 struct arm_cpuidle_irq_context context; 475 476 ct_cpuidle_enter(); 477 arm_cpuidle_save_irq_context(&context); 478 ret = psci_ops.cpu_suspend(state, 0); 479 arm_cpuidle_restore_irq_context(&context); 480 ct_cpuidle_exit(); 481 } else { 482 /* 483 * ARM64 cpu_suspend() wants to do ct_cpuidle_*() itself. 484 */ 485 if (!IS_ENABLED(CONFIG_ARM64)) 486 ct_cpuidle_enter(); 487 488 ret = cpu_suspend(state, psci_suspend_finisher); 489 490 if (!IS_ENABLED(CONFIG_ARM64)) 491 ct_cpuidle_exit(); 492 } 493 494 return ret; 495} 496#endif 497 498static int psci_system_suspend(unsigned long unused) 499{ 500 phys_addr_t pa_cpu_resume = __pa_symbol(cpu_resume); 501 502 return invoke_psci_fn(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND), 503 pa_cpu_resume, 0, 0); 504} 505 506static int psci_system_suspend_enter(suspend_state_t state) 507{ 508 return cpu_suspend(0, psci_system_suspend); 509} 510 511static const struct platform_suspend_ops psci_suspend_ops = { 512 .valid = suspend_valid_only_mem, 513 .enter = psci_system_suspend_enter, 514}; 515 516static void __init psci_init_system_reset2(void) 517{ 518 int ret; 519 520 ret = psci_features(PSCI_FN_NATIVE(1_1, SYSTEM_RESET2)); 521 522 if (ret != PSCI_RET_NOT_SUPPORTED) 523 psci_system_reset2_supported = true; 524} 525 526static void __init psci_init_system_suspend(void) 527{ 528 int ret; 529 530 if (!IS_ENABLED(CONFIG_SUSPEND)) 531 return; 532 533 ret = psci_features(PSCI_FN_NATIVE(1_0, SYSTEM_SUSPEND)); 534 535 if (ret != PSCI_RET_NOT_SUPPORTED) 536 suspend_set_ops(&psci_suspend_ops); 537} 538 539static void __init psci_init_cpu_suspend(void) 540{ 541 int feature = psci_features(PSCI_FN_NATIVE(0_2, CPU_SUSPEND)); 542 543 if (feature != PSCI_RET_NOT_SUPPORTED) 544 psci_cpu_suspend_feature = feature; 545} 546 547/* 548 * Detect the presence of a resident Trusted OS which may cause CPU_OFF to 549 * return DENIED (which would be fatal). 550 */ 551static void __init psci_init_migrate(void) 552{ 553 unsigned long cpuid; 554 int type, cpu = -1; 555 556 type = psci_ops.migrate_info_type(); 557 558 if (type == PSCI_0_2_TOS_MP) { 559 pr_info("Trusted OS migration not required\n"); 560 return; 561 } 562 563 if (type == PSCI_RET_NOT_SUPPORTED) { 564 pr_info("MIGRATE_INFO_TYPE not supported.\n"); 565 return; 566 } 567 568 if (type != PSCI_0_2_TOS_UP_MIGRATE && 569 type != PSCI_0_2_TOS_UP_NO_MIGRATE) { 570 pr_err("MIGRATE_INFO_TYPE returned unknown type (%d)\n", type); 571 return; 572 } 573 574 cpuid = psci_migrate_info_up_cpu(); 575 if (cpuid & ~MPIDR_HWID_BITMASK) { 576 pr_warn("MIGRATE_INFO_UP_CPU reported invalid physical ID (0x%lx)\n", 577 cpuid); 578 return; 579 } 580 581 cpu = get_logical_index(cpuid); 582 resident_cpu = cpu >= 0 ? cpu : -1; 583 584 pr_info("Trusted OS resident on physical CPU 0x%lx\n", cpuid); 585} 586 587static void __init psci_init_smccc(void) 588{ 589 u32 ver = ARM_SMCCC_VERSION_1_0; 590 int feature; 591 592 feature = psci_features(ARM_SMCCC_VERSION_FUNC_ID); 593 594 if (feature != PSCI_RET_NOT_SUPPORTED) { 595 u32 ret; 596 ret = invoke_psci_fn(ARM_SMCCC_VERSION_FUNC_ID, 0, 0, 0); 597 if (ret >= ARM_SMCCC_VERSION_1_1) { 598 arm_smccc_version_init(ret, psci_conduit); 599 ver = ret; 600 } 601 } 602 603 /* 604 * Conveniently, the SMCCC and PSCI versions are encoded the 605 * same way. No, this isn't accidental. 606 */ 607 pr_info("SMC Calling Convention v%d.%d\n", 608 PSCI_VERSION_MAJOR(ver), PSCI_VERSION_MINOR(ver)); 609 610} 611 612static void __init psci_0_2_set_functions(void) 613{ 614 pr_info("Using standard PSCI v0.2 function IDs\n"); 615 616 psci_ops = (struct psci_operations){ 617 .get_version = psci_0_2_get_version, 618 .cpu_suspend = psci_0_2_cpu_suspend, 619 .cpu_off = psci_0_2_cpu_off, 620 .cpu_on = psci_0_2_cpu_on, 621 .migrate = psci_0_2_migrate, 622 .affinity_info = psci_affinity_info, 623 .migrate_info_type = psci_migrate_info_type, 624 }; 625 626 register_restart_handler(&psci_sys_reset_nb); 627 628 pm_power_off = psci_sys_poweroff; 629} 630 631/* 632 * Probe function for PSCI firmware versions >= 0.2 633 */ 634static int __init psci_probe(void) 635{ 636 u32 ver = psci_0_2_get_version(); 637 638 pr_info("PSCIv%d.%d detected in firmware.\n", 639 PSCI_VERSION_MAJOR(ver), 640 PSCI_VERSION_MINOR(ver)); 641 642 if (PSCI_VERSION_MAJOR(ver) == 0 && PSCI_VERSION_MINOR(ver) < 2) { 643 pr_err("Conflicting PSCI version detected.\n"); 644 return -EINVAL; 645 } 646 647 psci_0_2_set_functions(); 648 649 psci_init_migrate(); 650 651 if (PSCI_VERSION_MAJOR(ver) >= 1) { 652 psci_init_smccc(); 653 psci_init_cpu_suspend(); 654 psci_init_system_suspend(); 655 psci_init_system_reset2(); 656 kvm_init_hyp_services(); 657 } 658 659 return 0; 660} 661 662typedef int (*psci_initcall_t)(const struct device_node *); 663 664/* 665 * PSCI init function for PSCI versions >=0.2 666 * 667 * Probe based on PSCI PSCI_VERSION function 668 */ 669static int __init psci_0_2_init(const struct device_node *np) 670{ 671 int err; 672 673 err = get_set_conduit_method(np); 674 if (err) 675 return err; 676 677 /* 678 * Starting with v0.2, the PSCI specification introduced a call 679 * (PSCI_VERSION) that allows probing the firmware version, so 680 * that PSCI function IDs and version specific initialization 681 * can be carried out according to the specific version reported 682 * by firmware 683 */ 684 return psci_probe(); 685} 686 687/* 688 * PSCI < v0.2 get PSCI Function IDs via DT. 689 */ 690static int __init psci_0_1_init(const struct device_node *np) 691{ 692 u32 id; 693 int err; 694 695 err = get_set_conduit_method(np); 696 if (err) 697 return err; 698 699 pr_info("Using PSCI v0.1 Function IDs from DT\n"); 700 701 psci_ops.get_version = psci_0_1_get_version; 702 703 if (!of_property_read_u32(np, "cpu_suspend", &id)) { 704 psci_0_1_function_ids.cpu_suspend = id; 705 psci_ops.cpu_suspend = psci_0_1_cpu_suspend; 706 } 707 708 if (!of_property_read_u32(np, "cpu_off", &id)) { 709 psci_0_1_function_ids.cpu_off = id; 710 psci_ops.cpu_off = psci_0_1_cpu_off; 711 } 712 713 if (!of_property_read_u32(np, "cpu_on", &id)) { 714 psci_0_1_function_ids.cpu_on = id; 715 psci_ops.cpu_on = psci_0_1_cpu_on; 716 } 717 718 if (!of_property_read_u32(np, "migrate", &id)) { 719 psci_0_1_function_ids.migrate = id; 720 psci_ops.migrate = psci_0_1_migrate; 721 } 722 723 return 0; 724} 725 726static int __init psci_1_0_init(const struct device_node *np) 727{ 728 int err; 729 730 err = psci_0_2_init(np); 731 if (err) 732 return err; 733 734 if (psci_has_osi_support()) { 735 pr_info("OSI mode supported.\n"); 736 737 /* Default to PC mode. */ 738 psci_set_osi_mode(false); 739 } 740 741 return 0; 742} 743 744static const struct of_device_id psci_of_match[] __initconst = { 745 { .compatible = "arm,psci", .data = psci_0_1_init}, 746 { .compatible = "arm,psci-0.2", .data = psci_0_2_init}, 747 { .compatible = "arm,psci-1.0", .data = psci_1_0_init}, 748 {}, 749}; 750 751int __init psci_dt_init(void) 752{ 753 struct device_node *np; 754 const struct of_device_id *matched_np; 755 psci_initcall_t init_fn; 756 int ret; 757 758 np = of_find_matching_node_and_match(NULL, psci_of_match, &matched_np); 759 760 if (!np || !of_device_is_available(np)) 761 return -ENODEV; 762 763 init_fn = (psci_initcall_t)matched_np->data; 764 ret = init_fn(np); 765 766 of_node_put(np); 767 return ret; 768} 769 770#ifdef CONFIG_ACPI 771/* 772 * We use PSCI 0.2+ when ACPI is deployed on ARM64 and it's 773 * explicitly clarified in SBBR 774 */ 775int __init psci_acpi_init(void) 776{ 777 if (!acpi_psci_present()) { 778 pr_info("is not implemented in ACPI.\n"); 779 return -EOPNOTSUPP; 780 } 781 782 pr_info("probing for conduit method from ACPI.\n"); 783 784 if (acpi_psci_use_hvc()) 785 set_conduit(SMCCC_CONDUIT_HVC); 786 else 787 set_conduit(SMCCC_CONDUIT_SMC); 788 789 return psci_probe(); 790} 791#endif 792