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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 251da177e4SLinus Torvalds */ 26b6ec26fbSSudeep Holla #define pr_fmt(fmt) "ACPI: " fmt 271da177e4SLinus Torvalds 281da177e4SLinus Torvalds #include <linux/module.h> 291da177e4SLinus Torvalds #include <linux/acpi.h> 301da177e4SLinus Torvalds #include <linux/dmi.h> 314e57b681STim Schmielau #include <linux/sched.h> /* need_resched() */ 32ee41eebfSThomas Gleixner #include <linux/tick.h> 334f86d3a8SLen Brown #include <linux/cpuidle.h> 348b48463fSLv Zheng #include <acpi/processor.h> 351da177e4SLinus Torvalds 363434933bSThomas Gleixner /* 373434933bSThomas Gleixner * Include the apic definitions for x86 to have the APIC timer related defines 383434933bSThomas Gleixner * available also for UP (on SMP it gets magically included via linux/smp.h). 393434933bSThomas Gleixner * asm/acpi.h is not an option, as it would require more include magic. Also 403434933bSThomas Gleixner * creating an empty asm-ia64/apic.h would just trade pest vs. cholera. 413434933bSThomas Gleixner */ 423434933bSThomas Gleixner #ifdef CONFIG_X86 433434933bSThomas Gleixner #include <asm/apic.h> 443434933bSThomas Gleixner #endif 453434933bSThomas Gleixner 461da177e4SLinus Torvalds #define ACPI_PROCESSOR_CLASS "processor" 471da177e4SLinus Torvalds #define _COMPONENT ACPI_PROCESSOR_COMPONENT 48f52fd66dSLen Brown ACPI_MODULE_NAME("processor_idle"); 491da177e4SLinus Torvalds 504f86d3a8SLen Brown static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER; 514f86d3a8SLen Brown module_param(max_cstate, uint, 0000); 52b6835052SAndreas Mohr static unsigned int nocst __read_mostly; 531da177e4SLinus Torvalds module_param(nocst, uint, 0000); 54d3e7e99fSLen Brown static int bm_check_disable __read_mostly; 55d3e7e99fSLen Brown module_param(bm_check_disable, uint, 0000); 561da177e4SLinus Torvalds 5725de5718SLen Brown static unsigned int latency_factor __read_mostly = 2; 584963f620SLen Brown module_param(latency_factor, uint, 0644); 591da177e4SLinus Torvalds 603d339dcbSDaniel Lezcano static DEFINE_PER_CPU(struct cpuidle_device *, acpi_cpuidle_device); 613d339dcbSDaniel Lezcano 6235ae7133SSudeep Holla struct cpuidle_driver acpi_idle_driver = { 6335ae7133SSudeep Holla .name = "acpi_idle", 6435ae7133SSudeep Holla .owner = THIS_MODULE, 6535ae7133SSudeep Holla }; 6635ae7133SSudeep Holla 6735ae7133SSudeep Holla #ifdef CONFIG_ACPI_PROCESSOR_CSTATE 6825528213SPeter Zijlstra static 6925528213SPeter Zijlstra DEFINE_PER_CPU(struct acpi_processor_cx * [CPUIDLE_STATE_MAX], acpi_cstate); 70ac3ebafaSDaniel Lezcano 71d1896049SThomas Renninger static int disabled_by_idle_boot_param(void) 72d1896049SThomas Renninger { 73d1896049SThomas Renninger return boot_option_idle_override == IDLE_POLL || 74d1896049SThomas Renninger boot_option_idle_override == IDLE_HALT; 75d1896049SThomas Renninger } 76d1896049SThomas Renninger 771da177e4SLinus Torvalds /* 781da177e4SLinus Torvalds * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3. 791da177e4SLinus Torvalds * For now disable this. Probably a bug somewhere else. 801da177e4SLinus Torvalds * 811da177e4SLinus Torvalds * To skip this limit, boot/load with a large max_cstate limit. 821da177e4SLinus Torvalds */ 831855256cSJeff Garzik static int set_max_cstate(const struct dmi_system_id *id) 841da177e4SLinus Torvalds { 851da177e4SLinus Torvalds if (max_cstate > ACPI_PROCESSOR_MAX_POWER) 861da177e4SLinus Torvalds return 0; 871da177e4SLinus Torvalds 88b6ec26fbSSudeep Holla pr_notice("%s detected - limiting to C%ld max_cstate." 891da177e4SLinus Torvalds " Override with \"processor.max_cstate=%d\"\n", id->ident, 903d35600aSLen Brown (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1); 911da177e4SLinus Torvalds 923d35600aSLen Brown max_cstate = (long)id->driver_data; 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds return 0; 951da177e4SLinus Torvalds } 961da177e4SLinus Torvalds 97b0346688SMathias Krause static const struct dmi_system_id processor_power_dmi_table[] = { 98335f16beSDavid Shaohua Li { set_max_cstate, "Clevo 5600D", { 99876c184bSThomas Rosner DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"), 100876c184bSThomas Rosner DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")}, 101335f16beSDavid Shaohua Li (void *)2}, 102370d5cd8SArjan van de Ven { set_max_cstate, "Pavilion zv5000", { 103370d5cd8SArjan van de Ven DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 104370d5cd8SArjan van de Ven DMI_MATCH(DMI_PRODUCT_NAME,"Pavilion zv5000 (DS502A#ABA)")}, 105370d5cd8SArjan van de Ven (void *)1}, 106370d5cd8SArjan van de Ven { set_max_cstate, "Asus L8400B", { 107370d5cd8SArjan van de Ven DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."), 108370d5cd8SArjan van de Ven DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")}, 109370d5cd8SArjan van de Ven (void *)1}, 1101da177e4SLinus Torvalds {}, 1111da177e4SLinus Torvalds }; 1121da177e4SLinus Torvalds 1134f86d3a8SLen Brown 1142e906655Svenkatesh.pallipadi@intel.com /* 1152e906655Svenkatesh.pallipadi@intel.com * Callers should disable interrupts before the call and enable 1162e906655Svenkatesh.pallipadi@intel.com * interrupts after return. 1172e906655Svenkatesh.pallipadi@intel.com */ 118ddc081a1SVenkatesh Pallipadi static void acpi_safe_halt(void) 119ddc081a1SVenkatesh Pallipadi { 120ea811747SPeter Zijlstra if (!tif_need_resched()) { 121ddc081a1SVenkatesh Pallipadi safe_halt(); 12271e93d15SVenki Pallipadi local_irq_disable(); 12371e93d15SVenki Pallipadi } 124ddc081a1SVenkatesh Pallipadi } 125ddc081a1SVenkatesh Pallipadi 126169a0abbSThomas Gleixner #ifdef ARCH_APICTIMER_STOPS_ON_C3 127169a0abbSThomas Gleixner 128169a0abbSThomas Gleixner /* 129169a0abbSThomas Gleixner * Some BIOS implementations switch to C3 in the published C2 state. 130296d93cdSLinus Torvalds * This seems to be a common problem on AMD boxen, but other vendors 131296d93cdSLinus Torvalds * are affected too. We pick the most conservative approach: we assume 132296d93cdSLinus Torvalds * that the local APIC stops in both C2 and C3. 133169a0abbSThomas Gleixner */ 1347e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr, 135169a0abbSThomas Gleixner struct acpi_processor_cx *cx) 136169a0abbSThomas Gleixner { 137169a0abbSThomas Gleixner struct acpi_processor_power *pwr = &pr->power; 138e585bef8SThomas Gleixner u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2; 139169a0abbSThomas Gleixner 140db954b58SVenkatesh Pallipadi if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT)) 141db954b58SVenkatesh Pallipadi return; 142db954b58SVenkatesh Pallipadi 14302c68a02SLen Brown if (amd_e400_c1e_detected) 14487ad57baSShaohua Li type = ACPI_STATE_C1; 14587ad57baSShaohua Li 146169a0abbSThomas Gleixner /* 147169a0abbSThomas Gleixner * Check, if one of the previous states already marked the lapic 148169a0abbSThomas Gleixner * unstable 149169a0abbSThomas Gleixner */ 150169a0abbSThomas Gleixner if (pwr->timer_broadcast_on_state < state) 151169a0abbSThomas Gleixner return; 152169a0abbSThomas Gleixner 153e585bef8SThomas Gleixner if (cx->type >= type) 154169a0abbSThomas Gleixner pr->power.timer_broadcast_on_state = state; 155169a0abbSThomas Gleixner } 156169a0abbSThomas Gleixner 157918aae42SHidetoshi Seto static void __lapic_timer_propagate_broadcast(void *arg) 158169a0abbSThomas Gleixner { 159f833bab8SSuresh Siddha struct acpi_processor *pr = (struct acpi_processor *) arg; 160e9e2cdb4SThomas Gleixner 161ee41eebfSThomas Gleixner if (pr->power.timer_broadcast_on_state < INT_MAX) 162ee41eebfSThomas Gleixner tick_broadcast_enable(); 163ee41eebfSThomas Gleixner else 164ee41eebfSThomas Gleixner tick_broadcast_disable(); 165e9e2cdb4SThomas Gleixner } 166e9e2cdb4SThomas Gleixner 167918aae42SHidetoshi Seto static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) 168918aae42SHidetoshi Seto { 169918aae42SHidetoshi Seto smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast, 170918aae42SHidetoshi Seto (void *)pr, 1); 171918aae42SHidetoshi Seto } 172918aae42SHidetoshi Seto 173e9e2cdb4SThomas Gleixner /* Power(C) State timer broadcast control */ 1747e275cc4SLen Brown static void lapic_timer_state_broadcast(struct acpi_processor *pr, 175e9e2cdb4SThomas Gleixner struct acpi_processor_cx *cx, 176e9e2cdb4SThomas Gleixner int broadcast) 177e9e2cdb4SThomas Gleixner { 178e9e2cdb4SThomas Gleixner int state = cx - pr->power.states; 179e9e2cdb4SThomas Gleixner 180e9e2cdb4SThomas Gleixner if (state >= pr->power.timer_broadcast_on_state) { 1817815701cSThomas Gleixner if (broadcast) 1827815701cSThomas Gleixner tick_broadcast_enter(); 1837815701cSThomas Gleixner else 1847815701cSThomas Gleixner tick_broadcast_exit(); 185e9e2cdb4SThomas Gleixner } 186169a0abbSThomas Gleixner } 187169a0abbSThomas Gleixner 188169a0abbSThomas Gleixner #else 189169a0abbSThomas Gleixner 1907e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr, 191169a0abbSThomas Gleixner struct acpi_processor_cx *cstate) { } 1927e275cc4SLen Brown static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { } 1937e275cc4SLen Brown static void lapic_timer_state_broadcast(struct acpi_processor *pr, 194e9e2cdb4SThomas Gleixner struct acpi_processor_cx *cx, 195e9e2cdb4SThomas Gleixner int broadcast) 196e9e2cdb4SThomas Gleixner { 197e9e2cdb4SThomas Gleixner } 198169a0abbSThomas Gleixner 199169a0abbSThomas Gleixner #endif 200169a0abbSThomas Gleixner 201592913ecSJohn Stultz #if defined(CONFIG_X86) 202520daf72SLen Brown static void tsc_check_state(int state) 203ddb25f9aSAndi Kleen { 204ddb25f9aSAndi Kleen switch (boot_cpu_data.x86_vendor) { 205ddb25f9aSAndi Kleen case X86_VENDOR_AMD: 20640fb1715SVenki Pallipadi case X86_VENDOR_INTEL: 207ddb25f9aSAndi Kleen /* 208ddb25f9aSAndi Kleen * AMD Fam10h TSC will tick in all 209ddb25f9aSAndi Kleen * C/P/S0/S1 states when this bit is set. 210ddb25f9aSAndi Kleen */ 21140fb1715SVenki Pallipadi if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC)) 212520daf72SLen Brown return; 21340fb1715SVenki Pallipadi 214ddb25f9aSAndi Kleen /*FALL THROUGH*/ 215ddb25f9aSAndi Kleen default: 216520daf72SLen Brown /* TSC could halt in idle, so notify users */ 217520daf72SLen Brown if (state > ACPI_STATE_C1) 218520daf72SLen Brown mark_tsc_unstable("TSC halts in idle"); 219ddb25f9aSAndi Kleen } 220ddb25f9aSAndi Kleen } 221520daf72SLen Brown #else 222520daf72SLen Brown static void tsc_check_state(int state) { return; } 223ddb25f9aSAndi Kleen #endif 224ddb25f9aSAndi Kleen 2251da177e4SLinus Torvalds static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr) 2261da177e4SLinus Torvalds { 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds if (!pr->pblk) 229d550d98dSPatrick Mochel return -ENODEV; 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds /* if info is obtained from pblk/fadt, type equals state */ 2321da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; 2331da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; 2341da177e4SLinus Torvalds 2354c033552SVenkatesh Pallipadi #ifndef CONFIG_HOTPLUG_CPU 2364c033552SVenkatesh Pallipadi /* 2374c033552SVenkatesh Pallipadi * Check for P_LVL2_UP flag before entering C2 and above on 2384c033552SVenkatesh Pallipadi * an SMP system. 2394c033552SVenkatesh Pallipadi */ 240ad71860aSAlexey Starikovskiy if ((num_online_cpus() > 1) && 241cee324b1SAlexey Starikovskiy !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED)) 242d550d98dSPatrick Mochel return -ENODEV; 2434c033552SVenkatesh Pallipadi #endif 2444c033552SVenkatesh Pallipadi 2451da177e4SLinus Torvalds /* determine C2 and C3 address from pblk */ 2461da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4; 2471da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5; 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds /* determine latencies from FADT */ 250ba494beeSBob Moore pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency; 251ba494beeSBob Moore pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency; 2521da177e4SLinus Torvalds 2535d76b6f6SLen Brown /* 2545d76b6f6SLen Brown * FADT specified C2 latency must be less than or equal to 2555d76b6f6SLen Brown * 100 microseconds. 2565d76b6f6SLen Brown */ 257ba494beeSBob Moore if (acpi_gbl_FADT.c2_latency > ACPI_PROCESSOR_MAX_C2_LATENCY) { 2585d76b6f6SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_INFO, 259ba494beeSBob Moore "C2 latency too large [%d]\n", acpi_gbl_FADT.c2_latency)); 2605d76b6f6SLen Brown /* invalidate C2 */ 2615d76b6f6SLen Brown pr->power.states[ACPI_STATE_C2].address = 0; 2625d76b6f6SLen Brown } 2635d76b6f6SLen Brown 264a6d72c18SLen Brown /* 265a6d72c18SLen Brown * FADT supplied C3 latency must be less than or equal to 266a6d72c18SLen Brown * 1000 microseconds. 267a6d72c18SLen Brown */ 268ba494beeSBob Moore if (acpi_gbl_FADT.c3_latency > ACPI_PROCESSOR_MAX_C3_LATENCY) { 269a6d72c18SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_INFO, 270ba494beeSBob Moore "C3 latency too large [%d]\n", acpi_gbl_FADT.c3_latency)); 271a6d72c18SLen Brown /* invalidate C3 */ 272a6d72c18SLen Brown pr->power.states[ACPI_STATE_C3].address = 0; 273a6d72c18SLen Brown } 274a6d72c18SLen Brown 2751da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, 2761da177e4SLinus Torvalds "lvl2[0x%08x] lvl3[0x%08x]\n", 2771da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].address, 2781da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].address)); 2791da177e4SLinus Torvalds 280d550d98dSPatrick Mochel return 0; 2811da177e4SLinus Torvalds } 2821da177e4SLinus Torvalds 283991528d7SVenkatesh Pallipadi static int acpi_processor_get_power_info_default(struct acpi_processor *pr) 284acf05f4bSVenkatesh Pallipadi { 285991528d7SVenkatesh Pallipadi if (!pr->power.states[ACPI_STATE_C1].valid) { 286cf824788SJanosch Machowinski /* set the first C-State to C1 */ 287991528d7SVenkatesh Pallipadi /* all processors need to support C1 */ 288acf05f4bSVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; 289acf05f4bSVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].valid = 1; 2900fda6b40SVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT; 291991528d7SVenkatesh Pallipadi } 292991528d7SVenkatesh Pallipadi /* the C0 state only exists as a filler in our array */ 293991528d7SVenkatesh Pallipadi pr->power.states[ACPI_STATE_C0].valid = 1; 294d550d98dSPatrick Mochel return 0; 295acf05f4bSVenkatesh Pallipadi } 296acf05f4bSVenkatesh Pallipadi 2971da177e4SLinus Torvalds static int acpi_processor_get_power_info_cst(struct acpi_processor *pr) 2981da177e4SLinus Torvalds { 2996fd8050aSSudeep Holla acpi_status status; 300439913ffSLin Ming u64 count; 301cf824788SJanosch Machowinski int current_count; 3026fd8050aSSudeep Holla int i, ret = 0; 3031da177e4SLinus Torvalds struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 3041da177e4SLinus Torvalds union acpi_object *cst; 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds 3071da177e4SLinus Torvalds if (nocst) 308d550d98dSPatrick Mochel return -ENODEV; 3091da177e4SLinus Torvalds 310991528d7SVenkatesh Pallipadi current_count = 0; 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer); 3131da177e4SLinus Torvalds if (ACPI_FAILURE(status)) { 3141da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n")); 315d550d98dSPatrick Mochel return -ENODEV; 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds 31850dd0969SJan Engelhardt cst = buffer.pointer; 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds /* There must be at least 2 elements */ 3211da177e4SLinus Torvalds if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) { 322b6ec26fbSSudeep Holla pr_err("not enough elements in _CST\n"); 3236fd8050aSSudeep Holla ret = -EFAULT; 3241da177e4SLinus Torvalds goto end; 3251da177e4SLinus Torvalds } 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds count = cst->package.elements[0].integer.value; 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds /* Validate number of power states. */ 3301da177e4SLinus Torvalds if (count < 1 || count != cst->package.count - 1) { 331b6ec26fbSSudeep Holla pr_err("count given by _CST is not valid\n"); 3326fd8050aSSudeep Holla ret = -EFAULT; 3331da177e4SLinus Torvalds goto end; 3341da177e4SLinus Torvalds } 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds /* Tell driver that at least _CST is supported. */ 3371da177e4SLinus Torvalds pr->flags.has_cst = 1; 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds for (i = 1; i <= count; i++) { 3401da177e4SLinus Torvalds union acpi_object *element; 3411da177e4SLinus Torvalds union acpi_object *obj; 3421da177e4SLinus Torvalds struct acpi_power_register *reg; 3431da177e4SLinus Torvalds struct acpi_processor_cx cx; 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds memset(&cx, 0, sizeof(cx)); 3461da177e4SLinus Torvalds 34750dd0969SJan Engelhardt element = &(cst->package.elements[i]); 3481da177e4SLinus Torvalds if (element->type != ACPI_TYPE_PACKAGE) 3491da177e4SLinus Torvalds continue; 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds if (element->package.count != 4) 3521da177e4SLinus Torvalds continue; 3531da177e4SLinus Torvalds 35450dd0969SJan Engelhardt obj = &(element->package.elements[0]); 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_BUFFER) 3571da177e4SLinus Torvalds continue; 3581da177e4SLinus Torvalds 3591da177e4SLinus Torvalds reg = (struct acpi_power_register *)obj->buffer.pointer; 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && 3621da177e4SLinus Torvalds (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) 3631da177e4SLinus Torvalds continue; 3641da177e4SLinus Torvalds 3651da177e4SLinus Torvalds /* There should be an easy way to extract an integer... */ 36650dd0969SJan Engelhardt obj = &(element->package.elements[1]); 3671da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 3681da177e4SLinus Torvalds continue; 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds cx.type = obj->integer.value; 371991528d7SVenkatesh Pallipadi /* 372991528d7SVenkatesh Pallipadi * Some buggy BIOSes won't list C1 in _CST - 373991528d7SVenkatesh Pallipadi * Let acpi_processor_get_power_info_default() handle them later 374991528d7SVenkatesh Pallipadi */ 375991528d7SVenkatesh Pallipadi if (i == 1 && cx.type != ACPI_STATE_C1) 376991528d7SVenkatesh Pallipadi current_count++; 3771da177e4SLinus Torvalds 378991528d7SVenkatesh Pallipadi cx.address = reg->address; 379991528d7SVenkatesh Pallipadi cx.index = current_count + 1; 3801da177e4SLinus Torvalds 381bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_SYSTEMIO; 382991528d7SVenkatesh Pallipadi if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { 383991528d7SVenkatesh Pallipadi if (acpi_processor_ffh_cstate_probe 384991528d7SVenkatesh Pallipadi (pr->id, &cx, reg) == 0) { 385bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_FFH; 386bc71bec9Svenkatesh.pallipadi@intel.com } else if (cx.type == ACPI_STATE_C1) { 387991528d7SVenkatesh Pallipadi /* 388991528d7SVenkatesh Pallipadi * C1 is a special case where FIXED_HARDWARE 389991528d7SVenkatesh Pallipadi * can be handled in non-MWAIT way as well. 390991528d7SVenkatesh Pallipadi * In that case, save this _CST entry info. 391991528d7SVenkatesh Pallipadi * Otherwise, ignore this info and continue. 392991528d7SVenkatesh Pallipadi */ 393bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_HALT; 3944fcb2fcdSVenkatesh Pallipadi snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 395bc71bec9Svenkatesh.pallipadi@intel.com } else { 3961da177e4SLinus Torvalds continue; 397991528d7SVenkatesh Pallipadi } 398da5e09a1SZhao Yakui if (cx.type == ACPI_STATE_C1 && 399d1896049SThomas Renninger (boot_option_idle_override == IDLE_NOMWAIT)) { 400c1e3b377SZhao Yakui /* 401c1e3b377SZhao Yakui * In most cases the C1 space_id obtained from 402c1e3b377SZhao Yakui * _CST object is FIXED_HARDWARE access mode. 403c1e3b377SZhao Yakui * But when the option of idle=halt is added, 404c1e3b377SZhao Yakui * the entry_method type should be changed from 405c1e3b377SZhao Yakui * CSTATE_FFH to CSTATE_HALT. 406da5e09a1SZhao Yakui * When the option of idle=nomwait is added, 407da5e09a1SZhao Yakui * the C1 entry_method type should be 408da5e09a1SZhao Yakui * CSTATE_HALT. 409c1e3b377SZhao Yakui */ 410c1e3b377SZhao Yakui cx.entry_method = ACPI_CSTATE_HALT; 411c1e3b377SZhao Yakui snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 412c1e3b377SZhao Yakui } 4134fcb2fcdSVenkatesh Pallipadi } else { 4144fcb2fcdSVenkatesh Pallipadi snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x", 4154fcb2fcdSVenkatesh Pallipadi cx.address); 416991528d7SVenkatesh Pallipadi } 4171da177e4SLinus Torvalds 4180fda6b40SVenkatesh Pallipadi if (cx.type == ACPI_STATE_C1) { 4190fda6b40SVenkatesh Pallipadi cx.valid = 1; 4200fda6b40SVenkatesh Pallipadi } 4214fcb2fcdSVenkatesh Pallipadi 42250dd0969SJan Engelhardt obj = &(element->package.elements[2]); 4231da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 4241da177e4SLinus Torvalds continue; 4251da177e4SLinus Torvalds 4261da177e4SLinus Torvalds cx.latency = obj->integer.value; 4271da177e4SLinus Torvalds 42850dd0969SJan Engelhardt obj = &(element->package.elements[3]); 4291da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 4301da177e4SLinus Torvalds continue; 4311da177e4SLinus Torvalds 432cf824788SJanosch Machowinski current_count++; 433cf824788SJanosch Machowinski memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx)); 434cf824788SJanosch Machowinski 435cf824788SJanosch Machowinski /* 436cf824788SJanosch Machowinski * We support total ACPI_PROCESSOR_MAX_POWER - 1 437cf824788SJanosch Machowinski * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1) 438cf824788SJanosch Machowinski */ 439cf824788SJanosch Machowinski if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) { 440b6ec26fbSSudeep Holla pr_warn("Limiting number of power states to max (%d)\n", 441cf824788SJanosch Machowinski ACPI_PROCESSOR_MAX_POWER); 442b6ec26fbSSudeep Holla pr_warn("Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n"); 443cf824788SJanosch Machowinski break; 444cf824788SJanosch Machowinski } 4451da177e4SLinus Torvalds } 4461da177e4SLinus Torvalds 4474be44fcdSLen Brown ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n", 448cf824788SJanosch Machowinski current_count)); 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds /* Validate number of power states discovered */ 451cf824788SJanosch Machowinski if (current_count < 2) 4526fd8050aSSudeep Holla ret = -EFAULT; 4531da177e4SLinus Torvalds 4541da177e4SLinus Torvalds end: 45502438d87SLen Brown kfree(buffer.pointer); 4561da177e4SLinus Torvalds 4576fd8050aSSudeep Holla return ret; 4581da177e4SLinus Torvalds } 4591da177e4SLinus Torvalds 4604be44fcdSLen Brown static void acpi_processor_power_verify_c3(struct acpi_processor *pr, 4611da177e4SLinus Torvalds struct acpi_processor_cx *cx) 4621da177e4SLinus Torvalds { 463ee1ca48fSPallipadi, Venkatesh static int bm_check_flag = -1; 464ee1ca48fSPallipadi, Venkatesh static int bm_control_flag = -1; 46502df8b93SVenkatesh Pallipadi 4661da177e4SLinus Torvalds 4671da177e4SLinus Torvalds if (!cx->address) 468d550d98dSPatrick Mochel return; 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds /* 4711da177e4SLinus Torvalds * PIIX4 Erratum #18: We don't support C3 when Type-F (fast) 4721da177e4SLinus Torvalds * DMA transfers are used by any ISA device to avoid livelock. 4731da177e4SLinus Torvalds * Note that we could disable Type-F DMA (as recommended by 4741da177e4SLinus Torvalds * the erratum), but this is known to disrupt certain ISA 4751da177e4SLinus Torvalds * devices thus we take the conservative approach. 4761da177e4SLinus Torvalds */ 4771da177e4SLinus Torvalds else if (errata.piix4.fdma) { 4781da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, 4791da177e4SLinus Torvalds "C3 not supported on PIIX4 with Type-F DMA\n")); 480d550d98dSPatrick Mochel return; 4811da177e4SLinus Torvalds } 4821da177e4SLinus Torvalds 48302df8b93SVenkatesh Pallipadi /* All the logic here assumes flags.bm_check is same across all CPUs */ 484ee1ca48fSPallipadi, Venkatesh if (bm_check_flag == -1) { 48502df8b93SVenkatesh Pallipadi /* Determine whether bm_check is needed based on CPU */ 48602df8b93SVenkatesh Pallipadi acpi_processor_power_init_bm_check(&(pr->flags), pr->id); 48702df8b93SVenkatesh Pallipadi bm_check_flag = pr->flags.bm_check; 488ee1ca48fSPallipadi, Venkatesh bm_control_flag = pr->flags.bm_control; 48902df8b93SVenkatesh Pallipadi } else { 49002df8b93SVenkatesh Pallipadi pr->flags.bm_check = bm_check_flag; 491ee1ca48fSPallipadi, Venkatesh pr->flags.bm_control = bm_control_flag; 49202df8b93SVenkatesh Pallipadi } 49302df8b93SVenkatesh Pallipadi 49402df8b93SVenkatesh Pallipadi if (pr->flags.bm_check) { 49502df8b93SVenkatesh Pallipadi if (!pr->flags.bm_control) { 496ed3110efSVenki Pallipadi if (pr->flags.has_cst != 1) { 497ed3110efSVenki Pallipadi /* bus mastering control is necessary */ 49802df8b93SVenkatesh Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 499ed3110efSVenki Pallipadi "C3 support requires BM control\n")); 500ed3110efSVenki Pallipadi return; 501ed3110efSVenki Pallipadi } else { 502ed3110efSVenki Pallipadi /* Here we enter C3 without bus mastering */ 503ed3110efSVenki Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 504ed3110efSVenki Pallipadi "C3 support without BM control\n")); 505ed3110efSVenki Pallipadi } 50602df8b93SVenkatesh Pallipadi } 50702df8b93SVenkatesh Pallipadi } else { 50802df8b93SVenkatesh Pallipadi /* 50902df8b93SVenkatesh Pallipadi * WBINVD should be set in fadt, for C3 state to be 51002df8b93SVenkatesh Pallipadi * supported on when bm_check is not required. 51102df8b93SVenkatesh Pallipadi */ 512cee324b1SAlexey Starikovskiy if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) { 51302df8b93SVenkatesh Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 51402df8b93SVenkatesh Pallipadi "Cache invalidation should work properly" 51502df8b93SVenkatesh Pallipadi " for C3 to be enabled on SMP systems\n")); 516d550d98dSPatrick Mochel return; 51702df8b93SVenkatesh Pallipadi } 51802df8b93SVenkatesh Pallipadi } 51902df8b93SVenkatesh Pallipadi 5201da177e4SLinus Torvalds /* 5211da177e4SLinus Torvalds * Otherwise we've met all of our C3 requirements. 5221da177e4SLinus Torvalds * Normalize the C3 latency to expidite policy. Enable 5231da177e4SLinus Torvalds * checking of bus mastering status (bm_check) so we can 5241da177e4SLinus Torvalds * use this in our C3 policy 5251da177e4SLinus Torvalds */ 5261da177e4SLinus Torvalds cx->valid = 1; 5274f86d3a8SLen Brown 52831878dd8SLen Brown /* 52931878dd8SLen Brown * On older chipsets, BM_RLD needs to be set 53031878dd8SLen Brown * in order for Bus Master activity to wake the 53131878dd8SLen Brown * system from C3. Newer chipsets handle DMA 53231878dd8SLen Brown * during C3 automatically and BM_RLD is a NOP. 53331878dd8SLen Brown * In either case, the proper way to 53431878dd8SLen Brown * handle BM_RLD is to set it and leave it set. 53531878dd8SLen Brown */ 53650ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 1); 5371da177e4SLinus Torvalds 538d550d98dSPatrick Mochel return; 5391da177e4SLinus Torvalds } 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds static int acpi_processor_power_verify(struct acpi_processor *pr) 5421da177e4SLinus Torvalds { 5431da177e4SLinus Torvalds unsigned int i; 5441da177e4SLinus Torvalds unsigned int working = 0; 5456eb0a0fdSVenkatesh Pallipadi 546169a0abbSThomas Gleixner pr->power.timer_broadcast_on_state = INT_MAX; 5476eb0a0fdSVenkatesh Pallipadi 548a0bf284bSLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 5491da177e4SLinus Torvalds struct acpi_processor_cx *cx = &pr->power.states[i]; 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds switch (cx->type) { 5521da177e4SLinus Torvalds case ACPI_STATE_C1: 5531da177e4SLinus Torvalds cx->valid = 1; 5541da177e4SLinus Torvalds break; 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds case ACPI_STATE_C2: 557d22edd29SLen Brown if (!cx->address) 558d22edd29SLen Brown break; 559d22edd29SLen Brown cx->valid = 1; 5601da177e4SLinus Torvalds break; 5611da177e4SLinus Torvalds 5621da177e4SLinus Torvalds case ACPI_STATE_C3: 5631da177e4SLinus Torvalds acpi_processor_power_verify_c3(pr, cx); 5641da177e4SLinus Torvalds break; 5651da177e4SLinus Torvalds } 5667e275cc4SLen Brown if (!cx->valid) 5677e275cc4SLen Brown continue; 5681da177e4SLinus Torvalds 5697e275cc4SLen Brown lapic_timer_check_state(i, pr, cx); 5707e275cc4SLen Brown tsc_check_state(cx->type); 5711da177e4SLinus Torvalds working++; 5721da177e4SLinus Torvalds } 5731da177e4SLinus Torvalds 574918aae42SHidetoshi Seto lapic_timer_propagate_broadcast(pr); 575bd663347SAndi Kleen 5761da177e4SLinus Torvalds return (working); 5771da177e4SLinus Torvalds } 5781da177e4SLinus Torvalds 5794be44fcdSLen Brown static int acpi_processor_get_power_info(struct acpi_processor *pr) 5801da177e4SLinus Torvalds { 5811da177e4SLinus Torvalds unsigned int i; 5821da177e4SLinus Torvalds int result; 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds /* NOTE: the idle thread may not be running while calling 5861da177e4SLinus Torvalds * this function */ 5871da177e4SLinus Torvalds 588991528d7SVenkatesh Pallipadi /* Zero initialize all the C-states info. */ 589991528d7SVenkatesh Pallipadi memset(pr->power.states, 0, sizeof(pr->power.states)); 590991528d7SVenkatesh Pallipadi 5911da177e4SLinus Torvalds result = acpi_processor_get_power_info_cst(pr); 5926d93c648SVenkatesh Pallipadi if (result == -ENODEV) 593c5a114f1SDarrick J. Wong result = acpi_processor_get_power_info_fadt(pr); 5946d93c648SVenkatesh Pallipadi 595991528d7SVenkatesh Pallipadi if (result) 596991528d7SVenkatesh Pallipadi return result; 597991528d7SVenkatesh Pallipadi 598991528d7SVenkatesh Pallipadi acpi_processor_get_power_info_default(pr); 599991528d7SVenkatesh Pallipadi 600cf824788SJanosch Machowinski pr->power.count = acpi_processor_power_verify(pr); 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds /* 6031da177e4SLinus Torvalds * if one state of type C2 or C3 is available, mark this 6041da177e4SLinus Torvalds * CPU as being "idle manageable" 6051da177e4SLinus Torvalds */ 6061da177e4SLinus Torvalds for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 607acf05f4bSVenkatesh Pallipadi if (pr->power.states[i].valid) { 6081da177e4SLinus Torvalds pr->power.count = i; 6092203d6edSLinus Torvalds if (pr->power.states[i].type >= ACPI_STATE_C2) 6101da177e4SLinus Torvalds pr->flags.power = 1; 6111da177e4SLinus Torvalds } 612acf05f4bSVenkatesh Pallipadi } 6131da177e4SLinus Torvalds 614d550d98dSPatrick Mochel return 0; 6151da177e4SLinus Torvalds } 6161da177e4SLinus Torvalds 6174f86d3a8SLen Brown /** 6184f86d3a8SLen Brown * acpi_idle_bm_check - checks if bus master activity was detected 6194f86d3a8SLen Brown */ 6204f86d3a8SLen Brown static int acpi_idle_bm_check(void) 6214f86d3a8SLen Brown { 6224f86d3a8SLen Brown u32 bm_status = 0; 6234f86d3a8SLen Brown 624d3e7e99fSLen Brown if (bm_check_disable) 625d3e7e99fSLen Brown return 0; 626d3e7e99fSLen Brown 62750ffba1bSBob Moore acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status); 6284f86d3a8SLen Brown if (bm_status) 62950ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, 1); 6304f86d3a8SLen Brown /* 6314f86d3a8SLen Brown * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect 6324f86d3a8SLen Brown * the true state of bus mastering activity; forcing us to 6334f86d3a8SLen Brown * manually check the BMIDEA bit of each IDE channel. 6344f86d3a8SLen Brown */ 6354f86d3a8SLen Brown else if (errata.piix4.bmisx) { 6364f86d3a8SLen Brown if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01) 6374f86d3a8SLen Brown || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01)) 6384f86d3a8SLen Brown bm_status = 1; 6394f86d3a8SLen Brown } 6404f86d3a8SLen Brown return bm_status; 6414f86d3a8SLen Brown } 6424f86d3a8SLen Brown 6434f86d3a8SLen Brown /** 644b00783fdSRafael J. Wysocki * acpi_idle_do_entry - enter idle state using the appropriate method 6454f86d3a8SLen Brown * @cx: cstate data 646bc71bec9Svenkatesh.pallipadi@intel.com * 647bc71bec9Svenkatesh.pallipadi@intel.com * Caller disables interrupt before call and enables interrupt after return. 6484f86d3a8SLen Brown */ 649b00783fdSRafael J. Wysocki static void acpi_idle_do_entry(struct acpi_processor_cx *cx) 6504f86d3a8SLen Brown { 651bc71bec9Svenkatesh.pallipadi@intel.com if (cx->entry_method == ACPI_CSTATE_FFH) { 6524f86d3a8SLen Brown /* Call into architectural FFH based C-state */ 6534f86d3a8SLen Brown acpi_processor_ffh_cstate_enter(cx); 654bc71bec9Svenkatesh.pallipadi@intel.com } else if (cx->entry_method == ACPI_CSTATE_HALT) { 655bc71bec9Svenkatesh.pallipadi@intel.com acpi_safe_halt(); 6564f86d3a8SLen Brown } else { 6574f86d3a8SLen Brown /* IO port based C-state */ 6584f86d3a8SLen Brown inb(cx->address); 6594f86d3a8SLen Brown /* Dummy wait op - must do something useless after P_LVL2 read 6604f86d3a8SLen Brown because chipsets cannot guarantee that STPCLK# signal 6614f86d3a8SLen Brown gets asserted in time to freeze execution properly. */ 662cfa806f0SAndi Kleen inl(acpi_gbl_FADT.xpm_timer_block.address); 6634f86d3a8SLen Brown } 6644f86d3a8SLen Brown } 6654f86d3a8SLen Brown 6664f86d3a8SLen Brown /** 6671a022e3fSBoris Ostrovsky * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining) 6681a022e3fSBoris Ostrovsky * @dev: the target CPU 6691a022e3fSBoris Ostrovsky * @index: the index of suggested state 6701a022e3fSBoris Ostrovsky */ 6711a022e3fSBoris Ostrovsky static int acpi_idle_play_dead(struct cpuidle_device *dev, int index) 6721a022e3fSBoris Ostrovsky { 6736240a10dSAlex Shi struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 6741a022e3fSBoris Ostrovsky 6751a022e3fSBoris Ostrovsky ACPI_FLUSH_CPU_CACHE(); 6761a022e3fSBoris Ostrovsky 6771a022e3fSBoris Ostrovsky while (1) { 6781a022e3fSBoris Ostrovsky 6791a022e3fSBoris Ostrovsky if (cx->entry_method == ACPI_CSTATE_HALT) 68054f70077SLuck, Tony safe_halt(); 6811a022e3fSBoris Ostrovsky else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) { 6821a022e3fSBoris Ostrovsky inb(cx->address); 6831a022e3fSBoris Ostrovsky /* See comment in acpi_idle_do_entry() */ 6841a022e3fSBoris Ostrovsky inl(acpi_gbl_FADT.xpm_timer_block.address); 6851a022e3fSBoris Ostrovsky } else 6861a022e3fSBoris Ostrovsky return -ENODEV; 6871a022e3fSBoris Ostrovsky } 6881a022e3fSBoris Ostrovsky 6891a022e3fSBoris Ostrovsky /* Never reached */ 6901a022e3fSBoris Ostrovsky return 0; 6911a022e3fSBoris Ostrovsky } 6921a022e3fSBoris Ostrovsky 693adcb2623SRafael J. Wysocki static bool acpi_idle_fallback_to_c1(struct acpi_processor *pr) 694adcb2623SRafael J. Wysocki { 6955f508185SRafael J. Wysocki return IS_ENABLED(CONFIG_HOTPLUG_CPU) && !pr->flags.has_cst && 6965f508185SRafael J. Wysocki !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED); 697adcb2623SRafael J. Wysocki } 698adcb2623SRafael J. Wysocki 6994f86d3a8SLen Brown static int c3_cpu_count; 700e12f65f7SThomas Gleixner static DEFINE_RAW_SPINLOCK(c3_lock); 7014f86d3a8SLen Brown 7024f86d3a8SLen Brown /** 7034f86d3a8SLen Brown * acpi_idle_enter_bm - enters C3 with proper BM handling 7046491bc0cSRafael J. Wysocki * @pr: Target processor 7056491bc0cSRafael J. Wysocki * @cx: Target state context 7065f508185SRafael J. Wysocki * @timer_bc: Whether or not to change timer mode to broadcast 7074f86d3a8SLen Brown */ 7086491bc0cSRafael J. Wysocki static void acpi_idle_enter_bm(struct acpi_processor *pr, 7095f508185SRafael J. Wysocki struct acpi_processor_cx *cx, bool timer_bc) 7104f86d3a8SLen Brown { 711996520c1SVenki Pallipadi acpi_unlazy_tlb(smp_processor_id()); 712996520c1SVenki Pallipadi 7134f86d3a8SLen Brown /* 7144f86d3a8SLen Brown * Must be done before busmaster disable as we might need to 7154f86d3a8SLen Brown * access HPET ! 7164f86d3a8SLen Brown */ 7175f508185SRafael J. Wysocki if (timer_bc) 7187e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 1); 7194f86d3a8SLen Brown 720c9c860e5SVenkatesh Pallipadi /* 721c9c860e5SVenkatesh Pallipadi * disable bus master 722c9c860e5SVenkatesh Pallipadi * bm_check implies we need ARB_DIS 723c9c860e5SVenkatesh Pallipadi * bm_control implies whether we can do ARB_DIS 724c9c860e5SVenkatesh Pallipadi * 725c9c860e5SVenkatesh Pallipadi * That leaves a case where bm_check is set and bm_control is 726c9c860e5SVenkatesh Pallipadi * not set. In that case we cannot do much, we enter C3 727c9c860e5SVenkatesh Pallipadi * without doing anything. 728c9c860e5SVenkatesh Pallipadi */ 7292a738352SRafael J. Wysocki if (pr->flags.bm_control) { 730e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock); 7314f86d3a8SLen Brown c3_cpu_count++; 7324f86d3a8SLen Brown /* Disable bus master arbitration when all CPUs are in C3 */ 7334f86d3a8SLen Brown if (c3_cpu_count == num_online_cpus()) 73450ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1); 735e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock); 736c9c860e5SVenkatesh Pallipadi } 7374f86d3a8SLen Brown 7384f86d3a8SLen Brown acpi_idle_do_entry(cx); 7394f86d3a8SLen Brown 7404f86d3a8SLen Brown /* Re-enable bus master arbitration */ 7412a738352SRafael J. Wysocki if (pr->flags.bm_control) { 742e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock); 74350ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0); 7444f86d3a8SLen Brown c3_cpu_count--; 745e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock); 7464f86d3a8SLen Brown } 7474f86d3a8SLen Brown 7485f508185SRafael J. Wysocki if (timer_bc) 7497e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 0); 7506491bc0cSRafael J. Wysocki } 7516491bc0cSRafael J. Wysocki 7526491bc0cSRafael J. Wysocki static int acpi_idle_enter(struct cpuidle_device *dev, 7536491bc0cSRafael J. Wysocki struct cpuidle_driver *drv, int index) 7546491bc0cSRafael J. Wysocki { 7556491bc0cSRafael J. Wysocki struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 7566491bc0cSRafael J. Wysocki struct acpi_processor *pr; 7576491bc0cSRafael J. Wysocki 7586491bc0cSRafael J. Wysocki pr = __this_cpu_read(processors); 7596491bc0cSRafael J. Wysocki if (unlikely(!pr)) 7606491bc0cSRafael J. Wysocki return -EINVAL; 7616491bc0cSRafael J. Wysocki 7626491bc0cSRafael J. Wysocki if (cx->type != ACPI_STATE_C1) { 7635f508185SRafael J. Wysocki if (acpi_idle_fallback_to_c1(pr) && num_online_cpus() > 1) { 7646491bc0cSRafael J. Wysocki index = CPUIDLE_DRIVER_STATE_START; 7656491bc0cSRafael J. Wysocki cx = per_cpu(acpi_cstate[index], dev->cpu); 7666491bc0cSRafael J. Wysocki } else if (cx->type == ACPI_STATE_C3 && pr->flags.bm_check) { 7676491bc0cSRafael J. Wysocki if (cx->bm_sts_skip || !acpi_idle_bm_check()) { 7685f508185SRafael J. Wysocki acpi_idle_enter_bm(pr, cx, true); 7696491bc0cSRafael J. Wysocki return index; 7706491bc0cSRafael J. Wysocki } else if (drv->safe_state_index >= 0) { 7716491bc0cSRafael J. Wysocki index = drv->safe_state_index; 7726491bc0cSRafael J. Wysocki cx = per_cpu(acpi_cstate[index], dev->cpu); 7736491bc0cSRafael J. Wysocki } else { 7746491bc0cSRafael J. Wysocki acpi_safe_halt(); 7756491bc0cSRafael J. Wysocki return -EBUSY; 7766491bc0cSRafael J. Wysocki } 7776491bc0cSRafael J. Wysocki } 7786491bc0cSRafael J. Wysocki } 7796491bc0cSRafael J. Wysocki 7806491bc0cSRafael J. Wysocki lapic_timer_state_broadcast(pr, cx, 1); 7816491bc0cSRafael J. Wysocki 7826491bc0cSRafael J. Wysocki if (cx->type == ACPI_STATE_C3) 7836491bc0cSRafael J. Wysocki ACPI_FLUSH_CPU_CACHE(); 7846491bc0cSRafael J. Wysocki 7856491bc0cSRafael J. Wysocki acpi_idle_do_entry(cx); 7866491bc0cSRafael J. Wysocki 7876491bc0cSRafael J. Wysocki lapic_timer_state_broadcast(pr, cx, 0); 7886491bc0cSRafael J. Wysocki 789e978aa7dSDeepthi Dharwar return index; 7904f86d3a8SLen Brown } 7914f86d3a8SLen Brown 7925f508185SRafael J. Wysocki static void acpi_idle_enter_freeze(struct cpuidle_device *dev, 7935f508185SRafael J. Wysocki struct cpuidle_driver *drv, int index) 7945f508185SRafael J. Wysocki { 7955f508185SRafael J. Wysocki struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 7965f508185SRafael J. Wysocki 7975f508185SRafael J. Wysocki if (cx->type == ACPI_STATE_C3) { 7985f508185SRafael J. Wysocki struct acpi_processor *pr = __this_cpu_read(processors); 7995f508185SRafael J. Wysocki 8005f508185SRafael J. Wysocki if (unlikely(!pr)) 8015f508185SRafael J. Wysocki return; 8025f508185SRafael J. Wysocki 8035f508185SRafael J. Wysocki if (pr->flags.bm_check) { 8045f508185SRafael J. Wysocki acpi_idle_enter_bm(pr, cx, false); 8055f508185SRafael J. Wysocki return; 8065f508185SRafael J. Wysocki } else { 8075f508185SRafael J. Wysocki ACPI_FLUSH_CPU_CACHE(); 8085f508185SRafael J. Wysocki } 8095f508185SRafael J. Wysocki } 8105f508185SRafael J. Wysocki acpi_idle_do_entry(cx); 8115f508185SRafael J. Wysocki } 8125f508185SRafael J. Wysocki 8134f86d3a8SLen Brown /** 81446bcfad7SDeepthi Dharwar * acpi_processor_setup_cpuidle_cx - prepares and configures CPUIDLE 81546bcfad7SDeepthi Dharwar * device i.e. per-cpu data 81646bcfad7SDeepthi Dharwar * 8174f86d3a8SLen Brown * @pr: the ACPI processor 8186ef0f086SDaniel Lezcano * @dev : the cpuidle device 8194f86d3a8SLen Brown */ 8206ef0f086SDaniel Lezcano static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr, 8216ef0f086SDaniel Lezcano struct cpuidle_device *dev) 8224f86d3a8SLen Brown { 8239a0b8415Svenkatesh.pallipadi@intel.com int i, count = CPUIDLE_DRIVER_STATE_START; 8244f86d3a8SLen Brown struct acpi_processor_cx *cx; 8254f86d3a8SLen Brown 8264f86d3a8SLen Brown if (!pr->flags.power_setup_done) 8274f86d3a8SLen Brown return -EINVAL; 8284f86d3a8SLen Brown 8294f86d3a8SLen Brown if (pr->flags.power == 0) { 8304f86d3a8SLen Brown return -EINVAL; 8314f86d3a8SLen Brown } 8324f86d3a8SLen Brown 833b88a634aSKonrad Rzeszutek Wilk if (!dev) 834b88a634aSKonrad Rzeszutek Wilk return -EINVAL; 835b88a634aSKonrad Rzeszutek Wilk 836dcb84f33SVenkatesh Pallipadi dev->cpu = pr->id; 8374fcb2fcdSVenkatesh Pallipadi 838615dfd93SLen Brown if (max_cstate == 0) 839615dfd93SLen Brown max_cstate = 1; 840615dfd93SLen Brown 8414f86d3a8SLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 8424f86d3a8SLen Brown cx = &pr->power.states[i]; 8434f86d3a8SLen Brown 8444f86d3a8SLen Brown if (!cx->valid) 8454f86d3a8SLen Brown continue; 8464f86d3a8SLen Brown 8476240a10dSAlex Shi per_cpu(acpi_cstate[count], dev->cpu) = cx; 8484f86d3a8SLen Brown 84946bcfad7SDeepthi Dharwar count++; 85046bcfad7SDeepthi Dharwar if (count == CPUIDLE_STATE_MAX) 85146bcfad7SDeepthi Dharwar break; 85246bcfad7SDeepthi Dharwar } 85346bcfad7SDeepthi Dharwar 85446bcfad7SDeepthi Dharwar if (!count) 85546bcfad7SDeepthi Dharwar return -EINVAL; 85646bcfad7SDeepthi Dharwar 85746bcfad7SDeepthi Dharwar return 0; 85846bcfad7SDeepthi Dharwar } 85946bcfad7SDeepthi Dharwar 86046bcfad7SDeepthi Dharwar /** 86146bcfad7SDeepthi Dharwar * acpi_processor_setup_cpuidle states- prepares and configures cpuidle 86246bcfad7SDeepthi Dharwar * global state data i.e. idle routines 86346bcfad7SDeepthi Dharwar * 86446bcfad7SDeepthi Dharwar * @pr: the ACPI processor 86546bcfad7SDeepthi Dharwar */ 86646bcfad7SDeepthi Dharwar static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr) 86746bcfad7SDeepthi Dharwar { 86846bcfad7SDeepthi Dharwar int i, count = CPUIDLE_DRIVER_STATE_START; 86946bcfad7SDeepthi Dharwar struct acpi_processor_cx *cx; 87046bcfad7SDeepthi Dharwar struct cpuidle_state *state; 87146bcfad7SDeepthi Dharwar struct cpuidle_driver *drv = &acpi_idle_driver; 87246bcfad7SDeepthi Dharwar 87346bcfad7SDeepthi Dharwar if (!pr->flags.power_setup_done) 87446bcfad7SDeepthi Dharwar return -EINVAL; 87546bcfad7SDeepthi Dharwar 87646bcfad7SDeepthi Dharwar if (pr->flags.power == 0) 87746bcfad7SDeepthi Dharwar return -EINVAL; 87846bcfad7SDeepthi Dharwar 87946bcfad7SDeepthi Dharwar drv->safe_state_index = -1; 880c7e8bdf5SThomas Schlichter for (i = CPUIDLE_DRIVER_STATE_START; i < CPUIDLE_STATE_MAX; i++) { 88146bcfad7SDeepthi Dharwar drv->states[i].name[0] = '\0'; 88246bcfad7SDeepthi Dharwar drv->states[i].desc[0] = '\0'; 88346bcfad7SDeepthi Dharwar } 88446bcfad7SDeepthi Dharwar 88546bcfad7SDeepthi Dharwar if (max_cstate == 0) 88646bcfad7SDeepthi Dharwar max_cstate = 1; 88746bcfad7SDeepthi Dharwar 88846bcfad7SDeepthi Dharwar for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 88946bcfad7SDeepthi Dharwar cx = &pr->power.states[i]; 89046bcfad7SDeepthi Dharwar 89146bcfad7SDeepthi Dharwar if (!cx->valid) 89246bcfad7SDeepthi Dharwar continue; 89346bcfad7SDeepthi Dharwar 89446bcfad7SDeepthi Dharwar state = &drv->states[count]; 8954f86d3a8SLen Brown snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i); 8964fcb2fcdSVenkatesh Pallipadi strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); 8974f86d3a8SLen Brown state->exit_latency = cx->latency; 8984963f620SLen Brown state->target_residency = cx->latency * latency_factor; 8996491bc0cSRafael J. Wysocki state->enter = acpi_idle_enter; 9004f86d3a8SLen Brown 9014f86d3a8SLen Brown state->flags = 0; 9026491bc0cSRafael J. Wysocki if (cx->type == ACPI_STATE_C1 || cx->type == ACPI_STATE_C2) { 9031a022e3fSBoris Ostrovsky state->enter_dead = acpi_idle_play_dead; 90446bcfad7SDeepthi Dharwar drv->safe_state_index = count; 9054f86d3a8SLen Brown } 9065f508185SRafael J. Wysocki /* 9075f508185SRafael J. Wysocki * Halt-induced C1 is not good for ->enter_freeze, because it 9085f508185SRafael J. Wysocki * re-enables interrupts on exit. Moreover, C1 is generally not 9095f508185SRafael J. Wysocki * particularly interesting from the suspend-to-idle angle, so 9105f508185SRafael J. Wysocki * avoid C1 and the situations in which we may need to fall back 9115f508185SRafael J. Wysocki * to it altogether. 9125f508185SRafael J. Wysocki */ 9135f508185SRafael J. Wysocki if (cx->type != ACPI_STATE_C1 && !acpi_idle_fallback_to_c1(pr)) 9145f508185SRafael J. Wysocki state->enter_freeze = acpi_idle_enter_freeze; 9154f86d3a8SLen Brown 9164f86d3a8SLen Brown count++; 9179a0b8415Svenkatesh.pallipadi@intel.com if (count == CPUIDLE_STATE_MAX) 9189a0b8415Svenkatesh.pallipadi@intel.com break; 9194f86d3a8SLen Brown } 9204f86d3a8SLen Brown 92146bcfad7SDeepthi Dharwar drv->state_count = count; 9224f86d3a8SLen Brown 9234f86d3a8SLen Brown if (!count) 9244f86d3a8SLen Brown return -EINVAL; 9254f86d3a8SLen Brown 9264f86d3a8SLen Brown return 0; 9274f86d3a8SLen Brown } 9284f86d3a8SLen Brown 92935ae7133SSudeep Holla static inline void acpi_processor_cstate_first_run_checks(void) 93035ae7133SSudeep Holla { 93135ae7133SSudeep Holla acpi_status status; 93235ae7133SSudeep Holla static int first_run; 93335ae7133SSudeep Holla 93435ae7133SSudeep Holla if (first_run) 93535ae7133SSudeep Holla return; 93635ae7133SSudeep Holla dmi_check_system(processor_power_dmi_table); 93735ae7133SSudeep Holla max_cstate = acpi_processor_cstate_check(max_cstate); 93835ae7133SSudeep Holla if (max_cstate < ACPI_C_STATES_MAX) 93935ae7133SSudeep Holla pr_notice("ACPI: processor limited to max C-state %d\n", 94035ae7133SSudeep Holla max_cstate); 94135ae7133SSudeep Holla first_run++; 94235ae7133SSudeep Holla 94335ae7133SSudeep Holla if (acpi_gbl_FADT.cst_control && !nocst) { 94435ae7133SSudeep Holla status = acpi_os_write_port(acpi_gbl_FADT.smi_command, 94535ae7133SSudeep Holla acpi_gbl_FADT.cst_control, 8); 94635ae7133SSudeep Holla if (ACPI_FAILURE(status)) 94735ae7133SSudeep Holla ACPI_EXCEPTION((AE_INFO, status, 94835ae7133SSudeep Holla "Notifying BIOS of _CST ability failed")); 94935ae7133SSudeep Holla } 95035ae7133SSudeep Holla } 95135ae7133SSudeep Holla #else 95235ae7133SSudeep Holla 95335ae7133SSudeep Holla static inline int disabled_by_idle_boot_param(void) { return 0; } 95435ae7133SSudeep Holla static inline void acpi_processor_cstate_first_run_checks(void) { } 95535ae7133SSudeep Holla static int acpi_processor_get_power_info(struct acpi_processor *pr) 95635ae7133SSudeep Holla { 95735ae7133SSudeep Holla return -ENODEV; 95835ae7133SSudeep Holla } 95935ae7133SSudeep Holla 96035ae7133SSudeep Holla static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr, 96135ae7133SSudeep Holla struct cpuidle_device *dev) 96235ae7133SSudeep Holla { 96335ae7133SSudeep Holla return -EINVAL; 96435ae7133SSudeep Holla } 96535ae7133SSudeep Holla 96635ae7133SSudeep Holla static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr) 96735ae7133SSudeep Holla { 96835ae7133SSudeep Holla return -EINVAL; 96935ae7133SSudeep Holla } 97035ae7133SSudeep Holla 97135ae7133SSudeep Holla #endif /* CONFIG_ACPI_PROCESSOR_CSTATE */ 97235ae7133SSudeep Holla 97346bcfad7SDeepthi Dharwar int acpi_processor_hotplug(struct acpi_processor *pr) 9744f86d3a8SLen Brown { 975dcb84f33SVenkatesh Pallipadi int ret = 0; 976e8b1b59dSWei Yongjun struct cpuidle_device *dev; 9774f86d3a8SLen Brown 978d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 97936a91358SVenkatesh Pallipadi return 0; 98036a91358SVenkatesh Pallipadi 981bf9b59f2SBartlomiej Zolnierkiewicz if (nocst) 9824f86d3a8SLen Brown return -ENODEV; 9834f86d3a8SLen Brown 9844f86d3a8SLen Brown if (!pr->flags.power_setup_done) 9854f86d3a8SLen Brown return -ENODEV; 9864f86d3a8SLen Brown 987e8b1b59dSWei Yongjun dev = per_cpu(acpi_cpuidle_device, pr->id); 9884f86d3a8SLen Brown cpuidle_pause_and_lock(); 9893d339dcbSDaniel Lezcano cpuidle_disable_device(dev); 9904f86d3a8SLen Brown acpi_processor_get_power_info(pr); 991dcb84f33SVenkatesh Pallipadi if (pr->flags.power) { 9926ef0f086SDaniel Lezcano acpi_processor_setup_cpuidle_cx(pr, dev); 9933d339dcbSDaniel Lezcano ret = cpuidle_enable_device(dev); 994dcb84f33SVenkatesh Pallipadi } 9954f86d3a8SLen Brown cpuidle_resume_and_unlock(); 9964f86d3a8SLen Brown 9974f86d3a8SLen Brown return ret; 9984f86d3a8SLen Brown } 9994f86d3a8SLen Brown 100046bcfad7SDeepthi Dharwar int acpi_processor_cst_has_changed(struct acpi_processor *pr) 100146bcfad7SDeepthi Dharwar { 100246bcfad7SDeepthi Dharwar int cpu; 100346bcfad7SDeepthi Dharwar struct acpi_processor *_pr; 10043d339dcbSDaniel Lezcano struct cpuidle_device *dev; 100546bcfad7SDeepthi Dharwar 100646bcfad7SDeepthi Dharwar if (disabled_by_idle_boot_param()) 100746bcfad7SDeepthi Dharwar return 0; 100846bcfad7SDeepthi Dharwar 100946bcfad7SDeepthi Dharwar if (nocst) 101046bcfad7SDeepthi Dharwar return -ENODEV; 101146bcfad7SDeepthi Dharwar 101246bcfad7SDeepthi Dharwar if (!pr->flags.power_setup_done) 101346bcfad7SDeepthi Dharwar return -ENODEV; 101446bcfad7SDeepthi Dharwar 101546bcfad7SDeepthi Dharwar /* 101646bcfad7SDeepthi Dharwar * FIXME: Design the ACPI notification to make it once per 101746bcfad7SDeepthi Dharwar * system instead of once per-cpu. This condition is a hack 101846bcfad7SDeepthi Dharwar * to make the code that updates C-States be called once. 101946bcfad7SDeepthi Dharwar */ 102046bcfad7SDeepthi Dharwar 10219505626dSPaul E. McKenney if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) { 102246bcfad7SDeepthi Dharwar 102346bcfad7SDeepthi Dharwar /* Protect against cpu-hotplug */ 102446bcfad7SDeepthi Dharwar get_online_cpus(); 10256726655dSJiri Kosina cpuidle_pause_and_lock(); 102646bcfad7SDeepthi Dharwar 102746bcfad7SDeepthi Dharwar /* Disable all cpuidle devices */ 102846bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) { 102946bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu); 103046bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done) 103146bcfad7SDeepthi Dharwar continue; 10323d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu); 10333d339dcbSDaniel Lezcano cpuidle_disable_device(dev); 103446bcfad7SDeepthi Dharwar } 103546bcfad7SDeepthi Dharwar 103646bcfad7SDeepthi Dharwar /* Populate Updated C-state information */ 1037f427e5f1SThomas Schlichter acpi_processor_get_power_info(pr); 103846bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr); 103946bcfad7SDeepthi Dharwar 104046bcfad7SDeepthi Dharwar /* Enable all cpuidle devices */ 104146bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) { 104246bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu); 104346bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done) 104446bcfad7SDeepthi Dharwar continue; 104546bcfad7SDeepthi Dharwar acpi_processor_get_power_info(_pr); 104646bcfad7SDeepthi Dharwar if (_pr->flags.power) { 10473d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu); 10486ef0f086SDaniel Lezcano acpi_processor_setup_cpuidle_cx(_pr, dev); 10493d339dcbSDaniel Lezcano cpuidle_enable_device(dev); 105046bcfad7SDeepthi Dharwar } 105146bcfad7SDeepthi Dharwar } 105246bcfad7SDeepthi Dharwar cpuidle_resume_and_unlock(); 10536726655dSJiri Kosina put_online_cpus(); 105446bcfad7SDeepthi Dharwar } 105546bcfad7SDeepthi Dharwar 105646bcfad7SDeepthi Dharwar return 0; 105746bcfad7SDeepthi Dharwar } 105846bcfad7SDeepthi Dharwar 105946bcfad7SDeepthi Dharwar static int acpi_processor_registered; 106046bcfad7SDeepthi Dharwar 1061fe7bf106SPaul Gortmaker int acpi_processor_power_init(struct acpi_processor *pr) 10621da177e4SLinus Torvalds { 106346bcfad7SDeepthi Dharwar int retval; 10643d339dcbSDaniel Lezcano struct cpuidle_device *dev; 10651da177e4SLinus Torvalds 1066d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 106736a91358SVenkatesh Pallipadi return 0; 10681da177e4SLinus Torvalds 106935ae7133SSudeep Holla acpi_processor_cstate_first_run_checks(); 10701da177e4SLinus Torvalds 107135ae7133SSudeep Holla if (!acpi_processor_get_power_info(pr)) 10724f86d3a8SLen Brown pr->flags.power_setup_done = 1; 10731da177e4SLinus Torvalds 10741da177e4SLinus Torvalds /* 10751da177e4SLinus Torvalds * Install the idle handler if processor power management is supported. 10761da177e4SLinus Torvalds * Note that we use previously set idle handler will be used on 10771da177e4SLinus Torvalds * platforms that only support C1. 10781da177e4SLinus Torvalds */ 107936a91358SVenkatesh Pallipadi if (pr->flags.power) { 108046bcfad7SDeepthi Dharwar /* Register acpi_idle_driver if not already registered */ 108146bcfad7SDeepthi Dharwar if (!acpi_processor_registered) { 108246bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr); 108346bcfad7SDeepthi Dharwar retval = cpuidle_register_driver(&acpi_idle_driver); 108446bcfad7SDeepthi Dharwar if (retval) 108546bcfad7SDeepthi Dharwar return retval; 1086b6ec26fbSSudeep Holla pr_debug("%s registered with cpuidle\n", 108746bcfad7SDeepthi Dharwar acpi_idle_driver.name); 108846bcfad7SDeepthi Dharwar } 10893d339dcbSDaniel Lezcano 10903d339dcbSDaniel Lezcano dev = kzalloc(sizeof(*dev), GFP_KERNEL); 10913d339dcbSDaniel Lezcano if (!dev) 10923d339dcbSDaniel Lezcano return -ENOMEM; 10933d339dcbSDaniel Lezcano per_cpu(acpi_cpuidle_device, pr->id) = dev; 10943d339dcbSDaniel Lezcano 10956ef0f086SDaniel Lezcano acpi_processor_setup_cpuidle_cx(pr, dev); 10963d339dcbSDaniel Lezcano 109746bcfad7SDeepthi Dharwar /* Register per-cpu cpuidle_device. Cpuidle driver 109846bcfad7SDeepthi Dharwar * must already be registered before registering device 109946bcfad7SDeepthi Dharwar */ 11003d339dcbSDaniel Lezcano retval = cpuidle_register_device(dev); 110146bcfad7SDeepthi Dharwar if (retval) { 110246bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0) 110346bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver); 110446bcfad7SDeepthi Dharwar return retval; 110546bcfad7SDeepthi Dharwar } 110646bcfad7SDeepthi Dharwar acpi_processor_registered++; 11071da177e4SLinus Torvalds } 1108d550d98dSPatrick Mochel return 0; 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds 111138a991b6SDaniel Lezcano int acpi_processor_power_exit(struct acpi_processor *pr) 11121da177e4SLinus Torvalds { 11133d339dcbSDaniel Lezcano struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id); 11143d339dcbSDaniel Lezcano 1115d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 111636a91358SVenkatesh Pallipadi return 0; 111736a91358SVenkatesh Pallipadi 111846bcfad7SDeepthi Dharwar if (pr->flags.power) { 11193d339dcbSDaniel Lezcano cpuidle_unregister_device(dev); 112046bcfad7SDeepthi Dharwar acpi_processor_registered--; 112146bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0) 112246bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver); 112346bcfad7SDeepthi Dharwar } 11241da177e4SLinus Torvalds 112546bcfad7SDeepthi Dharwar pr->flags.power_setup_done = 0; 1126d550d98dSPatrick Mochel return 0; 11271da177e4SLinus Torvalds } 1128