11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * processor_idle - idle state submodule to the ACPI processor driver 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 51da177e4SLinus Torvalds * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6c5ab81caSDominik Brodowski * Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de> 71da177e4SLinus Torvalds * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> 81da177e4SLinus Torvalds * - Added processor hotplug support 902df8b93SVenkatesh Pallipadi * Copyright (C) 2005 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com> 1002df8b93SVenkatesh Pallipadi * - Added support for C3 on SMP 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 131da177e4SLinus Torvalds * 141da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 151da177e4SLinus Torvalds * it under the terms of the GNU General Public License as published by 161da177e4SLinus Torvalds * the Free Software Foundation; either version 2 of the License, or (at 171da177e4SLinus Torvalds * your option) any later version. 181da177e4SLinus Torvalds * 191da177e4SLinus Torvalds * This program is distributed in the hope that it will be useful, but 201da177e4SLinus Torvalds * WITHOUT ANY WARRANTY; without even the implied warranty of 211da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 221da177e4SLinus Torvalds * General Public License for more details. 231da177e4SLinus Torvalds * 241da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License along 251da177e4SLinus Torvalds * with this program; if not, write to the Free Software Foundation, Inc., 261da177e4SLinus Torvalds * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 271da177e4SLinus Torvalds * 281da177e4SLinus Torvalds * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 291da177e4SLinus Torvalds */ 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include <linux/module.h> 321da177e4SLinus Torvalds #include <linux/acpi.h> 331da177e4SLinus Torvalds #include <linux/dmi.h> 344e57b681STim Schmielau #include <linux/sched.h> /* need_resched() */ 35e9e2cdb4SThomas Gleixner #include <linux/clockchips.h> 364f86d3a8SLen Brown #include <linux/cpuidle.h> 370a3b15acSRafael J. Wysocki #include <linux/syscore_ops.h> 381da177e4SLinus Torvalds 393434933bSThomas Gleixner /* 403434933bSThomas Gleixner * Include the apic definitions for x86 to have the APIC timer related defines 413434933bSThomas Gleixner * available also for UP (on SMP it gets magically included via linux/smp.h). 423434933bSThomas Gleixner * asm/acpi.h is not an option, as it would require more include magic. Also 433434933bSThomas Gleixner * creating an empty asm-ia64/apic.h would just trade pest vs. cholera. 443434933bSThomas Gleixner */ 453434933bSThomas Gleixner #ifdef CONFIG_X86 463434933bSThomas Gleixner #include <asm/apic.h> 473434933bSThomas Gleixner #endif 483434933bSThomas Gleixner 491da177e4SLinus Torvalds #include <acpi/acpi_bus.h> 501da177e4SLinus Torvalds #include <acpi/processor.h> 511da177e4SLinus Torvalds 52a192a958SLen Brown #define PREFIX "ACPI: " 53a192a958SLen Brown 541da177e4SLinus Torvalds #define ACPI_PROCESSOR_CLASS "processor" 551da177e4SLinus Torvalds #define _COMPONENT ACPI_PROCESSOR_COMPONENT 56f52fd66dSLen Brown ACPI_MODULE_NAME("processor_idle"); 571da177e4SLinus Torvalds 584f86d3a8SLen Brown static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER; 594f86d3a8SLen Brown module_param(max_cstate, uint, 0000); 60b6835052SAndreas Mohr static unsigned int nocst __read_mostly; 611da177e4SLinus Torvalds module_param(nocst, uint, 0000); 62d3e7e99fSLen Brown static int bm_check_disable __read_mostly; 63d3e7e99fSLen Brown module_param(bm_check_disable, uint, 0000); 641da177e4SLinus Torvalds 6525de5718SLen Brown static unsigned int latency_factor __read_mostly = 2; 664963f620SLen Brown module_param(latency_factor, uint, 0644); 671da177e4SLinus Torvalds 683d339dcbSDaniel Lezcano static DEFINE_PER_CPU(struct cpuidle_device *, acpi_cpuidle_device); 693d339dcbSDaniel Lezcano 706240a10dSAlex Shi static DEFINE_PER_CPU(struct acpi_processor_cx * [CPUIDLE_STATE_MAX], 716240a10dSAlex Shi acpi_cstate); 72ac3ebafaSDaniel Lezcano 73d1896049SThomas Renninger static int disabled_by_idle_boot_param(void) 74d1896049SThomas Renninger { 75d1896049SThomas Renninger return boot_option_idle_override == IDLE_POLL || 76d1896049SThomas Renninger boot_option_idle_override == IDLE_HALT; 77d1896049SThomas Renninger } 78d1896049SThomas Renninger 791da177e4SLinus Torvalds /* 801da177e4SLinus Torvalds * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3. 811da177e4SLinus Torvalds * For now disable this. Probably a bug somewhere else. 821da177e4SLinus Torvalds * 831da177e4SLinus Torvalds * To skip this limit, boot/load with a large max_cstate limit. 841da177e4SLinus Torvalds */ 851855256cSJeff Garzik static int set_max_cstate(const struct dmi_system_id *id) 861da177e4SLinus Torvalds { 871da177e4SLinus Torvalds if (max_cstate > ACPI_PROCESSOR_MAX_POWER) 881da177e4SLinus Torvalds return 0; 891da177e4SLinus Torvalds 903d35600aSLen Brown printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate." 911da177e4SLinus Torvalds " Override with \"processor.max_cstate=%d\"\n", id->ident, 923d35600aSLen Brown (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1); 931da177e4SLinus Torvalds 943d35600aSLen Brown max_cstate = (long)id->driver_data; 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds return 0; 971da177e4SLinus Torvalds } 981da177e4SLinus Torvalds 99fe7bf106SPaul Gortmaker static struct dmi_system_id processor_power_dmi_table[] = { 100335f16beSDavid Shaohua Li { set_max_cstate, "Clevo 5600D", { 101876c184bSThomas Rosner DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"), 102876c184bSThomas Rosner DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")}, 103335f16beSDavid Shaohua Li (void *)2}, 104370d5cd8SArjan van de Ven { set_max_cstate, "Pavilion zv5000", { 105370d5cd8SArjan van de Ven DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 106370d5cd8SArjan van de Ven DMI_MATCH(DMI_PRODUCT_NAME,"Pavilion zv5000 (DS502A#ABA)")}, 107370d5cd8SArjan van de Ven (void *)1}, 108370d5cd8SArjan van de Ven { set_max_cstate, "Asus L8400B", { 109370d5cd8SArjan van de Ven DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."), 110370d5cd8SArjan van de Ven DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")}, 111370d5cd8SArjan van de Ven (void *)1}, 1121da177e4SLinus Torvalds {}, 1131da177e4SLinus Torvalds }; 1141da177e4SLinus Torvalds 1154f86d3a8SLen Brown 1162e906655Svenkatesh.pallipadi@intel.com /* 1172e906655Svenkatesh.pallipadi@intel.com * Callers should disable interrupts before the call and enable 1182e906655Svenkatesh.pallipadi@intel.com * interrupts after return. 1192e906655Svenkatesh.pallipadi@intel.com */ 120ddc081a1SVenkatesh Pallipadi static void acpi_safe_halt(void) 121ddc081a1SVenkatesh Pallipadi { 122ea811747SPeter Zijlstra if (!tif_need_resched()) { 123ddc081a1SVenkatesh Pallipadi safe_halt(); 12471e93d15SVenki Pallipadi local_irq_disable(); 12571e93d15SVenki Pallipadi } 126ddc081a1SVenkatesh Pallipadi } 127ddc081a1SVenkatesh Pallipadi 128169a0abbSThomas Gleixner #ifdef ARCH_APICTIMER_STOPS_ON_C3 129169a0abbSThomas Gleixner 130169a0abbSThomas Gleixner /* 131169a0abbSThomas Gleixner * Some BIOS implementations switch to C3 in the published C2 state. 132296d93cdSLinus Torvalds * This seems to be a common problem on AMD boxen, but other vendors 133296d93cdSLinus Torvalds * are affected too. We pick the most conservative approach: we assume 134296d93cdSLinus Torvalds * that the local APIC stops in both C2 and C3. 135169a0abbSThomas Gleixner */ 1367e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr, 137169a0abbSThomas Gleixner struct acpi_processor_cx *cx) 138169a0abbSThomas Gleixner { 139169a0abbSThomas Gleixner struct acpi_processor_power *pwr = &pr->power; 140e585bef8SThomas Gleixner u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2; 141169a0abbSThomas Gleixner 142db954b58SVenkatesh Pallipadi if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT)) 143db954b58SVenkatesh Pallipadi return; 144db954b58SVenkatesh Pallipadi 14502c68a02SLen Brown if (amd_e400_c1e_detected) 14687ad57baSShaohua Li type = ACPI_STATE_C1; 14787ad57baSShaohua Li 148169a0abbSThomas Gleixner /* 149169a0abbSThomas Gleixner * Check, if one of the previous states already marked the lapic 150169a0abbSThomas Gleixner * unstable 151169a0abbSThomas Gleixner */ 152169a0abbSThomas Gleixner if (pwr->timer_broadcast_on_state < state) 153169a0abbSThomas Gleixner return; 154169a0abbSThomas Gleixner 155e585bef8SThomas Gleixner if (cx->type >= type) 156169a0abbSThomas Gleixner pr->power.timer_broadcast_on_state = state; 157169a0abbSThomas Gleixner } 158169a0abbSThomas Gleixner 159918aae42SHidetoshi Seto static void __lapic_timer_propagate_broadcast(void *arg) 160169a0abbSThomas Gleixner { 161f833bab8SSuresh Siddha struct acpi_processor *pr = (struct acpi_processor *) arg; 162e9e2cdb4SThomas Gleixner unsigned long reason; 163e9e2cdb4SThomas Gleixner 164e9e2cdb4SThomas Gleixner reason = pr->power.timer_broadcast_on_state < INT_MAX ? 165e9e2cdb4SThomas Gleixner CLOCK_EVT_NOTIFY_BROADCAST_ON : CLOCK_EVT_NOTIFY_BROADCAST_OFF; 166e9e2cdb4SThomas Gleixner 167e9e2cdb4SThomas Gleixner clockevents_notify(reason, &pr->id); 168e9e2cdb4SThomas Gleixner } 169e9e2cdb4SThomas Gleixner 170918aae42SHidetoshi Seto static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) 171918aae42SHidetoshi Seto { 172918aae42SHidetoshi Seto smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast, 173918aae42SHidetoshi Seto (void *)pr, 1); 174918aae42SHidetoshi Seto } 175918aae42SHidetoshi Seto 176e9e2cdb4SThomas Gleixner /* Power(C) State timer broadcast control */ 1777e275cc4SLen Brown static void lapic_timer_state_broadcast(struct acpi_processor *pr, 178e9e2cdb4SThomas Gleixner struct acpi_processor_cx *cx, 179e9e2cdb4SThomas Gleixner int broadcast) 180e9e2cdb4SThomas Gleixner { 181e9e2cdb4SThomas Gleixner int state = cx - pr->power.states; 182e9e2cdb4SThomas Gleixner 183e9e2cdb4SThomas Gleixner if (state >= pr->power.timer_broadcast_on_state) { 184e9e2cdb4SThomas Gleixner unsigned long reason; 185e9e2cdb4SThomas Gleixner 186e9e2cdb4SThomas Gleixner reason = broadcast ? CLOCK_EVT_NOTIFY_BROADCAST_ENTER : 187e9e2cdb4SThomas Gleixner CLOCK_EVT_NOTIFY_BROADCAST_EXIT; 188e9e2cdb4SThomas Gleixner clockevents_notify(reason, &pr->id); 189e9e2cdb4SThomas Gleixner } 190169a0abbSThomas Gleixner } 191169a0abbSThomas Gleixner 192169a0abbSThomas Gleixner #else 193169a0abbSThomas Gleixner 1947e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr, 195169a0abbSThomas Gleixner struct acpi_processor_cx *cstate) { } 1967e275cc4SLen Brown static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { } 1977e275cc4SLen Brown static void lapic_timer_state_broadcast(struct acpi_processor *pr, 198e9e2cdb4SThomas Gleixner struct acpi_processor_cx *cx, 199e9e2cdb4SThomas Gleixner int broadcast) 200e9e2cdb4SThomas Gleixner { 201e9e2cdb4SThomas Gleixner } 202169a0abbSThomas Gleixner 203169a0abbSThomas Gleixner #endif 204169a0abbSThomas Gleixner 2050a3b15acSRafael J. Wysocki #ifdef CONFIG_PM_SLEEP 206815ab0fdSLen Brown static u32 saved_bm_rld; 207815ab0fdSLen Brown 20895d45d4cSFengguang Wu static int acpi_processor_suspend(void) 209815ab0fdSLen Brown { 210815ab0fdSLen Brown acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld); 2110a3b15acSRafael J. Wysocki return 0; 212815ab0fdSLen Brown } 2130a3b15acSRafael J. Wysocki 21495d45d4cSFengguang Wu static void acpi_processor_resume(void) 215815ab0fdSLen Brown { 216815ab0fdSLen Brown u32 resumed_bm_rld; 217815ab0fdSLen Brown 218815ab0fdSLen Brown acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld); 2190a3b15acSRafael J. Wysocki if (resumed_bm_rld == saved_bm_rld) 2200a3b15acSRafael J. Wysocki return; 221815ab0fdSLen Brown 222815ab0fdSLen Brown acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld); 223815ab0fdSLen Brown } 224b04e7bdbSThomas Gleixner 2250a3b15acSRafael J. Wysocki static struct syscore_ops acpi_processor_syscore_ops = { 2260a3b15acSRafael J. Wysocki .suspend = acpi_processor_suspend, 2270a3b15acSRafael J. Wysocki .resume = acpi_processor_resume, 2280a3b15acSRafael J. Wysocki }; 2290a3b15acSRafael J. Wysocki 2300a3b15acSRafael J. Wysocki void acpi_processor_syscore_init(void) 231b04e7bdbSThomas Gleixner { 2320a3b15acSRafael J. Wysocki register_syscore_ops(&acpi_processor_syscore_ops); 233b04e7bdbSThomas Gleixner } 234b04e7bdbSThomas Gleixner 2350a3b15acSRafael J. Wysocki void acpi_processor_syscore_exit(void) 236b04e7bdbSThomas Gleixner { 2370a3b15acSRafael J. Wysocki unregister_syscore_ops(&acpi_processor_syscore_ops); 238b04e7bdbSThomas Gleixner } 2390a3b15acSRafael J. Wysocki #endif /* CONFIG_PM_SLEEP */ 240b04e7bdbSThomas Gleixner 241592913ecSJohn Stultz #if defined(CONFIG_X86) 242520daf72SLen Brown static void tsc_check_state(int state) 243ddb25f9aSAndi Kleen { 244ddb25f9aSAndi Kleen switch (boot_cpu_data.x86_vendor) { 245ddb25f9aSAndi Kleen case X86_VENDOR_AMD: 24640fb1715SVenki Pallipadi case X86_VENDOR_INTEL: 247ddb25f9aSAndi Kleen /* 248ddb25f9aSAndi Kleen * AMD Fam10h TSC will tick in all 249ddb25f9aSAndi Kleen * C/P/S0/S1 states when this bit is set. 250ddb25f9aSAndi Kleen */ 25140fb1715SVenki Pallipadi if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC)) 252520daf72SLen Brown return; 25340fb1715SVenki Pallipadi 254ddb25f9aSAndi Kleen /*FALL THROUGH*/ 255ddb25f9aSAndi Kleen default: 256520daf72SLen Brown /* TSC could halt in idle, so notify users */ 257520daf72SLen Brown if (state > ACPI_STATE_C1) 258520daf72SLen Brown mark_tsc_unstable("TSC halts in idle"); 259ddb25f9aSAndi Kleen } 260ddb25f9aSAndi Kleen } 261520daf72SLen Brown #else 262520daf72SLen Brown static void tsc_check_state(int state) { return; } 263ddb25f9aSAndi Kleen #endif 264ddb25f9aSAndi Kleen 2651da177e4SLinus Torvalds static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr) 2661da177e4SLinus Torvalds { 2671da177e4SLinus Torvalds 2681da177e4SLinus Torvalds if (!pr->pblk) 269d550d98dSPatrick Mochel return -ENODEV; 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds /* if info is obtained from pblk/fadt, type equals state */ 2721da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; 2731da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; 2741da177e4SLinus Torvalds 2754c033552SVenkatesh Pallipadi #ifndef CONFIG_HOTPLUG_CPU 2764c033552SVenkatesh Pallipadi /* 2774c033552SVenkatesh Pallipadi * Check for P_LVL2_UP flag before entering C2 and above on 2784c033552SVenkatesh Pallipadi * an SMP system. 2794c033552SVenkatesh Pallipadi */ 280ad71860aSAlexey Starikovskiy if ((num_online_cpus() > 1) && 281cee324b1SAlexey Starikovskiy !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED)) 282d550d98dSPatrick Mochel return -ENODEV; 2834c033552SVenkatesh Pallipadi #endif 2844c033552SVenkatesh Pallipadi 2851da177e4SLinus Torvalds /* determine C2 and C3 address from pblk */ 2861da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4; 2871da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5; 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds /* determine latencies from FADT */ 290ba494beeSBob Moore pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency; 291ba494beeSBob Moore pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency; 2921da177e4SLinus Torvalds 2935d76b6f6SLen Brown /* 2945d76b6f6SLen Brown * FADT specified C2 latency must be less than or equal to 2955d76b6f6SLen Brown * 100 microseconds. 2965d76b6f6SLen Brown */ 297ba494beeSBob Moore if (acpi_gbl_FADT.c2_latency > ACPI_PROCESSOR_MAX_C2_LATENCY) { 2985d76b6f6SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_INFO, 299ba494beeSBob Moore "C2 latency too large [%d]\n", acpi_gbl_FADT.c2_latency)); 3005d76b6f6SLen Brown /* invalidate C2 */ 3015d76b6f6SLen Brown pr->power.states[ACPI_STATE_C2].address = 0; 3025d76b6f6SLen Brown } 3035d76b6f6SLen Brown 304a6d72c18SLen Brown /* 305a6d72c18SLen Brown * FADT supplied C3 latency must be less than or equal to 306a6d72c18SLen Brown * 1000 microseconds. 307a6d72c18SLen Brown */ 308ba494beeSBob Moore if (acpi_gbl_FADT.c3_latency > ACPI_PROCESSOR_MAX_C3_LATENCY) { 309a6d72c18SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_INFO, 310ba494beeSBob Moore "C3 latency too large [%d]\n", acpi_gbl_FADT.c3_latency)); 311a6d72c18SLen Brown /* invalidate C3 */ 312a6d72c18SLen Brown pr->power.states[ACPI_STATE_C3].address = 0; 313a6d72c18SLen Brown } 314a6d72c18SLen Brown 3151da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, 3161da177e4SLinus Torvalds "lvl2[0x%08x] lvl3[0x%08x]\n", 3171da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].address, 3181da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].address)); 3191da177e4SLinus Torvalds 320d550d98dSPatrick Mochel return 0; 3211da177e4SLinus Torvalds } 3221da177e4SLinus Torvalds 323991528d7SVenkatesh Pallipadi static int acpi_processor_get_power_info_default(struct acpi_processor *pr) 324acf05f4bSVenkatesh Pallipadi { 325991528d7SVenkatesh Pallipadi if (!pr->power.states[ACPI_STATE_C1].valid) { 326cf824788SJanosch Machowinski /* set the first C-State to C1 */ 327991528d7SVenkatesh Pallipadi /* all processors need to support C1 */ 328acf05f4bSVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; 329acf05f4bSVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].valid = 1; 3300fda6b40SVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT; 331991528d7SVenkatesh Pallipadi } 332991528d7SVenkatesh Pallipadi /* the C0 state only exists as a filler in our array */ 333991528d7SVenkatesh Pallipadi pr->power.states[ACPI_STATE_C0].valid = 1; 334d550d98dSPatrick Mochel return 0; 335acf05f4bSVenkatesh Pallipadi } 336acf05f4bSVenkatesh Pallipadi 3371da177e4SLinus Torvalds static int acpi_processor_get_power_info_cst(struct acpi_processor *pr) 3381da177e4SLinus Torvalds { 3391da177e4SLinus Torvalds acpi_status status = 0; 340439913ffSLin Ming u64 count; 341cf824788SJanosch Machowinski int current_count; 3421da177e4SLinus Torvalds int i; 3431da177e4SLinus Torvalds struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 3441da177e4SLinus Torvalds union acpi_object *cst; 3451da177e4SLinus Torvalds 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds if (nocst) 348d550d98dSPatrick Mochel return -ENODEV; 3491da177e4SLinus Torvalds 350991528d7SVenkatesh Pallipadi current_count = 0; 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer); 3531da177e4SLinus Torvalds if (ACPI_FAILURE(status)) { 3541da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n")); 355d550d98dSPatrick Mochel return -ENODEV; 3561da177e4SLinus Torvalds } 3571da177e4SLinus Torvalds 35850dd0969SJan Engelhardt cst = buffer.pointer; 3591da177e4SLinus Torvalds 3601da177e4SLinus Torvalds /* There must be at least 2 elements */ 3611da177e4SLinus Torvalds if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) { 3626468463aSLen Brown printk(KERN_ERR PREFIX "not enough elements in _CST\n"); 3631da177e4SLinus Torvalds status = -EFAULT; 3641da177e4SLinus Torvalds goto end; 3651da177e4SLinus Torvalds } 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds count = cst->package.elements[0].integer.value; 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds /* Validate number of power states. */ 3701da177e4SLinus Torvalds if (count < 1 || count != cst->package.count - 1) { 3716468463aSLen Brown printk(KERN_ERR PREFIX "count given by _CST is not valid\n"); 3721da177e4SLinus Torvalds status = -EFAULT; 3731da177e4SLinus Torvalds goto end; 3741da177e4SLinus Torvalds } 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds /* Tell driver that at least _CST is supported. */ 3771da177e4SLinus Torvalds pr->flags.has_cst = 1; 3781da177e4SLinus Torvalds 3791da177e4SLinus Torvalds for (i = 1; i <= count; i++) { 3801da177e4SLinus Torvalds union acpi_object *element; 3811da177e4SLinus Torvalds union acpi_object *obj; 3821da177e4SLinus Torvalds struct acpi_power_register *reg; 3831da177e4SLinus Torvalds struct acpi_processor_cx cx; 3841da177e4SLinus Torvalds 3851da177e4SLinus Torvalds memset(&cx, 0, sizeof(cx)); 3861da177e4SLinus Torvalds 38750dd0969SJan Engelhardt element = &(cst->package.elements[i]); 3881da177e4SLinus Torvalds if (element->type != ACPI_TYPE_PACKAGE) 3891da177e4SLinus Torvalds continue; 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds if (element->package.count != 4) 3921da177e4SLinus Torvalds continue; 3931da177e4SLinus Torvalds 39450dd0969SJan Engelhardt obj = &(element->package.elements[0]); 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_BUFFER) 3971da177e4SLinus Torvalds continue; 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds reg = (struct acpi_power_register *)obj->buffer.pointer; 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && 4021da177e4SLinus Torvalds (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) 4031da177e4SLinus Torvalds continue; 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds /* There should be an easy way to extract an integer... */ 40650dd0969SJan Engelhardt obj = &(element->package.elements[1]); 4071da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 4081da177e4SLinus Torvalds continue; 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds cx.type = obj->integer.value; 411991528d7SVenkatesh Pallipadi /* 412991528d7SVenkatesh Pallipadi * Some buggy BIOSes won't list C1 in _CST - 413991528d7SVenkatesh Pallipadi * Let acpi_processor_get_power_info_default() handle them later 414991528d7SVenkatesh Pallipadi */ 415991528d7SVenkatesh Pallipadi if (i == 1 && cx.type != ACPI_STATE_C1) 416991528d7SVenkatesh Pallipadi current_count++; 4171da177e4SLinus Torvalds 418991528d7SVenkatesh Pallipadi cx.address = reg->address; 419991528d7SVenkatesh Pallipadi cx.index = current_count + 1; 4201da177e4SLinus Torvalds 421bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_SYSTEMIO; 422991528d7SVenkatesh Pallipadi if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { 423991528d7SVenkatesh Pallipadi if (acpi_processor_ffh_cstate_probe 424991528d7SVenkatesh Pallipadi (pr->id, &cx, reg) == 0) { 425bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_FFH; 426bc71bec9Svenkatesh.pallipadi@intel.com } else if (cx.type == ACPI_STATE_C1) { 427991528d7SVenkatesh Pallipadi /* 428991528d7SVenkatesh Pallipadi * C1 is a special case where FIXED_HARDWARE 429991528d7SVenkatesh Pallipadi * can be handled in non-MWAIT way as well. 430991528d7SVenkatesh Pallipadi * In that case, save this _CST entry info. 431991528d7SVenkatesh Pallipadi * Otherwise, ignore this info and continue. 432991528d7SVenkatesh Pallipadi */ 433bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_HALT; 4344fcb2fcdSVenkatesh Pallipadi snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 435bc71bec9Svenkatesh.pallipadi@intel.com } else { 4361da177e4SLinus Torvalds continue; 437991528d7SVenkatesh Pallipadi } 438da5e09a1SZhao Yakui if (cx.type == ACPI_STATE_C1 && 439d1896049SThomas Renninger (boot_option_idle_override == IDLE_NOMWAIT)) { 440c1e3b377SZhao Yakui /* 441c1e3b377SZhao Yakui * In most cases the C1 space_id obtained from 442c1e3b377SZhao Yakui * _CST object is FIXED_HARDWARE access mode. 443c1e3b377SZhao Yakui * But when the option of idle=halt is added, 444c1e3b377SZhao Yakui * the entry_method type should be changed from 445c1e3b377SZhao Yakui * CSTATE_FFH to CSTATE_HALT. 446da5e09a1SZhao Yakui * When the option of idle=nomwait is added, 447da5e09a1SZhao Yakui * the C1 entry_method type should be 448da5e09a1SZhao Yakui * CSTATE_HALT. 449c1e3b377SZhao Yakui */ 450c1e3b377SZhao Yakui cx.entry_method = ACPI_CSTATE_HALT; 451c1e3b377SZhao Yakui snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 452c1e3b377SZhao Yakui } 4534fcb2fcdSVenkatesh Pallipadi } else { 4544fcb2fcdSVenkatesh Pallipadi snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x", 4554fcb2fcdSVenkatesh Pallipadi cx.address); 456991528d7SVenkatesh Pallipadi } 4571da177e4SLinus Torvalds 4580fda6b40SVenkatesh Pallipadi if (cx.type == ACPI_STATE_C1) { 4590fda6b40SVenkatesh Pallipadi cx.valid = 1; 4600fda6b40SVenkatesh Pallipadi } 4614fcb2fcdSVenkatesh Pallipadi 46250dd0969SJan Engelhardt obj = &(element->package.elements[2]); 4631da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 4641da177e4SLinus Torvalds continue; 4651da177e4SLinus Torvalds 4661da177e4SLinus Torvalds cx.latency = obj->integer.value; 4671da177e4SLinus Torvalds 46850dd0969SJan Engelhardt obj = &(element->package.elements[3]); 4691da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 4701da177e4SLinus Torvalds continue; 4711da177e4SLinus Torvalds 472cf824788SJanosch Machowinski current_count++; 473cf824788SJanosch Machowinski memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx)); 474cf824788SJanosch Machowinski 475cf824788SJanosch Machowinski /* 476cf824788SJanosch Machowinski * We support total ACPI_PROCESSOR_MAX_POWER - 1 477cf824788SJanosch Machowinski * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1) 478cf824788SJanosch Machowinski */ 479cf824788SJanosch Machowinski if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) { 480cf824788SJanosch Machowinski printk(KERN_WARNING 481cf824788SJanosch Machowinski "Limiting number of power states to max (%d)\n", 482cf824788SJanosch Machowinski ACPI_PROCESSOR_MAX_POWER); 483cf824788SJanosch Machowinski printk(KERN_WARNING 484cf824788SJanosch Machowinski "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n"); 485cf824788SJanosch Machowinski break; 486cf824788SJanosch Machowinski } 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds 4894be44fcdSLen Brown ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n", 490cf824788SJanosch Machowinski current_count)); 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds /* Validate number of power states discovered */ 493cf824788SJanosch Machowinski if (current_count < 2) 4946d93c648SVenkatesh Pallipadi status = -EFAULT; 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds end: 49702438d87SLen Brown kfree(buffer.pointer); 4981da177e4SLinus Torvalds 499d550d98dSPatrick Mochel return status; 5001da177e4SLinus Torvalds } 5011da177e4SLinus Torvalds 5024be44fcdSLen Brown static void acpi_processor_power_verify_c3(struct acpi_processor *pr, 5031da177e4SLinus Torvalds struct acpi_processor_cx *cx) 5041da177e4SLinus Torvalds { 505ee1ca48fSPallipadi, Venkatesh static int bm_check_flag = -1; 506ee1ca48fSPallipadi, Venkatesh static int bm_control_flag = -1; 50702df8b93SVenkatesh Pallipadi 5081da177e4SLinus Torvalds 5091da177e4SLinus Torvalds if (!cx->address) 510d550d98dSPatrick Mochel return; 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds /* 5131da177e4SLinus Torvalds * PIIX4 Erratum #18: We don't support C3 when Type-F (fast) 5141da177e4SLinus Torvalds * DMA transfers are used by any ISA device to avoid livelock. 5151da177e4SLinus Torvalds * Note that we could disable Type-F DMA (as recommended by 5161da177e4SLinus Torvalds * the erratum), but this is known to disrupt certain ISA 5171da177e4SLinus Torvalds * devices thus we take the conservative approach. 5181da177e4SLinus Torvalds */ 5191da177e4SLinus Torvalds else if (errata.piix4.fdma) { 5201da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, 5211da177e4SLinus Torvalds "C3 not supported on PIIX4 with Type-F DMA\n")); 522d550d98dSPatrick Mochel return; 5231da177e4SLinus Torvalds } 5241da177e4SLinus Torvalds 52502df8b93SVenkatesh Pallipadi /* All the logic here assumes flags.bm_check is same across all CPUs */ 526ee1ca48fSPallipadi, Venkatesh if (bm_check_flag == -1) { 52702df8b93SVenkatesh Pallipadi /* Determine whether bm_check is needed based on CPU */ 52802df8b93SVenkatesh Pallipadi acpi_processor_power_init_bm_check(&(pr->flags), pr->id); 52902df8b93SVenkatesh Pallipadi bm_check_flag = pr->flags.bm_check; 530ee1ca48fSPallipadi, Venkatesh bm_control_flag = pr->flags.bm_control; 53102df8b93SVenkatesh Pallipadi } else { 53202df8b93SVenkatesh Pallipadi pr->flags.bm_check = bm_check_flag; 533ee1ca48fSPallipadi, Venkatesh pr->flags.bm_control = bm_control_flag; 53402df8b93SVenkatesh Pallipadi } 53502df8b93SVenkatesh Pallipadi 53602df8b93SVenkatesh Pallipadi if (pr->flags.bm_check) { 53702df8b93SVenkatesh Pallipadi if (!pr->flags.bm_control) { 538ed3110efSVenki Pallipadi if (pr->flags.has_cst != 1) { 539ed3110efSVenki Pallipadi /* bus mastering control is necessary */ 54002df8b93SVenkatesh Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 541ed3110efSVenki Pallipadi "C3 support requires BM control\n")); 542ed3110efSVenki Pallipadi return; 543ed3110efSVenki Pallipadi } else { 544ed3110efSVenki Pallipadi /* Here we enter C3 without bus mastering */ 545ed3110efSVenki Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 546ed3110efSVenki Pallipadi "C3 support without BM control\n")); 547ed3110efSVenki Pallipadi } 54802df8b93SVenkatesh Pallipadi } 54902df8b93SVenkatesh Pallipadi } else { 55002df8b93SVenkatesh Pallipadi /* 55102df8b93SVenkatesh Pallipadi * WBINVD should be set in fadt, for C3 state to be 55202df8b93SVenkatesh Pallipadi * supported on when bm_check is not required. 55302df8b93SVenkatesh Pallipadi */ 554cee324b1SAlexey Starikovskiy if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) { 55502df8b93SVenkatesh Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 55602df8b93SVenkatesh Pallipadi "Cache invalidation should work properly" 55702df8b93SVenkatesh Pallipadi " for C3 to be enabled on SMP systems\n")); 558d550d98dSPatrick Mochel return; 55902df8b93SVenkatesh Pallipadi } 56002df8b93SVenkatesh Pallipadi } 56102df8b93SVenkatesh Pallipadi 5621da177e4SLinus Torvalds /* 5631da177e4SLinus Torvalds * Otherwise we've met all of our C3 requirements. 5641da177e4SLinus Torvalds * Normalize the C3 latency to expidite policy. Enable 5651da177e4SLinus Torvalds * checking of bus mastering status (bm_check) so we can 5661da177e4SLinus Torvalds * use this in our C3 policy 5671da177e4SLinus Torvalds */ 5681da177e4SLinus Torvalds cx->valid = 1; 5694f86d3a8SLen Brown 57031878dd8SLen Brown /* 57131878dd8SLen Brown * On older chipsets, BM_RLD needs to be set 57231878dd8SLen Brown * in order for Bus Master activity to wake the 57331878dd8SLen Brown * system from C3. Newer chipsets handle DMA 57431878dd8SLen Brown * during C3 automatically and BM_RLD is a NOP. 57531878dd8SLen Brown * In either case, the proper way to 57631878dd8SLen Brown * handle BM_RLD is to set it and leave it set. 57731878dd8SLen Brown */ 57850ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 1); 5791da177e4SLinus Torvalds 580d550d98dSPatrick Mochel return; 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds static int acpi_processor_power_verify(struct acpi_processor *pr) 5841da177e4SLinus Torvalds { 5851da177e4SLinus Torvalds unsigned int i; 5861da177e4SLinus Torvalds unsigned int working = 0; 5876eb0a0fdSVenkatesh Pallipadi 588169a0abbSThomas Gleixner pr->power.timer_broadcast_on_state = INT_MAX; 5896eb0a0fdSVenkatesh Pallipadi 590a0bf284bSLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 5911da177e4SLinus Torvalds struct acpi_processor_cx *cx = &pr->power.states[i]; 5921da177e4SLinus Torvalds 5931da177e4SLinus Torvalds switch (cx->type) { 5941da177e4SLinus Torvalds case ACPI_STATE_C1: 5951da177e4SLinus Torvalds cx->valid = 1; 5961da177e4SLinus Torvalds break; 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds case ACPI_STATE_C2: 599d22edd29SLen Brown if (!cx->address) 600d22edd29SLen Brown break; 601d22edd29SLen Brown cx->valid = 1; 6021da177e4SLinus Torvalds break; 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds case ACPI_STATE_C3: 6051da177e4SLinus Torvalds acpi_processor_power_verify_c3(pr, cx); 6061da177e4SLinus Torvalds break; 6071da177e4SLinus Torvalds } 6087e275cc4SLen Brown if (!cx->valid) 6097e275cc4SLen Brown continue; 6101da177e4SLinus Torvalds 6117e275cc4SLen Brown lapic_timer_check_state(i, pr, cx); 6127e275cc4SLen Brown tsc_check_state(cx->type); 6131da177e4SLinus Torvalds working++; 6141da177e4SLinus Torvalds } 6151da177e4SLinus Torvalds 616918aae42SHidetoshi Seto lapic_timer_propagate_broadcast(pr); 617bd663347SAndi Kleen 6181da177e4SLinus Torvalds return (working); 6191da177e4SLinus Torvalds } 6201da177e4SLinus Torvalds 6214be44fcdSLen Brown static int acpi_processor_get_power_info(struct acpi_processor *pr) 6221da177e4SLinus Torvalds { 6231da177e4SLinus Torvalds unsigned int i; 6241da177e4SLinus Torvalds int result; 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds /* NOTE: the idle thread may not be running while calling 6281da177e4SLinus Torvalds * this function */ 6291da177e4SLinus Torvalds 630991528d7SVenkatesh Pallipadi /* Zero initialize all the C-states info. */ 631991528d7SVenkatesh Pallipadi memset(pr->power.states, 0, sizeof(pr->power.states)); 632991528d7SVenkatesh Pallipadi 6331da177e4SLinus Torvalds result = acpi_processor_get_power_info_cst(pr); 6346d93c648SVenkatesh Pallipadi if (result == -ENODEV) 635c5a114f1SDarrick J. Wong result = acpi_processor_get_power_info_fadt(pr); 6366d93c648SVenkatesh Pallipadi 637991528d7SVenkatesh Pallipadi if (result) 638991528d7SVenkatesh Pallipadi return result; 639991528d7SVenkatesh Pallipadi 640991528d7SVenkatesh Pallipadi acpi_processor_get_power_info_default(pr); 641991528d7SVenkatesh Pallipadi 642cf824788SJanosch Machowinski pr->power.count = acpi_processor_power_verify(pr); 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds /* 6451da177e4SLinus Torvalds * if one state of type C2 or C3 is available, mark this 6461da177e4SLinus Torvalds * CPU as being "idle manageable" 6471da177e4SLinus Torvalds */ 6481da177e4SLinus Torvalds for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 649acf05f4bSVenkatesh Pallipadi if (pr->power.states[i].valid) { 6501da177e4SLinus Torvalds pr->power.count = i; 6512203d6edSLinus Torvalds if (pr->power.states[i].type >= ACPI_STATE_C2) 6521da177e4SLinus Torvalds pr->flags.power = 1; 6531da177e4SLinus Torvalds } 654acf05f4bSVenkatesh Pallipadi } 6551da177e4SLinus Torvalds 656d550d98dSPatrick Mochel return 0; 6571da177e4SLinus Torvalds } 6581da177e4SLinus Torvalds 6594f86d3a8SLen Brown /** 6604f86d3a8SLen Brown * acpi_idle_bm_check - checks if bus master activity was detected 6614f86d3a8SLen Brown */ 6624f86d3a8SLen Brown static int acpi_idle_bm_check(void) 6634f86d3a8SLen Brown { 6644f86d3a8SLen Brown u32 bm_status = 0; 6654f86d3a8SLen Brown 666d3e7e99fSLen Brown if (bm_check_disable) 667d3e7e99fSLen Brown return 0; 668d3e7e99fSLen Brown 66950ffba1bSBob Moore acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status); 6704f86d3a8SLen Brown if (bm_status) 67150ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, 1); 6724f86d3a8SLen Brown /* 6734f86d3a8SLen Brown * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect 6744f86d3a8SLen Brown * the true state of bus mastering activity; forcing us to 6754f86d3a8SLen Brown * manually check the BMIDEA bit of each IDE channel. 6764f86d3a8SLen Brown */ 6774f86d3a8SLen Brown else if (errata.piix4.bmisx) { 6784f86d3a8SLen Brown if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01) 6794f86d3a8SLen Brown || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01)) 6804f86d3a8SLen Brown bm_status = 1; 6814f86d3a8SLen Brown } 6824f86d3a8SLen Brown return bm_status; 6834f86d3a8SLen Brown } 6844f86d3a8SLen Brown 6854f86d3a8SLen Brown /** 6864f86d3a8SLen Brown * acpi_idle_do_entry - a helper function that does C2 and C3 type entry 6874f86d3a8SLen Brown * @cx: cstate data 688bc71bec9Svenkatesh.pallipadi@intel.com * 689bc71bec9Svenkatesh.pallipadi@intel.com * Caller disables interrupt before call and enables interrupt after return. 6904f86d3a8SLen Brown */ 6914f86d3a8SLen Brown static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx) 6924f86d3a8SLen Brown { 693dcf30997SSteven Rostedt /* Don't trace irqs off for idle */ 694dcf30997SSteven Rostedt stop_critical_timings(); 695bc71bec9Svenkatesh.pallipadi@intel.com if (cx->entry_method == ACPI_CSTATE_FFH) { 6964f86d3a8SLen Brown /* Call into architectural FFH based C-state */ 6974f86d3a8SLen Brown acpi_processor_ffh_cstate_enter(cx); 698bc71bec9Svenkatesh.pallipadi@intel.com } else if (cx->entry_method == ACPI_CSTATE_HALT) { 699bc71bec9Svenkatesh.pallipadi@intel.com acpi_safe_halt(); 7004f86d3a8SLen Brown } else { 7014f86d3a8SLen Brown /* IO port based C-state */ 7024f86d3a8SLen Brown inb(cx->address); 7034f86d3a8SLen Brown /* Dummy wait op - must do something useless after P_LVL2 read 7044f86d3a8SLen Brown because chipsets cannot guarantee that STPCLK# signal 7054f86d3a8SLen Brown gets asserted in time to freeze execution properly. */ 706cfa806f0SAndi Kleen inl(acpi_gbl_FADT.xpm_timer_block.address); 7074f86d3a8SLen Brown } 708dcf30997SSteven Rostedt start_critical_timings(); 7094f86d3a8SLen Brown } 7104f86d3a8SLen Brown 7114f86d3a8SLen Brown /** 7124f86d3a8SLen Brown * acpi_idle_enter_c1 - enters an ACPI C1 state-type 7134f86d3a8SLen Brown * @dev: the target CPU 71446bcfad7SDeepthi Dharwar * @drv: cpuidle driver containing cpuidle state info 715e978aa7dSDeepthi Dharwar * @index: index of target state 7164f86d3a8SLen Brown * 7174f86d3a8SLen Brown * This is equivalent to the HALT instruction. 7184f86d3a8SLen Brown */ 7194f86d3a8SLen Brown static int acpi_idle_enter_c1(struct cpuidle_device *dev, 72046bcfad7SDeepthi Dharwar struct cpuidle_driver *drv, int index) 7214f86d3a8SLen Brown { 7224f86d3a8SLen Brown struct acpi_processor *pr; 7236240a10dSAlex Shi struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 7249b12e18cSvenkatesh.pallipadi@intel.com 7254a6f4fe8SChristoph Lameter pr = __this_cpu_read(processors); 7264f86d3a8SLen Brown 7274f86d3a8SLen Brown if (unlikely(!pr)) 728e978aa7dSDeepthi Dharwar return -EINVAL; 7294f86d3a8SLen Brown 730ea811747SPeter Zijlstra if (cx->entry_method == ACPI_CSTATE_FFH) { 731ea811747SPeter Zijlstra if (current_set_polling_and_test()) 732ea811747SPeter Zijlstra return -EINVAL; 733ea811747SPeter Zijlstra } 734ea811747SPeter Zijlstra 7357e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 1); 736bc71bec9Svenkatesh.pallipadi@intel.com acpi_idle_do_entry(cx); 7374f86d3a8SLen Brown 7387e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 0); 7394f86d3a8SLen Brown 740e978aa7dSDeepthi Dharwar return index; 7414f86d3a8SLen Brown } 7424f86d3a8SLen Brown 7431a022e3fSBoris Ostrovsky 7441a022e3fSBoris Ostrovsky /** 7451a022e3fSBoris Ostrovsky * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining) 7461a022e3fSBoris Ostrovsky * @dev: the target CPU 7471a022e3fSBoris Ostrovsky * @index: the index of suggested state 7481a022e3fSBoris Ostrovsky */ 7491a022e3fSBoris Ostrovsky static int acpi_idle_play_dead(struct cpuidle_device *dev, int index) 7501a022e3fSBoris Ostrovsky { 7516240a10dSAlex Shi struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 7521a022e3fSBoris Ostrovsky 7531a022e3fSBoris Ostrovsky ACPI_FLUSH_CPU_CACHE(); 7541a022e3fSBoris Ostrovsky 7551a022e3fSBoris Ostrovsky while (1) { 7561a022e3fSBoris Ostrovsky 7571a022e3fSBoris Ostrovsky if (cx->entry_method == ACPI_CSTATE_HALT) 75854f70077SLuck, Tony safe_halt(); 7591a022e3fSBoris Ostrovsky else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) { 7601a022e3fSBoris Ostrovsky inb(cx->address); 7611a022e3fSBoris Ostrovsky /* See comment in acpi_idle_do_entry() */ 7621a022e3fSBoris Ostrovsky inl(acpi_gbl_FADT.xpm_timer_block.address); 7631a022e3fSBoris Ostrovsky } else 7641a022e3fSBoris Ostrovsky return -ENODEV; 7651a022e3fSBoris Ostrovsky } 7661a022e3fSBoris Ostrovsky 7671a022e3fSBoris Ostrovsky /* Never reached */ 7681a022e3fSBoris Ostrovsky return 0; 7691a022e3fSBoris Ostrovsky } 7701a022e3fSBoris Ostrovsky 7714f86d3a8SLen Brown /** 7724f86d3a8SLen Brown * acpi_idle_enter_simple - enters an ACPI state without BM handling 7734f86d3a8SLen Brown * @dev: the target CPU 77446bcfad7SDeepthi Dharwar * @drv: cpuidle driver with cpuidle state information 775e978aa7dSDeepthi Dharwar * @index: the index of suggested state 7764f86d3a8SLen Brown */ 7774f86d3a8SLen Brown static int acpi_idle_enter_simple(struct cpuidle_device *dev, 77846bcfad7SDeepthi Dharwar struct cpuidle_driver *drv, int index) 7794f86d3a8SLen Brown { 7804f86d3a8SLen Brown struct acpi_processor *pr; 7816240a10dSAlex Shi struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 78250629118SVenkatesh Pallipadi 7834a6f4fe8SChristoph Lameter pr = __this_cpu_read(processors); 7844f86d3a8SLen Brown 7854f86d3a8SLen Brown if (unlikely(!pr)) 786e978aa7dSDeepthi Dharwar return -EINVAL; 787e196441bSLen Brown 7887ca380f6SBartlomiej Zolnierkiewicz #ifdef CONFIG_HOTPLUG_CPU 7897ca380f6SBartlomiej Zolnierkiewicz if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) && 7907ca380f6SBartlomiej Zolnierkiewicz !pr->flags.has_cst && 7917ca380f6SBartlomiej Zolnierkiewicz !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED)) 7927ca380f6SBartlomiej Zolnierkiewicz return acpi_idle_enter_c1(dev, drv, CPUIDLE_DRIVER_STATE_START); 7937ca380f6SBartlomiej Zolnierkiewicz #endif 7947ca380f6SBartlomiej Zolnierkiewicz 795ea811747SPeter Zijlstra if (cx->entry_method == ACPI_CSTATE_FFH) { 796ea811747SPeter Zijlstra if (current_set_polling_and_test()) 797e978aa7dSDeepthi Dharwar return -EINVAL; 7984f86d3a8SLen Brown } 7994f86d3a8SLen Brown 800e17bcb43SThomas Gleixner /* 801e17bcb43SThomas Gleixner * Must be done before busmaster disable as we might need to 802e17bcb43SThomas Gleixner * access HPET ! 803e17bcb43SThomas Gleixner */ 8047e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 1); 805e17bcb43SThomas Gleixner 8064f86d3a8SLen Brown if (cx->type == ACPI_STATE_C3) 8074f86d3a8SLen Brown ACPI_FLUSH_CPU_CACHE(); 8084f86d3a8SLen Brown 80950629118SVenkatesh Pallipadi /* Tell the scheduler that we are going deep-idle: */ 81050629118SVenkatesh Pallipadi sched_clock_idle_sleep_event(); 8114f86d3a8SLen Brown acpi_idle_do_entry(cx); 8124f86d3a8SLen Brown 813a474a515SJulius Werner sched_clock_idle_wakeup_event(0); 814e978aa7dSDeepthi Dharwar 8157e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 0); 816e978aa7dSDeepthi Dharwar return index; 8174f86d3a8SLen Brown } 8184f86d3a8SLen Brown 8194f86d3a8SLen Brown static int c3_cpu_count; 820e12f65f7SThomas Gleixner static DEFINE_RAW_SPINLOCK(c3_lock); 8214f86d3a8SLen Brown 8224f86d3a8SLen Brown /** 8234f86d3a8SLen Brown * acpi_idle_enter_bm - enters C3 with proper BM handling 8244f86d3a8SLen Brown * @dev: the target CPU 82546bcfad7SDeepthi Dharwar * @drv: cpuidle driver containing state data 826e978aa7dSDeepthi Dharwar * @index: the index of suggested state 8274f86d3a8SLen Brown * 8284f86d3a8SLen Brown * If BM is detected, the deepest non-C3 idle state is entered instead. 8294f86d3a8SLen Brown */ 8304f86d3a8SLen Brown static int acpi_idle_enter_bm(struct cpuidle_device *dev, 83146bcfad7SDeepthi Dharwar struct cpuidle_driver *drv, int index) 8324f86d3a8SLen Brown { 8334f86d3a8SLen Brown struct acpi_processor *pr; 8346240a10dSAlex Shi struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 83550629118SVenkatesh Pallipadi 8364a6f4fe8SChristoph Lameter pr = __this_cpu_read(processors); 8374f86d3a8SLen Brown 8384f86d3a8SLen Brown if (unlikely(!pr)) 839e978aa7dSDeepthi Dharwar return -EINVAL; 8404f86d3a8SLen Brown 8417ca380f6SBartlomiej Zolnierkiewicz #ifdef CONFIG_HOTPLUG_CPU 8427ca380f6SBartlomiej Zolnierkiewicz if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) && 8437ca380f6SBartlomiej Zolnierkiewicz !pr->flags.has_cst && 8447ca380f6SBartlomiej Zolnierkiewicz !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED)) 8457ca380f6SBartlomiej Zolnierkiewicz return acpi_idle_enter_c1(dev, drv, CPUIDLE_DRIVER_STATE_START); 8467ca380f6SBartlomiej Zolnierkiewicz #endif 8477ca380f6SBartlomiej Zolnierkiewicz 848718be4aaSLen Brown if (!cx->bm_sts_skip && acpi_idle_bm_check()) { 84946bcfad7SDeepthi Dharwar if (drv->safe_state_index >= 0) { 85046bcfad7SDeepthi Dharwar return drv->states[drv->safe_state_index].enter(dev, 85146bcfad7SDeepthi Dharwar drv, drv->safe_state_index); 852ddc081a1SVenkatesh Pallipadi } else { 853ddc081a1SVenkatesh Pallipadi acpi_safe_halt(); 85475cc5235SDeepthi Dharwar return -EBUSY; 855ddc081a1SVenkatesh Pallipadi } 856ddc081a1SVenkatesh Pallipadi } 857ddc081a1SVenkatesh Pallipadi 858ea811747SPeter Zijlstra if (cx->entry_method == ACPI_CSTATE_FFH) { 859ea811747SPeter Zijlstra if (current_set_polling_and_test()) 860e978aa7dSDeepthi Dharwar return -EINVAL; 8614f86d3a8SLen Brown } 8624f86d3a8SLen Brown 863996520c1SVenki Pallipadi acpi_unlazy_tlb(smp_processor_id()); 864996520c1SVenki Pallipadi 86550629118SVenkatesh Pallipadi /* Tell the scheduler that we are going deep-idle: */ 86650629118SVenkatesh Pallipadi sched_clock_idle_sleep_event(); 8674f86d3a8SLen Brown /* 8684f86d3a8SLen Brown * Must be done before busmaster disable as we might need to 8694f86d3a8SLen Brown * access HPET ! 8704f86d3a8SLen Brown */ 8717e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 1); 8724f86d3a8SLen Brown 873c9c860e5SVenkatesh Pallipadi /* 874c9c860e5SVenkatesh Pallipadi * disable bus master 875c9c860e5SVenkatesh Pallipadi * bm_check implies we need ARB_DIS 876c9c860e5SVenkatesh Pallipadi * !bm_check implies we need cache flush 877c9c860e5SVenkatesh Pallipadi * bm_control implies whether we can do ARB_DIS 878c9c860e5SVenkatesh Pallipadi * 879c9c860e5SVenkatesh Pallipadi * That leaves a case where bm_check is set and bm_control is 880c9c860e5SVenkatesh Pallipadi * not set. In that case we cannot do much, we enter C3 881c9c860e5SVenkatesh Pallipadi * without doing anything. 882c9c860e5SVenkatesh Pallipadi */ 883c9c860e5SVenkatesh Pallipadi if (pr->flags.bm_check && pr->flags.bm_control) { 884e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock); 8854f86d3a8SLen Brown c3_cpu_count++; 8864f86d3a8SLen Brown /* Disable bus master arbitration when all CPUs are in C3 */ 8874f86d3a8SLen Brown if (c3_cpu_count == num_online_cpus()) 88850ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1); 889e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock); 890c9c860e5SVenkatesh Pallipadi } else if (!pr->flags.bm_check) { 891c9c860e5SVenkatesh Pallipadi ACPI_FLUSH_CPU_CACHE(); 892c9c860e5SVenkatesh Pallipadi } 8934f86d3a8SLen Brown 8944f86d3a8SLen Brown acpi_idle_do_entry(cx); 8954f86d3a8SLen Brown 8964f86d3a8SLen Brown /* Re-enable bus master arbitration */ 897c9c860e5SVenkatesh Pallipadi if (pr->flags.bm_check && pr->flags.bm_control) { 898e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock); 89950ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0); 9004f86d3a8SLen Brown c3_cpu_count--; 901e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock); 9024f86d3a8SLen Brown } 9034f86d3a8SLen Brown 904a474a515SJulius Werner sched_clock_idle_wakeup_event(0); 905e978aa7dSDeepthi Dharwar 9067e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 0); 907e978aa7dSDeepthi Dharwar return index; 9084f86d3a8SLen Brown } 9094f86d3a8SLen Brown 9104f86d3a8SLen Brown struct cpuidle_driver acpi_idle_driver = { 9114f86d3a8SLen Brown .name = "acpi_idle", 9124f86d3a8SLen Brown .owner = THIS_MODULE, 9134f86d3a8SLen Brown }; 9144f86d3a8SLen Brown 9154f86d3a8SLen Brown /** 91646bcfad7SDeepthi Dharwar * acpi_processor_setup_cpuidle_cx - prepares and configures CPUIDLE 91746bcfad7SDeepthi Dharwar * device i.e. per-cpu data 91846bcfad7SDeepthi Dharwar * 9194f86d3a8SLen Brown * @pr: the ACPI processor 9206ef0f086SDaniel Lezcano * @dev : the cpuidle device 9214f86d3a8SLen Brown */ 9226ef0f086SDaniel Lezcano static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr, 9236ef0f086SDaniel Lezcano struct cpuidle_device *dev) 9244f86d3a8SLen Brown { 9259a0b8415Svenkatesh.pallipadi@intel.com int i, count = CPUIDLE_DRIVER_STATE_START; 9264f86d3a8SLen Brown struct acpi_processor_cx *cx; 9274f86d3a8SLen Brown 9284f86d3a8SLen Brown if (!pr->flags.power_setup_done) 9294f86d3a8SLen Brown return -EINVAL; 9304f86d3a8SLen Brown 9314f86d3a8SLen Brown if (pr->flags.power == 0) { 9324f86d3a8SLen Brown return -EINVAL; 9334f86d3a8SLen Brown } 9344f86d3a8SLen Brown 935b88a634aSKonrad Rzeszutek Wilk if (!dev) 936b88a634aSKonrad Rzeszutek Wilk return -EINVAL; 937b88a634aSKonrad Rzeszutek Wilk 938dcb84f33SVenkatesh Pallipadi dev->cpu = pr->id; 9394fcb2fcdSVenkatesh Pallipadi 940615dfd93SLen Brown if (max_cstate == 0) 941615dfd93SLen Brown max_cstate = 1; 942615dfd93SLen Brown 9434f86d3a8SLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 9444f86d3a8SLen Brown cx = &pr->power.states[i]; 9454f86d3a8SLen Brown 9464f86d3a8SLen Brown if (!cx->valid) 9474f86d3a8SLen Brown continue; 9484f86d3a8SLen Brown 9496240a10dSAlex Shi per_cpu(acpi_cstate[count], dev->cpu) = cx; 9504f86d3a8SLen Brown 95146bcfad7SDeepthi Dharwar count++; 95246bcfad7SDeepthi Dharwar if (count == CPUIDLE_STATE_MAX) 95346bcfad7SDeepthi Dharwar break; 95446bcfad7SDeepthi Dharwar } 95546bcfad7SDeepthi Dharwar 95646bcfad7SDeepthi Dharwar dev->state_count = count; 95746bcfad7SDeepthi Dharwar 95846bcfad7SDeepthi Dharwar if (!count) 95946bcfad7SDeepthi Dharwar return -EINVAL; 96046bcfad7SDeepthi Dharwar 96146bcfad7SDeepthi Dharwar return 0; 96246bcfad7SDeepthi Dharwar } 96346bcfad7SDeepthi Dharwar 96446bcfad7SDeepthi Dharwar /** 96546bcfad7SDeepthi Dharwar * acpi_processor_setup_cpuidle states- prepares and configures cpuidle 96646bcfad7SDeepthi Dharwar * global state data i.e. idle routines 96746bcfad7SDeepthi Dharwar * 96846bcfad7SDeepthi Dharwar * @pr: the ACPI processor 96946bcfad7SDeepthi Dharwar */ 97046bcfad7SDeepthi Dharwar static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr) 97146bcfad7SDeepthi Dharwar { 97246bcfad7SDeepthi Dharwar int i, count = CPUIDLE_DRIVER_STATE_START; 97346bcfad7SDeepthi Dharwar struct acpi_processor_cx *cx; 97446bcfad7SDeepthi Dharwar struct cpuidle_state *state; 97546bcfad7SDeepthi Dharwar struct cpuidle_driver *drv = &acpi_idle_driver; 97646bcfad7SDeepthi Dharwar 97746bcfad7SDeepthi Dharwar if (!pr->flags.power_setup_done) 97846bcfad7SDeepthi Dharwar return -EINVAL; 97946bcfad7SDeepthi Dharwar 98046bcfad7SDeepthi Dharwar if (pr->flags.power == 0) 98146bcfad7SDeepthi Dharwar return -EINVAL; 98246bcfad7SDeepthi Dharwar 98346bcfad7SDeepthi Dharwar drv->safe_state_index = -1; 98446bcfad7SDeepthi Dharwar for (i = 0; i < CPUIDLE_STATE_MAX; i++) { 98546bcfad7SDeepthi Dharwar drv->states[i].name[0] = '\0'; 98646bcfad7SDeepthi Dharwar drv->states[i].desc[0] = '\0'; 98746bcfad7SDeepthi Dharwar } 98846bcfad7SDeepthi Dharwar 98946bcfad7SDeepthi Dharwar if (max_cstate == 0) 99046bcfad7SDeepthi Dharwar max_cstate = 1; 99146bcfad7SDeepthi Dharwar 99246bcfad7SDeepthi Dharwar for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 99346bcfad7SDeepthi Dharwar cx = &pr->power.states[i]; 99446bcfad7SDeepthi Dharwar 99546bcfad7SDeepthi Dharwar if (!cx->valid) 99646bcfad7SDeepthi Dharwar continue; 99746bcfad7SDeepthi Dharwar 99846bcfad7SDeepthi Dharwar state = &drv->states[count]; 9994f86d3a8SLen Brown snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i); 10004fcb2fcdSVenkatesh Pallipadi strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); 10014f86d3a8SLen Brown state->exit_latency = cx->latency; 10024963f620SLen Brown state->target_residency = cx->latency * latency_factor; 10034f86d3a8SLen Brown 10044f86d3a8SLen Brown state->flags = 0; 10054f86d3a8SLen Brown switch (cx->type) { 10064f86d3a8SLen Brown case ACPI_STATE_C1: 10078e92b660SVenki Pallipadi if (cx->entry_method == ACPI_CSTATE_FFH) 10089b12e18cSvenkatesh.pallipadi@intel.com state->flags |= CPUIDLE_FLAG_TIME_VALID; 10098e92b660SVenki Pallipadi 10104f86d3a8SLen Brown state->enter = acpi_idle_enter_c1; 10111a022e3fSBoris Ostrovsky state->enter_dead = acpi_idle_play_dead; 101246bcfad7SDeepthi Dharwar drv->safe_state_index = count; 10134f86d3a8SLen Brown break; 10144f86d3a8SLen Brown 10154f86d3a8SLen Brown case ACPI_STATE_C2: 10164f86d3a8SLen Brown state->flags |= CPUIDLE_FLAG_TIME_VALID; 10174f86d3a8SLen Brown state->enter = acpi_idle_enter_simple; 10181a022e3fSBoris Ostrovsky state->enter_dead = acpi_idle_play_dead; 101946bcfad7SDeepthi Dharwar drv->safe_state_index = count; 10204f86d3a8SLen Brown break; 10214f86d3a8SLen Brown 10224f86d3a8SLen Brown case ACPI_STATE_C3: 10234f86d3a8SLen Brown state->flags |= CPUIDLE_FLAG_TIME_VALID; 10244f86d3a8SLen Brown state->enter = pr->flags.bm_check ? 10254f86d3a8SLen Brown acpi_idle_enter_bm : 10264f86d3a8SLen Brown acpi_idle_enter_simple; 10274f86d3a8SLen Brown break; 10284f86d3a8SLen Brown } 10294f86d3a8SLen Brown 10304f86d3a8SLen Brown count++; 10319a0b8415Svenkatesh.pallipadi@intel.com if (count == CPUIDLE_STATE_MAX) 10329a0b8415Svenkatesh.pallipadi@intel.com break; 10334f86d3a8SLen Brown } 10344f86d3a8SLen Brown 103546bcfad7SDeepthi Dharwar drv->state_count = count; 10364f86d3a8SLen Brown 10374f86d3a8SLen Brown if (!count) 10384f86d3a8SLen Brown return -EINVAL; 10394f86d3a8SLen Brown 10404f86d3a8SLen Brown return 0; 10414f86d3a8SLen Brown } 10424f86d3a8SLen Brown 104346bcfad7SDeepthi Dharwar int acpi_processor_hotplug(struct acpi_processor *pr) 10444f86d3a8SLen Brown { 1045dcb84f33SVenkatesh Pallipadi int ret = 0; 1046e8b1b59dSWei Yongjun struct cpuidle_device *dev; 10474f86d3a8SLen Brown 1048d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 104936a91358SVenkatesh Pallipadi return 0; 105036a91358SVenkatesh Pallipadi 1051bf9b59f2SBartlomiej Zolnierkiewicz if (nocst) 10524f86d3a8SLen Brown return -ENODEV; 10534f86d3a8SLen Brown 10544f86d3a8SLen Brown if (!pr->flags.power_setup_done) 10554f86d3a8SLen Brown return -ENODEV; 10564f86d3a8SLen Brown 1057e8b1b59dSWei Yongjun dev = per_cpu(acpi_cpuidle_device, pr->id); 10584f86d3a8SLen Brown cpuidle_pause_and_lock(); 10593d339dcbSDaniel Lezcano cpuidle_disable_device(dev); 10604f86d3a8SLen Brown acpi_processor_get_power_info(pr); 1061dcb84f33SVenkatesh Pallipadi if (pr->flags.power) { 10626ef0f086SDaniel Lezcano acpi_processor_setup_cpuidle_cx(pr, dev); 10633d339dcbSDaniel Lezcano ret = cpuidle_enable_device(dev); 1064dcb84f33SVenkatesh Pallipadi } 10654f86d3a8SLen Brown cpuidle_resume_and_unlock(); 10664f86d3a8SLen Brown 10674f86d3a8SLen Brown return ret; 10684f86d3a8SLen Brown } 10694f86d3a8SLen Brown 107046bcfad7SDeepthi Dharwar int acpi_processor_cst_has_changed(struct acpi_processor *pr) 107146bcfad7SDeepthi Dharwar { 107246bcfad7SDeepthi Dharwar int cpu; 107346bcfad7SDeepthi Dharwar struct acpi_processor *_pr; 10743d339dcbSDaniel Lezcano struct cpuidle_device *dev; 107546bcfad7SDeepthi Dharwar 107646bcfad7SDeepthi Dharwar if (disabled_by_idle_boot_param()) 107746bcfad7SDeepthi Dharwar return 0; 107846bcfad7SDeepthi Dharwar 107946bcfad7SDeepthi Dharwar if (nocst) 108046bcfad7SDeepthi Dharwar return -ENODEV; 108146bcfad7SDeepthi Dharwar 108246bcfad7SDeepthi Dharwar if (!pr->flags.power_setup_done) 108346bcfad7SDeepthi Dharwar return -ENODEV; 108446bcfad7SDeepthi Dharwar 108546bcfad7SDeepthi Dharwar /* 108646bcfad7SDeepthi Dharwar * FIXME: Design the ACPI notification to make it once per 108746bcfad7SDeepthi Dharwar * system instead of once per-cpu. This condition is a hack 108846bcfad7SDeepthi Dharwar * to make the code that updates C-States be called once. 108946bcfad7SDeepthi Dharwar */ 109046bcfad7SDeepthi Dharwar 10919505626dSPaul E. McKenney if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) { 109246bcfad7SDeepthi Dharwar 109346bcfad7SDeepthi Dharwar cpuidle_pause_and_lock(); 109446bcfad7SDeepthi Dharwar /* Protect against cpu-hotplug */ 109546bcfad7SDeepthi Dharwar get_online_cpus(); 109646bcfad7SDeepthi Dharwar 109746bcfad7SDeepthi Dharwar /* Disable all cpuidle devices */ 109846bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) { 109946bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu); 110046bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done) 110146bcfad7SDeepthi Dharwar continue; 11023d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu); 11033d339dcbSDaniel Lezcano cpuidle_disable_device(dev); 110446bcfad7SDeepthi Dharwar } 110546bcfad7SDeepthi Dharwar 110646bcfad7SDeepthi Dharwar /* Populate Updated C-state information */ 1107f427e5f1SThomas Schlichter acpi_processor_get_power_info(pr); 110846bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr); 110946bcfad7SDeepthi Dharwar 111046bcfad7SDeepthi Dharwar /* Enable all cpuidle devices */ 111146bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) { 111246bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu); 111346bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done) 111446bcfad7SDeepthi Dharwar continue; 111546bcfad7SDeepthi Dharwar acpi_processor_get_power_info(_pr); 111646bcfad7SDeepthi Dharwar if (_pr->flags.power) { 11173d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu); 11186ef0f086SDaniel Lezcano acpi_processor_setup_cpuidle_cx(_pr, dev); 11193d339dcbSDaniel Lezcano cpuidle_enable_device(dev); 112046bcfad7SDeepthi Dharwar } 112146bcfad7SDeepthi Dharwar } 112246bcfad7SDeepthi Dharwar put_online_cpus(); 112346bcfad7SDeepthi Dharwar cpuidle_resume_and_unlock(); 112446bcfad7SDeepthi Dharwar } 112546bcfad7SDeepthi Dharwar 112646bcfad7SDeepthi Dharwar return 0; 112746bcfad7SDeepthi Dharwar } 112846bcfad7SDeepthi Dharwar 112946bcfad7SDeepthi Dharwar static int acpi_processor_registered; 113046bcfad7SDeepthi Dharwar 1131fe7bf106SPaul Gortmaker int acpi_processor_power_init(struct acpi_processor *pr) 11321da177e4SLinus Torvalds { 11331da177e4SLinus Torvalds acpi_status status = 0; 113446bcfad7SDeepthi Dharwar int retval; 11353d339dcbSDaniel Lezcano struct cpuidle_device *dev; 1136b6835052SAndreas Mohr static int first_run; 11371da177e4SLinus Torvalds 1138d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 113936a91358SVenkatesh Pallipadi return 0; 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds if (!first_run) { 11421da177e4SLinus Torvalds dmi_check_system(processor_power_dmi_table); 1143c1c30634SAlexey Starikovskiy max_cstate = acpi_processor_cstate_check(max_cstate); 11441da177e4SLinus Torvalds if (max_cstate < ACPI_C_STATES_MAX) 11454be44fcdSLen Brown printk(KERN_NOTICE 11464be44fcdSLen Brown "ACPI: processor limited to max C-state %d\n", 11474be44fcdSLen Brown max_cstate); 11481da177e4SLinus Torvalds first_run++; 11491da177e4SLinus Torvalds } 11501da177e4SLinus Torvalds 1151cee324b1SAlexey Starikovskiy if (acpi_gbl_FADT.cst_control && !nocst) { 11524be44fcdSLen Brown status = 1153cee324b1SAlexey Starikovskiy acpi_os_write_port(acpi_gbl_FADT.smi_command, acpi_gbl_FADT.cst_control, 8); 11541da177e4SLinus Torvalds if (ACPI_FAILURE(status)) { 1155a6fc6720SThomas Renninger ACPI_EXCEPTION((AE_INFO, status, 1156a6fc6720SThomas Renninger "Notifying BIOS of _CST ability failed")); 11571da177e4SLinus Torvalds } 11581da177e4SLinus Torvalds } 11591da177e4SLinus Torvalds 11601da177e4SLinus Torvalds acpi_processor_get_power_info(pr); 11614f86d3a8SLen Brown pr->flags.power_setup_done = 1; 11621da177e4SLinus Torvalds 11631da177e4SLinus Torvalds /* 11641da177e4SLinus Torvalds * Install the idle handler if processor power management is supported. 11651da177e4SLinus Torvalds * Note that we use previously set idle handler will be used on 11661da177e4SLinus Torvalds * platforms that only support C1. 11671da177e4SLinus Torvalds */ 116836a91358SVenkatesh Pallipadi if (pr->flags.power) { 116946bcfad7SDeepthi Dharwar /* Register acpi_idle_driver if not already registered */ 117046bcfad7SDeepthi Dharwar if (!acpi_processor_registered) { 117146bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr); 117246bcfad7SDeepthi Dharwar retval = cpuidle_register_driver(&acpi_idle_driver); 117346bcfad7SDeepthi Dharwar if (retval) 117446bcfad7SDeepthi Dharwar return retval; 117546bcfad7SDeepthi Dharwar printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n", 117646bcfad7SDeepthi Dharwar acpi_idle_driver.name); 117746bcfad7SDeepthi Dharwar } 11783d339dcbSDaniel Lezcano 11793d339dcbSDaniel Lezcano dev = kzalloc(sizeof(*dev), GFP_KERNEL); 11803d339dcbSDaniel Lezcano if (!dev) 11813d339dcbSDaniel Lezcano return -ENOMEM; 11823d339dcbSDaniel Lezcano per_cpu(acpi_cpuidle_device, pr->id) = dev; 11833d339dcbSDaniel Lezcano 11846ef0f086SDaniel Lezcano acpi_processor_setup_cpuidle_cx(pr, dev); 11853d339dcbSDaniel Lezcano 118646bcfad7SDeepthi Dharwar /* Register per-cpu cpuidle_device. Cpuidle driver 118746bcfad7SDeepthi Dharwar * must already be registered before registering device 118846bcfad7SDeepthi Dharwar */ 11893d339dcbSDaniel Lezcano retval = cpuidle_register_device(dev); 119046bcfad7SDeepthi Dharwar if (retval) { 119146bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0) 119246bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver); 119346bcfad7SDeepthi Dharwar return retval; 119446bcfad7SDeepthi Dharwar } 119546bcfad7SDeepthi Dharwar acpi_processor_registered++; 11961da177e4SLinus Torvalds } 1197d550d98dSPatrick Mochel return 0; 11981da177e4SLinus Torvalds } 11991da177e4SLinus Torvalds 120038a991b6SDaniel Lezcano int acpi_processor_power_exit(struct acpi_processor *pr) 12011da177e4SLinus Torvalds { 12023d339dcbSDaniel Lezcano struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id); 12033d339dcbSDaniel Lezcano 1204d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 120536a91358SVenkatesh Pallipadi return 0; 120636a91358SVenkatesh Pallipadi 120746bcfad7SDeepthi Dharwar if (pr->flags.power) { 12083d339dcbSDaniel Lezcano cpuidle_unregister_device(dev); 120946bcfad7SDeepthi Dharwar acpi_processor_registered--; 121046bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0) 121146bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver); 121246bcfad7SDeepthi Dharwar } 12131da177e4SLinus Torvalds 121446bcfad7SDeepthi Dharwar pr->flags.power_setup_done = 0; 1215d550d98dSPatrick Mochel return 0; 12161da177e4SLinus Torvalds } 1217