freq_table.c 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235
  1. /*
  2. * linux/drivers/cpufreq/freq_table.c
  3. *
  4. * Copyright (C) 2002 - 2003 Dominik Brodowski
  5. */
  6. #include <linux/kernel.h>
  7. #include <linux/module.h>
  8. #include <linux/init.h>
  9. #include <linux/cpufreq.h>
  10. #define dprintk(msg...) \
  11. cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, "freq-table", msg)
  12. /*********************************************************************
  13. * FREQUENCY TABLE HELPERS *
  14. *********************************************************************/
  15. int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
  16. struct cpufreq_frequency_table *table)
  17. {
  18. unsigned int min_freq = ~0;
  19. unsigned int max_freq = 0;
  20. unsigned int i;
  21. for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
  22. unsigned int freq = table[i].frequency;
  23. if (freq == CPUFREQ_ENTRY_INVALID) {
  24. dprintk("table entry %u is invalid, skipping\n", i);
  25. continue;
  26. }
  27. dprintk("table entry %u: %u kHz, %u index\n",
  28. i, freq, table[i].index);
  29. if (freq < min_freq)
  30. min_freq = freq;
  31. if (freq > max_freq)
  32. max_freq = freq;
  33. }
  34. policy->min = policy->cpuinfo.min_freq = min_freq;
  35. policy->max = policy->cpuinfo.max_freq = max_freq;
  36. if (policy->min == ~0)
  37. return -EINVAL;
  38. else
  39. return 0;
  40. }
  41. EXPORT_SYMBOL_GPL(cpufreq_frequency_table_cpuinfo);
  42. int cpufreq_frequency_table_verify(struct cpufreq_policy *policy,
  43. struct cpufreq_frequency_table *table)
  44. {
  45. unsigned int next_larger = ~0;
  46. unsigned int i;
  47. unsigned int count = 0;
  48. dprintk("request for verification of policy (%u - %u kHz) for cpu %u\n",
  49. policy->min, policy->max, policy->cpu);
  50. if (!cpu_online(policy->cpu))
  51. return -EINVAL;
  52. cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
  53. policy->cpuinfo.max_freq);
  54. for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
  55. unsigned int freq = table[i].frequency;
  56. if (freq == CPUFREQ_ENTRY_INVALID)
  57. continue;
  58. if ((freq >= policy->min) && (freq <= policy->max))
  59. count++;
  60. else if ((next_larger > freq) && (freq > policy->max))
  61. next_larger = freq;
  62. }
  63. if (!count)
  64. policy->max = next_larger;
  65. cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
  66. policy->cpuinfo.max_freq);
  67. dprintk("verification lead to (%u - %u kHz) for cpu %u\n",
  68. policy->min, policy->max, policy->cpu);
  69. return 0;
  70. }
  71. EXPORT_SYMBOL_GPL(cpufreq_frequency_table_verify);
  72. int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
  73. struct cpufreq_frequency_table *table,
  74. unsigned int target_freq,
  75. unsigned int relation,
  76. unsigned int *index)
  77. {
  78. struct cpufreq_frequency_table optimal = {
  79. .index = ~0,
  80. .frequency = 0,
  81. };
  82. struct cpufreq_frequency_table suboptimal = {
  83. .index = ~0,
  84. .frequency = 0,
  85. };
  86. unsigned int i;
  87. dprintk("request for target %u kHz (relation: %u) for cpu %u\n",
  88. target_freq, relation, policy->cpu);
  89. switch (relation) {
  90. case CPUFREQ_RELATION_H:
  91. suboptimal.frequency = ~0;
  92. break;
  93. case CPUFREQ_RELATION_L:
  94. optimal.frequency = ~0;
  95. break;
  96. }
  97. if (!cpu_online(policy->cpu))
  98. return -EINVAL;
  99. for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
  100. unsigned int freq = table[i].frequency;
  101. if (freq == CPUFREQ_ENTRY_INVALID)
  102. continue;
  103. if ((freq < policy->min) || (freq > policy->max))
  104. continue;
  105. switch(relation) {
  106. case CPUFREQ_RELATION_H:
  107. if (freq <= target_freq) {
  108. if (freq >= optimal.frequency) {
  109. optimal.frequency = freq;
  110. optimal.index = i;
  111. }
  112. } else {
  113. if (freq <= suboptimal.frequency) {
  114. suboptimal.frequency = freq;
  115. suboptimal.index = i;
  116. }
  117. }
  118. break;
  119. case CPUFREQ_RELATION_L:
  120. if (freq >= target_freq) {
  121. if (freq <= optimal.frequency) {
  122. optimal.frequency = freq;
  123. optimal.index = i;
  124. }
  125. } else {
  126. if (freq >= suboptimal.frequency) {
  127. suboptimal.frequency = freq;
  128. suboptimal.index = i;
  129. }
  130. }
  131. break;
  132. }
  133. }
  134. if (optimal.index > i) {
  135. if (suboptimal.index > i)
  136. return -EINVAL;
  137. *index = suboptimal.index;
  138. } else
  139. *index = optimal.index;
  140. dprintk("target is %u (%u kHz, %u)\n", *index, table[*index].frequency,
  141. table[*index].index);
  142. return 0;
  143. }
  144. EXPORT_SYMBOL_GPL(cpufreq_frequency_table_target);
  145. static struct cpufreq_frequency_table *show_table[NR_CPUS];
  146. /**
  147. * show_scaling_governor - show the current policy for the specified CPU
  148. */
  149. static ssize_t show_available_freqs (struct cpufreq_policy *policy, char *buf)
  150. {
  151. unsigned int i = 0;
  152. unsigned int cpu = policy->cpu;
  153. ssize_t count = 0;
  154. struct cpufreq_frequency_table *table;
  155. if (!show_table[cpu])
  156. return -ENODEV;
  157. table = show_table[cpu];
  158. for (i=0; (table[i].frequency != CPUFREQ_TABLE_END); i++) {
  159. if (table[i].frequency == CPUFREQ_ENTRY_INVALID)
  160. continue;
  161. count += sprintf(&buf[count], "%d ", table[i].frequency);
  162. }
  163. count += sprintf(&buf[count], "\n");
  164. return count;
  165. }
  166. struct freq_attr cpufreq_freq_attr_scaling_available_freqs = {
  167. .attr = { .name = "scaling_available_frequencies",
  168. .mode = 0444,
  169. .owner=THIS_MODULE
  170. },
  171. .show = show_available_freqs,
  172. };
  173. EXPORT_SYMBOL_GPL(cpufreq_freq_attr_scaling_available_freqs);
  174. /*
  175. * if you use these, you must assure that the frequency table is valid
  176. * all the time between get_attr and put_attr!
  177. */
  178. void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
  179. unsigned int cpu)
  180. {
  181. dprintk("setting show_table for cpu %u to %p\n", cpu, table);
  182. show_table[cpu] = table;
  183. }
  184. EXPORT_SYMBOL_GPL(cpufreq_frequency_table_get_attr);
  185. void cpufreq_frequency_table_put_attr(unsigned int cpu)
  186. {
  187. dprintk("clearing show_table for cpu %u\n", cpu);
  188. show_table[cpu] = NULL;
  189. }
  190. EXPORT_SYMBOL_GPL(cpufreq_frequency_table_put_attr);
  191. struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu)
  192. {
  193. return show_table[cpu];
  194. }
  195. EXPORT_SYMBOL_GPL(cpufreq_frequency_get_table);
  196. MODULE_AUTHOR ("Dominik Brodowski <linux@brodo.de>");
  197. MODULE_DESCRIPTION ("CPUfreq frequency table helpers");
  198. MODULE_LICENSE ("GPL");