blob: 65b3f056ad895a7d0f524f7412ff861ce9298649 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * processor_idle - idle state submodule to 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>
Dominik Brodowskic5ab81c2006-06-24 19:37:00 -04006 * Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
8 * - Added processor hotplug support
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -04009 * Copyright (C) 2005 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
10 * - Added support for C3 on SMP
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 *
12 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or (at
17 * your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful, but
20 * WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License along
25 * with this program; if not, write to the Free Software Foundation, Inc.,
26 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
27 *
28 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
29 */
30
31#include <linux/kernel.h>
32#include <linux/module.h>
33#include <linux/init.h>
34#include <linux/cpufreq.h>
35#include <linux/proc_fs.h>
36#include <linux/seq_file.h>
37#include <linux/acpi.h>
38#include <linux/dmi.h>
39#include <linux/moduleparam.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080040#include <linux/sched.h> /* need_resched() */
Arjan van de Ven5c875792006-09-30 23:27:17 -070041#include <linux/latency.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43#include <asm/io.h>
44#include <asm/uaccess.h>
45
46#include <acpi/acpi_bus.h>
47#include <acpi/processor.h>
48
49#define ACPI_PROCESSOR_COMPONENT 0x01000000
50#define ACPI_PROCESSOR_CLASS "processor"
51#define ACPI_PROCESSOR_DRIVER_NAME "ACPI Processor Driver"
52#define _COMPONENT ACPI_PROCESSOR_COMPONENT
Len Brown4be44fc2005-08-05 00:44:28 -040053ACPI_MODULE_NAME("acpi_processor")
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#define ACPI_PROCESSOR_FILE_POWER "power"
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#define US_TO_PM_TIMER_TICKS(t) ((t * (PM_TIMER_FREQUENCY/1000)) / 1000)
56#define C2_OVERHEAD 4 /* 1us (3.579 ticks per us) */
57#define C3_OVERHEAD 4 /* 1us (3.579 ticks per us) */
Andreas Mohrb6835052006-04-27 05:25:00 -040058static void (*pm_idle_save) (void) __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059module_param(max_cstate, uint, 0644);
60
Andreas Mohrb6835052006-04-27 05:25:00 -040061static unsigned int nocst __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062module_param(nocst, uint, 0000);
63
64/*
65 * bm_history -- bit-mask with a bit per jiffy of bus-master activity
66 * 1000 HZ: 0xFFFFFFFF: 32 jiffies = 32ms
67 * 800 HZ: 0xFFFFFFFF: 32 jiffies = 40ms
68 * 100 HZ: 0x0000000F: 4 jiffies = 40ms
69 * reduce history for more aggressive entry into C3
70 */
Andreas Mohrb6835052006-04-27 05:25:00 -040071static unsigned int bm_history __read_mostly =
Len Brown4be44fc2005-08-05 00:44:28 -040072 (HZ >= 800 ? 0xFFFFFFFF : ((1U << (HZ / 25)) - 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -070073module_param(bm_history, uint, 0644);
74/* --------------------------------------------------------------------------
75 Power Management
76 -------------------------------------------------------------------------- */
77
78/*
79 * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
80 * For now disable this. Probably a bug somewhere else.
81 *
82 * To skip this limit, boot/load with a large max_cstate limit.
83 */
David Shaohua Li335f16b2005-06-22 18:37:00 -040084static int set_max_cstate(struct dmi_system_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -070085{
86 if (max_cstate > ACPI_PROCESSOR_MAX_POWER)
87 return 0;
88
Len Brown3d356002005-08-03 00:22:52 -040089 printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate."
Len Brown4be44fc2005-08-05 00:44:28 -040090 " Override with \"processor.max_cstate=%d\"\n", id->ident,
91 (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Len Brown3d356002005-08-03 00:22:52 -040093 max_cstate = (long)id->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95 return 0;
96}
97
Ashok Raj7ded5682006-02-03 21:51:23 +010098/* Actually this shouldn't be __cpuinitdata, would be better to fix the
99 callers to only run once -AK */
100static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = {
Thomas Rosner876c1842006-01-06 01:31:00 -0500101 { set_max_cstate, "IBM ThinkPad R40e", {
102 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
Bartlomiej Swierczf8313352006-05-29 07:16:00 -0400103 DMI_MATCH(DMI_BIOS_VERSION,"1SET70WW")}, (void *)1},
104 { set_max_cstate, "IBM ThinkPad R40e", {
105 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
Thomas Rosner876c1842006-01-06 01:31:00 -0500106 DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW")}, (void *)1},
107 { set_max_cstate, "IBM ThinkPad R40e", {
108 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
109 DMI_MATCH(DMI_BIOS_VERSION,"1SET43WW") }, (void*)1},
110 { set_max_cstate, "IBM ThinkPad R40e", {
111 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
112 DMI_MATCH(DMI_BIOS_VERSION,"1SET45WW") }, (void*)1},
113 { set_max_cstate, "IBM ThinkPad R40e", {
114 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
115 DMI_MATCH(DMI_BIOS_VERSION,"1SET47WW") }, (void*)1},
116 { set_max_cstate, "IBM ThinkPad R40e", {
117 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
118 DMI_MATCH(DMI_BIOS_VERSION,"1SET50WW") }, (void*)1},
119 { set_max_cstate, "IBM ThinkPad R40e", {
120 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
121 DMI_MATCH(DMI_BIOS_VERSION,"1SET52WW") }, (void*)1},
122 { set_max_cstate, "IBM ThinkPad R40e", {
123 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
124 DMI_MATCH(DMI_BIOS_VERSION,"1SET55WW") }, (void*)1},
125 { set_max_cstate, "IBM ThinkPad R40e", {
126 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
127 DMI_MATCH(DMI_BIOS_VERSION,"1SET56WW") }, (void*)1},
128 { set_max_cstate, "IBM ThinkPad R40e", {
129 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
130 DMI_MATCH(DMI_BIOS_VERSION,"1SET59WW") }, (void*)1},
131 { set_max_cstate, "IBM ThinkPad R40e", {
132 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
133 DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW") }, (void*)1},
134 { set_max_cstate, "IBM ThinkPad R40e", {
135 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
136 DMI_MATCH(DMI_BIOS_VERSION,"1SET61WW") }, (void*)1},
137 { set_max_cstate, "IBM ThinkPad R40e", {
138 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
139 DMI_MATCH(DMI_BIOS_VERSION,"1SET62WW") }, (void*)1},
140 { set_max_cstate, "IBM ThinkPad R40e", {
141 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
142 DMI_MATCH(DMI_BIOS_VERSION,"1SET64WW") }, (void*)1},
143 { set_max_cstate, "IBM ThinkPad R40e", {
144 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
145 DMI_MATCH(DMI_BIOS_VERSION,"1SET65WW") }, (void*)1},
146 { set_max_cstate, "IBM ThinkPad R40e", {
147 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
148 DMI_MATCH(DMI_BIOS_VERSION,"1SET68WW") }, (void*)1},
149 { set_max_cstate, "Medion 41700", {
150 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
151 DMI_MATCH(DMI_BIOS_VERSION,"R01-A1J")}, (void *)1},
152 { set_max_cstate, "Clevo 5600D", {
153 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
154 DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
Len Brown4be44fc2005-08-05 00:44:28 -0400155 (void *)2},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 {},
157};
158
Len Brown4be44fc2005-08-05 00:44:28 -0400159static inline u32 ticks_elapsed(u32 t1, u32 t2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
161 if (t2 >= t1)
162 return (t2 - t1);
163 else if (!acpi_fadt.tmr_val_ext)
164 return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
165 else
166 return ((0xFFFFFFFF - t1) + t2);
167}
168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169static void
Len Brown4be44fc2005-08-05 00:44:28 -0400170acpi_processor_power_activate(struct acpi_processor *pr,
171 struct acpi_processor_cx *new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172{
Len Brown4be44fc2005-08-05 00:44:28 -0400173 struct acpi_processor_cx *old;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
175 if (!pr || !new)
176 return;
177
178 old = pr->power.state;
179
180 if (old)
181 old->promotion.count = 0;
Len Brown4be44fc2005-08-05 00:44:28 -0400182 new->demotion.count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184 /* Cleanup from old state. */
185 if (old) {
186 switch (old->type) {
187 case ACPI_STATE_C3:
188 /* Disable bus master reload */
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400189 if (new->type != ACPI_STATE_C3 && pr->flags.bm_check)
Len Brown4be44fc2005-08-05 00:44:28 -0400190 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0,
191 ACPI_MTX_DO_NOT_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 break;
193 }
194 }
195
196 /* Prepare to use new state. */
197 switch (new->type) {
198 case ACPI_STATE_C3:
199 /* Enable bus master reload */
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400200 if (old->type != ACPI_STATE_C3 && pr->flags.bm_check)
Len Brown4be44fc2005-08-05 00:44:28 -0400201 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 1,
202 ACPI_MTX_DO_NOT_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 break;
204 }
205
206 pr->power.state = new;
207
208 return;
209}
210
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800211static void acpi_safe_halt(void)
212{
Andi Kleen495ab9c2006-06-26 13:59:11 +0200213 current_thread_info()->status &= ~TS_POLLING;
Nick Piggin2a298a32005-12-02 12:44:19 +1100214 smp_mb__after_clear_bit();
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800215 if (!need_resched())
216 safe_halt();
Andi Kleen495ab9c2006-06-26 13:59:11 +0200217 current_thread_info()->status |= TS_POLLING;
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800218}
219
Len Brown4be44fc2005-08-05 00:44:28 -0400220static atomic_t c3_cpu_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700222/* Common C-state entry for C2, C3, .. */
223static void acpi_cstate_enter(struct acpi_processor_cx *cstate)
224{
225 if (cstate->space_id == ACPI_CSTATE_FFH) {
226 /* Call into architectural FFH based C-state */
227 acpi_processor_ffh_cstate_enter(cstate);
228 } else {
229 int unused;
230 /* IO port based C-state */
231 inb(cstate->address);
232 /* Dummy wait op - must do something useless after P_LVL2 read
233 because chipsets cannot guarantee that STPCLK# signal
234 gets asserted in time to freeze execution properly. */
235 unused = inl(acpi_fadt.xpm_tmr_blk.address);
236 }
237}
238
Len Brown4be44fc2005-08-05 00:44:28 -0400239static void acpi_processor_idle(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
Len Brown4be44fc2005-08-05 00:44:28 -0400241 struct acpi_processor *pr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 struct acpi_processor_cx *cx = NULL;
243 struct acpi_processor_cx *next_state = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400244 int sleep_ticks = 0;
245 u32 t1, t2 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800247 pr = processors[smp_processor_id()];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 if (!pr)
249 return;
250
251 /*
252 * Interrupts must be disabled during bus mastering calculations and
253 * for C2/C3 transitions.
254 */
255 local_irq_disable();
256
257 /*
258 * Check whether we truly need to go idle, or should
259 * reschedule:
260 */
261 if (unlikely(need_resched())) {
262 local_irq_enable();
263 return;
264 }
265
266 cx = pr->power.state;
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800267 if (!cx) {
268 if (pm_idle_save)
269 pm_idle_save();
270 else
271 acpi_safe_halt();
272 return;
273 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
275 /*
276 * Check BM Activity
277 * -----------------
278 * Check for bus mastering activity (if required), record, and check
279 * for demotion.
280 */
281 if (pr->flags.bm_check) {
Len Brown4be44fc2005-08-05 00:44:28 -0400282 u32 bm_status = 0;
283 unsigned long diff = jiffies - pr->power.bm_check_timestamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Dominik Brodowskic5ab81c2006-06-24 19:37:00 -0400285 if (diff > 31)
286 diff = 31;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Dominik Brodowskic5ab81c2006-06-24 19:37:00 -0400288 pr->power.bm_activity <<= diff;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS,
Len Brown4be44fc2005-08-05 00:44:28 -0400291 &bm_status, ACPI_MTX_DO_NOT_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 if (bm_status) {
Dominik Brodowskic5ab81c2006-06-24 19:37:00 -0400293 pr->power.bm_activity |= 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS,
Len Brown4be44fc2005-08-05 00:44:28 -0400295 1, ACPI_MTX_DO_NOT_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 }
297 /*
298 * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect
299 * the true state of bus mastering activity; forcing us to
300 * manually check the BMIDEA bit of each IDE channel.
301 */
302 else if (errata.piix4.bmisx) {
303 if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
Len Brown4be44fc2005-08-05 00:44:28 -0400304 || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
Dominik Brodowskic5ab81c2006-06-24 19:37:00 -0400305 pr->power.bm_activity |= 0x1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 }
307
308 pr->power.bm_check_timestamp = jiffies;
309
310 /*
Dominik Brodowskic4a001b2006-06-24 19:37:00 -0400311 * If bus mastering is or was active this jiffy, demote
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 * to avoid a faulty transition. Note that the processor
313 * won't enter a low-power state during this call (to this
Dominik Brodowskic4a001b2006-06-24 19:37:00 -0400314 * function) but should upon the next.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 *
316 * TBD: A better policy might be to fallback to the demotion
317 * state (use it for this quantum only) istead of
318 * demoting -- and rely on duration as our sole demotion
319 * qualification. This may, however, introduce DMA
320 * issues (e.g. floppy DMA transfer overrun/underrun).
321 */
Dominik Brodowskic4a001b2006-06-24 19:37:00 -0400322 if ((pr->power.bm_activity & 0x1) &&
323 cx->demotion.threshold.bm) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 local_irq_enable();
325 next_state = cx->demotion.state;
326 goto end;
327 }
328 }
329
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400330#ifdef CONFIG_HOTPLUG_CPU
331 /*
332 * Check for P_LVL2_UP flag before entering C2 and above on
333 * an SMP system. We do it here instead of doing it at _CST/P_LVL
334 * detection phase, to work cleanly with logical CPU hotplug.
335 */
336 if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
David Shaohua Li1e483962005-12-01 17:00:00 -0500337 !pr->flags.has_cst && !acpi_fadt.plvl2_up)
338 cx = &pr->power.states[ACPI_STATE_C1];
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400339#endif
David Shaohua Li1e483962005-12-01 17:00:00 -0500340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 /*
342 * Sleep:
343 * ------
344 * Invoke the current Cx state to put the processor to sleep.
345 */
Nick Piggin2a298a32005-12-02 12:44:19 +1100346 if (cx->type == ACPI_STATE_C2 || cx->type == ACPI_STATE_C3) {
Andi Kleen495ab9c2006-06-26 13:59:11 +0200347 current_thread_info()->status &= ~TS_POLLING;
Nick Piggin2a298a32005-12-02 12:44:19 +1100348 smp_mb__after_clear_bit();
349 if (need_resched()) {
Andi Kleen495ab9c2006-06-26 13:59:11 +0200350 current_thread_info()->status |= TS_POLLING;
Linus Torvaldsaf2eb172005-12-02 23:09:06 -0800351 local_irq_enable();
Nick Piggin2a298a32005-12-02 12:44:19 +1100352 return;
353 }
354 }
355
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 switch (cx->type) {
357
358 case ACPI_STATE_C1:
359 /*
360 * Invoke C1.
361 * Use the appropriate idle routine, the one that would
362 * be used without acpi C-states.
363 */
364 if (pm_idle_save)
365 pm_idle_save();
366 else
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800367 acpi_safe_halt();
368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 /*
Len Brown4be44fc2005-08-05 00:44:28 -0400370 * TBD: Can't get time duration while in C1, as resumes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 * go to an ISR rather than here. Need to instrument
372 * base interrupt handler.
373 */
374 sleep_ticks = 0xFFFFFFFF;
375 break;
376
377 case ACPI_STATE_C2:
378 /* Get start time (ticks) */
379 t1 = inl(acpi_fadt.xpm_tmr_blk.address);
380 /* Invoke C2 */
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700381 acpi_cstate_enter(cx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 /* Get end time (ticks) */
383 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
john stultz539eb112006-06-26 00:25:10 -0700384
385#ifdef CONFIG_GENERIC_TIME
386 /* TSC halts in C2, so notify users */
387 mark_tsc_unstable();
388#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 /* Re-enable interrupts */
390 local_irq_enable();
Andi Kleen495ab9c2006-06-26 13:59:11 +0200391 current_thread_info()->status |= TS_POLLING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 /* Compute time (ticks) that we were actually asleep */
Len Brown4be44fc2005-08-05 00:44:28 -0400393 sleep_ticks =
394 ticks_elapsed(t1, t2) - cx->latency_ticks - C2_OVERHEAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 break;
396
397 case ACPI_STATE_C3:
Len Brown4be44fc2005-08-05 00:44:28 -0400398
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400399 if (pr->flags.bm_check) {
400 if (atomic_inc_return(&c3_cpu_count) ==
Len Brown4be44fc2005-08-05 00:44:28 -0400401 num_online_cpus()) {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400402 /*
403 * All CPUs are trying to go to C3
404 * Disable bus master arbitration
405 */
406 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1,
Len Brown4be44fc2005-08-05 00:44:28 -0400407 ACPI_MTX_DO_NOT_LOCK);
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400408 }
409 } else {
410 /* SMP with no shared cache... Invalidate cache */
411 ACPI_FLUSH_CPU_CACHE();
412 }
Len Brown4be44fc2005-08-05 00:44:28 -0400413
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 /* Get start time (ticks) */
415 t1 = inl(acpi_fadt.xpm_tmr_blk.address);
416 /* Invoke C3 */
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700417 acpi_cstate_enter(cx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 /* Get end time (ticks) */
419 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400420 if (pr->flags.bm_check) {
421 /* Enable bus master arbitration */
422 atomic_dec(&c3_cpu_count);
Len Brown4be44fc2005-08-05 00:44:28 -0400423 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0,
424 ACPI_MTX_DO_NOT_LOCK);
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400425 }
426
john stultz539eb112006-06-26 00:25:10 -0700427#ifdef CONFIG_GENERIC_TIME
428 /* TSC halts in C3, so notify users */
429 mark_tsc_unstable();
430#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 /* Re-enable interrupts */
432 local_irq_enable();
Andi Kleen495ab9c2006-06-26 13:59:11 +0200433 current_thread_info()->status |= TS_POLLING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 /* Compute time (ticks) that we were actually asleep */
Len Brown4be44fc2005-08-05 00:44:28 -0400435 sleep_ticks =
436 ticks_elapsed(t1, t2) - cx->latency_ticks - C3_OVERHEAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 break;
438
439 default:
440 local_irq_enable();
441 return;
442 }
Dominik Brodowskia3c65982006-06-24 19:37:00 -0400443 cx->usage++;
444 if ((cx->type != ACPI_STATE_C1) && (sleep_ticks > 0))
445 cx->time += sleep_ticks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
447 next_state = pr->power.state;
448
David Shaohua Li1e483962005-12-01 17:00:00 -0500449#ifdef CONFIG_HOTPLUG_CPU
450 /* Don't do promotion/demotion */
451 if ((cx->type == ACPI_STATE_C1) && (num_online_cpus() > 1) &&
452 !pr->flags.has_cst && !acpi_fadt.plvl2_up) {
453 next_state = cx;
454 goto end;
455 }
456#endif
457
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 /*
459 * Promotion?
460 * ----------
461 * Track the number of longs (time asleep is greater than threshold)
462 * and promote when the count threshold is reached. Note that bus
463 * mastering activity may prevent promotions.
464 * Do not promote above max_cstate.
465 */
466 if (cx->promotion.state &&
467 ((cx->promotion.state - pr->power.states) <= max_cstate)) {
Arjan van de Ven5c875792006-09-30 23:27:17 -0700468 if (sleep_ticks > cx->promotion.threshold.ticks &&
469 cx->promotion.state->latency <= system_latency_constraint()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 cx->promotion.count++;
Len Brown4be44fc2005-08-05 00:44:28 -0400471 cx->demotion.count = 0;
472 if (cx->promotion.count >=
473 cx->promotion.threshold.count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 if (pr->flags.bm_check) {
Len Brown4be44fc2005-08-05 00:44:28 -0400475 if (!
476 (pr->power.bm_activity & cx->
477 promotion.threshold.bm)) {
478 next_state =
479 cx->promotion.state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 goto end;
481 }
Len Brown4be44fc2005-08-05 00:44:28 -0400482 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 next_state = cx->promotion.state;
484 goto end;
485 }
486 }
487 }
488 }
489
490 /*
491 * Demotion?
492 * ---------
493 * Track the number of shorts (time asleep is less than time threshold)
494 * and demote when the usage threshold is reached.
495 */
496 if (cx->demotion.state) {
497 if (sleep_ticks < cx->demotion.threshold.ticks) {
498 cx->demotion.count++;
499 cx->promotion.count = 0;
500 if (cx->demotion.count >= cx->demotion.threshold.count) {
501 next_state = cx->demotion.state;
502 goto end;
503 }
504 }
505 }
506
Len Brown4be44fc2005-08-05 00:44:28 -0400507 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 /*
509 * Demote if current state exceeds max_cstate
Arjan van de Ven5c875792006-09-30 23:27:17 -0700510 * or if the latency of the current state is unacceptable
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 */
Arjan van de Ven5c875792006-09-30 23:27:17 -0700512 if ((pr->power.state - pr->power.states) > max_cstate ||
513 pr->power.state->latency > system_latency_constraint()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 if (cx->demotion.state)
515 next_state = cx->demotion.state;
516 }
517
518 /*
519 * New Cx State?
520 * -------------
521 * If we're going to start using a new Cx state we must clean up
522 * from the previous and prepare to use the new.
523 */
524 if (next_state != pr->power.state)
525 acpi_processor_power_activate(pr, next_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526}
527
Len Brown4be44fc2005-08-05 00:44:28 -0400528static int acpi_processor_set_power_policy(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
530 unsigned int i;
531 unsigned int state_is_set = 0;
532 struct acpi_processor_cx *lower = NULL;
533 struct acpi_processor_cx *higher = NULL;
534 struct acpi_processor_cx *cx;
535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
537 if (!pr)
Patrick Mocheld550d982006-06-27 00:41:40 -0400538 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
540 /*
541 * This function sets the default Cx state policy (OS idle handler).
542 * Our scheme is to promote quickly to C2 but more conservatively
543 * to C3. We're favoring C2 for its characteristics of low latency
544 * (quick response), good power savings, and ability to allow bus
545 * mastering activity. Note that the Cx state policy is completely
546 * customizable and can be altered dynamically.
547 */
548
549 /* startup state */
Len Brown4be44fc2005-08-05 00:44:28 -0400550 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 cx = &pr->power.states[i];
552 if (!cx->valid)
553 continue;
554
555 if (!state_is_set)
556 pr->power.state = cx;
557 state_is_set++;
558 break;
Len Brown4be44fc2005-08-05 00:44:28 -0400559 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
561 if (!state_is_set)
Patrick Mocheld550d982006-06-27 00:41:40 -0400562 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
564 /* demotion */
Len Brown4be44fc2005-08-05 00:44:28 -0400565 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 cx = &pr->power.states[i];
567 if (!cx->valid)
568 continue;
569
570 if (lower) {
571 cx->demotion.state = lower;
572 cx->demotion.threshold.ticks = cx->latency_ticks;
573 cx->demotion.threshold.count = 1;
574 if (cx->type == ACPI_STATE_C3)
575 cx->demotion.threshold.bm = bm_history;
576 }
577
578 lower = cx;
579 }
580
581 /* promotion */
582 for (i = (ACPI_PROCESSOR_MAX_POWER - 1); i > 0; i--) {
583 cx = &pr->power.states[i];
584 if (!cx->valid)
585 continue;
586
587 if (higher) {
Len Brown4be44fc2005-08-05 00:44:28 -0400588 cx->promotion.state = higher;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 cx->promotion.threshold.ticks = cx->latency_ticks;
590 if (cx->type >= ACPI_STATE_C2)
591 cx->promotion.threshold.count = 4;
592 else
593 cx->promotion.threshold.count = 10;
594 if (higher->type == ACPI_STATE_C3)
595 cx->promotion.threshold.bm = bm_history;
596 }
597
598 higher = cx;
599 }
600
Patrick Mocheld550d982006-06-27 00:41:40 -0400601 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602}
603
Len Brown4be44fc2005-08-05 00:44:28 -0400604static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
607 if (!pr)
Patrick Mocheld550d982006-06-27 00:41:40 -0400608 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
610 if (!pr->pblk)
Patrick Mocheld550d982006-06-27 00:41:40 -0400611 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 /* if info is obtained from pblk/fadt, type equals state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
615 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3;
616
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400617#ifndef CONFIG_HOTPLUG_CPU
618 /*
619 * Check for P_LVL2_UP flag before entering C2 and above on
620 * an SMP system.
621 */
David Shaohua Li1e483962005-12-01 17:00:00 -0500622 if ((num_online_cpus() > 1) && !acpi_fadt.plvl2_up)
Patrick Mocheld550d982006-06-27 00:41:40 -0400623 return -ENODEV;
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400624#endif
625
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 /* determine C2 and C3 address from pblk */
627 pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4;
628 pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5;
629
630 /* determine latencies from FADT */
631 pr->power.states[ACPI_STATE_C2].latency = acpi_fadt.plvl2_lat;
632 pr->power.states[ACPI_STATE_C3].latency = acpi_fadt.plvl3_lat;
633
634 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
635 "lvl2[0x%08x] lvl3[0x%08x]\n",
636 pr->power.states[ACPI_STATE_C2].address,
637 pr->power.states[ACPI_STATE_C3].address));
638
Patrick Mocheld550d982006-06-27 00:41:40 -0400639 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640}
641
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700642static int acpi_processor_get_power_info_default(struct acpi_processor *pr)
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500643{
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700644 if (!pr->power.states[ACPI_STATE_C1].valid) {
645 /* set the first C-State to C1 */
646 /* all processors need to support C1 */
647 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
648 pr->power.states[ACPI_STATE_C1].valid = 1;
649 }
650 /* the C0 state only exists as a filler in our array */
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500651 pr->power.states[ACPI_STATE_C0].valid = 1;
Patrick Mocheld550d982006-06-27 00:41:40 -0400652 return 0;
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500653}
654
Len Brown4be44fc2005-08-05 00:44:28 -0400655static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656{
Len Brown4be44fc2005-08-05 00:44:28 -0400657 acpi_status status = 0;
658 acpi_integer count;
Janosch Machowinskicf824782005-08-20 08:02:00 -0400659 int current_count;
Len Brown4be44fc2005-08-05 00:44:28 -0400660 int i;
661 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
662 union acpi_object *cst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 if (nocst)
Patrick Mocheld550d982006-06-27 00:41:40 -0400666 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700668 current_count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
670 status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
671 if (ACPI_FAILURE(status)) {
672 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400673 return -ENODEV;
Len Brown4be44fc2005-08-05 00:44:28 -0400674 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Len Brown4be44fc2005-08-05 00:44:28 -0400676 cst = (union acpi_object *)buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678 /* There must be at least 2 elements */
679 if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
Len Brown64684632006-06-26 23:41:38 -0400680 printk(KERN_ERR PREFIX "not enough elements in _CST\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 status = -EFAULT;
682 goto end;
683 }
684
685 count = cst->package.elements[0].integer.value;
686
687 /* Validate number of power states. */
688 if (count < 1 || count != cst->package.count - 1) {
Len Brown64684632006-06-26 23:41:38 -0400689 printk(KERN_ERR PREFIX "count given by _CST is not valid\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 status = -EFAULT;
691 goto end;
692 }
693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 /* Tell driver that at least _CST is supported. */
695 pr->flags.has_cst = 1;
696
697 for (i = 1; i <= count; i++) {
698 union acpi_object *element;
699 union acpi_object *obj;
700 struct acpi_power_register *reg;
701 struct acpi_processor_cx cx;
702
703 memset(&cx, 0, sizeof(cx));
704
Len Brown4be44fc2005-08-05 00:44:28 -0400705 element = (union acpi_object *)&(cst->package.elements[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 if (element->type != ACPI_TYPE_PACKAGE)
707 continue;
708
709 if (element->package.count != 4)
710 continue;
711
Len Brown4be44fc2005-08-05 00:44:28 -0400712 obj = (union acpi_object *)&(element->package.elements[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713
714 if (obj->type != ACPI_TYPE_BUFFER)
715 continue;
716
Len Brown4be44fc2005-08-05 00:44:28 -0400717 reg = (struct acpi_power_register *)obj->buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
719 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO &&
Len Brown4be44fc2005-08-05 00:44:28 -0400720 (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 continue;
722
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 /* There should be an easy way to extract an integer... */
Len Brown4be44fc2005-08-05 00:44:28 -0400724 obj = (union acpi_object *)&(element->package.elements[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 if (obj->type != ACPI_TYPE_INTEGER)
726 continue;
727
728 cx.type = obj->integer.value;
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700729 /*
730 * Some buggy BIOSes won't list C1 in _CST -
731 * Let acpi_processor_get_power_info_default() handle them later
732 */
733 if (i == 1 && cx.type != ACPI_STATE_C1)
734 current_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700736 cx.address = reg->address;
737 cx.index = current_count + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700739 cx.space_id = ACPI_CSTATE_SYSTEMIO;
740 if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
741 if (acpi_processor_ffh_cstate_probe
742 (pr->id, &cx, reg) == 0) {
743 cx.space_id = ACPI_CSTATE_FFH;
744 } else if (cx.type != ACPI_STATE_C1) {
745 /*
746 * C1 is a special case where FIXED_HARDWARE
747 * can be handled in non-MWAIT way as well.
748 * In that case, save this _CST entry info.
749 * That is, we retain space_id of SYSTEM_IO for
750 * halt based C1.
751 * Otherwise, ignore this info and continue.
752 */
753 continue;
754 }
755 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Len Brown4be44fc2005-08-05 00:44:28 -0400757 obj = (union acpi_object *)&(element->package.elements[2]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 if (obj->type != ACPI_TYPE_INTEGER)
759 continue;
760
761 cx.latency = obj->integer.value;
762
Len Brown4be44fc2005-08-05 00:44:28 -0400763 obj = (union acpi_object *)&(element->package.elements[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 if (obj->type != ACPI_TYPE_INTEGER)
765 continue;
766
767 cx.power = obj->integer.value;
768
Janosch Machowinskicf824782005-08-20 08:02:00 -0400769 current_count++;
770 memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx));
771
772 /*
773 * We support total ACPI_PROCESSOR_MAX_POWER - 1
774 * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1)
775 */
776 if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) {
777 printk(KERN_WARNING
778 "Limiting number of power states to max (%d)\n",
779 ACPI_PROCESSOR_MAX_POWER);
780 printk(KERN_WARNING
781 "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
782 break;
783 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 }
785
Len Brown4be44fc2005-08-05 00:44:28 -0400786 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n",
Janosch Machowinskicf824782005-08-20 08:02:00 -0400787 current_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
789 /* Validate number of power states discovered */
Janosch Machowinskicf824782005-08-20 08:02:00 -0400790 if (current_count < 2)
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400791 status = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
Len Brown4be44fc2005-08-05 00:44:28 -0400793 end:
Len Brown02438d82006-06-30 03:19:10 -0400794 kfree(buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Patrick Mocheld550d982006-06-27 00:41:40 -0400796 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797}
798
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx)
800{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
802 if (!cx->address)
Patrick Mocheld550d982006-06-27 00:41:40 -0400803 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
805 /*
806 * C2 latency must be less than or equal to 100
807 * microseconds.
808 */
809 else if (cx->latency > ACPI_PROCESSOR_MAX_C2_LATENCY) {
810 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400811 "latency too large [%d]\n", cx->latency));
Patrick Mocheld550d982006-06-27 00:41:40 -0400812 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 }
814
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 /*
816 * Otherwise we've met all of our C2 requirements.
817 * Normalize the C2 latency to expidite policy
818 */
819 cx->valid = 1;
820 cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);
821
Patrick Mocheld550d982006-06-27 00:41:40 -0400822 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823}
824
Len Brown4be44fc2005-08-05 00:44:28 -0400825static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
826 struct acpi_processor_cx *cx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827{
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400828 static int bm_check_flag;
829
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
831 if (!cx->address)
Patrick Mocheld550d982006-06-27 00:41:40 -0400832 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 /*
835 * C3 latency must be less than or equal to 1000
836 * microseconds.
837 */
838 else if (cx->latency > ACPI_PROCESSOR_MAX_C3_LATENCY) {
839 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400840 "latency too large [%d]\n", cx->latency));
Patrick Mocheld550d982006-06-27 00:41:40 -0400841 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 }
843
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 /*
845 * PIIX4 Erratum #18: We don't support C3 when Type-F (fast)
846 * DMA transfers are used by any ISA device to avoid livelock.
847 * Note that we could disable Type-F DMA (as recommended by
848 * the erratum), but this is known to disrupt certain ISA
849 * devices thus we take the conservative approach.
850 */
851 else if (errata.piix4.fdma) {
852 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400853 "C3 not supported on PIIX4 with Type-F DMA\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400854 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 }
856
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400857 /* All the logic here assumes flags.bm_check is same across all CPUs */
858 if (!bm_check_flag) {
859 /* Determine whether bm_check is needed based on CPU */
860 acpi_processor_power_init_bm_check(&(pr->flags), pr->id);
861 bm_check_flag = pr->flags.bm_check;
862 } else {
863 pr->flags.bm_check = bm_check_flag;
864 }
865
866 if (pr->flags.bm_check) {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400867 /* bus mastering control is necessary */
868 if (!pr->flags.bm_control) {
869 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400870 "C3 support requires bus mastering control\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400871 return;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400872 }
873 } else {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400874 /*
875 * WBINVD should be set in fadt, for C3 state to be
876 * supported on when bm_check is not required.
877 */
878 if (acpi_fadt.wb_invd != 1) {
879 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400880 "Cache invalidation should work properly"
881 " for C3 to be enabled on SMP systems\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400882 return;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400883 }
884 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD,
Len Brown4be44fc2005-08-05 00:44:28 -0400885 0, ACPI_MTX_DO_NOT_LOCK);
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400886 }
887
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 /*
889 * Otherwise we've met all of our C3 requirements.
890 * Normalize the C3 latency to expidite policy. Enable
891 * checking of bus mastering status (bm_check) so we can
892 * use this in our C3 policy
893 */
894 cx->valid = 1;
895 cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Patrick Mocheld550d982006-06-27 00:41:40 -0400897 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898}
899
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900static int acpi_processor_power_verify(struct acpi_processor *pr)
901{
902 unsigned int i;
903 unsigned int working = 0;
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100904
Andi Kleenbd663342006-03-25 16:31:07 +0100905#ifdef ARCH_APICTIMER_STOPS_ON_C3
Andi Kleen0b5c59a2006-03-26 02:24:07 +0100906 int timer_broadcast = 0;
907 cpumask_t mask = cpumask_of_cpu(pr->id);
Andi Kleenbd663342006-03-25 16:31:07 +0100908 on_each_cpu(switch_ipi_to_APIC_timer, &mask, 1, 1);
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100909#endif
910
Len Brown4be44fc2005-08-05 00:44:28 -0400911 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 struct acpi_processor_cx *cx = &pr->power.states[i];
913
914 switch (cx->type) {
915 case ACPI_STATE_C1:
916 cx->valid = 1;
917 break;
918
919 case ACPI_STATE_C2:
920 acpi_processor_power_verify_c2(cx);
Andi Kleenbd663342006-03-25 16:31:07 +0100921#ifdef ARCH_APICTIMER_STOPS_ON_C3
922 /* Some AMD systems fake C3 as C2, but still
923 have timer troubles */
924 if (cx->valid &&
925 boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
926 timer_broadcast++;
927#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 break;
929
930 case ACPI_STATE_C3:
931 acpi_processor_power_verify_c3(pr, cx);
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100932#ifdef ARCH_APICTIMER_STOPS_ON_C3
Andi Kleenbd663342006-03-25 16:31:07 +0100933 if (cx->valid)
934 timer_broadcast++;
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100935#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 break;
937 }
938
939 if (cx->valid)
940 working++;
941 }
942
Andi Kleen0b5c59a2006-03-26 02:24:07 +0100943#ifdef ARCH_APICTIMER_STOPS_ON_C3
Andi Kleenbd663342006-03-25 16:31:07 +0100944 if (timer_broadcast)
945 on_each_cpu(switch_APIC_timer_to_ipi, &mask, 1, 1);
Andi Kleen0b5c59a2006-03-26 02:24:07 +0100946#endif
Andi Kleenbd663342006-03-25 16:31:07 +0100947
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 return (working);
949}
950
Len Brown4be44fc2005-08-05 00:44:28 -0400951static int acpi_processor_get_power_info(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952{
953 unsigned int i;
954 int result;
955
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956
957 /* NOTE: the idle thread may not be running while calling
958 * this function */
959
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700960 /* Zero initialize all the C-states info. */
961 memset(pr->power.states, 0, sizeof(pr->power.states));
962
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 result = acpi_processor_get_power_info_cst(pr);
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400964 if (result == -ENODEV)
Darrick J. Wongc5a114f2006-10-19 23:28:28 -0700965 result = acpi_processor_get_power_info_fadt(pr);
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400966
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700967 if (result)
968 return result;
969
970 acpi_processor_get_power_info_default(pr);
971
Janosch Machowinskicf824782005-08-20 08:02:00 -0400972 pr->power.count = acpi_processor_power_verify(pr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973
974 /*
975 * Set Default Policy
976 * ------------------
977 * Now that we know which states are supported, set the default
978 * policy. Note that this policy can be changed dynamically
979 * (e.g. encourage deeper sleeps to conserve battery life when
980 * not on AC).
981 */
982 result = acpi_processor_set_power_policy(pr);
983 if (result)
Patrick Mocheld550d982006-06-27 00:41:40 -0400984 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985
986 /*
987 * if one state of type C2 or C3 is available, mark this
988 * CPU as being "idle manageable"
989 */
990 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500991 if (pr->power.states[i].valid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 pr->power.count = i;
Linus Torvalds2203d6e2005-11-18 07:29:51 -0800993 if (pr->power.states[i].type >= ACPI_STATE_C2)
994 pr->flags.power = 1;
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500995 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 }
997
Patrick Mocheld550d982006-06-27 00:41:40 -0400998 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999}
1000
Len Brown4be44fc2005-08-05 00:44:28 -04001001int acpi_processor_cst_has_changed(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002{
Len Brown4be44fc2005-08-05 00:44:28 -04001003 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
1006 if (!pr)
Patrick Mocheld550d982006-06-27 00:41:40 -04001007 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008
Len Brown4be44fc2005-08-05 00:44:28 -04001009 if (nocst) {
Patrick Mocheld550d982006-06-27 00:41:40 -04001010 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 }
1012
1013 if (!pr->flags.power_setup_done)
Patrick Mocheld550d982006-06-27 00:41:40 -04001014 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
1016 /* Fall back to the default idle loop */
1017 pm_idle = pm_idle_save;
Len Brown4be44fc2005-08-05 00:44:28 -04001018 synchronize_sched(); /* Relies on interrupts forcing exit from idle. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
1020 pr->flags.power = 0;
1021 result = acpi_processor_get_power_info(pr);
1022 if ((pr->flags.power == 1) && (pr->flags.power_setup_done))
1023 pm_idle = acpi_processor_idle;
1024
Patrick Mocheld550d982006-06-27 00:41:40 -04001025 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026}
1027
1028/* proc interface */
1029
1030static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
1031{
Len Brown4be44fc2005-08-05 00:44:28 -04001032 struct acpi_processor *pr = (struct acpi_processor *)seq->private;
1033 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035
1036 if (!pr)
1037 goto end;
1038
1039 seq_printf(seq, "active state: C%zd\n"
Len Brown4be44fc2005-08-05 00:44:28 -04001040 "max_cstate: C%d\n"
Arjan van de Ven5c875792006-09-30 23:27:17 -07001041 "bus master activity: %08x\n"
1042 "maximum allowed latency: %d usec\n",
Len Brown4be44fc2005-08-05 00:44:28 -04001043 pr->power.state ? pr->power.state - pr->power.states : 0,
Arjan van de Ven5c875792006-09-30 23:27:17 -07001044 max_cstate, (unsigned)pr->power.bm_activity,
1045 system_latency_constraint());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046
1047 seq_puts(seq, "states:\n");
1048
1049 for (i = 1; i <= pr->power.count; i++) {
1050 seq_printf(seq, " %cC%d: ",
Len Brown4be44fc2005-08-05 00:44:28 -04001051 (&pr->power.states[i] ==
1052 pr->power.state ? '*' : ' '), i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
1054 if (!pr->power.states[i].valid) {
1055 seq_puts(seq, "<not supported>\n");
1056 continue;
1057 }
1058
1059 switch (pr->power.states[i].type) {
1060 case ACPI_STATE_C1:
1061 seq_printf(seq, "type[C1] ");
1062 break;
1063 case ACPI_STATE_C2:
1064 seq_printf(seq, "type[C2] ");
1065 break;
1066 case ACPI_STATE_C3:
1067 seq_printf(seq, "type[C3] ");
1068 break;
1069 default:
1070 seq_printf(seq, "type[--] ");
1071 break;
1072 }
1073
1074 if (pr->power.states[i].promotion.state)
1075 seq_printf(seq, "promotion[C%zd] ",
Len Brown4be44fc2005-08-05 00:44:28 -04001076 (pr->power.states[i].promotion.state -
1077 pr->power.states));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 else
1079 seq_puts(seq, "promotion[--] ");
1080
1081 if (pr->power.states[i].demotion.state)
1082 seq_printf(seq, "demotion[C%zd] ",
Len Brown4be44fc2005-08-05 00:44:28 -04001083 (pr->power.states[i].demotion.state -
1084 pr->power.states));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 else
1086 seq_puts(seq, "demotion[--] ");
1087
Dominik Brodowskia3c65982006-06-24 19:37:00 -04001088 seq_printf(seq, "latency[%03d] usage[%08d] duration[%020llu]\n",
Len Brown4be44fc2005-08-05 00:44:28 -04001089 pr->power.states[i].latency,
Dominik Brodowskia3c65982006-06-24 19:37:00 -04001090 pr->power.states[i].usage,
1091 pr->power.states[i].time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 }
1093
Len Brown4be44fc2005-08-05 00:44:28 -04001094 end:
Patrick Mocheld550d982006-06-27 00:41:40 -04001095 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096}
1097
1098static int acpi_processor_power_open_fs(struct inode *inode, struct file *file)
1099{
1100 return single_open(file, acpi_processor_power_seq_show,
Len Brown4be44fc2005-08-05 00:44:28 -04001101 PDE(inode)->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102}
1103
Arjan van de Vend7508032006-07-04 13:06:00 -04001104static const struct file_operations acpi_processor_power_fops = {
Len Brown4be44fc2005-08-05 00:44:28 -04001105 .open = acpi_processor_power_open_fs,
1106 .read = seq_read,
1107 .llseek = seq_lseek,
1108 .release = single_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109};
1110
Andrew Morton1fec74a2006-10-17 00:09:58 -07001111#ifdef CONFIG_SMP
Arjan van de Ven5c875792006-09-30 23:27:17 -07001112static void smp_callback(void *v)
1113{
1114 /* we already woke the CPU up, nothing more to do */
1115}
1116
1117/*
1118 * This function gets called when a part of the kernel has a new latency
1119 * requirement. This means we need to get all processors out of their C-state,
1120 * and then recalculate a new suitable C-state. Just do a cross-cpu IPI; that
1121 * wakes them all right up.
1122 */
1123static int acpi_processor_latency_notify(struct notifier_block *b,
1124 unsigned long l, void *v)
1125{
1126 smp_call_function(smp_callback, NULL, 0, 1);
1127 return NOTIFY_OK;
1128}
1129
1130static struct notifier_block acpi_processor_latency_notifier = {
1131 .notifier_call = acpi_processor_latency_notify,
1132};
Andrew Morton1fec74a2006-10-17 00:09:58 -07001133#endif
Arjan van de Ven5c875792006-09-30 23:27:17 -07001134
Pierre Ossman7af8b662006-10-10 14:20:31 -07001135int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
Len Brown4be44fc2005-08-05 00:44:28 -04001136 struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137{
Len Brown4be44fc2005-08-05 00:44:28 -04001138 acpi_status status = 0;
Andreas Mohrb6835052006-04-27 05:25:00 -04001139 static int first_run;
Len Brown4be44fc2005-08-05 00:44:28 -04001140 struct proc_dir_entry *entry = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 unsigned int i;
1142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
1144 if (!first_run) {
1145 dmi_check_system(processor_power_dmi_table);
1146 if (max_cstate < ACPI_C_STATES_MAX)
Len Brown4be44fc2005-08-05 00:44:28 -04001147 printk(KERN_NOTICE
1148 "ACPI: processor limited to max C-state %d\n",
1149 max_cstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 first_run++;
Andrew Morton1fec74a2006-10-17 00:09:58 -07001151#ifdef CONFIG_SMP
Arjan van de Ven5c875792006-09-30 23:27:17 -07001152 register_latency_notifier(&acpi_processor_latency_notifier);
Andrew Morton1fec74a2006-10-17 00:09:58 -07001153#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 }
1155
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -04001156 if (!pr)
Patrick Mocheld550d982006-06-27 00:41:40 -04001157 return -EINVAL;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -04001158
1159 if (acpi_fadt.cst_cnt && !nocst) {
Len Brown4be44fc2005-08-05 00:44:28 -04001160 status =
1161 acpi_os_write_port(acpi_fadt.smi_cmd, acpi_fadt.cst_cnt, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -04001163 ACPI_EXCEPTION((AE_INFO, status,
1164 "Notifying BIOS of _CST ability failed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 }
1166 }
1167
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 acpi_processor_get_power_info(pr);
1169
1170 /*
1171 * Install the idle handler if processor power management is supported.
1172 * Note that we use previously set idle handler will be used on
1173 * platforms that only support C1.
1174 */
1175 if ((pr->flags.power) && (!boot_option_idle_override)) {
1176 printk(KERN_INFO PREFIX "CPU%d (power states:", pr->id);
1177 for (i = 1; i <= pr->power.count; i++)
1178 if (pr->power.states[i].valid)
Len Brown4be44fc2005-08-05 00:44:28 -04001179 printk(" C%d[C%d]", i,
1180 pr->power.states[i].type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 printk(")\n");
1182
1183 if (pr->id == 0) {
1184 pm_idle_save = pm_idle;
1185 pm_idle = acpi_processor_idle;
1186 }
1187 }
1188
1189 /* 'power' [R] */
1190 entry = create_proc_entry(ACPI_PROCESSOR_FILE_POWER,
Len Brown4be44fc2005-08-05 00:44:28 -04001191 S_IRUGO, acpi_device_dir(device));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 if (!entry)
Thomas Renningera6fc6722006-06-26 23:58:43 -04001193 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 else {
1195 entry->proc_fops = &acpi_processor_power_fops;
1196 entry->data = acpi_driver_data(device);
1197 entry->owner = THIS_MODULE;
1198 }
1199
1200 pr->flags.power_setup_done = 1;
1201
Patrick Mocheld550d982006-06-27 00:41:40 -04001202 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203}
1204
Len Brown4be44fc2005-08-05 00:44:28 -04001205int acpi_processor_power_exit(struct acpi_processor *pr,
1206 struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208
1209 pr->flags.power_setup_done = 0;
1210
1211 if (acpi_device_dir(device))
Len Brown4be44fc2005-08-05 00:44:28 -04001212 remove_proc_entry(ACPI_PROCESSOR_FILE_POWER,
1213 acpi_device_dir(device));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
1215 /* Unregister the idle handler when processor #0 is removed. */
1216 if (pr->id == 0) {
1217 pm_idle = pm_idle_save;
1218
1219 /*
1220 * We are about to unload the current idle thread pm callback
1221 * (pm_idle), Wait for all processors to update cached/local
1222 * copies of pm_idle before proceeding.
1223 */
1224 cpu_idle_wait();
Andrew Morton1fec74a2006-10-17 00:09:58 -07001225#ifdef CONFIG_SMP
Arjan van de Ven5c875792006-09-30 23:27:17 -07001226 unregister_latency_notifier(&acpi_processor_latency_notifier);
Andrew Morton1fec74a2006-10-17 00:09:58 -07001227#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 }
1229
Patrick Mocheld550d982006-06-27 00:41:40 -04001230 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231}