1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * CPU frequency scaling for OMAP using OPP information 4 * 5 * Copyright (C) 2005 Nokia Corporation 6 * Written by Tony Lindgren <tony@atomide.com> 7 * 8 * Based on cpu-sa1110.c, Copyright (C) 2001 Russell King 9 * 10 * Copyright (C) 2007-2011 Texas Instruments, Inc. 11 * - OMAP3/4 support by Rajendra Nayak, Santosh Shilimkar 12 */ 13 14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 16 #include <linux/types.h> 17 #include <linux/kernel.h> 18 #include <linux/sched.h> 19 #include <linux/cpufreq.h> 20 #include <linux/delay.h> 21 #include <linux/init.h> 22 #include <linux/err.h> 23 #include <linux/clk.h> 24 #include <linux/io.h> 25 #include <linux/pm_opp.h> 26 #include <linux/cpu.h> 27 #include <linux/module.h> 28 #include <linux/platform_device.h> 29 #include <linux/regulator/consumer.h> 30 31 #include <asm/smp_plat.h> 32 #include <asm/cpu.h> 33 34 /* OPP tolerance in percentage */ 35 #define OPP_TOLERANCE 4 36 37 static struct cpufreq_frequency_table *freq_table; 38 static atomic_t freq_table_users = ATOMIC_INIT(0); 39 static struct device *mpu_dev; 40 static struct regulator *mpu_reg; 41 42 static int omap_target(struct cpufreq_policy *policy, unsigned int index) 43 { 44 int r, ret; 45 struct dev_pm_opp *opp; 46 unsigned long freq, volt = 0, volt_old = 0, tol = 0; 47 unsigned int old_freq, new_freq; 48 49 old_freq = policy->cur; 50 new_freq = freq_table[index].frequency; 51 52 freq = new_freq * 1000; 53 ret = clk_round_rate(policy->clk, freq); 54 if (ret < 0) { 55 dev_warn(mpu_dev, 56 "CPUfreq: Cannot find matching frequency for %lu\n", 57 freq); 58 return ret; 59 } 60 freq = ret; 61 62 if (mpu_reg) { 63 opp = dev_pm_opp_find_freq_ceil(mpu_dev, &freq); 64 if (IS_ERR(opp)) { 65 dev_err(mpu_dev, "%s: unable to find MPU OPP for %d\n", 66 __func__, new_freq); 67 return -EINVAL; 68 } 69 volt = dev_pm_opp_get_voltage(opp); 70 dev_pm_opp_put(opp); 71 tol = volt * OPP_TOLERANCE / 100; 72 volt_old = regulator_get_voltage(mpu_reg); 73 } 74 75 dev_dbg(mpu_dev, "cpufreq-omap: %u MHz, %ld mV --> %u MHz, %ld mV\n", 76 old_freq / 1000, volt_old ? volt_old / 1000 : -1, 77 new_freq / 1000, volt ? volt / 1000 : -1); 78 79 /* scaling up? scale voltage before frequency */ 80 if (mpu_reg && (new_freq > old_freq)) { 81 r = regulator_set_voltage(mpu_reg, volt - tol, volt + tol); 82 if (r < 0) { 83 dev_warn(mpu_dev, "%s: unable to scale voltage up.\n", 84 __func__); 85 return r; 86 } 87 } 88 89 ret = clk_set_rate(policy->clk, new_freq * 1000); 90 91 /* scaling down? scale voltage after frequency */ 92 if (mpu_reg && (new_freq < old_freq)) { 93 r = regulator_set_voltage(mpu_reg, volt - tol, volt + tol); 94 if (r < 0) { 95 dev_warn(mpu_dev, "%s: unable to scale voltage down.\n", 96 __func__); 97 clk_set_rate(policy->clk, old_freq * 1000); 98 return r; 99 } 100 } 101 102 return ret; 103 } 104 105 static inline void freq_table_free(void) 106 { 107 if (atomic_dec_and_test(&freq_table_users)) 108 dev_pm_opp_free_cpufreq_table(mpu_dev, &freq_table); 109 } 110 111 static int omap_cpu_init(struct cpufreq_policy *policy) 112 { 113 int result; 114 115 policy->clk = clk_get(NULL, "cpufreq_ck"); 116 if (IS_ERR(policy->clk)) 117 return PTR_ERR(policy->clk); 118 119 if (!freq_table) { 120 result = dev_pm_opp_init_cpufreq_table(mpu_dev, &freq_table); 121 if (result) { 122 dev_err(mpu_dev, 123 "%s: cpu%d: failed creating freq table[%d]\n", 124 __func__, policy->cpu, result); 125 goto fail; 126 } 127 } 128 129 atomic_inc_return(&freq_table_users); 130 131 /* FIXME: what's the actual transition time? */ 132 result = cpufreq_generic_init(policy, freq_table, 300 * 1000); 133 if (!result) { 134 dev_pm_opp_of_register_em(policy->cpus); 135 return 0; 136 } 137 138 freq_table_free(); 139 fail: 140 clk_put(policy->clk); 141 return result; 142 } 143 144 static int omap_cpu_exit(struct cpufreq_policy *policy) 145 { 146 freq_table_free(); 147 clk_put(policy->clk); 148 return 0; 149 } 150 151 static struct cpufreq_driver omap_driver = { 152 .flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK, 153 .verify = cpufreq_generic_frequency_table_verify, 154 .target_index = omap_target, 155 .get = cpufreq_generic_get, 156 .init = omap_cpu_init, 157 .exit = omap_cpu_exit, 158 .name = "omap", 159 .attr = cpufreq_generic_attr, 160 }; 161 162 static int omap_cpufreq_probe(struct platform_device *pdev) 163 { 164 mpu_dev = get_cpu_device(0); 165 if (!mpu_dev) { 166 pr_warn("%s: unable to get the MPU device\n", __func__); 167 return -EINVAL; 168 } 169 170 mpu_reg = regulator_get(mpu_dev, "vcc"); 171 if (IS_ERR(mpu_reg)) { 172 pr_warn("%s: unable to get MPU regulator\n", __func__); 173 mpu_reg = NULL; 174 } else { 175 /* 176 * Ensure physical regulator is present. 177 * (e.g. could be dummy regulator.) 178 */ 179 if (regulator_get_voltage(mpu_reg) < 0) { 180 pr_warn("%s: physical regulator not present for MPU\n", 181 __func__); 182 regulator_put(mpu_reg); 183 mpu_reg = NULL; 184 } 185 } 186 187 return cpufreq_register_driver(&omap_driver); 188 } 189 190 static int omap_cpufreq_remove(struct platform_device *pdev) 191 { 192 return cpufreq_unregister_driver(&omap_driver); 193 } 194 195 static struct platform_driver omap_cpufreq_platdrv = { 196 .driver = { 197 .name = "omap-cpufreq", 198 }, 199 .probe = omap_cpufreq_probe, 200 .remove = omap_cpufreq_remove, 201 }; 202 module_platform_driver(omap_cpufreq_platdrv); 203 204 MODULE_DESCRIPTION("cpufreq driver for OMAP SoCs"); 205 MODULE_LICENSE("GPL"); 206