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