1 // SPDX-License-Identifier: GPL-2.0-only
3 * (C) 2004-2009 Dominik Brodowski <linux@dominikbrodowski.de>
11 #include <sys/types.h>
17 #include "cpupower_intern.h"
19 /* CPUFREQ sysfs access **************************************************/
21 /* helper function to read file from /sys into given buffer */
22 /* fname is a relative path under "cpuX/cpufreq" dir */
23 static unsigned int sysfs_cpufreq_read_file(unsigned int cpu, const char *fname,
24 char *buf, size_t buflen)
26 char path[SYSFS_PATH_MAX];
28 snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
30 return cpupower_read_sysfs(path, buf, buflen);
33 /* helper function to write a new value to a /sys file */
34 /* fname is a relative path under "cpuX/cpufreq" dir */
35 static unsigned int sysfs_cpufreq_write_file(unsigned int cpu,
37 const char *value, size_t len)
39 char path[SYSFS_PATH_MAX];
43 snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
46 fd = open(path, O_WRONLY);
50 numwrite = write(fd, value, len);
58 return (unsigned int) numwrite;
61 /* read access to files which contain one numeric value */
71 STATS_NUM_TRANSITIONS,
72 MAX_CPUFREQ_VALUE_READ_FILES
75 static const char *cpufreq_value_files[MAX_CPUFREQ_VALUE_READ_FILES] = {
76 [CPUINFO_CUR_FREQ] = "cpuinfo_cur_freq",
77 [CPUINFO_MIN_FREQ] = "cpuinfo_min_freq",
78 [CPUINFO_MAX_FREQ] = "cpuinfo_max_freq",
79 [CPUINFO_LATENCY] = "cpuinfo_transition_latency",
80 [SCALING_CUR_FREQ] = "scaling_cur_freq",
81 [SCALING_MIN_FREQ] = "scaling_min_freq",
82 [SCALING_MAX_FREQ] = "scaling_max_freq",
83 [STATS_NUM_TRANSITIONS] = "stats/total_trans"
86 unsigned long cpufreq_get_sysfs_value_from_table(unsigned int cpu,
93 char linebuf[MAX_LINE_LEN];
96 if (!table || index >= size || !table[index])
99 len = sysfs_cpufreq_read_file(cpu, table[index], linebuf,
105 value = strtoul(linebuf, &endp, 0);
107 if (endp == linebuf || errno == ERANGE)
113 static unsigned long sysfs_cpufreq_get_one_value(unsigned int cpu,
114 enum cpufreq_value which)
116 return cpufreq_get_sysfs_value_from_table(cpu, cpufreq_value_files,
118 MAX_CPUFREQ_VALUE_READ_FILES);
121 /* read access to files which contain one string */
123 enum cpufreq_string {
126 MAX_CPUFREQ_STRING_FILES
129 static const char *cpufreq_string_files[MAX_CPUFREQ_STRING_FILES] = {
130 [SCALING_DRIVER] = "scaling_driver",
131 [SCALING_GOVERNOR] = "scaling_governor",
135 static char *sysfs_cpufreq_get_one_string(unsigned int cpu,
136 enum cpufreq_string which)
138 char linebuf[MAX_LINE_LEN];
142 if (which >= MAX_CPUFREQ_STRING_FILES)
145 len = sysfs_cpufreq_read_file(cpu, cpufreq_string_files[which],
146 linebuf, sizeof(linebuf));
150 result = strdup(linebuf);
154 if (result[strlen(result) - 1] == '\n')
155 result[strlen(result) - 1] = '\0';
163 WRITE_SCALING_MIN_FREQ,
164 WRITE_SCALING_MAX_FREQ,
165 WRITE_SCALING_GOVERNOR,
166 WRITE_SCALING_SET_SPEED,
167 MAX_CPUFREQ_WRITE_FILES
170 static const char *cpufreq_write_files[MAX_CPUFREQ_WRITE_FILES] = {
171 [WRITE_SCALING_MIN_FREQ] = "scaling_min_freq",
172 [WRITE_SCALING_MAX_FREQ] = "scaling_max_freq",
173 [WRITE_SCALING_GOVERNOR] = "scaling_governor",
174 [WRITE_SCALING_SET_SPEED] = "scaling_setspeed",
177 static int sysfs_cpufreq_write_one_value(unsigned int cpu,
178 enum cpufreq_write which,
179 const char *new_value, size_t len)
181 if (which >= MAX_CPUFREQ_WRITE_FILES)
184 if (sysfs_cpufreq_write_file(cpu, cpufreq_write_files[which],
185 new_value, len) != len)
191 unsigned long cpufreq_get_freq_kernel(unsigned int cpu)
193 return sysfs_cpufreq_get_one_value(cpu, SCALING_CUR_FREQ);
196 unsigned long cpufreq_get_freq_hardware(unsigned int cpu)
198 return sysfs_cpufreq_get_one_value(cpu, CPUINFO_CUR_FREQ);
201 unsigned long cpufreq_get_transition_latency(unsigned int cpu)
203 return sysfs_cpufreq_get_one_value(cpu, CPUINFO_LATENCY);
206 int cpufreq_get_hardware_limits(unsigned int cpu,
210 if ((!min) || (!max))
213 *min = sysfs_cpufreq_get_one_value(cpu, CPUINFO_MIN_FREQ);
217 *max = sysfs_cpufreq_get_one_value(cpu, CPUINFO_MAX_FREQ);
224 char *cpufreq_get_driver(unsigned int cpu)
226 return sysfs_cpufreq_get_one_string(cpu, SCALING_DRIVER);
229 void cpufreq_put_driver(char *ptr)
236 struct cpufreq_policy *cpufreq_get_policy(unsigned int cpu)
238 struct cpufreq_policy *policy;
240 policy = malloc(sizeof(struct cpufreq_policy));
244 policy->governor = sysfs_cpufreq_get_one_string(cpu, SCALING_GOVERNOR);
245 if (!policy->governor) {
249 policy->min = sysfs_cpufreq_get_one_value(cpu, SCALING_MIN_FREQ);
250 policy->max = sysfs_cpufreq_get_one_value(cpu, SCALING_MAX_FREQ);
251 if ((!policy->min) || (!policy->max)) {
252 free(policy->governor);
260 void cpufreq_put_policy(struct cpufreq_policy *policy)
262 if ((!policy) || (!policy->governor))
265 free(policy->governor);
266 policy->governor = NULL;
270 struct cpufreq_available_governors *cpufreq_get_available_governors(unsigned
273 struct cpufreq_available_governors *first = NULL;
274 struct cpufreq_available_governors *current = NULL;
275 char linebuf[MAX_LINE_LEN];
279 len = sysfs_cpufreq_read_file(cpu, "scaling_available_governors",
280 linebuf, sizeof(linebuf));
285 for (i = 0; i < len; i++) {
286 if (linebuf[i] == ' ' || linebuf[i] == '\n') {
290 current->next = malloc(sizeof(*current));
293 current = current->next;
295 first = malloc(sizeof(*first));
300 current->first = first;
301 current->next = NULL;
303 current->governor = malloc(i - pos + 1);
304 if (!current->governor)
307 memcpy(current->governor, linebuf + pos, i - pos);
308 current->governor[i - pos] = '\0';
317 current = first->next;
319 free(first->governor);
326 void cpufreq_put_available_governors(struct cpufreq_available_governors *any)
328 struct cpufreq_available_governors *tmp, *next;
344 struct cpufreq_available_frequencies
345 *cpufreq_get_available_frequencies(unsigned int cpu)
347 struct cpufreq_available_frequencies *first = NULL;
348 struct cpufreq_available_frequencies *current = NULL;
349 char one_value[SYSFS_PATH_MAX];
350 char linebuf[MAX_LINE_LEN];
354 len = sysfs_cpufreq_read_file(cpu, "scaling_available_frequencies",
355 linebuf, sizeof(linebuf));
360 for (i = 0; i < len; i++) {
361 if (linebuf[i] == ' ' || linebuf[i] == '\n') {
364 if (i - pos >= SYSFS_PATH_MAX)
367 current->next = malloc(sizeof(*current));
370 current = current->next;
372 first = malloc(sizeof(*first));
377 current->first = first;
378 current->next = NULL;
380 memcpy(one_value, linebuf + pos, i - pos);
381 one_value[i - pos] = '\0';
382 if (sscanf(one_value, "%lu", ¤t->frequency) != 1)
393 current = first->next;
400 struct cpufreq_available_frequencies
401 *cpufreq_get_boost_frequencies(unsigned int cpu)
403 struct cpufreq_available_frequencies *first = NULL;
404 struct cpufreq_available_frequencies *current = NULL;
405 char one_value[SYSFS_PATH_MAX];
406 char linebuf[MAX_LINE_LEN];
410 len = sysfs_cpufreq_read_file(cpu, "scaling_boost_frequencies",
411 linebuf, sizeof(linebuf));
416 for (i = 0; i < len; i++) {
417 if (linebuf[i] == ' ' || linebuf[i] == '\n') {
420 if (i - pos >= SYSFS_PATH_MAX)
423 current->next = malloc(sizeof(*current));
426 current = current->next;
428 first = malloc(sizeof(*first));
433 current->first = first;
434 current->next = NULL;
436 memcpy(one_value, linebuf + pos, i - pos);
437 one_value[i - pos] = '\0';
438 if (sscanf(one_value, "%lu", ¤t->frequency) != 1)
449 current = first->next;
456 void cpufreq_put_available_frequencies(struct cpufreq_available_frequencies *any)
458 struct cpufreq_available_frequencies *tmp, *next;
471 void cpufreq_put_boost_frequencies(struct cpufreq_available_frequencies *any)
473 cpufreq_put_available_frequencies(any);
476 static struct cpufreq_affected_cpus *sysfs_get_cpu_list(unsigned int cpu,
479 struct cpufreq_affected_cpus *first = NULL;
480 struct cpufreq_affected_cpus *current = NULL;
481 char one_value[SYSFS_PATH_MAX];
482 char linebuf[MAX_LINE_LEN];
486 len = sysfs_cpufreq_read_file(cpu, file, linebuf, sizeof(linebuf));
491 for (i = 0; i < len; i++) {
492 if (i == len || linebuf[i] == ' ' || linebuf[i] == '\n') {
495 if (i - pos >= SYSFS_PATH_MAX)
498 current->next = malloc(sizeof(*current));
501 current = current->next;
503 first = malloc(sizeof(*first));
508 current->first = first;
509 current->next = NULL;
511 memcpy(one_value, linebuf + pos, i - pos);
512 one_value[i - pos] = '\0';
514 if (sscanf(one_value, "%u", ¤t->cpu) != 1)
525 current = first->next;
532 struct cpufreq_affected_cpus *cpufreq_get_affected_cpus(unsigned int cpu)
534 return sysfs_get_cpu_list(cpu, "affected_cpus");
537 void cpufreq_put_affected_cpus(struct cpufreq_affected_cpus *any)
539 struct cpufreq_affected_cpus *tmp, *next;
553 struct cpufreq_affected_cpus *cpufreq_get_related_cpus(unsigned int cpu)
555 return sysfs_get_cpu_list(cpu, "related_cpus");
558 void cpufreq_put_related_cpus(struct cpufreq_affected_cpus *any)
560 cpufreq_put_affected_cpus(any);
563 static int verify_gov(char *new_gov, char *passed_gov)
565 unsigned int i, j = 0;
567 if (!passed_gov || (strlen(passed_gov) > 19))
570 strncpy(new_gov, passed_gov, 20);
571 for (i = 0; i < 20; i++) {
576 if ((new_gov[i] >= 'a') && (new_gov[i] <= 'z'))
579 if ((new_gov[i] >= 'A') && (new_gov[i] <= 'Z'))
582 if (new_gov[i] == '-')
585 if (new_gov[i] == '_')
588 if (new_gov[i] == '\0') {
598 int cpufreq_set_policy(unsigned int cpu, struct cpufreq_policy *policy)
600 char min[SYSFS_PATH_MAX];
601 char max[SYSFS_PATH_MAX];
602 char gov[SYSFS_PATH_MAX];
604 unsigned long old_min;
607 if (!policy || !(policy->governor))
610 if (policy->max < policy->min)
613 if (verify_gov(gov, policy->governor))
616 snprintf(min, SYSFS_PATH_MAX, "%lu", policy->min);
617 snprintf(max, SYSFS_PATH_MAX, "%lu", policy->max);
619 old_min = sysfs_cpufreq_get_one_value(cpu, SCALING_MIN_FREQ);
620 write_max_first = (old_min && (policy->max < old_min) ? 0 : 1);
622 if (write_max_first) {
623 ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
629 ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MIN_FREQ, min,
634 if (!write_max_first) {
635 ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
641 return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_GOVERNOR,
646 int cpufreq_modify_policy_min(unsigned int cpu, unsigned long min_freq)
648 char value[SYSFS_PATH_MAX];
650 snprintf(value, SYSFS_PATH_MAX, "%lu", min_freq);
652 return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MIN_FREQ,
653 value, strlen(value));
657 int cpufreq_modify_policy_max(unsigned int cpu, unsigned long max_freq)
659 char value[SYSFS_PATH_MAX];
661 snprintf(value, SYSFS_PATH_MAX, "%lu", max_freq);
663 return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
664 value, strlen(value));
667 int cpufreq_modify_policy_governor(unsigned int cpu, char *governor)
669 char new_gov[SYSFS_PATH_MAX];
671 if ((!governor) || (strlen(governor) > 19))
674 if (verify_gov(new_gov, governor))
677 return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_GOVERNOR,
678 new_gov, strlen(new_gov));
681 int cpufreq_set_frequency(unsigned int cpu, unsigned long target_frequency)
683 struct cpufreq_policy *pol = cpufreq_get_policy(cpu);
684 char userspace_gov[] = "userspace";
685 char freq[SYSFS_PATH_MAX];
691 if (strncmp(pol->governor, userspace_gov, 9) != 0) {
692 ret = cpufreq_modify_policy_governor(cpu, userspace_gov);
694 cpufreq_put_policy(pol);
699 cpufreq_put_policy(pol);
701 snprintf(freq, SYSFS_PATH_MAX, "%lu", target_frequency);
703 return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_SET_SPEED,
707 struct cpufreq_stats *cpufreq_get_stats(unsigned int cpu,
708 unsigned long long *total_time)
710 struct cpufreq_stats *first = NULL;
711 struct cpufreq_stats *current = NULL;
712 char one_value[SYSFS_PATH_MAX];
713 char linebuf[MAX_LINE_LEN];
717 len = sysfs_cpufreq_read_file(cpu, "stats/time_in_state",
718 linebuf, sizeof(linebuf));
724 for (i = 0; i < len; i++) {
725 if (i == strlen(linebuf) || linebuf[i] == '\n') {
728 if ((i - pos) >= SYSFS_PATH_MAX)
731 current->next = malloc(sizeof(*current));
734 current = current->next;
736 first = malloc(sizeof(*first));
741 current->first = first;
742 current->next = NULL;
744 memcpy(one_value, linebuf + pos, i - pos);
745 one_value[i - pos] = '\0';
746 if (sscanf(one_value, "%lu %llu",
748 ¤t->time_in_state) != 2)
751 *total_time = *total_time + current->time_in_state;
760 current = first->next;
767 void cpufreq_put_stats(struct cpufreq_stats *any)
769 struct cpufreq_stats *tmp, *next;
782 unsigned long cpufreq_get_transitions(unsigned int cpu)
784 return sysfs_cpufreq_get_one_value(cpu, STATS_NUM_TRANSITIONS);