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 if (data->get_intermediate) { 367 dt_cpufreq_driver.target_intermediate = data->target_intermediate; 368 dt_cpufreq_driver.get_intermediate = data->get_intermediate; 369 } 370 } 371 372 ret = cpufreq_register_driver(&dt_cpufreq_driver); 373 if (ret) 374 dev_err(&pdev->dev, "failed register driver: %d\n", ret); 375 376 return ret; 377 } 378 379 static int dt_cpufreq_remove(struct platform_device *pdev) 380 { 381 cpufreq_unregister_driver(&dt_cpufreq_driver); 382 return 0; 383 } 384 385 static struct platform_driver dt_cpufreq_platdrv = { 386 .driver = { 387 .name = "cpufreq-dt", 388 }, 389 .probe = dt_cpufreq_probe, 390 .remove = dt_cpufreq_remove, 391 }; 392 module_platform_driver(dt_cpufreq_platdrv); 393 394 MODULE_ALIAS("platform:cpufreq-dt"); 395 MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>"); 396 MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>"); 397 MODULE_DESCRIPTION("Generic cpufreq driver"); 398 MODULE_LICENSE("GPL"); 399