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
;
28 static struct cpufreq_freqs freqs
;
30 static unsigned int locking_frequency
;
31 static bool frequency_locked
;
32 static DEFINE_MUTEX(cpufreq_lock
);
34 static unsigned int exynos_getspeed(unsigned int cpu
)
36 return clk_get_rate(exynos_info
->cpu_clk
) / 1000;
39 static int exynos_cpufreq_get_index(unsigned int freq
)
41 struct cpufreq_frequency_table
*freq_table
= exynos_info
->freq_table
;
45 freq_table
[index
].frequency
!= CPUFREQ_TABLE_END
; index
++)
46 if (freq_table
[index
].frequency
== freq
)
49 if (freq_table
[index
].frequency
== CPUFREQ_TABLE_END
)
55 static int exynos_cpufreq_scale(unsigned int target_freq
)
57 struct cpufreq_frequency_table
*freq_table
= exynos_info
->freq_table
;
58 unsigned int *volt_table
= exynos_info
->volt_table
;
59 struct cpufreq_policy
*policy
= cpufreq_cpu_get(0);
60 unsigned int arm_volt
, safe_arm_volt
= 0;
61 unsigned int mpll_freq_khz
= exynos_info
->mpll_freq_khz
;
65 freqs
.old
= policy
->cur
;
66 freqs
.new = target_freq
;
69 * The policy max have been changed so that we cannot get proper
70 * old_index with cpufreq_frequency_table_target(). Thus, ignore
71 * policy and get the index from the raw freqeuncy table.
73 old_index
= exynos_cpufreq_get_index(freqs
.old
);
79 index
= exynos_cpufreq_get_index(target_freq
);
86 * ARM clock source will be changed APLL to MPLL temporary
87 * To support this level, need to control regulator for
88 * required voltage level
90 if (exynos_info
->need_apll_change
!= NULL
) {
91 if (exynos_info
->need_apll_change(old_index
, index
) &&
92 (freq_table
[index
].frequency
< mpll_freq_khz
) &&
93 (freq_table
[old_index
].frequency
< mpll_freq_khz
))
94 safe_arm_volt
= volt_table
[exynos_info
->pll_safe_idx
];
96 arm_volt
= volt_table
[index
];
98 cpufreq_notify_transition(policy
, &freqs
, CPUFREQ_PRECHANGE
);
100 /* When the new frequency is higher than current frequency */
101 if ((freqs
.new > freqs
.old
) && !safe_arm_volt
) {
102 /* Firstly, voltage up to increase frequency */
103 ret
= regulator_set_voltage(arm_regulator
, arm_volt
, arm_volt
);
105 pr_err("%s: failed to set cpu voltage to %d\n",
107 freqs
.new = freqs
.old
;
113 ret
= regulator_set_voltage(arm_regulator
, safe_arm_volt
,
116 pr_err("%s: failed to set cpu voltage to %d\n",
117 __func__
, safe_arm_volt
);
118 freqs
.new = freqs
.old
;
123 exynos_info
->set_freq(old_index
, index
);
126 cpufreq_notify_transition(policy
, &freqs
, CPUFREQ_POSTCHANGE
);
131 /* When the new frequency is lower than current frequency */
132 if ((freqs
.new < freqs
.old
) ||
133 ((freqs
.new > freqs
.old
) && safe_arm_volt
)) {
134 /* down the voltage after frequency change */
135 ret
= regulator_set_voltage(arm_regulator
, arm_volt
,
138 pr_err("%s: failed to set cpu voltage to %d\n",
146 cpufreq_cpu_put(policy
);
151 static int exynos_target(struct cpufreq_policy
*policy
, unsigned int index
)
153 struct cpufreq_frequency_table
*freq_table
= exynos_info
->freq_table
;
156 mutex_lock(&cpufreq_lock
);
158 if (frequency_locked
)
161 ret
= exynos_cpufreq_scale(freq_table
[index
].frequency
);
164 mutex_unlock(&cpufreq_lock
);
170 static int exynos_cpufreq_suspend(struct cpufreq_policy
*policy
)
175 static int exynos_cpufreq_resume(struct cpufreq_policy
*policy
)
182 * exynos_cpufreq_pm_notifier - block CPUFREQ's activities in suspend-resume
188 * While frequency_locked == true, target() ignores every frequency but
189 * locking_frequency. The locking_frequency value is the initial frequency,
190 * which is set by the bootloader. In order to eliminate possible
191 * inconsistency in clock values, we save and restore frequencies during
192 * suspend and resume and block CPUFREQ activities. Note that the standard
193 * suspend/resume cannot be used as they are too deep (syscore_ops) for
196 static int exynos_cpufreq_pm_notifier(struct notifier_block
*notifier
,
197 unsigned long pm_event
, void *v
)
202 case PM_SUSPEND_PREPARE
:
203 mutex_lock(&cpufreq_lock
);
204 frequency_locked
= true;
205 mutex_unlock(&cpufreq_lock
);
207 ret
= exynos_cpufreq_scale(locking_frequency
);
213 case PM_POST_SUSPEND
:
214 mutex_lock(&cpufreq_lock
);
215 frequency_locked
= false;
216 mutex_unlock(&cpufreq_lock
);
223 static struct notifier_block exynos_cpufreq_nb
= {
224 .notifier_call
= exynos_cpufreq_pm_notifier
,
227 static int exynos_cpufreq_cpu_init(struct cpufreq_policy
*policy
)
229 return cpufreq_generic_init(policy
, exynos_info
->freq_table
, 100000);
232 static struct cpufreq_driver exynos_driver
= {
233 .flags
= CPUFREQ_STICKY
,
234 .verify
= cpufreq_generic_frequency_table_verify
,
235 .target_index
= exynos_target
,
236 .get
= exynos_getspeed
,
237 .init
= exynos_cpufreq_cpu_init
,
238 .exit
= cpufreq_generic_exit
,
239 .name
= "exynos_cpufreq",
240 .attr
= cpufreq_generic_attr
,
242 .suspend
= exynos_cpufreq_suspend
,
243 .resume
= exynos_cpufreq_resume
,
247 static int __init
exynos_cpufreq_init(void)
251 exynos_info
= kzalloc(sizeof(*exynos_info
), GFP_KERNEL
);
255 if (soc_is_exynos4210())
256 ret
= exynos4210_cpufreq_init(exynos_info
);
257 else if (soc_is_exynos4212() || soc_is_exynos4412())
258 ret
= exynos4x12_cpufreq_init(exynos_info
);
259 else if (soc_is_exynos5250())
260 ret
= exynos5250_cpufreq_init(exynos_info
);
267 if (exynos_info
->set_freq
== NULL
) {
268 pr_err("%s: No set_freq function (ERR)\n", __func__
);
272 arm_regulator
= regulator_get(NULL
, "vdd_arm");
273 if (IS_ERR(arm_regulator
)) {
274 pr_err("%s: failed to get resource vdd_arm\n", __func__
);
278 locking_frequency
= exynos_getspeed(0);
280 register_pm_notifier(&exynos_cpufreq_nb
);
282 if (cpufreq_register_driver(&exynos_driver
)) {
283 pr_err("%s: failed to register cpufreq driver\n", __func__
);
289 unregister_pm_notifier(&exynos_cpufreq_nb
);
291 regulator_put(arm_regulator
);
296 late_initcall(exynos_cpufreq_init
);