d044ec519db0a226404653da9a20cbb079a2f293
[linux-2.6.git] / drivers / acpi / processor_throttling.c
1 /*
2  * processor_throttling.c - Throttling submodule of the ACPI processor driver
3  *
4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6  *  Copyright (C) 2004       Dominik Brodowski <linux@brodo.de>
7  *  Copyright (C) 2004  Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
8  *                      - Added processor hotplug support
9  *
10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11  *
12  *  This program is free software; you can redistribute it and/or modify
13  *  it under the terms of the GNU General Public License as published by
14  *  the Free Software Foundation; either version 2 of the License, or (at
15  *  your option) any later version.
16  *
17  *  This program is distributed in the hope that it will be useful, but
18  *  WITHOUT ANY WARRANTY; without even the implied warranty of
19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  *  General Public License for more details.
21  *
22  *  You should have received a copy of the GNU General Public License along
23  *  with this program; if not, write to the Free Software Foundation, Inc.,
24  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
25  *
26  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27  */
28
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/cpufreq.h>
33 #include <linux/proc_fs.h>
34 #include <linux/seq_file.h>
35
36 #include <asm/io.h>
37 #include <asm/uaccess.h>
38
39 #include <acpi/acpi_bus.h>
40 #include <acpi/processor.h>
41
42 #define ACPI_PROCESSOR_COMPONENT        0x01000000
43 #define ACPI_PROCESSOR_CLASS            "processor"
44 #define ACPI_PROCESSOR_DRIVER_NAME      "ACPI Processor Driver"
45 #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
46 ACPI_MODULE_NAME("acpi_processor")
47
48 /* --------------------------------------------------------------------------
49                               Throttling Control
50    -------------------------------------------------------------------------- */
51 static int acpi_processor_get_throttling(struct acpi_processor *pr)
52 {
53         int state = 0;
54         u32 value = 0;
55         u32 duty_mask = 0;
56         u32 duty_value = 0;
57
58
59         if (!pr)
60                 return -EINVAL;
61
62         if (!pr->flags.throttling)
63                 return -ENODEV;
64
65         pr->throttling.state = 0;
66
67         duty_mask = pr->throttling.state_count - 1;
68
69         duty_mask <<= pr->throttling.duty_offset;
70
71         local_irq_disable();
72
73         value = inl(pr->throttling.address);
74
75         /*
76          * Compute the current throttling state when throttling is enabled
77          * (bit 4 is on).
78          */
79         if (value & 0x10) {
80                 duty_value = value & duty_mask;
81                 duty_value >>= pr->throttling.duty_offset;
82
83                 if (duty_value)
84                         state = pr->throttling.state_count - duty_value;
85         }
86
87         pr->throttling.state = state;
88
89         local_irq_enable();
90
91         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
92                           "Throttling state is T%d (%d%% throttling applied)\n",
93                           state, pr->throttling.states[state].performance));
94
95         return 0;
96 }
97
98 int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
99 {
100         u32 value = 0;
101         u32 duty_mask = 0;
102         u32 duty_value = 0;
103
104
105         if (!pr)
106                 return -EINVAL;
107
108         if ((state < 0) || (state > (pr->throttling.state_count - 1)))
109                 return -EINVAL;
110
111         if (!pr->flags.throttling)
112                 return -ENODEV;
113
114         if (state == pr->throttling.state)
115                 return 0;
116
117         /*
118          * Calculate the duty_value and duty_mask.
119          */
120         if (state) {
121                 duty_value = pr->throttling.state_count - state;
122
123                 duty_value <<= pr->throttling.duty_offset;
124
125                 /* Used to clear all duty_value bits */
126                 duty_mask = pr->throttling.state_count - 1;
127
128                 duty_mask <<= acpi_fadt.duty_offset;
129                 duty_mask = ~duty_mask;
130         }
131
132         local_irq_disable();
133
134         /*
135          * Disable throttling by writing a 0 to bit 4.  Note that we must
136          * turn it off before you can change the duty_value.
137          */
138         value = inl(pr->throttling.address);
139         if (value & 0x10) {
140                 value &= 0xFFFFFFEF;
141                 outl(value, pr->throttling.address);
142         }
143
144         /*
145          * Write the new duty_value and then enable throttling.  Note
146          * that a state value of 0 leaves throttling disabled.
147          */
148         if (state) {
149                 value &= duty_mask;
150                 value |= duty_value;
151                 outl(value, pr->throttling.address);
152
153                 value |= 0x00000010;
154                 outl(value, pr->throttling.address);
155         }
156
157         pr->throttling.state = state;
158
159         local_irq_enable();
160
161         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
162                           "Throttling state set to T%d (%d%%)\n", state,
163                           (pr->throttling.states[state].performance ? pr->
164                            throttling.states[state].performance / 10 : 0)));
165
166         return 0;
167 }
168
169 int acpi_processor_get_throttling_info(struct acpi_processor *pr)
170 {
171         int result = 0;
172         int step = 0;
173         int i = 0;
174
175
176         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
177                           "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
178                           pr->throttling.address,
179                           pr->throttling.duty_offset,
180                           pr->throttling.duty_width));
181
182         if (!pr)
183                 return -EINVAL;
184
185         /* TBD: Support ACPI 2.0 objects */
186
187         if (!pr->throttling.address) {
188                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
189                 return 0;
190         } else if (!pr->throttling.duty_width) {
191                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n"));
192                 return 0;
193         }
194         /* TBD: Support duty_cycle values that span bit 4. */
195         else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
196                 printk(KERN_WARNING PREFIX "duty_cycle spans bit 4\n");
197                 return 0;
198         }
199
200         /*
201          * PIIX4 Errata: We don't support throttling on the original PIIX4.
202          * This shouldn't be an issue as few (if any) mobile systems ever
203          * used this part.
204          */
205         if (errata.piix4.throttle) {
206                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
207                                   "Throttling not supported on PIIX4 A- or B-step\n"));
208                 return 0;
209         }
210
211         pr->throttling.state_count = 1 << acpi_fadt.duty_width;
212
213         /*
214          * Compute state values. Note that throttling displays a linear power/
215          * performance relationship (at 50% performance the CPU will consume
216          * 50% power).  Values are in 1/10th of a percent to preserve accuracy.
217          */
218
219         step = (1000 / pr->throttling.state_count);
220
221         for (i = 0; i < pr->throttling.state_count; i++) {
222                 pr->throttling.states[i].performance = step * i;
223                 pr->throttling.states[i].power = step * i;
224         }
225
226         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
227                           pr->throttling.state_count));
228
229         pr->flags.throttling = 1;
230
231         /*
232          * Disable throttling (if enabled).  We'll let subsequent policy (e.g.
233          * thermal) decide to lower performance if it so chooses, but for now
234          * we'll crank up the speed.
235          */
236
237         result = acpi_processor_get_throttling(pr);
238         if (result)
239                 goto end;
240
241         if (pr->throttling.state) {
242                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
243                                   "Disabling throttling (was T%d)\n",
244                                   pr->throttling.state));
245                 result = acpi_processor_set_throttling(pr, 0);
246                 if (result)
247                         goto end;
248         }
249
250       end:
251         if (result)
252                 pr->flags.throttling = 0;
253
254         return result;
255 }
256
257 /* proc interface */
258
259 static int acpi_processor_throttling_seq_show(struct seq_file *seq,
260                                               void *offset)
261 {
262         struct acpi_processor *pr = (struct acpi_processor *)seq->private;
263         int i = 0;
264         int result = 0;
265
266
267         if (!pr)
268                 goto end;
269
270         if (!(pr->throttling.state_count > 0)) {
271                 seq_puts(seq, "<not supported>\n");
272                 goto end;
273         }
274
275         result = acpi_processor_get_throttling(pr);
276
277         if (result) {
278                 seq_puts(seq,
279                          "Could not determine current throttling state.\n");
280                 goto end;
281         }
282
283         seq_printf(seq, "state count:             %d\n"
284                    "active state:            T%d\n",
285                    pr->throttling.state_count, pr->throttling.state);
286
287         seq_puts(seq, "states:\n");
288         for (i = 0; i < pr->throttling.state_count; i++)
289                 seq_printf(seq, "   %cT%d:                  %02d%%\n",
290                            (i == pr->throttling.state ? '*' : ' '), i,
291                            (pr->throttling.states[i].performance ? pr->
292                             throttling.states[i].performance / 10 : 0));
293
294       end:
295         return 0;
296 }
297
298 static int acpi_processor_throttling_open_fs(struct inode *inode,
299                                              struct file *file)
300 {
301         return single_open(file, acpi_processor_throttling_seq_show,
302                            PDE(inode)->data);
303 }
304
305 static ssize_t acpi_processor_write_throttling(struct file * file,
306                                                const char __user * buffer,
307                                                size_t count, loff_t * data)
308 {
309         int result = 0;
310         struct seq_file *m = (struct seq_file *)file->private_data;
311         struct acpi_processor *pr = (struct acpi_processor *)m->private;
312         char state_string[12] = { '\0' };
313
314
315         if (!pr || (count > sizeof(state_string) - 1))
316                 return -EINVAL;
317
318         if (copy_from_user(state_string, buffer, count))
319                 return -EFAULT;
320
321         state_string[count] = '\0';
322
323         result = acpi_processor_set_throttling(pr,
324                                                simple_strtoul(state_string,
325                                                               NULL, 0));
326         if (result)
327                 return result;
328
329         return count;
330 }
331
332 struct file_operations acpi_processor_throttling_fops = {
333         .open = acpi_processor_throttling_open_fs,
334         .read = seq_read,
335         .write = acpi_processor_write_throttling,
336         .llseek = seq_lseek,
337         .release = single_release,
338 };