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