Branch data Line data Source code
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 : :
21 : 0 : int 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 [ # # ]: 0 : for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
29 : : unsigned int freq = table[i].frequency;
30 [ # # ]: 0 : if (freq == CPUFREQ_ENTRY_INVALID) {
31 : : pr_debug("table entry %u is invalid, skipping\n", i);
32 : :
33 : 0 : continue;
34 : : }
35 : : pr_debug("table entry %u: %u kHz, %u driver_data\n",
36 : : i, freq, table[i].driver_data);
37 [ # # ]: 0 : if (freq < min_freq)
38 : : min_freq = freq;
39 [ # # ]: 0 : if (freq > max_freq)
40 : : max_freq = freq;
41 : : }
42 : :
43 : 0 : policy->min = policy->cpuinfo.min_freq = min_freq;
44 : 0 : policy->max = policy->cpuinfo.max_freq = max_freq;
45 : :
46 [ # # ]: 0 : if (policy->min == ~0)
47 : : return -EINVAL;
48 : : else
49 : 0 : return 0;
50 : : }
51 : : EXPORT_SYMBOL_GPL(cpufreq_frequency_table_cpuinfo);
52 : :
53 : :
54 : 0 : int 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 [ # # ]: 0 : for (; freq = table[i].frequency, freq != CPUFREQ_TABLE_END; i++) {
66 [ # # ]: 0 : if (freq == CPUFREQ_ENTRY_INVALID)
67 : 0 : continue;
68 [ # # ][ # # ]: 0 : if ((freq >= policy->min) && (freq <= policy->max)) {
69 : : found = true;
70 : : break;
71 : : }
72 : :
73 [ # # ][ # # ]: 0 : if ((next_larger > freq) && (freq > policy->max))
74 : : next_larger = freq;
75 : : }
76 : :
77 [ # # ]: 0 : if (!found) {
78 : 0 : 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 : 0 : return 0;
86 : : }
87 : : EXPORT_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 : : */
93 : 0 : int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy)
94 : : {
95 : : struct cpufreq_frequency_table *table =
96 : 0 : cpufreq_frequency_get_table(policy->cpu);
97 [ # # ]: 0 : if (!table)
98 : : return -ENODEV;
99 : :
100 : 0 : return cpufreq_frequency_table_verify(policy, table);
101 : : }
102 : : EXPORT_SYMBOL_GPL(cpufreq_generic_frequency_table_verify);
103 : :
104 : 0 : int 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 [ + + ]: 14918 : switch (relation) {
124 : : case CPUFREQ_RELATION_H:
125 : : suboptimal.frequency = ~0;
126 : 742 : break;
127 : : case CPUFREQ_RELATION_L:
128 : : optimal.frequency = ~0;
129 : 14918 : break;
130 : : }
131 : :
132 [ + + ]: 253254 : for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
133 : : unsigned int freq = table[i].frequency;
134 [ + ]: 238336 : if (freq == CPUFREQ_ENTRY_INVALID)
135 : 0 : continue;
136 [ + + ][ + ]: 238613 : if ((freq < policy->min) || (freq > policy->max))
137 : 0 : continue;
138 [ + + ]: 238613 : switch (relation) {
139 : : case CPUFREQ_RELATION_H:
140 [ + - ]: 11872 : if (freq <= target_freq) {
141 [ + - ]: 11872 : if (freq >= optimal.frequency) {
142 : : optimal.frequency = freq;
143 : : optimal.driver_data = i;
144 : : }
145 : : } else {
146 [ # # ]: 0 : if (freq <= suboptimal.frequency) {
147 : : suboptimal.frequency = freq;
148 : : suboptimal.driver_data = i;
149 : : }
150 : : }
151 : : break;
152 : : case CPUFREQ_RELATION_L:
153 [ + + ]: 226928 : if (freq >= target_freq) {
154 [ + + ]: 135194 : if (freq <= optimal.frequency) {
155 : : optimal.frequency = freq;
156 : : optimal.driver_data = i;
157 : : }
158 : : } else {
159 [ + + ]: 91734 : if (freq >= suboptimal.frequency) {
160 : : suboptimal.frequency = freq;
161 : : suboptimal.driver_data = i;
162 : : }
163 : : }
164 : : break;
165 : : }
166 : : }
167 [ - + ]: 14918 : if (optimal.driver_data > i) {
168 [ # # ]: 0 : if (suboptimal.driver_data > i)
169 : : return -EINVAL;
170 : 0 : *index = suboptimal.driver_data;
171 : : } else
172 : 14918 : *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 : : }
179 : : EXPORT_SYMBOL_GPL(cpufreq_frequency_table_target);
180 : :
181 : : static DEFINE_PER_CPU(struct cpufreq_frequency_table *, cpufreq_show_table);
182 : : /**
183 : : * show_available_freqs - show available frequencies for the specified CPU
184 : : */
185 : 0 : static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf)
186 : : {
187 : : unsigned int i = 0;
188 : 0 : unsigned int cpu = policy->cpu;
189 : : ssize_t count = 0;
190 : : struct cpufreq_frequency_table *table;
191 : :
192 [ # # ]: 0 : if (!per_cpu(cpufreq_show_table, cpu))
193 : : return -ENODEV;
194 : :
195 : 0 : table = per_cpu(cpufreq_show_table, cpu);
196 : :
197 [ # # ]: 0 : for (i = 0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
198 [ # # ]: 0 : if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
199 : 0 : continue;
200 : 0 : count += sprintf(&buf[count], "%d ", table[i].frequency);
201 : : }
202 : 0 : count += sprintf(&buf[count], "\n");
203 : :
204 : 0 : return count;
205 : :
206 : : }
207 : :
208 : : struct freq_attr cpufreq_freq_attr_scaling_available_freqs = {
209 : : .attr = { .name = "scaling_available_frequencies",
210 : : .mode = 0444,
211 : : },
212 : : .show = show_available_freqs,
213 : : };
214 : : EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_available_freqs);
215 : :
216 : : struct freq_attr *cpufreq_generic_attr[] = {
217 : : &cpufreq_freq_attr_scaling_available_freqs,
218 : : NULL,
219 : : };
220 : : EXPORT_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 : : */
226 : 0 : void 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 : 0 : per_cpu(cpufreq_show_table, cpu) = table;
231 : 0 : }
232 : : EXPORT_SYMBOL_GPL(cpufreq_frequency_table_get_attr);
233 : :
234 : 0 : void cpufreq_frequency_table_put_attr(unsigned int cpu)
235 : : {
236 : : pr_debug("clearing show_table for cpu %u\n", cpu);
237 : 0 : per_cpu(cpufreq_show_table, cpu) = NULL;
238 : 0 : }
239 : : EXPORT_SYMBOL_GPL(cpufreq_frequency_table_put_attr);
240 : :
241 : 0 : int cpufreq_table_validate_and_show(struct cpufreq_policy *policy,
242 : : struct cpufreq_frequency_table *table)
243 : : {
244 : 0 : int ret = cpufreq_frequency_table_cpuinfo(policy, table);
245 : :
246 [ # # ]: 0 : if (!ret)
247 : 0 : cpufreq_frequency_table_get_attr(table, policy->cpu);
248 : :
249 : 0 : return ret;
250 : : }
251 : : EXPORT_SYMBOL_GPL(cpufreq_table_validate_and_show);
252 : :
253 : 0 : void 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 : 0 : per_cpu(cpufreq_show_table, policy->cpu) = per_cpu(cpufreq_show_table,
258 : : policy->last_cpu);
259 : 0 : per_cpu(cpufreq_show_table, policy->last_cpu) = NULL;
260 : 0 : }
261 : :
262 : 0 : struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu)
263 : : {
264 : 14942 : return per_cpu(cpufreq_show_table, cpu);
265 : : }
266 : : EXPORT_SYMBOL_GPL(cpufreq_frequency_get_table);
267 : :
268 : : MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>");
269 : : MODULE_DESCRIPTION("CPUfreq frequency table helpers");
270 : : MODULE_LICENSE("GPL");
|
