~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/power/cpupower/lib/cpufreq.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include <sys/types.h>
 13 #include <sys/stat.h>
 14 #include <fcntl.h>
 15 #include <unistd.h>
 16 
 17 #include "cpufreq.h"
 18 #include "cpupower_intern.h"
 19 
 20 /* CPUFREQ sysfs access **************************************************/
 21 
 22 /* helper function to read file from /sys into given buffer */
 23 /* fname is a relative path under "cpuX/cpufreq" dir */
 24 static unsigned int sysfs_cpufreq_read_file(unsigned int cpu, const char *fname,
 25                                             char *buf, size_t buflen)
 26 {
 27         char path[SYSFS_PATH_MAX];
 28 
 29         snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
 30                          cpu, fname);
 31         return sysfs_read_file(path, buf, buflen);
 32 }
 33 
 34 /* helper function to write a new value to a /sys file */
 35 /* fname is a relative path under "cpuX/cpufreq" dir */
 36 static unsigned int sysfs_cpufreq_write_file(unsigned int cpu,
 37                                              const char *fname,
 38                                              const char *value, size_t len)
 39 {
 40         char path[SYSFS_PATH_MAX];
 41         int fd;
 42         ssize_t numwrite;
 43 
 44         snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
 45                          cpu, fname);
 46 
 47         fd = open(path, O_WRONLY);
 48         if (fd == -1)
 49                 return 0;
 50 
 51         numwrite = write(fd, value, len);
 52         if (numwrite < 1) {
 53                 close(fd);
 54                 return 0;
 55         }
 56 
 57         close(fd);
 58 
 59         return (unsigned int) numwrite;
 60 }
 61 
 62 /* read access to files which contain one numeric value */
 63 
 64 enum cpufreq_value {
 65         CPUINFO_CUR_FREQ,
 66         CPUINFO_MIN_FREQ,
 67         CPUINFO_MAX_FREQ,
 68         CPUINFO_LATENCY,
 69         SCALING_CUR_FREQ,
 70         SCALING_MIN_FREQ,
 71         SCALING_MAX_FREQ,
 72         STATS_NUM_TRANSITIONS,
 73         MAX_CPUFREQ_VALUE_READ_FILES
 74 };
 75 
 76 static const char *cpufreq_value_files[MAX_CPUFREQ_VALUE_READ_FILES] = {
 77         [CPUINFO_CUR_FREQ] = "cpuinfo_cur_freq",
 78         [CPUINFO_MIN_FREQ] = "cpuinfo_min_freq",
 79         [CPUINFO_MAX_FREQ] = "cpuinfo_max_freq",
 80         [CPUINFO_LATENCY]  = "cpuinfo_transition_latency",
 81         [SCALING_CUR_FREQ] = "scaling_cur_freq",
 82         [SCALING_MIN_FREQ] = "scaling_min_freq",
 83         [SCALING_MAX_FREQ] = "scaling_max_freq",
 84         [STATS_NUM_TRANSITIONS] = "stats/total_trans"
 85 };
 86 
 87 
 88 static unsigned long sysfs_cpufreq_get_one_value(unsigned int cpu,
 89                                                  enum cpufreq_value which)
 90 {
 91         unsigned long value;
 92         unsigned int len;
 93         char linebuf[MAX_LINE_LEN];
 94         char *endp;
 95 
 96         if (which >= MAX_CPUFREQ_VALUE_READ_FILES)
 97                 return 0;
 98 
 99         len = sysfs_cpufreq_read_file(cpu, cpufreq_value_files[which],
100                                 linebuf, sizeof(linebuf));
101 
102         if (len == 0)
103                 return 0;
104 
105         value = strtoul(linebuf, &endp, 0);
106 
107         if (endp == linebuf || errno == ERANGE)
108                 return 0;
109 
110         return value;
111 }
112 
113 /* read access to files which contain one string */
114 
115 enum cpufreq_string {
116         SCALING_DRIVER,
117         SCALING_GOVERNOR,
118         MAX_CPUFREQ_STRING_FILES
119 };
120 
121 static const char *cpufreq_string_files[MAX_CPUFREQ_STRING_FILES] = {
122         [SCALING_DRIVER] = "scaling_driver",
123         [SCALING_GOVERNOR] = "scaling_governor",
124 };
125 
126 
127 static char *sysfs_cpufreq_get_one_string(unsigned int cpu,
128                                            enum cpufreq_string which)
129 {
130         char linebuf[MAX_LINE_LEN];
131         char *result;
132         unsigned int len;
133 
134         if (which >= MAX_CPUFREQ_STRING_FILES)
135                 return NULL;
136 
137         len = sysfs_cpufreq_read_file(cpu, cpufreq_string_files[which],
138                                 linebuf, sizeof(linebuf));
139         if (len == 0)
140                 return NULL;
141 
142         result = strdup(linebuf);
143         if (result == NULL)
144                 return NULL;
145 
146         if (result[strlen(result) - 1] == '\n')
147                 result[strlen(result) - 1] = '\0';
148 
149         return result;
150 }
151 
152 /* write access */
153 
154 enum cpufreq_write {
155         WRITE_SCALING_MIN_FREQ,
156         WRITE_SCALING_MAX_FREQ,
157         WRITE_SCALING_GOVERNOR,
158         WRITE_SCALING_SET_SPEED,
159         MAX_CPUFREQ_WRITE_FILES
160 };
161 
162 static const char *cpufreq_write_files[MAX_CPUFREQ_WRITE_FILES] = {
163         [WRITE_SCALING_MIN_FREQ] = "scaling_min_freq",
164         [WRITE_SCALING_MAX_FREQ] = "scaling_max_freq",
165         [WRITE_SCALING_GOVERNOR] = "scaling_governor",
166         [WRITE_SCALING_SET_SPEED] = "scaling_setspeed",
167 };
168 
169 static int sysfs_cpufreq_write_one_value(unsigned int cpu,
170                                          enum cpufreq_write which,
171                                          const char *new_value, size_t len)
172 {
173         if (which >= MAX_CPUFREQ_WRITE_FILES)
174                 return 0;
175 
176         if (sysfs_cpufreq_write_file(cpu, cpufreq_write_files[which],
177                                         new_value, len) != len)
178                 return -ENODEV;
179 
180         return 0;
181 };
182 
183 unsigned long cpufreq_get_freq_kernel(unsigned int cpu)
184 {
185         return sysfs_cpufreq_get_one_value(cpu, SCALING_CUR_FREQ);
186 }
187 
188 unsigned long cpufreq_get_freq_hardware(unsigned int cpu)
189 {
190         return sysfs_cpufreq_get_one_value(cpu, CPUINFO_CUR_FREQ);
191 }
192 
193 unsigned long cpufreq_get_transition_latency(unsigned int cpu)
194 {
195         return sysfs_cpufreq_get_one_value(cpu, CPUINFO_LATENCY);
196 }
197 
198 int cpufreq_get_hardware_limits(unsigned int cpu,
199                                 unsigned long *min,
200                                 unsigned long *max)
201 {
202         if ((!min) || (!max))
203                 return -EINVAL;
204 
205         *min = sysfs_cpufreq_get_one_value(cpu, CPUINFO_MIN_FREQ);
206         if (!*min)
207                 return -ENODEV;
208 
209         *max = sysfs_cpufreq_get_one_value(cpu, CPUINFO_MAX_FREQ);
210         if (!*max)
211                 return -ENODEV;
212 
213         return 0;
214 }
215 
216 char *cpufreq_get_driver(unsigned int cpu)
217 {
218         return sysfs_cpufreq_get_one_string(cpu, SCALING_DRIVER);
219 }
220 
221 void cpufreq_put_driver(char *ptr)
222 {
223         if (!ptr)
224                 return;
225         free(ptr);
226 }
227 
228 struct cpufreq_policy *cpufreq_get_policy(unsigned int cpu)
229 {
230         struct cpufreq_policy *policy;
231 
232         policy = malloc(sizeof(struct cpufreq_policy));
233         if (!policy)
234                 return NULL;
235 
236         policy->governor = sysfs_cpufreq_get_one_string(cpu, SCALING_GOVERNOR);
237         if (!policy->governor) {
238                 free(policy);
239                 return NULL;
240         }
241         policy->min = sysfs_cpufreq_get_one_value(cpu, SCALING_MIN_FREQ);
242         policy->max = sysfs_cpufreq_get_one_value(cpu, SCALING_MAX_FREQ);
243         if ((!policy->min) || (!policy->max)) {
244                 free(policy->governor);
245                 free(policy);
246                 return NULL;
247         }
248 
249         return policy;
250 }
251 
252 void cpufreq_put_policy(struct cpufreq_policy *policy)
253 {
254         if ((!policy) || (!policy->governor))
255                 return;
256 
257         free(policy->governor);
258         policy->governor = NULL;
259         free(policy);
260 }
261 
262 struct cpufreq_available_governors *cpufreq_get_available_governors(unsigned
263                                                                 int cpu)
264 {
265         struct cpufreq_available_governors *first = NULL;
266         struct cpufreq_available_governors *current = NULL;
267         char linebuf[MAX_LINE_LEN];
268         unsigned int pos, i;
269         unsigned int len;
270 
271         len = sysfs_cpufreq_read_file(cpu, "scaling_available_governors",
272                                 linebuf, sizeof(linebuf));
273         if (len == 0)
274                 return NULL;
275 
276         pos = 0;
277         for (i = 0; i < len; i++) {
278                 if (linebuf[i] == ' ' || linebuf[i] == '\n') {
279                         if (i - pos < 2)
280                                 continue;
281                         if (current) {
282                                 current->next = malloc(sizeof(*current));
283                                 if (!current->next)
284                                         goto error_out;
285                                 current = current->next;
286                         } else {
287                                 first = malloc(sizeof(*first));
288                                 if (!first)
289                                         goto error_out;
290                                 current = first;
291                         }
292                         current->first = first;
293                         current->next = NULL;
294 
295                         current->governor = malloc(i - pos + 1);
296                         if (!current->governor)
297                                 goto error_out;
298 
299                         memcpy(current->governor, linebuf + pos, i - pos);
300                         current->governor[i - pos] = '\0';
301                         pos = i + 1;
302                 }
303         }
304 
305         return first;
306 
307  error_out:
308         while (first) {
309                 current = first->next;
310                 if (first->governor)
311                         free(first->governor);
312                 free(first);
313                 first = current;
314         }
315         return NULL;
316 }
317 
318 void cpufreq_put_available_governors(struct cpufreq_available_governors *any)
319 {
320         struct cpufreq_available_governors *tmp, *next;
321 
322         if (!any)
323                 return;
324 
325         tmp = any->first;
326         while (tmp) {
327                 next = tmp->next;
328                 if (tmp->governor)
329                         free(tmp->governor);
330                 free(tmp);
331                 tmp = next;
332         }
333 }
334 
335 
336 struct cpufreq_available_frequencies
337 *cpufreq_get_available_frequencies(unsigned int cpu)
338 {
339         struct cpufreq_available_frequencies *first = NULL;
340         struct cpufreq_available_frequencies *current = NULL;
341         char one_value[SYSFS_PATH_MAX];
342         char linebuf[MAX_LINE_LEN];
343         unsigned int pos, i;
344         unsigned int len;
345 
346         len = sysfs_cpufreq_read_file(cpu, "scaling_available_frequencies",
347                                 linebuf, sizeof(linebuf));
348         if (len == 0)
349                 return NULL;
350 
351         pos = 0;
352         for (i = 0; i < len; i++) {
353                 if (linebuf[i] == ' ' || linebuf[i] == '\n') {
354                         if (i - pos < 2)
355                                 continue;
356                         if (i - pos >= SYSFS_PATH_MAX)
357                                 goto error_out;
358                         if (current) {
359                                 current->next = malloc(sizeof(*current));
360                                 if (!current->next)
361                                         goto error_out;
362                                 current = current->next;
363                         } else {
364                                 first = malloc(sizeof(*first));
365                                 if (!first)
366                                         goto error_out;
367                                 current = first;
368                         }
369                         current->first = first;
370                         current->next = NULL;
371 
372                         memcpy(one_value, linebuf + pos, i - pos);
373                         one_value[i - pos] = '\0';
374                         if (sscanf(one_value, "%lu", &current->frequency) != 1)
375                                 goto error_out;
376 
377                         pos = i + 1;
378                 }
379         }
380 
381         return first;
382 
383  error_out:
384         while (first) {
385                 current = first->next;
386                 free(first);
387                 first = current;
388         }
389         return NULL;
390 }
391 
392 void cpufreq_put_available_frequencies(struct cpufreq_available_frequencies
393                                 *any) {
394         struct cpufreq_available_frequencies *tmp, *next;
395 
396         if (!any)
397                 return;
398 
399         tmp = any->first;
400         while (tmp) {
401                 next = tmp->next;
402                 free(tmp);
403                 tmp = next;
404         }
405 }
406 
407 static struct cpufreq_affected_cpus *sysfs_get_cpu_list(unsigned int cpu,
408                                                         const char *file)
409 {
410         struct cpufreq_affected_cpus *first = NULL;
411         struct cpufreq_affected_cpus *current = NULL;
412         char one_value[SYSFS_PATH_MAX];
413         char linebuf[MAX_LINE_LEN];
414         unsigned int pos, i;
415         unsigned int len;
416 
417         len = sysfs_cpufreq_read_file(cpu, file, linebuf, sizeof(linebuf));
418         if (len == 0)
419                 return NULL;
420 
421         pos = 0;
422         for (i = 0; i < len; i++) {
423                 if (i == len || linebuf[i] == ' ' || linebuf[i] == '\n') {
424                         if (i - pos  < 1)
425                                 continue;
426                         if (i - pos >= SYSFS_PATH_MAX)
427                                 goto error_out;
428                         if (current) {
429                                 current->next = malloc(sizeof(*current));
430                                 if (!current->next)
431                                         goto error_out;
432                                 current = current->next;
433                         } else {
434                                 first = malloc(sizeof(*first));
435                                 if (!first)
436                                         goto error_out;
437                                 current = first;
438                         }
439                         current->first = first;
440                         current->next = NULL;
441 
442                         memcpy(one_value, linebuf + pos, i - pos);
443                         one_value[i - pos] = '\0';
444 
445                         if (sscanf(one_value, "%u", &current->cpu) != 1)
446                                 goto error_out;
447 
448                         pos = i + 1;
449                 }
450         }
451 
452         return first;
453 
454  error_out:
455         while (first) {
456                 current = first->next;
457                 free(first);
458                 first = current;
459         }
460         return NULL;
461 }
462 
463 struct cpufreq_affected_cpus *cpufreq_get_affected_cpus(unsigned int cpu)
464 {
465         return sysfs_get_cpu_list(cpu, "affected_cpus");
466 }
467 
468 void cpufreq_put_affected_cpus(struct cpufreq_affected_cpus *any)
469 {
470         struct cpufreq_affected_cpus *tmp, *next;
471 
472         if (!any)
473                 return;
474 
475         tmp = any->first;
476         while (tmp) {
477                 next = tmp->next;
478                 free(tmp);
479                 tmp = next;
480         }
481 }
482 
483 
484 struct cpufreq_affected_cpus *cpufreq_get_related_cpus(unsigned int cpu)
485 {
486         return sysfs_get_cpu_list(cpu, "related_cpus");
487 }
488 
489 void cpufreq_put_related_cpus(struct cpufreq_affected_cpus *any)
490 {
491         cpufreq_put_affected_cpus(any);
492 }
493 
494 static int verify_gov(char *new_gov, char *passed_gov)
495 {
496         unsigned int i, j = 0;
497 
498         if (!passed_gov || (strlen(passed_gov) > 19))
499                 return -EINVAL;
500 
501         strncpy(new_gov, passed_gov, 20);
502         for (i = 0; i < 20; i++) {
503                 if (j) {
504                         new_gov[i] = '\0';
505                         continue;
506                 }
507                 if ((new_gov[i] >= 'a') && (new_gov[i] <= 'z'))
508                         continue;
509 
510                 if ((new_gov[i] >= 'A') && (new_gov[i] <= 'Z'))
511                         continue;
512 
513                 if (new_gov[i] == '-')
514                         continue;
515 
516                 if (new_gov[i] == '_')
517                         continue;
518 
519                 if (new_gov[i] == '\0') {
520                         j = 1;
521                         continue;
522                 }
523                 return -EINVAL;
524         }
525         new_gov[19] = '\0';
526         return 0;
527 }
528 
529 int cpufreq_set_policy(unsigned int cpu, struct cpufreq_policy *policy)
530 {
531         char min[SYSFS_PATH_MAX];
532         char max[SYSFS_PATH_MAX];
533         char gov[SYSFS_PATH_MAX];
534         int ret;
535         unsigned long old_min;
536         int write_max_first;
537 
538         if (!policy || !(policy->governor))
539                 return -EINVAL;
540 
541         if (policy->max < policy->min)
542                 return -EINVAL;
543 
544         if (verify_gov(gov, policy->governor))
545                 return -EINVAL;
546 
547         snprintf(min, SYSFS_PATH_MAX, "%lu", policy->min);
548         snprintf(max, SYSFS_PATH_MAX, "%lu", policy->max);
549 
550         old_min = sysfs_cpufreq_get_one_value(cpu, SCALING_MIN_FREQ);
551         write_max_first = (old_min && (policy->max < old_min) ? 0 : 1);
552 
553         if (write_max_first) {
554                 ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
555                                                     max, strlen(max));
556                 if (ret)
557                         return ret;
558         }
559 
560         ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MIN_FREQ, min,
561                                             strlen(min));
562         if (ret)
563                 return ret;
564 
565         if (!write_max_first) {
566                 ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
567                                                     max, strlen(max));
568                 if (ret)
569                         return ret;
570         }
571 
572         return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_GOVERNOR,
573                                              gov, strlen(gov));
574 }
575 
576 
577 int cpufreq_modify_policy_min(unsigned int cpu, unsigned long min_freq)
578 {
579         char value[SYSFS_PATH_MAX];
580 
581         snprintf(value, SYSFS_PATH_MAX, "%lu", min_freq);
582 
583         return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MIN_FREQ,
584                                              value, strlen(value));
585 }
586 
587 
588 int cpufreq_modify_policy_max(unsigned int cpu, unsigned long max_freq)
589 {
590         char value[SYSFS_PATH_MAX];
591 
592         snprintf(value, SYSFS_PATH_MAX, "%lu", max_freq);
593 
594         return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
595                                              value, strlen(value));
596 }
597 
598 int cpufreq_modify_policy_governor(unsigned int cpu, char *governor)
599 {
600         char new_gov[SYSFS_PATH_MAX];
601 
602         if ((!governor) || (strlen(governor) > 19))
603                 return -EINVAL;
604 
605         if (verify_gov(new_gov, governor))
606                 return -EINVAL;
607 
608         return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_GOVERNOR,
609                                              new_gov, strlen(new_gov));
610 }
611 
612 int cpufreq_set_frequency(unsigned int cpu, unsigned long target_frequency)
613 {
614         struct cpufreq_policy *pol = cpufreq_get_policy(cpu);
615         char userspace_gov[] = "userspace";
616         char freq[SYSFS_PATH_MAX];
617         int ret;
618 
619         if (!pol)
620                 return -ENODEV;
621 
622         if (strncmp(pol->governor, userspace_gov, 9) != 0) {
623                 ret = cpufreq_modify_policy_governor(cpu, userspace_gov);
624                 if (ret) {
625                         cpufreq_put_policy(pol);
626                         return ret;
627                 }
628         }
629 
630         cpufreq_put_policy(pol);
631 
632         snprintf(freq, SYSFS_PATH_MAX, "%lu", target_frequency);
633 
634         return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_SET_SPEED,
635                                              freq, strlen(freq));
636 }
637 
638 struct cpufreq_stats *cpufreq_get_stats(unsigned int cpu,
639                                         unsigned long long *total_time)
640 {
641         struct cpufreq_stats *first = NULL;
642         struct cpufreq_stats *current = NULL;
643         char one_value[SYSFS_PATH_MAX];
644         char linebuf[MAX_LINE_LEN];
645         unsigned int pos, i;
646         unsigned int len;
647 
648         len = sysfs_cpufreq_read_file(cpu, "stats/time_in_state",
649                                 linebuf, sizeof(linebuf));
650         if (len == 0)
651                 return NULL;
652 
653         *total_time = 0;
654         pos = 0;
655         for (i = 0; i < len; i++) {
656                 if (i == strlen(linebuf) || linebuf[i] == '\n') {
657                         if (i - pos < 2)
658                                 continue;
659                         if ((i - pos) >= SYSFS_PATH_MAX)
660                                 goto error_out;
661                         if (current) {
662                                 current->next = malloc(sizeof(*current));
663                                 if (!current->next)
664                                         goto error_out;
665                                 current = current->next;
666                         } else {
667                                 first = malloc(sizeof(*first));
668                                 if (!first)
669                                         goto error_out;
670                                 current = first;
671                         }
672                         current->first = first;
673                         current->next = NULL;
674 
675                         memcpy(one_value, linebuf + pos, i - pos);
676                         one_value[i - pos] = '\0';
677                         if (sscanf(one_value, "%lu %llu",
678                                         &current->frequency,
679                                         &current->time_in_state) != 2)
680                                 goto error_out;
681 
682                         *total_time = *total_time + current->time_in_state;
683                         pos = i + 1;
684                 }
685         }
686 
687         return first;
688 
689  error_out:
690         while (first) {
691                 current = first->next;
692                 free(first);
693                 first = current;
694         }
695         return NULL;
696 }
697 
698 void cpufreq_put_stats(struct cpufreq_stats *any)
699 {
700         struct cpufreq_stats *tmp, *next;
701 
702         if (!any)
703                 return;
704 
705         tmp = any->first;
706         while (tmp) {
707                 next = tmp->next;
708                 free(tmp);
709                 tmp = next;
710         }
711 }
712 
713 unsigned long cpufreq_get_transitions(unsigned int cpu)
714 {
715         return sysfs_cpufreq_get_one_value(cpu, STATS_NUM_TRANSITIONS);
716 }
717 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp