blob: 2be895895943b5eba51973fa3678d49819cef038 [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>
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
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() */
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#include <asm/io.h>
43#include <asm/uaccess.h>
44
45#include <acpi/acpi_bus.h>
46#include <acpi/processor.h>
47
48#define ACPI_PROCESSOR_COMPONENT 0x01000000
49#define ACPI_PROCESSOR_CLASS "processor"
50#define ACPI_PROCESSOR_DRIVER_NAME "ACPI Processor Driver"
51#define _COMPONENT ACPI_PROCESSOR_COMPONENT
Len Brown4be44fc2005-08-05 00:44:28 -040052ACPI_MODULE_NAME("acpi_processor")
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#define ACPI_PROCESSOR_FILE_POWER "power"
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#define US_TO_PM_TIMER_TICKS(t) ((t * (PM_TIMER_FREQUENCY/1000)) / 1000)
55#define C2_OVERHEAD 4 /* 1us (3.579 ticks per us) */
56#define C3_OVERHEAD 4 /* 1us (3.579 ticks per us) */
Len Brown4be44fc2005-08-05 00:44:28 -040057static void (*pm_idle_save) (void);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058module_param(max_cstate, uint, 0644);
59
60static unsigned int nocst = 0;
61module_param(nocst, uint, 0000);
62
63/*
64 * bm_history -- bit-mask with a bit per jiffy of bus-master activity
65 * 1000 HZ: 0xFFFFFFFF: 32 jiffies = 32ms
66 * 800 HZ: 0xFFFFFFFF: 32 jiffies = 40ms
67 * 100 HZ: 0x0000000F: 4 jiffies = 40ms
68 * reduce history for more aggressive entry into C3
69 */
Len Brown4be44fc2005-08-05 00:44:28 -040070static unsigned int bm_history =
71 (HZ >= 800 ? 0xFFFFFFFF : ((1U << (HZ / 25)) - 1));
Linus Torvalds1da177e2005-04-16 15:20:36 -070072module_param(bm_history, uint, 0644);
73/* --------------------------------------------------------------------------
74 Power Management
75 -------------------------------------------------------------------------- */
76
77/*
78 * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
79 * For now disable this. Probably a bug somewhere else.
80 *
81 * To skip this limit, boot/load with a large max_cstate limit.
82 */
David Shaohua Li335f16b2005-06-22 18:37:00 -040083static int set_max_cstate(struct dmi_system_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084{
85 if (max_cstate > ACPI_PROCESSOR_MAX_POWER)
86 return 0;
87
Len Brown3d356002005-08-03 00:22:52 -040088 printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate."
Len Brown4be44fc2005-08-05 00:44:28 -040089 " Override with \"processor.max_cstate=%d\"\n", id->ident,
90 (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Len Brown3d356002005-08-03 00:22:52 -040092 max_cstate = (long)id->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94 return 0;
95}
96
Ashok Raj7ded5682006-02-03 21:51:23 +010097/* Actually this shouldn't be __cpuinitdata, would be better to fix the
98 callers to only run once -AK */
99static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = {
Thomas Rosner876c1842006-01-06 01:31:00 -0500100 { set_max_cstate, "IBM ThinkPad R40e", {
101 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
102 DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW")}, (void *)1},
103 { set_max_cstate, "IBM ThinkPad R40e", {
104 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
105 DMI_MATCH(DMI_BIOS_VERSION,"1SET43WW") }, (void*)1},
106 { set_max_cstate, "IBM ThinkPad R40e", {
107 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
108 DMI_MATCH(DMI_BIOS_VERSION,"1SET45WW") }, (void*)1},
109 { set_max_cstate, "IBM ThinkPad R40e", {
110 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
111 DMI_MATCH(DMI_BIOS_VERSION,"1SET47WW") }, (void*)1},
112 { set_max_cstate, "IBM ThinkPad R40e", {
113 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
114 DMI_MATCH(DMI_BIOS_VERSION,"1SET50WW") }, (void*)1},
115 { set_max_cstate, "IBM ThinkPad R40e", {
116 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
117 DMI_MATCH(DMI_BIOS_VERSION,"1SET52WW") }, (void*)1},
118 { set_max_cstate, "IBM ThinkPad R40e", {
119 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
120 DMI_MATCH(DMI_BIOS_VERSION,"1SET55WW") }, (void*)1},
121 { set_max_cstate, "IBM ThinkPad R40e", {
122 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
123 DMI_MATCH(DMI_BIOS_VERSION,"1SET56WW") }, (void*)1},
124 { set_max_cstate, "IBM ThinkPad R40e", {
125 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
126 DMI_MATCH(DMI_BIOS_VERSION,"1SET59WW") }, (void*)1},
127 { set_max_cstate, "IBM ThinkPad R40e", {
128 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
129 DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW") }, (void*)1},
130 { set_max_cstate, "IBM ThinkPad R40e", {
131 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
132 DMI_MATCH(DMI_BIOS_VERSION,"1SET61WW") }, (void*)1},
133 { set_max_cstate, "IBM ThinkPad R40e", {
134 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
135 DMI_MATCH(DMI_BIOS_VERSION,"1SET62WW") }, (void*)1},
136 { set_max_cstate, "IBM ThinkPad R40e", {
137 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
138 DMI_MATCH(DMI_BIOS_VERSION,"1SET64WW") }, (void*)1},
139 { set_max_cstate, "IBM ThinkPad R40e", {
140 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
141 DMI_MATCH(DMI_BIOS_VERSION,"1SET65WW") }, (void*)1},
142 { set_max_cstate, "IBM ThinkPad R40e", {
143 DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
144 DMI_MATCH(DMI_BIOS_VERSION,"1SET68WW") }, (void*)1},
145 { set_max_cstate, "Medion 41700", {
146 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
147 DMI_MATCH(DMI_BIOS_VERSION,"R01-A1J")}, (void *)1},
148 { set_max_cstate, "Clevo 5600D", {
149 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
150 DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
Len Brown4be44fc2005-08-05 00:44:28 -0400151 (void *)2},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 {},
153};
154
Len Brown4be44fc2005-08-05 00:44:28 -0400155static inline u32 ticks_elapsed(u32 t1, u32 t2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156{
157 if (t2 >= t1)
158 return (t2 - t1);
159 else if (!acpi_fadt.tmr_val_ext)
160 return (((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
161 else
162 return ((0xFFFFFFFF - t1) + t2);
163}
164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165static void
Len Brown4be44fc2005-08-05 00:44:28 -0400166acpi_processor_power_activate(struct acpi_processor *pr,
167 struct acpi_processor_cx *new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Len Brown4be44fc2005-08-05 00:44:28 -0400169 struct acpi_processor_cx *old;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 if (!pr || !new)
172 return;
173
174 old = pr->power.state;
175
176 if (old)
177 old->promotion.count = 0;
Len Brown4be44fc2005-08-05 00:44:28 -0400178 new->demotion.count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
180 /* Cleanup from old state. */
181 if (old) {
182 switch (old->type) {
183 case ACPI_STATE_C3:
184 /* Disable bus master reload */
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400185 if (new->type != ACPI_STATE_C3 && pr->flags.bm_check)
Len Brown4be44fc2005-08-05 00:44:28 -0400186 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0,
187 ACPI_MTX_DO_NOT_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 break;
189 }
190 }
191
192 /* Prepare to use new state. */
193 switch (new->type) {
194 case ACPI_STATE_C3:
195 /* Enable bus master reload */
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400196 if (old->type != ACPI_STATE_C3 && pr->flags.bm_check)
Len Brown4be44fc2005-08-05 00:44:28 -0400197 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 1,
198 ACPI_MTX_DO_NOT_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 break;
200 }
201
202 pr->power.state = new;
203
204 return;
205}
206
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800207static void acpi_safe_halt(void)
208{
Nick Piggin2a298a32005-12-02 12:44:19 +1100209 clear_thread_flag(TIF_POLLING_NRFLAG);
210 smp_mb__after_clear_bit();
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800211 if (!need_resched())
212 safe_halt();
Nick Piggin2a298a32005-12-02 12:44:19 +1100213 set_thread_flag(TIF_POLLING_NRFLAG);
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800214}
215
Len Brown4be44fc2005-08-05 00:44:28 -0400216static atomic_t c3_cpu_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Len Brown4be44fc2005-08-05 00:44:28 -0400218static void acpi_processor_idle(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
Len Brown4be44fc2005-08-05 00:44:28 -0400220 struct acpi_processor *pr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 struct acpi_processor_cx *cx = NULL;
222 struct acpi_processor_cx *next_state = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400223 int sleep_ticks = 0;
224 u32 t1, t2 = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800226 pr = processors[smp_processor_id()];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 if (!pr)
228 return;
229
230 /*
231 * Interrupts must be disabled during bus mastering calculations and
232 * for C2/C3 transitions.
233 */
234 local_irq_disable();
235
236 /*
237 * Check whether we truly need to go idle, or should
238 * reschedule:
239 */
240 if (unlikely(need_resched())) {
241 local_irq_enable();
242 return;
243 }
244
245 cx = pr->power.state;
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800246 if (!cx) {
247 if (pm_idle_save)
248 pm_idle_save();
249 else
250 acpi_safe_halt();
251 return;
252 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254 /*
255 * Check BM Activity
256 * -----------------
257 * Check for bus mastering activity (if required), record, and check
258 * for demotion.
259 */
260 if (pr->flags.bm_check) {
Len Brown4be44fc2005-08-05 00:44:28 -0400261 u32 bm_status = 0;
262 unsigned long diff = jiffies - pr->power.bm_check_timestamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 if (diff > 32)
265 diff = 32;
266
267 while (diff) {
268 /* if we didn't get called, assume there was busmaster activity */
269 diff--;
270 if (diff)
271 pr->power.bm_activity |= 0x1;
272 pr->power.bm_activity <<= 1;
273 }
274
275 acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS,
Len Brown4be44fc2005-08-05 00:44:28 -0400276 &bm_status, ACPI_MTX_DO_NOT_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 if (bm_status) {
278 pr->power.bm_activity++;
279 acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS,
Len Brown4be44fc2005-08-05 00:44:28 -0400280 1, ACPI_MTX_DO_NOT_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 }
282 /*
283 * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect
284 * the true state of bus mastering activity; forcing us to
285 * manually check the BMIDEA bit of each IDE channel.
286 */
287 else if (errata.piix4.bmisx) {
288 if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
Len Brown4be44fc2005-08-05 00:44:28 -0400289 || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 pr->power.bm_activity++;
291 }
292
293 pr->power.bm_check_timestamp = jiffies;
294
295 /*
296 * Apply bus mastering demotion policy. Automatically demote
297 * to avoid a faulty transition. Note that the processor
298 * won't enter a low-power state during this call (to this
299 * funciton) but should upon the next.
300 *
301 * TBD: A better policy might be to fallback to the demotion
302 * state (use it for this quantum only) istead of
303 * demoting -- and rely on duration as our sole demotion
304 * qualification. This may, however, introduce DMA
305 * issues (e.g. floppy DMA transfer overrun/underrun).
306 */
307 if (pr->power.bm_activity & cx->demotion.threshold.bm) {
308 local_irq_enable();
309 next_state = cx->demotion.state;
310 goto end;
311 }
312 }
313
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400314#ifdef CONFIG_HOTPLUG_CPU
315 /*
316 * Check for P_LVL2_UP flag before entering C2 and above on
317 * an SMP system. We do it here instead of doing it at _CST/P_LVL
318 * detection phase, to work cleanly with logical CPU hotplug.
319 */
320 if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
David Shaohua Li1e483962005-12-01 17:00:00 -0500321 !pr->flags.has_cst && !acpi_fadt.plvl2_up)
322 cx = &pr->power.states[ACPI_STATE_C1];
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400323#endif
David Shaohua Li1e483962005-12-01 17:00:00 -0500324
325 cx->usage++;
326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 /*
328 * Sleep:
329 * ------
330 * Invoke the current Cx state to put the processor to sleep.
331 */
Nick Piggin2a298a32005-12-02 12:44:19 +1100332 if (cx->type == ACPI_STATE_C2 || cx->type == ACPI_STATE_C3) {
333 clear_thread_flag(TIF_POLLING_NRFLAG);
334 smp_mb__after_clear_bit();
335 if (need_resched()) {
336 set_thread_flag(TIF_POLLING_NRFLAG);
Linus Torvaldsaf2eb172005-12-02 23:09:06 -0800337 local_irq_enable();
Nick Piggin2a298a32005-12-02 12:44:19 +1100338 return;
339 }
340 }
341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 switch (cx->type) {
343
344 case ACPI_STATE_C1:
345 /*
346 * Invoke C1.
347 * Use the appropriate idle routine, the one that would
348 * be used without acpi C-states.
349 */
350 if (pm_idle_save)
351 pm_idle_save();
352 else
Nick Piggin64c7c8f2005-11-08 21:39:04 -0800353 acpi_safe_halt();
354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 /*
Len Brown4be44fc2005-08-05 00:44:28 -0400356 * TBD: Can't get time duration while in C1, as resumes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 * go to an ISR rather than here. Need to instrument
358 * base interrupt handler.
359 */
360 sleep_ticks = 0xFFFFFFFF;
361 break;
362
363 case ACPI_STATE_C2:
364 /* Get start time (ticks) */
365 t1 = inl(acpi_fadt.xpm_tmr_blk.address);
366 /* Invoke C2 */
367 inb(cx->address);
368 /* Dummy op - must do something useless after P_LVL2 read */
369 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
370 /* Get end time (ticks) */
371 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
372 /* Re-enable interrupts */
373 local_irq_enable();
Nick Piggin2a298a32005-12-02 12:44:19 +1100374 set_thread_flag(TIF_POLLING_NRFLAG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 /* Compute time (ticks) that we were actually asleep */
Len Brown4be44fc2005-08-05 00:44:28 -0400376 sleep_ticks =
377 ticks_elapsed(t1, t2) - cx->latency_ticks - C2_OVERHEAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 break;
379
380 case ACPI_STATE_C3:
Len Brown4be44fc2005-08-05 00:44:28 -0400381
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400382 if (pr->flags.bm_check) {
383 if (atomic_inc_return(&c3_cpu_count) ==
Len Brown4be44fc2005-08-05 00:44:28 -0400384 num_online_cpus()) {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400385 /*
386 * All CPUs are trying to go to C3
387 * Disable bus master arbitration
388 */
389 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1,
Len Brown4be44fc2005-08-05 00:44:28 -0400390 ACPI_MTX_DO_NOT_LOCK);
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400391 }
392 } else {
393 /* SMP with no shared cache... Invalidate cache */
394 ACPI_FLUSH_CPU_CACHE();
395 }
Len Brown4be44fc2005-08-05 00:44:28 -0400396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 /* Get start time (ticks) */
398 t1 = inl(acpi_fadt.xpm_tmr_blk.address);
399 /* Invoke C3 */
400 inb(cx->address);
401 /* Dummy op - must do something useless after P_LVL3 read */
402 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
403 /* Get end time (ticks) */
404 t2 = inl(acpi_fadt.xpm_tmr_blk.address);
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400405 if (pr->flags.bm_check) {
406 /* Enable bus master arbitration */
407 atomic_dec(&c3_cpu_count);
Len Brown4be44fc2005-08-05 00:44:28 -0400408 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0,
409 ACPI_MTX_DO_NOT_LOCK);
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400410 }
411
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 /* Re-enable interrupts */
413 local_irq_enable();
Nick Piggin2a298a32005-12-02 12:44:19 +1100414 set_thread_flag(TIF_POLLING_NRFLAG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 /* Compute time (ticks) that we were actually asleep */
Len Brown4be44fc2005-08-05 00:44:28 -0400416 sleep_ticks =
417 ticks_elapsed(t1, t2) - cx->latency_ticks - C3_OVERHEAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 break;
419
420 default:
421 local_irq_enable();
422 return;
423 }
424
425 next_state = pr->power.state;
426
David Shaohua Li1e483962005-12-01 17:00:00 -0500427#ifdef CONFIG_HOTPLUG_CPU
428 /* Don't do promotion/demotion */
429 if ((cx->type == ACPI_STATE_C1) && (num_online_cpus() > 1) &&
430 !pr->flags.has_cst && !acpi_fadt.plvl2_up) {
431 next_state = cx;
432 goto end;
433 }
434#endif
435
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 /*
437 * Promotion?
438 * ----------
439 * Track the number of longs (time asleep is greater than threshold)
440 * and promote when the count threshold is reached. Note that bus
441 * mastering activity may prevent promotions.
442 * Do not promote above max_cstate.
443 */
444 if (cx->promotion.state &&
445 ((cx->promotion.state - pr->power.states) <= max_cstate)) {
446 if (sleep_ticks > cx->promotion.threshold.ticks) {
447 cx->promotion.count++;
Len Brown4be44fc2005-08-05 00:44:28 -0400448 cx->demotion.count = 0;
449 if (cx->promotion.count >=
450 cx->promotion.threshold.count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 if (pr->flags.bm_check) {
Len Brown4be44fc2005-08-05 00:44:28 -0400452 if (!
453 (pr->power.bm_activity & cx->
454 promotion.threshold.bm)) {
455 next_state =
456 cx->promotion.state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 goto end;
458 }
Len Brown4be44fc2005-08-05 00:44:28 -0400459 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 next_state = cx->promotion.state;
461 goto end;
462 }
463 }
464 }
465 }
466
467 /*
468 * Demotion?
469 * ---------
470 * Track the number of shorts (time asleep is less than time threshold)
471 * and demote when the usage threshold is reached.
472 */
473 if (cx->demotion.state) {
474 if (sleep_ticks < cx->demotion.threshold.ticks) {
475 cx->demotion.count++;
476 cx->promotion.count = 0;
477 if (cx->demotion.count >= cx->demotion.threshold.count) {
478 next_state = cx->demotion.state;
479 goto end;
480 }
481 }
482 }
483
Len Brown4be44fc2005-08-05 00:44:28 -0400484 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 /*
486 * Demote if current state exceeds max_cstate
487 */
488 if ((pr->power.state - pr->power.states) > max_cstate) {
489 if (cx->demotion.state)
490 next_state = cx->demotion.state;
491 }
492
493 /*
494 * New Cx State?
495 * -------------
496 * If we're going to start using a new Cx state we must clean up
497 * from the previous and prepare to use the new.
498 */
499 if (next_state != pr->power.state)
500 acpi_processor_power_activate(pr, next_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
502
Len Brown4be44fc2005-08-05 00:44:28 -0400503static int acpi_processor_set_power_policy(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504{
505 unsigned int i;
506 unsigned int state_is_set = 0;
507 struct acpi_processor_cx *lower = NULL;
508 struct acpi_processor_cx *higher = NULL;
509 struct acpi_processor_cx *cx;
510
Len Brown4be44fc2005-08-05 00:44:28 -0400511 ACPI_FUNCTION_TRACE("acpi_processor_set_power_policy");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
513 if (!pr)
514 return_VALUE(-EINVAL);
515
516 /*
517 * This function sets the default Cx state policy (OS idle handler).
518 * Our scheme is to promote quickly to C2 but more conservatively
519 * to C3. We're favoring C2 for its characteristics of low latency
520 * (quick response), good power savings, and ability to allow bus
521 * mastering activity. Note that the Cx state policy is completely
522 * customizable and can be altered dynamically.
523 */
524
525 /* startup state */
Len Brown4be44fc2005-08-05 00:44:28 -0400526 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 cx = &pr->power.states[i];
528 if (!cx->valid)
529 continue;
530
531 if (!state_is_set)
532 pr->power.state = cx;
533 state_is_set++;
534 break;
Len Brown4be44fc2005-08-05 00:44:28 -0400535 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
537 if (!state_is_set)
538 return_VALUE(-ENODEV);
539
540 /* demotion */
Len Brown4be44fc2005-08-05 00:44:28 -0400541 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 cx = &pr->power.states[i];
543 if (!cx->valid)
544 continue;
545
546 if (lower) {
547 cx->demotion.state = lower;
548 cx->demotion.threshold.ticks = cx->latency_ticks;
549 cx->demotion.threshold.count = 1;
550 if (cx->type == ACPI_STATE_C3)
551 cx->demotion.threshold.bm = bm_history;
552 }
553
554 lower = cx;
555 }
556
557 /* promotion */
558 for (i = (ACPI_PROCESSOR_MAX_POWER - 1); i > 0; i--) {
559 cx = &pr->power.states[i];
560 if (!cx->valid)
561 continue;
562
563 if (higher) {
Len Brown4be44fc2005-08-05 00:44:28 -0400564 cx->promotion.state = higher;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 cx->promotion.threshold.ticks = cx->latency_ticks;
566 if (cx->type >= ACPI_STATE_C2)
567 cx->promotion.threshold.count = 4;
568 else
569 cx->promotion.threshold.count = 10;
570 if (higher->type == ACPI_STATE_C3)
571 cx->promotion.threshold.bm = bm_history;
572 }
573
574 higher = cx;
575 }
576
Len Brown4be44fc2005-08-05 00:44:28 -0400577 return_VALUE(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578}
579
Len Brown4be44fc2005-08-05 00:44:28 -0400580static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_fadt");
583
584 if (!pr)
585 return_VALUE(-EINVAL);
586
587 if (!pr->pblk)
588 return_VALUE(-ENODEV);
589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 /* if info is obtained from pblk/fadt, type equals state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
592 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3;
593
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400594#ifndef CONFIG_HOTPLUG_CPU
595 /*
596 * Check for P_LVL2_UP flag before entering C2 and above on
597 * an SMP system.
598 */
David Shaohua Li1e483962005-12-01 17:00:00 -0500599 if ((num_online_cpus() > 1) && !acpi_fadt.plvl2_up)
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400600 return_VALUE(-ENODEV);
601#endif
602
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 /* determine C2 and C3 address from pblk */
604 pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4;
605 pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5;
606
607 /* determine latencies from FADT */
608 pr->power.states[ACPI_STATE_C2].latency = acpi_fadt.plvl2_lat;
609 pr->power.states[ACPI_STATE_C3].latency = acpi_fadt.plvl3_lat;
610
611 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
612 "lvl2[0x%08x] lvl3[0x%08x]\n",
613 pr->power.states[ACPI_STATE_C2].address,
614 pr->power.states[ACPI_STATE_C3].address));
615
616 return_VALUE(0);
617}
618
Len Brown4be44fc2005-08-05 00:44:28 -0400619static int acpi_processor_get_power_info_default_c1(struct acpi_processor *pr)
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500620{
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500621 ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_default_c1");
622
Janosch Machowinskicf824782005-08-20 08:02:00 -0400623 /* Zero initialize all the C-states info. */
Linus Torvalds2203d6e2005-11-18 07:29:51 -0800624 memset(pr->power.states, 0, sizeof(pr->power.states));
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500625
Janosch Machowinskicf824782005-08-20 08:02:00 -0400626 /* set the first C-State to C1 */
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500627 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500628
629 /* the C0 state only exists as a filler in our array,
630 * and all processors need to support C1 */
631 pr->power.states[ACPI_STATE_C0].valid = 1;
632 pr->power.states[ACPI_STATE_C1].valid = 1;
633
634 return_VALUE(0);
635}
636
Len Brown4be44fc2005-08-05 00:44:28 -0400637static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638{
Len Brown4be44fc2005-08-05 00:44:28 -0400639 acpi_status status = 0;
640 acpi_integer count;
Janosch Machowinskicf824782005-08-20 08:02:00 -0400641 int current_count;
Len Brown4be44fc2005-08-05 00:44:28 -0400642 int i;
643 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
644 union acpi_object *cst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646 ACPI_FUNCTION_TRACE("acpi_processor_get_power_info_cst");
647
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 if (nocst)
649 return_VALUE(-ENODEV);
650
Janosch Machowinskicf824782005-08-20 08:02:00 -0400651 current_count = 1;
652
653 /* Zero initialize C2 onwards and prepare for fresh CST lookup */
654 for (i = 2; i < ACPI_PROCESSOR_MAX_POWER; i++)
655 memset(&(pr->power.states[i]), 0,
656 sizeof(struct acpi_processor_cx));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
658 status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
659 if (ACPI_FAILURE(status)) {
660 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n"));
661 return_VALUE(-ENODEV);
Len Brown4be44fc2005-08-05 00:44:28 -0400662 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Len Brown4be44fc2005-08-05 00:44:28 -0400664 cst = (union acpi_object *)buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
666 /* There must be at least 2 elements */
667 if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
Len Brown4be44fc2005-08-05 00:44:28 -0400668 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
669 "not enough elements in _CST\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 status = -EFAULT;
671 goto end;
672 }
673
674 count = cst->package.elements[0].integer.value;
675
676 /* Validate number of power states. */
677 if (count < 1 || count != cst->package.count - 1) {
Len Brown4be44fc2005-08-05 00:44:28 -0400678 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
679 "count given by _CST is not valid\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 status = -EFAULT;
681 goto end;
682 }
683
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 /* Tell driver that at least _CST is supported. */
685 pr->flags.has_cst = 1;
686
687 for (i = 1; i <= count; i++) {
688 union acpi_object *element;
689 union acpi_object *obj;
690 struct acpi_power_register *reg;
691 struct acpi_processor_cx cx;
692
693 memset(&cx, 0, sizeof(cx));
694
Len Brown4be44fc2005-08-05 00:44:28 -0400695 element = (union acpi_object *)&(cst->package.elements[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 if (element->type != ACPI_TYPE_PACKAGE)
697 continue;
698
699 if (element->package.count != 4)
700 continue;
701
Len Brown4be44fc2005-08-05 00:44:28 -0400702 obj = (union acpi_object *)&(element->package.elements[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703
704 if (obj->type != ACPI_TYPE_BUFFER)
705 continue;
706
Len Brown4be44fc2005-08-05 00:44:28 -0400707 reg = (struct acpi_power_register *)obj->buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
709 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO &&
Len Brown4be44fc2005-08-05 00:44:28 -0400710 (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 continue;
712
713 cx.address = (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) ?
Len Brown4be44fc2005-08-05 00:44:28 -0400714 0 : reg->address;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
716 /* There should be an easy way to extract an integer... */
Len Brown4be44fc2005-08-05 00:44:28 -0400717 obj = (union acpi_object *)&(element->package.elements[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 if (obj->type != ACPI_TYPE_INTEGER)
719 continue;
720
721 cx.type = obj->integer.value;
722
723 if ((cx.type != ACPI_STATE_C1) &&
724 (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO))
725 continue;
726
Janosch Machowinskicf824782005-08-20 08:02:00 -0400727 if ((cx.type < ACPI_STATE_C2) || (cx.type > ACPI_STATE_C3))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 continue;
729
Len Brown4be44fc2005-08-05 00:44:28 -0400730 obj = (union acpi_object *)&(element->package.elements[2]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 if (obj->type != ACPI_TYPE_INTEGER)
732 continue;
733
734 cx.latency = obj->integer.value;
735
Len Brown4be44fc2005-08-05 00:44:28 -0400736 obj = (union acpi_object *)&(element->package.elements[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 if (obj->type != ACPI_TYPE_INTEGER)
738 continue;
739
740 cx.power = obj->integer.value;
741
Janosch Machowinskicf824782005-08-20 08:02:00 -0400742 current_count++;
743 memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx));
744
745 /*
746 * We support total ACPI_PROCESSOR_MAX_POWER - 1
747 * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1)
748 */
749 if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) {
750 printk(KERN_WARNING
751 "Limiting number of power states to max (%d)\n",
752 ACPI_PROCESSOR_MAX_POWER);
753 printk(KERN_WARNING
754 "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
755 break;
756 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 }
758
Len Brown4be44fc2005-08-05 00:44:28 -0400759 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n",
Janosch Machowinskicf824782005-08-20 08:02:00 -0400760 current_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
762 /* Validate number of power states discovered */
Janosch Machowinskicf824782005-08-20 08:02:00 -0400763 if (current_count < 2)
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400764 status = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Len Brown4be44fc2005-08-05 00:44:28 -0400766 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 acpi_os_free(buffer.pointer);
768
769 return_VALUE(status);
770}
771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx)
773{
774 ACPI_FUNCTION_TRACE("acpi_processor_get_power_verify_c2");
775
776 if (!cx->address)
777 return_VOID;
778
779 /*
780 * C2 latency must be less than or equal to 100
781 * microseconds.
782 */
783 else if (cx->latency > ACPI_PROCESSOR_MAX_C2_LATENCY) {
784 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400785 "latency too large [%d]\n", cx->latency));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 return_VOID;
787 }
788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 /*
790 * Otherwise we've met all of our C2 requirements.
791 * Normalize the C2 latency to expidite policy
792 */
793 cx->valid = 1;
794 cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);
795
796 return_VOID;
797}
798
Len Brown4be44fc2005-08-05 00:44:28 -0400799static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
800 struct acpi_processor_cx *cx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801{
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400802 static int bm_check_flag;
803
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 ACPI_FUNCTION_TRACE("acpi_processor_get_power_verify_c3");
805
806 if (!cx->address)
807 return_VOID;
808
809 /*
810 * C3 latency must be less than or equal to 1000
811 * microseconds.
812 */
813 else if (cx->latency > ACPI_PROCESSOR_MAX_C3_LATENCY) {
814 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400815 "latency too large [%d]\n", cx->latency));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 return_VOID;
817 }
818
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 /*
820 * PIIX4 Erratum #18: We don't support C3 when Type-F (fast)
821 * DMA transfers are used by any ISA device to avoid livelock.
822 * Note that we could disable Type-F DMA (as recommended by
823 * the erratum), but this is known to disrupt certain ISA
824 * devices thus we take the conservative approach.
825 */
826 else if (errata.piix4.fdma) {
827 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400828 "C3 not supported on PIIX4 with Type-F DMA\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 return_VOID;
830 }
831
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400832 /* All the logic here assumes flags.bm_check is same across all CPUs */
833 if (!bm_check_flag) {
834 /* Determine whether bm_check is needed based on CPU */
835 acpi_processor_power_init_bm_check(&(pr->flags), pr->id);
836 bm_check_flag = pr->flags.bm_check;
837 } else {
838 pr->flags.bm_check = bm_check_flag;
839 }
840
841 if (pr->flags.bm_check) {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400842 /* bus mastering control is necessary */
843 if (!pr->flags.bm_control) {
844 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400845 "C3 support requires bus mastering control\n"));
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400846 return_VOID;
847 }
848 } else {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400849 /*
850 * WBINVD should be set in fadt, for C3 state to be
851 * supported on when bm_check is not required.
852 */
853 if (acpi_fadt.wb_invd != 1) {
854 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400855 "Cache invalidation should work properly"
856 " for C3 to be enabled on SMP systems\n"));
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400857 return_VOID;
858 }
859 acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD,
Len Brown4be44fc2005-08-05 00:44:28 -0400860 0, ACPI_MTX_DO_NOT_LOCK);
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400861 }
862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 /*
864 * Otherwise we've met all of our C3 requirements.
865 * Normalize the C3 latency to expidite policy. Enable
866 * checking of bus mastering status (bm_check) so we can
867 * use this in our C3 policy
868 */
869 cx->valid = 1;
870 cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
872 return_VOID;
873}
874
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875static int acpi_processor_power_verify(struct acpi_processor *pr)
876{
877 unsigned int i;
878 unsigned int working = 0;
Andi Kleenbd663342006-03-25 16:31:07 +0100879 int timer_broadcast = 0;
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100880 cpumask_t mask = cpumask_of_cpu(pr->id);
881
Andi Kleenbd663342006-03-25 16:31:07 +0100882#ifdef ARCH_APICTIMER_STOPS_ON_C3
883 on_each_cpu(switch_ipi_to_APIC_timer, &mask, 1, 1);
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100884#endif
885
Len Brown4be44fc2005-08-05 00:44:28 -0400886 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 struct acpi_processor_cx *cx = &pr->power.states[i];
888
889 switch (cx->type) {
890 case ACPI_STATE_C1:
891 cx->valid = 1;
892 break;
893
894 case ACPI_STATE_C2:
895 acpi_processor_power_verify_c2(cx);
Andi Kleenbd663342006-03-25 16:31:07 +0100896#ifdef ARCH_APICTIMER_STOPS_ON_C3
897 /* Some AMD systems fake C3 as C2, but still
898 have timer troubles */
899 if (cx->valid &&
900 boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
901 timer_broadcast++;
902#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 break;
904
905 case ACPI_STATE_C3:
906 acpi_processor_power_verify_c3(pr, cx);
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100907#ifdef ARCH_APICTIMER_STOPS_ON_C3
Andi Kleenbd663342006-03-25 16:31:07 +0100908 if (cx->valid)
909 timer_broadcast++;
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100910#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 break;
912 }
913
914 if (cx->valid)
915 working++;
916 }
917
Andi Kleenbd663342006-03-25 16:31:07 +0100918 if (timer_broadcast)
919 on_each_cpu(switch_APIC_timer_to_ipi, &mask, 1, 1);
920
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 return (working);
922}
923
Len Brown4be44fc2005-08-05 00:44:28 -0400924static int acpi_processor_get_power_info(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925{
926 unsigned int i;
927 int result;
928
929 ACPI_FUNCTION_TRACE("acpi_processor_get_power_info");
930
931 /* NOTE: the idle thread may not be running while calling
932 * this function */
933
Janosch Machowinskicf824782005-08-20 08:02:00 -0400934 /* Adding C1 state */
935 acpi_processor_get_power_info_default_c1(pr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 result = acpi_processor_get_power_info_cst(pr);
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400937 if (result == -ENODEV)
Janosch Machowinskicf824782005-08-20 08:02:00 -0400938 acpi_processor_get_power_info_fadt(pr);
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400939
Janosch Machowinskicf824782005-08-20 08:02:00 -0400940 pr->power.count = acpi_processor_power_verify(pr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941
942 /*
943 * Set Default Policy
944 * ------------------
945 * Now that we know which states are supported, set the default
946 * policy. Note that this policy can be changed dynamically
947 * (e.g. encourage deeper sleeps to conserve battery life when
948 * not on AC).
949 */
950 result = acpi_processor_set_power_policy(pr);
951 if (result)
952 return_VALUE(result);
953
954 /*
955 * if one state of type C2 or C3 is available, mark this
956 * CPU as being "idle manageable"
957 */
958 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500959 if (pr->power.states[i].valid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 pr->power.count = i;
Linus Torvalds2203d6e2005-11-18 07:29:51 -0800961 if (pr->power.states[i].type >= ACPI_STATE_C2)
962 pr->flags.power = 1;
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500963 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 }
965
966 return_VALUE(0);
967}
968
Len Brown4be44fc2005-08-05 00:44:28 -0400969int acpi_processor_cst_has_changed(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970{
Len Brown4be44fc2005-08-05 00:44:28 -0400971 int result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
973 ACPI_FUNCTION_TRACE("acpi_processor_cst_has_changed");
974
975 if (!pr)
Len Brown4be44fc2005-08-05 00:44:28 -0400976 return_VALUE(-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977
Len Brown4be44fc2005-08-05 00:44:28 -0400978 if (nocst) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 return_VALUE(-ENODEV);
980 }
981
982 if (!pr->flags.power_setup_done)
983 return_VALUE(-ENODEV);
984
985 /* Fall back to the default idle loop */
986 pm_idle = pm_idle_save;
Len Brown4be44fc2005-08-05 00:44:28 -0400987 synchronize_sched(); /* Relies on interrupts forcing exit from idle. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
989 pr->flags.power = 0;
990 result = acpi_processor_get_power_info(pr);
991 if ((pr->flags.power == 1) && (pr->flags.power_setup_done))
992 pm_idle = acpi_processor_idle;
993
994 return_VALUE(result);
995}
996
997/* proc interface */
998
999static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
1000{
Len Brown4be44fc2005-08-05 00:44:28 -04001001 struct acpi_processor *pr = (struct acpi_processor *)seq->private;
1002 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003
1004 ACPI_FUNCTION_TRACE("acpi_processor_power_seq_show");
1005
1006 if (!pr)
1007 goto end;
1008
1009 seq_printf(seq, "active state: C%zd\n"
Len Brown4be44fc2005-08-05 00:44:28 -04001010 "max_cstate: C%d\n"
1011 "bus master activity: %08x\n",
1012 pr->power.state ? pr->power.state - pr->power.states : 0,
1013 max_cstate, (unsigned)pr->power.bm_activity);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014
1015 seq_puts(seq, "states:\n");
1016
1017 for (i = 1; i <= pr->power.count; i++) {
1018 seq_printf(seq, " %cC%d: ",
Len Brown4be44fc2005-08-05 00:44:28 -04001019 (&pr->power.states[i] ==
1020 pr->power.state ? '*' : ' '), i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021
1022 if (!pr->power.states[i].valid) {
1023 seq_puts(seq, "<not supported>\n");
1024 continue;
1025 }
1026
1027 switch (pr->power.states[i].type) {
1028 case ACPI_STATE_C1:
1029 seq_printf(seq, "type[C1] ");
1030 break;
1031 case ACPI_STATE_C2:
1032 seq_printf(seq, "type[C2] ");
1033 break;
1034 case ACPI_STATE_C3:
1035 seq_printf(seq, "type[C3] ");
1036 break;
1037 default:
1038 seq_printf(seq, "type[--] ");
1039 break;
1040 }
1041
1042 if (pr->power.states[i].promotion.state)
1043 seq_printf(seq, "promotion[C%zd] ",
Len Brown4be44fc2005-08-05 00:44:28 -04001044 (pr->power.states[i].promotion.state -
1045 pr->power.states));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 else
1047 seq_puts(seq, "promotion[--] ");
1048
1049 if (pr->power.states[i].demotion.state)
1050 seq_printf(seq, "demotion[C%zd] ",
Len Brown4be44fc2005-08-05 00:44:28 -04001051 (pr->power.states[i].demotion.state -
1052 pr->power.states));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 else
1054 seq_puts(seq, "demotion[--] ");
1055
1056 seq_printf(seq, "latency[%03d] usage[%08d]\n",
Len Brown4be44fc2005-08-05 00:44:28 -04001057 pr->power.states[i].latency,
1058 pr->power.states[i].usage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 }
1060
Len Brown4be44fc2005-08-05 00:44:28 -04001061 end:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 return_VALUE(0);
1063}
1064
1065static int acpi_processor_power_open_fs(struct inode *inode, struct file *file)
1066{
1067 return single_open(file, acpi_processor_power_seq_show,
Len Brown4be44fc2005-08-05 00:44:28 -04001068 PDE(inode)->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069}
1070
1071static struct file_operations acpi_processor_power_fops = {
Len Brown4be44fc2005-08-05 00:44:28 -04001072 .open = acpi_processor_power_open_fs,
1073 .read = seq_read,
1074 .llseek = seq_lseek,
1075 .release = single_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076};
1077
Len Brown4be44fc2005-08-05 00:44:28 -04001078int acpi_processor_power_init(struct acpi_processor *pr,
1079 struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080{
Len Brown4be44fc2005-08-05 00:44:28 -04001081 acpi_status status = 0;
1082 static int first_run = 0;
1083 struct proc_dir_entry *entry = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 unsigned int i;
1085
1086 ACPI_FUNCTION_TRACE("acpi_processor_power_init");
1087
1088 if (!first_run) {
1089 dmi_check_system(processor_power_dmi_table);
1090 if (max_cstate < ACPI_C_STATES_MAX)
Len Brown4be44fc2005-08-05 00:44:28 -04001091 printk(KERN_NOTICE
1092 "ACPI: processor limited to max C-state %d\n",
1093 max_cstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 first_run++;
1095 }
1096
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -04001097 if (!pr)
1098 return_VALUE(-EINVAL);
1099
1100 if (acpi_fadt.cst_cnt && !nocst) {
Len Brown4be44fc2005-08-05 00:44:28 -04001101 status =
1102 acpi_os_write_port(acpi_fadt.smi_cmd, acpi_fadt.cst_cnt, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 if (ACPI_FAILURE(status)) {
1104 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1105 "Notifying BIOS of _CST ability failed\n"));
1106 }
1107 }
1108
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 acpi_processor_get_power_info(pr);
1110
1111 /*
1112 * Install the idle handler if processor power management is supported.
1113 * Note that we use previously set idle handler will be used on
1114 * platforms that only support C1.
1115 */
1116 if ((pr->flags.power) && (!boot_option_idle_override)) {
1117 printk(KERN_INFO PREFIX "CPU%d (power states:", pr->id);
1118 for (i = 1; i <= pr->power.count; i++)
1119 if (pr->power.states[i].valid)
Len Brown4be44fc2005-08-05 00:44:28 -04001120 printk(" C%d[C%d]", i,
1121 pr->power.states[i].type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 printk(")\n");
1123
1124 if (pr->id == 0) {
1125 pm_idle_save = pm_idle;
1126 pm_idle = acpi_processor_idle;
1127 }
1128 }
1129
1130 /* 'power' [R] */
1131 entry = create_proc_entry(ACPI_PROCESSOR_FILE_POWER,
Len Brown4be44fc2005-08-05 00:44:28 -04001132 S_IRUGO, acpi_device_dir(device));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 if (!entry)
1134 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
Len Brown4be44fc2005-08-05 00:44:28 -04001135 "Unable to create '%s' fs entry\n",
1136 ACPI_PROCESSOR_FILE_POWER));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 else {
1138 entry->proc_fops = &acpi_processor_power_fops;
1139 entry->data = acpi_driver_data(device);
1140 entry->owner = THIS_MODULE;
1141 }
1142
1143 pr->flags.power_setup_done = 1;
1144
1145 return_VALUE(0);
1146}
1147
Len Brown4be44fc2005-08-05 00:44:28 -04001148int acpi_processor_power_exit(struct acpi_processor *pr,
1149 struct acpi_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150{
1151 ACPI_FUNCTION_TRACE("acpi_processor_power_exit");
1152
1153 pr->flags.power_setup_done = 0;
1154
1155 if (acpi_device_dir(device))
Len Brown4be44fc2005-08-05 00:44:28 -04001156 remove_proc_entry(ACPI_PROCESSOR_FILE_POWER,
1157 acpi_device_dir(device));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
1159 /* Unregister the idle handler when processor #0 is removed. */
1160 if (pr->id == 0) {
1161 pm_idle = pm_idle_save;
1162
1163 /*
1164 * We are about to unload the current idle thread pm callback
1165 * (pm_idle), Wait for all processors to update cached/local
1166 * copies of pm_idle before proceeding.
1167 */
1168 cpu_idle_wait();
1169 }
1170
1171 return_VALUE(0);
1172}