2 * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
3 * http://www.samsung.com
5 * EXYNOS - CPU frequency scaling support for EXYNOS series
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/kernel.h>
13 #include <linux/err.h>
14 #include <linux/clk.h>
16 #include <linux/slab.h>
17 #include <linux/regulator/consumer.h>
18 #include <linux/cpufreq.h>
19 #include <linux/suspend.h>
23 #include "exynos-cpufreq.h"
25 static struct exynos_dvfs_info *exynos_info;
27 static struct regulator *arm_regulator;
29 static unsigned int locking_frequency;
30 static bool frequency_locked;
31 static DEFINE_MUTEX(cpufreq_lock);
33 static unsigned int exynos_getspeed(unsigned int cpu)
35 return clk_get_rate(exynos_info->cpu_clk) / 1000;
38 static int exynos_cpufreq_get_index(unsigned int freq)
40 struct cpufreq_frequency_table *freq_table = exynos_info->freq_table;
44 freq_table[index].frequency != CPUFREQ_TABLE_END; index++)
45 if (freq_table[index].frequency == freq)
48 if (freq_table[index].frequency == CPUFREQ_TABLE_END)
54 static int exynos_cpufreq_scale(unsigned int target_freq)
56 struct cpufreq_frequency_table *freq_table = exynos_info->freq_table;
57 unsigned int *volt_table = exynos_info->volt_table;
58 struct cpufreq_policy *policy = cpufreq_cpu_get(0);
59 unsigned int arm_volt, safe_arm_volt = 0;
60 unsigned int mpll_freq_khz = exynos_info->mpll_freq_khz;
61 unsigned int old_freq;
65 old_freq = policy->cur;
68 * The policy max have been changed so that we cannot get proper
69 * old_index with cpufreq_frequency_table_target(). Thus, ignore
70 * policy and get the index from the raw frequency table.
72 old_index = exynos_cpufreq_get_index(old_freq);
78 index = exynos_cpufreq_get_index(target_freq);
85 * ARM clock source will be changed APLL to MPLL temporary
86 * To support this level, need to control regulator for
87 * required voltage level
89 if (exynos_info->need_apll_change != NULL) {
90 if (exynos_info->need_apll_change(old_index, index) &&
91 (freq_table[index].frequency < mpll_freq_khz) &&
92 (freq_table[old_index].frequency < mpll_freq_khz))
93 safe_arm_volt = volt_table[exynos_info->pll_safe_idx];
95 arm_volt = volt_table[index];
97 /* When the new frequency is higher than current frequency */
98 if ((target_freq > old_freq) && !safe_arm_volt) {
99 /* Firstly, voltage up to increase frequency */
100 ret = regulator_set_voltage(arm_regulator, arm_volt, arm_volt);
102 pr_err("%s: failed to set cpu voltage to %d\n",
109 ret = regulator_set_voltage(arm_regulator, safe_arm_volt,
112 pr_err("%s: failed to set cpu voltage to %d\n",
113 __func__, safe_arm_volt);
118 exynos_info->set_freq(old_index, index);
120 /* When the new frequency is lower than current frequency */
121 if ((target_freq < old_freq) ||
122 ((target_freq > old_freq) && safe_arm_volt)) {
123 /* down the voltage after frequency change */
124 ret = regulator_set_voltage(arm_regulator, arm_volt,
127 pr_err("%s: failed to set cpu voltage to %d\n",
134 cpufreq_cpu_put(policy);
139 static int exynos_target(struct cpufreq_policy *policy, unsigned int index)
141 struct cpufreq_frequency_table *freq_table = exynos_info->freq_table;
144 mutex_lock(&cpufreq_lock);
146 if (frequency_locked)
149 ret = exynos_cpufreq_scale(freq_table[index].frequency);
152 mutex_unlock(&cpufreq_lock);
158 static int exynos_cpufreq_suspend(struct cpufreq_policy *policy)
163 static int exynos_cpufreq_resume(struct cpufreq_policy *policy)
170 * exynos_cpufreq_pm_notifier - block CPUFREQ's activities in suspend-resume
176 * While frequency_locked == true, target() ignores every frequency but
177 * locking_frequency. The locking_frequency value is the initial frequency,
178 * which is set by the bootloader. In order to eliminate possible
179 * inconsistency in clock values, we save and restore frequencies during
180 * suspend and resume and block CPUFREQ activities. Note that the standard
181 * suspend/resume cannot be used as they are too deep (syscore_ops) for
184 static int exynos_cpufreq_pm_notifier(struct notifier_block *notifier,
185 unsigned long pm_event, void *v)
190 case PM_SUSPEND_PREPARE:
191 mutex_lock(&cpufreq_lock);
192 frequency_locked = true;
193 mutex_unlock(&cpufreq_lock);
195 ret = exynos_cpufreq_scale(locking_frequency);
201 case PM_POST_SUSPEND:
202 mutex_lock(&cpufreq_lock);
203 frequency_locked = false;
204 mutex_unlock(&cpufreq_lock);
211 static struct notifier_block exynos_cpufreq_nb = {
212 .notifier_call = exynos_cpufreq_pm_notifier,
215 static int exynos_cpufreq_cpu_init(struct cpufreq_policy *policy)
217 return cpufreq_generic_init(policy, exynos_info->freq_table, 100000);
220 static struct cpufreq_driver exynos_driver = {
221 .flags = CPUFREQ_STICKY,
222 .verify = cpufreq_generic_frequency_table_verify,
223 .target_index = exynos_target,
224 .get = exynos_getspeed,
225 .init = exynos_cpufreq_cpu_init,
226 .exit = cpufreq_generic_exit,
227 .name = "exynos_cpufreq",
228 .attr = cpufreq_generic_attr,
230 .suspend = exynos_cpufreq_suspend,
231 .resume = exynos_cpufreq_resume,
235 static int __init exynos_cpufreq_init(void)
239 exynos_info = kzalloc(sizeof(*exynos_info), GFP_KERNEL);
243 if (soc_is_exynos4210())
244 ret = exynos4210_cpufreq_init(exynos_info);
245 else if (soc_is_exynos4212() || soc_is_exynos4412())
246 ret = exynos4x12_cpufreq_init(exynos_info);
247 else if (soc_is_exynos5250())
248 ret = exynos5250_cpufreq_init(exynos_info);
255 if (exynos_info->set_freq == NULL) {
256 pr_err("%s: No set_freq function (ERR)\n", __func__);
260 arm_regulator = regulator_get(NULL, "vdd_arm");
261 if (IS_ERR(arm_regulator)) {
262 pr_err("%s: failed to get resource vdd_arm\n", __func__);
266 locking_frequency = exynos_getspeed(0);
268 register_pm_notifier(&exynos_cpufreq_nb);
270 if (cpufreq_register_driver(&exynos_driver)) {
271 pr_err("%s: failed to register cpufreq driver\n", __func__);
277 unregister_pm_notifier(&exynos_cpufreq_nb);
279 regulator_put(arm_regulator);
284 late_initcall(exynos_cpufreq_init);