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 		dev_pm_opp_of_register_em(policy->cpus);
138 		return 0;
139 	}
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