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"); 365