tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * linux/drivers/cpufreq/freq_table.c
3 *
4 * Copyright (C) 2002 - 2003 Dominik Brodowski
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 */
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14#include <linux/cpufreq.h>
15#include <linux/module.h>
16
17/*********************************************************************
18 * FREQUENCY TABLE HELPERS *
19 *********************************************************************/
20
21int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
22 struct cpufreq_frequency_table *table)
23{
24 unsigned int min_freq = ~0;
25 unsigned int max_freq = 0;
26 unsigned int i;
27
28 for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
29 unsigned int freq = table[i].frequency;
30 if (freq == CPUFREQ_ENTRY_INVALID) {
31 pr_debug("table entry %u is invalid, skipping\n", i);
32
33 continue;
34 }
35 pr_debug("table entry %u: %u kHz, %u driver_data\n",
36 i, freq, table[i].driver_data);
37 if (freq < min_freq)
38 min_freq = freq;
39 if (freq > max_freq)
40 max_freq = freq;
41 }
42
43 policy->min = policy->cpuinfo.min_freq = min_freq;
44 policy->max = policy->cpuinfo.max_freq = max_freq;
45
46 if (policy->min == ~0)
47 return -EINVAL;
48 else
49 return 0;
50}
51EXPORT_SYMBOL_GPL(cpufreq_frequency_table_cpuinfo);
52
53
54int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
55 struct cpufreq_frequency_table *table)
56{
57 unsigned int next_larger = ~0, freq, i = 0;
58 bool found = false;
59
60 pr_debug("request for verification of policy (%u - %u kHz) for cpu %u\n",
61 policy->min, policy->max, policy->cpu);
62
63 cpufreq_verify_within_cpu_limits(policy);
64
65 for (; freq = table[i].frequency, freq != CPUFREQ_TABLE_END; i++) {
66 if (freq == CPUFREQ_ENTRY_INVALID)
67 continue;
68 if ((freq >= policy->min) && (freq <= policy->max)) {
69 found = true;
70 break;
71 }
72
73 if ((next_larger > freq) && (freq > policy->max))
74 next_larger = freq;
75 }
76
77 if (!found) {
78 policy->max = next_larger;
79 cpufreq_verify_within_cpu_limits(policy);
80 }
81
82 pr_debug("verification lead to (%u - %u kHz) for cpu %u\n",
83 policy->min, policy->max, policy->cpu);
84
85 return 0;
86}
87EXPORT_SYMBOL_GPL(cpufreq_frequency_table_verify);
88
89/*
90 * Generic routine to verify policy & frequency table, requires driver to call
91 * cpufreq_frequency_table_get_attr() prior to it.
92 */
93int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy)
94{
95 struct cpufreq_frequency_table *table =
96 cpufreq_frequency_get_table(policy->cpu);
97 if (!table)
98 return -ENODEV;
99
100 return cpufreq_frequency_table_verify(policy, table);
101}
102EXPORT_SYMBOL_GPL(cpufreq_generic_frequency_table_verify);
103
104int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
105 struct cpufreq_frequency_table *table,
106 unsigned int target_freq,
107 unsigned int relation,
108 unsigned int *index)
109{
110 struct cpufreq_frequency_table optimal = {
111 .driver_data = ~0,
112 .frequency = 0,
113 };
114 struct cpufreq_frequency_table suboptimal = {
115 .driver_data = ~0,
116 .frequency = 0,
117 };
118 unsigned int i;
119
120 pr_debug("request for target %u kHz (relation: %u) for cpu %u\n",
121 target_freq, relation, policy->cpu);
122
123 switch (relation) {
124 case CPUFREQ_RELATION_H:
125 suboptimal.frequency = ~0;
126 break;
127 case CPUFREQ_RELATION_L:
128 optimal.frequency = ~0;
129 break;
130 }
131
132 for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
133 unsigned int freq = table[i].frequency;
134 if (freq == CPUFREQ_ENTRY_INVALID)
135 continue;
136 if ((freq < policy->min) || (freq > policy->max))
137 continue;
138 switch (relation) {
139 case CPUFREQ_RELATION_H:
140 if (freq <= target_freq) {
141 if (freq >= optimal.frequency) {
142 optimal.frequency = freq;
143 optimal.driver_data = i;
144 }
145 } else {
146 if (freq <= suboptimal.frequency) {
147 suboptimal.frequency = freq;
148 suboptimal.driver_data = i;
149 }
150 }
151 break;
152 case CPUFREQ_RELATION_L:
153 if (freq >= target_freq) {
154 if (freq <= optimal.frequency) {
155 optimal.frequency = freq;
156 optimal.driver_data = i;
157 }
158 } else {
159 if (freq >= suboptimal.frequency) {
160 suboptimal.frequency = freq;
161 suboptimal.driver_data = i;
162 }
163 }
164 break;
165 }
166 }
167 if (optimal.driver_data > i) {
168 if (suboptimal.driver_data > i)
169 return -EINVAL;
170 *index = suboptimal.driver_data;
171 } else
172 *index = optimal.driver_data;
173
174 pr_debug("target is %u (%u kHz, %u)\n", *index, table[*index].frequency,
175 table[*index].driver_data);
176
177 return 0;
178}
179EXPORT_SYMBOL_GPL(cpufreq_frequency_table_target);
180
181static DEFINE_PER_CPU(struct cpufreq_frequency_table *, cpufreq_show_table);
182/**
183 * show_available_freqs - show available frequencies for the specified CPU
184 */
185static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf)
186{
187 unsigned int i = 0;
188 unsigned int cpu = policy->cpu;
189 ssize_t count = 0;
190 struct cpufreq_frequency_table *table;
191
192 if (!per_cpu(cpufreq_show_table, cpu))
193 return -ENODEV;
194
195 table = per_cpu(cpufreq_show_table, cpu);
196
197 for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
198 if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
199 continue;
200 count += sprintf(&buf[count], "%d ", table[i].frequency);
201 }
202 count += sprintf(&buf[count], "\n");
203
204 return count;
205
206}
207
208struct freq_attr cpufreq_freq_attr_scaling_available_freqs = {
209 .attr = { .name = "scaling_available_frequencies",
210 .mode = 0444,
211 },
212 .show = show_available_freqs,
213};
214EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_available_freqs);
215
216struct freq_attr *cpufreq_generic_attr[] = {
217 &cpufreq_freq_attr_scaling_available_freqs,
218 NULL,
219};
220EXPORT_SYMBOL_GPL(cpufreq_generic_attr);
221
222/*
223 * if you use these, you must assure that the frequency table is valid
224 * all the time between get_attr and put_attr!
225 */
226void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
227 unsigned int cpu)
228{
229 pr_debug("setting show_table for cpu %u to %p\n", cpu, table);
230 per_cpu(cpufreq_show_table, cpu) = table;
231}
232EXPORT_SYMBOL_GPL(cpufreq_frequency_table_get_attr);
233
234void cpufreq_frequency_table_put_attr(unsigned int cpu)
235{
236 pr_debug("clearing show_table for cpu %u\n", cpu);
237 per_cpu(cpufreq_show_table, cpu) = NULL;
238}
239EXPORT_SYMBOL_GPL(cpufreq_frequency_table_put_attr);
240
241int cpufreq_table_validate_and_show(struct cpufreq_policy *policy,
242 struct cpufreq_frequency_table *table)
243{
244 int ret = cpufreq_frequency_table_cpuinfo(policy, table);
245
246 if (!ret)
247 cpufreq_frequency_table_get_attr(table, policy->cpu);
248
249 return ret;
250}
251EXPORT_SYMBOL_GPL(cpufreq_table_validate_and_show);
252
253void cpufreq_frequency_table_update_policy_cpu(struct cpufreq_policy *policy)
254{
255 pr_debug("Updating show_table for new_cpu %u from last_cpu %u\n",
256 policy->cpu, policy->last_cpu);
257 per_cpu(cpufreq_show_table, policy->cpu) = per_cpu(cpufreq_show_table,
258 policy->last_cpu);
259 per_cpu(cpufreq_show_table, policy->last_cpu) = NULL;
260}
261
262struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu)
263{
264 return per_cpu(cpufreq_show_table, cpu);
265}
266EXPORT_SYMBOL_GPL(cpufreq_frequency_get_table);
267
268MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>");
269MODULE_DESCRIPTION("CPUfreq frequency table helpers");
270MODULE_LICENSE("GPL");