kernel/power/energy_model.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Energy Model of devices
   4  *
   5  * Copyright (c) 2018-2021, Arm ltd.
   6  * Written by: Quentin Perret, Arm ltd.
   7  * Improvements provided by: Lukasz Luba, Arm ltd.
   8  */
   9
  10 #define pr_fmt(fmt) "energy_model: " fmt
  11
  12 #include <linux/cpu.h>
  13 #include <linux/cpufreq.h>
  14 #include <linux/cpumask.h>
  15 #include <linux/debugfs.h>
  16 #include <linux/energy_model.h>
  17 #include <linux/sched/topology.h>
  18 #include <linux/slab.h>
  19
  20 /*
  21  * Mutex serializing the registrations of performance domains and letting
  22  * callbacks defined by drivers sleep.
  23  */
  24 static DEFINE_MUTEX(em_pd_mutex);
  25
  26 static bool _is_cpu_device(struct device *dev)
  27 {
  28         return (dev->bus == &cpu_subsys);
  29 }
  30
  31 #ifdef CONFIG_DEBUG_FS
  32 static struct dentry *rootdir;
  33
  34 static void em_debug_create_ps(struct em_perf_state *ps, struct dentry *pd)
  35 {
  36         struct dentry *d;
  37         char name[24];
  38
  39         snprintf(name, sizeof(name), "ps:%lu", ps->frequency);
  40
  41         /* Create per-ps directory */
  42         d = debugfs_create_dir(name, pd);
  43         debugfs_create_ulong("frequency", 0444, d, &ps->frequency);
  44         debugfs_create_ulong("power", 0444, d, &ps->power);
  45         debugfs_create_ulong("cost", 0444, d, &ps->cost);
  46         debugfs_create_ulong("inefficient", 0444, d, &ps->flags);
  47 }
  48
  49 static int em_debug_cpus_show(struct seq_file *s, void *unused)
  50 {
  51         seq_printf(s, "%*pbl\n", cpumask_pr_args(to_cpumask(s->private)));
  52
  53         return 0;
  54 }
  55 DEFINE_SHOW_ATTRIBUTE(em_debug_cpus);
  56
  57 static int em_debug_flags_show(struct seq_file *s, void *unused)
  58 {
  59         struct em_perf_domain *pd = s->private;
  60
  61         seq_printf(s, "%#lx\n", pd->flags);
  62
  63         return 0;
  64 }
  65 DEFINE_SHOW_ATTRIBUTE(em_debug_flags);
  66
  67 static void em_debug_create_pd(struct device *dev)
  68 {
  69         struct dentry *d;
  70         int i;
  71
  72         /* Create the directory of the performance domain */
  73         d = debugfs_create_dir(dev_name(dev), rootdir);
  74
  75         if (_is_cpu_device(dev))
  76                 debugfs_create_file("cpus", 0444, d, dev->em_pd->cpus,
  77                                     &em_debug_cpus_fops);
  78
  79         debugfs_create_file("flags", 0444, d, dev->em_pd,
  80                             &em_debug_flags_fops);
  81
  82         /* Create a sub-directory for each performance state */
  83         for (i = 0; i < dev->em_pd->nr_perf_states; i++)
  84                 em_debug_create_ps(&dev->em_pd->table[i], d);
  85
  86 }
  87
  88 static void em_debug_remove_pd(struct device *dev)
  89 {
  90         struct dentry *debug_dir;
  91
  92         debug_dir = debugfs_lookup(dev_name(dev), rootdir);
  93         debugfs_remove_recursive(debug_dir);
  94 }
  95
  96 static int __init em_debug_init(void)
  97 {
  98         /* Create /sys/kernel/debug/energy_model directory */
  99         rootdir = debugfs_create_dir("energy_model", NULL);
 100
 101         return 0;
 102 }
 103 fs_initcall(em_debug_init);
 104 #else /* CONFIG_DEBUG_FS */
 105 static void em_debug_create_pd(struct device *dev) {}
 106 static void em_debug_remove_pd(struct device *dev) {}
 107 #endif
 108
 109 static int em_create_perf_table(struct device *dev, struct em_perf_domain *pd,
 110                                 int nr_states, struct em_data_callback *cb,
 111                                 unsigned long flags)
 112 {
 113         unsigned long power, freq, prev_freq = 0, prev_cost = ULONG_MAX;
 114         struct em_perf_state *table;
 115         int i, ret;
 116         u64 fmax;
 117
 118         table = kcalloc(nr_states, sizeof(*table), GFP_KERNEL);
 119         if (!table)
 120                 return -ENOMEM;
 121
 122         /* Build the list of performance states for this performance domain */
 123         for (i = 0, freq = 0; i < nr_states; i++, freq++) {
 124                 /*
 125                  * active_power() is a driver callback which ceils 'freq' to
 126                  * lowest performance state of 'dev' above 'freq' and updates
 127                  * 'power' and 'freq' accordingly.
 128                  */
 129                 ret = cb->active_power(dev, &power, &freq);
 130                 if (ret) {
 131                         dev_err(dev, "EM: invalid perf. state: %d\n",
 132                                 ret);
 133                         goto free_ps_table;
 134                 }
 135
 136                 /*
 137                  * We expect the driver callback to increase the frequency for
 138                  * higher performance states.
 139                  */
 140                 if (freq <= prev_freq) {
 141                         dev_err(dev, "EM: non-increasing freq: %lu\n",
 142                                 freq);
 143                         goto free_ps_table;
 144                 }
 145
 146                 /*
 147                  * The power returned by active_state() is expected to be
 148                  * positive and to fit into 16 bits.
 149                  */
 150                 if (!power || power > EM_MAX_POWER) {
 151                         dev_err(dev, "EM: invalid power: %lu\n",
 152                                 power);
 153                         goto free_ps_table;
 154                 }
 155
 156                 table[i].power = power;
 157                 table[i].frequency = prev_freq = freq;
 158         }
 159
 160         /* Compute the cost of each performance state. */
 161         fmax = (u64) table[nr_states - 1].frequency;
 162         for (i = nr_states - 1; i >= 0; i--) {
 163                 unsigned long power_res, cost;
 164
 165                 if (flags & EM_PERF_DOMAIN_ARTIFICIAL) {
 166                         ret = cb->get_cost(dev, table[i].frequency, &cost);
 167                         if (ret || !cost || cost > EM_MAX_POWER) {
 168                                 dev_err(dev, "EM: invalid cost %lu %d\n",
 169                                         cost, ret);
 170                                 goto free_ps_table;
 171                         }
 172                 } else {
 173                         power_res = em_scale_power(table[i].power);
 174                         cost = div64_u64(fmax * power_res, table[i].frequency);
 175                 }
 176
 177                 table[i].cost = cost;
 178
 179                 if (table[i].cost >= prev_cost) {
 180                         table[i].flags = EM_PERF_STATE_INEFFICIENT;
 181                         dev_dbg(dev, "EM: OPP:%lu is inefficient\n",
 182                                 table[i].frequency);
 183                 } else {
 184                         prev_cost = table[i].cost;
 185                 }
 186         }
 187
 188         pd->table = table;
 189         pd->nr_perf_states = nr_states;
 190
 191         return 0;
 192
 193 free_ps_table:
 194         kfree(table);
 195         return -EINVAL;
 196 }
 197
 198 static int em_create_pd(struct device *dev, int nr_states,
 199                         struct em_data_callback *cb, cpumask_t *cpus,
 200                         unsigned long flags)
 201 {
 202         struct em_perf_domain *pd;
 203         struct device *cpu_dev;
 204         int cpu, ret;
 205
 206         if (_is_cpu_device(dev)) {
 207                 pd = kzalloc(sizeof(*pd) + cpumask_size(), GFP_KERNEL);
 208                 if (!pd)
 209                         return -ENOMEM;
 210
 211                 cpumask_copy(em_span_cpus(pd), cpus);
 212         } else {
 213                 pd = kzalloc(sizeof(*pd), GFP_KERNEL);
 214                 if (!pd)
 215                         return -ENOMEM;
 216         }
 217
 218         ret = em_create_perf_table(dev, pd, nr_states, cb, flags);
 219         if (ret) {
 220                 kfree(pd);
 221                 return ret;
 222         }
 223
 224         if (_is_cpu_device(dev))
 225                 for_each_cpu(cpu, cpus) {
 226                         cpu_dev = get_cpu_device(cpu);
 227                         cpu_dev->em_pd = pd;
 228                 }
 229
 230         dev->em_pd = pd;
 231
 232         return 0;
 233 }
 234
 235 static void em_cpufreq_update_efficiencies(struct device *dev)
 236 {
 237         struct em_perf_domain *pd = dev->em_pd;
 238         struct em_perf_state *table;
 239         struct cpufreq_policy *policy;
 240         int found = 0;
 241         int i;
 242
 243         if (!_is_cpu_device(dev) || !pd)
 244                 return;
 245
 246         policy = cpufreq_cpu_get(cpumask_first(em_span_cpus(pd)));
 247         if (!policy) {
 248                 dev_warn(dev, "EM: Access to CPUFreq policy failed");
 249                 return;
 250         }
 251
 252         table = pd->table;
 253
 254         for (i = 0; i < pd->nr_perf_states; i++) {
 255                 if (!(table[i].flags & EM_PERF_STATE_INEFFICIENT))
 256                         continue;
 257
 258                 if (!cpufreq_table_set_inefficient(policy, table[i].frequency))
 259                         found++;
 260         }
 261
 262         if (!found)
 263                 return;
 264
 265         /*
 266          * Efficiencies have been installed in CPUFreq, inefficient frequencies
 267          * will be skipped. The EM can do the same.
 268          */
 269         pd->flags |= EM_PERF_DOMAIN_SKIP_INEFFICIENCIES;
 270 }
 271
 272 /**
 273  * em_pd_get() - Return the performance domain for a device
 274  * @dev : Device to find the performance domain for
 275  *
 276  * Returns the performance domain to which @dev belongs, or NULL if it doesn't
 277  * exist.
 278  */
 279 struct em_perf_domain *em_pd_get(struct device *dev)
 280 {
 281         if (IS_ERR_OR_NULL(dev))
 282                 return NULL;
 283
 284         return dev->em_pd;
 285 }
 286 EXPORT_SYMBOL_GPL(em_pd_get);
 287
 288 /**
 289  * em_cpu_get() - Return the performance domain for a CPU
 290  * @cpu : CPU to find the performance domain for
 291  *
 292  * Returns the performance domain to which @cpu belongs, or NULL if it doesn't
 293  * exist.
 294  */
 295 struct em_perf_domain *em_cpu_get(int cpu)
 296 {
 297         struct device *cpu_dev;
 298
 299         cpu_dev = get_cpu_device(cpu);
 300         if (!cpu_dev)
 301                 return NULL;
 302
 303         return em_pd_get(cpu_dev);
 304 }
 305 EXPORT_SYMBOL_GPL(em_cpu_get);
 306
 307 /**
 308  * em_dev_register_perf_domain() - Register the Energy Model (EM) for a device
 309  * @dev         : Device for which the EM is to register
 310  * @nr_states   : Number of performance states to register
 311  * @cb          : Callback functions providing the data of the Energy Model
 312  * @cpus        : Pointer to cpumask_t, which in case of a CPU device is
 313  *              obligatory. It can be taken from i.e. 'policy->cpus'. For other
 314  *              type of devices this should be set to NULL.
 315  * @milliwatts  : Flag indicating that the power values are in milliWatts or
 316  *              in some other scale. It must be set properly.
 317  *
 318  * Create Energy Model tables for a performance domain using the callbacks
 319  * defined in cb.
 320  *
 321  * The @milliwatts is important to set with correct value. Some kernel
 322  * sub-systems might rely on this flag and check if all devices in the EM are
 323  * using the same scale.
 324  *
 325  * If multiple clients register the same performance domain, all but the first
 326  * registration will be ignored.
 327  *
 328  * Return 0 on success
 329  */
 330 int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states,
 331                                 struct em_data_callback *cb, cpumask_t *cpus,
 332                                 bool milliwatts)
 333 {
 334         unsigned long cap, prev_cap = 0;
 335         unsigned long flags = 0;
 336         int cpu, ret;
 337
 338         if (!dev || !nr_states || !cb)
 339                 return -EINVAL;
 340
 341         /*
 342          * Use a mutex to serialize the registration of performance domains and
 343          * let the driver-defined callback functions sleep.
 344          */
 345         mutex_lock(&em_pd_mutex);
 346
 347         if (dev->em_pd) {
 348                 ret = -EEXIST;
 349                 goto unlock;
 350         }
 351
 352         if (_is_cpu_device(dev)) {
 353                 if (!cpus) {
 354                         dev_err(dev, "EM: invalid CPU mask\n");
 355                         ret = -EINVAL;
 356                         goto unlock;
 357                 }
 358
 359                 for_each_cpu(cpu, cpus) {
 360                         if (em_cpu_get(cpu)) {
 361                                 dev_err(dev, "EM: exists for CPU%d\n", cpu);
 362                                 ret = -EEXIST;
 363                                 goto unlock;
 364                         }
 365                         /*
 366                          * All CPUs of a domain must have the same
 367                          * micro-architecture since they all share the same
 368                          * table.
 369                          */
 370                         cap = arch_scale_cpu_capacity(cpu);
 371                         if (prev_cap && prev_cap != cap) {
 372                                 dev_err(dev, "EM: CPUs of %*pbl must have the same capacity\n",
 373                                         cpumask_pr_args(cpus));
 374
 375                                 ret = -EINVAL;
 376                                 goto unlock;
 377                         }
 378                         prev_cap = cap;
 379                 }
 380         }
 381
 382         if (milliwatts)
 383                 flags |= EM_PERF_DOMAIN_MILLIWATTS;
 384         else if (cb->get_cost)
 385                 flags |= EM_PERF_DOMAIN_ARTIFICIAL;
 386
 387         ret = em_create_pd(dev, nr_states, cb, cpus, flags);
 388         if (ret)
 389                 goto unlock;
 390
 391         dev->em_pd->flags |= flags;
 392
 393         em_cpufreq_update_efficiencies(dev);
 394
 395         em_debug_create_pd(dev);
 396         dev_info(dev, "EM: created perf domain\n");
 397
 398 unlock:
 399         mutex_unlock(&em_pd_mutex);
 400         return ret;
 401 }
 402 EXPORT_SYMBOL_GPL(em_dev_register_perf_domain);
 403
 404 /**
 405  * em_dev_unregister_perf_domain() - Unregister Energy Model (EM) for a device
 406  * @dev         : Device for which the EM is registered
 407  *
 408  * Unregister the EM for the specified @dev (but not a CPU device).
 409  */
 410 void em_dev_unregister_perf_domain(struct device *dev)
 411 {
 412         if (IS_ERR_OR_NULL(dev) || !dev->em_pd)
 413                 return;
 414
 415         if (_is_cpu_device(dev))
 416                 return;
 417
 418         /*
 419          * The mutex separates all register/unregister requests and protects
 420          * from potential clean-up/setup issues in the debugfs directories.
 421          * The debugfs directory name is the same as device's name.
 422          */
 423         mutex_lock(&em_pd_mutex);
 424         em_debug_remove_pd(dev);
 425
 426         kfree(dev->em_pd->table);
 427         kfree(dev->em_pd);
 428         dev->em_pd = NULL;
 429         mutex_unlock(&em_pd_mutex);
 430 }
 431 EXPORT_SYMBOL_GPL(em_dev_unregister_perf_domain);