2de40bd5fdff99e0d15066edb27767ec34d67fc9
[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         ACPI_FUNCTION_TRACE("acpi_processor_get_throttling");
59
60         if (!pr)
61                 return_VALUE(-EINVAL);
62
63         if (!pr->flags.throttling)
64                 return_VALUE(-ENODEV);
65
66         pr->throttling.state = 0;
67
68         duty_mask = pr->throttling.state_count - 1;
69
70         duty_mask <<= pr->throttling.duty_offset;
71
72         local_irq_disable();
73
74         value = inl(pr->throttling.address);
75
76         /*
77          * Compute the current throttling state when throttling is enabled
78          * (bit 4 is on).
79          */
80         if (value & 0x10) {
81                 duty_value = value & duty_mask;
82                 duty_value >>= pr->throttling.duty_offset;
83
84                 if (duty_value)
85                         state = pr->throttling.state_count - duty_value;
86         }
87
88         pr->throttling.state = state;
89
90         local_irq_enable();
91
92         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
93                           "Throttling state is T%d (%d%% throttling applied)\n",
94                           state, pr->throttling.states[state].performance));
95
96         return_VALUE(0);
97 }
98
99 int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
100 {
101         u32 value = 0;
102         u32 duty_mask = 0;
103         u32 duty_value = 0;
104
105         ACPI_FUNCTION_TRACE("acpi_processor_set_throttling");
106
107         if (!pr)
108                 return_VALUE(-EINVAL);
109
110         if ((state < 0) || (state > (pr->throttling.state_count - 1)))
111                 return_VALUE(-EINVAL);
112
113         if (!pr->flags.throttling)
114                 return_VALUE(-ENODEV);
115
116         if (state == pr->throttling.state)
117                 return_VALUE(0);
118
119         /*
120          * Calculate the duty_value and duty_mask.
121          */
122         if (state) {
123                 duty_value = pr->throttling.state_count - state;
124
125                 duty_value <<= pr->throttling.duty_offset;
126
127                 /* Used to clear all duty_value bits */
128                 duty_mask = pr->throttling.state_count - 1;
129
130                 duty_mask <<= acpi_fadt.duty_offset;
131                 duty_mask = ~duty_mask;
132         }
133
134         local_irq_disable();
135
136         /*
137          * Disable throttling by writing a 0 to bit 4.  Note that we must
138          * turn it off before you can change the duty_value.
139          */
140         value = inl(pr->throttling.address);
141         if (value & 0x10) {
142                 value &= 0xFFFFFFEF;
143                 outl(value, pr->throttling.address);
144         }
145
146         /*
147          * Write the new duty_value and then enable throttling.  Note
148          * that a state value of 0 leaves throttling disabled.
149          */
150         if (state) {
151                 value &= duty_mask;
152                 value |= duty_value;
153                 outl(value, pr->throttling.address);
154
155                 value |= 0x00000010;
156                 outl(value, pr->throttling.address);
157         }
158
159         pr->throttling.state = state;
160
161         local_irq_enable();
162
163         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
164                           "Throttling state set to T%d (%d%%)\n", state,
165                           (pr->throttling.states[state].performance ? pr->
166                            throttling.states[state].performance / 10 : 0)));
167
168         return_VALUE(0);
169 }
170
171 int acpi_processor_get_throttling_info(struct acpi_processor *pr)
172 {
173         int result = 0;
174         int step = 0;
175         int i = 0;
176
177         ACPI_FUNCTION_TRACE("acpi_processor_get_throttling_info");
178
179         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
180                           "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
181                           pr->throttling.address,
182                           pr->throttling.duty_offset,
183                           pr->throttling.duty_width));
184
185         if (!pr)
186                 return_VALUE(-EINVAL);
187
188         /* TBD: Support ACPI 2.0 objects */
189
190         if (!pr->throttling.address) {
191                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
192                 return_VALUE(0);
193         } else if (!pr->throttling.duty_width) {
194                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n"));
195                 return_VALUE(0);
196         }
197         /* TBD: Support duty_cycle values that span bit 4. */
198         else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
199                 printk(KERN_WARNING PREFIX "duty_cycle spans bit 4\n");
200                 return_VALUE(0);
201         }
202
203         /*
204          * PIIX4 Errata: We don't support throttling on the original PIIX4.
205          * This shouldn't be an issue as few (if any) mobile systems ever
206          * used this part.
207          */
208         if (errata.piix4.throttle) {
209                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
210                                   "Throttling not supported on PIIX4 A- or B-step\n"));
211                 return_VALUE(0);
212         }
213
214         pr->throttling.state_count = 1 << acpi_fadt.duty_width;
215
216         /*
217          * Compute state values. Note that throttling displays a linear power/
218          * performance relationship (at 50% performance the CPU will consume
219          * 50% power).  Values are in 1/10th of a percent to preserve accuracy.
220          */
221
222         step = (1000 / pr->throttling.state_count);
223
224         for (i = 0; i < pr->throttling.state_count; i++) {
225                 pr->throttling.states[i].performance = step * i;
226                 pr->throttling.states[i].power = step * i;
227         }
228
229         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
230                           pr->throttling.state_count));
231
232         pr->flags.throttling = 1;
233
234         /*
235          * Disable throttling (if enabled).  We'll let subsequent policy (e.g.
236          * thermal) decide to lower performance if it so chooses, but for now
237          * we'll crank up the speed.
238          */
239
240         result = acpi_processor_get_throttling(pr);
241         if (result)
242                 goto end;
243
244         if (pr->throttling.state) {
245                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
246                                   "Disabling throttling (was T%d)\n",
247                                   pr->throttling.state));
248                 result = acpi_processor_set_throttling(pr, 0);
249                 if (result)
250                         goto end;
251         }
252
253       end:
254         if (result)
255                 pr->flags.throttling = 0;
256
257         return_VALUE(result);
258 }
259
260 /* proc interface */
261
262 static int acpi_processor_throttling_seq_show(struct seq_file *seq,
263                                               void *offset)
264 {
265         struct acpi_processor *pr = (struct acpi_processor *)seq->private;
266         int i = 0;
267         int result = 0;
268
269         ACPI_FUNCTION_TRACE("acpi_processor_throttling_seq_show");
270
271         if (!pr)
272                 goto end;
273
274         if (!(pr->throttling.state_count > 0)) {
275                 seq_puts(seq, "<not supported>\n");
276                 goto end;
277         }
278
279         result = acpi_processor_get_throttling(pr);
280
281         if (result) {
282                 seq_puts(seq,
283                          "Could not determine current throttling state.\n");
284                 goto end;
285         }
286
287         seq_printf(seq, "state count:             %d\n"
288                    "active state:            T%d\n",
289                    pr->throttling.state_count, pr->throttling.state);
290
291         seq_puts(seq, "states:\n");
292         for (i = 0; i < pr->throttling.state_count; i++)
293                 seq_printf(seq, "   %cT%d:                  %02d%%\n",
294                            (i == pr->throttling.state ? '*' : ' '), i,
295                            (pr->throttling.states[i].performance ? pr->
296                             throttling.states[i].performance / 10 : 0));
297
298       end:
299         return_VALUE(0);
300 }
301
302 static int acpi_processor_throttling_open_fs(struct inode *inode,
303                                              struct file *file)
304 {
305         return single_open(file, acpi_processor_throttling_seq_show,
306                            PDE(inode)->data);
307 }
308
309 static ssize_t acpi_processor_write_throttling(struct file * file,
310                                                const char __user * buffer,
311                                                size_t count, loff_t * data)
312 {
313         int result = 0;
314         struct seq_file *m = (struct seq_file *)file->private_data;
315         struct acpi_processor *pr = (struct acpi_processor *)m->private;
316         char state_string[12] = { '\0' };
317
318         ACPI_FUNCTION_TRACE("acpi_processor_write_throttling");
319
320         if (!pr || (count > sizeof(state_string) - 1))
321                 return_VALUE(-EINVAL);
322
323         if (copy_from_user(state_string, buffer, count))
324                 return_VALUE(-EFAULT);
325
326         state_string[count] = '\0';
327
328         result = acpi_processor_set_throttling(pr,
329                                                simple_strtoul(state_string,
330                                                               NULL, 0));
331         if (result)
332                 return_VALUE(result);
333
334         return_VALUE(count);
335 }
336
337 struct file_operations acpi_processor_throttling_fops = {
338         .open = acpi_processor_throttling_open_fs,
339         .read = seq_read,
340         .write = acpi_processor_write_throttling,
341         .llseek = seq_lseek,
342         .release = single_release,
343 };