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/list.h> 17 #include <linux/module.h> 18 #include <linux/of.h> 19 #include <linux/pm_opp.h> 20 #include <linux/platform_device.h> 21 #include <linux/regulator/consumer.h> 22 #include <linux/slab.h> 23 #include <linux/thermal.h> 24 25 #include "cpufreq-dt.h" 26 27 struct private_data { 28 struct list_head node; 29 30 cpumask_var_t cpus; 31 struct device *cpu_dev; 32 struct cpufreq_frequency_table *freq_table; 33 bool have_static_opps; 34 int opp_token; 35 }; 36 37 static LIST_HEAD(priv_list); 38 39 static struct private_data *cpufreq_dt_find_data(int cpu) 40 { 41 struct private_data *priv; 42 43 list_for_each_entry(priv, &priv_list, node) { 44 if (cpumask_test_cpu(cpu, priv->cpus)) 45 return priv; 46 } 47 48 return NULL; 49 } 50 51 static int set_target(struct cpufreq_policy *policy, unsigned int index) 52 { 53 struct private_data *priv = policy->driver_data; 54 unsigned long freq = policy->freq_table[index].frequency; 55 56 return dev_pm_opp_set_rate(priv->cpu_dev, freq * 1000); 57 } 58 59 /* 60 * An earlier version of opp-v1 bindings used to name the regulator 61 * "cpu0-supply", we still need to handle that for backwards compatibility. 62 */ 63 static const char *find_supply_name(struct device *dev) 64 { 65 struct device_node *np __free(device_node) = of_node_get(dev->of_node); 66 int cpu = dev->id; 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 && of_property_present(np, "cpu0-supply")) 74 return "cpu0"; 75 76 if (of_property_present(np, "cpu-supply")) 77 return "cpu"; 78 79 dev_dbg(dev, "no regulator for cpu%d\n", cpu); 80 return NULL; 81 } 82 83 static int cpufreq_init(struct cpufreq_policy *policy) 84 { 85 struct private_data *priv; 86 struct device *cpu_dev; 87 struct clk *cpu_clk; 88 unsigned int transition_latency; 89 int ret; 90 91 priv = cpufreq_dt_find_data(policy->cpu); 92 if (!priv) { 93 pr_err("failed to find data for cpu%d\n", policy->cpu); 94 return -ENODEV; 95 } 96 cpu_dev = priv->cpu_dev; 97 98 cpu_clk = clk_get(cpu_dev, NULL); 99 if (IS_ERR(cpu_clk)) { 100 ret = PTR_ERR(cpu_clk); 101 dev_err(cpu_dev, "%s: failed to get clk: %d\n", __func__, ret); 102 return ret; 103 } 104 105 transition_latency = dev_pm_opp_get_max_transition_latency(cpu_dev); 106 if (!transition_latency) 107 transition_latency = CPUFREQ_ETERNAL; 108 109 cpumask_copy(policy->cpus, priv->cpus); 110 policy->driver_data = priv; 111 policy->clk = cpu_clk; 112 policy->freq_table = priv->freq_table; 113 policy->suspend_freq = dev_pm_opp_get_suspend_opp_freq(cpu_dev) / 1000; 114 policy->cpuinfo.transition_latency = transition_latency; 115 policy->dvfs_possible_from_any_cpu = true; 116 117 return 0; 118 } 119 120 static int cpufreq_online(struct cpufreq_policy *policy) 121 { 122 /* We did light-weight tear down earlier, nothing to do here */ 123 return 0; 124 } 125 126 static int cpufreq_offline(struct cpufreq_policy *policy) 127 { 128 /* 129 * Preserve policy->driver_data and don't free resources on light-weight 130 * tear down. 131 */ 132 return 0; 133 } 134 135 static void cpufreq_exit(struct cpufreq_policy *policy) 136 { 137 clk_put(policy->clk); 138 } 139 140 static struct cpufreq_driver dt_cpufreq_driver = { 141 .flags = CPUFREQ_NEED_INITIAL_FREQ_CHECK | 142 CPUFREQ_IS_COOLING_DEV, 143 .verify = cpufreq_generic_frequency_table_verify, 144 .target_index = set_target, 145 .get = cpufreq_generic_get, 146 .init = cpufreq_init, 147 .exit = cpufreq_exit, 148 .online = cpufreq_online, 149 .offline = cpufreq_offline, 150 .register_em = cpufreq_register_em_with_opp, 151 .name = "cpufreq-dt", 152 .set_boost = cpufreq_boost_set_sw, 153 .suspend = cpufreq_generic_suspend, 154 }; 155 156 static int dt_cpufreq_early_init(struct device *dev, int cpu) 157 { 158 struct private_data *priv; 159 struct device *cpu_dev; 160 bool fallback = false; 161 const char *reg_name[] = { NULL, NULL }; 162 int ret; 163 164 /* Check if this CPU is already covered by some other policy */ 165 if (cpufreq_dt_find_data(cpu)) 166 return 0; 167 168 cpu_dev = get_cpu_device(cpu); 169 if (!cpu_dev) 170 return -EPROBE_DEFER; 171 172 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 173 if (!priv) 174 return -ENOMEM; 175 176 if (!zalloc_cpumask_var(&priv->cpus, GFP_KERNEL)) 177 return -ENOMEM; 178 179 cpumask_set_cpu(cpu, priv->cpus); 180 priv->cpu_dev = cpu_dev; 181 182 /* 183 * OPP layer will be taking care of regulators now, but it needs to know 184 * the name of the regulator first. 185 */ 186 reg_name[0] = find_supply_name(cpu_dev); 187 if (reg_name[0]) { 188 priv->opp_token = dev_pm_opp_set_regulators(cpu_dev, reg_name); 189 if (priv->opp_token < 0) { 190 ret = dev_err_probe(cpu_dev, priv->opp_token, 191 "failed to set regulators\n"); 192 goto free_cpumask; 193 } 194 } 195 196 /* Get OPP-sharing information from "operating-points-v2" bindings */ 197 ret = dev_pm_opp_of_get_sharing_cpus(cpu_dev, priv->cpus); 198 if (ret) { 199 if (ret != -ENOENT) 200 goto out; 201 202 /* 203 * operating-points-v2 not supported, fallback to all CPUs share 204 * OPP for backward compatibility if the platform hasn't set 205 * sharing CPUs. 206 */ 207 if (dev_pm_opp_get_sharing_cpus(cpu_dev, priv->cpus)) 208 fallback = true; 209 } 210 211 /* 212 * Initialize OPP tables for all priv->cpus. They will be shared by 213 * all CPUs which have marked their CPUs shared with OPP bindings. 214 * 215 * For platforms not using operating-points-v2 bindings, we do this 216 * before updating priv->cpus. Otherwise, we will end up creating 217 * duplicate OPPs for the CPUs. 218 * 219 * OPPs might be populated at runtime, don't fail for error here unless 220 * it is -EPROBE_DEFER. 221 */ 222 ret = dev_pm_opp_of_cpumask_add_table(priv->cpus); 223 if (!ret) { 224 priv->have_static_opps = true; 225 } else if (ret == -EPROBE_DEFER) { 226 goto out; 227 } 228 229 /* 230 * The OPP table must be initialized, statically or dynamically, by this 231 * point. 232 */ 233 ret = dev_pm_opp_get_opp_count(cpu_dev); 234 if (ret <= 0) { 235 dev_err(cpu_dev, "OPP table can't be empty\n"); 236 ret = -ENODEV; 237 goto out; 238 } 239 240 if (fallback) { 241 cpumask_setall(priv->cpus); 242 ret = dev_pm_opp_set_sharing_cpus(cpu_dev, priv->cpus); 243 if (ret) 244 dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n", 245 __func__, ret); 246 } 247 248 ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &priv->freq_table); 249 if (ret) { 250 dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret); 251 goto out; 252 } 253 254 list_add(&priv->node, &priv_list); 255 return 0; 256 257 out: 258 if (priv->have_static_opps) 259 dev_pm_opp_of_cpumask_remove_table(priv->cpus); 260 dev_pm_opp_put_regulators(priv->opp_token); 261 free_cpumask: 262 free_cpumask_var(priv->cpus); 263 return ret; 264 } 265 266 static void dt_cpufreq_release(void) 267 { 268 struct private_data *priv, *tmp; 269 270 list_for_each_entry_safe(priv, tmp, &priv_list, node) { 271 dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &priv->freq_table); 272 if (priv->have_static_opps) 273 dev_pm_opp_of_cpumask_remove_table(priv->cpus); 274 dev_pm_opp_put_regulators(priv->opp_token); 275 free_cpumask_var(priv->cpus); 276 list_del(&priv->node); 277 } 278 } 279 280 static int dt_cpufreq_probe(struct platform_device *pdev) 281 { 282 struct cpufreq_dt_platform_data *data = dev_get_platdata(&pdev->dev); 283 int ret, cpu; 284 285 /* Request resources early so we can return in case of -EPROBE_DEFER */ 286 for_each_present_cpu(cpu) { 287 ret = dt_cpufreq_early_init(&pdev->dev, cpu); 288 if (ret) 289 goto err; 290 } 291 292 if (data) { 293 if (data->have_governor_per_policy) 294 dt_cpufreq_driver.flags |= CPUFREQ_HAVE_GOVERNOR_PER_POLICY; 295 296 dt_cpufreq_driver.resume = data->resume; 297 if (data->suspend) 298 dt_cpufreq_driver.suspend = data->suspend; 299 if (data->get_intermediate) { 300 dt_cpufreq_driver.target_intermediate = data->target_intermediate; 301 dt_cpufreq_driver.get_intermediate = data->get_intermediate; 302 } 303 } 304 305 ret = cpufreq_register_driver(&dt_cpufreq_driver); 306 if (ret) { 307 dev_err(&pdev->dev, "failed register driver: %d\n", ret); 308 goto err; 309 } 310 311 return 0; 312 err: 313 dt_cpufreq_release(); 314 return ret; 315 } 316 317 static void dt_cpufreq_remove(struct platform_device *pdev) 318 { 319 cpufreq_unregister_driver(&dt_cpufreq_driver); 320 dt_cpufreq_release(); 321 } 322 323 static struct platform_driver dt_cpufreq_platdrv = { 324 .driver = { 325 .name = "cpufreq-dt", 326 }, 327 .probe = dt_cpufreq_probe, 328 .remove = dt_cpufreq_remove, 329 }; 330 module_platform_driver(dt_cpufreq_platdrv); 331 332 MODULE_ALIAS("platform:cpufreq-dt"); 333 MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>"); 334 MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>"); 335 MODULE_DESCRIPTION("Generic cpufreq driver"); 336 MODULE_LICENSE("GPL"); 337