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> 346727ad9eSChris Metcalf #include <linux/cpu.h> 358b48463fSLv Zheng #include <acpi/processor.h> 361da177e4SLinus Torvalds 373434933bSThomas Gleixner /* 383434933bSThomas Gleixner * Include the apic definitions for x86 to have the APIC timer related defines 393434933bSThomas Gleixner * available also for UP (on SMP it gets magically included via linux/smp.h). 403434933bSThomas Gleixner * asm/acpi.h is not an option, as it would require more include magic. Also 413434933bSThomas Gleixner * creating an empty asm-ia64/apic.h would just trade pest vs. cholera. 423434933bSThomas Gleixner */ 433434933bSThomas Gleixner #ifdef CONFIG_X86 443434933bSThomas Gleixner #include <asm/apic.h> 453434933bSThomas Gleixner #endif 463434933bSThomas Gleixner 471da177e4SLinus Torvalds #define ACPI_PROCESSOR_CLASS "processor" 481da177e4SLinus Torvalds #define _COMPONENT ACPI_PROCESSOR_COMPONENT 49f52fd66dSLen Brown ACPI_MODULE_NAME("processor_idle"); 501da177e4SLinus Torvalds 51dc2251bfSRafael J. Wysocki #define ACPI_IDLE_STATE_START (IS_ENABLED(CONFIG_ARCH_HAS_CPU_RELAX) ? 1 : 0) 52dc2251bfSRafael J. Wysocki 534f86d3a8SLen Brown static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER; 544f86d3a8SLen Brown module_param(max_cstate, uint, 0000); 55b6835052SAndreas Mohr static unsigned int nocst __read_mostly; 561da177e4SLinus Torvalds module_param(nocst, uint, 0000); 57d3e7e99fSLen Brown static int bm_check_disable __read_mostly; 58d3e7e99fSLen Brown module_param(bm_check_disable, uint, 0000); 591da177e4SLinus Torvalds 6025de5718SLen Brown static unsigned int latency_factor __read_mostly = 2; 614963f620SLen Brown module_param(latency_factor, uint, 0644); 621da177e4SLinus Torvalds 633d339dcbSDaniel Lezcano static DEFINE_PER_CPU(struct cpuidle_device *, acpi_cpuidle_device); 643d339dcbSDaniel Lezcano 6535ae7133SSudeep Holla struct cpuidle_driver acpi_idle_driver = { 6635ae7133SSudeep Holla .name = "acpi_idle", 6735ae7133SSudeep Holla .owner = THIS_MODULE, 6835ae7133SSudeep Holla }; 6935ae7133SSudeep Holla 7035ae7133SSudeep Holla #ifdef CONFIG_ACPI_PROCESSOR_CSTATE 7125528213SPeter Zijlstra static 7225528213SPeter Zijlstra DEFINE_PER_CPU(struct acpi_processor_cx * [CPUIDLE_STATE_MAX], acpi_cstate); 73ac3ebafaSDaniel Lezcano 74d1896049SThomas Renninger static int disabled_by_idle_boot_param(void) 75d1896049SThomas Renninger { 76d1896049SThomas Renninger return boot_option_idle_override == IDLE_POLL || 77d1896049SThomas Renninger boot_option_idle_override == IDLE_HALT; 78d1896049SThomas Renninger } 79d1896049SThomas Renninger 801da177e4SLinus Torvalds /* 811da177e4SLinus Torvalds * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3. 821da177e4SLinus Torvalds * For now disable this. Probably a bug somewhere else. 831da177e4SLinus Torvalds * 841da177e4SLinus Torvalds * To skip this limit, boot/load with a large max_cstate limit. 851da177e4SLinus Torvalds */ 861855256cSJeff Garzik static int set_max_cstate(const struct dmi_system_id *id) 871da177e4SLinus Torvalds { 881da177e4SLinus Torvalds if (max_cstate > ACPI_PROCESSOR_MAX_POWER) 891da177e4SLinus Torvalds return 0; 901da177e4SLinus Torvalds 91b6ec26fbSSudeep Holla pr_notice("%s detected - limiting to C%ld max_cstate." 921da177e4SLinus Torvalds " Override with \"processor.max_cstate=%d\"\n", id->ident, 933d35600aSLen Brown (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1); 941da177e4SLinus Torvalds 953d35600aSLen Brown max_cstate = (long)id->driver_data; 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds return 0; 981da177e4SLinus Torvalds } 991da177e4SLinus Torvalds 100b0346688SMathias Krause static const struct dmi_system_id processor_power_dmi_table[] = { 101335f16beSDavid Shaohua Li { set_max_cstate, "Clevo 5600D", { 102876c184bSThomas Rosner DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"), 103876c184bSThomas Rosner DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")}, 104335f16beSDavid Shaohua Li (void *)2}, 105370d5cd8SArjan van de Ven { set_max_cstate, "Pavilion zv5000", { 106370d5cd8SArjan van de Ven DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 107370d5cd8SArjan van de Ven DMI_MATCH(DMI_PRODUCT_NAME,"Pavilion zv5000 (DS502A#ABA)")}, 108370d5cd8SArjan van de Ven (void *)1}, 109370d5cd8SArjan van de Ven { set_max_cstate, "Asus L8400B", { 110370d5cd8SArjan van de Ven DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."), 111370d5cd8SArjan van de Ven DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")}, 112370d5cd8SArjan van de Ven (void *)1}, 1131da177e4SLinus Torvalds {}, 1141da177e4SLinus Torvalds }; 1151da177e4SLinus Torvalds 1164f86d3a8SLen Brown 1172e906655Svenkatesh.pallipadi@intel.com /* 1182e906655Svenkatesh.pallipadi@intel.com * Callers should disable interrupts before the call and enable 1192e906655Svenkatesh.pallipadi@intel.com * interrupts after return. 1202e906655Svenkatesh.pallipadi@intel.com */ 1216727ad9eSChris Metcalf static void __cpuidle acpi_safe_halt(void) 122ddc081a1SVenkatesh Pallipadi { 123ea811747SPeter Zijlstra if (!tif_need_resched()) { 124ddc081a1SVenkatesh Pallipadi safe_halt(); 12571e93d15SVenki Pallipadi local_irq_disable(); 12671e93d15SVenki Pallipadi } 127ddc081a1SVenkatesh Pallipadi } 128ddc081a1SVenkatesh Pallipadi 129169a0abbSThomas Gleixner #ifdef ARCH_APICTIMER_STOPS_ON_C3 130169a0abbSThomas Gleixner 131169a0abbSThomas Gleixner /* 132169a0abbSThomas Gleixner * Some BIOS implementations switch to C3 in the published C2 state. 133296d93cdSLinus Torvalds * This seems to be a common problem on AMD boxen, but other vendors 134296d93cdSLinus Torvalds * are affected too. We pick the most conservative approach: we assume 135296d93cdSLinus Torvalds * that the local APIC stops in both C2 and C3. 136169a0abbSThomas Gleixner */ 1377e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr, 138169a0abbSThomas Gleixner struct acpi_processor_cx *cx) 139169a0abbSThomas Gleixner { 140169a0abbSThomas Gleixner struct acpi_processor_power *pwr = &pr->power; 141e585bef8SThomas Gleixner u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2; 142169a0abbSThomas Gleixner 143db954b58SVenkatesh Pallipadi if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT)) 144db954b58SVenkatesh Pallipadi return; 145db954b58SVenkatesh Pallipadi 14607c94a38SBorislav Petkov if (boot_cpu_has_bug(X86_BUG_AMD_APIC_C1E)) 14787ad57baSShaohua Li type = ACPI_STATE_C1; 14887ad57baSShaohua Li 149169a0abbSThomas Gleixner /* 150169a0abbSThomas Gleixner * Check, if one of the previous states already marked the lapic 151169a0abbSThomas Gleixner * unstable 152169a0abbSThomas Gleixner */ 153169a0abbSThomas Gleixner if (pwr->timer_broadcast_on_state < state) 154169a0abbSThomas Gleixner return; 155169a0abbSThomas Gleixner 156e585bef8SThomas Gleixner if (cx->type >= type) 157169a0abbSThomas Gleixner pr->power.timer_broadcast_on_state = state; 158169a0abbSThomas Gleixner } 159169a0abbSThomas Gleixner 160918aae42SHidetoshi Seto static void __lapic_timer_propagate_broadcast(void *arg) 161169a0abbSThomas Gleixner { 162f833bab8SSuresh Siddha struct acpi_processor *pr = (struct acpi_processor *) arg; 163e9e2cdb4SThomas Gleixner 164ee41eebfSThomas Gleixner if (pr->power.timer_broadcast_on_state < INT_MAX) 165ee41eebfSThomas Gleixner tick_broadcast_enable(); 166ee41eebfSThomas Gleixner else 167ee41eebfSThomas Gleixner tick_broadcast_disable(); 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) { 1847815701cSThomas Gleixner if (broadcast) 1857815701cSThomas Gleixner tick_broadcast_enter(); 1867815701cSThomas Gleixner else 1877815701cSThomas Gleixner tick_broadcast_exit(); 188e9e2cdb4SThomas Gleixner } 189169a0abbSThomas Gleixner } 190169a0abbSThomas Gleixner 191169a0abbSThomas Gleixner #else 192169a0abbSThomas Gleixner 1937e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr, 194169a0abbSThomas Gleixner struct acpi_processor_cx *cstate) { } 1957e275cc4SLen Brown static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { } 1967e275cc4SLen Brown static void lapic_timer_state_broadcast(struct acpi_processor *pr, 197e9e2cdb4SThomas Gleixner struct acpi_processor_cx *cx, 198e9e2cdb4SThomas Gleixner int broadcast) 199e9e2cdb4SThomas Gleixner { 200e9e2cdb4SThomas Gleixner } 201169a0abbSThomas Gleixner 202169a0abbSThomas Gleixner #endif 203169a0abbSThomas Gleixner 204592913ecSJohn Stultz #if defined(CONFIG_X86) 205520daf72SLen Brown static void tsc_check_state(int state) 206ddb25f9aSAndi Kleen { 207ddb25f9aSAndi Kleen switch (boot_cpu_data.x86_vendor) { 208ddb25f9aSAndi Kleen case X86_VENDOR_AMD: 20940fb1715SVenki Pallipadi case X86_VENDOR_INTEL: 210ddb25f9aSAndi Kleen /* 211ddb25f9aSAndi Kleen * AMD Fam10h TSC will tick in all 212ddb25f9aSAndi Kleen * C/P/S0/S1 states when this bit is set. 213ddb25f9aSAndi Kleen */ 21440fb1715SVenki Pallipadi if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC)) 215520daf72SLen Brown return; 21640fb1715SVenki Pallipadi 217ddb25f9aSAndi Kleen /*FALL THROUGH*/ 218ddb25f9aSAndi Kleen default: 219520daf72SLen Brown /* TSC could halt in idle, so notify users */ 220520daf72SLen Brown if (state > ACPI_STATE_C1) 221520daf72SLen Brown mark_tsc_unstable("TSC halts in idle"); 222ddb25f9aSAndi Kleen } 223ddb25f9aSAndi Kleen } 224520daf72SLen Brown #else 225520daf72SLen Brown static void tsc_check_state(int state) { return; } 226ddb25f9aSAndi Kleen #endif 227ddb25f9aSAndi Kleen 2281da177e4SLinus Torvalds static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr) 2291da177e4SLinus Torvalds { 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds if (!pr->pblk) 232d550d98dSPatrick Mochel return -ENODEV; 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds /* if info is obtained from pblk/fadt, type equals state */ 2351da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; 2361da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; 2371da177e4SLinus Torvalds 2384c033552SVenkatesh Pallipadi #ifndef CONFIG_HOTPLUG_CPU 2394c033552SVenkatesh Pallipadi /* 2404c033552SVenkatesh Pallipadi * Check for P_LVL2_UP flag before entering C2 and above on 2414c033552SVenkatesh Pallipadi * an SMP system. 2424c033552SVenkatesh Pallipadi */ 243ad71860aSAlexey Starikovskiy if ((num_online_cpus() > 1) && 244cee324b1SAlexey Starikovskiy !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED)) 245d550d98dSPatrick Mochel return -ENODEV; 2464c033552SVenkatesh Pallipadi #endif 2474c033552SVenkatesh Pallipadi 2481da177e4SLinus Torvalds /* determine C2 and C3 address from pblk */ 2491da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4; 2501da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5; 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds /* determine latencies from FADT */ 253ba494beeSBob Moore pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency; 254ba494beeSBob Moore pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency; 2551da177e4SLinus Torvalds 2565d76b6f6SLen Brown /* 2575d76b6f6SLen Brown * FADT specified C2 latency must be less than or equal to 2585d76b6f6SLen Brown * 100 microseconds. 2595d76b6f6SLen Brown */ 260ba494beeSBob Moore if (acpi_gbl_FADT.c2_latency > ACPI_PROCESSOR_MAX_C2_LATENCY) { 2615d76b6f6SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_INFO, 262ba494beeSBob Moore "C2 latency too large [%d]\n", acpi_gbl_FADT.c2_latency)); 2635d76b6f6SLen Brown /* invalidate C2 */ 2645d76b6f6SLen Brown pr->power.states[ACPI_STATE_C2].address = 0; 2655d76b6f6SLen Brown } 2665d76b6f6SLen Brown 267a6d72c18SLen Brown /* 268a6d72c18SLen Brown * FADT supplied C3 latency must be less than or equal to 269a6d72c18SLen Brown * 1000 microseconds. 270a6d72c18SLen Brown */ 271ba494beeSBob Moore if (acpi_gbl_FADT.c3_latency > ACPI_PROCESSOR_MAX_C3_LATENCY) { 272a6d72c18SLen Brown ACPI_DEBUG_PRINT((ACPI_DB_INFO, 273ba494beeSBob Moore "C3 latency too large [%d]\n", acpi_gbl_FADT.c3_latency)); 274a6d72c18SLen Brown /* invalidate C3 */ 275a6d72c18SLen Brown pr->power.states[ACPI_STATE_C3].address = 0; 276a6d72c18SLen Brown } 277a6d72c18SLen Brown 2781da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, 2791da177e4SLinus Torvalds "lvl2[0x%08x] lvl3[0x%08x]\n", 2801da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].address, 2811da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].address)); 2821da177e4SLinus Torvalds 283d550d98dSPatrick Mochel return 0; 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds 286991528d7SVenkatesh Pallipadi static int acpi_processor_get_power_info_default(struct acpi_processor *pr) 287acf05f4bSVenkatesh Pallipadi { 288991528d7SVenkatesh Pallipadi if (!pr->power.states[ACPI_STATE_C1].valid) { 289cf824788SJanosch Machowinski /* set the first C-State to C1 */ 290991528d7SVenkatesh Pallipadi /* all processors need to support C1 */ 291acf05f4bSVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; 292acf05f4bSVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].valid = 1; 2930fda6b40SVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT; 294248e8841SYazen Ghannam 295248e8841SYazen Ghannam snprintf(pr->power.states[ACPI_STATE_C1].desc, 296248e8841SYazen Ghannam ACPI_CX_DESC_LEN, "ACPI HLT"); 297991528d7SVenkatesh Pallipadi } 298991528d7SVenkatesh Pallipadi /* the C0 state only exists as a filler in our array */ 299991528d7SVenkatesh Pallipadi pr->power.states[ACPI_STATE_C0].valid = 1; 300d550d98dSPatrick Mochel return 0; 301acf05f4bSVenkatesh Pallipadi } 302acf05f4bSVenkatesh Pallipadi 3031da177e4SLinus Torvalds static int acpi_processor_get_power_info_cst(struct acpi_processor *pr) 3041da177e4SLinus Torvalds { 3056fd8050aSSudeep Holla acpi_status status; 306439913ffSLin Ming u64 count; 307cf824788SJanosch Machowinski int current_count; 3086fd8050aSSudeep Holla int i, ret = 0; 3091da177e4SLinus Torvalds struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 3101da177e4SLinus Torvalds union acpi_object *cst; 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds if (nocst) 313d550d98dSPatrick Mochel return -ENODEV; 3141da177e4SLinus Torvalds 315991528d7SVenkatesh Pallipadi current_count = 0; 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer); 3181da177e4SLinus Torvalds if (ACPI_FAILURE(status)) { 3191da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n")); 320d550d98dSPatrick Mochel return -ENODEV; 3211da177e4SLinus Torvalds } 3221da177e4SLinus Torvalds 32350dd0969SJan Engelhardt cst = buffer.pointer; 3241da177e4SLinus Torvalds 3251da177e4SLinus Torvalds /* There must be at least 2 elements */ 3261da177e4SLinus Torvalds if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) { 327b6ec26fbSSudeep Holla pr_err("not enough elements in _CST\n"); 3286fd8050aSSudeep Holla ret = -EFAULT; 3291da177e4SLinus Torvalds goto end; 3301da177e4SLinus Torvalds } 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds count = cst->package.elements[0].integer.value; 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds /* Validate number of power states. */ 3351da177e4SLinus Torvalds if (count < 1 || count != cst->package.count - 1) { 336b6ec26fbSSudeep Holla pr_err("count given by _CST is not valid\n"); 3376fd8050aSSudeep Holla ret = -EFAULT; 3381da177e4SLinus Torvalds goto end; 3391da177e4SLinus Torvalds } 3401da177e4SLinus Torvalds 3411da177e4SLinus Torvalds /* Tell driver that at least _CST is supported. */ 3421da177e4SLinus Torvalds pr->flags.has_cst = 1; 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds for (i = 1; i <= count; i++) { 3451da177e4SLinus Torvalds union acpi_object *element; 3461da177e4SLinus Torvalds union acpi_object *obj; 3471da177e4SLinus Torvalds struct acpi_power_register *reg; 3481da177e4SLinus Torvalds struct acpi_processor_cx cx; 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds memset(&cx, 0, sizeof(cx)); 3511da177e4SLinus Torvalds 35250dd0969SJan Engelhardt element = &(cst->package.elements[i]); 3531da177e4SLinus Torvalds if (element->type != ACPI_TYPE_PACKAGE) 3541da177e4SLinus Torvalds continue; 3551da177e4SLinus Torvalds 3561da177e4SLinus Torvalds if (element->package.count != 4) 3571da177e4SLinus Torvalds continue; 3581da177e4SLinus Torvalds 35950dd0969SJan Engelhardt obj = &(element->package.elements[0]); 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_BUFFER) 3621da177e4SLinus Torvalds continue; 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds reg = (struct acpi_power_register *)obj->buffer.pointer; 3651da177e4SLinus Torvalds 3661da177e4SLinus Torvalds if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && 3671da177e4SLinus Torvalds (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) 3681da177e4SLinus Torvalds continue; 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds /* There should be an easy way to extract an integer... */ 37150dd0969SJan Engelhardt obj = &(element->package.elements[1]); 3721da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 3731da177e4SLinus Torvalds continue; 3741da177e4SLinus Torvalds 3751da177e4SLinus Torvalds cx.type = obj->integer.value; 376991528d7SVenkatesh Pallipadi /* 377991528d7SVenkatesh Pallipadi * Some buggy BIOSes won't list C1 in _CST - 378991528d7SVenkatesh Pallipadi * Let acpi_processor_get_power_info_default() handle them later 379991528d7SVenkatesh Pallipadi */ 380991528d7SVenkatesh Pallipadi if (i == 1 && cx.type != ACPI_STATE_C1) 381991528d7SVenkatesh Pallipadi current_count++; 3821da177e4SLinus Torvalds 383991528d7SVenkatesh Pallipadi cx.address = reg->address; 384991528d7SVenkatesh Pallipadi cx.index = current_count + 1; 3851da177e4SLinus Torvalds 386bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_SYSTEMIO; 387991528d7SVenkatesh Pallipadi if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { 388991528d7SVenkatesh Pallipadi if (acpi_processor_ffh_cstate_probe 389991528d7SVenkatesh Pallipadi (pr->id, &cx, reg) == 0) { 390bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_FFH; 391bc71bec9Svenkatesh.pallipadi@intel.com } else if (cx.type == ACPI_STATE_C1) { 392991528d7SVenkatesh Pallipadi /* 393991528d7SVenkatesh Pallipadi * C1 is a special case where FIXED_HARDWARE 394991528d7SVenkatesh Pallipadi * can be handled in non-MWAIT way as well. 395991528d7SVenkatesh Pallipadi * In that case, save this _CST entry info. 396991528d7SVenkatesh Pallipadi * Otherwise, ignore this info and continue. 397991528d7SVenkatesh Pallipadi */ 398bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_HALT; 3994fcb2fcdSVenkatesh Pallipadi snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 400bc71bec9Svenkatesh.pallipadi@intel.com } else { 4011da177e4SLinus Torvalds continue; 402991528d7SVenkatesh Pallipadi } 403da5e09a1SZhao Yakui if (cx.type == ACPI_STATE_C1 && 404d1896049SThomas Renninger (boot_option_idle_override == IDLE_NOMWAIT)) { 405c1e3b377SZhao Yakui /* 406c1e3b377SZhao Yakui * In most cases the C1 space_id obtained from 407c1e3b377SZhao Yakui * _CST object is FIXED_HARDWARE access mode. 408c1e3b377SZhao Yakui * But when the option of idle=halt is added, 409c1e3b377SZhao Yakui * the entry_method type should be changed from 410c1e3b377SZhao Yakui * CSTATE_FFH to CSTATE_HALT. 411da5e09a1SZhao Yakui * When the option of idle=nomwait is added, 412da5e09a1SZhao Yakui * the C1 entry_method type should be 413da5e09a1SZhao Yakui * CSTATE_HALT. 414c1e3b377SZhao Yakui */ 415c1e3b377SZhao Yakui cx.entry_method = ACPI_CSTATE_HALT; 416c1e3b377SZhao Yakui snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 417c1e3b377SZhao Yakui } 4184fcb2fcdSVenkatesh Pallipadi } else { 4194fcb2fcdSVenkatesh Pallipadi snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x", 4204fcb2fcdSVenkatesh Pallipadi cx.address); 421991528d7SVenkatesh Pallipadi } 4221da177e4SLinus Torvalds 4230fda6b40SVenkatesh Pallipadi if (cx.type == ACPI_STATE_C1) { 4240fda6b40SVenkatesh Pallipadi cx.valid = 1; 4250fda6b40SVenkatesh Pallipadi } 4264fcb2fcdSVenkatesh Pallipadi 42750dd0969SJan Engelhardt obj = &(element->package.elements[2]); 4281da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 4291da177e4SLinus Torvalds continue; 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds cx.latency = obj->integer.value; 4321da177e4SLinus Torvalds 43350dd0969SJan Engelhardt obj = &(element->package.elements[3]); 4341da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 4351da177e4SLinus Torvalds continue; 4361da177e4SLinus Torvalds 437cf824788SJanosch Machowinski current_count++; 438cf824788SJanosch Machowinski memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx)); 439cf824788SJanosch Machowinski 440cf824788SJanosch Machowinski /* 441cf824788SJanosch Machowinski * We support total ACPI_PROCESSOR_MAX_POWER - 1 442cf824788SJanosch Machowinski * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1) 443cf824788SJanosch Machowinski */ 444cf824788SJanosch Machowinski if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) { 445b6ec26fbSSudeep Holla pr_warn("Limiting number of power states to max (%d)\n", 446cf824788SJanosch Machowinski ACPI_PROCESSOR_MAX_POWER); 447b6ec26fbSSudeep Holla pr_warn("Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n"); 448cf824788SJanosch Machowinski break; 449cf824788SJanosch Machowinski } 4501da177e4SLinus Torvalds } 4511da177e4SLinus Torvalds 4524be44fcdSLen Brown ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n", 453cf824788SJanosch Machowinski current_count)); 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds /* Validate number of power states discovered */ 456cf824788SJanosch Machowinski if (current_count < 2) 4576fd8050aSSudeep Holla ret = -EFAULT; 4581da177e4SLinus Torvalds 4591da177e4SLinus Torvalds end: 46002438d87SLen Brown kfree(buffer.pointer); 4611da177e4SLinus Torvalds 4626fd8050aSSudeep Holla return ret; 4631da177e4SLinus Torvalds } 4641da177e4SLinus Torvalds 4654be44fcdSLen Brown static void acpi_processor_power_verify_c3(struct acpi_processor *pr, 4661da177e4SLinus Torvalds struct acpi_processor_cx *cx) 4671da177e4SLinus Torvalds { 468ee1ca48fSPallipadi, Venkatesh static int bm_check_flag = -1; 469ee1ca48fSPallipadi, Venkatesh static int bm_control_flag = -1; 47002df8b93SVenkatesh Pallipadi 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds if (!cx->address) 473d550d98dSPatrick Mochel return; 4741da177e4SLinus Torvalds 4751da177e4SLinus Torvalds /* 4761da177e4SLinus Torvalds * PIIX4 Erratum #18: We don't support C3 when Type-F (fast) 4771da177e4SLinus Torvalds * DMA transfers are used by any ISA device to avoid livelock. 4781da177e4SLinus Torvalds * Note that we could disable Type-F DMA (as recommended by 4791da177e4SLinus Torvalds * the erratum), but this is known to disrupt certain ISA 4801da177e4SLinus Torvalds * devices thus we take the conservative approach. 4811da177e4SLinus Torvalds */ 4821da177e4SLinus Torvalds else if (errata.piix4.fdma) { 4831da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, 4841da177e4SLinus Torvalds "C3 not supported on PIIX4 with Type-F DMA\n")); 485d550d98dSPatrick Mochel return; 4861da177e4SLinus Torvalds } 4871da177e4SLinus Torvalds 48802df8b93SVenkatesh Pallipadi /* All the logic here assumes flags.bm_check is same across all CPUs */ 489ee1ca48fSPallipadi, Venkatesh if (bm_check_flag == -1) { 49002df8b93SVenkatesh Pallipadi /* Determine whether bm_check is needed based on CPU */ 49102df8b93SVenkatesh Pallipadi acpi_processor_power_init_bm_check(&(pr->flags), pr->id); 49202df8b93SVenkatesh Pallipadi bm_check_flag = pr->flags.bm_check; 493ee1ca48fSPallipadi, Venkatesh bm_control_flag = pr->flags.bm_control; 49402df8b93SVenkatesh Pallipadi } else { 49502df8b93SVenkatesh Pallipadi pr->flags.bm_check = bm_check_flag; 496ee1ca48fSPallipadi, Venkatesh pr->flags.bm_control = bm_control_flag; 49702df8b93SVenkatesh Pallipadi } 49802df8b93SVenkatesh Pallipadi 49902df8b93SVenkatesh Pallipadi if (pr->flags.bm_check) { 50002df8b93SVenkatesh Pallipadi if (!pr->flags.bm_control) { 501ed3110efSVenki Pallipadi if (pr->flags.has_cst != 1) { 502ed3110efSVenki Pallipadi /* bus mastering control is necessary */ 50302df8b93SVenkatesh Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 504ed3110efSVenki Pallipadi "C3 support requires BM control\n")); 505ed3110efSVenki Pallipadi return; 506ed3110efSVenki Pallipadi } else { 507ed3110efSVenki Pallipadi /* Here we enter C3 without bus mastering */ 508ed3110efSVenki Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 509ed3110efSVenki Pallipadi "C3 support without BM control\n")); 510ed3110efSVenki Pallipadi } 51102df8b93SVenkatesh Pallipadi } 51202df8b93SVenkatesh Pallipadi } else { 51302df8b93SVenkatesh Pallipadi /* 51402df8b93SVenkatesh Pallipadi * WBINVD should be set in fadt, for C3 state to be 51502df8b93SVenkatesh Pallipadi * supported on when bm_check is not required. 51602df8b93SVenkatesh Pallipadi */ 517cee324b1SAlexey Starikovskiy if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) { 51802df8b93SVenkatesh Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 51902df8b93SVenkatesh Pallipadi "Cache invalidation should work properly" 52002df8b93SVenkatesh Pallipadi " for C3 to be enabled on SMP systems\n")); 521d550d98dSPatrick Mochel return; 52202df8b93SVenkatesh Pallipadi } 52302df8b93SVenkatesh Pallipadi } 52402df8b93SVenkatesh Pallipadi 5251da177e4SLinus Torvalds /* 5261da177e4SLinus Torvalds * Otherwise we've met all of our C3 requirements. 5271da177e4SLinus Torvalds * Normalize the C3 latency to expidite policy. Enable 5281da177e4SLinus Torvalds * checking of bus mastering status (bm_check) so we can 5291da177e4SLinus Torvalds * use this in our C3 policy 5301da177e4SLinus Torvalds */ 5311da177e4SLinus Torvalds cx->valid = 1; 5324f86d3a8SLen Brown 53331878dd8SLen Brown /* 53431878dd8SLen Brown * On older chipsets, BM_RLD needs to be set 53531878dd8SLen Brown * in order for Bus Master activity to wake the 53631878dd8SLen Brown * system from C3. Newer chipsets handle DMA 53731878dd8SLen Brown * during C3 automatically and BM_RLD is a NOP. 53831878dd8SLen Brown * In either case, the proper way to 53931878dd8SLen Brown * handle BM_RLD is to set it and leave it set. 54031878dd8SLen Brown */ 54150ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 1); 5421da177e4SLinus Torvalds 543d550d98dSPatrick Mochel return; 5441da177e4SLinus Torvalds } 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds static int acpi_processor_power_verify(struct acpi_processor *pr) 5471da177e4SLinus Torvalds { 5481da177e4SLinus Torvalds unsigned int i; 5491da177e4SLinus Torvalds unsigned int working = 0; 5506eb0a0fdSVenkatesh Pallipadi 551169a0abbSThomas Gleixner pr->power.timer_broadcast_on_state = INT_MAX; 5526eb0a0fdSVenkatesh Pallipadi 553a0bf284bSLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 5541da177e4SLinus Torvalds struct acpi_processor_cx *cx = &pr->power.states[i]; 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds switch (cx->type) { 5571da177e4SLinus Torvalds case ACPI_STATE_C1: 5581da177e4SLinus Torvalds cx->valid = 1; 5591da177e4SLinus Torvalds break; 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds case ACPI_STATE_C2: 562d22edd29SLen Brown if (!cx->address) 563d22edd29SLen Brown break; 564d22edd29SLen Brown cx->valid = 1; 5651da177e4SLinus Torvalds break; 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds case ACPI_STATE_C3: 5681da177e4SLinus Torvalds acpi_processor_power_verify_c3(pr, cx); 5691da177e4SLinus Torvalds break; 5701da177e4SLinus Torvalds } 5717e275cc4SLen Brown if (!cx->valid) 5727e275cc4SLen Brown continue; 5731da177e4SLinus Torvalds 5747e275cc4SLen Brown lapic_timer_check_state(i, pr, cx); 5757e275cc4SLen Brown tsc_check_state(cx->type); 5761da177e4SLinus Torvalds working++; 5771da177e4SLinus Torvalds } 5781da177e4SLinus Torvalds 579918aae42SHidetoshi Seto lapic_timer_propagate_broadcast(pr); 580bd663347SAndi Kleen 5811da177e4SLinus Torvalds return (working); 5821da177e4SLinus Torvalds } 5831da177e4SLinus Torvalds 584a36a7fecSSudeep Holla static int acpi_processor_get_cstate_info(struct acpi_processor *pr) 5851da177e4SLinus Torvalds { 5861da177e4SLinus Torvalds unsigned int i; 5871da177e4SLinus Torvalds int result; 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds /* NOTE: the idle thread may not be running while calling 5911da177e4SLinus Torvalds * this function */ 5921da177e4SLinus Torvalds 593991528d7SVenkatesh Pallipadi /* Zero initialize all the C-states info. */ 594991528d7SVenkatesh Pallipadi memset(pr->power.states, 0, sizeof(pr->power.states)); 595991528d7SVenkatesh Pallipadi 5961da177e4SLinus Torvalds result = acpi_processor_get_power_info_cst(pr); 5976d93c648SVenkatesh Pallipadi if (result == -ENODEV) 598c5a114f1SDarrick J. Wong result = acpi_processor_get_power_info_fadt(pr); 5996d93c648SVenkatesh Pallipadi 600991528d7SVenkatesh Pallipadi if (result) 601991528d7SVenkatesh Pallipadi return result; 602991528d7SVenkatesh Pallipadi 603991528d7SVenkatesh Pallipadi acpi_processor_get_power_info_default(pr); 604991528d7SVenkatesh Pallipadi 605cf824788SJanosch Machowinski pr->power.count = acpi_processor_power_verify(pr); 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds /* 6081da177e4SLinus Torvalds * if one state of type C2 or C3 is available, mark this 6091da177e4SLinus Torvalds * CPU as being "idle manageable" 6101da177e4SLinus Torvalds */ 6111da177e4SLinus Torvalds for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 612acf05f4bSVenkatesh Pallipadi if (pr->power.states[i].valid) { 6131da177e4SLinus Torvalds pr->power.count = i; 6142203d6edSLinus Torvalds if (pr->power.states[i].type >= ACPI_STATE_C2) 6151da177e4SLinus Torvalds pr->flags.power = 1; 6161da177e4SLinus Torvalds } 617acf05f4bSVenkatesh Pallipadi } 6181da177e4SLinus Torvalds 619d550d98dSPatrick Mochel return 0; 6201da177e4SLinus Torvalds } 6211da177e4SLinus Torvalds 6224f86d3a8SLen Brown /** 6234f86d3a8SLen Brown * acpi_idle_bm_check - checks if bus master activity was detected 6244f86d3a8SLen Brown */ 6254f86d3a8SLen Brown static int acpi_idle_bm_check(void) 6264f86d3a8SLen Brown { 6274f86d3a8SLen Brown u32 bm_status = 0; 6284f86d3a8SLen Brown 629d3e7e99fSLen Brown if (bm_check_disable) 630d3e7e99fSLen Brown return 0; 631d3e7e99fSLen Brown 63250ffba1bSBob Moore acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status); 6334f86d3a8SLen Brown if (bm_status) 63450ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, 1); 6354f86d3a8SLen Brown /* 6364f86d3a8SLen Brown * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect 6374f86d3a8SLen Brown * the true state of bus mastering activity; forcing us to 6384f86d3a8SLen Brown * manually check the BMIDEA bit of each IDE channel. 6394f86d3a8SLen Brown */ 6404f86d3a8SLen Brown else if (errata.piix4.bmisx) { 6414f86d3a8SLen Brown if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01) 6424f86d3a8SLen Brown || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01)) 6434f86d3a8SLen Brown bm_status = 1; 6444f86d3a8SLen Brown } 6454f86d3a8SLen Brown return bm_status; 6464f86d3a8SLen Brown } 6474f86d3a8SLen Brown 6484f86d3a8SLen Brown /** 649b00783fdSRafael J. Wysocki * acpi_idle_do_entry - enter idle state using the appropriate method 6504f86d3a8SLen Brown * @cx: cstate data 651bc71bec9Svenkatesh.pallipadi@intel.com * 652bc71bec9Svenkatesh.pallipadi@intel.com * Caller disables interrupt before call and enables interrupt after return. 6534f86d3a8SLen Brown */ 6546727ad9eSChris Metcalf static void __cpuidle acpi_idle_do_entry(struct acpi_processor_cx *cx) 6554f86d3a8SLen Brown { 656bc71bec9Svenkatesh.pallipadi@intel.com if (cx->entry_method == ACPI_CSTATE_FFH) { 6574f86d3a8SLen Brown /* Call into architectural FFH based C-state */ 6584f86d3a8SLen Brown acpi_processor_ffh_cstate_enter(cx); 659bc71bec9Svenkatesh.pallipadi@intel.com } else if (cx->entry_method == ACPI_CSTATE_HALT) { 660bc71bec9Svenkatesh.pallipadi@intel.com acpi_safe_halt(); 6614f86d3a8SLen Brown } else { 6624f86d3a8SLen Brown /* IO port based C-state */ 6634f86d3a8SLen Brown inb(cx->address); 6644f86d3a8SLen Brown /* Dummy wait op - must do something useless after P_LVL2 read 6654f86d3a8SLen Brown because chipsets cannot guarantee that STPCLK# signal 6664f86d3a8SLen Brown gets asserted in time to freeze execution properly. */ 667cfa806f0SAndi Kleen inl(acpi_gbl_FADT.xpm_timer_block.address); 6684f86d3a8SLen Brown } 6694f86d3a8SLen Brown } 6704f86d3a8SLen Brown 6714f86d3a8SLen Brown /** 6721a022e3fSBoris Ostrovsky * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining) 6731a022e3fSBoris Ostrovsky * @dev: the target CPU 6741a022e3fSBoris Ostrovsky * @index: the index of suggested state 6751a022e3fSBoris Ostrovsky */ 6761a022e3fSBoris Ostrovsky static int acpi_idle_play_dead(struct cpuidle_device *dev, int index) 6771a022e3fSBoris Ostrovsky { 6786240a10dSAlex Shi struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 6791a022e3fSBoris Ostrovsky 6801a022e3fSBoris Ostrovsky ACPI_FLUSH_CPU_CACHE(); 6811a022e3fSBoris Ostrovsky 6821a022e3fSBoris Ostrovsky while (1) { 6831a022e3fSBoris Ostrovsky 6841a022e3fSBoris Ostrovsky if (cx->entry_method == ACPI_CSTATE_HALT) 68554f70077SLuck, Tony safe_halt(); 6861a022e3fSBoris Ostrovsky else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) { 6871a022e3fSBoris Ostrovsky inb(cx->address); 6881a022e3fSBoris Ostrovsky /* See comment in acpi_idle_do_entry() */ 6891a022e3fSBoris Ostrovsky inl(acpi_gbl_FADT.xpm_timer_block.address); 6901a022e3fSBoris Ostrovsky } else 6911a022e3fSBoris Ostrovsky return -ENODEV; 6921a022e3fSBoris Ostrovsky } 6931a022e3fSBoris Ostrovsky 6941a022e3fSBoris Ostrovsky /* Never reached */ 6951a022e3fSBoris Ostrovsky return 0; 6961a022e3fSBoris Ostrovsky } 6971a022e3fSBoris Ostrovsky 698adcb2623SRafael J. Wysocki static bool acpi_idle_fallback_to_c1(struct acpi_processor *pr) 699adcb2623SRafael J. Wysocki { 7005f508185SRafael J. Wysocki return IS_ENABLED(CONFIG_HOTPLUG_CPU) && !pr->flags.has_cst && 7015f508185SRafael J. Wysocki !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED); 702adcb2623SRafael J. Wysocki } 703adcb2623SRafael J. Wysocki 7044f86d3a8SLen Brown static int c3_cpu_count; 705e12f65f7SThomas Gleixner static DEFINE_RAW_SPINLOCK(c3_lock); 7064f86d3a8SLen Brown 7074f86d3a8SLen Brown /** 7084f86d3a8SLen Brown * acpi_idle_enter_bm - enters C3 with proper BM handling 7096491bc0cSRafael J. Wysocki * @pr: Target processor 7106491bc0cSRafael J. Wysocki * @cx: Target state context 7115f508185SRafael J. Wysocki * @timer_bc: Whether or not to change timer mode to broadcast 7124f86d3a8SLen Brown */ 7136491bc0cSRafael J. Wysocki static void acpi_idle_enter_bm(struct acpi_processor *pr, 7145f508185SRafael J. Wysocki struct acpi_processor_cx *cx, bool timer_bc) 7154f86d3a8SLen Brown { 71667535736SAndy Lutomirski acpi_unlazy_tlb(smp_processor_id()); 71767535736SAndy Lutomirski 7184f86d3a8SLen Brown /* 7194f86d3a8SLen Brown * Must be done before busmaster disable as we might need to 7204f86d3a8SLen Brown * access HPET ! 7214f86d3a8SLen Brown */ 7225f508185SRafael J. Wysocki if (timer_bc) 7237e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 1); 7244f86d3a8SLen Brown 725c9c860e5SVenkatesh Pallipadi /* 726c9c860e5SVenkatesh Pallipadi * disable bus master 727c9c860e5SVenkatesh Pallipadi * bm_check implies we need ARB_DIS 728c9c860e5SVenkatesh Pallipadi * bm_control implies whether we can do ARB_DIS 729c9c860e5SVenkatesh Pallipadi * 730c9c860e5SVenkatesh Pallipadi * That leaves a case where bm_check is set and bm_control is 731c9c860e5SVenkatesh Pallipadi * not set. In that case we cannot do much, we enter C3 732c9c860e5SVenkatesh Pallipadi * without doing anything. 733c9c860e5SVenkatesh Pallipadi */ 7342a738352SRafael J. Wysocki if (pr->flags.bm_control) { 735e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock); 7364f86d3a8SLen Brown c3_cpu_count++; 7374f86d3a8SLen Brown /* Disable bus master arbitration when all CPUs are in C3 */ 7384f86d3a8SLen Brown if (c3_cpu_count == num_online_cpus()) 73950ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1); 740e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock); 741c9c860e5SVenkatesh Pallipadi } 7424f86d3a8SLen Brown 7434f86d3a8SLen Brown acpi_idle_do_entry(cx); 7444f86d3a8SLen Brown 7454f86d3a8SLen Brown /* Re-enable bus master arbitration */ 7462a738352SRafael J. Wysocki if (pr->flags.bm_control) { 747e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock); 74850ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0); 7494f86d3a8SLen Brown c3_cpu_count--; 750e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock); 7514f86d3a8SLen Brown } 7524f86d3a8SLen Brown 7535f508185SRafael J. Wysocki if (timer_bc) 7547e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 0); 7556491bc0cSRafael J. Wysocki } 7566491bc0cSRafael J. Wysocki 7576491bc0cSRafael J. Wysocki static int acpi_idle_enter(struct cpuidle_device *dev, 7586491bc0cSRafael J. Wysocki struct cpuidle_driver *drv, int index) 7596491bc0cSRafael J. Wysocki { 7606491bc0cSRafael J. Wysocki struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 7616491bc0cSRafael J. Wysocki struct acpi_processor *pr; 7626491bc0cSRafael J. Wysocki 7636491bc0cSRafael J. Wysocki pr = __this_cpu_read(processors); 7646491bc0cSRafael J. Wysocki if (unlikely(!pr)) 7656491bc0cSRafael J. Wysocki return -EINVAL; 7666491bc0cSRafael J. Wysocki 7676491bc0cSRafael J. Wysocki if (cx->type != ACPI_STATE_C1) { 7685f508185SRafael J. Wysocki if (acpi_idle_fallback_to_c1(pr) && num_online_cpus() > 1) { 769dc2251bfSRafael J. Wysocki index = ACPI_IDLE_STATE_START; 7706491bc0cSRafael J. Wysocki cx = per_cpu(acpi_cstate[index], dev->cpu); 7716491bc0cSRafael J. Wysocki } else if (cx->type == ACPI_STATE_C3 && pr->flags.bm_check) { 7726491bc0cSRafael J. Wysocki if (cx->bm_sts_skip || !acpi_idle_bm_check()) { 7735f508185SRafael J. Wysocki acpi_idle_enter_bm(pr, cx, true); 7746491bc0cSRafael J. Wysocki return index; 7756491bc0cSRafael J. Wysocki } else if (drv->safe_state_index >= 0) { 7766491bc0cSRafael J. Wysocki index = drv->safe_state_index; 7776491bc0cSRafael J. Wysocki cx = per_cpu(acpi_cstate[index], dev->cpu); 7786491bc0cSRafael J. Wysocki } else { 7796491bc0cSRafael J. Wysocki acpi_safe_halt(); 7806491bc0cSRafael J. Wysocki return -EBUSY; 7816491bc0cSRafael J. Wysocki } 7826491bc0cSRafael J. Wysocki } 7836491bc0cSRafael J. Wysocki } 7846491bc0cSRafael J. Wysocki 7856491bc0cSRafael J. Wysocki lapic_timer_state_broadcast(pr, cx, 1); 7866491bc0cSRafael J. Wysocki 7876491bc0cSRafael J. Wysocki if (cx->type == ACPI_STATE_C3) 7886491bc0cSRafael J. Wysocki ACPI_FLUSH_CPU_CACHE(); 7896491bc0cSRafael J. Wysocki 7906491bc0cSRafael J. Wysocki acpi_idle_do_entry(cx); 7916491bc0cSRafael J. Wysocki 7926491bc0cSRafael J. Wysocki lapic_timer_state_broadcast(pr, cx, 0); 7936491bc0cSRafael J. Wysocki 794e978aa7dSDeepthi Dharwar return index; 7954f86d3a8SLen Brown } 7964f86d3a8SLen Brown 79728ba086eSRafael J. Wysocki static void acpi_idle_enter_s2idle(struct cpuidle_device *dev, 7985f508185SRafael J. Wysocki struct cpuidle_driver *drv, int index) 7995f508185SRafael J. Wysocki { 8005f508185SRafael J. Wysocki struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 8015f508185SRafael J. Wysocki 8025f508185SRafael J. Wysocki if (cx->type == ACPI_STATE_C3) { 8035f508185SRafael J. Wysocki struct acpi_processor *pr = __this_cpu_read(processors); 8045f508185SRafael J. Wysocki 8055f508185SRafael J. Wysocki if (unlikely(!pr)) 8065f508185SRafael J. Wysocki return; 8075f508185SRafael J. Wysocki 8085f508185SRafael J. Wysocki if (pr->flags.bm_check) { 8095f508185SRafael J. Wysocki acpi_idle_enter_bm(pr, cx, false); 8105f508185SRafael J. Wysocki return; 8115f508185SRafael J. Wysocki } else { 8125f508185SRafael J. Wysocki ACPI_FLUSH_CPU_CACHE(); 8135f508185SRafael J. Wysocki } 8145f508185SRafael J. Wysocki } 8155f508185SRafael J. Wysocki acpi_idle_do_entry(cx); 8165f508185SRafael J. Wysocki } 8175f508185SRafael J. Wysocki 8186ef0f086SDaniel Lezcano static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr, 8196ef0f086SDaniel Lezcano struct cpuidle_device *dev) 8204f86d3a8SLen Brown { 821dc2251bfSRafael J. Wysocki int i, count = ACPI_IDLE_STATE_START; 8224f86d3a8SLen Brown struct acpi_processor_cx *cx; 8234f86d3a8SLen Brown 824615dfd93SLen Brown if (max_cstate == 0) 825615dfd93SLen Brown max_cstate = 1; 826615dfd93SLen Brown 8274f86d3a8SLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 8284f86d3a8SLen Brown cx = &pr->power.states[i]; 8294f86d3a8SLen Brown 8304f86d3a8SLen Brown if (!cx->valid) 8314f86d3a8SLen Brown continue; 8324f86d3a8SLen Brown 8336240a10dSAlex Shi per_cpu(acpi_cstate[count], dev->cpu) = cx; 8344f86d3a8SLen Brown 83546bcfad7SDeepthi Dharwar count++; 83646bcfad7SDeepthi Dharwar if (count == CPUIDLE_STATE_MAX) 83746bcfad7SDeepthi Dharwar break; 83846bcfad7SDeepthi Dharwar } 83946bcfad7SDeepthi Dharwar 84046bcfad7SDeepthi Dharwar if (!count) 84146bcfad7SDeepthi Dharwar return -EINVAL; 84246bcfad7SDeepthi Dharwar 84346bcfad7SDeepthi Dharwar return 0; 84446bcfad7SDeepthi Dharwar } 84546bcfad7SDeepthi Dharwar 846a36a7fecSSudeep Holla static int acpi_processor_setup_cstates(struct acpi_processor *pr) 84746bcfad7SDeepthi Dharwar { 8481b39e3f8SRafael J. Wysocki int i, count; 84946bcfad7SDeepthi Dharwar struct acpi_processor_cx *cx; 85046bcfad7SDeepthi Dharwar struct cpuidle_state *state; 85146bcfad7SDeepthi Dharwar struct cpuidle_driver *drv = &acpi_idle_driver; 85246bcfad7SDeepthi Dharwar 85346bcfad7SDeepthi Dharwar if (max_cstate == 0) 85446bcfad7SDeepthi Dharwar max_cstate = 1; 85546bcfad7SDeepthi Dharwar 8561b39e3f8SRafael J. Wysocki if (IS_ENABLED(CONFIG_ARCH_HAS_CPU_RELAX)) { 8571b39e3f8SRafael J. Wysocki cpuidle_poll_state_init(drv); 8581b39e3f8SRafael J. Wysocki count = 1; 8591b39e3f8SRafael J. Wysocki } else { 8601b39e3f8SRafael J. Wysocki count = 0; 8611b39e3f8SRafael J. Wysocki } 8621b39e3f8SRafael J. Wysocki 86346bcfad7SDeepthi Dharwar for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 86446bcfad7SDeepthi Dharwar cx = &pr->power.states[i]; 86546bcfad7SDeepthi Dharwar 86646bcfad7SDeepthi Dharwar if (!cx->valid) 86746bcfad7SDeepthi Dharwar continue; 86846bcfad7SDeepthi Dharwar 86946bcfad7SDeepthi Dharwar state = &drv->states[count]; 8704f86d3a8SLen Brown snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i); 871a36a7fecSSudeep Holla strlcpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); 8724f86d3a8SLen Brown state->exit_latency = cx->latency; 8734963f620SLen Brown state->target_residency = cx->latency * latency_factor; 8746491bc0cSRafael J. Wysocki state->enter = acpi_idle_enter; 8754f86d3a8SLen Brown 8764f86d3a8SLen Brown state->flags = 0; 8776491bc0cSRafael J. Wysocki if (cx->type == ACPI_STATE_C1 || cx->type == ACPI_STATE_C2) { 8781a022e3fSBoris Ostrovsky state->enter_dead = acpi_idle_play_dead; 87946bcfad7SDeepthi Dharwar drv->safe_state_index = count; 8804f86d3a8SLen Brown } 8815f508185SRafael J. Wysocki /* 88228ba086eSRafael J. Wysocki * Halt-induced C1 is not good for ->enter_s2idle, because it 8835f508185SRafael J. Wysocki * re-enables interrupts on exit. Moreover, C1 is generally not 8845f508185SRafael J. Wysocki * particularly interesting from the suspend-to-idle angle, so 8855f508185SRafael J. Wysocki * avoid C1 and the situations in which we may need to fall back 8865f508185SRafael J. Wysocki * to it altogether. 8875f508185SRafael J. Wysocki */ 8885f508185SRafael J. Wysocki if (cx->type != ACPI_STATE_C1 && !acpi_idle_fallback_to_c1(pr)) 88928ba086eSRafael J. Wysocki state->enter_s2idle = acpi_idle_enter_s2idle; 8904f86d3a8SLen Brown 8914f86d3a8SLen Brown count++; 8929a0b8415Svenkatesh.pallipadi@intel.com if (count == CPUIDLE_STATE_MAX) 8939a0b8415Svenkatesh.pallipadi@intel.com break; 8944f86d3a8SLen Brown } 8954f86d3a8SLen Brown 89646bcfad7SDeepthi Dharwar drv->state_count = count; 8974f86d3a8SLen Brown 8984f86d3a8SLen Brown if (!count) 8994f86d3a8SLen Brown return -EINVAL; 9004f86d3a8SLen Brown 9014f86d3a8SLen Brown return 0; 9024f86d3a8SLen Brown } 9034f86d3a8SLen Brown 90435ae7133SSudeep Holla static inline void acpi_processor_cstate_first_run_checks(void) 90535ae7133SSudeep Holla { 90635ae7133SSudeep Holla acpi_status status; 90735ae7133SSudeep Holla static int first_run; 90835ae7133SSudeep Holla 90935ae7133SSudeep Holla if (first_run) 91035ae7133SSudeep Holla return; 91135ae7133SSudeep Holla dmi_check_system(processor_power_dmi_table); 91235ae7133SSudeep Holla max_cstate = acpi_processor_cstate_check(max_cstate); 91335ae7133SSudeep Holla if (max_cstate < ACPI_C_STATES_MAX) 91435ae7133SSudeep Holla pr_notice("ACPI: processor limited to max C-state %d\n", 91535ae7133SSudeep Holla max_cstate); 91635ae7133SSudeep Holla first_run++; 91735ae7133SSudeep Holla 91835ae7133SSudeep Holla if (acpi_gbl_FADT.cst_control && !nocst) { 91935ae7133SSudeep Holla status = acpi_os_write_port(acpi_gbl_FADT.smi_command, 92035ae7133SSudeep Holla acpi_gbl_FADT.cst_control, 8); 92135ae7133SSudeep Holla if (ACPI_FAILURE(status)) 92235ae7133SSudeep Holla ACPI_EXCEPTION((AE_INFO, status, 92335ae7133SSudeep Holla "Notifying BIOS of _CST ability failed")); 92435ae7133SSudeep Holla } 92535ae7133SSudeep Holla } 92635ae7133SSudeep Holla #else 92735ae7133SSudeep Holla 92835ae7133SSudeep Holla static inline int disabled_by_idle_boot_param(void) { return 0; } 92935ae7133SSudeep Holla static inline void acpi_processor_cstate_first_run_checks(void) { } 930a36a7fecSSudeep Holla static int acpi_processor_get_cstate_info(struct acpi_processor *pr) 93135ae7133SSudeep Holla { 93235ae7133SSudeep Holla return -ENODEV; 93335ae7133SSudeep Holla } 93435ae7133SSudeep Holla 93535ae7133SSudeep Holla static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr, 93635ae7133SSudeep Holla struct cpuidle_device *dev) 93735ae7133SSudeep Holla { 93835ae7133SSudeep Holla return -EINVAL; 93935ae7133SSudeep Holla } 94035ae7133SSudeep Holla 941a36a7fecSSudeep Holla static int acpi_processor_setup_cstates(struct acpi_processor *pr) 94235ae7133SSudeep Holla { 94335ae7133SSudeep Holla return -EINVAL; 94435ae7133SSudeep Holla } 94535ae7133SSudeep Holla 94635ae7133SSudeep Holla #endif /* CONFIG_ACPI_PROCESSOR_CSTATE */ 94735ae7133SSudeep Holla 948a36a7fecSSudeep Holla struct acpi_lpi_states_array { 949a36a7fecSSudeep Holla unsigned int size; 950a36a7fecSSudeep Holla unsigned int composite_states_size; 951a36a7fecSSudeep Holla struct acpi_lpi_state *entries; 952a36a7fecSSudeep Holla struct acpi_lpi_state *composite_states[ACPI_PROCESSOR_MAX_POWER]; 953a36a7fecSSudeep Holla }; 954a36a7fecSSudeep Holla 955a36a7fecSSudeep Holla static int obj_get_integer(union acpi_object *obj, u32 *value) 956a36a7fecSSudeep Holla { 957a36a7fecSSudeep Holla if (obj->type != ACPI_TYPE_INTEGER) 958a36a7fecSSudeep Holla return -EINVAL; 959a36a7fecSSudeep Holla 960a36a7fecSSudeep Holla *value = obj->integer.value; 961a36a7fecSSudeep Holla return 0; 962a36a7fecSSudeep Holla } 963a36a7fecSSudeep Holla 964a36a7fecSSudeep Holla static int acpi_processor_evaluate_lpi(acpi_handle handle, 965a36a7fecSSudeep Holla struct acpi_lpi_states_array *info) 966a36a7fecSSudeep Holla { 967a36a7fecSSudeep Holla acpi_status status; 968a36a7fecSSudeep Holla int ret = 0; 969a36a7fecSSudeep Holla int pkg_count, state_idx = 1, loop; 970a36a7fecSSudeep Holla struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 971a36a7fecSSudeep Holla union acpi_object *lpi_data; 972a36a7fecSSudeep Holla struct acpi_lpi_state *lpi_state; 973a36a7fecSSudeep Holla 974a36a7fecSSudeep Holla status = acpi_evaluate_object(handle, "_LPI", NULL, &buffer); 975a36a7fecSSudeep Holla if (ACPI_FAILURE(status)) { 976a36a7fecSSudeep Holla ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _LPI, giving up\n")); 977a36a7fecSSudeep Holla return -ENODEV; 978a36a7fecSSudeep Holla } 979a36a7fecSSudeep Holla 980a36a7fecSSudeep Holla lpi_data = buffer.pointer; 981a36a7fecSSudeep Holla 982a36a7fecSSudeep Holla /* There must be at least 4 elements = 3 elements + 1 package */ 983a36a7fecSSudeep Holla if (!lpi_data || lpi_data->type != ACPI_TYPE_PACKAGE || 984a36a7fecSSudeep Holla lpi_data->package.count < 4) { 985a36a7fecSSudeep Holla pr_debug("not enough elements in _LPI\n"); 986a36a7fecSSudeep Holla ret = -ENODATA; 987a36a7fecSSudeep Holla goto end; 988a36a7fecSSudeep Holla } 989a36a7fecSSudeep Holla 990a36a7fecSSudeep Holla pkg_count = lpi_data->package.elements[2].integer.value; 991a36a7fecSSudeep Holla 992a36a7fecSSudeep Holla /* Validate number of power states. */ 993a36a7fecSSudeep Holla if (pkg_count < 1 || pkg_count != lpi_data->package.count - 3) { 994a36a7fecSSudeep Holla pr_debug("count given by _LPI is not valid\n"); 995a36a7fecSSudeep Holla ret = -ENODATA; 996a36a7fecSSudeep Holla goto end; 997a36a7fecSSudeep Holla } 998a36a7fecSSudeep Holla 999a36a7fecSSudeep Holla lpi_state = kcalloc(pkg_count, sizeof(*lpi_state), GFP_KERNEL); 1000a36a7fecSSudeep Holla if (!lpi_state) { 1001a36a7fecSSudeep Holla ret = -ENOMEM; 1002a36a7fecSSudeep Holla goto end; 1003a36a7fecSSudeep Holla } 1004a36a7fecSSudeep Holla 1005a36a7fecSSudeep Holla info->size = pkg_count; 1006a36a7fecSSudeep Holla info->entries = lpi_state; 1007a36a7fecSSudeep Holla 1008a36a7fecSSudeep Holla /* LPI States start at index 3 */ 1009a36a7fecSSudeep Holla for (loop = 3; state_idx <= pkg_count; loop++, state_idx++, lpi_state++) { 1010a36a7fecSSudeep Holla union acpi_object *element, *pkg_elem, *obj; 1011a36a7fecSSudeep Holla 1012a36a7fecSSudeep Holla element = &lpi_data->package.elements[loop]; 1013a36a7fecSSudeep Holla if (element->type != ACPI_TYPE_PACKAGE || element->package.count < 7) 1014a36a7fecSSudeep Holla continue; 1015a36a7fecSSudeep Holla 1016a36a7fecSSudeep Holla pkg_elem = element->package.elements; 1017a36a7fecSSudeep Holla 1018a36a7fecSSudeep Holla obj = pkg_elem + 6; 1019a36a7fecSSudeep Holla if (obj->type == ACPI_TYPE_BUFFER) { 1020a36a7fecSSudeep Holla struct acpi_power_register *reg; 1021a36a7fecSSudeep Holla 1022a36a7fecSSudeep Holla reg = (struct acpi_power_register *)obj->buffer.pointer; 1023a36a7fecSSudeep Holla if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && 1024a36a7fecSSudeep Holla reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) 1025a36a7fecSSudeep Holla continue; 1026a36a7fecSSudeep Holla 1027a36a7fecSSudeep Holla lpi_state->address = reg->address; 1028a36a7fecSSudeep Holla lpi_state->entry_method = 1029a36a7fecSSudeep Holla reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE ? 1030a36a7fecSSudeep Holla ACPI_CSTATE_FFH : ACPI_CSTATE_SYSTEMIO; 1031a36a7fecSSudeep Holla } else if (obj->type == ACPI_TYPE_INTEGER) { 1032a36a7fecSSudeep Holla lpi_state->entry_method = ACPI_CSTATE_INTEGER; 1033a36a7fecSSudeep Holla lpi_state->address = obj->integer.value; 1034a36a7fecSSudeep Holla } else { 1035a36a7fecSSudeep Holla continue; 1036a36a7fecSSudeep Holla } 1037a36a7fecSSudeep Holla 1038a36a7fecSSudeep Holla /* elements[7,8] skipped for now i.e. Residency/Usage counter*/ 1039a36a7fecSSudeep Holla 1040a36a7fecSSudeep Holla obj = pkg_elem + 9; 1041a36a7fecSSudeep Holla if (obj->type == ACPI_TYPE_STRING) 1042a36a7fecSSudeep Holla strlcpy(lpi_state->desc, obj->string.pointer, 1043a36a7fecSSudeep Holla ACPI_CX_DESC_LEN); 1044a36a7fecSSudeep Holla 1045a36a7fecSSudeep Holla lpi_state->index = state_idx; 1046a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 0, &lpi_state->min_residency)) { 1047a36a7fecSSudeep Holla pr_debug("No min. residency found, assuming 10 us\n"); 1048a36a7fecSSudeep Holla lpi_state->min_residency = 10; 1049a36a7fecSSudeep Holla } 1050a36a7fecSSudeep Holla 1051a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 1, &lpi_state->wake_latency)) { 1052a36a7fecSSudeep Holla pr_debug("No wakeup residency found, assuming 10 us\n"); 1053a36a7fecSSudeep Holla lpi_state->wake_latency = 10; 1054a36a7fecSSudeep Holla } 1055a36a7fecSSudeep Holla 1056a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 2, &lpi_state->flags)) 1057a36a7fecSSudeep Holla lpi_state->flags = 0; 1058a36a7fecSSudeep Holla 1059a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 3, &lpi_state->arch_flags)) 1060a36a7fecSSudeep Holla lpi_state->arch_flags = 0; 1061a36a7fecSSudeep Holla 1062a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 4, &lpi_state->res_cnt_freq)) 1063a36a7fecSSudeep Holla lpi_state->res_cnt_freq = 1; 1064a36a7fecSSudeep Holla 1065a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 5, &lpi_state->enable_parent_state)) 1066a36a7fecSSudeep Holla lpi_state->enable_parent_state = 0; 1067a36a7fecSSudeep Holla } 1068a36a7fecSSudeep Holla 1069a36a7fecSSudeep Holla acpi_handle_debug(handle, "Found %d power states\n", state_idx); 1070a36a7fecSSudeep Holla end: 1071a36a7fecSSudeep Holla kfree(buffer.pointer); 1072a36a7fecSSudeep Holla return ret; 1073a36a7fecSSudeep Holla } 1074a36a7fecSSudeep Holla 1075a36a7fecSSudeep Holla /* 1076a36a7fecSSudeep Holla * flat_state_cnt - the number of composite LPI states after the process of flattening 1077a36a7fecSSudeep Holla */ 1078a36a7fecSSudeep Holla static int flat_state_cnt; 1079a36a7fecSSudeep Holla 1080a36a7fecSSudeep Holla /** 1081a36a7fecSSudeep Holla * combine_lpi_states - combine local and parent LPI states to form a composite LPI state 1082a36a7fecSSudeep Holla * 1083a36a7fecSSudeep Holla * @local: local LPI state 1084a36a7fecSSudeep Holla * @parent: parent LPI state 1085a36a7fecSSudeep Holla * @result: composite LPI state 1086a36a7fecSSudeep Holla */ 1087a36a7fecSSudeep Holla static bool combine_lpi_states(struct acpi_lpi_state *local, 1088a36a7fecSSudeep Holla struct acpi_lpi_state *parent, 1089a36a7fecSSudeep Holla struct acpi_lpi_state *result) 1090a36a7fecSSudeep Holla { 1091a36a7fecSSudeep Holla if (parent->entry_method == ACPI_CSTATE_INTEGER) { 1092a36a7fecSSudeep Holla if (!parent->address) /* 0 means autopromotable */ 1093a36a7fecSSudeep Holla return false; 1094a36a7fecSSudeep Holla result->address = local->address + parent->address; 1095a36a7fecSSudeep Holla } else { 1096a36a7fecSSudeep Holla result->address = parent->address; 1097a36a7fecSSudeep Holla } 1098a36a7fecSSudeep Holla 1099a36a7fecSSudeep Holla result->min_residency = max(local->min_residency, parent->min_residency); 1100a36a7fecSSudeep Holla result->wake_latency = local->wake_latency + parent->wake_latency; 1101a36a7fecSSudeep Holla result->enable_parent_state = parent->enable_parent_state; 1102a36a7fecSSudeep Holla result->entry_method = local->entry_method; 1103a36a7fecSSudeep Holla 1104a36a7fecSSudeep Holla result->flags = parent->flags; 1105a36a7fecSSudeep Holla result->arch_flags = parent->arch_flags; 1106a36a7fecSSudeep Holla result->index = parent->index; 1107a36a7fecSSudeep Holla 1108a36a7fecSSudeep Holla strlcpy(result->desc, local->desc, ACPI_CX_DESC_LEN); 1109a36a7fecSSudeep Holla strlcat(result->desc, "+", ACPI_CX_DESC_LEN); 1110a36a7fecSSudeep Holla strlcat(result->desc, parent->desc, ACPI_CX_DESC_LEN); 1111a36a7fecSSudeep Holla return true; 1112a36a7fecSSudeep Holla } 1113a36a7fecSSudeep Holla 1114a36a7fecSSudeep Holla #define ACPI_LPI_STATE_FLAGS_ENABLED BIT(0) 1115a36a7fecSSudeep Holla 1116a36a7fecSSudeep Holla static void stash_composite_state(struct acpi_lpi_states_array *curr_level, 1117a36a7fecSSudeep Holla struct acpi_lpi_state *t) 1118a36a7fecSSudeep Holla { 1119a36a7fecSSudeep Holla curr_level->composite_states[curr_level->composite_states_size++] = t; 1120a36a7fecSSudeep Holla } 1121a36a7fecSSudeep Holla 1122a36a7fecSSudeep Holla static int flatten_lpi_states(struct acpi_processor *pr, 1123a36a7fecSSudeep Holla struct acpi_lpi_states_array *curr_level, 1124a36a7fecSSudeep Holla struct acpi_lpi_states_array *prev_level) 1125a36a7fecSSudeep Holla { 1126a36a7fecSSudeep Holla int i, j, state_count = curr_level->size; 1127a36a7fecSSudeep Holla struct acpi_lpi_state *p, *t = curr_level->entries; 1128a36a7fecSSudeep Holla 1129a36a7fecSSudeep Holla curr_level->composite_states_size = 0; 1130a36a7fecSSudeep Holla for (j = 0; j < state_count; j++, t++) { 1131a36a7fecSSudeep Holla struct acpi_lpi_state *flpi; 1132a36a7fecSSudeep Holla 1133a36a7fecSSudeep Holla if (!(t->flags & ACPI_LPI_STATE_FLAGS_ENABLED)) 1134a36a7fecSSudeep Holla continue; 1135a36a7fecSSudeep Holla 1136a36a7fecSSudeep Holla if (flat_state_cnt >= ACPI_PROCESSOR_MAX_POWER) { 1137a36a7fecSSudeep Holla pr_warn("Limiting number of LPI states to max (%d)\n", 1138a36a7fecSSudeep Holla ACPI_PROCESSOR_MAX_POWER); 1139a36a7fecSSudeep Holla pr_warn("Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n"); 1140a36a7fecSSudeep Holla break; 1141a36a7fecSSudeep Holla } 1142a36a7fecSSudeep Holla 1143a36a7fecSSudeep Holla flpi = &pr->power.lpi_states[flat_state_cnt]; 1144a36a7fecSSudeep Holla 1145a36a7fecSSudeep Holla if (!prev_level) { /* leaf/processor node */ 1146a36a7fecSSudeep Holla memcpy(flpi, t, sizeof(*t)); 1147a36a7fecSSudeep Holla stash_composite_state(curr_level, flpi); 1148a36a7fecSSudeep Holla flat_state_cnt++; 1149a36a7fecSSudeep Holla continue; 1150a36a7fecSSudeep Holla } 1151a36a7fecSSudeep Holla 1152a36a7fecSSudeep Holla for (i = 0; i < prev_level->composite_states_size; i++) { 1153a36a7fecSSudeep Holla p = prev_level->composite_states[i]; 1154a36a7fecSSudeep Holla if (t->index <= p->enable_parent_state && 1155a36a7fecSSudeep Holla combine_lpi_states(p, t, flpi)) { 1156a36a7fecSSudeep Holla stash_composite_state(curr_level, flpi); 1157a36a7fecSSudeep Holla flat_state_cnt++; 1158a36a7fecSSudeep Holla flpi++; 1159a36a7fecSSudeep Holla } 1160a36a7fecSSudeep Holla } 1161a36a7fecSSudeep Holla } 1162a36a7fecSSudeep Holla 1163a36a7fecSSudeep Holla kfree(curr_level->entries); 1164a36a7fecSSudeep Holla return 0; 1165a36a7fecSSudeep Holla } 1166a36a7fecSSudeep Holla 1167a36a7fecSSudeep Holla static int acpi_processor_get_lpi_info(struct acpi_processor *pr) 1168a36a7fecSSudeep Holla { 1169a36a7fecSSudeep Holla int ret, i; 1170a36a7fecSSudeep Holla acpi_status status; 1171a36a7fecSSudeep Holla acpi_handle handle = pr->handle, pr_ahandle; 1172a36a7fecSSudeep Holla struct acpi_device *d = NULL; 1173a36a7fecSSudeep Holla struct acpi_lpi_states_array info[2], *tmp, *prev, *curr; 1174a36a7fecSSudeep Holla 1175a36a7fecSSudeep Holla if (!osc_pc_lpi_support_confirmed) 1176a36a7fecSSudeep Holla return -EOPNOTSUPP; 1177a36a7fecSSudeep Holla 1178a36a7fecSSudeep Holla if (!acpi_has_method(handle, "_LPI")) 1179a36a7fecSSudeep Holla return -EINVAL; 1180a36a7fecSSudeep Holla 1181a36a7fecSSudeep Holla flat_state_cnt = 0; 1182a36a7fecSSudeep Holla prev = &info[0]; 1183a36a7fecSSudeep Holla curr = &info[1]; 1184a36a7fecSSudeep Holla handle = pr->handle; 1185a36a7fecSSudeep Holla ret = acpi_processor_evaluate_lpi(handle, prev); 1186a36a7fecSSudeep Holla if (ret) 1187a36a7fecSSudeep Holla return ret; 1188a36a7fecSSudeep Holla flatten_lpi_states(pr, prev, NULL); 1189a36a7fecSSudeep Holla 1190a36a7fecSSudeep Holla status = acpi_get_parent(handle, &pr_ahandle); 1191a36a7fecSSudeep Holla while (ACPI_SUCCESS(status)) { 1192a36a7fecSSudeep Holla acpi_bus_get_device(pr_ahandle, &d); 1193a36a7fecSSudeep Holla handle = pr_ahandle; 1194a36a7fecSSudeep Holla 1195a36a7fecSSudeep Holla if (strcmp(acpi_device_hid(d), ACPI_PROCESSOR_CONTAINER_HID)) 1196a36a7fecSSudeep Holla break; 1197a36a7fecSSudeep Holla 1198a36a7fecSSudeep Holla /* can be optional ? */ 1199a36a7fecSSudeep Holla if (!acpi_has_method(handle, "_LPI")) 1200a36a7fecSSudeep Holla break; 1201a36a7fecSSudeep Holla 1202a36a7fecSSudeep Holla ret = acpi_processor_evaluate_lpi(handle, curr); 1203a36a7fecSSudeep Holla if (ret) 1204a36a7fecSSudeep Holla break; 1205a36a7fecSSudeep Holla 1206a36a7fecSSudeep Holla /* flatten all the LPI states in this level of hierarchy */ 1207a36a7fecSSudeep Holla flatten_lpi_states(pr, curr, prev); 1208a36a7fecSSudeep Holla 1209a36a7fecSSudeep Holla tmp = prev, prev = curr, curr = tmp; 1210a36a7fecSSudeep Holla 1211a36a7fecSSudeep Holla status = acpi_get_parent(handle, &pr_ahandle); 1212a36a7fecSSudeep Holla } 1213a36a7fecSSudeep Holla 1214a36a7fecSSudeep Holla pr->power.count = flat_state_cnt; 1215a36a7fecSSudeep Holla /* reset the index after flattening */ 1216a36a7fecSSudeep Holla for (i = 0; i < pr->power.count; i++) 1217a36a7fecSSudeep Holla pr->power.lpi_states[i].index = i; 1218a36a7fecSSudeep Holla 1219a36a7fecSSudeep Holla /* Tell driver that _LPI is supported. */ 1220a36a7fecSSudeep Holla pr->flags.has_lpi = 1; 1221a36a7fecSSudeep Holla pr->flags.power = 1; 1222a36a7fecSSudeep Holla 1223a36a7fecSSudeep Holla return 0; 1224a36a7fecSSudeep Holla } 1225a36a7fecSSudeep Holla 1226a36a7fecSSudeep Holla int __weak acpi_processor_ffh_lpi_probe(unsigned int cpu) 1227a36a7fecSSudeep Holla { 1228a36a7fecSSudeep Holla return -ENODEV; 1229a36a7fecSSudeep Holla } 1230a36a7fecSSudeep Holla 1231a36a7fecSSudeep Holla int __weak acpi_processor_ffh_lpi_enter(struct acpi_lpi_state *lpi) 1232a36a7fecSSudeep Holla { 1233a36a7fecSSudeep Holla return -ENODEV; 1234a36a7fecSSudeep Holla } 1235a36a7fecSSudeep Holla 1236a36a7fecSSudeep Holla /** 1237a36a7fecSSudeep Holla * acpi_idle_lpi_enter - enters an ACPI any LPI state 1238a36a7fecSSudeep Holla * @dev: the target CPU 1239a36a7fecSSudeep Holla * @drv: cpuidle driver containing cpuidle state info 1240a36a7fecSSudeep Holla * @index: index of target state 1241a36a7fecSSudeep Holla * 1242a36a7fecSSudeep Holla * Return: 0 for success or negative value for error 1243a36a7fecSSudeep Holla */ 1244a36a7fecSSudeep Holla static int acpi_idle_lpi_enter(struct cpuidle_device *dev, 1245a36a7fecSSudeep Holla struct cpuidle_driver *drv, int index) 1246a36a7fecSSudeep Holla { 1247a36a7fecSSudeep Holla struct acpi_processor *pr; 1248a36a7fecSSudeep Holla struct acpi_lpi_state *lpi; 1249a36a7fecSSudeep Holla 1250a36a7fecSSudeep Holla pr = __this_cpu_read(processors); 1251a36a7fecSSudeep Holla 1252a36a7fecSSudeep Holla if (unlikely(!pr)) 1253a36a7fecSSudeep Holla return -EINVAL; 1254a36a7fecSSudeep Holla 1255a36a7fecSSudeep Holla lpi = &pr->power.lpi_states[index]; 1256a36a7fecSSudeep Holla if (lpi->entry_method == ACPI_CSTATE_FFH) 1257a36a7fecSSudeep Holla return acpi_processor_ffh_lpi_enter(lpi); 1258a36a7fecSSudeep Holla 1259a36a7fecSSudeep Holla return -EINVAL; 1260a36a7fecSSudeep Holla } 1261a36a7fecSSudeep Holla 1262a36a7fecSSudeep Holla static int acpi_processor_setup_lpi_states(struct acpi_processor *pr) 1263a36a7fecSSudeep Holla { 1264a36a7fecSSudeep Holla int i; 1265a36a7fecSSudeep Holla struct acpi_lpi_state *lpi; 1266a36a7fecSSudeep Holla struct cpuidle_state *state; 1267a36a7fecSSudeep Holla struct cpuidle_driver *drv = &acpi_idle_driver; 1268a36a7fecSSudeep Holla 1269a36a7fecSSudeep Holla if (!pr->flags.has_lpi) 1270a36a7fecSSudeep Holla return -EOPNOTSUPP; 1271a36a7fecSSudeep Holla 1272a36a7fecSSudeep Holla for (i = 0; i < pr->power.count && i < CPUIDLE_STATE_MAX; i++) { 1273a36a7fecSSudeep Holla lpi = &pr->power.lpi_states[i]; 1274a36a7fecSSudeep Holla 1275a36a7fecSSudeep Holla state = &drv->states[i]; 1276a36a7fecSSudeep Holla snprintf(state->name, CPUIDLE_NAME_LEN, "LPI-%d", i); 1277a36a7fecSSudeep Holla strlcpy(state->desc, lpi->desc, CPUIDLE_DESC_LEN); 1278a36a7fecSSudeep Holla state->exit_latency = lpi->wake_latency; 1279a36a7fecSSudeep Holla state->target_residency = lpi->min_residency; 1280a36a7fecSSudeep Holla if (lpi->arch_flags) 1281a36a7fecSSudeep Holla state->flags |= CPUIDLE_FLAG_TIMER_STOP; 1282a36a7fecSSudeep Holla state->enter = acpi_idle_lpi_enter; 1283a36a7fecSSudeep Holla drv->safe_state_index = i; 1284a36a7fecSSudeep Holla } 1285a36a7fecSSudeep Holla 1286a36a7fecSSudeep Holla drv->state_count = i; 1287a36a7fecSSudeep Holla 1288a36a7fecSSudeep Holla return 0; 1289a36a7fecSSudeep Holla } 1290a36a7fecSSudeep Holla 1291a36a7fecSSudeep Holla /** 1292a36a7fecSSudeep Holla * acpi_processor_setup_cpuidle_states- prepares and configures cpuidle 1293a36a7fecSSudeep Holla * global state data i.e. idle routines 1294a36a7fecSSudeep Holla * 1295a36a7fecSSudeep Holla * @pr: the ACPI processor 1296a36a7fecSSudeep Holla */ 1297a36a7fecSSudeep Holla static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr) 1298a36a7fecSSudeep Holla { 1299a36a7fecSSudeep Holla int i; 1300a36a7fecSSudeep Holla struct cpuidle_driver *drv = &acpi_idle_driver; 1301a36a7fecSSudeep Holla 1302a36a7fecSSudeep Holla if (!pr->flags.power_setup_done || !pr->flags.power) 1303a36a7fecSSudeep Holla return -EINVAL; 1304a36a7fecSSudeep Holla 1305a36a7fecSSudeep Holla drv->safe_state_index = -1; 1306dc2251bfSRafael J. Wysocki for (i = ACPI_IDLE_STATE_START; i < CPUIDLE_STATE_MAX; i++) { 1307a36a7fecSSudeep Holla drv->states[i].name[0] = '\0'; 1308a36a7fecSSudeep Holla drv->states[i].desc[0] = '\0'; 1309a36a7fecSSudeep Holla } 1310a36a7fecSSudeep Holla 1311a36a7fecSSudeep Holla if (pr->flags.has_lpi) 1312a36a7fecSSudeep Holla return acpi_processor_setup_lpi_states(pr); 1313a36a7fecSSudeep Holla 1314a36a7fecSSudeep Holla return acpi_processor_setup_cstates(pr); 1315a36a7fecSSudeep Holla } 1316a36a7fecSSudeep Holla 1317a36a7fecSSudeep Holla /** 1318a36a7fecSSudeep Holla * acpi_processor_setup_cpuidle_dev - prepares and configures CPUIDLE 1319a36a7fecSSudeep Holla * device i.e. per-cpu data 1320a36a7fecSSudeep Holla * 1321a36a7fecSSudeep Holla * @pr: the ACPI processor 1322a36a7fecSSudeep Holla * @dev : the cpuidle device 1323a36a7fecSSudeep Holla */ 1324a36a7fecSSudeep Holla static int acpi_processor_setup_cpuidle_dev(struct acpi_processor *pr, 1325a36a7fecSSudeep Holla struct cpuidle_device *dev) 1326a36a7fecSSudeep Holla { 1327a36a7fecSSudeep Holla if (!pr->flags.power_setup_done || !pr->flags.power || !dev) 1328a36a7fecSSudeep Holla return -EINVAL; 1329a36a7fecSSudeep Holla 1330a36a7fecSSudeep Holla dev->cpu = pr->id; 1331a36a7fecSSudeep Holla if (pr->flags.has_lpi) 1332a36a7fecSSudeep Holla return acpi_processor_ffh_lpi_probe(pr->id); 1333a36a7fecSSudeep Holla 1334a36a7fecSSudeep Holla return acpi_processor_setup_cpuidle_cx(pr, dev); 1335a36a7fecSSudeep Holla } 1336a36a7fecSSudeep Holla 1337a36a7fecSSudeep Holla static int acpi_processor_get_power_info(struct acpi_processor *pr) 1338a36a7fecSSudeep Holla { 1339a36a7fecSSudeep Holla int ret; 1340a36a7fecSSudeep Holla 1341a36a7fecSSudeep Holla ret = acpi_processor_get_lpi_info(pr); 1342a36a7fecSSudeep Holla if (ret) 1343a36a7fecSSudeep Holla ret = acpi_processor_get_cstate_info(pr); 1344a36a7fecSSudeep Holla 1345a36a7fecSSudeep Holla return ret; 1346a36a7fecSSudeep Holla } 1347a36a7fecSSudeep Holla 134846bcfad7SDeepthi Dharwar int acpi_processor_hotplug(struct acpi_processor *pr) 13494f86d3a8SLen Brown { 1350dcb84f33SVenkatesh Pallipadi int ret = 0; 1351e8b1b59dSWei Yongjun struct cpuidle_device *dev; 13524f86d3a8SLen Brown 1353d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 135436a91358SVenkatesh Pallipadi return 0; 135536a91358SVenkatesh Pallipadi 13564f86d3a8SLen Brown if (!pr->flags.power_setup_done) 13574f86d3a8SLen Brown return -ENODEV; 13584f86d3a8SLen Brown 1359e8b1b59dSWei Yongjun dev = per_cpu(acpi_cpuidle_device, pr->id); 13604f86d3a8SLen Brown cpuidle_pause_and_lock(); 13613d339dcbSDaniel Lezcano cpuidle_disable_device(dev); 1362a36a7fecSSudeep Holla ret = acpi_processor_get_power_info(pr); 1363a36a7fecSSudeep Holla if (!ret && pr->flags.power) { 1364a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(pr, dev); 13653d339dcbSDaniel Lezcano ret = cpuidle_enable_device(dev); 1366dcb84f33SVenkatesh Pallipadi } 13674f86d3a8SLen Brown cpuidle_resume_and_unlock(); 13684f86d3a8SLen Brown 13694f86d3a8SLen Brown return ret; 13704f86d3a8SLen Brown } 13714f86d3a8SLen Brown 1372a36a7fecSSudeep Holla int acpi_processor_power_state_has_changed(struct acpi_processor *pr) 137346bcfad7SDeepthi Dharwar { 137446bcfad7SDeepthi Dharwar int cpu; 137546bcfad7SDeepthi Dharwar struct acpi_processor *_pr; 13763d339dcbSDaniel Lezcano struct cpuidle_device *dev; 137746bcfad7SDeepthi Dharwar 137846bcfad7SDeepthi Dharwar if (disabled_by_idle_boot_param()) 137946bcfad7SDeepthi Dharwar return 0; 138046bcfad7SDeepthi Dharwar 138146bcfad7SDeepthi Dharwar if (!pr->flags.power_setup_done) 138246bcfad7SDeepthi Dharwar return -ENODEV; 138346bcfad7SDeepthi Dharwar 138446bcfad7SDeepthi Dharwar /* 138546bcfad7SDeepthi Dharwar * FIXME: Design the ACPI notification to make it once per 138646bcfad7SDeepthi Dharwar * system instead of once per-cpu. This condition is a hack 138746bcfad7SDeepthi Dharwar * to make the code that updates C-States be called once. 138846bcfad7SDeepthi Dharwar */ 138946bcfad7SDeepthi Dharwar 13909505626dSPaul E. McKenney if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) { 139146bcfad7SDeepthi Dharwar 139246bcfad7SDeepthi Dharwar /* Protect against cpu-hotplug */ 139346bcfad7SDeepthi Dharwar get_online_cpus(); 13946726655dSJiri Kosina cpuidle_pause_and_lock(); 139546bcfad7SDeepthi Dharwar 139646bcfad7SDeepthi Dharwar /* Disable all cpuidle devices */ 139746bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) { 139846bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu); 139946bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done) 140046bcfad7SDeepthi Dharwar continue; 14013d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu); 14023d339dcbSDaniel Lezcano cpuidle_disable_device(dev); 140346bcfad7SDeepthi Dharwar } 140446bcfad7SDeepthi Dharwar 140546bcfad7SDeepthi Dharwar /* Populate Updated C-state information */ 1406f427e5f1SThomas Schlichter acpi_processor_get_power_info(pr); 140746bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr); 140846bcfad7SDeepthi Dharwar 140946bcfad7SDeepthi Dharwar /* Enable all cpuidle devices */ 141046bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) { 141146bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu); 141246bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done) 141346bcfad7SDeepthi Dharwar continue; 141446bcfad7SDeepthi Dharwar acpi_processor_get_power_info(_pr); 141546bcfad7SDeepthi Dharwar if (_pr->flags.power) { 14163d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu); 1417a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(_pr, dev); 14183d339dcbSDaniel Lezcano cpuidle_enable_device(dev); 141946bcfad7SDeepthi Dharwar } 142046bcfad7SDeepthi Dharwar } 142146bcfad7SDeepthi Dharwar cpuidle_resume_and_unlock(); 14226726655dSJiri Kosina put_online_cpus(); 142346bcfad7SDeepthi Dharwar } 142446bcfad7SDeepthi Dharwar 142546bcfad7SDeepthi Dharwar return 0; 142646bcfad7SDeepthi Dharwar } 142746bcfad7SDeepthi Dharwar 142846bcfad7SDeepthi Dharwar static int acpi_processor_registered; 142946bcfad7SDeepthi Dharwar 1430fe7bf106SPaul Gortmaker int acpi_processor_power_init(struct acpi_processor *pr) 14311da177e4SLinus Torvalds { 143246bcfad7SDeepthi Dharwar int retval; 14333d339dcbSDaniel Lezcano struct cpuidle_device *dev; 14341da177e4SLinus Torvalds 1435d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 143636a91358SVenkatesh Pallipadi return 0; 14371da177e4SLinus Torvalds 143835ae7133SSudeep Holla acpi_processor_cstate_first_run_checks(); 14391da177e4SLinus Torvalds 144035ae7133SSudeep Holla if (!acpi_processor_get_power_info(pr)) 14414f86d3a8SLen Brown pr->flags.power_setup_done = 1; 14421da177e4SLinus Torvalds 14431da177e4SLinus Torvalds /* 14441da177e4SLinus Torvalds * Install the idle handler if processor power management is supported. 14451da177e4SLinus Torvalds * Note that we use previously set idle handler will be used on 14461da177e4SLinus Torvalds * platforms that only support C1. 14471da177e4SLinus Torvalds */ 144836a91358SVenkatesh Pallipadi if (pr->flags.power) { 144946bcfad7SDeepthi Dharwar /* Register acpi_idle_driver if not already registered */ 145046bcfad7SDeepthi Dharwar if (!acpi_processor_registered) { 145146bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr); 145246bcfad7SDeepthi Dharwar retval = cpuidle_register_driver(&acpi_idle_driver); 145346bcfad7SDeepthi Dharwar if (retval) 145446bcfad7SDeepthi Dharwar return retval; 1455b6ec26fbSSudeep Holla pr_debug("%s registered with cpuidle\n", 145646bcfad7SDeepthi Dharwar acpi_idle_driver.name); 145746bcfad7SDeepthi Dharwar } 14583d339dcbSDaniel Lezcano 14593d339dcbSDaniel Lezcano dev = kzalloc(sizeof(*dev), GFP_KERNEL); 14603d339dcbSDaniel Lezcano if (!dev) 14613d339dcbSDaniel Lezcano return -ENOMEM; 14623d339dcbSDaniel Lezcano per_cpu(acpi_cpuidle_device, pr->id) = dev; 14633d339dcbSDaniel Lezcano 1464a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(pr, dev); 14653d339dcbSDaniel Lezcano 146646bcfad7SDeepthi Dharwar /* Register per-cpu cpuidle_device. Cpuidle driver 146746bcfad7SDeepthi Dharwar * must already be registered before registering device 146846bcfad7SDeepthi Dharwar */ 14693d339dcbSDaniel Lezcano retval = cpuidle_register_device(dev); 147046bcfad7SDeepthi Dharwar if (retval) { 147146bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0) 147246bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver); 147346bcfad7SDeepthi Dharwar return retval; 147446bcfad7SDeepthi Dharwar } 147546bcfad7SDeepthi Dharwar acpi_processor_registered++; 14761da177e4SLinus Torvalds } 1477d550d98dSPatrick Mochel return 0; 14781da177e4SLinus Torvalds } 14791da177e4SLinus Torvalds 148038a991b6SDaniel Lezcano int acpi_processor_power_exit(struct acpi_processor *pr) 14811da177e4SLinus Torvalds { 14823d339dcbSDaniel Lezcano struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id); 14833d339dcbSDaniel Lezcano 1484d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 148536a91358SVenkatesh Pallipadi return 0; 148636a91358SVenkatesh Pallipadi 148746bcfad7SDeepthi Dharwar if (pr->flags.power) { 14883d339dcbSDaniel Lezcano cpuidle_unregister_device(dev); 148946bcfad7SDeepthi Dharwar acpi_processor_registered--; 149046bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0) 149146bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver); 149246bcfad7SDeepthi Dharwar } 14931da177e4SLinus Torvalds 149446bcfad7SDeepthi Dharwar pr->flags.power_setup_done = 0; 1495d550d98dSPatrick Mochel return 0; 14961da177e4SLinus Torvalds } 1497