linux/drivers/thermal/cpuidle_cooling.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 *  Copyright (C) 2019 Linaro Limited.
   4 *
   5 *  Author: Daniel Lezcano <daniel.lezcano@linaro.org>
   6 *
   7 */
   8#define pr_fmt(fmt) "cpuidle cooling: " fmt
   9
  10#include <linux/cpu_cooling.h>
  11#include <linux/cpuidle.h>
  12#include <linux/device.h>
  13#include <linux/err.h>
  14#include <linux/idle_inject.h>
  15#include <linux/of_device.h>
  16#include <linux/slab.h>
  17#include <linux/thermal.h>
  18
  19/**
  20 * struct cpuidle_cooling_device - data for the idle cooling device
  21 * @ii_dev: an atomic to keep track of the last task exiting the idle cycle
  22 * @state: a normalized integer giving the state of the cooling device
  23 */
  24struct cpuidle_cooling_device {
  25        struct idle_inject_device *ii_dev;
  26        unsigned long state;
  27};
  28
  29/**
  30 * cpuidle_cooling_runtime - Running time computation
  31 * @idle_duration_us: CPU idle time to inject in microseconds
  32 * @state: a percentile based number
  33 *
  34 * The running duration is computed from the idle injection duration
  35 * which is fixed. If we reach 100% of idle injection ratio, that
  36 * means the running duration is zero. If we have a 50% ratio
  37 * injection, that means we have equal duration for idle and for
  38 * running duration.
  39 *
  40 * The formula is deduced as follows:
  41 *
  42 *  running = idle x ((100 / ratio) - 1)
  43 *
  44 * For precision purpose for integer math, we use the following:
  45 *
  46 *  running = (idle x 100) / ratio - idle
  47 *
  48 * For example, if we have an injected duration of 50%, then we end up
  49 * with 10ms of idle injection and 10ms of running duration.
  50 *
  51 * Return: An unsigned int for a usec based runtime duration.
  52 */
  53static unsigned int cpuidle_cooling_runtime(unsigned int idle_duration_us,
  54                                            unsigned long state)
  55{
  56        if (!state)
  57                return 0;
  58
  59        return ((idle_duration_us * 100) / state) - idle_duration_us;
  60}
  61
  62/**
  63 * cpuidle_cooling_get_max_state - Get the maximum state
  64 * @cdev  : the thermal cooling device
  65 * @state : a pointer to the state variable to be filled
  66 *
  67 * The function always returns 100 as the injection ratio. It is
  68 * percentile based for consistency accross different platforms.
  69 *
  70 * Return: The function can not fail, it is always zero
  71 */
  72static int cpuidle_cooling_get_max_state(struct thermal_cooling_device *cdev,
  73                                         unsigned long *state)
  74{
  75        /*
  76         * Depending on the configuration or the hardware, the running
  77         * cycle and the idle cycle could be different. We want to
  78         * unify that to an 0..100 interval, so the set state
  79         * interface will be the same whatever the platform is.
  80         *
  81         * The state 100% will make the cluster 100% ... idle. A 0%
  82         * injection ratio means no idle injection at all and 50%
  83         * means for 10ms of idle injection, we have 10ms of running
  84         * time.
  85         */
  86        *state = 100;
  87
  88        return 0;
  89}
  90
  91/**
  92 * cpuidle_cooling_get_cur_state - Get the current cooling state
  93 * @cdev: the thermal cooling device
  94 * @state: a pointer to the state
  95 *
  96 * The function just copies  the state value from the private thermal
  97 * cooling device structure, the mapping is 1 <-> 1.
  98 *
  99 * Return: The function can not fail, it is always zero
 100 */
 101static int cpuidle_cooling_get_cur_state(struct thermal_cooling_device *cdev,
 102                                         unsigned long *state)
 103{
 104        struct cpuidle_cooling_device *idle_cdev = cdev->devdata;
 105
 106        *state = idle_cdev->state;
 107
 108        return 0;
 109}
 110
 111/**
 112 * cpuidle_cooling_set_cur_state - Set the current cooling state
 113 * @cdev: the thermal cooling device
 114 * @state: the target state
 115 *
 116 * The function checks first if we are initiating the mitigation which
 117 * in turn wakes up all the idle injection tasks belonging to the idle
 118 * cooling device. In any case, it updates the internal state for the
 119 * cooling device.
 120 *
 121 * Return: The function can not fail, it is always zero
 122 */
 123static int cpuidle_cooling_set_cur_state(struct thermal_cooling_device *cdev,
 124                                         unsigned long state)
 125{
 126        struct cpuidle_cooling_device *idle_cdev = cdev->devdata;
 127        struct idle_inject_device *ii_dev = idle_cdev->ii_dev;
 128        unsigned long current_state = idle_cdev->state;
 129        unsigned int runtime_us, idle_duration_us;
 130
 131        idle_cdev->state = state;
 132
 133        idle_inject_get_duration(ii_dev, &runtime_us, &idle_duration_us);
 134
 135        runtime_us = cpuidle_cooling_runtime(idle_duration_us, state);
 136
 137        idle_inject_set_duration(ii_dev, runtime_us, idle_duration_us);
 138
 139        if (current_state == 0 && state > 0) {
 140                idle_inject_start(ii_dev);
 141        } else if (current_state > 0 && !state)  {
 142                idle_inject_stop(ii_dev);
 143        }
 144
 145        return 0;
 146}
 147
 148/**
 149 * cpuidle_cooling_ops - thermal cooling device ops
 150 */
 151static struct thermal_cooling_device_ops cpuidle_cooling_ops = {
 152        .get_max_state = cpuidle_cooling_get_max_state,
 153        .get_cur_state = cpuidle_cooling_get_cur_state,
 154        .set_cur_state = cpuidle_cooling_set_cur_state,
 155};
 156
 157/**
 158 * __cpuidle_cooling_register: register the cooling device
 159 * @drv: a cpuidle driver structure pointer
 160 * @np: a device node structure pointer used for the thermal binding
 161 *
 162 * This function is in charge of allocating the cpuidle cooling device
 163 * structure, the idle injection, initialize them and register the
 164 * cooling device to the thermal framework.
 165 *
 166 * Return: zero on success, a negative value returned by one of the
 167 * underlying subsystem in case of error
 168 */
 169static int __cpuidle_cooling_register(struct device_node *np,
 170                                      struct cpuidle_driver *drv)
 171{
 172        struct idle_inject_device *ii_dev;
 173        struct cpuidle_cooling_device *idle_cdev;
 174        struct thermal_cooling_device *cdev;
 175        struct device *dev;
 176        unsigned int idle_duration_us = TICK_USEC;
 177        unsigned int latency_us = UINT_MAX;
 178        char *name;
 179        int ret;
 180
 181        idle_cdev = kzalloc(sizeof(*idle_cdev), GFP_KERNEL);
 182        if (!idle_cdev) {
 183                ret = -ENOMEM;
 184                goto out;
 185        }
 186
 187        ii_dev = idle_inject_register(drv->cpumask);
 188        if (!ii_dev) {
 189                ret = -EINVAL;
 190                goto out_kfree;
 191        }
 192
 193        of_property_read_u32(np, "duration-us", &idle_duration_us);
 194        of_property_read_u32(np, "exit-latency-us", &latency_us);
 195
 196        idle_inject_set_duration(ii_dev, TICK_USEC, idle_duration_us);
 197        idle_inject_set_latency(ii_dev, latency_us);
 198
 199        idle_cdev->ii_dev = ii_dev;
 200
 201        dev = get_cpu_device(cpumask_first(drv->cpumask));
 202
 203        name = kasprintf(GFP_KERNEL, "idle-%s", dev_name(dev));
 204        if (!name) {
 205                ret = -ENOMEM;
 206                goto out_unregister;
 207        }
 208
 209        cdev = thermal_of_cooling_device_register(np, name, idle_cdev,
 210                                                  &cpuidle_cooling_ops);
 211        if (IS_ERR(cdev)) {
 212                ret = PTR_ERR(cdev);
 213                goto out_kfree_name;
 214        }
 215
 216        pr_debug("%s: Idle injection set with idle duration=%u, latency=%u\n",
 217                 name, idle_duration_us, latency_us);
 218
 219        kfree(name);
 220
 221        return 0;
 222
 223out_kfree_name:
 224        kfree(name);
 225out_unregister:
 226        idle_inject_unregister(ii_dev);
 227out_kfree:
 228        kfree(idle_cdev);
 229out:
 230        return ret;
 231}
 232
 233/**
 234 * cpuidle_cooling_register - Idle cooling device initialization function
 235 * @drv: a cpuidle driver structure pointer
 236 *
 237 * This function is in charge of creating a cooling device per cpuidle
 238 * driver and register it to the thermal framework.
 239 *
 240 * Return: zero on success, or negative value corresponding to the
 241 * error detected in the underlying subsystems.
 242 */
 243void cpuidle_cooling_register(struct cpuidle_driver *drv)
 244{
 245        struct device_node *cooling_node;
 246        struct device_node *cpu_node;
 247        int cpu, ret;
 248
 249        for_each_cpu(cpu, drv->cpumask) {
 250
 251                cpu_node = of_cpu_device_node_get(cpu);
 252
 253                cooling_node = of_get_child_by_name(cpu_node, "thermal-idle");
 254
 255                of_node_put(cpu_node);
 256
 257                if (!cooling_node) {
 258                        pr_debug("'thermal-idle' node not found for cpu%d\n", cpu);
 259                        continue;
 260                }
 261
 262                ret = __cpuidle_cooling_register(cooling_node, drv);
 263
 264                of_node_put(cooling_node);
 265
 266                if (ret) {
 267                        pr_err("Failed to register the cpuidle cooling device" \
 268                               "for cpu%d: %d\n", cpu, ret);
 269                        break;
 270                }
 271        }
 272}
 273