arch/arm64/kernel/psci.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License version 2 as
   4  * published by the Free Software Foundation.
   5  *
   6  * This program is distributed in the hope that it will be useful,
   7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9  * GNU General Public License for more details.
  10  *
  11  * Copyright (C) 2013 ARM Limited
  12  *
  13  * Author: Will Deacon <will.deacon@arm.com>
  14  */
  15
  16 #define pr_fmt(fmt) "psci: " fmt
  17
  18 #include <linux/acpi.h>
  19 #include <linux/init.h>
  20 #include <linux/of.h>
  21 #include <linux/smp.h>
  22 #include <linux/reboot.h>
  23 #include <linux/pm.h>
  24 #include <linux/delay.h>
  25 #include <linux/slab.h>
  26 #include <uapi/linux/psci.h>
  27
  28 #include <asm/acpi.h>
  29 #include <asm/compiler.h>
  30 #include <asm/cpu_ops.h>
  31 #include <asm/errno.h>
  32 #include <asm/psci.h>
  33 #include <asm/smp_plat.h>
  34 #include <asm/suspend.h>
  35 #include <asm/system_misc.h>
  36
  37 #define PSCI_POWER_STATE_TYPE_STANDBY           0
  38 #define PSCI_POWER_STATE_TYPE_POWER_DOWN        1
  39
  40 struct psci_power_state {
  41         u16     id;
  42         u8      type;
  43         u8      affinity_level;
  44 };
  45
  46 struct psci_operations {
  47         int (*cpu_suspend)(struct psci_power_state state,
  48                            unsigned long entry_point);
  49         int (*cpu_off)(struct psci_power_state state);
  50         int (*cpu_on)(unsigned long cpuid, unsigned long entry_point);
  51         int (*migrate)(unsigned long cpuid);
  52         int (*affinity_info)(unsigned long target_affinity,
  53                         unsigned long lowest_affinity_level);
  54         int (*migrate_info_type)(void);
  55 };
  56
  57 static struct psci_operations psci_ops;
  58
  59 static int (*invoke_psci_fn)(u64, u64, u64, u64);
  60 typedef int (*psci_initcall_t)(const struct device_node *);
  61
  62 asmlinkage int __invoke_psci_fn_hvc(u64, u64, u64, u64);
  63 asmlinkage int __invoke_psci_fn_smc(u64, u64, u64, u64);
  64
  65 enum psci_function {
  66         PSCI_FN_CPU_SUSPEND,
  67         PSCI_FN_CPU_ON,
  68         PSCI_FN_CPU_OFF,
  69         PSCI_FN_MIGRATE,
  70         PSCI_FN_AFFINITY_INFO,
  71         PSCI_FN_MIGRATE_INFO_TYPE,
  72         PSCI_FN_MAX,
  73 };
  74
  75 static DEFINE_PER_CPU_READ_MOSTLY(struct psci_power_state *, psci_power_state);
  76
  77 static u32 psci_function_id[PSCI_FN_MAX];
  78
  79 static int psci_to_linux_errno(int errno)
  80 {
  81         switch (errno) {
  82         case PSCI_RET_SUCCESS:
  83                 return 0;
  84         case PSCI_RET_NOT_SUPPORTED:
  85                 return -EOPNOTSUPP;
  86         case PSCI_RET_INVALID_PARAMS:
  87                 return -EINVAL;
  88         case PSCI_RET_DENIED:
  89                 return -EPERM;
  90         };
  91
  92         return -EINVAL;
  93 }
  94
  95 static u32 psci_power_state_pack(struct psci_power_state state)
  96 {
  97         return ((state.id << PSCI_0_2_POWER_STATE_ID_SHIFT)
  98                         & PSCI_0_2_POWER_STATE_ID_MASK) |
  99                 ((state.type << PSCI_0_2_POWER_STATE_TYPE_SHIFT)
 100                  & PSCI_0_2_POWER_STATE_TYPE_MASK) |
 101                 ((state.affinity_level << PSCI_0_2_POWER_STATE_AFFL_SHIFT)
 102                  & PSCI_0_2_POWER_STATE_AFFL_MASK);
 103 }
 104
 105 static void psci_power_state_unpack(u32 power_state,
 106                                     struct psci_power_state *state)
 107 {
 108         state->id = (power_state & PSCI_0_2_POWER_STATE_ID_MASK) >>
 109                         PSCI_0_2_POWER_STATE_ID_SHIFT;
 110         state->type = (power_state & PSCI_0_2_POWER_STATE_TYPE_MASK) >>
 111                         PSCI_0_2_POWER_STATE_TYPE_SHIFT;
 112         state->affinity_level =
 113                         (power_state & PSCI_0_2_POWER_STATE_AFFL_MASK) >>
 114                         PSCI_0_2_POWER_STATE_AFFL_SHIFT;
 115 }
 116
 117 static int psci_get_version(void)
 118 {
 119         int err;
 120
 121         err = invoke_psci_fn(PSCI_0_2_FN_PSCI_VERSION, 0, 0, 0);
 122         return err;
 123 }
 124
 125 static int psci_cpu_suspend(struct psci_power_state state,
 126                             unsigned long entry_point)
 127 {
 128         int err;
 129         u32 fn, power_state;
 130
 131         fn = psci_function_id[PSCI_FN_CPU_SUSPEND];
 132         power_state = psci_power_state_pack(state);
 133         err = invoke_psci_fn(fn, power_state, entry_point, 0);
 134         return psci_to_linux_errno(err);
 135 }
 136
 137 static int psci_cpu_off(struct psci_power_state state)
 138 {
 139         int err;
 140         u32 fn, power_state;
 141
 142         fn = psci_function_id[PSCI_FN_CPU_OFF];
 143         power_state = psci_power_state_pack(state);
 144         err = invoke_psci_fn(fn, power_state, 0, 0);
 145         return psci_to_linux_errno(err);
 146 }
 147
 148 static int psci_cpu_on(unsigned long cpuid, unsigned long entry_point)
 149 {
 150         int err;
 151         u32 fn;
 152
 153         fn = psci_function_id[PSCI_FN_CPU_ON];
 154         err = invoke_psci_fn(fn, cpuid, entry_point, 0);
 155         return psci_to_linux_errno(err);
 156 }
 157
 158 static int psci_migrate(unsigned long cpuid)
 159 {
 160         int err;
 161         u32 fn;
 162
 163         fn = psci_function_id[PSCI_FN_MIGRATE];
 164         err = invoke_psci_fn(fn, cpuid, 0, 0);
 165         return psci_to_linux_errno(err);
 166 }
 167
 168 static int psci_affinity_info(unsigned long target_affinity,
 169                 unsigned long lowest_affinity_level)
 170 {
 171         int err;
 172         u32 fn;
 173
 174         fn = psci_function_id[PSCI_FN_AFFINITY_INFO];
 175         err = invoke_psci_fn(fn, target_affinity, lowest_affinity_level, 0);
 176         return err;
 177 }
 178
 179 static int psci_migrate_info_type(void)
 180 {
 181         int err;
 182         u32 fn;
 183
 184         fn = psci_function_id[PSCI_FN_MIGRATE_INFO_TYPE];
 185         err = invoke_psci_fn(fn, 0, 0, 0);
 186         return err;
 187 }
 188
 189 static int __maybe_unused cpu_psci_cpu_init_idle(unsigned int cpu)
 190 {
 191         int i, ret, count = 0;
 192         struct psci_power_state *psci_states;
 193         struct device_node *state_node, *cpu_node;
 194
 195         cpu_node = of_get_cpu_node(cpu, NULL);
 196         if (!cpu_node)
 197                 return -ENODEV;
 198
 199         /*
 200          * If the PSCI cpu_suspend function hook has not been initialized
 201          * idle states must not be enabled, so bail out
 202          */
 203         if (!psci_ops.cpu_suspend)
 204                 return -EOPNOTSUPP;
 205
 206         /* Count idle states */
 207         while ((state_node = of_parse_phandle(cpu_node, "cpu-idle-states",
 208                                               count))) {
 209                 count++;
 210                 of_node_put(state_node);
 211         }
 212
 213         if (!count)
 214                 return -ENODEV;
 215
 216         psci_states = kcalloc(count, sizeof(*psci_states), GFP_KERNEL);
 217         if (!psci_states)
 218                 return -ENOMEM;
 219
 220         for (i = 0; i < count; i++) {
 221                 u32 psci_power_state;
 222
 223                 state_node = of_parse_phandle(cpu_node, "cpu-idle-states", i);
 224
 225                 ret = of_property_read_u32(state_node,
 226                                            "arm,psci-suspend-param",
 227                                            &psci_power_state);
 228                 if (ret) {
 229                         pr_warn(" * %s missing arm,psci-suspend-param property\n",
 230                                 state_node->full_name);
 231                         of_node_put(state_node);
 232                         goto free_mem;
 233                 }
 234
 235                 of_node_put(state_node);
 236                 pr_debug("psci-power-state %#x index %d\n", psci_power_state,
 237                                                             i);
 238                 psci_power_state_unpack(psci_power_state, &psci_states[i]);
 239         }
 240         /* Idle states parsed correctly, initialize per-cpu pointer */
 241         per_cpu(psci_power_state, cpu) = psci_states;
 242         return 0;
 243
 244 free_mem:
 245         kfree(psci_states);
 246         return ret;
 247 }
 248
 249 static int get_set_conduit_method(struct device_node *np)
 250 {
 251         const char *method;
 252
 253         pr_info("probing for conduit method from DT.\n");
 254
 255         if (of_property_read_string(np, "method", &method)) {
 256                 pr_warn("missing \"method\" property\n");
 257                 return -ENXIO;
 258         }
 259
 260         if (!strcmp("hvc", method)) {
 261                 invoke_psci_fn = __invoke_psci_fn_hvc;
 262         } else if (!strcmp("smc", method)) {
 263                 invoke_psci_fn = __invoke_psci_fn_smc;
 264         } else {
 265                 pr_warn("invalid \"method\" property: %s\n", method);
 266                 return -EINVAL;
 267         }
 268         return 0;
 269 }
 270
 271 static void psci_sys_reset(enum reboot_mode reboot_mode, const char *cmd)
 272 {
 273         invoke_psci_fn(PSCI_0_2_FN_SYSTEM_RESET, 0, 0, 0);
 274 }
 275
 276 static void psci_sys_poweroff(void)
 277 {
 278         invoke_psci_fn(PSCI_0_2_FN_SYSTEM_OFF, 0, 0, 0);
 279 }
 280
 281 static void __init psci_0_2_set_functions(void)
 282 {
 283         pr_info("Using standard PSCI v0.2 function IDs\n");
 284         psci_function_id[PSCI_FN_CPU_SUSPEND] = PSCI_0_2_FN64_CPU_SUSPEND;
 285         psci_ops.cpu_suspend = psci_cpu_suspend;
 286
 287         psci_function_id[PSCI_FN_CPU_OFF] = PSCI_0_2_FN_CPU_OFF;
 288         psci_ops.cpu_off = psci_cpu_off;
 289
 290         psci_function_id[PSCI_FN_CPU_ON] = PSCI_0_2_FN64_CPU_ON;
 291         psci_ops.cpu_on = psci_cpu_on;
 292
 293         psci_function_id[PSCI_FN_MIGRATE] = PSCI_0_2_FN64_MIGRATE;
 294         psci_ops.migrate = psci_migrate;
 295
 296         psci_function_id[PSCI_FN_AFFINITY_INFO] = PSCI_0_2_FN64_AFFINITY_INFO;
 297         psci_ops.affinity_info = psci_affinity_info;
 298
 299         psci_function_id[PSCI_FN_MIGRATE_INFO_TYPE] =
 300                 PSCI_0_2_FN_MIGRATE_INFO_TYPE;
 301         psci_ops.migrate_info_type = psci_migrate_info_type;
 302
 303         arm_pm_restart = psci_sys_reset;
 304
 305         pm_power_off = psci_sys_poweroff;
 306 }
 307
 308 /*
 309  * Probe function for PSCI firmware versions >= 0.2
 310  */
 311 static int __init psci_probe(void)
 312 {
 313         int ver = psci_get_version();
 314
 315         if (ver == PSCI_RET_NOT_SUPPORTED) {
 316                 /*
 317                  * PSCI versions >=0.2 mandates implementation of
 318                  * PSCI_VERSION.
 319                  */
 320                 pr_err("PSCI firmware does not comply with the v0.2 spec.\n");
 321                 return -EOPNOTSUPP;
 322         } else {
 323                 pr_info("PSCIv%d.%d detected in firmware.\n",
 324                                 PSCI_VERSION_MAJOR(ver),
 325                                 PSCI_VERSION_MINOR(ver));
 326
 327                 if (PSCI_VERSION_MAJOR(ver) == 0 &&
 328                                 PSCI_VERSION_MINOR(ver) < 2) {
 329                         pr_err("Conflicting PSCI version detected.\n");
 330                         return -EINVAL;
 331                 }
 332         }
 333
 334         psci_0_2_set_functions();
 335
 336         return 0;
 337 }
 338
 339 /*
 340  * PSCI init function for PSCI versions >=0.2
 341  *
 342  * Probe based on PSCI PSCI_VERSION function
 343  */
 344 static int __init psci_0_2_init(struct device_node *np)
 345 {
 346         int err;
 347
 348         err = get_set_conduit_method(np);
 349
 350         if (err)
 351                 goto out_put_node;
 352         /*
 353          * Starting with v0.2, the PSCI specification introduced a call
 354          * (PSCI_VERSION) that allows probing the firmware version, so
 355          * that PSCI function IDs and version specific initialization
 356          * can be carried out according to the specific version reported
 357          * by firmware
 358          */
 359         err = psci_probe();
 360
 361 out_put_node:
 362         of_node_put(np);
 363         return err;
 364 }
 365
 366 /*
 367  * PSCI < v0.2 get PSCI Function IDs via DT.
 368  */
 369 static int __init psci_0_1_init(struct device_node *np)
 370 {
 371         u32 id;
 372         int err;
 373
 374         err = get_set_conduit_method(np);
 375
 376         if (err)
 377                 goto out_put_node;
 378
 379         pr_info("Using PSCI v0.1 Function IDs from DT\n");
 380
 381         if (!of_property_read_u32(np, "cpu_suspend", &id)) {
 382                 psci_function_id[PSCI_FN_CPU_SUSPEND] = id;
 383                 psci_ops.cpu_suspend = psci_cpu_suspend;
 384         }
 385
 386         if (!of_property_read_u32(np, "cpu_off", &id)) {
 387                 psci_function_id[PSCI_FN_CPU_OFF] = id;
 388                 psci_ops.cpu_off = psci_cpu_off;
 389         }
 390
 391         if (!of_property_read_u32(np, "cpu_on", &id)) {
 392                 psci_function_id[PSCI_FN_CPU_ON] = id;
 393                 psci_ops.cpu_on = psci_cpu_on;
 394         }
 395
 396         if (!of_property_read_u32(np, "migrate", &id)) {
 397                 psci_function_id[PSCI_FN_MIGRATE] = id;
 398                 psci_ops.migrate = psci_migrate;
 399         }
 400
 401 out_put_node:
 402         of_node_put(np);
 403         return err;
 404 }
 405
 406 static const struct of_device_id psci_of_match[] __initconst = {
 407         { .compatible = "arm,psci",     .data = psci_0_1_init},
 408         { .compatible = "arm,psci-0.2", .data = psci_0_2_init},
 409         {},
 410 };
 411
 412 int __init psci_dt_init(void)
 413 {
 414         struct device_node *np;
 415         const struct of_device_id *matched_np;
 416         psci_initcall_t init_fn;
 417
 418         np = of_find_matching_node_and_match(NULL, psci_of_match, &matched_np);
 419
 420         if (!np)
 421                 return -ENODEV;
 422
 423         init_fn = (psci_initcall_t)matched_np->data;
 424         return init_fn(np);
 425 }
 426
 427 /*
 428  * We use PSCI 0.2+ when ACPI is deployed on ARM64 and it's
 429  * explicitly clarified in SBBR
 430  */
 431 int __init psci_acpi_init(void)
 432 {
 433         if (!acpi_psci_present()) {
 434                 pr_info("is not implemented in ACPI.\n");
 435                 return -EOPNOTSUPP;
 436         }
 437
 438         pr_info("probing for conduit method from ACPI.\n");
 439
 440         if (acpi_psci_use_hvc())
 441                 invoke_psci_fn = __invoke_psci_fn_hvc;
 442         else
 443                 invoke_psci_fn = __invoke_psci_fn_smc;
 444
 445         return psci_probe();
 446 }
 447
 448 #ifdef CONFIG_SMP
 449
 450 static int __init cpu_psci_cpu_init(unsigned int cpu)
 451 {
 452         return 0;
 453 }
 454
 455 static int __init cpu_psci_cpu_prepare(unsigned int cpu)
 456 {
 457         if (!psci_ops.cpu_on) {
 458                 pr_err("no cpu_on method, not booting CPU%d\n", cpu);
 459                 return -ENODEV;
 460         }
 461
 462         return 0;
 463 }
 464
 465 static int cpu_psci_cpu_boot(unsigned int cpu)
 466 {
 467         int err = psci_ops.cpu_on(cpu_logical_map(cpu), __pa(secondary_entry));
 468         if (err)
 469                 pr_err("failed to boot CPU%d (%d)\n", cpu, err);
 470
 471         return err;
 472 }
 473
 474 #ifdef CONFIG_HOTPLUG_CPU
 475 static int cpu_psci_cpu_disable(unsigned int cpu)
 476 {
 477         /* Fail early if we don't have CPU_OFF support */
 478         if (!psci_ops.cpu_off)
 479                 return -EOPNOTSUPP;
 480         return 0;
 481 }
 482
 483 static void cpu_psci_cpu_die(unsigned int cpu)
 484 {
 485         int ret;
 486         /*
 487          * There are no known implementations of PSCI actually using the
 488          * power state field, pass a sensible default for now.
 489          */
 490         struct psci_power_state state = {
 491                 .type = PSCI_POWER_STATE_TYPE_POWER_DOWN,
 492         };
 493
 494         ret = psci_ops.cpu_off(state);
 495
 496         pr_crit("unable to power off CPU%u (%d)\n", cpu, ret);
 497 }
 498
 499 static int cpu_psci_cpu_kill(unsigned int cpu)
 500 {
 501         int err, i;
 502
 503         if (!psci_ops.affinity_info)
 504                 return 1;
 505         /*
 506          * cpu_kill could race with cpu_die and we can
 507          * potentially end up declaring this cpu undead
 508          * while it is dying. So, try again a few times.
 509          */
 510
 511         for (i = 0; i < 10; i++) {
 512                 err = psci_ops.affinity_info(cpu_logical_map(cpu), 0);
 513                 if (err == PSCI_0_2_AFFINITY_LEVEL_OFF) {
 514                         pr_info("CPU%d killed.\n", cpu);
 515                         return 1;
 516                 }
 517
 518                 msleep(10);
 519                 pr_info("Retrying again to check for CPU kill\n");
 520         }
 521
 522         pr_warn("CPU%d may not have shut down cleanly (AFFINITY_INFO reports %d)\n",
 523                         cpu, err);
 524         /* Make op_cpu_kill() fail. */
 525         return 0;
 526 }
 527 #endif
 528 #endif
 529
 530 static int psci_suspend_finisher(unsigned long index)
 531 {
 532         struct psci_power_state *state = __this_cpu_read(psci_power_state);
 533
 534         return psci_ops.cpu_suspend(state[index - 1],
 535                                     virt_to_phys(cpu_resume));
 536 }
 537
 538 static int __maybe_unused cpu_psci_cpu_suspend(unsigned long index)
 539 {
 540         int ret;
 541         struct psci_power_state *state = __this_cpu_read(psci_power_state);
 542         /*
 543          * idle state index 0 corresponds to wfi, should never be called
 544          * from the cpu_suspend operations
 545          */
 546         if (WARN_ON_ONCE(!index))
 547                 return -EINVAL;
 548
 549         if (state[index - 1].type == PSCI_POWER_STATE_TYPE_STANDBY)
 550                 ret = psci_ops.cpu_suspend(state[index - 1], 0);
 551         else
 552                 ret = __cpu_suspend(index, psci_suspend_finisher);
 553
 554         return ret;
 555 }
 556
 557 const struct cpu_operations cpu_psci_ops = {
 558         .name           = "psci",
 559 #ifdef CONFIG_CPU_IDLE
 560         .cpu_init_idle  = cpu_psci_cpu_init_idle,
 561         .cpu_suspend    = cpu_psci_cpu_suspend,
 562 #endif
 563 #ifdef CONFIG_SMP
 564         .cpu_init       = cpu_psci_cpu_init,
 565         .cpu_prepare    = cpu_psci_cpu_prepare,
 566         .cpu_boot       = cpu_psci_cpu_boot,
 567 #ifdef CONFIG_HOTPLUG_CPU
 568         .cpu_disable    = cpu_psci_cpu_disable,
 569         .cpu_die        = cpu_psci_cpu_die,
 570         .cpu_kill       = cpu_psci_cpu_kill,
 571 #endif
 572 #endif
 573 };
 574