drivers/cpufreq/cpufreq-dt.c

   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         ret = dev_pm_opp_of_find_icc_paths(cpu_dev, NULL);
 125         if (ret)
 126                 return ret;
 127
 128         name = find_supply_name(cpu_dev);
 129         /* Platform doesn't require regulator */
 130         if (!name)
 131                 return 0;
 132
 133         cpu_reg = regulator_get_optional(cpu_dev, name);
 134         ret = PTR_ERR_OR_ZERO(cpu_reg);
 135         if (ret) {
 136                 /*
 137                  * If cpu's regulator supply node is present, but regulator is
 138                  * not yet registered, we should try defering probe.
 139                  */
 140                 if (ret == -EPROBE_DEFER)
 141                         dev_dbg(cpu_dev, "cpu0 regulator not ready, retry\n");
 142                 else
 143                         dev_dbg(cpu_dev, "no regulator for cpu0: %d\n", ret);
 144
 145                 return ret;
 146         }
 147
 148         regulator_put(cpu_reg);
 149         return 0;
 150 }
 151
 152 static int cpufreq_init(struct cpufreq_policy *policy)
 153 {
 154         struct cpufreq_frequency_table *freq_table;
 155         struct opp_table *opp_table = NULL;
 156         struct private_data *priv;
 157         struct device *cpu_dev;
 158         struct clk *cpu_clk;
 159         unsigned int transition_latency;
 160         bool fallback = false;
 161         const char *name;
 162         int ret;
 163
 164         cpu_dev = get_cpu_device(policy->cpu);
 165         if (!cpu_dev) {
 166                 pr_err("failed to get cpu%d device\n", policy->cpu);
 167                 return -ENODEV;
 168         }
 169
 170         cpu_clk = clk_get(cpu_dev, NULL);
 171         if (IS_ERR(cpu_clk)) {
 172                 ret = PTR_ERR(cpu_clk);
 173                 dev_err(cpu_dev, "%s: failed to get clk: %d\n", __func__, ret);
 174                 return ret;
 175         }
 176
 177         /* Get OPP-sharing information from "operating-points-v2" bindings */
 178         ret = dev_pm_opp_of_get_sharing_cpus(cpu_dev, policy->cpus);
 179         if (ret) {
 180                 if (ret != -ENOENT)
 181                         goto out_put_clk;
 182
 183                 /*
 184                  * operating-points-v2 not supported, fallback to old method of
 185                  * finding shared-OPPs for backward compatibility if the
 186                  * platform hasn't set sharing CPUs.
 187                  */
 188                 if (dev_pm_opp_get_sharing_cpus(cpu_dev, policy->cpus))
 189                         fallback = true;
 190         }
 191
 192         /*
 193          * OPP layer will be taking care of regulators now, but it needs to know
 194          * the name of the regulator first.
 195          */
 196         name = find_supply_name(cpu_dev);
 197         if (name) {
 198                 opp_table = dev_pm_opp_set_regulators(cpu_dev, &name, 1);
 199                 if (IS_ERR(opp_table)) {
 200                         ret = PTR_ERR(opp_table);
 201                         dev_err(cpu_dev, "Failed to set regulator for cpu%d: %d\n",
 202                                 policy->cpu, ret);
 203                         goto out_put_clk;
 204                 }
 205         }
 206
 207         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 208         if (!priv) {
 209                 ret = -ENOMEM;
 210                 goto out_put_regulator;
 211         }
 212
 213         priv->reg_name = name;
 214         priv->opp_table = opp_table;
 215
 216         /*
 217          * Initialize OPP tables for all policy->cpus. They will be shared by
 218          * all CPUs which have marked their CPUs shared with OPP bindings.
 219          *
 220          * For platforms not using operating-points-v2 bindings, we do this
 221          * before updating policy->cpus. Otherwise, we will end up creating
 222          * duplicate OPPs for policy->cpus.
 223          *
 224          * OPPs might be populated at runtime, don't check for error here
 225          */
 226         if (!dev_pm_opp_of_cpumask_add_table(policy->cpus))
 227                 priv->have_static_opps = true;
 228
 229         /*
 230          * But we need OPP table to function so if it is not there let's
 231          * give platform code chance to provide it for us.
 232          */
 233         ret = dev_pm_opp_get_opp_count(cpu_dev);
 234         if (ret <= 0) {
 235                 dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
 236                 ret = -EPROBE_DEFER;
 237                 goto out_free_opp;
 238         }
 239
 240         if (fallback) {
 241                 cpumask_setall(policy->cpus);
 242
 243                 /*
 244                  * OPP tables are initialized only for policy->cpu, do it for
 245                  * others as well.
 246                  */
 247                 ret = dev_pm_opp_set_sharing_cpus(cpu_dev, policy->cpus);
 248                 if (ret)
 249                         dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
 250                                 __func__, ret);
 251         }
 252
 253         ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
 254         if (ret) {
 255                 dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
 256                 goto out_free_opp;
 257         }
 258
 259         priv->cpu_dev = cpu_dev;
 260         policy->driver_data = priv;
 261         policy->clk = cpu_clk;
 262         policy->freq_table = freq_table;
 263
 264         policy->suspend_freq = dev_pm_opp_get_suspend_opp_freq(cpu_dev) / 1000;
 265
 266         /* Support turbo/boost mode */
 267         if (policy_has_boost_freq(policy)) {
 268                 /* This gets disabled by core on driver unregister */
 269                 ret = cpufreq_enable_boost_support();
 270                 if (ret)
 271                         goto out_free_cpufreq_table;
 272                 cpufreq_dt_attr[1] = &cpufreq_freq_attr_scaling_boost_freqs;
 273         }
 274
 275         transition_latency = dev_pm_opp_get_max_transition_latency(cpu_dev);
 276         if (!transition_latency)
 277                 transition_latency = CPUFREQ_ETERNAL;
 278
 279         policy->cpuinfo.transition_latency = transition_latency;
 280         policy->dvfs_possible_from_any_cpu = true;
 281
 282         dev_pm_opp_of_register_em(policy->cpus);
 283
 284         return 0;
 285
 286 out_free_cpufreq_table:
 287         dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
 288 out_free_opp:
 289         if (priv->have_static_opps)
 290                 dev_pm_opp_of_cpumask_remove_table(policy->cpus);
 291         kfree(priv);
 292 out_put_regulator:
 293         if (name)
 294                 dev_pm_opp_put_regulators(opp_table);
 295 out_put_clk:
 296         clk_put(cpu_clk);
 297
 298         return ret;
 299 }
 300
 301 static int cpufreq_online(struct cpufreq_policy *policy)
 302 {
 303         /* We did light-weight tear down earlier, nothing to do here */
 304         return 0;
 305 }
 306
 307 static int cpufreq_offline(struct cpufreq_policy *policy)
 308 {
 309         /*
 310          * Preserve policy->driver_data and don't free resources on light-weight
 311          * tear down.
 312          */
 313         return 0;
 314 }
 315
 316 static int cpufreq_exit(struct cpufreq_policy *policy)
 317 {
 318         struct private_data *priv = policy->driver_data;
 319
 320         dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
 321         if (priv->have_static_opps)
 322                 dev_pm_opp_of_cpumask_remove_table(policy->related_cpus);
 323         if (priv->reg_name)
 324                 dev_pm_opp_put_regulators(priv->opp_table);
 325
 326         clk_put(policy->clk);
 327         kfree(priv);
 328
 329         return 0;
 330 }
 331
 332 static struct cpufreq_driver dt_cpufreq_driver = {
 333         .flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK |
 334                  CPUFREQ_IS_COOLING_DEV,
 335         .verify = cpufreq_generic_frequency_table_verify,
 336         .target_index = set_target,
 337         .get = cpufreq_generic_get,
 338         .init = cpufreq_init,
 339         .exit = cpufreq_exit,
 340         .online = cpufreq_online,
 341         .offline = cpufreq_offline,
 342         .name = "cpufreq-dt",
 343         .attr = cpufreq_dt_attr,
 344         .suspend = cpufreq_generic_suspend,
 345 };
 346
 347 static int dt_cpufreq_probe(struct platform_device *pdev)
 348 {
 349         struct cpufreq_dt_platform_data *data = dev_get_platdata(&pdev->dev);
 350         int ret;
 351
 352         /*
 353          * All per-cluster (CPUs sharing clock/voltages) initialization is done
 354          * from ->init(). In probe(), we just need to make sure that clk and
 355          * regulators are available. Else defer probe and retry.
 356          *
 357          * FIXME: Is checking this only for CPU0 sufficient ?
 358          */
 359         ret = resources_available();
 360         if (ret)
 361                 return ret;
 362
 363         if (data) {
 364                 if (data->have_governor_per_policy)
 365                         dt_cpufreq_driver.flags |= CPUFREQ_HAVE_GOVERNOR_PER_POLICY;
 366
 367                 dt_cpufreq_driver.resume = data->resume;
 368                 if (data->suspend)
 369                         dt_cpufreq_driver.suspend = data->suspend;
 370                 if (data->get_intermediate) {
 371                         dt_cpufreq_driver.target_intermediate = data->target_intermediate;
 372                         dt_cpufreq_driver.get_intermediate = data->get_intermediate;
 373                 }
 374         }
 375
 376         ret = cpufreq_register_driver(&dt_cpufreq_driver);
 377         if (ret)
 378                 dev_err(&pdev->dev, "failed register driver: %d\n", ret);
 379
 380         return ret;
 381 }
 382
 383 static int dt_cpufreq_remove(struct platform_device *pdev)
 384 {
 385         cpufreq_unregister_driver(&dt_cpufreq_driver);
 386         return 0;
 387 }
 388
 389 static struct platform_driver dt_cpufreq_platdrv = {
 390         .driver = {
 391                 .name   = "cpufreq-dt",
 392         },
 393         .probe          = dt_cpufreq_probe,
 394         .remove         = dt_cpufreq_remove,
 395 };
 396 module_platform_driver(dt_cpufreq_platdrv);
 397
 398 MODULE_ALIAS("platform:cpufreq-dt");
 399 MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
 400 MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
 401 MODULE_DESCRIPTION("Generic cpufreq driver");
 402 MODULE_LICENSE("GPL");