d415b6b52a099af02bda2787d4048a1169f9f1bc
[linux-2.6.git] / tools / power / cpupower / utils / cpufreq-set.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 <unistd.h>
9 #include <stdio.h>
10 #include <errno.h>
11 #include <stdlib.h>
12 #include <limits.h>
13 #include <string.h>
14 #include <ctype.h>
15
16 #include <getopt.h>
17
18 #include "cpufreq.h"
19 #include "helpers/helpers.h"
20
21 #define NORM_FREQ_LEN 32
22
23 void freq_set_help(void)
24 {
25         printf(_("Usage: cpupower frequency-set [options]\n"));
26         printf(_("Options:\n"));
27         printf(_("  -d FREQ, --min FREQ      new minimum CPU frequency the governor may select\n"));
28         printf(_("  -u FREQ, --max FREQ      new maximum CPU frequency the governor may select\n"));
29         printf(_("  -g GOV, --governor GOV   new cpufreq governor\n"));
30         printf(_("  -f FREQ, --freq FREQ     specific frequency to be set. Requires userspace\n"
31                "                           governor to be available and loaded\n"));
32         printf(_("  -r, --related            Switches all hardware-related CPUs\n"));
33         printf(_("  -h, --help               Prints out this screen\n"));
34         printf("\n");
35         printf(_("Notes:\n"
36                "1. Omitting the -c or --cpu argument is equivalent to setting it to \"all\"\n"));
37         printf(_("2. The -f FREQ, --freq FREQ parameter cannot be combined with any other parameter\n"
38                "   except the -c CPU, --cpu CPU parameter\n"
39                "3. FREQuencies can be passed in Hz, kHz (default), MHz, GHz, or THz\n"
40                "   by postfixing the value with the wanted unit name, without any space\n"
41                "   (FREQuency in kHz =^ Hz * 0.001 =^ MHz * 1000 =^ GHz * 1000000).\n"));
42
43 }
44
45 static struct option set_opts[] = {
46         { .name="min",          .has_arg=required_argument,     .flag=NULL,     .val='d'},
47         { .name="max",          .has_arg=required_argument,     .flag=NULL,     .val='u'},
48         { .name="governor",     .has_arg=required_argument,     .flag=NULL,     .val='g'},
49         { .name="freq",         .has_arg=required_argument,     .flag=NULL,     .val='f'},
50         { .name="help",         .has_arg=no_argument,           .flag=NULL,     .val='h'},
51         { .name="related",      .has_arg=no_argument,           .flag=NULL,     .val='r'},
52         { },
53 };
54
55 static void print_error(void)
56 {
57         printf(_("Error setting new values. Common errors:\n"
58                         "- Do you have proper administration rights? (super-user?)\n"
59                         "- Is the governor you requested available and modprobed?\n"
60                         "- Trying to set an invalid policy?\n"
61                         "- Trying to set a specific frequency, but userspace governor is not available,\n"
62                         "   for example because of hardware which cannot be set to a specific frequency\n"
63                         "   or because the userspace governor isn't loaded?\n"));
64 };
65
66 struct freq_units {
67         char*           str_unit;
68         int             power_of_ten;
69 };
70
71 const struct freq_units def_units[] = {
72         {"hz", -3},
73         {"khz", 0}, /* default */
74         {"mhz", 3},
75         {"ghz", 6},
76         {"thz", 9},
77         {NULL, 0}
78 };
79
80 static void print_unknown_arg(void)
81 {
82         printf(_("invalid or unknown argument\n"));
83         freq_set_help();
84 }
85
86 static unsigned long string_to_frequency(const char *str)
87 {
88         char normalized[NORM_FREQ_LEN];
89         const struct freq_units *unit;
90         const char *scan;
91         char *end;
92         unsigned long freq;
93         int power = 0, match_count = 0, i, cp, pad;
94
95         while (*str == '0')
96                 str++;
97
98         for (scan = str; isdigit(*scan) || *scan == '.'; scan++) {
99                 if (*scan == '.' && match_count == 0)
100                         match_count = 1;
101                 else if (*scan == '.' && match_count == 1)
102                         return 0;
103         }
104
105         if (*scan) {
106                 match_count = 0;
107                 for (unit = def_units; unit->str_unit; unit++) {
108                         for (i = 0;
109                              scan[i] && tolower(scan[i]) == unit->str_unit[i];
110                              ++i)
111                                 continue;
112                         if (scan[i])
113                                 continue;
114                         match_count++;
115                         power = unit->power_of_ten;
116                 }
117                 if (match_count != 1)
118                         return 0;
119         }
120
121         /* count the number of digits to be copied */
122         for (cp = 0; isdigit(str[cp]); cp++)
123                 continue;
124
125         if (str[cp] == '.') {
126                 while (power > -1 && isdigit(str[cp+1]))
127                         cp++, power--;
128         }
129         if (power >= -1)        /* not enough => pad */
130                 pad = power + 1;
131         else                    /* to much => strip */
132                 pad = 0, cp += power + 1;
133         /* check bounds */
134         if (cp <= 0 || cp + pad > NORM_FREQ_LEN - 1)
135                 return 0;
136
137         /* copy digits */
138         for (i = 0; i < cp; i++, str++) {
139                 if (*str == '.')
140                         str++;
141                 normalized[i] = *str;
142         }
143         /* and pad */
144         for (; i < cp + pad; i++)
145                 normalized[i] = '0';
146
147         /* round up, down ? */
148         match_count = (normalized[i-1] >= '5');
149         /* and drop the decimal part */
150         normalized[i-1] = 0; /* cp > 0 && pad >= 0 ==> i > 0 */
151
152         /* final conversion (and applying rounding) */
153         errno = 0;
154         freq = strtoul(normalized, &end, 10);
155         if (errno)
156                 return 0;
157         else {
158                 if (match_count && freq != ULONG_MAX)
159                         freq++;
160                 return freq;
161         }
162 }
163
164 static int do_new_policy(unsigned int cpu, struct cpufreq_policy *new_pol)
165 {
166         struct cpufreq_policy *cur_pol = cpufreq_get_policy(cpu);
167         int ret;
168
169         if (!cur_pol) {
170                 printf(_("wrong, unknown or unhandled CPU?\n"));
171                 return -EINVAL;
172         }
173
174         if (!new_pol->min)
175                 new_pol->min = cur_pol->min;
176
177         if (!new_pol->max)
178                 new_pol->max = cur_pol->max;
179
180         if (!new_pol->governor)
181                 new_pol->governor = cur_pol->governor;
182
183         ret = cpufreq_set_policy(cpu, new_pol);
184
185         cpufreq_put_policy(cur_pol);
186
187         return ret;
188 }
189
190
191 static int do_one_cpu(unsigned int cpu, struct cpufreq_policy *new_pol,
192                 unsigned long freq, unsigned int pc)
193 {
194         switch (pc) {
195         case 0:
196                 return cpufreq_set_frequency(cpu, freq);
197
198         case 1:
199                 /* if only one value of a policy is to be changed, we can
200                  * use a "fast path".
201                  */
202                 if (new_pol->min)
203                         return cpufreq_modify_policy_min(cpu, new_pol->min);
204                 else if (new_pol->max)
205                         return cpufreq_modify_policy_max(cpu, new_pol->max);
206                 else if (new_pol->governor)
207                         return cpufreq_modify_policy_governor(cpu, new_pol->governor);
208
209         default:
210                 /* slow path */
211                 return do_new_policy(cpu, new_pol);
212         }
213 }
214
215 int cmd_freq_set(int argc, char **argv)
216 {
217         extern char *optarg;
218         extern int optind, opterr, optopt;
219         int ret = 0, cont = 1;
220         int double_parm = 0, related = 0, policychange = 0;
221         unsigned long freq = 0;
222         char gov[20];
223         unsigned int cpu;
224
225         struct cpufreq_policy new_pol = {
226                 .min = 0,
227                 .max = 0,
228                 .governor = NULL,
229         };
230
231         /* parameter parsing */
232         do {
233                 ret = getopt_long(argc, argv, "d:u:g:f:hr", set_opts, NULL);
234                 switch (ret) {
235                 case '?':
236                         print_unknown_arg();
237                         return -EINVAL;
238                 case 'h':
239                         freq_set_help();
240                         return 0;
241                 case -1:
242                         cont = 0;
243                         break;
244                 case 'r':
245                         if (related)
246                                 double_parm++;
247                         related++;
248                         break;
249                 case 'd':
250                         if (new_pol.min)
251                                 double_parm++;
252                         policychange++;
253                         new_pol.min = string_to_frequency(optarg);
254                         if (new_pol.min == 0) {
255                                 print_unknown_arg();
256                                 return -EINVAL;
257                         }
258                         break;
259                 case 'u':
260                         if (new_pol.max)
261                                 double_parm++;
262                         policychange++;
263                         new_pol.max = string_to_frequency(optarg);
264                         if (new_pol.max == 0) {
265                                 print_unknown_arg();
266                                 return -EINVAL;
267                         }
268                         break;
269                 case 'f':
270                         if (freq)
271                                 double_parm++;
272                         freq = string_to_frequency(optarg);
273                         if (freq == 0) {
274                                 print_unknown_arg();
275                                 return -EINVAL;
276                         }
277                         break;
278                 case 'g':
279                         if (new_pol.governor)
280                                 double_parm++;
281                         policychange++;
282                         if ((strlen(optarg) < 3) || (strlen(optarg) > 18)) {
283                                 print_unknown_arg();
284                                 return -EINVAL;
285                         }
286                         if ((sscanf(optarg, "%s", gov)) != 1) {
287                                 print_unknown_arg();
288                                 return -EINVAL;
289                         }
290                         new_pol.governor = gov;
291                         break;
292                 }
293         } while(cont);
294
295         /* parameter checking */
296         if (double_parm) {
297                 printf("the same parameter was passed more than once\n");
298                 return -EINVAL;
299         }
300
301         if (freq && policychange) {
302                 printf(_("the -f/--freq parameter cannot be combined with -d/--min, -u/--max or\n"
303                                 "-g/--governor parameters\n"));
304                 return -EINVAL;
305         }
306
307         if (!freq && !policychange) {
308                 printf(_("At least one parameter out of -f/--freq, -d/--min, -u/--max, and\n"
309                                 "-g/--governor must be passed\n"));
310                 return -EINVAL;
311         }
312
313         /* Default is: set all CPUs */
314         if (bitmask_isallclear(cpus_chosen))
315                 bitmask_setall(cpus_chosen);
316
317         /* Also set frequency settings for related CPUs if -r is passed */
318         if (related) {
319                 for (cpu = bitmask_first(cpus_chosen);
320                      cpu <= bitmask_last(cpus_chosen); cpu++) {
321                         struct cpufreq_affected_cpus *cpus;
322
323                         if (!bitmask_isbitset(cpus_chosen, cpu) ||
324                             cpufreq_cpu_exists(cpu))
325                                 continue;
326
327                         cpus = cpufreq_get_related_cpus(cpu);
328                         if (!cpus)
329                                 break;
330                         while (cpus->next) {
331                                 bitmask_setbit(cpus_chosen, cpus->cpu);
332                                 cpus = cpus->next;
333                         }
334                         cpufreq_put_related_cpus(cpus);
335                 }
336         }
337
338
339         /* loop over CPUs */
340         for (cpu = bitmask_first(cpus_chosen);
341              cpu <= bitmask_last(cpus_chosen); cpu++) {
342                 
343                 if (!bitmask_isbitset(cpus_chosen, cpu) ||
344                     cpufreq_cpu_exists(cpu))
345                         continue;
346
347                 printf(_("Setting cpu: %d\n"), cpu);
348                 ret = do_one_cpu(cpu, &new_pol, freq, policychange);
349                 if (ret)
350                         break;
351         }
352
353         if (ret)
354                 print_error();
355
356         return ret;
357 }