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