root/drivers/cpufreq/freq_table.c

DEFINITIONS

1. policy_has_boost_freq
2. cpufreq_frequency_table_cpuinfo
3. cpufreq_frequency_table_verify
4. cpufreq_generic_frequency_table_verify
5. cpufreq_table_index_unsorted
6. cpufreq_frequency_table_get_index
7. show_available_freqs
8. scaling_available_frequencies_show
9. scaling_boost_frequencies_show
10. set_freq_table_sorted
11. cpufreq_table_validate_and_sort

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * linux/drivers/cpufreq/freq_table.c
   4  *
   5  * Copyright (C) 2002 - 2003 Dominik Brodowski
   6  */
   7 
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9 
  10 #include <linux/cpufreq.h>
  11 #include <linux/module.h>
  12 
  13 /*********************************************************************
  14  *                     FREQUENCY TABLE HELPERS                       *
  15  *********************************************************************/
  16 
  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 
  32 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
  33                                     struct cpufreq_frequency_table *table)
  34 {
  35         struct cpufreq_frequency_table *pos;
  36         unsigned int min_freq = ~0;
  37         unsigned int max_freq = 0;
  38         unsigned int freq;
  39 
  40         cpufreq_for_each_valid_entry(pos, table) {
  41                 freq = pos->frequency;
  42 
  43                 if (!cpufreq_boost_enabled()
  44                     && (pos->flags & CPUFREQ_BOOST_FREQ))
  45                         continue;
  46 
  47                 pr_debug("table entry %u: %u kHz\n", (int)(pos - table), freq);
  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 }
  62 
  63 int cpufreq_frequency_table_verify(struct cpufreq_policy_data *policy,
  64                                    struct cpufreq_frequency_table *table)
  65 {
  66         struct cpufreq_frequency_table *pos;
  67         unsigned int freq, next_larger = ~0;
  68         bool found = false;
  69 
  70         pr_debug("request for verification of policy (%u - %u kHz) for cpu %u\n",
  71                                         policy->min, policy->max, policy->cpu);
  72 
  73         cpufreq_verify_within_cpu_limits(policy);
  74 
  75         cpufreq_for_each_valid_entry(pos, table) {
  76                 freq = pos->frequency;
  77 
  78                 if ((freq >= policy->min) && (freq <= policy->max)) {
  79                         found = true;
  80                         break;
  81                 }
  82 
  83                 if ((next_larger > freq) && (freq > policy->max))
  84                         next_larger = freq;
  85         }
  86 
  87         if (!found) {
  88                 policy->max = next_larger;
  89                 cpufreq_verify_within_cpu_limits(policy);
  90         }
  91 
  92         pr_debug("verification lead to (%u - %u kHz) for cpu %u\n",
  93                                 policy->min, policy->max, policy->cpu);
  94 
  95         return 0;
  96 }
  97 EXPORT_SYMBOL_GPL(cpufreq_frequency_table_verify);
  98 
  99 /*
 100  * Generic routine to verify policy & frequency table, requires driver to set
 101  * policy->freq_table prior to it.
 102  */
 103 int cpufreq_generic_frequency_table_verify(struct cpufreq_policy_data *policy)
 104 {
 105         if (!policy->freq_table)
 106                 return -ENODEV;
 107 
 108         return cpufreq_frequency_table_verify(policy, policy->freq_table);
 109 }
 110 EXPORT_SYMBOL_GPL(cpufreq_generic_frequency_table_verify);
 111 
 112 int cpufreq_table_index_unsorted(struct cpufreq_policy *policy,
 113                                  unsigned int target_freq,
 114                                  unsigned int relation)
 115 {
 116         struct cpufreq_frequency_table optimal = {
 117                 .driver_data = ~0,
 118                 .frequency = 0,
 119         };
 120         struct cpufreq_frequency_table suboptimal = {
 121                 .driver_data = ~0,
 122                 .frequency = 0,
 123         };
 124         struct cpufreq_frequency_table *pos;
 125         struct cpufreq_frequency_table *table = policy->freq_table;
 126         unsigned int freq, diff, i = 0;
 127         int index;
 128 
 129         pr_debug("request for target %u kHz (relation: %u) for cpu %u\n",
 130                                         target_freq, relation, policy->cpu);
 131 
 132         switch (relation) {
 133         case CPUFREQ_RELATION_H:
 134                 suboptimal.frequency = ~0;
 135                 break;
 136         case CPUFREQ_RELATION_L:
 137         case CPUFREQ_RELATION_C:
 138                 optimal.frequency = ~0;
 139                 break;
 140         }
 141 
 142         cpufreq_for_each_valid_entry_idx(pos, table, i) {
 143                 freq = pos->frequency;
 144 
 145                 if ((freq < policy->min) || (freq > policy->max))
 146                         continue;
 147                 if (freq == target_freq) {
 148                         optimal.driver_data = i;
 149                         break;
 150                 }
 151                 switch (relation) {
 152                 case CPUFREQ_RELATION_H:
 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                 case CPUFREQ_RELATION_L:
 166                         if (freq > target_freq) {
 167                                 if (freq <= optimal.frequency) {
 168                                         optimal.frequency = freq;
 169                                         optimal.driver_data = i;
 170                                 }
 171                         } else {
 172                                 if (freq >= suboptimal.frequency) {
 173                                         suboptimal.frequency = freq;
 174                                         suboptimal.driver_data = i;
 175                                 }
 176                         }
 177                         break;
 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;
 187                 }
 188         }
 189         if (optimal.driver_data > i) {
 190                 if (suboptimal.driver_data > i) {
 191                         WARN(1, "Invalid frequency table: %d\n", policy->cpu);
 192                         return 0;
 193                 }
 194 
 195                 index = suboptimal.driver_data;
 196         } else
 197                 index = optimal.driver_data;
 198 
 199         pr_debug("target index is %u, freq is:%u kHz\n", index,
 200                  table[index].frequency);
 201         return index;
 202 }
 203 EXPORT_SYMBOL_GPL(cpufreq_table_index_unsorted);
 204 
 205 int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
 206                 unsigned int freq)
 207 {
 208         struct cpufreq_frequency_table *pos, *table = policy->freq_table;
 209         int idx;
 210 
 211         if (unlikely(!table)) {
 212                 pr_debug("%s: Unable to find frequency table\n", __func__);
 213                 return -ENOENT;
 214         }
 215 
 216         cpufreq_for_each_valid_entry_idx(pos, table, idx)
 217                 if (pos->frequency == freq)
 218                         return idx;
 219 
 220         return -EINVAL;
 221 }
 222 EXPORT_SYMBOL_GPL(cpufreq_frequency_table_get_index);
 223 
 224 /**
 225  * show_available_freqs - show available frequencies for the specified CPU
 226  */
 227 static ssize_t show_available_freqs(struct cpufreq_policy *policy, char *buf,
 228                                     bool show_boost)
 229 {
 230         ssize_t count = 0;
 231         struct cpufreq_frequency_table *pos, *table = policy->freq_table;
 232 
 233         if (!table)
 234                 return -ENODEV;
 235 
 236         cpufreq_for_each_valid_entry(pos, table) {
 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                  */
 248                 if (show_boost ^ (pos->flags & CPUFREQ_BOOST_FREQ))
 249                         continue;
 250 
 251                 count += sprintf(&buf[count], "%d ", pos->frequency);
 252         }
 253         count += sprintf(&buf[count], "\n");
 254 
 255         return count;
 256 
 257 }
 258 
 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);
 273 EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_available_freqs);
 274 
 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 
 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 
 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 
 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 
 362 MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>");
 363 MODULE_DESCRIPTION("CPUfreq frequency table helpers");
 364 MODULE_LICENSE("GPL");