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