drivers/cpuidle/cpuidle-arm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ARM/ARM64 generic CPU idle driver.
   4  *
   5  * Copyright (C) 2014 ARM Ltd.
   6  * Author: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
   7  */
   8
   9 #define pr_fmt(fmt) "CPUidle arm: " fmt
  10
  11 #include <linux/cpuidle.h>
  12 #include <linux/cpumask.h>
  13 #include <linux/cpu_pm.h>
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/of.h>
  17 #include <linux/slab.h>
  18 #include <linux/topology.h>
  19
  20 #include <asm/cpuidle.h>
  21
  22 #include "dt_idle_states.h"
  23
  24 /*
  25  * arm_enter_idle_state - Programs CPU to enter the specified state
  26  *
  27  * dev: cpuidle device
  28  * drv: cpuidle driver
  29  * idx: state index
  30  *
  31  * Called from the CPUidle framework to program the device to the
  32  * specified target state selected by the governor.
  33  */
  34 static int arm_enter_idle_state(struct cpuidle_device *dev,
  35                                 struct cpuidle_driver *drv, int idx)
  36 {
  37         /*
  38          * Pass idle state index to arm_cpuidle_suspend which in turn
  39          * will call the CPU ops suspend protocol with idle index as a
  40          * parameter.
  41          */
  42         return CPU_PM_CPU_IDLE_ENTER(arm_cpuidle_suspend, idx);
  43 }
  44
  45 static struct cpuidle_driver arm_idle_driver __initdata = {
  46         .name = "arm_idle",
  47         .owner = THIS_MODULE,
  48         /*
  49          * State at index 0 is standby wfi and considered standard
  50          * on all ARM platforms. If in some platforms simple wfi
  51          * can't be used as "state 0", DT bindings must be implemented
  52          * to work around this issue and allow installing a special
  53          * handler for idle state index 0.
  54          */
  55         .states[0] = {
  56                 .enter                  = arm_enter_idle_state,
  57                 .exit_latency           = 1,
  58                 .target_residency       = 1,
  59                 .power_usage            = UINT_MAX,
  60                 .name                   = "WFI",
  61                 .desc                   = "ARM WFI",
  62         }
  63 };
  64
  65 static const struct of_device_id arm_idle_state_match[] __initconst = {
  66         { .compatible = "arm,idle-state",
  67           .data = arm_enter_idle_state },
  68         { },
  69 };
  70
  71 /*
  72  * arm_idle_init_cpu
  73  *
  74  * Registers the arm specific cpuidle driver with the cpuidle
  75  * framework. It relies on core code to parse the idle states
  76  * and initialize them using driver data structures accordingly.
  77  */
  78 static int __init arm_idle_init_cpu(int cpu)
  79 {
  80         int ret;
  81         struct cpuidle_driver *drv;
  82
  83         drv = kmemdup(&arm_idle_driver, sizeof(*drv), GFP_KERNEL);
  84         if (!drv)
  85                 return -ENOMEM;
  86
  87         drv->cpumask = (struct cpumask *)cpumask_of(cpu);
  88
  89         /*
  90          * Initialize idle states data, starting at index 1.  This
  91          * driver is DT only, if no DT idle states are detected (ret
  92          * == 0) let the driver initialization fail accordingly since
  93          * there is no reason to initialize the idle driver if only
  94          * wfi is supported.
  95          */
  96         ret = dt_init_idle_driver(drv, arm_idle_state_match, 1);
  97         if (ret <= 0) {
  98                 ret = ret ? : -ENODEV;
  99                 goto out_kfree_drv;
 100         }
 101
 102         /*
 103          * Call arch CPU operations in order to initialize
 104          * idle states suspend back-end specific data
 105          */
 106         ret = arm_cpuidle_init(cpu);
 107
 108         /*
 109          * Allow the initialization to continue for other CPUs, if the reported
 110          * failure is a HW misconfiguration/breakage (-ENXIO).
 111          */
 112         if (ret) {
 113                 pr_err("CPU %d failed to init idle CPU ops\n", cpu);
 114                 ret = ret == -ENXIO ? 0 : ret;
 115                 goto out_kfree_drv;
 116         }
 117
 118         ret = cpuidle_register(drv, NULL);
 119         if (ret)
 120                 goto out_kfree_drv;
 121
 122         return 0;
 123
 124 out_kfree_drv:
 125         kfree(drv);
 126         return ret;
 127 }
 128
 129 /*
 130  * arm_idle_init - Initializes arm cpuidle driver
 131  *
 132  * Initializes arm cpuidle driver for all CPUs, if any CPU fails
 133  * to register cpuidle driver then rollback to cancel all CPUs
 134  * registeration.
 135  */
 136 static int __init arm_idle_init(void)
 137 {
 138         int cpu, ret;
 139         struct cpuidle_driver *drv;
 140         struct cpuidle_device *dev;
 141
 142         for_each_possible_cpu(cpu) {
 143                 ret = arm_idle_init_cpu(cpu);
 144                 if (ret)
 145                         goto out_fail;
 146         }
 147
 148         return 0;
 149
 150 out_fail:
 151         while (--cpu >= 0) {
 152                 dev = per_cpu(cpuidle_devices, cpu);
 153                 drv = cpuidle_get_cpu_driver(dev);
 154                 cpuidle_unregister(drv);
 155                 kfree(drv);
 156         }
 157
 158         return ret;
 159 }
 160 device_initcall(arm_idle_init);