Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
1da177e4 LT |
2 | /* |
3 | * linux/drivers/cpufreq/freq_table.c | |
4 | * | |
5 | * Copyright (C) 2002 - 2003 Dominik Brodowski | |
6 | */ | |
7 | ||
db701151 VK |
8 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
9 | ||
1da177e4 | 10 | #include <linux/cpufreq.h> |
5ff0a268 | 11 | #include <linux/module.h> |
1da177e4 | 12 | |
1da177e4 LT |
13 | /********************************************************************* |
14 | * FREQUENCY TABLE HELPERS * | |
15 | *********************************************************************/ | |
16 | ||
44139ed4 VK |
17 | bool policy_has_boost_freq(struct cpufreq_policy *policy) |
18 | { | |
19 | struct cpufreq_frequency_table *pos, *table = policy->freq_table; | |
20 | ||
21 | if (!table) | |
22 | return false; | |
23 | ||
24 | cpufreq_for_each_valid_entry(pos, table) | |
25 | if (pos->flags & CPUFREQ_BOOST_FREQ) | |
26 | return true; | |
27 | ||
28 | return false; | |
29 | } | |
30 | EXPORT_SYMBOL_GPL(policy_has_boost_freq); | |
31 | ||
1da177e4 LT |
32 | int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, |
33 | struct cpufreq_frequency_table *table) | |
34 | { | |
041526f9 | 35 | struct cpufreq_frequency_table *pos; |
1da177e4 LT |
36 | unsigned int min_freq = ~0; |
37 | unsigned int max_freq = 0; | |
041526f9 | 38 | unsigned int freq; |
1da177e4 | 39 | |
041526f9 SK |
40 | cpufreq_for_each_valid_entry(pos, table) { |
41 | freq = pos->frequency; | |
1da177e4 | 42 | |
6f19efc0 | 43 | if (!cpufreq_boost_enabled() |
041526f9 | 44 | && (pos->flags & CPUFREQ_BOOST_FREQ)) |
6f19efc0 LM |
45 | continue; |
46 | ||
041526f9 | 47 | pr_debug("table entry %u: %u kHz\n", (int)(pos - table), freq); |
1da177e4 LT |
48 | if (freq < min_freq) |
49 | min_freq = freq; | |
50 | if (freq > max_freq) | |
51 | max_freq = freq; | |
52 | } | |
53 | ||
54 | policy->min = policy->cpuinfo.min_freq = min_freq; | |
55 | policy->max = policy->cpuinfo.max_freq = max_freq; | |
56 | ||
57 | if (policy->min == ~0) | |
58 | return -EINVAL; | |
59 | else | |
60 | return 0; | |
61 | } | |
1da177e4 LT |
62 | |
63 | int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, | |
64 | struct cpufreq_frequency_table *table) | |
65 | { | |
041526f9 SK |
66 | struct cpufreq_frequency_table *pos; |
67 | unsigned int freq, next_larger = ~0; | |
77db50c4 | 68 | bool found = false; |
1da177e4 | 69 | |
2d06d8c4 | 70 | pr_debug("request for verification of policy (%u - %u kHz) for cpu %u\n", |
e08f5f5b | 71 | policy->min, policy->max, policy->cpu); |
1da177e4 | 72 | |
be49e346 | 73 | cpufreq_verify_within_cpu_limits(policy); |
1da177e4 | 74 | |
041526f9 SK |
75 | cpufreq_for_each_valid_entry(pos, table) { |
76 | freq = pos->frequency; | |
77 | ||
77db50c4 VK |
78 | if ((freq >= policy->min) && (freq <= policy->max)) { |
79 | found = true; | |
80 | break; | |
81 | } | |
82 | ||
83 | if ((next_larger > freq) && (freq > policy->max)) | |
1da177e4 LT |
84 | next_larger = freq; |
85 | } | |
86 | ||
77db50c4 | 87 | if (!found) { |
1da177e4 | 88 | policy->max = next_larger; |
be49e346 | 89 | cpufreq_verify_within_cpu_limits(policy); |
77db50c4 | 90 | } |
1da177e4 | 91 | |
2d06d8c4 | 92 | pr_debug("verification lead to (%u - %u kHz) for cpu %u\n", |
e08f5f5b | 93 | policy->min, policy->max, policy->cpu); |
1da177e4 LT |
94 | |
95 | return 0; | |
96 | } | |
97 | EXPORT_SYMBOL_GPL(cpufreq_frequency_table_verify); | |
98 | ||
18434512 | 99 | /* |
e0b3165b VK |
100 | * Generic routine to verify policy & frequency table, requires driver to set |
101 | * policy->freq_table prior to it. | |
18434512 VK |
102 | */ |
103 | int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy) | |
104 | { | |
f8bfc116 | 105 | if (!policy->freq_table) |
18434512 VK |
106 | return -ENODEV; |
107 | ||
f8bfc116 | 108 | return cpufreq_frequency_table_verify(policy, policy->freq_table); |
18434512 VK |
109 | } |
110 | EXPORT_SYMBOL_GPL(cpufreq_generic_frequency_table_verify); | |
1da177e4 | 111 | |
da0c6dc0 VK |
112 | int cpufreq_table_index_unsorted(struct cpufreq_policy *policy, |
113 | unsigned int target_freq, | |
114 | unsigned int relation) | |
1da177e4 | 115 | { |
484944a5 | 116 | struct cpufreq_frequency_table optimal = { |
50701588 | 117 | .driver_data = ~0, |
484944a5 DJ |
118 | .frequency = 0, |
119 | }; | |
120 | struct cpufreq_frequency_table suboptimal = { | |
50701588 | 121 | .driver_data = ~0, |
484944a5 DJ |
122 | .frequency = 0, |
123 | }; | |
041526f9 | 124 | struct cpufreq_frequency_table *pos; |
7ab4aabb | 125 | struct cpufreq_frequency_table *table = policy->freq_table; |
5b0c0b16 | 126 | unsigned int freq, diff, i = 0; |
d218ed77 | 127 | int index; |
1da177e4 | 128 | |
2d06d8c4 | 129 | pr_debug("request for target %u kHz (relation: %u) for cpu %u\n", |
e08f5f5b | 130 | target_freq, relation, policy->cpu); |
1da177e4 LT |
131 | |
132 | switch (relation) { | |
133 | case CPUFREQ_RELATION_H: | |
1da177e4 LT |
134 | suboptimal.frequency = ~0; |
135 | break; | |
136 | case CPUFREQ_RELATION_L: | |
5b0c0b16 | 137 | case CPUFREQ_RELATION_C: |
1da177e4 | 138 | optimal.frequency = ~0; |
1da177e4 LT |
139 | break; |
140 | } | |
141 | ||
ffd81dcf | 142 | cpufreq_for_each_valid_entry_idx(pos, table, i) { |
041526f9 SK |
143 | freq = pos->frequency; |
144 | ||
1da177e4 LT |
145 | if ((freq < policy->min) || (freq > policy->max)) |
146 | continue; | |
1e498856 SK |
147 | if (freq == target_freq) { |
148 | optimal.driver_data = i; | |
149 | break; | |
150 | } | |
97acec55 | 151 | switch (relation) { |
1da177e4 | 152 | case CPUFREQ_RELATION_H: |
1e498856 | 153 | if (freq < target_freq) { |
1da177e4 LT |
154 | if (freq >= optimal.frequency) { |
155 | optimal.frequency = freq; | |
50701588 | 156 | optimal.driver_data = i; |
1da177e4 LT |
157 | } |
158 | } else { | |
159 | if (freq <= suboptimal.frequency) { | |
160 | suboptimal.frequency = freq; | |
50701588 | 161 | suboptimal.driver_data = i; |
1da177e4 LT |
162 | } |
163 | } | |
164 | break; | |
165 | case CPUFREQ_RELATION_L: | |
1e498856 | 166 | if (freq > target_freq) { |
1da177e4 LT |
167 | if (freq <= optimal.frequency) { |
168 | optimal.frequency = freq; | |
50701588 | 169 | optimal.driver_data = i; |
1da177e4 LT |
170 | } |
171 | } else { | |
172 | if (freq >= suboptimal.frequency) { | |
173 | suboptimal.frequency = freq; | |
50701588 | 174 | suboptimal.driver_data = i; |
1da177e4 LT |
175 | } |
176 | } | |
177 | break; | |
5b0c0b16 SK |
178 | case CPUFREQ_RELATION_C: |
179 | diff = abs(freq - target_freq); | |
180 | if (diff < optimal.frequency || | |
181 | (diff == optimal.frequency && | |
182 | freq > table[optimal.driver_data].frequency)) { | |
183 | optimal.frequency = diff; | |
184 | optimal.driver_data = i; | |
185 | } | |
186 | break; | |
1da177e4 LT |
187 | } |
188 | } | |
50701588 | 189 | if (optimal.driver_data > i) { |
d218ed77 VK |
190 | if (suboptimal.driver_data > i) { |
191 | WARN(1, "Invalid frequency table: %d\n", policy->cpu); | |
192 | return 0; | |
193 | } | |
1da177e4 | 194 | |
d218ed77 VK |
195 | index = suboptimal.driver_data; |
196 | } else | |
197 | index = optimal.driver_data; | |
1da177e4 | 198 | |
d218ed77 VK |
199 | pr_debug("target index is %u, freq is:%u kHz\n", index, |
200 | table[index].frequency); | |
201 | return index; | |
1da177e4 | 202 | } |
da0c6dc0 | 203 | EXPORT_SYMBOL_GPL(cpufreq_table_index_unsorted); |
1da177e4 | 204 | |
d3916691 VK |
205 | int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy, |
206 | unsigned int freq) | |
207 | { | |
f8bfc116 | 208 | struct cpufreq_frequency_table *pos, *table = policy->freq_table; |
ffd81dcf | 209 | int idx; |
d3916691 | 210 | |
d3916691 VK |
211 | if (unlikely(!table)) { |
212 | pr_debug("%s: Unable to find frequency table\n", __func__); | |
213 | return -ENOENT; | |
214 | } | |
215 | ||
ffd81dcf | 216 | cpufreq_for_each_valid_entry_idx(pos, table, idx) |
041526f9 | 217 | if (pos->frequency == freq) |
ffd81dcf | 218 | return idx; |
d3916691 VK |
219 | |
220 | return -EINVAL; | |
221 | } | |
222 | EXPORT_SYMBOL_GPL(cpufreq_frequency_table_get_index); | |
223 | ||
1da177e4 | 224 | /** |
e32d22f7 | 225 | * show_available_freqs - show available frequencies for the specified CPU |
1da177e4 | 226 | */ |
6f19efc0 LM |
227 | static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf, |
228 | bool show_boost) | |
1da177e4 | 229 | { |
1da177e4 | 230 | ssize_t count = 0; |
041526f9 | 231 | struct cpufreq_frequency_table *pos, *table = policy->freq_table; |
1da177e4 | 232 | |
e0b3165b | 233 | if (!table) |
1da177e4 LT |
234 | return -ENODEV; |
235 | ||
041526f9 | 236 | cpufreq_for_each_valid_entry(pos, table) { |
6f19efc0 LM |
237 | /* |
238 | * show_boost = true and driver_data = BOOST freq | |
239 | * display BOOST freqs | |
240 | * | |
241 | * show_boost = false and driver_data = BOOST freq | |
242 | * show_boost = true and driver_data != BOOST freq | |
243 | * continue - do not display anything | |
244 | * | |
245 | * show_boost = false and driver_data != BOOST freq | |
246 | * display NON BOOST freqs | |
247 | */ | |
041526f9 | 248 | if (show_boost ^ (pos->flags & CPUFREQ_BOOST_FREQ)) |
6f19efc0 LM |
249 | continue; |
250 | ||
041526f9 | 251 | count += sprintf(&buf[count], "%d ", pos->frequency); |
1da177e4 LT |
252 | } |
253 | count += sprintf(&buf[count], "\n"); | |
254 | ||
255 | return count; | |
256 | ||
257 | } | |
258 | ||
6f19efc0 LM |
259 | #define cpufreq_attr_available_freq(_name) \ |
260 | struct freq_attr cpufreq_freq_attr_##_name##_freqs = \ | |
261 | __ATTR_RO(_name##_frequencies) | |
262 | ||
263 | /** | |
264 | * show_scaling_available_frequencies - show available normal frequencies for | |
265 | * the specified CPU | |
266 | */ | |
267 | static ssize_t scaling_available_frequencies_show(struct cpufreq_policy *policy, | |
268 | char *buf) | |
269 | { | |
270 | return show_available_freqs(policy, buf, false); | |
271 | } | |
272 | cpufreq_attr_available_freq(scaling_available); | |
1da177e4 LT |
273 | EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_available_freqs); |
274 | ||
6f19efc0 LM |
275 | /** |
276 | * show_available_boost_freqs - show available boost frequencies for | |
277 | * the specified CPU | |
278 | */ | |
279 | static ssize_t scaling_boost_frequencies_show(struct cpufreq_policy *policy, | |
280 | char *buf) | |
281 | { | |
282 | return show_available_freqs(policy, buf, true); | |
283 | } | |
284 | cpufreq_attr_available_freq(scaling_boost); | |
285 | EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_boost_freqs); | |
286 | ||
18434512 VK |
287 | struct freq_attr *cpufreq_generic_attr[] = { |
288 | &cpufreq_freq_attr_scaling_available_freqs, | |
289 | NULL, | |
290 | }; | |
291 | EXPORT_SYMBOL_GPL(cpufreq_generic_attr); | |
292 | ||
da0c6dc0 VK |
293 | static int set_freq_table_sorted(struct cpufreq_policy *policy) |
294 | { | |
295 | struct cpufreq_frequency_table *pos, *table = policy->freq_table; | |
296 | struct cpufreq_frequency_table *prev = NULL; | |
297 | int ascending = 0; | |
298 | ||
299 | policy->freq_table_sorted = CPUFREQ_TABLE_UNSORTED; | |
300 | ||
301 | cpufreq_for_each_valid_entry(pos, table) { | |
302 | if (!prev) { | |
303 | prev = pos; | |
304 | continue; | |
305 | } | |
306 | ||
307 | if (pos->frequency == prev->frequency) { | |
308 | pr_warn("Duplicate freq-table entries: %u\n", | |
309 | pos->frequency); | |
310 | return -EINVAL; | |
311 | } | |
312 | ||
313 | /* Frequency increased from prev to pos */ | |
314 | if (pos->frequency > prev->frequency) { | |
315 | /* But frequency was decreasing earlier */ | |
316 | if (ascending < 0) { | |
317 | pr_debug("Freq table is unsorted\n"); | |
318 | return 0; | |
319 | } | |
320 | ||
321 | ascending++; | |
322 | } else { | |
323 | /* Frequency decreased from prev to pos */ | |
324 | ||
325 | /* But frequency was increasing earlier */ | |
326 | if (ascending > 0) { | |
327 | pr_debug("Freq table is unsorted\n"); | |
328 | return 0; | |
329 | } | |
330 | ||
331 | ascending--; | |
332 | } | |
333 | ||
334 | prev = pos; | |
335 | } | |
336 | ||
337 | if (ascending > 0) | |
338 | policy->freq_table_sorted = CPUFREQ_TABLE_SORTED_ASCENDING; | |
339 | else | |
340 | policy->freq_table_sorted = CPUFREQ_TABLE_SORTED_DESCENDING; | |
341 | ||
342 | pr_debug("Freq table is sorted in %s order\n", | |
343 | ascending > 0 ? "ascending" : "descending"); | |
344 | ||
345 | return 0; | |
346 | } | |
347 | ||
d417e069 VK |
348 | int cpufreq_table_validate_and_sort(struct cpufreq_policy *policy) |
349 | { | |
350 | int ret; | |
351 | ||
352 | if (!policy->freq_table) | |
353 | return 0; | |
354 | ||
355 | ret = cpufreq_frequency_table_cpuinfo(policy, policy->freq_table); | |
356 | if (ret) | |
357 | return ret; | |
358 | ||
359 | return set_freq_table_sorted(policy); | |
360 | } | |
361 | ||
97acec55 DJ |
362 | MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>"); |
363 | MODULE_DESCRIPTION("CPUfreq frequency table helpers"); | |
364 | MODULE_LICENSE("GPL"); |