git.maemo.org Git - cpufrequi/blob - cpufreq.c

   1 /*
   2  *  (C) 2004-2009  Dominik Brodowski <linux@dominikbrodowski.de>
   3  *
   4  *  Licensed under the terms of the GNU GPL License version 2.
   5  */
   6
   7
   8 #include <stdio.h>
   9 #include <errno.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include "cpufreq.h"
  14 #include "interfaces.h"
  15
  16 #define LINE_LEN 10
  17
  18 int cpufreq_cpu_exists(unsigned int cpu)
  19 {
  20         int ret = sysfs_cpu_exists(cpu);
  21         if (ret == -ENOSYS)
  22                 ret = proc_cpu_exists(cpu);
  23         return (ret);
  24 }
  25
  26 unsigned long cpufreq_get_freq_kernel(unsigned int cpu)
  27 {
  28         unsigned long ret = sysfs_get_freq_kernel(cpu);
  29         if (!ret)
  30                 ret = proc_get_freq_kernel(cpu);
  31         return (ret);
  32 }
  33
  34 unsigned long cpufreq_get_freq_hardware(unsigned int cpu)
  35 {
  36         unsigned long ret = sysfs_get_freq_hardware(cpu);
  37         if (!ret)
  38                 ret = proc_get_freq_hardware(cpu);
  39         return (ret);
  40 }
  41
  42 unsigned long cpufreq_get_transition_latency(unsigned int cpu)
  43 {
  44         unsigned long ret = sysfs_get_transition_latency(cpu);
  45         if (!ret)
  46                 ret = proc_get_transition_latency(cpu);
  47         return (ret);
  48 }
  49
  50 int cpufreq_get_hardware_limits(unsigned int cpu,
  51                                 unsigned long *min,
  52                                 unsigned long *max)
  53 {
  54         int ret;
  55         if ((!min) || (!max))
  56                 return -EINVAL;
  57         ret = sysfs_get_hardware_limits(cpu, min, max);
  58         if (ret)
  59                 ret = proc_get_hardware_limits(cpu, min, max);
  60         return (ret);
  61 }
  62
  63 char * cpufreq_get_driver(unsigned int cpu) {
  64         char * ret;
  65         ret = sysfs_get_driver(cpu);
  66         if (!ret) {
  67                 ret = proc_get_driver(cpu);
  68         }
  69         return (ret);
  70 }
  71
  72 void cpufreq_put_driver(char * ptr) {
  73         if (!ptr)
  74                 return;
  75         free(ptr);
  76 }
  77
  78 struct cpufreq_policy * cpufreq_get_policy(unsigned int cpu) {
  79         struct cpufreq_policy * ret;
  80         ret = sysfs_get_policy(cpu);
  81         if (!ret)
  82                 ret = proc_get_policy(cpu);
  83         return (ret);
  84 }
  85
  86 void cpufreq_put_policy(struct cpufreq_policy *policy) {
  87         if ((!policy) || (!policy->governor))
  88                 return;
  89
  90         free(policy->governor);
  91         policy->governor = NULL;
  92         free(policy);
  93 }
  94
  95 struct cpufreq_available_governors * cpufreq_get_available_governors(unsigned int cpu) {
  96         struct cpufreq_available_governors *ret;
  97         ret = sysfs_get_available_governors(cpu);
  98         if (!ret)
  99                 ret = proc_get_available_governors(cpu);
 100         return (ret);
 101 }
 102
 103 void cpufreq_put_available_governors(struct cpufreq_available_governors *any) {
 104         struct cpufreq_available_governors *tmp, *next;
 105
 106         if (!any)
 107                 return;
 108
 109         tmp = any->first;
 110         while (tmp) {
 111                 next = tmp->next;
 112                 if (tmp->governor)
 113                         free(tmp->governor);
 114                 free(tmp);
 115                 tmp = next;
 116         }
 117 }
 118
 119
 120 struct cpufreq_available_frequencies * cpufreq_get_available_frequencies(unsigned int cpu) {
 121         struct cpufreq_available_frequencies * ret;
 122         ret = sysfs_get_available_frequencies(cpu);
 123         if (!ret)
 124                 ret = proc_get_available_frequencies(cpu);
 125         return (ret);
 126 }
 127
 128 void cpufreq_put_available_frequencies(struct cpufreq_available_frequencies *any) {
 129         struct cpufreq_available_frequencies *tmp, *next;
 130
 131         if (!any)
 132                 return;
 133
 134         tmp = any->first;
 135         while (tmp) {
 136                 next = tmp->next;
 137                 free(tmp);
 138                 tmp = next;
 139         }
 140 }
 141
 142
 143 struct cpufreq_affected_cpus * cpufreq_get_affected_cpus(unsigned int cpu) {
 144         struct cpufreq_affected_cpus * ret;
 145         ret = sysfs_get_affected_cpus(cpu);
 146         if (!ret)
 147                 ret = proc_get_affected_cpus(cpu);
 148         return (ret);
 149 }
 150
 151 void cpufreq_put_affected_cpus(struct cpufreq_affected_cpus *any) {
 152         struct cpufreq_affected_cpus *tmp, *next;
 153
 154         if (!any)
 155                 return;
 156
 157         tmp = any->first;
 158         while (tmp) {
 159                 next = tmp->next;
 160                 free(tmp);
 161                 tmp = next;
 162         }
 163 }
 164
 165
 166 struct cpufreq_affected_cpus * cpufreq_get_related_cpus(unsigned int cpu) {
 167         struct cpufreq_affected_cpus * ret;
 168         ret = sysfs_get_related_cpus(cpu);
 169         if (!ret)
 170                 ret = proc_get_related_cpus(cpu);
 171         return (ret);
 172 }
 173
 174 void cpufreq_put_related_cpus(struct cpufreq_affected_cpus *any) {
 175         cpufreq_put_affected_cpus(any);
 176 }
 177
 178
 179 int cpufreq_set_policy(unsigned int cpu, struct cpufreq_policy *policy) {
 180         int ret;
 181         if (!policy || !(policy->governor))
 182                 return -EINVAL;
 183
 184         ret = sysfs_set_policy(cpu, policy);
 185         if (ret)
 186                 ret = proc_set_policy(cpu, policy);
 187         return (ret);
 188 }
 189
 190
 191 int cpufreq_modify_policy_min(unsigned int cpu, unsigned long min_freq) {
 192         int ret;
 193
 194         ret = sysfs_modify_policy_min(cpu, min_freq);
 195         if (ret)
 196                 ret = proc_modify_policy_min(cpu, min_freq);
 197         return (ret);
 198 }
 199
 200
 201 int cpufreq_modify_policy_max(unsigned int cpu, unsigned long max_freq) {
 202         int ret;
 203
 204         ret = sysfs_modify_policy_max(cpu, max_freq);
 205         if (ret)
 206                 ret = proc_modify_policy_max(cpu, max_freq);
 207         return (ret);
 208 }
 209
 210
 211 int cpufreq_modify_policy_governor(unsigned int cpu, char *governor) {
 212         int ret;
 213
 214         if ((!governor) || (strlen(governor) > 19))
 215                 return -EINVAL;
 216
 217         ret = sysfs_modify_policy_governor(cpu, governor);
 218         if (ret)
 219                 ret = proc_modify_policy_governor(cpu, governor);
 220         return (ret);
 221 }
 222
 223 int cpufreq_set_frequency(unsigned int cpu, unsigned long target_frequency) {
 224         int ret;
 225
 226         ret = sysfs_set_frequency(cpu, target_frequency);
 227         if (ret)
 228                 ret = proc_set_frequency(cpu, target_frequency);
 229         return (ret);
 230 }
 231
 232 struct cpufreq_stats * cpufreq_get_stats(unsigned int cpu, unsigned long long *total_time) {
 233         struct cpufreq_stats *ret;
 234
 235         ret = sysfs_get_stats(cpu, total_time);
 236         return (ret);
 237 }
 238
 239 void cpufreq_put_stats(struct cpufreq_stats *any) {
 240         struct cpufreq_stats *tmp, *next;
 241
 242         if (!any)
 243                 return;
 244
 245         tmp = any->first;
 246         while (tmp) {
 247                 next = tmp->next;
 248                 free(tmp);
 249                 tmp = next;
 250         }
 251 }
 252
 253 unsigned long cpufreq_get_transitions(unsigned int cpu) {
 254         unsigned long ret = sysfs_get_transitions(cpu);
 255
 256         return (ret);
 257 }
 258
 259 unsigned int count_cpus(void)
 260 {
 261         FILE *fp;
 262         char value[LINE_LEN];
 263         unsigned int ret = 0;
 264         unsigned int cpunr = 0;
 265
 266         fp = fopen("/proc/stat", "r");
 267         if(!fp) {
 268                 //printf(gettext("Couldn't count the number of CPUs (%s: %s), assuming 1\n"), "/proc/stat", strerror(errno));
 269                 return 1;
 270         }
 271
 272         while (!feof(fp)) {
 273                 if (!fgets(value, LINE_LEN, fp))
 274                         continue;
 275                 value[LINE_LEN - 1] = '\0';
 276                 if (strlen(value) < (LINE_LEN - 2))
 277                         continue;
 278                 if (strstr(value, "cpu "))
 279                         continue;
 280                 if (sscanf(value, "cpu%d ", &cpunr) != 1)
 281                         continue;
 282                 if (cpunr > ret)
 283                         ret = cpunr;
 284         }
 285         fclose(fp);
 286
 287         /* cpu count starts from 0, on error return 1 (UP) */
 288         return (ret+1);
 289 }
 290
 291 unsigned long cpufreq_get_up_threshold(unsigned int cpu)
 292 {
 293     unsigned long ret = sysfs_get_up_threshold(cpu);
 294     return (ret);
 295 }
 296
 297 unsigned long cpufreq_get_sampling_rate(unsigned int cpu)
 298 {
 299     unsigned long ret = sysfs_get_sampling_rate(cpu);
 300     return (ret);
 301 }
 302
 303 int cpufreq_set_up_threshold(unsigned int cpu, unsigned long target_up_threshold)
 304 {
 305     int ret;
 306     ret = sysfs_set_up_threshold(cpu, target_up_threshold);
 307     return (ret);
 308 }
 309
 310 int cpufreq_set_sampling_rate(unsigned int cpu, unsigned long target_sampling_rate)
 311 {
 312     int ret;
 313     ret = sysfs_set_sampling_rate(cpu, target_sampling_rate);
 314     return (ret);
 315 }
 316
 317 int cpufreq_get_ignore_nice_load(unsigned int cpu)
 318 {
 319     return sysfs_get_ignore_nice_load(cpu);
 320 }
 321
 322 int cpufreq_set_ignore_nice_load(unsigned int cpu, int target_ignore_nice_load)
 323 {
 324     return sysfs_set_ignore_nice_load(cpu, target_ignore_nice_load);
 325 }
 326
 327 int cpufreq_get_SmartReflex()
 328 {
 329     return sysfs_get_SmartReflex();
 330 }
 331
 332 int cpufreq_set_SmartReflex(int target_ignore_nice_load)
 333 {
 334     sysfs_set_SmartReflex(target_ignore_nice_load);
 335 }