drivers/cpufreq/cpufreq-dt.c

   1 /*
   2  * Copyright (C) 2012 Freescale Semiconductor, Inc.
   3  *
   4  * Copyright (C) 2014 Linaro.
   5  * Viresh Kumar <viresh.kumar@linaro.org>
   6  *
   7  * The OPP code in function set_target() is reused from
   8  * drivers/cpufreq/omap-cpufreq.c
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  */
  14
  15 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
  16
  17 #include <linux/clk.h>
  18 #include <linux/cpu.h>
  19 #include <linux/cpu_cooling.h>
  20 #include <linux/cpufreq.h>
  21 #include <linux/cpumask.h>
  22 #include <linux/err.h>
  23 #include <linux/module.h>
  24 #include <linux/of.h>
  25 #include <linux/pm_opp.h>
  26 #include <linux/platform_device.h>
  27 #include <linux/regulator/consumer.h>
  28 #include <linux/slab.h>
  29 #include <linux/thermal.h>
  30
  31 struct private_data {
  32         struct device *cpu_dev;
  33         struct regulator *cpu_reg;
  34         struct thermal_cooling_device *cdev;
  35         unsigned int voltage_tolerance; /* in percentage */
  36 };
  37
  38 static int set_target(struct cpufreq_policy *policy, unsigned int index)
  39 {
  40         struct dev_pm_opp *opp;
  41         struct cpufreq_frequency_table *freq_table = policy->freq_table;
  42         struct clk *cpu_clk = policy->clk;
  43         struct private_data *priv = policy->driver_data;
  44         struct device *cpu_dev = priv->cpu_dev;
  45         struct regulator *cpu_reg = priv->cpu_reg;
  46         unsigned long volt = 0, volt_old = 0, tol = 0;
  47         unsigned int old_freq, new_freq;
  48         long freq_Hz, freq_exact;
  49         int ret;
  50
  51         freq_Hz = clk_round_rate(cpu_clk, freq_table[index].frequency * 1000);
  52         if (freq_Hz <= 0)
  53                 freq_Hz = freq_table[index].frequency * 1000;
  54
  55         freq_exact = freq_Hz;
  56         new_freq = freq_Hz / 1000;
  57         old_freq = clk_get_rate(cpu_clk) / 1000;
  58
  59         if (!IS_ERR(cpu_reg)) {
  60                 rcu_read_lock();
  61                 opp = dev_pm_opp_find_freq_ceil(cpu_dev, &freq_Hz);
  62                 if (IS_ERR(opp)) {
  63                         rcu_read_unlock();
  64                         dev_err(cpu_dev, "failed to find OPP for %ld\n",
  65                                 freq_Hz);
  66                         return PTR_ERR(opp);
  67                 }
  68                 volt = dev_pm_opp_get_voltage(opp);
  69                 rcu_read_unlock();
  70                 tol = volt * priv->voltage_tolerance / 100;
  71                 volt_old = regulator_get_voltage(cpu_reg);
  72         }
  73
  74         dev_dbg(cpu_dev, "%u MHz, %ld mV --> %u MHz, %ld mV\n",
  75                 old_freq / 1000, volt_old ? volt_old / 1000 : -1,
  76                 new_freq / 1000, volt ? volt / 1000 : -1);
  77
  78         /* scaling up?  scale voltage before frequency */
  79         if (!IS_ERR(cpu_reg) && new_freq > old_freq) {
  80                 ret = regulator_set_voltage_tol(cpu_reg, volt, tol);
  81                 if (ret) {
  82                         dev_err(cpu_dev, "failed to scale voltage up: %d\n",
  83                                 ret);
  84                         return ret;
  85                 }
  86         }
  87
  88         ret = clk_set_rate(cpu_clk, freq_exact);
  89         if (ret) {
  90                 dev_err(cpu_dev, "failed to set clock rate: %d\n", ret);
  91                 if (!IS_ERR(cpu_reg))
  92                         regulator_set_voltage_tol(cpu_reg, volt_old, tol);
  93                 return ret;
  94         }
  95
  96         /* scaling down?  scale voltage after frequency */
  97         if (!IS_ERR(cpu_reg) && new_freq < old_freq) {
  98                 ret = regulator_set_voltage_tol(cpu_reg, volt, tol);
  99                 if (ret) {
 100                         dev_err(cpu_dev, "failed to scale voltage down: %d\n",
 101                                 ret);
 102                         clk_set_rate(cpu_clk, old_freq * 1000);
 103                 }
 104         }
 105
 106         return ret;
 107 }
 108
 109 static int allocate_resources(int cpu, struct device **cdev,
 110                               struct regulator **creg, struct clk **cclk)
 111 {
 112         struct device *cpu_dev;
 113         struct regulator *cpu_reg;
 114         struct clk *cpu_clk;
 115         int ret = 0;
 116         char *reg_cpu0 = "cpu0", *reg_cpu = "cpu", *reg;
 117
 118         cpu_dev = get_cpu_device(cpu);
 119         if (!cpu_dev) {
 120                 pr_err("failed to get cpu%d device\n", cpu);
 121                 return -ENODEV;
 122         }
 123
 124         /* Try "cpu0" for older DTs */
 125         if (!cpu)
 126                 reg = reg_cpu0;
 127         else
 128                 reg = reg_cpu;
 129
 130 try_again:
 131         cpu_reg = regulator_get_optional(cpu_dev, reg);
 132         if (IS_ERR(cpu_reg)) {
 133                 /*
 134                  * If cpu's regulator supply node is present, but regulator is
 135                  * not yet registered, we should try defering probe.
 136                  */
 137                 if (PTR_ERR(cpu_reg) == -EPROBE_DEFER) {
 138                         dev_dbg(cpu_dev, "cpu%d regulator not ready, retry\n",
 139                                 cpu);
 140                         return -EPROBE_DEFER;
 141                 }
 142
 143                 /* Try with "cpu-supply" */
 144                 if (reg == reg_cpu0) {
 145                         reg = reg_cpu;
 146                         goto try_again;
 147                 }
 148
 149                 dev_warn(cpu_dev, "failed to get cpu%d regulator: %ld\n",
 150                          cpu, PTR_ERR(cpu_reg));
 151         }
 152
 153         cpu_clk = clk_get(cpu_dev, NULL);
 154         if (IS_ERR(cpu_clk)) {
 155                 /* put regulator */
 156                 if (!IS_ERR(cpu_reg))
 157                         regulator_put(cpu_reg);
 158
 159                 ret = PTR_ERR(cpu_clk);
 160
 161                 /*
 162                  * If cpu's clk node is present, but clock is not yet
 163                  * registered, we should try defering probe.
 164                  */
 165                 if (ret == -EPROBE_DEFER)
 166                         dev_dbg(cpu_dev, "cpu%d clock not ready, retry\n", cpu);
 167                 else
 168                         dev_err(cpu_dev, "failed to get cpu%d clock: %d\n", ret,
 169                                 cpu);
 170         } else {
 171                 *cdev = cpu_dev;
 172                 *creg = cpu_reg;
 173                 *cclk = cpu_clk;
 174         }
 175
 176         return ret;
 177 }
 178
 179 static int cpufreq_init(struct cpufreq_policy *policy)
 180 {
 181         struct cpufreq_frequency_table *freq_table;
 182         struct thermal_cooling_device *cdev;
 183         struct device_node *np;
 184         struct private_data *priv;
 185         struct device *cpu_dev;
 186         struct regulator *cpu_reg;
 187         struct clk *cpu_clk;
 188         unsigned int transition_latency;
 189         int ret;
 190
 191         ret = allocate_resources(policy->cpu, &cpu_dev, &cpu_reg, &cpu_clk);
 192         if (ret) {
 193                 pr_err("%s: Failed to allocate resources\n: %d", __func__, ret);
 194                 return ret;
 195         }
 196
 197         np = of_node_get(cpu_dev->of_node);
 198         if (!np) {
 199                 dev_err(cpu_dev, "failed to find cpu%d node\n", policy->cpu);
 200                 ret = -ENOENT;
 201                 goto out_put_reg_clk;
 202         }
 203
 204         /* OPPs might be populated at runtime, don't check for error here */
 205         of_init_opp_table(cpu_dev);
 206
 207         ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
 208         if (ret) {
 209                 dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
 210                 goto out_put_node;
 211         }
 212
 213         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 214         if (!priv) {
 215                 ret = -ENOMEM;
 216                 goto out_free_table;
 217         }
 218
 219         of_property_read_u32(np, "voltage-tolerance", &priv->voltage_tolerance);
 220
 221         if (of_property_read_u32(np, "clock-latency", &transition_latency))
 222                 transition_latency = CPUFREQ_ETERNAL;
 223
 224         if (!IS_ERR(cpu_reg)) {
 225                 struct dev_pm_opp *opp;
 226                 unsigned long min_uV, max_uV;
 227                 int i;
 228
 229                 /*
 230                  * OPP is maintained in order of increasing frequency, and
 231                  * freq_table initialised from OPP is therefore sorted in the
 232                  * same order.
 233                  */
 234                 for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++)
 235                         ;
 236                 rcu_read_lock();
 237                 opp = dev_pm_opp_find_freq_exact(cpu_dev,
 238                                 freq_table[0].frequency * 1000, true);
 239                 min_uV = dev_pm_opp_get_voltage(opp);
 240                 opp = dev_pm_opp_find_freq_exact(cpu_dev,
 241                                 freq_table[i-1].frequency * 1000, true);
 242                 max_uV = dev_pm_opp_get_voltage(opp);
 243                 rcu_read_unlock();
 244                 ret = regulator_set_voltage_time(cpu_reg, min_uV, max_uV);
 245                 if (ret > 0)
 246                         transition_latency += ret * 1000;
 247         }
 248
 249         /*
 250          * For now, just loading the cooling device;
 251          * thermal DT code takes care of matching them.
 252          */
 253         if (of_find_property(np, "#cooling-cells", NULL)) {
 254                 cdev = of_cpufreq_cooling_register(np, cpu_present_mask);
 255                 if (IS_ERR(cdev))
 256                         dev_err(cpu_dev,
 257                                 "running cpufreq without cooling device: %ld\n",
 258                                 PTR_ERR(cdev));
 259                 else
 260                         priv->cdev = cdev;
 261         }
 262
 263         priv->cpu_dev = cpu_dev;
 264         priv->cpu_reg = cpu_reg;
 265         policy->driver_data = priv;
 266
 267         policy->clk = cpu_clk;
 268         ret = cpufreq_generic_init(policy, freq_table, transition_latency);
 269         if (ret)
 270                 goto out_cooling_unregister;
 271
 272         of_node_put(np);
 273
 274         return 0;
 275
 276 out_cooling_unregister:
 277         cpufreq_cooling_unregister(priv->cdev);
 278         kfree(priv);
 279 out_free_table:
 280         dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
 281 out_put_node:
 282         of_node_put(np);
 283 out_put_reg_clk:
 284         clk_put(cpu_clk);
 285         if (!IS_ERR(cpu_reg))
 286                 regulator_put(cpu_reg);
 287
 288         return ret;
 289 }
 290
 291 static int cpufreq_exit(struct cpufreq_policy *policy)
 292 {
 293         struct private_data *priv = policy->driver_data;
 294
 295         cpufreq_cooling_unregister(priv->cdev);
 296         dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
 297         clk_put(policy->clk);
 298         if (!IS_ERR(priv->cpu_reg))
 299                 regulator_put(priv->cpu_reg);
 300         kfree(priv);
 301
 302         return 0;
 303 }
 304
 305 static struct cpufreq_driver dt_cpufreq_driver = {
 306         .flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK,
 307         .verify = cpufreq_generic_frequency_table_verify,
 308         .target_index = set_target,
 309         .get = cpufreq_generic_get,
 310         .init = cpufreq_init,
 311         .exit = cpufreq_exit,
 312         .name = "cpufreq-dt",
 313         .attr = cpufreq_generic_attr,
 314 };
 315
 316 static int dt_cpufreq_probe(struct platform_device *pdev)
 317 {
 318         struct device *cpu_dev;
 319         struct regulator *cpu_reg;
 320         struct clk *cpu_clk;
 321         int ret;
 322
 323         /*
 324          * All per-cluster (CPUs sharing clock/voltages) initialization is done
 325          * from ->init(). In probe(), we just need to make sure that clk and
 326          * regulators are available. Else defer probe and retry.
 327          *
 328          * FIXME: Is checking this only for CPU0 sufficient ?
 329          */
 330         ret = allocate_resources(0, &cpu_dev, &cpu_reg, &cpu_clk);
 331         if (ret)
 332                 return ret;
 333
 334         clk_put(cpu_clk);
 335         if (!IS_ERR(cpu_reg))
 336                 regulator_put(cpu_reg);
 337
 338         ret = cpufreq_register_driver(&dt_cpufreq_driver);
 339         if (ret)
 340                 dev_err(cpu_dev, "failed register driver: %d\n", ret);
 341
 342         return ret;
 343 }
 344
 345 static int dt_cpufreq_remove(struct platform_device *pdev)
 346 {
 347         cpufreq_unregister_driver(&dt_cpufreq_driver);
 348         return 0;
 349 }
 350
 351 static struct platform_driver dt_cpufreq_platdrv = {
 352         .driver = {
 353                 .name   = "cpufreq-dt",
 354                 .owner  = THIS_MODULE,
 355         },
 356         .probe          = dt_cpufreq_probe,
 357         .remove         = dt_cpufreq_remove,
 358 };
 359 module_platform_driver(dt_cpufreq_platdrv);
 360
 361 MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
 362 MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
 363 MODULE_DESCRIPTION("Generic cpufreq driver");
 364 MODULE_LICENSE("GPL");