blob: 175c86bee3a95b47934d094a491b842973e2e090 [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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 */
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/acpi.h>
29#include <linux/dmi.h>
Daniel Lezcanoe2668fb2013-02-04 22:44:41 +000030#include <linux/sched.h> /* need_resched() */
Thomas Gleixneree41eeb2015-04-03 02:02:00 +020031#include <linux/tick.h>
Len Brown4f86d3a2007-10-03 18:58:00 -040032#include <linux/cpuidle.h>
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +020033#include <linux/syscore_ops.h>
Lv Zheng8b484632013-12-03 08:49:16 +080034#include <acpi/processor.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
Thomas Gleixner34349332007-02-16 01:27:54 -080036/*
37 * Include the apic definitions for x86 to have the APIC timer related defines
38 * available also for UP (on SMP it gets magically included via linux/smp.h).
39 * asm/acpi.h is not an option, as it would require more include magic. Also
40 * creating an empty asm-ia64/apic.h would just trade pest vs. cholera.
41 */
42#ifdef CONFIG_X86
43#include <asm/apic.h>
44#endif
45
Len Browna192a952009-07-28 16:45:54 -040046#define PREFIX "ACPI: "
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#define ACPI_PROCESSOR_CLASS "processor"
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#define _COMPONENT ACPI_PROCESSOR_COMPONENT
Len Brownf52fd662007-02-12 22:42:12 -050050ACPI_MODULE_NAME("processor_idle");
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Len Brown4f86d3a2007-10-03 18:58:00 -040052static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER;
53module_param(max_cstate, uint, 0000);
Andreas Mohrb6835052006-04-27 05:25:00 -040054static unsigned int nocst __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055module_param(nocst, uint, 0000);
Len Brownd3e7e992010-07-22 17:23:10 -040056static int bm_check_disable __read_mostly;
57module_param(bm_check_disable, uint, 0000);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Len Brown25de5712007-12-14 00:24:15 -050059static unsigned int latency_factor __read_mostly = 2;
Len Brown4963f622007-12-13 23:50:45 -050060module_param(latency_factor, uint, 0644);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
Daniel Lezcano3d339dc2012-09-17 23:01:56 +020062static DEFINE_PER_CPU(struct cpuidle_device *, acpi_cpuidle_device);
63
Alex Shi6240a102013-04-02 01:56:54 +020064static DEFINE_PER_CPU(struct acpi_processor_cx * [CPUIDLE_STATE_MAX],
65 acpi_cstate);
Daniel Lezcanoac3ebaf2013-02-04 22:44:43 +000066
Thomas Renningerd1896042010-11-03 17:06:14 +010067static int disabled_by_idle_boot_param(void)
68{
69 return boot_option_idle_override == IDLE_POLL ||
Thomas Renningerd1896042010-11-03 17:06:14 +010070 boot_option_idle_override == IDLE_HALT;
71}
72
Linus Torvalds1da177e2005-04-16 15:20:36 -070073/*
74 * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
75 * For now disable this. Probably a bug somewhere else.
76 *
77 * To skip this limit, boot/load with a large max_cstate limit.
78 */
Jeff Garzik18552562007-10-03 15:15:40 -040079static int set_max_cstate(const struct dmi_system_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
81 if (max_cstate > ACPI_PROCESSOR_MAX_POWER)
82 return 0;
83
Len Brown3d356002005-08-03 00:22:52 -040084 printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate."
Len Brown4be44fc2005-08-05 00:44:28 -040085 " Override with \"processor.max_cstate=%d\"\n", id->ident,
86 (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
Len Brown3d356002005-08-03 00:22:52 -040088 max_cstate = (long)id->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
90 return 0;
91}
92
Mathias Krauseb0346682015-06-13 14:26:57 +020093static const struct dmi_system_id processor_power_dmi_table[] = {
Thomas Rosner876c1842006-01-06 01:31:00 -050094 { set_max_cstate, "Clevo 5600D", {
95 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
96 DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
Len Brown4be44fc2005-08-05 00:44:28 -040097 (void *)2},
Arjan van de Ven370d5cd2010-01-27 15:25:39 -080098 { set_max_cstate, "Pavilion zv5000", {
99 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
100 DMI_MATCH(DMI_PRODUCT_NAME,"Pavilion zv5000 (DS502A#ABA)")},
101 (void *)1},
102 { set_max_cstate, "Asus L8400B", {
103 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
104 DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")},
105 (void *)1},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 {},
107};
108
Len Brown4f86d3a2007-10-03 18:58:00 -0400109
venkatesh.pallipadi@intel.com2e906652008-01-31 17:35:03 -0800110/*
111 * Callers should disable interrupts before the call and enable
112 * interrupts after return.
113 */
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500114static void acpi_safe_halt(void)
115{
Peter Zijlstraea811742013-09-11 12:43:13 +0200116 if (!tif_need_resched()) {
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500117 safe_halt();
Venki Pallipadi71e93d12008-03-13 17:18:19 -0700118 local_irq_disable();
119 }
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500120}
121
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800122#ifdef ARCH_APICTIMER_STOPS_ON_C3
123
124/*
125 * Some BIOS implementations switch to C3 in the published C2 state.
Linus Torvalds296d93c2007-03-23 08:03:47 -0700126 * This seems to be a common problem on AMD boxen, but other vendors
127 * are affected too. We pick the most conservative approach: we assume
128 * that the local APIC stops in both C2 and C3.
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800129 */
Len Brown7e275cc2009-05-15 02:08:44 -0400130static void lapic_timer_check_state(int state, struct acpi_processor *pr,
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800131 struct acpi_processor_cx *cx)
132{
133 struct acpi_processor_power *pwr = &pr->power;
Thomas Gleixnere585bef2007-03-23 16:08:01 +0100134 u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2;
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800135
Venkatesh Pallipadidb954b52009-04-06 18:51:29 -0700136 if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT))
137 return;
138
Len Brown02c68a02011-04-01 16:59:53 -0400139 if (amd_e400_c1e_detected)
Shaohua Li87ad57ba2009-05-19 16:09:42 +0800140 type = ACPI_STATE_C1;
141
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800142 /*
143 * Check, if one of the previous states already marked the lapic
144 * unstable
145 */
146 if (pwr->timer_broadcast_on_state < state)
147 return;
148
Thomas Gleixnere585bef2007-03-23 16:08:01 +0100149 if (cx->type >= type)
Linus Torvalds296d93c2007-03-23 08:03:47 -0700150 pr->power.timer_broadcast_on_state = state;
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800151}
152
Hidetoshi Seto918aae42009-12-14 17:10:06 +0900153static void __lapic_timer_propagate_broadcast(void *arg)
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800154{
Suresh Siddhaf833bab2009-08-17 14:34:59 -0700155 struct acpi_processor *pr = (struct acpi_processor *) arg;
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800156
Thomas Gleixneree41eeb2015-04-03 02:02:00 +0200157 if (pr->power.timer_broadcast_on_state < INT_MAX)
158 tick_broadcast_enable();
159 else
160 tick_broadcast_disable();
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800161}
162
Hidetoshi Seto918aae42009-12-14 17:10:06 +0900163static void lapic_timer_propagate_broadcast(struct acpi_processor *pr)
164{
165 smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast,
166 (void *)pr, 1);
167}
168
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800169/* Power(C) State timer broadcast control */
Len Brown7e275cc2009-05-15 02:08:44 -0400170static void lapic_timer_state_broadcast(struct acpi_processor *pr,
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800171 struct acpi_processor_cx *cx,
172 int broadcast)
173{
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800174 int state = cx - pr->power.states;
175
176 if (state >= pr->power.timer_broadcast_on_state) {
Thomas Gleixner78157012015-04-03 02:12:03 +0200177 if (broadcast)
178 tick_broadcast_enter();
179 else
180 tick_broadcast_exit();
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800181 }
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800182}
183
184#else
185
Len Brown7e275cc2009-05-15 02:08:44 -0400186static void lapic_timer_check_state(int state, struct acpi_processor *pr,
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800187 struct acpi_processor_cx *cstate) { }
Len Brown7e275cc2009-05-15 02:08:44 -0400188static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { }
189static void lapic_timer_state_broadcast(struct acpi_processor *pr,
Thomas Gleixnere9e2cdb2007-02-16 01:28:04 -0800190 struct acpi_processor_cx *cx,
191 int broadcast)
192{
193}
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800194
195#endif
196
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200197#ifdef CONFIG_PM_SLEEP
Len Brown815ab0f2009-05-07 22:19:45 -0400198static u32 saved_bm_rld;
199
Fengguang Wu95d45d42013-06-11 00:55:10 +0200200static int acpi_processor_suspend(void)
Len Brown815ab0f2009-05-07 22:19:45 -0400201{
202 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200203 return 0;
Len Brown815ab0f2009-05-07 22:19:45 -0400204}
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200205
Fengguang Wu95d45d42013-06-11 00:55:10 +0200206static void acpi_processor_resume(void)
Len Brown815ab0f2009-05-07 22:19:45 -0400207{
Al Stone43575fa2013-12-16 17:01:37 -0700208 u32 resumed_bm_rld = 0;
Len Brown815ab0f2009-05-07 22:19:45 -0400209
210 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200211 if (resumed_bm_rld == saved_bm_rld)
212 return;
Len Brown815ab0f2009-05-07 22:19:45 -0400213
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200214 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
Len Brown815ab0f2009-05-07 22:19:45 -0400215}
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000216
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200217static struct syscore_ops acpi_processor_syscore_ops = {
218 .suspend = acpi_processor_suspend,
219 .resume = acpi_processor_resume,
220};
221
222void acpi_processor_syscore_init(void)
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000223{
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200224 register_syscore_ops(&acpi_processor_syscore_ops);
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000225}
226
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200227void acpi_processor_syscore_exit(void)
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000228{
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200229 unregister_syscore_ops(&acpi_processor_syscore_ops);
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000230}
Rafael J. Wysocki0a3b15a2013-05-02 21:54:37 +0200231#endif /* CONFIG_PM_SLEEP */
Thomas Gleixnerb04e7bd2007-09-22 22:29:05 +0000232
John Stultz592913e2010-07-13 17:56:20 -0700233#if defined(CONFIG_X86)
Len Brown520daf72009-05-14 17:27:38 -0400234static void tsc_check_state(int state)
Andi Kleenddb25f92008-01-30 13:32:41 +0100235{
236 switch (boot_cpu_data.x86_vendor) {
237 case X86_VENDOR_AMD:
Venki Pallipadi40fb1712008-11-17 16:11:37 -0800238 case X86_VENDOR_INTEL:
Andi Kleenddb25f92008-01-30 13:32:41 +0100239 /*
240 * AMD Fam10h TSC will tick in all
241 * C/P/S0/S1 states when this bit is set.
242 */
Venki Pallipadi40fb1712008-11-17 16:11:37 -0800243 if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
Len Brown520daf72009-05-14 17:27:38 -0400244 return;
Venki Pallipadi40fb1712008-11-17 16:11:37 -0800245
Andi Kleenddb25f92008-01-30 13:32:41 +0100246 /*FALL THROUGH*/
Andi Kleenddb25f92008-01-30 13:32:41 +0100247 default:
Len Brown520daf72009-05-14 17:27:38 -0400248 /* TSC could halt in idle, so notify users */
249 if (state > ACPI_STATE_C1)
250 mark_tsc_unstable("TSC halts in idle");
Andi Kleenddb25f92008-01-30 13:32:41 +0100251 }
252}
Len Brown520daf72009-05-14 17:27:38 -0400253#else
254static void tsc_check_state(int state) { return; }
Andi Kleenddb25f92008-01-30 13:32:41 +0100255#endif
256
Len Brown4be44fc2005-08-05 00:44:28 -0400257static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 if (!pr->pblk)
Patrick Mocheld550d982006-06-27 00:41:40 -0400261 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 /* if info is obtained from pblk/fadt, type equals state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
265 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3;
266
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400267#ifndef CONFIG_HOTPLUG_CPU
268 /*
269 * Check for P_LVL2_UP flag before entering C2 and above on
Len Brown4f86d3a2007-10-03 18:58:00 -0400270 * an SMP system.
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400271 */
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300272 if ((num_online_cpus() > 1) &&
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300273 !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
Patrick Mocheld550d982006-06-27 00:41:40 -0400274 return -ENODEV;
Venkatesh Pallipadi4c033552005-09-15 12:20:00 -0400275#endif
276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 /* determine C2 and C3 address from pblk */
278 pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4;
279 pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5;
280
281 /* determine latencies from FADT */
Bob Mooreba494be2012-07-12 09:40:10 +0800282 pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency;
283 pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
Len Brown5d76b6f2010-01-19 22:41:14 -0500285 /*
286 * FADT specified C2 latency must be less than or equal to
287 * 100 microseconds.
288 */
Bob Mooreba494be2012-07-12 09:40:10 +0800289 if (acpi_gbl_FADT.c2_latency > ACPI_PROCESSOR_MAX_C2_LATENCY) {
Len Brown5d76b6f2010-01-19 22:41:14 -0500290 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Bob Mooreba494be2012-07-12 09:40:10 +0800291 "C2 latency too large [%d]\n", acpi_gbl_FADT.c2_latency));
Len Brown5d76b6f2010-01-19 22:41:14 -0500292 /* invalidate C2 */
293 pr->power.states[ACPI_STATE_C2].address = 0;
294 }
295
Len Browna6d72c12010-01-19 23:10:04 -0500296 /*
297 * FADT supplied C3 latency must be less than or equal to
298 * 1000 microseconds.
299 */
Bob Mooreba494be2012-07-12 09:40:10 +0800300 if (acpi_gbl_FADT.c3_latency > ACPI_PROCESSOR_MAX_C3_LATENCY) {
Len Browna6d72c12010-01-19 23:10:04 -0500301 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Bob Mooreba494be2012-07-12 09:40:10 +0800302 "C3 latency too large [%d]\n", acpi_gbl_FADT.c3_latency));
Len Browna6d72c12010-01-19 23:10:04 -0500303 /* invalidate C3 */
304 pr->power.states[ACPI_STATE_C3].address = 0;
305 }
306
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
308 "lvl2[0x%08x] lvl3[0x%08x]\n",
309 pr->power.states[ACPI_STATE_C2].address,
310 pr->power.states[ACPI_STATE_C3].address));
311
Patrick Mocheld550d982006-06-27 00:41:40 -0400312 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313}
314
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700315static int acpi_processor_get_power_info_default(struct acpi_processor *pr)
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500316{
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700317 if (!pr->power.states[ACPI_STATE_C1].valid) {
318 /* set the first C-State to C1 */
319 /* all processors need to support C1 */
320 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
321 pr->power.states[ACPI_STATE_C1].valid = 1;
Venkatesh Pallipadi0fda6b42008-04-09 21:31:46 -0400322 pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT;
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700323 }
324 /* the C0 state only exists as a filler in our array */
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500325 pr->power.states[ACPI_STATE_C0].valid = 1;
Patrick Mocheld550d982006-06-27 00:41:40 -0400326 return 0;
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500327}
328
Len Brown4be44fc2005-08-05 00:44:28 -0400329static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
Sudeep Holla6fd80502014-11-25 14:48:50 +0000331 acpi_status status;
Lin Ming439913f2010-01-28 10:53:19 +0800332 u64 count;
Janosch Machowinskicf824782005-08-20 08:02:00 -0400333 int current_count;
Sudeep Holla6fd80502014-11-25 14:48:50 +0000334 int i, ret = 0;
Len Brown4be44fc2005-08-05 00:44:28 -0400335 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
336 union acpi_object *cst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 if (nocst)
Patrick Mocheld550d982006-06-27 00:41:40 -0400340 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700342 current_count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344 status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
345 if (ACPI_FAILURE(status)) {
346 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400347 return -ENODEV;
Len Brown4be44fc2005-08-05 00:44:28 -0400348 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200350 cst = buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352 /* There must be at least 2 elements */
353 if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
Len Brown64684632006-06-26 23:41:38 -0400354 printk(KERN_ERR PREFIX "not enough elements in _CST\n");
Sudeep Holla6fd80502014-11-25 14:48:50 +0000355 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 goto end;
357 }
358
359 count = cst->package.elements[0].integer.value;
360
361 /* Validate number of power states. */
362 if (count < 1 || count != cst->package.count - 1) {
Len Brown64684632006-06-26 23:41:38 -0400363 printk(KERN_ERR PREFIX "count given by _CST is not valid\n");
Sudeep Holla6fd80502014-11-25 14:48:50 +0000364 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 goto end;
366 }
367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 /* Tell driver that at least _CST is supported. */
369 pr->flags.has_cst = 1;
370
371 for (i = 1; i <= count; i++) {
372 union acpi_object *element;
373 union acpi_object *obj;
374 struct acpi_power_register *reg;
375 struct acpi_processor_cx cx;
376
377 memset(&cx, 0, sizeof(cx));
378
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200379 element = &(cst->package.elements[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 if (element->type != ACPI_TYPE_PACKAGE)
381 continue;
382
383 if (element->package.count != 4)
384 continue;
385
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200386 obj = &(element->package.elements[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
388 if (obj->type != ACPI_TYPE_BUFFER)
389 continue;
390
Len Brown4be44fc2005-08-05 00:44:28 -0400391 reg = (struct acpi_power_register *)obj->buffer.pointer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO &&
Len Brown4be44fc2005-08-05 00:44:28 -0400394 (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 continue;
396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 /* There should be an easy way to extract an integer... */
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200398 obj = &(element->package.elements[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 if (obj->type != ACPI_TYPE_INTEGER)
400 continue;
401
402 cx.type = obj->integer.value;
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700403 /*
404 * Some buggy BIOSes won't list C1 in _CST -
405 * Let acpi_processor_get_power_info_default() handle them later
406 */
407 if (i == 1 && cx.type != ACPI_STATE_C1)
408 current_count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700410 cx.address = reg->address;
411 cx.index = current_count + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800413 cx.entry_method = ACPI_CSTATE_SYSTEMIO;
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700414 if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
415 if (acpi_processor_ffh_cstate_probe
416 (pr->id, &cx, reg) == 0) {
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800417 cx.entry_method = ACPI_CSTATE_FFH;
418 } else if (cx.type == ACPI_STATE_C1) {
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700419 /*
420 * C1 is a special case where FIXED_HARDWARE
421 * can be handled in non-MWAIT way as well.
422 * In that case, save this _CST entry info.
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700423 * Otherwise, ignore this info and continue.
424 */
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800425 cx.entry_method = ACPI_CSTATE_HALT;
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800426 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800427 } else {
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700428 continue;
429 }
Zhao Yakuida5e09a2008-06-24 18:01:09 +0800430 if (cx.type == ACPI_STATE_C1 &&
Thomas Renningerd1896042010-11-03 17:06:14 +0100431 (boot_option_idle_override == IDLE_NOMWAIT)) {
Zhao Yakuic1e3b372008-06-24 17:58:53 +0800432 /*
433 * In most cases the C1 space_id obtained from
434 * _CST object is FIXED_HARDWARE access mode.
435 * But when the option of idle=halt is added,
436 * the entry_method type should be changed from
437 * CSTATE_FFH to CSTATE_HALT.
Zhao Yakuida5e09a2008-06-24 18:01:09 +0800438 * When the option of idle=nomwait is added,
439 * the C1 entry_method type should be
440 * CSTATE_HALT.
Zhao Yakuic1e3b372008-06-24 17:58:53 +0800441 */
442 cx.entry_method = ACPI_CSTATE_HALT;
443 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
444 }
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800445 } else {
446 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x",
447 cx.address);
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700448 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
Venkatesh Pallipadi0fda6b42008-04-09 21:31:46 -0400450 if (cx.type == ACPI_STATE_C1) {
451 cx.valid = 1;
452 }
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800453
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200454 obj = &(element->package.elements[2]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 if (obj->type != ACPI_TYPE_INTEGER)
456 continue;
457
458 cx.latency = obj->integer.value;
459
Jan Engelhardt50dd0962006-10-01 00:28:50 +0200460 obj = &(element->package.elements[3]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 if (obj->type != ACPI_TYPE_INTEGER)
462 continue;
463
Janosch Machowinskicf824782005-08-20 08:02:00 -0400464 current_count++;
465 memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx));
466
467 /*
468 * We support total ACPI_PROCESSOR_MAX_POWER - 1
469 * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1)
470 */
471 if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) {
472 printk(KERN_WARNING
473 "Limiting number of power states to max (%d)\n",
474 ACPI_PROCESSOR_MAX_POWER);
475 printk(KERN_WARNING
476 "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
477 break;
478 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 }
480
Len Brown4be44fc2005-08-05 00:44:28 -0400481 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n",
Janosch Machowinskicf824782005-08-20 08:02:00 -0400482 current_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 /* Validate number of power states discovered */
Janosch Machowinskicf824782005-08-20 08:02:00 -0400485 if (current_count < 2)
Sudeep Holla6fd80502014-11-25 14:48:50 +0000486 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
Len Brown4be44fc2005-08-05 00:44:28 -0400488 end:
Len Brown02438d82006-06-30 03:19:10 -0400489 kfree(buffer.pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Sudeep Holla6fd80502014-11-25 14:48:50 +0000491 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492}
493
Len Brown4be44fc2005-08-05 00:44:28 -0400494static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
495 struct acpi_processor_cx *cx)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
Pallipadi, Venkateshee1ca482009-05-21 17:09:10 -0700497 static int bm_check_flag = -1;
498 static int bm_control_flag = -1;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501 if (!cx->address)
Patrick Mocheld550d982006-06-27 00:41:40 -0400502 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 * PIIX4 Erratum #18: We don't support C3 when Type-F (fast)
506 * DMA transfers are used by any ISA device to avoid livelock.
507 * Note that we could disable Type-F DMA (as recommended by
508 * the erratum), but this is known to disrupt certain ISA
509 * devices thus we take the conservative approach.
510 */
511 else if (errata.piix4.fdma) {
512 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400513 "C3 not supported on PIIX4 with Type-F DMA\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400514 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 }
516
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400517 /* All the logic here assumes flags.bm_check is same across all CPUs */
Pallipadi, Venkateshee1ca482009-05-21 17:09:10 -0700518 if (bm_check_flag == -1) {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400519 /* Determine whether bm_check is needed based on CPU */
520 acpi_processor_power_init_bm_check(&(pr->flags), pr->id);
521 bm_check_flag = pr->flags.bm_check;
Pallipadi, Venkateshee1ca482009-05-21 17:09:10 -0700522 bm_control_flag = pr->flags.bm_control;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400523 } else {
524 pr->flags.bm_check = bm_check_flag;
Pallipadi, Venkateshee1ca482009-05-21 17:09:10 -0700525 pr->flags.bm_control = bm_control_flag;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400526 }
527
528 if (pr->flags.bm_check) {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400529 if (!pr->flags.bm_control) {
Venki Pallipadied3110e2007-07-31 12:04:31 -0700530 if (pr->flags.has_cst != 1) {
531 /* bus mastering control is necessary */
532 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
533 "C3 support requires BM control\n"));
534 return;
535 } else {
536 /* Here we enter C3 without bus mastering */
537 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
538 "C3 support without BM control\n"));
539 }
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400540 }
541 } else {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400542 /*
543 * WBINVD should be set in fadt, for C3 state to be
544 * supported on when bm_check is not required.
545 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300546 if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) {
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400547 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Len Brown4be44fc2005-08-05 00:44:28 -0400548 "Cache invalidation should work properly"
549 " for C3 to be enabled on SMP systems\n"));
Patrick Mocheld550d982006-06-27 00:41:40 -0400550 return;
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400551 }
Venkatesh Pallipadi02df8b92005-04-15 15:07:10 -0400552 }
553
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 /*
555 * Otherwise we've met all of our C3 requirements.
556 * Normalize the C3 latency to expidite policy. Enable
557 * checking of bus mastering status (bm_check) so we can
558 * use this in our C3 policy
559 */
560 cx->valid = 1;
Len Brown4f86d3a2007-10-03 18:58:00 -0400561
Len Brown31878dd2009-01-28 18:28:09 -0500562 /*
563 * On older chipsets, BM_RLD needs to be set
564 * in order for Bus Master activity to wake the
565 * system from C3. Newer chipsets handle DMA
566 * during C3 automatically and BM_RLD is a NOP.
567 * In either case, the proper way to
568 * handle BM_RLD is to set it and leave it set.
569 */
Bob Moore50ffba12009-02-23 15:02:07 +0800570 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
Patrick Mocheld550d982006-06-27 00:41:40 -0400572 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573}
574
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575static int acpi_processor_power_verify(struct acpi_processor *pr)
576{
577 unsigned int i;
578 unsigned int working = 0;
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100579
Thomas Gleixner169a0ab2007-02-16 01:27:55 -0800580 pr->power.timer_broadcast_on_state = INT_MAX;
Venkatesh Pallipadi6eb0a0f2006-01-11 22:44:21 +0100581
Len Browna0bf2842009-05-15 01:29:31 -0400582 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 struct acpi_processor_cx *cx = &pr->power.states[i];
584
585 switch (cx->type) {
586 case ACPI_STATE_C1:
587 cx->valid = 1;
588 break;
589
590 case ACPI_STATE_C2:
Len Brownd22edd22010-01-19 23:29:09 -0500591 if (!cx->address)
592 break;
Al Stonecad1525a2013-12-04 12:59:11 -0700593 cx->valid = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 break;
595
596 case ACPI_STATE_C3:
597 acpi_processor_power_verify_c3(pr, cx);
598 break;
599 }
Len Brown7e275cc2009-05-15 02:08:44 -0400600 if (!cx->valid)
601 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
Len Brown7e275cc2009-05-15 02:08:44 -0400603 lapic_timer_check_state(i, pr, cx);
604 tsc_check_state(cx->type);
605 working++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 }
607
Hidetoshi Seto918aae42009-12-14 17:10:06 +0900608 lapic_timer_propagate_broadcast(pr);
Andi Kleenbd663342006-03-25 16:31:07 +0100609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 return (working);
611}
612
Len Brown4be44fc2005-08-05 00:44:28 -0400613static int acpi_processor_get_power_info(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614{
615 unsigned int i;
616 int result;
617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
619 /* NOTE: the idle thread may not be running while calling
620 * this function */
621
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700622 /* Zero initialize all the C-states info. */
623 memset(pr->power.states, 0, sizeof(pr->power.states));
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 result = acpi_processor_get_power_info_cst(pr);
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400626 if (result == -ENODEV)
Darrick J. Wongc5a114f2006-10-19 23:28:28 -0700627 result = acpi_processor_get_power_info_fadt(pr);
Venkatesh Pallipadi6d93c642005-09-15 12:19:00 -0400628
Venkatesh Pallipadi991528d2006-09-25 16:28:13 -0700629 if (result)
630 return result;
631
632 acpi_processor_get_power_info_default(pr);
633
Janosch Machowinskicf824782005-08-20 08:02:00 -0400634 pr->power.count = acpi_processor_power_verify(pr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 /*
637 * if one state of type C2 or C3 is available, mark this
638 * CPU as being "idle manageable"
639 */
640 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500641 if (pr->power.states[i].valid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 pr->power.count = i;
Linus Torvalds2203d6e2005-11-18 07:29:51 -0800643 if (pr->power.states[i].type >= ACPI_STATE_C2)
644 pr->flags.power = 1;
Venkatesh Pallipadiacf05f42005-03-31 23:23:15 -0500645 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 }
647
Patrick Mocheld550d982006-06-27 00:41:40 -0400648 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649}
650
Len Brown4f86d3a2007-10-03 18:58:00 -0400651/**
652 * acpi_idle_bm_check - checks if bus master activity was detected
653 */
654static int acpi_idle_bm_check(void)
655{
656 u32 bm_status = 0;
657
Len Brownd3e7e992010-07-22 17:23:10 -0400658 if (bm_check_disable)
659 return 0;
660
Bob Moore50ffba12009-02-23 15:02:07 +0800661 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status);
Len Brown4f86d3a2007-10-03 18:58:00 -0400662 if (bm_status)
Bob Moore50ffba12009-02-23 15:02:07 +0800663 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, 1);
Len Brown4f86d3a2007-10-03 18:58:00 -0400664 /*
665 * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect
666 * the true state of bus mastering activity; forcing us to
667 * manually check the BMIDEA bit of each IDE channel.
668 */
669 else if (errata.piix4.bmisx) {
670 if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
671 || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
672 bm_status = 1;
673 }
674 return bm_status;
675}
676
677/**
Rafael J. Wysockib00783f2015-02-02 23:55:08 +0100678 * acpi_idle_do_entry - enter idle state using the appropriate method
Len Brown4f86d3a2007-10-03 18:58:00 -0400679 * @cx: cstate data
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800680 *
681 * Caller disables interrupt before call and enables interrupt after return.
Len Brown4f86d3a2007-10-03 18:58:00 -0400682 */
Rafael J. Wysockib00783f2015-02-02 23:55:08 +0100683static void acpi_idle_do_entry(struct acpi_processor_cx *cx)
Len Brown4f86d3a2007-10-03 18:58:00 -0400684{
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800685 if (cx->entry_method == ACPI_CSTATE_FFH) {
Len Brown4f86d3a2007-10-03 18:58:00 -0400686 /* Call into architectural FFH based C-state */
687 acpi_processor_ffh_cstate_enter(cx);
venkatesh.pallipadi@intel.combc71bec2008-01-31 17:35:04 -0800688 } else if (cx->entry_method == ACPI_CSTATE_HALT) {
689 acpi_safe_halt();
Len Brown4f86d3a2007-10-03 18:58:00 -0400690 } else {
Len Brown4f86d3a2007-10-03 18:58:00 -0400691 /* IO port based C-state */
692 inb(cx->address);
693 /* Dummy wait op - must do something useless after P_LVL2 read
694 because chipsets cannot guarantee that STPCLK# signal
695 gets asserted in time to freeze execution properly. */
Andi Kleencfa806f2010-07-20 15:18:36 -0700696 inl(acpi_gbl_FADT.xpm_timer_block.address);
Len Brown4f86d3a2007-10-03 18:58:00 -0400697 }
698}
699
700/**
Boris Ostrovsky1a022e32012-03-13 19:55:09 +0100701 * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining)
702 * @dev: the target CPU
703 * @index: the index of suggested state
704 */
705static int acpi_idle_play_dead(struct cpuidle_device *dev, int index)
706{
Alex Shi6240a102013-04-02 01:56:54 +0200707 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
Boris Ostrovsky1a022e32012-03-13 19:55:09 +0100708
709 ACPI_FLUSH_CPU_CACHE();
710
711 while (1) {
712
713 if (cx->entry_method == ACPI_CSTATE_HALT)
Luck, Tony54f70072012-04-03 09:37:28 -0700714 safe_halt();
Boris Ostrovsky1a022e32012-03-13 19:55:09 +0100715 else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) {
716 inb(cx->address);
717 /* See comment in acpi_idle_do_entry() */
718 inl(acpi_gbl_FADT.xpm_timer_block.address);
719 } else
720 return -ENODEV;
721 }
722
723 /* Never reached */
724 return 0;
725}
726
Rafael J. Wysockiadcb2622015-02-02 23:55:42 +0100727static bool acpi_idle_fallback_to_c1(struct acpi_processor *pr)
728{
Rafael J. Wysocki5f508182015-02-11 05:04:57 +0100729 return IS_ENABLED(CONFIG_HOTPLUG_CPU) && !pr->flags.has_cst &&
730 !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED);
Rafael J. Wysockiadcb2622015-02-02 23:55:42 +0100731}
732
Len Brown4f86d3a2007-10-03 18:58:00 -0400733static int c3_cpu_count;
Thomas Gleixnere12f65f2009-07-25 18:14:37 +0200734static DEFINE_RAW_SPINLOCK(c3_lock);
Len Brown4f86d3a2007-10-03 18:58:00 -0400735
736/**
737 * acpi_idle_enter_bm - enters C3 with proper BM handling
Rafael J. Wysocki6491bc02015-02-03 21:55:11 +0100738 * @pr: Target processor
739 * @cx: Target state context
Rafael J. Wysocki5f508182015-02-11 05:04:57 +0100740 * @timer_bc: Whether or not to change timer mode to broadcast
Len Brown4f86d3a2007-10-03 18:58:00 -0400741 */
Rafael J. Wysocki6491bc02015-02-03 21:55:11 +0100742static void acpi_idle_enter_bm(struct acpi_processor *pr,
Rafael J. Wysocki5f508182015-02-11 05:04:57 +0100743 struct acpi_processor_cx *cx, bool timer_bc)
Len Brown4f86d3a2007-10-03 18:58:00 -0400744{
Venki Pallipadi996520c2008-03-24 14:24:10 -0700745 acpi_unlazy_tlb(smp_processor_id());
746
Len Brown4f86d3a2007-10-03 18:58:00 -0400747 /*
748 * Must be done before busmaster disable as we might need to
749 * access HPET !
750 */
Rafael J. Wysocki5f508182015-02-11 05:04:57 +0100751 if (timer_bc)
752 lapic_timer_state_broadcast(pr, cx, 1);
Len Brown4f86d3a2007-10-03 18:58:00 -0400753
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500754 /*
755 * disable bus master
756 * bm_check implies we need ARB_DIS
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500757 * bm_control implies whether we can do ARB_DIS
758 *
759 * That leaves a case where bm_check is set and bm_control is
760 * not set. In that case we cannot do much, we enter C3
761 * without doing anything.
762 */
Rafael J. Wysocki2a738352015-02-02 23:56:03 +0100763 if (pr->flags.bm_control) {
Thomas Gleixnere12f65f2009-07-25 18:14:37 +0200764 raw_spin_lock(&c3_lock);
Len Brown4f86d3a2007-10-03 18:58:00 -0400765 c3_cpu_count++;
766 /* Disable bus master arbitration when all CPUs are in C3 */
767 if (c3_cpu_count == num_online_cpus())
Bob Moore50ffba12009-02-23 15:02:07 +0800768 acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1);
Thomas Gleixnere12f65f2009-07-25 18:14:37 +0200769 raw_spin_unlock(&c3_lock);
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500770 }
Len Brown4f86d3a2007-10-03 18:58:00 -0400771
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500772 acpi_idle_do_entry(cx);
Len Brown4f86d3a2007-10-03 18:58:00 -0400773
Venkatesh Pallipadiddc081a2007-11-19 21:43:22 -0500774 /* Re-enable bus master arbitration */
Rafael J. Wysocki2a738352015-02-02 23:56:03 +0100775 if (pr->flags.bm_control) {
Thomas Gleixnere12f65f2009-07-25 18:14:37 +0200776 raw_spin_lock(&c3_lock);
Bob Moore50ffba12009-02-23 15:02:07 +0800777 acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0);
Len Brown4f86d3a2007-10-03 18:58:00 -0400778 c3_cpu_count--;
Thomas Gleixnere12f65f2009-07-25 18:14:37 +0200779 raw_spin_unlock(&c3_lock);
Len Brown4f86d3a2007-10-03 18:58:00 -0400780 }
781
Rafael J. Wysocki5f508182015-02-11 05:04:57 +0100782 if (timer_bc)
783 lapic_timer_state_broadcast(pr, cx, 0);
Rafael J. Wysocki6491bc02015-02-03 21:55:11 +0100784}
785
786static int acpi_idle_enter(struct cpuidle_device *dev,
787 struct cpuidle_driver *drv, int index)
788{
789 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
790 struct acpi_processor *pr;
791
792 pr = __this_cpu_read(processors);
793 if (unlikely(!pr))
794 return -EINVAL;
795
796 if (cx->type != ACPI_STATE_C1) {
Rafael J. Wysocki5f508182015-02-11 05:04:57 +0100797 if (acpi_idle_fallback_to_c1(pr) && num_online_cpus() > 1) {
Rafael J. Wysocki6491bc02015-02-03 21:55:11 +0100798 index = CPUIDLE_DRIVER_STATE_START;
799 cx = per_cpu(acpi_cstate[index], dev->cpu);
800 } else if (cx->type == ACPI_STATE_C3 && pr->flags.bm_check) {
801 if (cx->bm_sts_skip || !acpi_idle_bm_check()) {
Rafael J. Wysocki5f508182015-02-11 05:04:57 +0100802 acpi_idle_enter_bm(pr, cx, true);
Rafael J. Wysocki6491bc02015-02-03 21:55:11 +0100803 return index;
804 } else if (drv->safe_state_index >= 0) {
805 index = drv->safe_state_index;
806 cx = per_cpu(acpi_cstate[index], dev->cpu);
807 } else {
808 acpi_safe_halt();
809 return -EBUSY;
810 }
811 }
812 }
813
814 lapic_timer_state_broadcast(pr, cx, 1);
815
816 if (cx->type == ACPI_STATE_C3)
817 ACPI_FLUSH_CPU_CACHE();
818
819 acpi_idle_do_entry(cx);
820
821 lapic_timer_state_broadcast(pr, cx, 0);
822
Deepthi Dharware978aa72011-10-28 16:20:09 +0530823 return index;
Len Brown4f86d3a2007-10-03 18:58:00 -0400824}
825
Rafael J. Wysocki5f508182015-02-11 05:04:57 +0100826static void acpi_idle_enter_freeze(struct cpuidle_device *dev,
827 struct cpuidle_driver *drv, int index)
828{
829 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
830
831 if (cx->type == ACPI_STATE_C3) {
832 struct acpi_processor *pr = __this_cpu_read(processors);
833
834 if (unlikely(!pr))
835 return;
836
837 if (pr->flags.bm_check) {
838 acpi_idle_enter_bm(pr, cx, false);
839 return;
840 } else {
841 ACPI_FLUSH_CPU_CACHE();
842 }
843 }
844 acpi_idle_do_entry(cx);
845}
846
Len Brown4f86d3a2007-10-03 18:58:00 -0400847struct cpuidle_driver acpi_idle_driver = {
848 .name = "acpi_idle",
849 .owner = THIS_MODULE,
850};
851
852/**
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530853 * acpi_processor_setup_cpuidle_cx - prepares and configures CPUIDLE
854 * device i.e. per-cpu data
855 *
Len Brown4f86d3a2007-10-03 18:58:00 -0400856 * @pr: the ACPI processor
Daniel Lezcano6ef0f082013-02-04 22:44:42 +0000857 * @dev : the cpuidle device
Len Brown4f86d3a2007-10-03 18:58:00 -0400858 */
Daniel Lezcano6ef0f082013-02-04 22:44:42 +0000859static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr,
860 struct cpuidle_device *dev)
Len Brown4f86d3a2007-10-03 18:58:00 -0400861{
venkatesh.pallipadi@intel.com9a0b8412008-01-31 17:35:06 -0800862 int i, count = CPUIDLE_DRIVER_STATE_START;
Len Brown4f86d3a2007-10-03 18:58:00 -0400863 struct acpi_processor_cx *cx;
Len Brown4f86d3a2007-10-03 18:58:00 -0400864
865 if (!pr->flags.power_setup_done)
866 return -EINVAL;
867
868 if (pr->flags.power == 0) {
869 return -EINVAL;
870 }
871
Konrad Rzeszutek Wilkb88a6342013-01-16 23:40:07 +0100872 if (!dev)
873 return -EINVAL;
874
Venkatesh Pallipadidcb84f32008-05-19 19:09:27 -0400875 dev->cpu = pr->id;
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800876
Len Brown615dfd92009-04-23 23:21:29 -0400877 if (max_cstate == 0)
878 max_cstate = 1;
879
Len Brown4f86d3a2007-10-03 18:58:00 -0400880 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
881 cx = &pr->power.states[i];
Len Brown4f86d3a2007-10-03 18:58:00 -0400882
883 if (!cx->valid)
884 continue;
885
Alex Shi6240a102013-04-02 01:56:54 +0200886 per_cpu(acpi_cstate[count], dev->cpu) = cx;
Len Brown4f86d3a2007-10-03 18:58:00 -0400887
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530888 count++;
889 if (count == CPUIDLE_STATE_MAX)
890 break;
891 }
892
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530893 if (!count)
894 return -EINVAL;
895
896 return 0;
897}
898
899/**
900 * acpi_processor_setup_cpuidle states- prepares and configures cpuidle
901 * global state data i.e. idle routines
902 *
903 * @pr: the ACPI processor
904 */
905static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
906{
907 int i, count = CPUIDLE_DRIVER_STATE_START;
908 struct acpi_processor_cx *cx;
909 struct cpuidle_state *state;
910 struct cpuidle_driver *drv = &acpi_idle_driver;
911
912 if (!pr->flags.power_setup_done)
913 return -EINVAL;
914
915 if (pr->flags.power == 0)
916 return -EINVAL;
917
918 drv->safe_state_index = -1;
Thomas Schlichterc7e8bdf2015-03-31 20:24:39 +0200919 for (i = CPUIDLE_DRIVER_STATE_START; i < CPUIDLE_STATE_MAX; i++) {
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530920 drv->states[i].name[0] = '\0';
921 drv->states[i].desc[0] = '\0';
922 }
923
924 if (max_cstate == 0)
925 max_cstate = 1;
926
927 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
928 cx = &pr->power.states[i];
929
930 if (!cx->valid)
931 continue;
932
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530933 state = &drv->states[count];
Len Brown4f86d3a2007-10-03 18:58:00 -0400934 snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i);
Venkatesh Pallipadi4fcb2fc2008-02-11 17:46:31 -0800935 strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN);
Len Brown4f86d3a2007-10-03 18:58:00 -0400936 state->exit_latency = cx->latency;
Len Brown4963f622007-12-13 23:50:45 -0500937 state->target_residency = cx->latency * latency_factor;
Rafael J. Wysocki6491bc02015-02-03 21:55:11 +0100938 state->enter = acpi_idle_enter;
Len Brown4f86d3a2007-10-03 18:58:00 -0400939
940 state->flags = 0;
Rafael J. Wysocki6491bc02015-02-03 21:55:11 +0100941 if (cx->type == ACPI_STATE_C1 || cx->type == ACPI_STATE_C2) {
Boris Ostrovsky1a022e32012-03-13 19:55:09 +0100942 state->enter_dead = acpi_idle_play_dead;
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530943 drv->safe_state_index = count;
Len Brown4f86d3a2007-10-03 18:58:00 -0400944 }
Rafael J. Wysocki5f508182015-02-11 05:04:57 +0100945 /*
946 * Halt-induced C1 is not good for ->enter_freeze, because it
947 * re-enables interrupts on exit. Moreover, C1 is generally not
948 * particularly interesting from the suspend-to-idle angle, so
949 * avoid C1 and the situations in which we may need to fall back
950 * to it altogether.
951 */
952 if (cx->type != ACPI_STATE_C1 && !acpi_idle_fallback_to_c1(pr))
953 state->enter_freeze = acpi_idle_enter_freeze;
Len Brown4f86d3a2007-10-03 18:58:00 -0400954
955 count++;
venkatesh.pallipadi@intel.com9a0b8412008-01-31 17:35:06 -0800956 if (count == CPUIDLE_STATE_MAX)
957 break;
Len Brown4f86d3a2007-10-03 18:58:00 -0400958 }
959
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530960 drv->state_count = count;
Len Brown4f86d3a2007-10-03 18:58:00 -0400961
962 if (!count)
963 return -EINVAL;
964
Len Brown4f86d3a2007-10-03 18:58:00 -0400965 return 0;
966}
967
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530968int acpi_processor_hotplug(struct acpi_processor *pr)
Len Brown4f86d3a2007-10-03 18:58:00 -0400969{
Venkatesh Pallipadidcb84f32008-05-19 19:09:27 -0400970 int ret = 0;
Wei Yongjune8b1b592012-10-08 08:40:42 +0800971 struct cpuidle_device *dev;
Len Brown4f86d3a2007-10-03 18:58:00 -0400972
Thomas Renningerd1896042010-11-03 17:06:14 +0100973 if (disabled_by_idle_boot_param())
Venkatesh Pallipadi36a91352008-04-30 13:57:15 -0400974 return 0;
975
Bartlomiej Zolnierkiewiczbf9b59f2013-08-30 12:30:51 +0200976 if (nocst)
Len Brown4f86d3a2007-10-03 18:58:00 -0400977 return -ENODEV;
Len Brown4f86d3a2007-10-03 18:58:00 -0400978
979 if (!pr->flags.power_setup_done)
980 return -ENODEV;
981
Wei Yongjune8b1b592012-10-08 08:40:42 +0800982 dev = per_cpu(acpi_cpuidle_device, pr->id);
Len Brown4f86d3a2007-10-03 18:58:00 -0400983 cpuidle_pause_and_lock();
Daniel Lezcano3d339dc2012-09-17 23:01:56 +0200984 cpuidle_disable_device(dev);
Len Brown4f86d3a2007-10-03 18:58:00 -0400985 acpi_processor_get_power_info(pr);
Venkatesh Pallipadidcb84f32008-05-19 19:09:27 -0400986 if (pr->flags.power) {
Daniel Lezcano6ef0f082013-02-04 22:44:42 +0000987 acpi_processor_setup_cpuidle_cx(pr, dev);
Daniel Lezcano3d339dc2012-09-17 23:01:56 +0200988 ret = cpuidle_enable_device(dev);
Venkatesh Pallipadidcb84f32008-05-19 19:09:27 -0400989 }
Len Brown4f86d3a2007-10-03 18:58:00 -0400990 cpuidle_resume_and_unlock();
991
992 return ret;
993}
994
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +0530995int acpi_processor_cst_has_changed(struct acpi_processor *pr)
996{
997 int cpu;
998 struct acpi_processor *_pr;
Daniel Lezcano3d339dc2012-09-17 23:01:56 +0200999 struct cpuidle_device *dev;
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301000
1001 if (disabled_by_idle_boot_param())
1002 return 0;
1003
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301004 if (nocst)
1005 return -ENODEV;
1006
1007 if (!pr->flags.power_setup_done)
1008 return -ENODEV;
1009
1010 /*
1011 * FIXME: Design the ACPI notification to make it once per
1012 * system instead of once per-cpu. This condition is a hack
1013 * to make the code that updates C-States be called once.
1014 */
1015
Paul E. McKenney95056262012-02-28 13:27:44 -08001016 if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) {
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301017
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301018 /* Protect against cpu-hotplug */
1019 get_online_cpus();
Jiri Kosina67266552014-09-03 15:04:28 +02001020 cpuidle_pause_and_lock();
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301021
1022 /* Disable all cpuidle devices */
1023 for_each_online_cpu(cpu) {
1024 _pr = per_cpu(processors, cpu);
1025 if (!_pr || !_pr->flags.power_setup_done)
1026 continue;
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001027 dev = per_cpu(acpi_cpuidle_device, cpu);
1028 cpuidle_disable_device(dev);
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301029 }
1030
1031 /* Populate Updated C-state information */
Thomas Schlichterf427e5f2013-01-19 00:28:22 +01001032 acpi_processor_get_power_info(pr);
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301033 acpi_processor_setup_cpuidle_states(pr);
1034
1035 /* Enable all cpuidle devices */
1036 for_each_online_cpu(cpu) {
1037 _pr = per_cpu(processors, cpu);
1038 if (!_pr || !_pr->flags.power_setup_done)
1039 continue;
1040 acpi_processor_get_power_info(_pr);
1041 if (_pr->flags.power) {
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001042 dev = per_cpu(acpi_cpuidle_device, cpu);
Daniel Lezcano6ef0f082013-02-04 22:44:42 +00001043 acpi_processor_setup_cpuidle_cx(_pr, dev);
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001044 cpuidle_enable_device(dev);
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301045 }
1046 }
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301047 cpuidle_resume_and_unlock();
Jiri Kosina67266552014-09-03 15:04:28 +02001048 put_online_cpus();
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301049 }
1050
1051 return 0;
1052}
1053
1054static int acpi_processor_registered;
1055
Paul Gortmakerfe7bf102013-06-19 14:30:58 -04001056int acpi_processor_power_init(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057{
Sudeep Holla6fd80502014-11-25 14:48:50 +00001058 acpi_status status;
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301059 int retval;
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001060 struct cpuidle_device *dev;
Andreas Mohrb6835052006-04-27 05:25:00 -04001061 static int first_run;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
Thomas Renningerd1896042010-11-03 17:06:14 +01001063 if (disabled_by_idle_boot_param())
Venkatesh Pallipadi36a91352008-04-30 13:57:15 -04001064 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
1066 if (!first_run) {
1067 dmi_check_system(processor_power_dmi_table);
Alexey Starikovskiyc1c30632007-11-26 20:42:19 +01001068 max_cstate = acpi_processor_cstate_check(max_cstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 if (max_cstate < ACPI_C_STATES_MAX)
Len Brown4be44fc2005-08-05 00:44:28 -04001070 printk(KERN_NOTICE
1071 "ACPI: processor limited to max C-state %d\n",
1072 max_cstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 first_run++;
1074 }
1075
Alexey Starikovskiycee324b2007-02-02 19:48:22 +03001076 if (acpi_gbl_FADT.cst_control && !nocst) {
Len Brown4be44fc2005-08-05 00:44:28 -04001077 status =
Alexey Starikovskiycee324b2007-02-02 19:48:22 +03001078 acpi_os_write_port(acpi_gbl_FADT.smi_command, acpi_gbl_FADT.cst_control, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 if (ACPI_FAILURE(status)) {
Thomas Renningera6fc6722006-06-26 23:58:43 -04001080 ACPI_EXCEPTION((AE_INFO, status,
1081 "Notifying BIOS of _CST ability failed"));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 }
1083 }
1084
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 acpi_processor_get_power_info(pr);
Len Brown4f86d3a2007-10-03 18:58:00 -04001086 pr->flags.power_setup_done = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
1088 /*
1089 * Install the idle handler if processor power management is supported.
1090 * Note that we use previously set idle handler will be used on
1091 * platforms that only support C1.
1092 */
Venkatesh Pallipadi36a91352008-04-30 13:57:15 -04001093 if (pr->flags.power) {
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301094 /* Register acpi_idle_driver if not already registered */
1095 if (!acpi_processor_registered) {
1096 acpi_processor_setup_cpuidle_states(pr);
1097 retval = cpuidle_register_driver(&acpi_idle_driver);
1098 if (retval)
1099 return retval;
1100 printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n",
1101 acpi_idle_driver.name);
1102 }
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001103
1104 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1105 if (!dev)
1106 return -ENOMEM;
1107 per_cpu(acpi_cpuidle_device, pr->id) = dev;
1108
Daniel Lezcano6ef0f082013-02-04 22:44:42 +00001109 acpi_processor_setup_cpuidle_cx(pr, dev);
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001110
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301111 /* Register per-cpu cpuidle_device. Cpuidle driver
1112 * must already be registered before registering device
1113 */
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001114 retval = cpuidle_register_device(dev);
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301115 if (retval) {
1116 if (acpi_processor_registered == 0)
1117 cpuidle_unregister_driver(&acpi_idle_driver);
1118 return retval;
1119 }
1120 acpi_processor_registered++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 }
Patrick Mocheld550d982006-06-27 00:41:40 -04001122 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123}
1124
Daniel Lezcano38a991b2012-09-15 22:42:54 +02001125int acpi_processor_power_exit(struct acpi_processor *pr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126{
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001127 struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id);
1128
Thomas Renningerd1896042010-11-03 17:06:14 +01001129 if (disabled_by_idle_boot_param())
Venkatesh Pallipadi36a91352008-04-30 13:57:15 -04001130 return 0;
1131
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301132 if (pr->flags.power) {
Daniel Lezcano3d339dc2012-09-17 23:01:56 +02001133 cpuidle_unregister_device(dev);
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301134 acpi_processor_registered--;
1135 if (acpi_processor_registered == 0)
1136 cpuidle_unregister_driver(&acpi_idle_driver);
1137 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Deepthi Dharwar46bcfad2011-10-28 16:20:42 +05301139 pr->flags.power_setup_done = 0;
Patrick Mocheld550d982006-06-27 00:41:40 -04001140 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141}