blob: b33486009f41c690f1b6bed87f4818beb17a27d6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#define _COMPONENT ACPI_PROCESSOR_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050045ACPI_MODULE_NAME("processor_throttling");
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47/* --------------------------------------------------------------------------
48 Throttling Control
49 -------------------------------------------------------------------------- */
Len Brown4be44fc2005-08-05 00:44:28 -040050static int acpi_processor_get_throttling(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051{
Len Brown4be44fc2005-08-05 00:44:28 -040052 int state = 0;
53 u32 value = 0;
54 u32 duty_mask = 0;
55 u32 duty_value = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
58 if (!pr)
Patrick Mocheld550d982006-06-27 00:41:40 -040059 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
61 if (!pr->flags.throttling)
Patrick Mocheld550d982006-06-27 00:41:40 -040062 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64 pr->throttling.state = 0;
65
66 duty_mask = pr->throttling.state_count - 1;
67
68 duty_mask <<= pr->throttling.duty_offset;
69
70 local_irq_disable();
71
72 value = inl(pr->throttling.address);
73
74 /*
75 * Compute the current throttling state when throttling is enabled
76 * (bit 4 is on).
77 */
78 if (value & 0x10) {
79 duty_value = value & duty_mask;
80 duty_value >>= pr->throttling.duty_offset;
81
82 if (duty_value)
Len Brown4be44fc2005-08-05 00:44:28 -040083 state = pr->throttling.state_count - duty_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 }
85
86 pr->throttling.state = state;
87
88 local_irq_enable();
89
90 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -040091 "Throttling state is T%d (%d%% throttling applied)\n",
92 state, pr->throttling.states[state].performance));
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Patrick Mocheld550d982006-06-27 00:41:40 -040094 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095}
96
Len Brown4be44fc2005-08-05 00:44:28 -040097int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
Len Brown4be44fc2005-08-05 00:44:28 -040099 u32 value = 0;
100 u32 duty_mask = 0;
101 u32 duty_value = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
104 if (!pr)
Patrick Mocheld550d982006-06-27 00:41:40 -0400105 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107 if ((state < 0) || (state > (pr->throttling.state_count - 1)))
Patrick Mocheld550d982006-06-27 00:41:40 -0400108 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110 if (!pr->flags.throttling)
Patrick Mocheld550d982006-06-27 00:41:40 -0400111 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
113 if (state == pr->throttling.state)
Patrick Mocheld550d982006-06-27 00:41:40 -0400114 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
116 /*
117 * Calculate the duty_value and duty_mask.
118 */
119 if (state) {
120 duty_value = pr->throttling.state_count - state;
121
122 duty_value <<= pr->throttling.duty_offset;
123
124 /* Used to clear all duty_value bits */
125 duty_mask = pr->throttling.state_count - 1;
126
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300127 duty_mask <<= acpi_gbl_FADT.duty_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 duty_mask = ~duty_mask;
129 }
130
131 local_irq_disable();
132
133 /*
134 * Disable throttling by writing a 0 to bit 4. Note that we must
135 * turn it off before you can change the duty_value.
136 */
137 value = inl(pr->throttling.address);
138 if (value & 0x10) {
139 value &= 0xFFFFFFEF;
140 outl(value, pr->throttling.address);
141 }
142
143 /*
144 * Write the new duty_value and then enable throttling. Note
145 * that a state value of 0 leaves throttling disabled.
146 */
147 if (state) {
148 value &= duty_mask;
149 value |= duty_value;
150 outl(value, pr->throttling.address);
151
152 value |= 0x00000010;
153 outl(value, pr->throttling.address);
154 }
155
156 pr->throttling.state = state;
157
158 local_irq_enable();
159
160 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400161 "Throttling state set to T%d (%d%%)\n", state,
162 (pr->throttling.states[state].performance ? pr->
163 throttling.states[state].performance / 10 : 0)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
Patrick Mocheld550d982006-06-27 00:41:40 -0400165 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166}
167
Len Brown4be44fc2005-08-05 00:44:28 -0400168int acpi_processor_get_throttling_info(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169{
Len Brown4be44fc2005-08-05 00:44:28 -0400170 int result = 0;
171 int step = 0;
172 int i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
175 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400176 "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
177 pr->throttling.address,
178 pr->throttling.duty_offset,
179 pr->throttling.duty_width));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
181 if (!pr)
Patrick Mocheld550d982006-06-27 00:41:40 -0400182 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184 /* TBD: Support ACPI 2.0 objects */
185
186 if (!pr->throttling.address) {
187 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400188 return 0;
Len Brown4be44fc2005-08-05 00:44:28 -0400189 } else if (!pr->throttling.duty_width) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling states\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400191 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 }
193 /* TBD: Support duty_cycle values that span bit 4. */
Len Brown4be44fc2005-08-05 00:44:28 -0400194 else if ((pr->throttling.duty_offset + pr->throttling.duty_width) > 4) {
Len Browncece9292006-06-26 23:04:31 -0400195 printk(KERN_WARNING PREFIX "duty_cycle spans bit 4\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400196 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 }
198
199 /*
200 * PIIX4 Errata: We don't support throttling on the original PIIX4.
201 * This shouldn't be an issue as few (if any) mobile systems ever
202 * used this part.
203 */
204 if (errata.piix4.throttle) {
205 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400206 "Throttling not supported on PIIX4 A- or B-step\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400207 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 }
209
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300210 pr->throttling.state_count = 1 << acpi_gbl_FADT.duty_width;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
212 /*
213 * Compute state values. Note that throttling displays a linear power/
214 * performance relationship (at 50% performance the CPU will consume
215 * 50% power). Values are in 1/10th of a percent to preserve accuracy.
216 */
217
218 step = (1000 / pr->throttling.state_count);
219
Len Brown4be44fc2005-08-05 00:44:28 -0400220 for (i = 0; i < pr->throttling.state_count; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 pr->throttling.states[i].performance = step * i;
222 pr->throttling.states[i].power = step * i;
223 }
224
225 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400226 pr->throttling.state_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
228 pr->flags.throttling = 1;
229
230 /*
231 * Disable throttling (if enabled). We'll let subsequent policy (e.g.
232 * thermal) decide to lower performance if it so chooses, but for now
233 * we'll crank up the speed.
234 */
235
236 result = acpi_processor_get_throttling(pr);
237 if (result)
238 goto end;
239
240 if (pr->throttling.state) {
Len Brown4be44fc2005-08-05 00:44:28 -0400241 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
242 "Disabling throttling (was T%d)\n",
243 pr->throttling.state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 result = acpi_processor_set_throttling(pr, 0);
245 if (result)
246 goto end;
247 }
248
Len Brown4be44fc2005-08-05 00:44:28 -0400249 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 if (result)
251 pr->flags.throttling = 0;
252
Patrick Mocheld550d982006-06-27 00:41:40 -0400253 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254}
255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256/* proc interface */
257
Len Brown4be44fc2005-08-05 00:44:28 -0400258static int acpi_processor_throttling_seq_show(struct seq_file *seq,
259 void *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260{
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200261 struct acpi_processor *pr = seq->private;
Len Brown4be44fc2005-08-05 00:44:28 -0400262 int i = 0;
263 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
266 if (!pr)
267 goto end;
268
269 if (!(pr->throttling.state_count > 0)) {
270 seq_puts(seq, "<not supported>\n");
271 goto end;
272 }
273
274 result = acpi_processor_get_throttling(pr);
275
276 if (result) {
Len Brown4be44fc2005-08-05 00:44:28 -0400277 seq_puts(seq,
278 "Could not determine current throttling state.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 goto end;
280 }
281
282 seq_printf(seq, "state count: %d\n"
Len Brown4be44fc2005-08-05 00:44:28 -0400283 "active state: T%d\n",
284 pr->throttling.state_count, pr->throttling.state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286 seq_puts(seq, "states:\n");
287 for (i = 0; i < pr->throttling.state_count; i++)
288 seq_printf(seq, " %cT%d: %02d%%\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400289 (i == pr->throttling.state ? '*' : ' '), i,
290 (pr->throttling.states[i].performance ? pr->
291 throttling.states[i].performance / 10 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
Len Brown4be44fc2005-08-05 00:44:28 -0400293 end:
Patrick Mocheld550d982006-06-27 00:41:40 -0400294 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295}
296
Len Brown4be44fc2005-08-05 00:44:28 -0400297static int acpi_processor_throttling_open_fs(struct inode *inode,
298 struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299{
300 return single_open(file, acpi_processor_throttling_seq_show,
Len Brown4be44fc2005-08-05 00:44:28 -0400301 PDE(inode)->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302}
303
Adrian Bunk757b1862006-01-07 13:19:00 -0500304static ssize_t acpi_processor_write_throttling(struct file * file,
305 const char __user * buffer,
306 size_t count, loff_t * data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
Len Brown4be44fc2005-08-05 00:44:28 -0400308 int result = 0;
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200309 struct seq_file *m = file->private_data;
310 struct acpi_processor *pr = m->private;
Len Brown4be44fc2005-08-05 00:44:28 -0400311 char state_string[12] = { '\0' };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
314 if (!pr || (count > sizeof(state_string) - 1))
Patrick Mocheld550d982006-06-27 00:41:40 -0400315 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317 if (copy_from_user(state_string, buffer, count))
Patrick Mocheld550d982006-06-27 00:41:40 -0400318 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320 state_string[count] = '\0';
321
322 result = acpi_processor_set_throttling(pr,
Len Brown4be44fc2005-08-05 00:44:28 -0400323 simple_strtoul(state_string,
324 NULL, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400326 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
Patrick Mocheld550d982006-06-27 00:41:40 -0400328 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329}
330
331struct file_operations acpi_processor_throttling_fops = {
Len Brown4be44fc2005-08-05 00:44:28 -0400332 .open = acpi_processor_throttling_open_fs,
333 .read = seq_read,
Arjan van de Vend479e902006-01-06 16:47:00 -0500334 .write = acpi_processor_write_throttling,
Len Brown4be44fc2005-08-05 00:44:28 -0400335 .llseek = seq_lseek,
336 .release = single_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337};