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 /* OPP tolerance in percentage */ 32 #define OPP_TOLERANCE 4 33 34 static struct cpufreq_frequency_table *freq_table; 35 static atomic_t freq_table_users = ATOMIC_INIT(0); 36 static struct device *mpu_dev; 37 static struct regulator *mpu_reg; 38 39 static int omap_target(struct cpufreq_policy *policy, unsigned int index) 40 { 41 int r, ret; 42 struct dev_pm_opp *opp; 43 unsigned long freq, volt = 0, volt_old = 0, tol = 0; 44 unsigned int old_freq, new_freq; 45 46 old_freq = policy->cur; 47 new_freq = freq_table[index].frequency; 48 49 freq = new_freq * 1000; 50 ret = clk_round_rate(policy->clk, freq); 51 if (ret < 0) { 52 dev_warn(mpu_dev, 53 "CPUfreq: Cannot find matching frequency for %lu\n", 54 freq); 55 return ret; 56 } 57 freq = ret; 58 59 if (mpu_reg) { 60 opp = dev_pm_opp_find_freq_ceil(mpu_dev, &freq); 61 if (IS_ERR(opp)) { 62 dev_err(mpu_dev, "%s: unable to find MPU OPP for %d\n", 63 __func__, new_freq); 64 return -EINVAL; 65 } 66 volt = dev_pm_opp_get_voltage(opp); 67 dev_pm_opp_put(opp); 68 tol = volt * OPP_TOLERANCE / 100; 69 volt_old = regulator_get_voltage(mpu_reg); 70 } 71 72 dev_dbg(mpu_dev, "cpufreq-omap: %u MHz, %ld mV --> %u MHz, %ld mV\n", 73 old_freq / 1000, volt_old ? volt_old / 1000 : -1, 74 new_freq / 1000, volt ? volt / 1000 : -1); 75 76 /* scaling up? scale voltage before frequency */ 77 if (mpu_reg && (new_freq > old_freq)) { 78 r = regulator_set_voltage(mpu_reg, volt - tol, volt + tol); 79 if (r < 0) { 80 dev_warn(mpu_dev, "%s: unable to scale voltage up.\n", 81 __func__); 82 return r; 83 } 84 } 85 86 ret = clk_set_rate(policy->clk, new_freq * 1000); 87 88 /* scaling down? scale voltage after frequency */ 89 if (mpu_reg && (new_freq < old_freq)) { 90 r = regulator_set_voltage(mpu_reg, volt - tol, volt + tol); 91 if (r < 0) { 92 dev_warn(mpu_dev, "%s: unable to scale voltage down.\n", 93 __func__); 94 clk_set_rate(policy->clk, old_freq * 1000); 95 return r; 96 } 97 } 98 99 return ret; 100 } 101 102 static inline void freq_table_free(void) 103 { 104 if (atomic_dec_and_test(&freq_table_users)) 105 dev_pm_opp_free_cpufreq_table(mpu_dev, &freq_table); 106 } 107 108 static int omap_cpu_init(struct cpufreq_policy *policy) 109 { 110 int result; 111 112 policy->clk = clk_get(NULL, "cpufreq_ck"); 113 if (IS_ERR(policy->clk)) 114 return PTR_ERR(policy->clk); 115 116 if (!freq_table) { 117 result = dev_pm_opp_init_cpufreq_table(mpu_dev, &freq_table); 118 if (result) { 119 dev_err(mpu_dev, 120 "%s: cpu%d: failed creating freq table[%d]\n", 121 __func__, policy->cpu, result); 122 clk_put(policy->clk); 123 return result; 124 } 125 } 126 127 atomic_inc_return(&freq_table_users); 128 129 /* FIXME: what's the actual transition time? */ 130 cpufreq_generic_init(policy, freq_table, 300 * 1000); 131 132 return 0; 133 } 134 135 static void omap_cpu_exit(struct cpufreq_policy *policy) 136 { 137 freq_table_free(); 138 clk_put(policy->clk); 139 } 140 141 static struct cpufreq_driver omap_driver = { 142 .flags = CPUFREQ_NEED_INITIAL_FREQ_CHECK, 143 .verify = cpufreq_generic_frequency_table_verify, 144 .target_index = omap_target, 145 .get = cpufreq_generic_get, 146 .init = omap_cpu_init, 147 .exit = omap_cpu_exit, 148 .register_em = cpufreq_register_em_with_opp, 149 .name = "omap", 150 .attr = cpufreq_generic_attr, 151 }; 152 153 static int omap_cpufreq_probe(struct platform_device *pdev) 154 { 155 mpu_dev = get_cpu_device(0); 156 if (!mpu_dev) { 157 pr_warn("%s: unable to get the MPU device\n", __func__); 158 return -EINVAL; 159 } 160 161 mpu_reg = regulator_get(mpu_dev, "vcc"); 162 if (IS_ERR(mpu_reg)) { 163 pr_warn("%s: unable to get MPU regulator\n", __func__); 164 mpu_reg = NULL; 165 } else { 166 /* 167 * Ensure physical regulator is present. 168 * (e.g. could be dummy regulator.) 169 */ 170 if (regulator_get_voltage(mpu_reg) < 0) { 171 pr_warn("%s: physical regulator not present for MPU\n", 172 __func__); 173 regulator_put(mpu_reg); 174 mpu_reg = NULL; 175 } 176 } 177 178 return cpufreq_register_driver(&omap_driver); 179 } 180 181 static void omap_cpufreq_remove(struct platform_device *pdev) 182 { 183 cpufreq_unregister_driver(&omap_driver); 184 } 185 186 static struct platform_driver omap_cpufreq_platdrv = { 187 .driver = { 188 .name = "omap-cpufreq", 189 }, 190 .probe = omap_cpufreq_probe, 191 .remove = omap_cpufreq_remove, 192 }; 193 module_platform_driver(omap_cpufreq_platdrv); 194 195 MODULE_DESCRIPTION("cpufreq driver for OMAP SoCs"); 196 MODULE_LICENSE("GPL"); 197