blob: 17f9ec501972ef208b505ed881173e2dac0cc2ea [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/acpi.h>
33#include <linux/dmi.h>
Daniel Lezcanoe2668fb2013-02-04 22:44:41 +000034#include <linux/sched.h> /* need_resched() */
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -080035#include <linux/clockchips.h>
Len Brown4f86d3a2007-10-03 18:58:00 -040036#include <linux/cpuidle.h>
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +020037#include <linux/syscore_ops.h>
Lv Zheng8b484632013-12-03 08:49:16 +080038#include <acpi/processor.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Thomas Gleixner34349332007-02-16 01:27:54 -080040/*
41 * Include the apic definitions for x86 to have the APIC timer related defines
42 * available also for UP (on SMP it gets magically included via linux/smp.h).
43 * asm/acpi.h is not an option, as it would require more include magic. Also
44 * creating an empty asm-ia64/apic.h would just trade pest vs. cholera.
45 */
46#ifdef CONFIG_X86
47#include <asm/apic.h>
48#endif
49
Len Browna192a952009-07-28 16:45:54 -040050#define PREFIX "ACPI: "
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#define ACPI_PROCESSOR_CLASS "processor"
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#define _COMPONENT ACPI_PROCESSOR_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050054ACPI_MODULE_NAME("processor_idle");
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Len Brown4f86d3a2007-10-03 18:58:00 -040056static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER;
57module_param(max_cstate, uint, 0000);
Andreas Mohrb6835052006-04-27 05:25:00 -040058static unsigned int nocst __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059module_param(nocst, uint, 0000);
Len Brownd3e7e992010-07-22 17:23:10 -040060static int bm_check_disable __read_mostly;
61module_param(bm_check_disable, uint, 0000);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
Len Brown25de5712007-12-14 00:24:15 -050063static unsigned int latency_factor __read_mostly = 2;
Len Brown4963f622007-12-13 23:50:45 -050064module_param(latency_factor, uint, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Daniel Lezcano3d339dc2012-09-17 23:01:56 +020066static DEFINE_PER_CPU(struct cpuidle_device *, acpi_cpuidle_device);
67
Alex Shi6240a102013-04-02 01:56:54 +020068static DEFINE_PER_CPU(struct acpi_processor_cx * [CPUIDLE_STATE_MAX],
69 acpi_cstate);
Daniel Lezcanoac3ebaf2013-02-04 22:44:43 +000070
Thomas Renningerd1896042010-11-03 17:06:14 +010071static int disabled_by_idle_boot_param(void)
72{
73 return boot_option_idle_override == IDLE_POLL ||
Thomas Renningerd1896042010-11-03 17:06:14 +010074 boot_option_idle_override == IDLE_HALT;
75}
76
Linus Torvalds1da177e2005-04-16 15:20:36 -070077/*
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 */
Jeff Garzik18552562007-10-03 15:15:40 -040083static int set_max_cstate(const 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
Paul Gortmakerfe7bf102013-06-19 14:30:58 -040097static struct dmi_system_id processor_power_dmi_table[] = {
Thomas Rosner876c1842006-01-06 01:31:00 -050098 { set_max_cstate, "Clevo 5600D", {
99 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
100 DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
Len Brown4be44fc2005-08-05 00:44:28 -0400101 (void *)2},
Arjan van de Ven370d5cd2010-01-27 15:25:39 -0800102 { set_max_cstate, "Pavilion zv5000", {
103 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
104 DMI_MATCH(DMI_PRODUCT_NAME,"Pavilion zv5000 (DS502A#ABA)")},
105 (void *)1},
106 { set_max_cstate, "Asus L8400B", {
107 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
108 DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")},
109 (void *)1},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 {},
111};
112
Len Brown4f86d3a2007-10-03 18:58:00 -0400113
venkatesh.pallipadi@intel.com2e906652008-01-31 17:35:03 -0800114/*
115 * Callers should disable interrupts before the call and enable
116 * interrupts after return.
117 */
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500118static void acpi_safe_halt(void)
119{
Peter Zijlstraea811742013-09-11 12:43:13 +0200120 if (!tif_need_resched()) {
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500121 safe_halt();
Venki Pallipadi71e93d12008-03-13 17:18:19 -0700122 local_irq_disable();
123 }
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500124}
125
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800126#ifdef ARCH_APICTIMER_STOPS_ON_C3
127
128/*
129 * Some BIOS implementations switch to C3 in the published C2 state.
Linus Torvalds296d93c2007-03-23 08:03:47 -0700130 * This seems to be a common problem on AMD boxen, but other vendors
131 * are affected too. We pick the most conservative approach: we assume
132 * that the local APIC stops in both C2 and C3.
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800133 */
Len Brown7e275cc2009-05-15 02:08:44 -0400134static void lapic_timer_check_state(int state, struct acpi_processor *pr,
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800135 struct acpi_processor_cx *cx)
136{
137 struct acpi_processor_power *pwr = &pr->power;
Thomas Gleixnere585bef2007-03-23 16:08:01 +0100138 u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2;
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800139
Venkatesh Pallipadidb954b52009-04-06 18:51:29 -0700140 if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT))
141 return;
142
Len Brown02c68a02011-04-01 16:59:53 -0400143 if (amd_e400_c1e_detected)
Shaohua Li87ad57ba2009-05-19 16:09:42 +0800144 type = ACPI_STATE_C1;
145
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800146 /*
147 * Check, if one of the previous states already marked the lapic
148 * unstable
149 */
150 if (pwr->timer_broadcast_on_state < state)
151 return;
152
Thomas Gleixnere585bef2007-03-23 16:08:01 +0100153 if (cx->type >= type)
Linus Torvalds296d93c2007-03-23 08:03:47 -0700154 pr->power.timer_broadcast_on_state = state;
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800155}
156
Hidetoshi Seto918aae42009-12-14 17:10:06 +0900157static void __lapic_timer_propagate_broadcast(void *arg)
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800158{
Suresh Siddhaf833bab2009-08-17 14:34:59 -0700159 struct acpi_processor *pr = (struct acpi_processor *) arg;
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800160 unsigned long reason;
161
162 reason = pr->power.timer_broadcast_on_state < INT_MAX ?
163 CLOCK_EVT_NOTIFY_BROADCAST_ON : CLOCK_EVT_NOTIFY_BROADCAST_OFF;
164
165 clockevents_notify(reason, &pr->id);
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800166}
167
Hidetoshi Seto918aae42009-12-14 17:10:06 +0900168static void lapic_timer_propagate_broadcast(struct acpi_processor *pr)
169{
170 smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast,
171 (void *)pr, 1);
172}
173
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800174/* Power(C) State timer broadcast control */
Len Brown7e275cc2009-05-15 02:08:44 -0400175static void lapic_timer_state_broadcast(struct acpi_processor *pr,
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800176 struct acpi_processor_cx *cx,
177 int broadcast)
178{
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800179 int state = cx - pr->power.states;
180
181 if (state >= pr->power.timer_broadcast_on_state) {
182 unsigned long reason;
183
184 reason = broadcast ? CLOCK_EVT_NOTIFY_BROADCAST_ENTER :
185 CLOCK_EVT_NOTIFY_BROADCAST_EXIT;
186 clockevents_notify(reason, &pr->id);
187 }
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800188}
189
190#else
191
Len Brown7e275cc2009-05-15 02:08:44 -0400192static void lapic_timer_check_state(int state, struct acpi_processor *pr,
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800193 struct acpi_processor_cx *cstate) { }
Len Brown7e275cc2009-05-15 02:08:44 -0400194static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { }
195static void lapic_timer_state_broadcast(struct acpi_processor *pr,
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800196 struct acpi_processor_cx *cx,
197 int broadcast)
198{
199}
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800200
201#endif
202
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200203#ifdef CONFIG_PM_SLEEP
Len Brown815ab0f2009-05-07 22:19:45 -0400204static u32 saved_bm_rld;
205
Fengguang Wu95d45d42013-06-11 00:55:10 +0200206static int acpi_processor_suspend(void)
Len Brown815ab0f2009-05-07 22:19:45 -0400207{
208 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200209 return 0;
Len Brown815ab0f2009-05-07 22:19:45 -0400210}
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200211
Fengguang Wu95d45d42013-06-11 00:55:10 +0200212static void acpi_processor_resume(void)
Len Brown815ab0f2009-05-07 22:19:45 -0400213{
Al Stone43575fa2013-12-16 17:01:37 -0700214 u32 resumed_bm_rld = 0;
Len Brown815ab0f2009-05-07 22:19:45 -0400215
216 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200217 if (resumed_bm_rld == saved_bm_rld)
218 return;
Len Brown815ab0f2009-05-07 22:19:45 -0400219
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200220 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
Len Brown815ab0f2009-05-07 22:19:45 -0400221}
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000222
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200223static struct syscore_ops acpi_processor_syscore_ops = {
224 .suspend = acpi_processor_suspend,
225 .resume = acpi_processor_resume,
226};
227
228void acpi_processor_syscore_init(void)
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000229{
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200230 register_syscore_ops(&acpi_processor_syscore_ops);
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000231}
232
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200233void acpi_processor_syscore_exit(void)
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000234{
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200235 unregister_syscore_ops(&acpi_processor_syscore_ops);
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000236}
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200237#endif /* CONFIG_PM_SLEEP */
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000238
John Stultz592913e2010-07-13 17:56:20 -0700239#if defined(CONFIG_X86)
Len Brown520daf72009-05-14 17:27:38 -0400240static void tsc_check_state(int state)
Andi Kleenddb25f92008-01-30 13:32:41 +0100241{
242 switch (boot_cpu_data.x86_vendor) {
243 case X86_VENDOR_AMD:
Venki Pallipadi40fb1712008-11-17 16:11:37 -0800244 case X86_VENDOR_INTEL:
Andi Kleenddb25f92008-01-30 13:32:41 +0100245 /*
246 * AMD Fam10h TSC will tick in all
247 * C/P/S0/S1 states when this bit is set.
248 */
Venki Pallipadi40fb1712008-11-17 16:11:37 -0800249 if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
Len Brown520daf72009-05-14 17:27:38 -0400250 return;
Venki Pallipadi40fb1712008-11-17 16:11:37 -0800251
Andi Kleenddb25f92008-01-30 13:32:41 +0100252 /*FALL THROUGH*/
Andi Kleenddb25f92008-01-30 13:32:41 +0100253 default:
Len Brown520daf72009-05-14 17:27:38 -0400254 /* TSC could halt in idle, so notify users */
255 if (state > ACPI_STATE_C1)
256 mark_tsc_unstable("TSC halts in idle");
Andi Kleenddb25f92008-01-30 13:32:41 +0100257 }
258}
Len Brown520daf72009-05-14 17:27:38 -0400259#else
260static void tsc_check_state(int state) { return; }
Andi Kleenddb25f92008-01-30 13:32:41 +0100261#endif
262
Len Brown4be44fc2005-08-05 00:44:28 -0400263static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 if (!pr->pblk)
Patrick Mocheld550d982006-06-27 00:41:40 -0400267 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 /* if info is obtained from pblk/fadt, type equals state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
271 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3;
272
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400273#ifndef CONFIG_HOTPLUG_CPU
274 /*
275 * Check for P_LVL2_UP flag before entering C2 and above on
Len Brown4f86d3a2007-10-03 18:58:00 -0400276 * an SMP system.
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400277 */
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300278 if ((num_online_cpus() > 1) &&
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300279 !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
Patrick Mocheld550d982006-06-27 00:41:40 -0400280 return -ENODEV;
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400281#endif
282
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 /* determine C2 and C3 address from pblk */
284 pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4;
285 pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5;
286
287 /* determine latencies from FADT */
Bob Mooreba494be2012-07-12 09:40:10 +0800288 pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency;
289 pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Len Brown5d76b6f2010-01-19 22:41:14 -0500291 /*
292 * FADT specified C2 latency must be less than or equal to
293 * 100 microseconds.
294 */
Bob Mooreba494be2012-07-12 09:40:10 +0800295 if (acpi_gbl_FADT.c2_latency > ACPI_PROCESSOR_MAX_C2_LATENCY) {
Len Brown5d76b6f2010-01-19 22:41:14 -0500296 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Bob Mooreba494be2012-07-12 09:40:10 +0800297 "C2 latency too large [%d]\n", acpi_gbl_FADT.c2_latency));
Len Brown5d76b6f2010-01-19 22:41:14 -0500298 /* invalidate C2 */
299 pr->power.states[ACPI_STATE_C2].address = 0;
300 }
301
Len Browna6d72c12010-01-19 23:10:04 -0500302 /*
303 * FADT supplied C3 latency must be less than or equal to
304 * 1000 microseconds.
305 */
Bob Mooreba494be2012-07-12 09:40:10 +0800306 if (acpi_gbl_FADT.c3_latency > ACPI_PROCESSOR_MAX_C3_LATENCY) {
Len Browna6d72c12010-01-19 23:10:04 -0500307 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Bob Mooreba494be2012-07-12 09:40:10 +0800308 "C3 latency too large [%d]\n", acpi_gbl_FADT.c3_latency));
Len Browna6d72c12010-01-19 23:10:04 -0500309 /* invalidate C3 */
310 pr->power.states[ACPI_STATE_C3].address = 0;
311 }
312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
314 "lvl2[0x%08x] lvl3[0x%08x]\n",
315 pr->power.states[ACPI_STATE_C2].address,
316 pr->power.states[ACPI_STATE_C3].address));
317
Patrick Mocheld550d982006-06-27 00:41:40 -0400318 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319}
320
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700321static int acpi_processor_get_power_info_default(struct acpi_processor *pr)
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500322{
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700323 if (!pr->power.states[ACPI_STATE_C1].valid) {
324 /* set the first C-State to C1 */
325 /* all processors need to support C1 */
326 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
327 pr->power.states[ACPI_STATE_C1].valid = 1;
Venkatesh Pallipadi0fda6b42008-04-09 21:31:46 -0400328 pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT;
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700329 }
330 /* the C0 state only exists as a filler in our array */
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500331 pr->power.states[ACPI_STATE_C0].valid = 1;
Patrick Mocheld550d982006-06-27 00:41:40 -0400332 return 0;
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500333}
334
Len Brown4be44fc2005-08-05 00:44:28 -0400335static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336{
Len Brown4be44fc2005-08-05 00:44:28 -0400337 acpi_status status = 0;
Lin Ming439913f2010-01-28 10:53:19 +0800338 u64 count;
Janosch Machowinskicf824782005-08-20 08:02:00 -0400339 int current_count;
Len Brown4be44fc2005-08-05 00:44:28 -0400340 int i;
341 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
342 union acpi_object *cst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 if (nocst)
Patrick Mocheld550d982006-06-27 00:41:40 -0400346 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700348 current_count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
350 status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
351 if (ACPI_FAILURE(status)) {
352 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400353 return -ENODEV;
Len Brown4be44fc2005-08-05 00:44:28 -0400354 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200356 cst = buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
358 /* There must be at least 2 elements */
359 if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
Len Brown64684632006-06-26 23:41:38 -0400360 printk(KERN_ERR PREFIX "not enough elements in _CST\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 status = -EFAULT;
362 goto end;
363 }
364
365 count = cst->package.elements[0].integer.value;
366
367 /* Validate number of power states. */
368 if (count < 1 || count != cst->package.count - 1) {
Len Brown64684632006-06-26 23:41:38 -0400369 printk(KERN_ERR PREFIX "count given by _CST is not valid\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 status = -EFAULT;
371 goto end;
372 }
373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 /* Tell driver that at least _CST is supported. */
375 pr->flags.has_cst = 1;
376
377 for (i = 1; i <= count; i++) {
378 union acpi_object *element;
379 union acpi_object *obj;
380 struct acpi_power_register *reg;
381 struct acpi_processor_cx cx;
382
383 memset(&cx, 0, sizeof(cx));
384
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200385 element = &(cst->package.elements[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 if (element->type != ACPI_TYPE_PACKAGE)
387 continue;
388
389 if (element->package.count != 4)
390 continue;
391
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200392 obj = &(element->package.elements[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
394 if (obj->type != ACPI_TYPE_BUFFER)
395 continue;
396
Len Brown4be44fc2005-08-05 00:44:28 -0400397 reg = (struct acpi_power_register *)obj->buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398
399 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO &&
Len Brown4be44fc2005-08-05 00:44:28 -0400400 (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 continue;
402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 /* There should be an easy way to extract an integer... */
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200404 obj = &(element->package.elements[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 if (obj->type != ACPI_TYPE_INTEGER)
406 continue;
407
408 cx.type = obj->integer.value;
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700409 /*
410 * Some buggy BIOSes won't list C1 in _CST -
411 * Let acpi_processor_get_power_info_default() handle them later
412 */
413 if (i == 1 && cx.type != ACPI_STATE_C1)
414 current_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700416 cx.address = reg->address;
417 cx.index = current_count + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800419 cx.entry_method = ACPI_CSTATE_SYSTEMIO;
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700420 if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
421 if (acpi_processor_ffh_cstate_probe
422 (pr->id, &cx, reg) == 0) {
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800423 cx.entry_method = ACPI_CSTATE_FFH;
424 } else if (cx.type == ACPI_STATE_C1) {
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700425 /*
426 * C1 is a special case where FIXED_HARDWARE
427 * can be handled in non-MWAIT way as well.
428 * In that case, save this _CST entry info.
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700429 * Otherwise, ignore this info and continue.
430 */
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800431 cx.entry_method = ACPI_CSTATE_HALT;
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800432 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800433 } else {
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700434 continue;
435 }
Zhao Yakuida5e09a2008-06-24 18:01:09 +0800436 if (cx.type == ACPI_STATE_C1 &&
Thomas Renningerd1896042010-11-03 17:06:14 +0100437 (boot_option_idle_override == IDLE_NOMWAIT)) {
Zhao Yakuic1e3b372008-06-24 17:58:53 +0800438 /*
439 * In most cases the C1 space_id obtained from
440 * _CST object is FIXED_HARDWARE access mode.
441 * But when the option of idle=halt is added,
442 * the entry_method type should be changed from
443 * CSTATE_FFH to CSTATE_HALT.
Zhao Yakuida5e09a2008-06-24 18:01:09 +0800444 * When the option of idle=nomwait is added,
445 * the C1 entry_method type should be
446 * CSTATE_HALT.
Zhao Yakuic1e3b372008-06-24 17:58:53 +0800447 */
448 cx.entry_method = ACPI_CSTATE_HALT;
449 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
450 }
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800451 } else {
452 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x",
453 cx.address);
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700454 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
Venkatesh Pallipadi0fda6b42008-04-09 21:31:46 -0400456 if (cx.type == ACPI_STATE_C1) {
457 cx.valid = 1;
458 }
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800459
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200460 obj = &(element->package.elements[2]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 if (obj->type != ACPI_TYPE_INTEGER)
462 continue;
463
464 cx.latency = obj->integer.value;
465
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200466 obj = &(element->package.elements[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (obj->type != ACPI_TYPE_INTEGER)
468 continue;
469
Janosch Machowinskicf824782005-08-20 08:02:00 -0400470 current_count++;
471 memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx));
472
473 /*
474 * We support total ACPI_PROCESSOR_MAX_POWER - 1
475 * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1)
476 */
477 if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) {
478 printk(KERN_WARNING
479 "Limiting number of power states to max (%d)\n",
480 ACPI_PROCESSOR_MAX_POWER);
481 printk(KERN_WARNING
482 "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
483 break;
484 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 }
486
Len Brown4be44fc2005-08-05 00:44:28 -0400487 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n",
Janosch Machowinskicf824782005-08-20 08:02:00 -0400488 current_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490 /* Validate number of power states discovered */
Janosch Machowinskicf824782005-08-20 08:02:00 -0400491 if (current_count < 2)
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400492 status = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Len Brown4be44fc2005-08-05 00:44:28 -0400494 end:
Len Brown02438d82006-06-30 03:19:10 -0400495 kfree(buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
Patrick Mocheld550d982006-06-27 00:41:40 -0400497 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498}
499
Len Brown4be44fc2005-08-05 00:44:28 -0400500static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
501 struct acpi_processor_cx *cx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
Pallipadi, Venkateshee1ca482009-05-21 17:09:10 -0700503 static int bm_check_flag = -1;
504 static int bm_control_flag = -1;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507 if (!cx->address)
Patrick Mocheld550d982006-06-27 00:41:40 -0400508 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
510 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 * PIIX4 Erratum #18: We don't support C3 when Type-F (fast)
512 * DMA transfers are used by any ISA device to avoid livelock.
513 * Note that we could disable Type-F DMA (as recommended by
514 * the erratum), but this is known to disrupt certain ISA
515 * devices thus we take the conservative approach.
516 */
517 else if (errata.piix4.fdma) {
518 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400519 "C3 not supported on PIIX4 with Type-F DMA\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400520 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 }
522
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400523 /* All the logic here assumes flags.bm_check is same across all CPUs */
Pallipadi, Venkateshee1ca482009-05-21 17:09:10 -0700524 if (bm_check_flag == -1) {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400525 /* Determine whether bm_check is needed based on CPU */
526 acpi_processor_power_init_bm_check(&(pr->flags), pr->id);
527 bm_check_flag = pr->flags.bm_check;
Pallipadi, Venkateshee1ca482009-05-21 17:09:10 -0700528 bm_control_flag = pr->flags.bm_control;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400529 } else {
530 pr->flags.bm_check = bm_check_flag;
Pallipadi, Venkateshee1ca482009-05-21 17:09:10 -0700531 pr->flags.bm_control = bm_control_flag;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400532 }
533
534 if (pr->flags.bm_check) {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400535 if (!pr->flags.bm_control) {
Venki Pallipadied3110e2007-07-31 12:04:31 -0700536 if (pr->flags.has_cst != 1) {
537 /* bus mastering control is necessary */
538 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
539 "C3 support requires BM control\n"));
540 return;
541 } else {
542 /* Here we enter C3 without bus mastering */
543 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
544 "C3 support without BM control\n"));
545 }
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400546 }
547 } else {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400548 /*
549 * WBINVD should be set in fadt, for C3 state to be
550 * supported on when bm_check is not required.
551 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300552 if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400553 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400554 "Cache invalidation should work properly"
555 " for C3 to be enabled on SMP systems\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400556 return;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400557 }
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400558 }
559
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 /*
561 * Otherwise we've met all of our C3 requirements.
562 * Normalize the C3 latency to expidite policy. Enable
563 * checking of bus mastering status (bm_check) so we can
564 * use this in our C3 policy
565 */
566 cx->valid = 1;
Len Brown4f86d3a2007-10-03 18:58:00 -0400567
Len Brown31878dd2009-01-28 18:28:09 -0500568 /*
569 * On older chipsets, BM_RLD needs to be set
570 * in order for Bus Master activity to wake the
571 * system from C3. Newer chipsets handle DMA
572 * during C3 automatically and BM_RLD is a NOP.
573 * In either case, the proper way to
574 * handle BM_RLD is to set it and leave it set.
575 */
Bob Moore50ffba12009-02-23 15:02:07 +0800576 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
Patrick Mocheld550d982006-06-27 00:41:40 -0400578 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579}
580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581static int acpi_processor_power_verify(struct acpi_processor *pr)
582{
583 unsigned int i;
584 unsigned int working = 0;
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100585
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800586 pr->power.timer_broadcast_on_state = INT_MAX;
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100587
Len Browna0bf2842009-05-15 01:29:31 -0400588 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 struct acpi_processor_cx *cx = &pr->power.states[i];
590
591 switch (cx->type) {
592 case ACPI_STATE_C1:
593 cx->valid = 1;
594 break;
595
596 case ACPI_STATE_C2:
Len Brownd22edd22010-01-19 23:29:09 -0500597 if (!cx->address)
598 break;
Al Stonecad1525a2013-12-04 12:59:11 -0700599 cx->valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 break;
601
602 case ACPI_STATE_C3:
603 acpi_processor_power_verify_c3(pr, cx);
604 break;
605 }
Len Brown7e275cc2009-05-15 02:08:44 -0400606 if (!cx->valid)
607 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
Len Brown7e275cc2009-05-15 02:08:44 -0400609 lapic_timer_check_state(i, pr, cx);
610 tsc_check_state(cx->type);
611 working++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 }
613
Hidetoshi Seto918aae42009-12-14 17:10:06 +0900614 lapic_timer_propagate_broadcast(pr);
Andi Kleenbd663342006-03-25 16:31:07 +0100615
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 return (working);
617}
618
Len Brown4be44fc2005-08-05 00:44:28 -0400619static int acpi_processor_get_power_info(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620{
621 unsigned int i;
622 int result;
623
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625 /* NOTE: the idle thread may not be running while calling
626 * this function */
627
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700628 /* Zero initialize all the C-states info. */
629 memset(pr->power.states, 0, sizeof(pr->power.states));
630
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 result = acpi_processor_get_power_info_cst(pr);
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400632 if (result == -ENODEV)
Darrick J. Wongc5a114f2006-10-19 23:28:28 -0700633 result = acpi_processor_get_power_info_fadt(pr);
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400634
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700635 if (result)
636 return result;
637
638 acpi_processor_get_power_info_default(pr);
639
Janosch Machowinskicf824782005-08-20 08:02:00 -0400640 pr->power.count = acpi_processor_power_verify(pr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 /*
643 * if one state of type C2 or C3 is available, mark this
644 * CPU as being "idle manageable"
645 */
646 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500647 if (pr->power.states[i].valid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 pr->power.count = i;
Linus Torvalds2203d6e2005-11-18 07:29:51 -0800649 if (pr->power.states[i].type >= ACPI_STATE_C2)
650 pr->flags.power = 1;
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500651 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 }
653
Patrick Mocheld550d982006-06-27 00:41:40 -0400654 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655}
656
Len Brown4f86d3a2007-10-03 18:58:00 -0400657/**
658 * acpi_idle_bm_check - checks if bus master activity was detected
659 */
660static int acpi_idle_bm_check(void)
661{
662 u32 bm_status = 0;
663
Len Brownd3e7e992010-07-22 17:23:10 -0400664 if (bm_check_disable)
665 return 0;
666
Bob Moore50ffba12009-02-23 15:02:07 +0800667 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status);
Len Brown4f86d3a2007-10-03 18:58:00 -0400668 if (bm_status)
Bob Moore50ffba12009-02-23 15:02:07 +0800669 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, 1);
Len Brown4f86d3a2007-10-03 18:58:00 -0400670 /*
671 * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect
672 * the true state of bus mastering activity; forcing us to
673 * manually check the BMIDEA bit of each IDE channel.
674 */
675 else if (errata.piix4.bmisx) {
676 if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
677 || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
678 bm_status = 1;
679 }
680 return bm_status;
681}
682
683/**
Len Brown4f86d3a2007-10-03 18:58:00 -0400684 * acpi_idle_do_entry - a helper function that does C2 and C3 type entry
685 * @cx: cstate data
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800686 *
687 * Caller disables interrupt before call and enables interrupt after return.
Len Brown4f86d3a2007-10-03 18:58:00 -0400688 */
689static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx)
690{
Steven Rostedtdcf30992008-07-25 18:00:42 -0400691 /* Don't trace irqs off for idle */
692 stop_critical_timings();
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800693 if (cx->entry_method == ACPI_CSTATE_FFH) {
Len Brown4f86d3a2007-10-03 18:58:00 -0400694 /* Call into architectural FFH based C-state */
695 acpi_processor_ffh_cstate_enter(cx);
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800696 } else if (cx->entry_method == ACPI_CSTATE_HALT) {
697 acpi_safe_halt();
Len Brown4f86d3a2007-10-03 18:58:00 -0400698 } else {
Len Brown4f86d3a2007-10-03 18:58:00 -0400699 /* IO port based C-state */
700 inb(cx->address);
701 /* Dummy wait op - must do something useless after P_LVL2 read
702 because chipsets cannot guarantee that STPCLK# signal
703 gets asserted in time to freeze execution properly. */
Andi Kleencfa806f2010-07-20 15:18:36 -0700704 inl(acpi_gbl_FADT.xpm_timer_block.address);
Len Brown4f86d3a2007-10-03 18:58:00 -0400705 }
Steven Rostedtdcf30992008-07-25 18:00:42 -0400706 start_critical_timings();
Len Brown4f86d3a2007-10-03 18:58:00 -0400707}
708
709/**
710 * acpi_idle_enter_c1 - enters an ACPI C1 state-type
711 * @dev: the target CPU
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530712 * @drv: cpuidle driver containing cpuidle state info
Deepthi Dharware978aa72011-10-28 16:20:09 +0530713 * @index: index of target state
Len Brown4f86d3a2007-10-03 18:58:00 -0400714 *
715 * This is equivalent to the HALT instruction.
716 */
717static int acpi_idle_enter_c1(struct cpuidle_device *dev,
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530718 struct cpuidle_driver *drv, int index)
Len Brown4f86d3a2007-10-03 18:58:00 -0400719{
720 struct acpi_processor *pr;
Alex Shi6240a102013-04-02 01:56:54 +0200721 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
venkatesh.pallipadi@intel.com9b12e182008-01-31 17:35:05 -0800722
Christoph Lameter4a6f4fe2010-12-06 11:16:24 -0600723 pr = __this_cpu_read(processors);
Len Brown4f86d3a2007-10-03 18:58:00 -0400724
725 if (unlikely(!pr))
Deepthi Dharware978aa72011-10-28 16:20:09 +0530726 return -EINVAL;
Len Brown4f86d3a2007-10-03 18:58:00 -0400727
Len Brown7e275cc2009-05-15 02:08:44 -0400728 lapic_timer_state_broadcast(pr, cx, 1);
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800729 acpi_idle_do_entry(cx);
Len Brown4f86d3a2007-10-03 18:58:00 -0400730
Len Brown7e275cc2009-05-15 02:08:44 -0400731 lapic_timer_state_broadcast(pr, cx, 0);
Len Brown4f86d3a2007-10-03 18:58:00 -0400732
Deepthi Dharware978aa72011-10-28 16:20:09 +0530733 return index;
Len Brown4f86d3a2007-10-03 18:58:00 -0400734}
735
Boris Ostrovsky1a022e32012-03-13 19:55:09 +0100736
737/**
738 * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining)
739 * @dev: the target CPU
740 * @index: the index of suggested state
741 */
742static int acpi_idle_play_dead(struct cpuidle_device *dev, int index)
743{
Alex Shi6240a102013-04-02 01:56:54 +0200744 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
Boris Ostrovsky1a022e32012-03-13 19:55:09 +0100745
746 ACPI_FLUSH_CPU_CACHE();
747
748 while (1) {
749
750 if (cx->entry_method == ACPI_CSTATE_HALT)
Luck, Tony54f70072012-04-03 09:37:28 -0700751 safe_halt();
Boris Ostrovsky1a022e32012-03-13 19:55:09 +0100752 else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) {
753 inb(cx->address);
754 /* See comment in acpi_idle_do_entry() */
755 inl(acpi_gbl_FADT.xpm_timer_block.address);
756 } else
757 return -ENODEV;
758 }
759
760 /* Never reached */
761 return 0;
762}
763
Len Brown4f86d3a2007-10-03 18:58:00 -0400764/**
765 * acpi_idle_enter_simple - enters an ACPI state without BM handling
766 * @dev: the target CPU
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530767 * @drv: cpuidle driver with cpuidle state information
Deepthi Dharware978aa72011-10-28 16:20:09 +0530768 * @index: the index of suggested state
Len Brown4f86d3a2007-10-03 18:58:00 -0400769 */
770static int acpi_idle_enter_simple(struct cpuidle_device *dev,
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530771 struct cpuidle_driver *drv, int index)
Len Brown4f86d3a2007-10-03 18:58:00 -0400772{
773 struct acpi_processor *pr;
Alex Shi6240a102013-04-02 01:56:54 +0200774 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
Venkatesh Pallipadi50629112007-11-19 19:49:00 -0500775
Christoph Lameter4a6f4fe2010-12-06 11:16:24 -0600776 pr = __this_cpu_read(processors);
Len Brown4f86d3a2007-10-03 18:58:00 -0400777
778 if (unlikely(!pr))
Deepthi Dharware978aa72011-10-28 16:20:09 +0530779 return -EINVAL;
Len Browne1964412007-10-04 01:23:47 -0400780
Bartlomiej Zolnierkiewicz7ca380f2013-12-20 19:47:26 +0100781#ifdef CONFIG_HOTPLUG_CPU
782 if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
783 !pr->flags.has_cst &&
784 !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
785 return acpi_idle_enter_c1(dev, drv, CPUIDLE_DRIVER_STATE_START);
786#endif
787
Thomas Gleixnere17bcb42007-12-07 19:16:17 +0100788 /*
789 * Must be done before busmaster disable as we might need to
790 * access HPET !
791 */
Len Brown7e275cc2009-05-15 02:08:44 -0400792 lapic_timer_state_broadcast(pr, cx, 1);
Thomas Gleixnere17bcb42007-12-07 19:16:17 +0100793
Len Brown4f86d3a2007-10-03 18:58:00 -0400794 if (cx->type == ACPI_STATE_C3)
795 ACPI_FLUSH_CPU_CACHE();
796
Venkatesh Pallipadi50629112007-11-19 19:49:00 -0500797 /* Tell the scheduler that we are going deep-idle: */
798 sched_clock_idle_sleep_event();
Len Brown4f86d3a2007-10-03 18:58:00 -0400799 acpi_idle_do_entry(cx);
Len Brown4f86d3a2007-10-03 18:58:00 -0400800
Julius Wernera474a512012-11-27 14:17:58 +0100801 sched_clock_idle_wakeup_event(0);
Deepthi Dharware978aa72011-10-28 16:20:09 +0530802
Len Brown7e275cc2009-05-15 02:08:44 -0400803 lapic_timer_state_broadcast(pr, cx, 0);
Deepthi Dharware978aa72011-10-28 16:20:09 +0530804 return index;
Len Brown4f86d3a2007-10-03 18:58:00 -0400805}
806
807static int c3_cpu_count;
Thomas Gleixnere12f65f2009-07-25 18:14:37 +0200808static DEFINE_RAW_SPINLOCK(c3_lock);
Len Brown4f86d3a2007-10-03 18:58:00 -0400809
810/**
811 * acpi_idle_enter_bm - enters C3 with proper BM handling
812 * @dev: the target CPU
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530813 * @drv: cpuidle driver containing state data
Deepthi Dharware978aa72011-10-28 16:20:09 +0530814 * @index: the index of suggested state
Len Brown4f86d3a2007-10-03 18:58:00 -0400815 *
816 * If BM is detected, the deepest non-C3 idle state is entered instead.
817 */
818static int acpi_idle_enter_bm(struct cpuidle_device *dev,
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530819 struct cpuidle_driver *drv, int index)
Len Brown4f86d3a2007-10-03 18:58:00 -0400820{
821 struct acpi_processor *pr;
Alex Shi6240a102013-04-02 01:56:54 +0200822 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
Venkatesh Pallipadi50629112007-11-19 19:49:00 -0500823
Christoph Lameter4a6f4fe2010-12-06 11:16:24 -0600824 pr = __this_cpu_read(processors);
Len Brown4f86d3a2007-10-03 18:58:00 -0400825
826 if (unlikely(!pr))
Deepthi Dharware978aa72011-10-28 16:20:09 +0530827 return -EINVAL;
Len Brown4f86d3a2007-10-03 18:58:00 -0400828
Bartlomiej Zolnierkiewicz7ca380f2013-12-20 19:47:26 +0100829#ifdef CONFIG_HOTPLUG_CPU
830 if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
831 !pr->flags.has_cst &&
832 !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
833 return acpi_idle_enter_c1(dev, drv, CPUIDLE_DRIVER_STATE_START);
834#endif
835
Len Brown718be4a2010-07-22 16:54:27 -0400836 if (!cx->bm_sts_skip && acpi_idle_bm_check()) {
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530837 if (drv->safe_state_index >= 0) {
838 return drv->states[drv->safe_state_index].enter(dev,
839 drv, drv->safe_state_index);
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500840 } else {
Preeti U Murthy8651f972012-07-09 10:12:56 +0200841 acpi_safe_halt();
Deepthi Dharwar75cc5232012-06-25 23:59:54 +0200842 return -EBUSY;
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500843 }
844 }
845
Venki Pallipadi996520c2008-03-24 14:24:10 -0700846 acpi_unlazy_tlb(smp_processor_id());
847
Venkatesh Pallipadi50629112007-11-19 19:49:00 -0500848 /* Tell the scheduler that we are going deep-idle: */
849 sched_clock_idle_sleep_event();
Len Brown4f86d3a2007-10-03 18:58:00 -0400850 /*
851 * Must be done before busmaster disable as we might need to
852 * access HPET !
853 */
Len Brown7e275cc2009-05-15 02:08:44 -0400854 lapic_timer_state_broadcast(pr, cx, 1);
Len Brown4f86d3a2007-10-03 18:58:00 -0400855
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500856 /*
857 * disable bus master
858 * bm_check implies we need ARB_DIS
859 * !bm_check implies we need cache flush
860 * bm_control implies whether we can do ARB_DIS
861 *
862 * That leaves a case where bm_check is set and bm_control is
863 * not set. In that case we cannot do much, we enter C3
864 * without doing anything.
865 */
866 if (pr->flags.bm_check && pr->flags.bm_control) {
Thomas Gleixnere12f65f2009-07-25 18:14:37 +0200867 raw_spin_lock(&c3_lock);
Len Brown4f86d3a2007-10-03 18:58:00 -0400868 c3_cpu_count++;
869 /* Disable bus master arbitration when all CPUs are in C3 */
870 if (c3_cpu_count == num_online_cpus())
Bob Moore50ffba12009-02-23 15:02:07 +0800871 acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1);
Thomas Gleixnere12f65f2009-07-25 18:14:37 +0200872 raw_spin_unlock(&c3_lock);
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500873 } else if (!pr->flags.bm_check) {
874 ACPI_FLUSH_CPU_CACHE();
875 }
Len Brown4f86d3a2007-10-03 18:58:00 -0400876
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500877 acpi_idle_do_entry(cx);
Len Brown4f86d3a2007-10-03 18:58:00 -0400878
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500879 /* Re-enable bus master arbitration */
880 if (pr->flags.bm_check && pr->flags.bm_control) {
Thomas Gleixnere12f65f2009-07-25 18:14:37 +0200881 raw_spin_lock(&c3_lock);
Bob Moore50ffba12009-02-23 15:02:07 +0800882 acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0);
Len Brown4f86d3a2007-10-03 18:58:00 -0400883 c3_cpu_count--;
Thomas Gleixnere12f65f2009-07-25 18:14:37 +0200884 raw_spin_unlock(&c3_lock);
Len Brown4f86d3a2007-10-03 18:58:00 -0400885 }
886
Julius Wernera474a512012-11-27 14:17:58 +0100887 sched_clock_idle_wakeup_event(0);
Deepthi Dharware978aa72011-10-28 16:20:09 +0530888
Len Brown7e275cc2009-05-15 02:08:44 -0400889 lapic_timer_state_broadcast(pr, cx, 0);
Deepthi Dharware978aa72011-10-28 16:20:09 +0530890 return index;
Len Brown4f86d3a2007-10-03 18:58:00 -0400891}
892
893struct cpuidle_driver acpi_idle_driver = {
894 .name = "acpi_idle",
895 .owner = THIS_MODULE,
896};
897
898/**
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530899 * acpi_processor_setup_cpuidle_cx - prepares and configures CPUIDLE
900 * device i.e. per-cpu data
901 *
Len Brown4f86d3a2007-10-03 18:58:00 -0400902 * @pr: the ACPI processor
Daniel Lezcano6ef0f082013-02-04 22:44:42 +0000903 * @dev : the cpuidle device
Len Brown4f86d3a2007-10-03 18:58:00 -0400904 */
Daniel Lezcano6ef0f082013-02-04 22:44:42 +0000905static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr,
906 struct cpuidle_device *dev)
Len Brown4f86d3a2007-10-03 18:58:00 -0400907{
venkatesh.pallipadi@intel.com9a0b8412008-01-31 17:35:06 -0800908 int i, count = CPUIDLE_DRIVER_STATE_START;
Len Brown4f86d3a2007-10-03 18:58:00 -0400909 struct acpi_processor_cx *cx;
Len Brown4f86d3a2007-10-03 18:58:00 -0400910
911 if (!pr->flags.power_setup_done)
912 return -EINVAL;
913
914 if (pr->flags.power == 0) {
915 return -EINVAL;
916 }
917
Konrad Rzeszutek Wilkb88a6342013-01-16 23:40:07 +0100918 if (!dev)
919 return -EINVAL;
920
Venkatesh Pallipadidcb84f32008-05-19 19:09:27 -0400921 dev->cpu = pr->id;
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800922
Len Brown615dfd92009-04-23 23:21:29 -0400923 if (max_cstate == 0)
924 max_cstate = 1;
925
Len Brown4f86d3a2007-10-03 18:58:00 -0400926 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
927 cx = &pr->power.states[i];
Len Brown4f86d3a2007-10-03 18:58:00 -0400928
929 if (!cx->valid)
930 continue;
931
Alex Shi6240a102013-04-02 01:56:54 +0200932 per_cpu(acpi_cstate[count], dev->cpu) = cx;
Len Brown4f86d3a2007-10-03 18:58:00 -0400933
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530934 count++;
935 if (count == CPUIDLE_STATE_MAX)
936 break;
937 }
938
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530939 if (!count)
940 return -EINVAL;
941
942 return 0;
943}
944
945/**
946 * acpi_processor_setup_cpuidle states- prepares and configures cpuidle
947 * global state data i.e. idle routines
948 *
949 * @pr: the ACPI processor
950 */
951static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
952{
953 int i, count = CPUIDLE_DRIVER_STATE_START;
954 struct acpi_processor_cx *cx;
955 struct cpuidle_state *state;
956 struct cpuidle_driver *drv = &acpi_idle_driver;
957
958 if (!pr->flags.power_setup_done)
959 return -EINVAL;
960
961 if (pr->flags.power == 0)
962 return -EINVAL;
963
964 drv->safe_state_index = -1;
965 for (i = 0; i < CPUIDLE_STATE_MAX; i++) {
966 drv->states[i].name[0] = '\0';
967 drv->states[i].desc[0] = '\0';
968 }
969
970 if (max_cstate == 0)
971 max_cstate = 1;
972
973 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
974 cx = &pr->power.states[i];
975
976 if (!cx->valid)
977 continue;
978
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530979 state = &drv->states[count];
Len Brown4f86d3a2007-10-03 18:58:00 -0400980 snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i);
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800981 strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN);
Len Brown4f86d3a2007-10-03 18:58:00 -0400982 state->exit_latency = cx->latency;
Len Brown4963f622007-12-13 23:50:45 -0500983 state->target_residency = cx->latency * latency_factor;
Len Brown4f86d3a2007-10-03 18:58:00 -0400984
985 state->flags = 0;
986 switch (cx->type) {
987 case ACPI_STATE_C1:
Venki Pallipadi8e92b662008-02-29 10:24:32 -0800988 if (cx->entry_method == ACPI_CSTATE_FFH)
989 state->flags |= CPUIDLE_FLAG_TIME_VALID;
990
Len Brown4f86d3a2007-10-03 18:58:00 -0400991 state->enter = acpi_idle_enter_c1;
Boris Ostrovsky1a022e32012-03-13 19:55:09 +0100992 state->enter_dead = acpi_idle_play_dead;
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530993 drv->safe_state_index = count;
Len Brown4f86d3a2007-10-03 18:58:00 -0400994 break;
995
996 case ACPI_STATE_C2:
Len Brown4f86d3a2007-10-03 18:58:00 -0400997 state->flags |= CPUIDLE_FLAG_TIME_VALID;
998 state->enter = acpi_idle_enter_simple;
Boris Ostrovsky1a022e32012-03-13 19:55:09 +0100999 state->enter_dead = acpi_idle_play_dead;
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301000 drv->safe_state_index = count;
Len Brown4f86d3a2007-10-03 18:58:00 -04001001 break;
1002
1003 case ACPI_STATE_C3:
Len Brown4f86d3a2007-10-03 18:58:00 -04001004 state->flags |= CPUIDLE_FLAG_TIME_VALID;
Len Brown4f86d3a2007-10-03 18:58:00 -04001005 state->enter = pr->flags.bm_check ?
1006 acpi_idle_enter_bm :
1007 acpi_idle_enter_simple;
1008 break;
1009 }
1010
1011 count++;
venkatesh.pallipadi@intel.com9a0b8412008-01-31 17:35:06 -08001012 if (count == CPUIDLE_STATE_MAX)
1013 break;
Len Brown4f86d3a2007-10-03 18:58:00 -04001014 }
1015
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301016 drv->state_count = count;
Len Brown4f86d3a2007-10-03 18:58:00 -04001017
1018 if (!count)
1019 return -EINVAL;
1020
Len Brown4f86d3a2007-10-03 18:58:00 -04001021 return 0;
1022}
1023
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301024int acpi_processor_hotplug(struct acpi_processor *pr)
Len Brown4f86d3a2007-10-03 18:58:00 -04001025{
Venkatesh Pallipadidcb84f32008-05-19 19:09:27 -04001026 int ret = 0;
Wei Yongjune8b1b592012-10-08 08:40:42 +08001027 struct cpuidle_device *dev;
Len Brown4f86d3a2007-10-03 18:58:00 -04001028
Thomas Renningerd1896042010-11-03 17:06:14 +01001029 if (disabled_by_idle_boot_param())
Venkatesh Pallipadi36a91352008-04-30 13:57:15 -04001030 return 0;
1031
Bartlomiej Zolnierkiewiczbf9b59f2013-08-30 12:30:51 +02001032 if (nocst)
Len Brown4f86d3a2007-10-03 18:58:00 -04001033 return -ENODEV;
Len Brown4f86d3a2007-10-03 18:58:00 -04001034
1035 if (!pr->flags.power_setup_done)
1036 return -ENODEV;
1037
Wei Yongjune8b1b592012-10-08 08:40:42 +08001038 dev = per_cpu(acpi_cpuidle_device, pr->id);
Len Brown4f86d3a2007-10-03 18:58:00 -04001039 cpuidle_pause_and_lock();
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001040 cpuidle_disable_device(dev);
Len Brown4f86d3a2007-10-03 18:58:00 -04001041 acpi_processor_get_power_info(pr);
Venkatesh Pallipadidcb84f32008-05-19 19:09:27 -04001042 if (pr->flags.power) {
Daniel Lezcano6ef0f082013-02-04 22:44:42 +00001043 acpi_processor_setup_cpuidle_cx(pr, dev);
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001044 ret = cpuidle_enable_device(dev);
Venkatesh Pallipadidcb84f32008-05-19 19:09:27 -04001045 }
Len Brown4f86d3a2007-10-03 18:58:00 -04001046 cpuidle_resume_and_unlock();
1047
1048 return ret;
1049}
1050
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301051int acpi_processor_cst_has_changed(struct acpi_processor *pr)
1052{
1053 int cpu;
1054 struct acpi_processor *_pr;
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001055 struct cpuidle_device *dev;
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301056
1057 if (disabled_by_idle_boot_param())
1058 return 0;
1059
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301060 if (nocst)
1061 return -ENODEV;
1062
1063 if (!pr->flags.power_setup_done)
1064 return -ENODEV;
1065
1066 /*
1067 * FIXME: Design the ACPI notification to make it once per
1068 * system instead of once per-cpu. This condition is a hack
1069 * to make the code that updates C-States be called once.
1070 */
1071
Paul E. McKenney95056262012-02-28 13:27:44 -08001072 if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) {
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301073
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301074 /* Protect against cpu-hotplug */
1075 get_online_cpus();
Jiri Kosina67266552014-09-03 15:04:28 +02001076 cpuidle_pause_and_lock();
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301077
1078 /* Disable all cpuidle devices */
1079 for_each_online_cpu(cpu) {
1080 _pr = per_cpu(processors, cpu);
1081 if (!_pr || !_pr->flags.power_setup_done)
1082 continue;
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001083 dev = per_cpu(acpi_cpuidle_device, cpu);
1084 cpuidle_disable_device(dev);
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301085 }
1086
1087 /* Populate Updated C-state information */
Thomas Schlichterf427e5f2013-01-19 00:28:22 +01001088 acpi_processor_get_power_info(pr);
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301089 acpi_processor_setup_cpuidle_states(pr);
1090
1091 /* Enable all cpuidle devices */
1092 for_each_online_cpu(cpu) {
1093 _pr = per_cpu(processors, cpu);
1094 if (!_pr || !_pr->flags.power_setup_done)
1095 continue;
1096 acpi_processor_get_power_info(_pr);
1097 if (_pr->flags.power) {
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001098 dev = per_cpu(acpi_cpuidle_device, cpu);
Daniel Lezcano6ef0f082013-02-04 22:44:42 +00001099 acpi_processor_setup_cpuidle_cx(_pr, dev);
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001100 cpuidle_enable_device(dev);
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301101 }
1102 }
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301103 cpuidle_resume_and_unlock();
Jiri Kosina67266552014-09-03 15:04:28 +02001104 put_online_cpus();
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301105 }
1106
1107 return 0;
1108}
1109
1110static int acpi_processor_registered;
1111
Paul Gortmakerfe7bf102013-06-19 14:30:58 -04001112int acpi_processor_power_init(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113{
Len Brown4be44fc2005-08-05 00:44:28 -04001114 acpi_status status = 0;
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301115 int retval;
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001116 struct cpuidle_device *dev;
Andreas Mohrb6835052006-04-27 05:25:00 -04001117 static int first_run;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118
Thomas Renningerd1896042010-11-03 17:06:14 +01001119 if (disabled_by_idle_boot_param())
Venkatesh Pallipadi36a91352008-04-30 13:57:15 -04001120 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121
1122 if (!first_run) {
1123 dmi_check_system(processor_power_dmi_table);
Alexey Starikovskiyc1c30632007-11-26 20:42:19 +01001124 max_cstate = acpi_processor_cstate_check(max_cstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 if (max_cstate < ACPI_C_STATES_MAX)
Len Brown4be44fc2005-08-05 00:44:28 -04001126 printk(KERN_NOTICE
1127 "ACPI: processor limited to max C-state %d\n",
1128 max_cstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 first_run++;
1130 }
1131
Alexey Starikovskiycee324b2007-02-02 19:48:22 +03001132 if (acpi_gbl_FADT.cst_control && !nocst) {
Len Brown4be44fc2005-08-05 00:44:28 -04001133 status =
Alexey Starikovskiycee324b2007-02-02 19:48:22 +03001134 acpi_os_write_port(acpi_gbl_FADT.smi_command, acpi_gbl_FADT.cst_control, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -04001136 ACPI_EXCEPTION((AE_INFO, status,
1137 "Notifying BIOS of _CST ability failed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 }
1139 }
1140
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 acpi_processor_get_power_info(pr);
Len Brown4f86d3a2007-10-03 18:58:00 -04001142 pr->flags.power_setup_done = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
1144 /*
1145 * Install the idle handler if processor power management is supported.
1146 * Note that we use previously set idle handler will be used on
1147 * platforms that only support C1.
1148 */
Venkatesh Pallipadi36a91352008-04-30 13:57:15 -04001149 if (pr->flags.power) {
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301150 /* Register acpi_idle_driver if not already registered */
1151 if (!acpi_processor_registered) {
1152 acpi_processor_setup_cpuidle_states(pr);
1153 retval = cpuidle_register_driver(&acpi_idle_driver);
1154 if (retval)
1155 return retval;
1156 printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n",
1157 acpi_idle_driver.name);
1158 }
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001159
1160 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1161 if (!dev)
1162 return -ENOMEM;
1163 per_cpu(acpi_cpuidle_device, pr->id) = dev;
1164
Daniel Lezcano6ef0f082013-02-04 22:44:42 +00001165 acpi_processor_setup_cpuidle_cx(pr, dev);
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001166
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301167 /* Register per-cpu cpuidle_device. Cpuidle driver
1168 * must already be registered before registering device
1169 */
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001170 retval = cpuidle_register_device(dev);
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301171 if (retval) {
1172 if (acpi_processor_registered == 0)
1173 cpuidle_unregister_driver(&acpi_idle_driver);
1174 return retval;
1175 }
1176 acpi_processor_registered++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 }
Patrick Mocheld550d982006-06-27 00:41:40 -04001178 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179}
1180
Daniel Lezcano38a991b2012-09-15 22:42:54 +02001181int acpi_processor_power_exit(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182{
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001183 struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id);
1184
Thomas Renningerd1896042010-11-03 17:06:14 +01001185 if (disabled_by_idle_boot_param())
Venkatesh Pallipadi36a91352008-04-30 13:57:15 -04001186 return 0;
1187
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301188 if (pr->flags.power) {
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001189 cpuidle_unregister_device(dev);
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301190 acpi_processor_registered--;
1191 if (acpi_processor_registered == 0)
1192 cpuidle_unregister_driver(&acpi_idle_driver);
1193 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301195 pr->flags.power_setup_done = 0;
Patrick Mocheld550d982006-06-27 00:41:40 -04001196 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197}