root/drivers/cpufreq/cpufreq-dt.c

DEFINITIONS

1. set_target
2. find_supply_name
3. resources_available
4. cpufreq_init
5. cpufreq_online
6. cpufreq_offline
7. cpufreq_exit
8. dt_cpufreq_probe
9. dt_cpufreq_remove

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2012 Freescale Semiconductor, Inc.
   4  *
   5  * Copyright (C) 2014 Linaro.
   6  * Viresh Kumar <viresh.kumar@linaro.org>
   7  */
   8 
   9 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
  10 
  11 #include <linux/clk.h>
  12 #include <linux/cpu.h>
  13 #include <linux/cpufreq.h>
  14 #include <linux/cpumask.h>
  15 #include <linux/err.h>
  16 #include <linux/module.h>
  17 #include <linux/of.h>
  18 #include <linux/pm_opp.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/regulator/consumer.h>
  21 #include <linux/slab.h>
  22 #include <linux/thermal.h>
  23 
  24 #include "cpufreq-dt.h"
  25 
  26 struct private_data {
  27         struct opp_table *opp_table;
  28         struct device *cpu_dev;
  29         const char *reg_name;
  30         bool have_static_opps;
  31 };
  32 
  33 static struct freq_attr *cpufreq_dt_attr[] = {
  34         &cpufreq_freq_attr_scaling_available_freqs,
  35         NULL,   /* Extra space for boost-attr if required */
  36         NULL,
  37 };
  38 
  39 static int set_target(struct cpufreq_policy *policy, unsigned int index)
  40 {
  41         struct private_data *priv = policy->driver_data;
  42         unsigned long freq = policy->freq_table[index].frequency;
  43         int ret;
  44 
  45         ret = dev_pm_opp_set_rate(priv->cpu_dev, freq * 1000);
  46 
  47         if (!ret) {
  48                 arch_set_freq_scale(policy->related_cpus, freq,
  49                                     policy->cpuinfo.max_freq);
  50         }
  51 
  52         return ret;
  53 }
  54 
  55 /*
  56  * An earlier version of opp-v1 bindings used to name the regulator
  57  * "cpu0-supply", we still need to handle that for backwards compatibility.
  58  */
  59 static const char *find_supply_name(struct device *dev)
  60 {
  61         struct device_node *np;
  62         struct property *pp;
  63         int cpu = dev->id;
  64         const char *name = NULL;
  65 
  66         np = of_node_get(dev->of_node);
  67 
  68         /* This must be valid for sure */
  69         if (WARN_ON(!np))
  70                 return NULL;
  71 
  72         /* Try "cpu0" for older DTs */
  73         if (!cpu) {
  74                 pp = of_find_property(np, "cpu0-supply", NULL);
  75                 if (pp) {
  76                         name = "cpu0";
  77                         goto node_put;
  78                 }
  79         }
  80 
  81         pp = of_find_property(np, "cpu-supply", NULL);
  82         if (pp) {
  83                 name = "cpu";
  84                 goto node_put;
  85         }
  86 
  87         dev_dbg(dev, "no regulator for cpu%d\n", cpu);
  88 node_put:
  89         of_node_put(np);
  90         return name;
  91 }
  92 
  93 static int resources_available(void)
  94 {
  95         struct device *cpu_dev;
  96         struct regulator *cpu_reg;
  97         struct clk *cpu_clk;
  98         int ret = 0;
  99         const char *name;
 100 
 101         cpu_dev = get_cpu_device(0);
 102         if (!cpu_dev) {
 103                 pr_err("failed to get cpu0 device\n");
 104                 return -ENODEV;
 105         }
 106 
 107         cpu_clk = clk_get(cpu_dev, NULL);
 108         ret = PTR_ERR_OR_ZERO(cpu_clk);
 109         if (ret) {
 110                 /*
 111                  * If cpu's clk node is present, but clock is not yet
 112                  * registered, we should try defering probe.
 113                  */
 114                 if (ret == -EPROBE_DEFER)
 115                         dev_dbg(cpu_dev, "clock not ready, retry\n");
 116                 else
 117                         dev_err(cpu_dev, "failed to get clock: %d\n", ret);
 118 
 119                 return ret;
 120         }
 121 
 122         clk_put(cpu_clk);
 123 
 124         name = find_supply_name(cpu_dev);
 125         /* Platform doesn't require regulator */
 126         if (!name)
 127                 return 0;
 128 
 129         cpu_reg = regulator_get_optional(cpu_dev, name);
 130         ret = PTR_ERR_OR_ZERO(cpu_reg);
 131         if (ret) {
 132                 /*
 133                  * If cpu's regulator supply node is present, but regulator is
 134                  * not yet registered, we should try defering probe.
 135                  */
 136                 if (ret == -EPROBE_DEFER)
 137                         dev_dbg(cpu_dev, "cpu0 regulator not ready, retry\n");
 138                 else
 139                         dev_dbg(cpu_dev, "no regulator for cpu0: %d\n", ret);
 140 
 141                 return ret;
 142         }
 143 
 144         regulator_put(cpu_reg);
 145         return 0;
 146 }
 147 
 148 static int cpufreq_init(struct cpufreq_policy *policy)
 149 {
 150         struct cpufreq_frequency_table *freq_table;
 151         struct opp_table *opp_table = NULL;
 152         struct private_data *priv;
 153         struct device *cpu_dev;
 154         struct clk *cpu_clk;
 155         unsigned int transition_latency;
 156         bool fallback = false;
 157         const char *name;
 158         int ret;
 159 
 160         cpu_dev = get_cpu_device(policy->cpu);
 161         if (!cpu_dev) {
 162                 pr_err("failed to get cpu%d device\n", policy->cpu);
 163                 return -ENODEV;
 164         }
 165 
 166         cpu_clk = clk_get(cpu_dev, NULL);
 167         if (IS_ERR(cpu_clk)) {
 168                 ret = PTR_ERR(cpu_clk);
 169                 dev_err(cpu_dev, "%s: failed to get clk: %d\n", __func__, ret);
 170                 return ret;
 171         }
 172 
 173         /* Get OPP-sharing information from "operating-points-v2" bindings */
 174         ret = dev_pm_opp_of_get_sharing_cpus(cpu_dev, policy->cpus);
 175         if (ret) {
 176                 if (ret != -ENOENT)
 177                         goto out_put_clk;
 178 
 179                 /*
 180                  * operating-points-v2 not supported, fallback to old method of
 181                  * finding shared-OPPs for backward compatibility if the
 182                  * platform hasn't set sharing CPUs.
 183                  */
 184                 if (dev_pm_opp_get_sharing_cpus(cpu_dev, policy->cpus))
 185                         fallback = true;
 186         }
 187 
 188         /*
 189          * OPP layer will be taking care of regulators now, but it needs to know
 190          * the name of the regulator first.
 191          */
 192         name = find_supply_name(cpu_dev);
 193         if (name) {
 194                 opp_table = dev_pm_opp_set_regulators(cpu_dev, &name, 1);
 195                 if (IS_ERR(opp_table)) {
 196                         ret = PTR_ERR(opp_table);
 197                         dev_err(cpu_dev, "Failed to set regulator for cpu%d: %d\n",
 198                                 policy->cpu, ret);
 199                         goto out_put_clk;
 200                 }
 201         }
 202 
 203         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 204         if (!priv) {
 205                 ret = -ENOMEM;
 206                 goto out_put_regulator;
 207         }
 208 
 209         priv->reg_name = name;
 210         priv->opp_table = opp_table;
 211 
 212         /*
 213          * Initialize OPP tables for all policy->cpus. They will be shared by
 214          * all CPUs which have marked their CPUs shared with OPP bindings.
 215          *
 216          * For platforms not using operating-points-v2 bindings, we do this
 217          * before updating policy->cpus. Otherwise, we will end up creating
 218          * duplicate OPPs for policy->cpus.
 219          *
 220          * OPPs might be populated at runtime, don't check for error here
 221          */
 222         if (!dev_pm_opp_of_cpumask_add_table(policy->cpus))
 223                 priv->have_static_opps = true;
 224 
 225         /*
 226          * But we need OPP table to function so if it is not there let's
 227          * give platform code chance to provide it for us.
 228          */
 229         ret = dev_pm_opp_get_opp_count(cpu_dev);
 230         if (ret <= 0) {
 231                 dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
 232                 ret = -EPROBE_DEFER;
 233                 goto out_free_opp;
 234         }
 235 
 236         if (fallback) {
 237                 cpumask_setall(policy->cpus);
 238 
 239                 /*
 240                  * OPP tables are initialized only for policy->cpu, do it for
 241                  * others as well.
 242                  */
 243                 ret = dev_pm_opp_set_sharing_cpus(cpu_dev, policy->cpus);
 244                 if (ret)
 245                         dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
 246                                 __func__, ret);
 247         }
 248 
 249         ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
 250         if (ret) {
 251                 dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
 252                 goto out_free_opp;
 253         }
 254 
 255         priv->cpu_dev = cpu_dev;
 256         policy->driver_data = priv;
 257         policy->clk = cpu_clk;
 258         policy->freq_table = freq_table;
 259 
 260         policy->suspend_freq = dev_pm_opp_get_suspend_opp_freq(cpu_dev) / 1000;
 261 
 262         /* Support turbo/boost mode */
 263         if (policy_has_boost_freq(policy)) {
 264                 /* This gets disabled by core on driver unregister */
 265                 ret = cpufreq_enable_boost_support();
 266                 if (ret)
 267                         goto out_free_cpufreq_table;
 268                 cpufreq_dt_attr[1] = &cpufreq_freq_attr_scaling_boost_freqs;
 269         }
 270 
 271         transition_latency = dev_pm_opp_get_max_transition_latency(cpu_dev);
 272         if (!transition_latency)
 273                 transition_latency = CPUFREQ_ETERNAL;
 274 
 275         policy->cpuinfo.transition_latency = transition_latency;
 276         policy->dvfs_possible_from_any_cpu = true;
 277 
 278         dev_pm_opp_of_register_em(policy->cpus);
 279 
 280         return 0;
 281 
 282 out_free_cpufreq_table:
 283         dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
 284 out_free_opp:
 285         if (priv->have_static_opps)
 286                 dev_pm_opp_of_cpumask_remove_table(policy->cpus);
 287         kfree(priv);
 288 out_put_regulator:
 289         if (name)
 290                 dev_pm_opp_put_regulators(opp_table);
 291 out_put_clk:
 292         clk_put(cpu_clk);
 293 
 294         return ret;
 295 }
 296 
 297 static int cpufreq_online(struct cpufreq_policy *policy)
 298 {
 299         /* We did light-weight tear down earlier, nothing to do here */
 300         return 0;
 301 }
 302 
 303 static int cpufreq_offline(struct cpufreq_policy *policy)
 304 {
 305         /*
 306          * Preserve policy->driver_data and don't free resources on light-weight
 307          * tear down.
 308          */
 309         return 0;
 310 }
 311 
 312 static int cpufreq_exit(struct cpufreq_policy *policy)
 313 {
 314         struct private_data *priv = policy->driver_data;
 315 
 316         dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
 317         if (priv->have_static_opps)
 318                 dev_pm_opp_of_cpumask_remove_table(policy->related_cpus);
 319         if (priv->reg_name)
 320                 dev_pm_opp_put_regulators(priv->opp_table);
 321 
 322         clk_put(policy->clk);
 323         kfree(priv);
 324 
 325         return 0;
 326 }
 327 
 328 static struct cpufreq_driver dt_cpufreq_driver = {
 329         .flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK |
 330                  CPUFREQ_IS_COOLING_DEV,
 331         .verify = cpufreq_generic_frequency_table_verify,
 332         .target_index = set_target,
 333         .get = cpufreq_generic_get,
 334         .init = cpufreq_init,
 335         .exit = cpufreq_exit,
 336         .online = cpufreq_online,
 337         .offline = cpufreq_offline,
 338         .name = "cpufreq-dt",
 339         .attr = cpufreq_dt_attr,
 340         .suspend = cpufreq_generic_suspend,
 341 };
 342 
 343 static int dt_cpufreq_probe(struct platform_device *pdev)
 344 {
 345         struct cpufreq_dt_platform_data *data = dev_get_platdata(&pdev->dev);
 346         int ret;
 347 
 348         /*
 349          * All per-cluster (CPUs sharing clock/voltages) initialization is done
 350          * from ->init(). In probe(), we just need to make sure that clk and
 351          * regulators are available. Else defer probe and retry.
 352          *
 353          * FIXME: Is checking this only for CPU0 sufficient ?
 354          */
 355         ret = resources_available();
 356         if (ret)
 357                 return ret;
 358 
 359         if (data) {
 360                 if (data->have_governor_per_policy)
 361                         dt_cpufreq_driver.flags |= CPUFREQ_HAVE_GOVERNOR_PER_POLICY;
 362 
 363                 dt_cpufreq_driver.resume = data->resume;
 364                 if (data->suspend)
 365                         dt_cpufreq_driver.suspend = data->suspend;
 366         }
 367 
 368         ret = cpufreq_register_driver(&dt_cpufreq_driver);
 369         if (ret)
 370                 dev_err(&pdev->dev, "failed register driver: %d\n", ret);
 371 
 372         return ret;
 373 }
 374 
 375 static int dt_cpufreq_remove(struct platform_device *pdev)
 376 {
 377         cpufreq_unregister_driver(&dt_cpufreq_driver);
 378         return 0;
 379 }
 380 
 381 static struct platform_driver dt_cpufreq_platdrv = {
 382         .driver = {
 383                 .name   = "cpufreq-dt",
 384         },
 385         .probe          = dt_cpufreq_probe,
 386         .remove         = dt_cpufreq_remove,
 387 };
 388 module_platform_driver(dt_cpufreq_platdrv);
 389 
 390 MODULE_ALIAS("platform:cpufreq-dt");
 391 MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
 392 MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
 393 MODULE_DESCRIPTION("Generic cpufreq driver");
 394 MODULE_LICENSE("GPL");