1c942fddfSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * processor_idle - idle state submodule to the ACPI processor driver 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 61da177e4SLinus Torvalds * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 7c5ab81caSDominik Brodowski * Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de> 81da177e4SLinus Torvalds * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> 91da177e4SLinus Torvalds * - Added processor hotplug support 1002df8b93SVenkatesh Pallipadi * Copyright (C) 2005 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com> 1102df8b93SVenkatesh Pallipadi * - Added support for C3 on SMP 121da177e4SLinus Torvalds */ 13b6ec26fbSSudeep Holla #define pr_fmt(fmt) "ACPI: " fmt 141da177e4SLinus Torvalds 151da177e4SLinus Torvalds #include <linux/module.h> 161da177e4SLinus Torvalds #include <linux/acpi.h> 171da177e4SLinus Torvalds #include <linux/dmi.h> 184e57b681STim Schmielau #include <linux/sched.h> /* need_resched() */ 1965ea8f2cSMario Limonciello #include <linux/sort.h> 20ee41eebfSThomas Gleixner #include <linux/tick.h> 214f86d3a8SLen Brown #include <linux/cpuidle.h> 226727ad9eSChris Metcalf #include <linux/cpu.h> 230e6078c3SGuo Zhengkui #include <linux/minmax.h> 242a606a18SStephane Eranian #include <linux/perf_event.h> 258b48463fSLv Zheng #include <acpi/processor.h> 26e67198ccSFrederic Weisbecker #include <linux/context_tracking.h> 271da177e4SLinus Torvalds 283434933bSThomas Gleixner /* 293434933bSThomas Gleixner * Include the apic definitions for x86 to have the APIC timer related defines 303434933bSThomas Gleixner * available also for UP (on SMP it gets magically included via linux/smp.h). 313434933bSThomas Gleixner * asm/acpi.h is not an option, as it would require more include magic. Also 323434933bSThomas Gleixner * creating an empty asm-ia64/apic.h would just trade pest vs. cholera. 333434933bSThomas Gleixner */ 343434933bSThomas Gleixner #ifdef CONFIG_X86 353434933bSThomas Gleixner #include <asm/apic.h> 368cdddd18SVitaly Kuznetsov #include <asm/cpu.h> 373434933bSThomas Gleixner #endif 383434933bSThomas Gleixner 39dc2251bfSRafael J. Wysocki #define ACPI_IDLE_STATE_START (IS_ENABLED(CONFIG_ARCH_HAS_CPU_RELAX) ? 1 : 0) 40dc2251bfSRafael J. Wysocki 414f86d3a8SLen Brown static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER; 4227263b34SYajun Deng module_param(max_cstate, uint, 0400); 4327263b34SYajun Deng static bool nocst __read_mostly; 4427263b34SYajun Deng module_param(nocst, bool, 0400); 4527263b34SYajun Deng static bool bm_check_disable __read_mostly; 4627263b34SYajun Deng module_param(bm_check_disable, bool, 0400); 471da177e4SLinus Torvalds 4825de5718SLen Brown static unsigned int latency_factor __read_mostly = 2; 494963f620SLen Brown module_param(latency_factor, uint, 0644); 501da177e4SLinus Torvalds 513d339dcbSDaniel Lezcano static DEFINE_PER_CPU(struct cpuidle_device *, acpi_cpuidle_device); 523d339dcbSDaniel Lezcano 5335ae7133SSudeep Holla struct cpuidle_driver acpi_idle_driver = { 5435ae7133SSudeep Holla .name = "acpi_idle", 5535ae7133SSudeep Holla .owner = THIS_MODULE, 5635ae7133SSudeep Holla }; 5735ae7133SSudeep Holla 5835ae7133SSudeep Holla #ifdef CONFIG_ACPI_PROCESSOR_CSTATE 5925528213SPeter Zijlstra static 6025528213SPeter Zijlstra DEFINE_PER_CPU(struct acpi_processor_cx * [CPUIDLE_STATE_MAX], acpi_cstate); 61ac3ebafaSDaniel Lezcano 62d1896049SThomas Renninger static int disabled_by_idle_boot_param(void) 63d1896049SThomas Renninger { 64d1896049SThomas Renninger return boot_option_idle_override == IDLE_POLL || 65d1896049SThomas Renninger boot_option_idle_override == IDLE_HALT; 66d1896049SThomas Renninger } 67d1896049SThomas Renninger 681da177e4SLinus Torvalds /* 691da177e4SLinus Torvalds * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3. 701da177e4SLinus Torvalds * For now disable this. Probably a bug somewhere else. 711da177e4SLinus Torvalds * 721da177e4SLinus Torvalds * To skip this limit, boot/load with a large max_cstate limit. 731da177e4SLinus Torvalds */ 741855256cSJeff Garzik static int set_max_cstate(const struct dmi_system_id *id) 751da177e4SLinus Torvalds { 761da177e4SLinus Torvalds if (max_cstate > ACPI_PROCESSOR_MAX_POWER) 771da177e4SLinus Torvalds return 0; 781da177e4SLinus Torvalds 79b6ec26fbSSudeep Holla pr_notice("%s detected - limiting to C%ld max_cstate." 801da177e4SLinus Torvalds " Override with \"processor.max_cstate=%d\"\n", id->ident, 813d35600aSLen Brown (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1); 821da177e4SLinus Torvalds 833d35600aSLen Brown max_cstate = (long)id->driver_data; 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds return 0; 861da177e4SLinus Torvalds } 871da177e4SLinus Torvalds 88b0346688SMathias Krause static const struct dmi_system_id processor_power_dmi_table[] = { 89335f16beSDavid Shaohua Li { set_max_cstate, "Clevo 5600D", { 90876c184bSThomas Rosner DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"), 91876c184bSThomas Rosner DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")}, 92335f16beSDavid Shaohua Li (void *)2}, 93370d5cd8SArjan van de Ven { set_max_cstate, "Pavilion zv5000", { 94370d5cd8SArjan van de Ven DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 95370d5cd8SArjan van de Ven DMI_MATCH(DMI_PRODUCT_NAME,"Pavilion zv5000 (DS502A#ABA)")}, 96370d5cd8SArjan van de Ven (void *)1}, 97370d5cd8SArjan van de Ven { set_max_cstate, "Asus L8400B", { 98370d5cd8SArjan van de Ven DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."), 99370d5cd8SArjan van de Ven DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")}, 100370d5cd8SArjan van de Ven (void *)1}, 1011da177e4SLinus Torvalds {}, 1021da177e4SLinus Torvalds }; 1031da177e4SLinus Torvalds 1044f86d3a8SLen Brown 1052e906655Svenkatesh.pallipadi@intel.com /* 1062e906655Svenkatesh.pallipadi@intel.com * Callers should disable interrupts before the call and enable 1072e906655Svenkatesh.pallipadi@intel.com * interrupts after return. 1082e906655Svenkatesh.pallipadi@intel.com */ 1096727ad9eSChris Metcalf static void __cpuidle acpi_safe_halt(void) 110ddc081a1SVenkatesh Pallipadi { 111ea811747SPeter Zijlstra if (!tif_need_resched()) { 112*8ce78470SPeter Zijlstra raw_safe_halt(); 113*8ce78470SPeter Zijlstra raw_local_irq_disable(); 11471e93d15SVenki Pallipadi } 115ddc081a1SVenkatesh Pallipadi } 116ddc081a1SVenkatesh Pallipadi 117169a0abbSThomas Gleixner #ifdef ARCH_APICTIMER_STOPS_ON_C3 118169a0abbSThomas Gleixner 119169a0abbSThomas Gleixner /* 120169a0abbSThomas Gleixner * Some BIOS implementations switch to C3 in the published C2 state. 121296d93cdSLinus Torvalds * This seems to be a common problem on AMD boxen, but other vendors 122296d93cdSLinus Torvalds * are affected too. We pick the most conservative approach: we assume 123296d93cdSLinus Torvalds * that the local APIC stops in both C2 and C3. 124169a0abbSThomas Gleixner */ 1257e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr, 126169a0abbSThomas Gleixner struct acpi_processor_cx *cx) 127169a0abbSThomas Gleixner { 128169a0abbSThomas Gleixner struct acpi_processor_power *pwr = &pr->power; 129e585bef8SThomas Gleixner u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2; 130169a0abbSThomas Gleixner 131db954b58SVenkatesh Pallipadi if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT)) 132db954b58SVenkatesh Pallipadi return; 133db954b58SVenkatesh Pallipadi 13407c94a38SBorislav Petkov if (boot_cpu_has_bug(X86_BUG_AMD_APIC_C1E)) 13587ad57baSShaohua Li type = ACPI_STATE_C1; 13687ad57baSShaohua Li 137169a0abbSThomas Gleixner /* 138169a0abbSThomas Gleixner * Check, if one of the previous states already marked the lapic 139169a0abbSThomas Gleixner * unstable 140169a0abbSThomas Gleixner */ 141169a0abbSThomas Gleixner if (pwr->timer_broadcast_on_state < state) 142169a0abbSThomas Gleixner return; 143169a0abbSThomas Gleixner 144e585bef8SThomas Gleixner if (cx->type >= type) 145169a0abbSThomas Gleixner pr->power.timer_broadcast_on_state = state; 146169a0abbSThomas Gleixner } 147169a0abbSThomas Gleixner 148918aae42SHidetoshi Seto static void __lapic_timer_propagate_broadcast(void *arg) 149169a0abbSThomas Gleixner { 150f833bab8SSuresh Siddha struct acpi_processor *pr = (struct acpi_processor *) arg; 151e9e2cdb4SThomas Gleixner 152ee41eebfSThomas Gleixner if (pr->power.timer_broadcast_on_state < INT_MAX) 153ee41eebfSThomas Gleixner tick_broadcast_enable(); 154ee41eebfSThomas Gleixner else 155ee41eebfSThomas Gleixner tick_broadcast_disable(); 156e9e2cdb4SThomas Gleixner } 157e9e2cdb4SThomas Gleixner 158918aae42SHidetoshi Seto static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) 159918aae42SHidetoshi Seto { 160918aae42SHidetoshi Seto smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast, 161918aae42SHidetoshi Seto (void *)pr, 1); 162918aae42SHidetoshi Seto } 163918aae42SHidetoshi Seto 164e9e2cdb4SThomas Gleixner /* Power(C) State timer broadcast control */ 165aa6b43d5SPeter Zijlstra static bool lapic_timer_needs_broadcast(struct acpi_processor *pr, 166aa6b43d5SPeter Zijlstra struct acpi_processor_cx *cx) 167e9e2cdb4SThomas Gleixner { 168aa6b43d5SPeter Zijlstra return cx - pr->power.states >= pr->power.timer_broadcast_on_state; 169169a0abbSThomas Gleixner } 170169a0abbSThomas Gleixner 171169a0abbSThomas Gleixner #else 172169a0abbSThomas Gleixner 1737e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr, 174169a0abbSThomas Gleixner struct acpi_processor_cx *cstate) { } 1757e275cc4SLen Brown static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { } 176aa6b43d5SPeter Zijlstra 177aa6b43d5SPeter Zijlstra static bool lapic_timer_needs_broadcast(struct acpi_processor *pr, 178aa6b43d5SPeter Zijlstra struct acpi_processor_cx *cx) 179e9e2cdb4SThomas Gleixner { 18095592128SRafael J. Wysocki return false; 181e9e2cdb4SThomas Gleixner } 182169a0abbSThomas Gleixner 183169a0abbSThomas Gleixner #endif 184169a0abbSThomas Gleixner 185592913ecSJohn Stultz #if defined(CONFIG_X86) 186520daf72SLen Brown static void tsc_check_state(int state) 187ddb25f9aSAndi Kleen { 188ddb25f9aSAndi Kleen switch (boot_cpu_data.x86_vendor) { 1897377ed4bSPu Wen case X86_VENDOR_HYGON: 190ddb25f9aSAndi Kleen case X86_VENDOR_AMD: 19140fb1715SVenki Pallipadi case X86_VENDOR_INTEL: 192fe6daab1Sdavidwang case X86_VENDOR_CENTAUR: 193773b2f30STony W Wang-oc case X86_VENDOR_ZHAOXIN: 194ddb25f9aSAndi Kleen /* 195ddb25f9aSAndi Kleen * AMD Fam10h TSC will tick in all 196ddb25f9aSAndi Kleen * C/P/S0/S1 states when this bit is set. 197ddb25f9aSAndi Kleen */ 19840fb1715SVenki Pallipadi if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC)) 199520daf72SLen Brown return; 20057d2dd4bSGustavo A. R. Silva fallthrough; 201ddb25f9aSAndi Kleen default: 202520daf72SLen Brown /* TSC could halt in idle, so notify users */ 203520daf72SLen Brown if (state > ACPI_STATE_C1) 204520daf72SLen Brown mark_tsc_unstable("TSC halts in idle"); 205ddb25f9aSAndi Kleen } 206ddb25f9aSAndi Kleen } 207520daf72SLen Brown #else 208520daf72SLen Brown static void tsc_check_state(int state) { return; } 209ddb25f9aSAndi Kleen #endif 210ddb25f9aSAndi Kleen 2111da177e4SLinus Torvalds static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr) 2121da177e4SLinus Torvalds { 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds if (!pr->pblk) 215d550d98dSPatrick Mochel return -ENODEV; 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds /* if info is obtained from pblk/fadt, type equals state */ 2181da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; 2191da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; 2201da177e4SLinus Torvalds 2214c033552SVenkatesh Pallipadi #ifndef CONFIG_HOTPLUG_CPU 2224c033552SVenkatesh Pallipadi /* 2234c033552SVenkatesh Pallipadi * Check for P_LVL2_UP flag before entering C2 and above on 2244c033552SVenkatesh Pallipadi * an SMP system. 2254c033552SVenkatesh Pallipadi */ 226ad71860aSAlexey Starikovskiy if ((num_online_cpus() > 1) && 227cee324b1SAlexey Starikovskiy !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED)) 228d550d98dSPatrick Mochel return -ENODEV; 2294c033552SVenkatesh Pallipadi #endif 2304c033552SVenkatesh Pallipadi 2311da177e4SLinus Torvalds /* determine C2 and C3 address from pblk */ 2321da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4; 2331da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5; 2341da177e4SLinus Torvalds 2351da177e4SLinus Torvalds /* determine latencies from FADT */ 236ba494beeSBob Moore pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency; 237ba494beeSBob Moore pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency; 2381da177e4SLinus Torvalds 2395d76b6f6SLen Brown /* 2405d76b6f6SLen Brown * FADT specified C2 latency must be less than or equal to 2415d76b6f6SLen Brown * 100 microseconds. 2425d76b6f6SLen Brown */ 243ba494beeSBob Moore if (acpi_gbl_FADT.c2_latency > ACPI_PROCESSOR_MAX_C2_LATENCY) { 24452af99c3SRafael J. Wysocki acpi_handle_debug(pr->handle, "C2 latency too large [%d]\n", 24552af99c3SRafael J. Wysocki acpi_gbl_FADT.c2_latency); 2465d76b6f6SLen Brown /* invalidate C2 */ 2475d76b6f6SLen Brown pr->power.states[ACPI_STATE_C2].address = 0; 2485d76b6f6SLen Brown } 2495d76b6f6SLen Brown 250a6d72c18SLen Brown /* 251a6d72c18SLen Brown * FADT supplied C3 latency must be less than or equal to 252a6d72c18SLen Brown * 1000 microseconds. 253a6d72c18SLen Brown */ 254ba494beeSBob Moore if (acpi_gbl_FADT.c3_latency > ACPI_PROCESSOR_MAX_C3_LATENCY) { 25552af99c3SRafael J. Wysocki acpi_handle_debug(pr->handle, "C3 latency too large [%d]\n", 25652af99c3SRafael J. Wysocki acpi_gbl_FADT.c3_latency); 257a6d72c18SLen Brown /* invalidate C3 */ 258a6d72c18SLen Brown pr->power.states[ACPI_STATE_C3].address = 0; 259a6d72c18SLen Brown } 260a6d72c18SLen Brown 26152af99c3SRafael J. Wysocki acpi_handle_debug(pr->handle, "lvl2[0x%08x] lvl3[0x%08x]\n", 2621da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].address, 26352af99c3SRafael J. Wysocki pr->power.states[ACPI_STATE_C3].address); 2641da177e4SLinus Torvalds 26534a62cd0SYazen Ghannam snprintf(pr->power.states[ACPI_STATE_C2].desc, 26634a62cd0SYazen Ghannam ACPI_CX_DESC_LEN, "ACPI P_LVL2 IOPORT 0x%x", 26734a62cd0SYazen Ghannam pr->power.states[ACPI_STATE_C2].address); 26834a62cd0SYazen Ghannam snprintf(pr->power.states[ACPI_STATE_C3].desc, 26934a62cd0SYazen Ghannam ACPI_CX_DESC_LEN, "ACPI P_LVL3 IOPORT 0x%x", 27034a62cd0SYazen Ghannam pr->power.states[ACPI_STATE_C3].address); 27134a62cd0SYazen Ghannam 272d550d98dSPatrick Mochel return 0; 2731da177e4SLinus Torvalds } 2741da177e4SLinus Torvalds 275991528d7SVenkatesh Pallipadi static int acpi_processor_get_power_info_default(struct acpi_processor *pr) 276acf05f4bSVenkatesh Pallipadi { 277991528d7SVenkatesh Pallipadi if (!pr->power.states[ACPI_STATE_C1].valid) { 278cf824788SJanosch Machowinski /* set the first C-State to C1 */ 279991528d7SVenkatesh Pallipadi /* all processors need to support C1 */ 280acf05f4bSVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; 281acf05f4bSVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].valid = 1; 2820fda6b40SVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT; 283248e8841SYazen Ghannam 284248e8841SYazen Ghannam snprintf(pr->power.states[ACPI_STATE_C1].desc, 285248e8841SYazen Ghannam ACPI_CX_DESC_LEN, "ACPI HLT"); 286991528d7SVenkatesh Pallipadi } 287991528d7SVenkatesh Pallipadi /* the C0 state only exists as a filler in our array */ 288991528d7SVenkatesh Pallipadi pr->power.states[ACPI_STATE_C0].valid = 1; 289d550d98dSPatrick Mochel return 0; 290acf05f4bSVenkatesh Pallipadi } 291acf05f4bSVenkatesh Pallipadi 292987c7853SRafael J. Wysocki static int acpi_processor_get_power_info_cst(struct acpi_processor *pr) 293987c7853SRafael J. Wysocki { 294987c7853SRafael J. Wysocki int ret; 295987c7853SRafael J. Wysocki 296987c7853SRafael J. Wysocki if (nocst) 297987c7853SRafael J. Wysocki return -ENODEV; 298987c7853SRafael J. Wysocki 299987c7853SRafael J. Wysocki ret = acpi_processor_evaluate_cst(pr->handle, pr->id, &pr->power); 300987c7853SRafael J. Wysocki if (ret) 301987c7853SRafael J. Wysocki return ret; 302987c7853SRafael J. Wysocki 303496121c0SZhang Rui if (!pr->power.count) 304987c7853SRafael J. Wysocki return -EFAULT; 305987c7853SRafael J. Wysocki 306987c7853SRafael J. Wysocki pr->flags.has_cst = 1; 307987c7853SRafael J. Wysocki return 0; 308987c7853SRafael J. Wysocki } 309987c7853SRafael J. Wysocki 3104be44fcdSLen Brown static void acpi_processor_power_verify_c3(struct acpi_processor *pr, 3111da177e4SLinus Torvalds struct acpi_processor_cx *cx) 3121da177e4SLinus Torvalds { 313ee1ca48fSPallipadi, Venkatesh static int bm_check_flag = -1; 314ee1ca48fSPallipadi, Venkatesh static int bm_control_flag = -1; 31502df8b93SVenkatesh Pallipadi 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds if (!cx->address) 318d550d98dSPatrick Mochel return; 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds /* 3211da177e4SLinus Torvalds * PIIX4 Erratum #18: We don't support C3 when Type-F (fast) 3221da177e4SLinus Torvalds * DMA transfers are used by any ISA device to avoid livelock. 3231da177e4SLinus Torvalds * Note that we could disable Type-F DMA (as recommended by 3241da177e4SLinus Torvalds * the erratum), but this is known to disrupt certain ISA 3251da177e4SLinus Torvalds * devices thus we take the conservative approach. 3261da177e4SLinus Torvalds */ 327b697b812SRafael J. Wysocki if (errata.piix4.fdma) { 32852af99c3SRafael J. Wysocki acpi_handle_debug(pr->handle, 32952af99c3SRafael J. Wysocki "C3 not supported on PIIX4 with Type-F DMA\n"); 330d550d98dSPatrick Mochel return; 3311da177e4SLinus Torvalds } 3321da177e4SLinus Torvalds 33302df8b93SVenkatesh Pallipadi /* All the logic here assumes flags.bm_check is same across all CPUs */ 334ee1ca48fSPallipadi, Venkatesh if (bm_check_flag == -1) { 33502df8b93SVenkatesh Pallipadi /* Determine whether bm_check is needed based on CPU */ 33602df8b93SVenkatesh Pallipadi acpi_processor_power_init_bm_check(&(pr->flags), pr->id); 33702df8b93SVenkatesh Pallipadi bm_check_flag = pr->flags.bm_check; 338ee1ca48fSPallipadi, Venkatesh bm_control_flag = pr->flags.bm_control; 33902df8b93SVenkatesh Pallipadi } else { 34002df8b93SVenkatesh Pallipadi pr->flags.bm_check = bm_check_flag; 341ee1ca48fSPallipadi, Venkatesh pr->flags.bm_control = bm_control_flag; 34202df8b93SVenkatesh Pallipadi } 34302df8b93SVenkatesh Pallipadi 34402df8b93SVenkatesh Pallipadi if (pr->flags.bm_check) { 34502df8b93SVenkatesh Pallipadi if (!pr->flags.bm_control) { 346ed3110efSVenki Pallipadi if (pr->flags.has_cst != 1) { 347ed3110efSVenki Pallipadi /* bus mastering control is necessary */ 34852af99c3SRafael J. Wysocki acpi_handle_debug(pr->handle, 34952af99c3SRafael J. Wysocki "C3 support requires BM control\n"); 350ed3110efSVenki Pallipadi return; 351ed3110efSVenki Pallipadi } else { 352ed3110efSVenki Pallipadi /* Here we enter C3 without bus mastering */ 35352af99c3SRafael J. Wysocki acpi_handle_debug(pr->handle, 35452af99c3SRafael J. Wysocki "C3 support without BM control\n"); 355ed3110efSVenki Pallipadi } 35602df8b93SVenkatesh Pallipadi } 35702df8b93SVenkatesh Pallipadi } else { 35802df8b93SVenkatesh Pallipadi /* 35902df8b93SVenkatesh Pallipadi * WBINVD should be set in fadt, for C3 state to be 36002df8b93SVenkatesh Pallipadi * supported on when bm_check is not required. 36102df8b93SVenkatesh Pallipadi */ 362cee324b1SAlexey Starikovskiy if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) { 36352af99c3SRafael J. Wysocki acpi_handle_debug(pr->handle, 36402df8b93SVenkatesh Pallipadi "Cache invalidation should work properly" 36552af99c3SRafael J. Wysocki " for C3 to be enabled on SMP systems\n"); 366d550d98dSPatrick Mochel return; 36702df8b93SVenkatesh Pallipadi } 36802df8b93SVenkatesh Pallipadi } 36902df8b93SVenkatesh Pallipadi 3701da177e4SLinus Torvalds /* 3711da177e4SLinus Torvalds * Otherwise we've met all of our C3 requirements. 3721da177e4SLinus Torvalds * Normalize the C3 latency to expidite policy. Enable 3731da177e4SLinus Torvalds * checking of bus mastering status (bm_check) so we can 3741da177e4SLinus Torvalds * use this in our C3 policy 3751da177e4SLinus Torvalds */ 3761da177e4SLinus Torvalds cx->valid = 1; 3774f86d3a8SLen Brown 37831878dd8SLen Brown /* 37931878dd8SLen Brown * On older chipsets, BM_RLD needs to be set 38031878dd8SLen Brown * in order for Bus Master activity to wake the 38131878dd8SLen Brown * system from C3. Newer chipsets handle DMA 38231878dd8SLen Brown * during C3 automatically and BM_RLD is a NOP. 38331878dd8SLen Brown * In either case, the proper way to 38431878dd8SLen Brown * handle BM_RLD is to set it and leave it set. 38531878dd8SLen Brown */ 38650ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 1); 3871da177e4SLinus Torvalds } 3881da177e4SLinus Torvalds 38965ea8f2cSMario Limonciello static int acpi_cst_latency_cmp(const void *a, const void *b) 39065ea8f2cSMario Limonciello { 39165ea8f2cSMario Limonciello const struct acpi_processor_cx *x = a, *y = b; 39265ea8f2cSMario Limonciello 39365ea8f2cSMario Limonciello if (!(x->valid && y->valid)) 39465ea8f2cSMario Limonciello return 0; 39565ea8f2cSMario Limonciello if (x->latency > y->latency) 39665ea8f2cSMario Limonciello return 1; 39765ea8f2cSMario Limonciello if (x->latency < y->latency) 39865ea8f2cSMario Limonciello return -1; 39965ea8f2cSMario Limonciello return 0; 40065ea8f2cSMario Limonciello } 40165ea8f2cSMario Limonciello static void acpi_cst_latency_swap(void *a, void *b, int n) 40265ea8f2cSMario Limonciello { 40365ea8f2cSMario Limonciello struct acpi_processor_cx *x = a, *y = b; 40465ea8f2cSMario Limonciello 40565ea8f2cSMario Limonciello if (!(x->valid && y->valid)) 40665ea8f2cSMario Limonciello return; 4070e6078c3SGuo Zhengkui swap(x->latency, y->latency); 40865ea8f2cSMario Limonciello } 40965ea8f2cSMario Limonciello 4101da177e4SLinus Torvalds static int acpi_processor_power_verify(struct acpi_processor *pr) 4111da177e4SLinus Torvalds { 4121da177e4SLinus Torvalds unsigned int i; 4131da177e4SLinus Torvalds unsigned int working = 0; 41465ea8f2cSMario Limonciello unsigned int last_latency = 0; 41565ea8f2cSMario Limonciello unsigned int last_type = 0; 41665ea8f2cSMario Limonciello bool buggy_latency = false; 4176eb0a0fdSVenkatesh Pallipadi 418169a0abbSThomas Gleixner pr->power.timer_broadcast_on_state = INT_MAX; 4196eb0a0fdSVenkatesh Pallipadi 420a0bf284bSLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 4211da177e4SLinus Torvalds struct acpi_processor_cx *cx = &pr->power.states[i]; 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds switch (cx->type) { 4241da177e4SLinus Torvalds case ACPI_STATE_C1: 4251da177e4SLinus Torvalds cx->valid = 1; 4261da177e4SLinus Torvalds break; 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds case ACPI_STATE_C2: 429d22edd29SLen Brown if (!cx->address) 430d22edd29SLen Brown break; 431d22edd29SLen Brown cx->valid = 1; 4321da177e4SLinus Torvalds break; 4331da177e4SLinus Torvalds 4341da177e4SLinus Torvalds case ACPI_STATE_C3: 4351da177e4SLinus Torvalds acpi_processor_power_verify_c3(pr, cx); 4361da177e4SLinus Torvalds break; 4371da177e4SLinus Torvalds } 4387e275cc4SLen Brown if (!cx->valid) 4397e275cc4SLen Brown continue; 44065ea8f2cSMario Limonciello if (cx->type >= last_type && cx->latency < last_latency) 44165ea8f2cSMario Limonciello buggy_latency = true; 44265ea8f2cSMario Limonciello last_latency = cx->latency; 44365ea8f2cSMario Limonciello last_type = cx->type; 4441da177e4SLinus Torvalds 4457e275cc4SLen Brown lapic_timer_check_state(i, pr, cx); 4467e275cc4SLen Brown tsc_check_state(cx->type); 4471da177e4SLinus Torvalds working++; 4481da177e4SLinus Torvalds } 4491da177e4SLinus Torvalds 45065ea8f2cSMario Limonciello if (buggy_latency) { 45165ea8f2cSMario Limonciello pr_notice("FW issue: working around C-state latencies out of order\n"); 45265ea8f2cSMario Limonciello sort(&pr->power.states[1], max_cstate, 45365ea8f2cSMario Limonciello sizeof(struct acpi_processor_cx), 45465ea8f2cSMario Limonciello acpi_cst_latency_cmp, 45565ea8f2cSMario Limonciello acpi_cst_latency_swap); 45665ea8f2cSMario Limonciello } 45765ea8f2cSMario Limonciello 458918aae42SHidetoshi Seto lapic_timer_propagate_broadcast(pr); 459bd663347SAndi Kleen 460b697b812SRafael J. Wysocki return working; 4611da177e4SLinus Torvalds } 4621da177e4SLinus Torvalds 463a36a7fecSSudeep Holla static int acpi_processor_get_cstate_info(struct acpi_processor *pr) 4641da177e4SLinus Torvalds { 4651da177e4SLinus Torvalds unsigned int i; 4661da177e4SLinus Torvalds int result; 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds /* NOTE: the idle thread may not be running while calling 4701da177e4SLinus Torvalds * this function */ 4711da177e4SLinus Torvalds 472991528d7SVenkatesh Pallipadi /* Zero initialize all the C-states info. */ 473991528d7SVenkatesh Pallipadi memset(pr->power.states, 0, sizeof(pr->power.states)); 474991528d7SVenkatesh Pallipadi 4751da177e4SLinus Torvalds result = acpi_processor_get_power_info_cst(pr); 4766d93c648SVenkatesh Pallipadi if (result == -ENODEV) 477c5a114f1SDarrick J. Wong result = acpi_processor_get_power_info_fadt(pr); 4786d93c648SVenkatesh Pallipadi 479991528d7SVenkatesh Pallipadi if (result) 480991528d7SVenkatesh Pallipadi return result; 481991528d7SVenkatesh Pallipadi 482991528d7SVenkatesh Pallipadi acpi_processor_get_power_info_default(pr); 483991528d7SVenkatesh Pallipadi 484cf824788SJanosch Machowinski pr->power.count = acpi_processor_power_verify(pr); 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds /* 4871da177e4SLinus Torvalds * if one state of type C2 or C3 is available, mark this 4881da177e4SLinus Torvalds * CPU as being "idle manageable" 4891da177e4SLinus Torvalds */ 4901da177e4SLinus Torvalds for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 491acf05f4bSVenkatesh Pallipadi if (pr->power.states[i].valid) { 4921da177e4SLinus Torvalds pr->power.count = i; 4931da177e4SLinus Torvalds pr->flags.power = 1; 4941da177e4SLinus Torvalds } 495acf05f4bSVenkatesh Pallipadi } 4961da177e4SLinus Torvalds 497d550d98dSPatrick Mochel return 0; 4981da177e4SLinus Torvalds } 4991da177e4SLinus Torvalds 5004f86d3a8SLen Brown /** 5014f86d3a8SLen Brown * acpi_idle_bm_check - checks if bus master activity was detected 5024f86d3a8SLen Brown */ 5034f86d3a8SLen Brown static int acpi_idle_bm_check(void) 5044f86d3a8SLen Brown { 5054f86d3a8SLen Brown u32 bm_status = 0; 5064f86d3a8SLen Brown 507d3e7e99fSLen Brown if (bm_check_disable) 508d3e7e99fSLen Brown return 0; 509d3e7e99fSLen Brown 51050ffba1bSBob Moore acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status); 5114f86d3a8SLen Brown if (bm_status) 51250ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, 1); 5134f86d3a8SLen Brown /* 5144f86d3a8SLen Brown * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect 5154f86d3a8SLen Brown * the true state of bus mastering activity; forcing us to 5164f86d3a8SLen Brown * manually check the BMIDEA bit of each IDE channel. 5174f86d3a8SLen Brown */ 5184f86d3a8SLen Brown else if (errata.piix4.bmisx) { 5194f86d3a8SLen Brown if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01) 5204f86d3a8SLen Brown || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01)) 5214f86d3a8SLen Brown bm_status = 1; 5224f86d3a8SLen Brown } 5234f86d3a8SLen Brown return bm_status; 5244f86d3a8SLen Brown } 5254f86d3a8SLen Brown 526*8ce78470SPeter Zijlstra static __cpuidle void io_idle(unsigned long addr) 527fa583f71SYin Fengwei { 528*8ce78470SPeter Zijlstra /* IO port based C-state */ 529*8ce78470SPeter Zijlstra inb(addr); 530*8ce78470SPeter Zijlstra 531fa583f71SYin Fengwei #ifdef CONFIG_X86 532fa583f71SYin Fengwei /* No delay is needed if we are in guest */ 533fa583f71SYin Fengwei if (boot_cpu_has(X86_FEATURE_HYPERVISOR)) 534fa583f71SYin Fengwei return; 535e400ad8bSDave Hansen /* 536e400ad8bSDave Hansen * Modern (>=Nehalem) Intel systems use ACPI via intel_idle, 537e400ad8bSDave Hansen * not this code. Assume that any Intel systems using this 538e400ad8bSDave Hansen * are ancient and may need the dummy wait. This also assumes 539e400ad8bSDave Hansen * that the motivating chipset issue was Intel-only. 540e400ad8bSDave Hansen */ 541e400ad8bSDave Hansen if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) 542e400ad8bSDave Hansen return; 543fa583f71SYin Fengwei #endif 544e400ad8bSDave Hansen /* 545e400ad8bSDave Hansen * Dummy wait op - must do something useless after P_LVL2 read 546e400ad8bSDave Hansen * because chipsets cannot guarantee that STPCLK# signal gets 547e400ad8bSDave Hansen * asserted in time to freeze execution properly 548e400ad8bSDave Hansen * 549e400ad8bSDave Hansen * This workaround has been in place since the original ACPI 550e400ad8bSDave Hansen * implementation was merged, circa 2002. 551e400ad8bSDave Hansen * 552e400ad8bSDave Hansen * If a profile is pointing to this instruction, please first 553e400ad8bSDave Hansen * consider moving your system to a more modern idle 554e400ad8bSDave Hansen * mechanism. 555e400ad8bSDave Hansen */ 556fa583f71SYin Fengwei inl(acpi_gbl_FADT.xpm_timer_block.address); 557fa583f71SYin Fengwei } 558fa583f71SYin Fengwei 5594f86d3a8SLen Brown /** 560b00783fdSRafael J. Wysocki * acpi_idle_do_entry - enter idle state using the appropriate method 5614f86d3a8SLen Brown * @cx: cstate data 562bc71bec9Svenkatesh.pallipadi@intel.com * 563bc71bec9Svenkatesh.pallipadi@intel.com * Caller disables interrupt before call and enables interrupt after return. 5644f86d3a8SLen Brown */ 5656727ad9eSChris Metcalf static void __cpuidle acpi_idle_do_entry(struct acpi_processor_cx *cx) 5664f86d3a8SLen Brown { 5672a606a18SStephane Eranian perf_lopwr_cb(true); 5682a606a18SStephane Eranian 569bc71bec9Svenkatesh.pallipadi@intel.com if (cx->entry_method == ACPI_CSTATE_FFH) { 5704f86d3a8SLen Brown /* Call into architectural FFH based C-state */ 5714f86d3a8SLen Brown acpi_processor_ffh_cstate_enter(cx); 572bc71bec9Svenkatesh.pallipadi@intel.com } else if (cx->entry_method == ACPI_CSTATE_HALT) { 573bc71bec9Svenkatesh.pallipadi@intel.com acpi_safe_halt(); 5744f86d3a8SLen Brown } else { 575*8ce78470SPeter Zijlstra io_idle(cx->address); 5764f86d3a8SLen Brown } 5772a606a18SStephane Eranian 5782a606a18SStephane Eranian perf_lopwr_cb(false); 5794f86d3a8SLen Brown } 5804f86d3a8SLen Brown 5814f86d3a8SLen Brown /** 5821a022e3fSBoris Ostrovsky * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining) 5831a022e3fSBoris Ostrovsky * @dev: the target CPU 5841a022e3fSBoris Ostrovsky * @index: the index of suggested state 5851a022e3fSBoris Ostrovsky */ 5861a022e3fSBoris Ostrovsky static int acpi_idle_play_dead(struct cpuidle_device *dev, int index) 5871a022e3fSBoris Ostrovsky { 5886240a10dSAlex Shi struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 5891a022e3fSBoris Ostrovsky 5901a022e3fSBoris Ostrovsky ACPI_FLUSH_CPU_CACHE(); 5911a022e3fSBoris Ostrovsky 5921a022e3fSBoris Ostrovsky while (1) { 5931a022e3fSBoris Ostrovsky 5941a022e3fSBoris Ostrovsky if (cx->entry_method == ACPI_CSTATE_HALT) 59554f70077SLuck, Tony safe_halt(); 5961a022e3fSBoris Ostrovsky else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) { 597*8ce78470SPeter Zijlstra io_idle(cx->address); 5981a022e3fSBoris Ostrovsky } else 5991a022e3fSBoris Ostrovsky return -ENODEV; 6008cdddd18SVitaly Kuznetsov 6018cdddd18SVitaly Kuznetsov #if defined(CONFIG_X86) && defined(CONFIG_HOTPLUG_CPU) 602fa26d0c7SVitaly Kuznetsov cond_wakeup_cpu0(); 6038cdddd18SVitaly Kuznetsov #endif 6041a022e3fSBoris Ostrovsky } 6051a022e3fSBoris Ostrovsky 6061a022e3fSBoris Ostrovsky /* Never reached */ 6071a022e3fSBoris Ostrovsky return 0; 6081a022e3fSBoris Ostrovsky } 6091a022e3fSBoris Ostrovsky 610adcb2623SRafael J. Wysocki static bool acpi_idle_fallback_to_c1(struct acpi_processor *pr) 611adcb2623SRafael J. Wysocki { 6125f508185SRafael J. Wysocki return IS_ENABLED(CONFIG_HOTPLUG_CPU) && !pr->flags.has_cst && 6135f508185SRafael J. Wysocki !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED); 614adcb2623SRafael J. Wysocki } 615adcb2623SRafael J. Wysocki 6164f86d3a8SLen Brown static int c3_cpu_count; 617e12f65f7SThomas Gleixner static DEFINE_RAW_SPINLOCK(c3_lock); 6184f86d3a8SLen Brown 6194f86d3a8SLen Brown /** 6204f86d3a8SLen Brown * acpi_idle_enter_bm - enters C3 with proper BM handling 6211fecfdbbSPeter Zijlstra * @drv: cpuidle driver 6226491bc0cSRafael J. Wysocki * @pr: Target processor 6236491bc0cSRafael J. Wysocki * @cx: Target state context 6241fecfdbbSPeter Zijlstra * @index: index of target state 6254f86d3a8SLen Brown */ 626409dfdcaSGuilherme G. Piccoli static int __cpuidle acpi_idle_enter_bm(struct cpuidle_driver *drv, 6271fecfdbbSPeter Zijlstra struct acpi_processor *pr, 6281fecfdbbSPeter Zijlstra struct acpi_processor_cx *cx, 6291fecfdbbSPeter Zijlstra int index) 6304f86d3a8SLen Brown { 6311fecfdbbSPeter Zijlstra static struct acpi_processor_cx safe_cx = { 6321fecfdbbSPeter Zijlstra .entry_method = ACPI_CSTATE_HALT, 6331fecfdbbSPeter Zijlstra }; 6341fecfdbbSPeter Zijlstra 6354f86d3a8SLen Brown /* 636c9c860e5SVenkatesh Pallipadi * disable bus master 637c9c860e5SVenkatesh Pallipadi * bm_check implies we need ARB_DIS 638c9c860e5SVenkatesh Pallipadi * bm_control implies whether we can do ARB_DIS 639c9c860e5SVenkatesh Pallipadi * 6401fecfdbbSPeter Zijlstra * That leaves a case where bm_check is set and bm_control is not set. 6411fecfdbbSPeter Zijlstra * In that case we cannot do much, we enter C3 without doing anything. 642c9c860e5SVenkatesh Pallipadi */ 6431fecfdbbSPeter Zijlstra bool dis_bm = pr->flags.bm_control; 6441fecfdbbSPeter Zijlstra 645a01353cfSPeter Zijlstra instrumentation_begin(); 646a01353cfSPeter Zijlstra 6471fecfdbbSPeter Zijlstra /* If we can skip BM, demote to a safe state. */ 6481fecfdbbSPeter Zijlstra if (!cx->bm_sts_skip && acpi_idle_bm_check()) { 6491fecfdbbSPeter Zijlstra dis_bm = false; 6501fecfdbbSPeter Zijlstra index = drv->safe_state_index; 6511fecfdbbSPeter Zijlstra if (index >= 0) { 6521fecfdbbSPeter Zijlstra cx = this_cpu_read(acpi_cstate[index]); 6531fecfdbbSPeter Zijlstra } else { 6541fecfdbbSPeter Zijlstra cx = &safe_cx; 6551fecfdbbSPeter Zijlstra index = -EBUSY; 6561fecfdbbSPeter Zijlstra } 6571fecfdbbSPeter Zijlstra } 6581fecfdbbSPeter Zijlstra 6591fecfdbbSPeter Zijlstra if (dis_bm) { 660e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock); 6614f86d3a8SLen Brown c3_cpu_count++; 6624f86d3a8SLen Brown /* Disable bus master arbitration when all CPUs are in C3 */ 6634f86d3a8SLen Brown if (c3_cpu_count == num_online_cpus()) 66450ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1); 665e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock); 666c9c860e5SVenkatesh Pallipadi } 6674f86d3a8SLen Brown 668a01353cfSPeter Zijlstra ct_cpuidle_enter(); 6691fecfdbbSPeter Zijlstra 6704f86d3a8SLen Brown acpi_idle_do_entry(cx); 6714f86d3a8SLen Brown 672a01353cfSPeter Zijlstra ct_cpuidle_exit(); 6731fecfdbbSPeter Zijlstra 6744f86d3a8SLen Brown /* Re-enable bus master arbitration */ 6751fecfdbbSPeter Zijlstra if (dis_bm) { 676e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock); 67750ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0); 6784f86d3a8SLen Brown c3_cpu_count--; 679e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock); 6804f86d3a8SLen Brown } 6811fecfdbbSPeter Zijlstra 682a01353cfSPeter Zijlstra instrumentation_end(); 683a01353cfSPeter Zijlstra 6841fecfdbbSPeter Zijlstra return index; 6856491bc0cSRafael J. Wysocki } 6866491bc0cSRafael J. Wysocki 687409dfdcaSGuilherme G. Piccoli static int __cpuidle acpi_idle_enter(struct cpuidle_device *dev, 6886491bc0cSRafael J. Wysocki struct cpuidle_driver *drv, int index) 6896491bc0cSRafael J. Wysocki { 6906491bc0cSRafael J. Wysocki struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 6916491bc0cSRafael J. Wysocki struct acpi_processor *pr; 6926491bc0cSRafael J. Wysocki 6936491bc0cSRafael J. Wysocki pr = __this_cpu_read(processors); 6946491bc0cSRafael J. Wysocki if (unlikely(!pr)) 6956491bc0cSRafael J. Wysocki return -EINVAL; 6966491bc0cSRafael J. Wysocki 6976491bc0cSRafael J. Wysocki if (cx->type != ACPI_STATE_C1) { 6981fecfdbbSPeter Zijlstra if (cx->type == ACPI_STATE_C3 && pr->flags.bm_check) 6991fecfdbbSPeter Zijlstra return acpi_idle_enter_bm(drv, pr, cx, index); 7001fecfdbbSPeter Zijlstra 7011fecfdbbSPeter Zijlstra /* C2 to C1 demotion. */ 7025f508185SRafael J. Wysocki if (acpi_idle_fallback_to_c1(pr) && num_online_cpus() > 1) { 703dc2251bfSRafael J. Wysocki index = ACPI_IDLE_STATE_START; 7046491bc0cSRafael J. Wysocki cx = per_cpu(acpi_cstate[index], dev->cpu); 7056491bc0cSRafael J. Wysocki } 7066491bc0cSRafael J. Wysocki } 7076491bc0cSRafael J. Wysocki 7086491bc0cSRafael J. Wysocki if (cx->type == ACPI_STATE_C3) 7096491bc0cSRafael J. Wysocki ACPI_FLUSH_CPU_CACHE(); 7106491bc0cSRafael J. Wysocki 7116491bc0cSRafael J. Wysocki acpi_idle_do_entry(cx); 7126491bc0cSRafael J. Wysocki 713e978aa7dSDeepthi Dharwar return index; 7144f86d3a8SLen Brown } 7154f86d3a8SLen Brown 716409dfdcaSGuilherme G. Piccoli static int __cpuidle acpi_idle_enter_s2idle(struct cpuidle_device *dev, 7175f508185SRafael J. Wysocki struct cpuidle_driver *drv, int index) 7185f508185SRafael J. Wysocki { 7195f508185SRafael J. Wysocki struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 7205f508185SRafael J. Wysocki 7215f508185SRafael J. Wysocki if (cx->type == ACPI_STATE_C3) { 7225f508185SRafael J. Wysocki struct acpi_processor *pr = __this_cpu_read(processors); 7235f508185SRafael J. Wysocki 7245f508185SRafael J. Wysocki if (unlikely(!pr)) 7250a398945SNeal Liu return 0; 7265f508185SRafael J. Wysocki 7275f508185SRafael J. Wysocki if (pr->flags.bm_check) { 7281fecfdbbSPeter Zijlstra u8 bm_sts_skip = cx->bm_sts_skip; 7291fecfdbbSPeter Zijlstra 7301fecfdbbSPeter Zijlstra /* Don't check BM_STS, do an unconditional ARB_DIS for S2IDLE */ 7311fecfdbbSPeter Zijlstra cx->bm_sts_skip = 1; 7321fecfdbbSPeter Zijlstra acpi_idle_enter_bm(drv, pr, cx, index); 7331fecfdbbSPeter Zijlstra cx->bm_sts_skip = bm_sts_skip; 7341fecfdbbSPeter Zijlstra 7350a398945SNeal Liu return 0; 7365f508185SRafael J. Wysocki } else { 7375f508185SRafael J. Wysocki ACPI_FLUSH_CPU_CACHE(); 7385f508185SRafael J. Wysocki } 7395f508185SRafael J. Wysocki } 7405f508185SRafael J. Wysocki acpi_idle_do_entry(cx); 741efe97112SNeal Liu 742efe97112SNeal Liu return 0; 7435f508185SRafael J. Wysocki } 7445f508185SRafael J. Wysocki 7456ef0f086SDaniel Lezcano static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr, 7466ef0f086SDaniel Lezcano struct cpuidle_device *dev) 7474f86d3a8SLen Brown { 748dc2251bfSRafael J. Wysocki int i, count = ACPI_IDLE_STATE_START; 7494f86d3a8SLen Brown struct acpi_processor_cx *cx; 750aa6b43d5SPeter Zijlstra struct cpuidle_state *state; 7514f86d3a8SLen Brown 752615dfd93SLen Brown if (max_cstate == 0) 753615dfd93SLen Brown max_cstate = 1; 754615dfd93SLen Brown 7554f86d3a8SLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 756a889a23aSPeter Zijlstra state = &acpi_idle_driver.states[count]; 7574f86d3a8SLen Brown cx = &pr->power.states[i]; 7584f86d3a8SLen Brown 7594f86d3a8SLen Brown if (!cx->valid) 7604f86d3a8SLen Brown continue; 7614f86d3a8SLen Brown 7626240a10dSAlex Shi per_cpu(acpi_cstate[count], dev->cpu) = cx; 7634f86d3a8SLen Brown 764a889a23aSPeter Zijlstra if (lapic_timer_needs_broadcast(pr, cx)) 765aa6b43d5SPeter Zijlstra state->flags |= CPUIDLE_FLAG_TIMER_STOP; 766a889a23aSPeter Zijlstra 7671fecfdbbSPeter Zijlstra if (cx->type == ACPI_STATE_C3) { 768a889a23aSPeter Zijlstra state->flags |= CPUIDLE_FLAG_TLB_FLUSHED; 7691fecfdbbSPeter Zijlstra if (pr->flags.bm_check) 7701fecfdbbSPeter Zijlstra state->flags |= CPUIDLE_FLAG_RCU_IDLE; 7711fecfdbbSPeter Zijlstra } 772aa6b43d5SPeter Zijlstra 77346bcfad7SDeepthi Dharwar count++; 77446bcfad7SDeepthi Dharwar if (count == CPUIDLE_STATE_MAX) 77546bcfad7SDeepthi Dharwar break; 77646bcfad7SDeepthi Dharwar } 77746bcfad7SDeepthi Dharwar 77846bcfad7SDeepthi Dharwar if (!count) 77946bcfad7SDeepthi Dharwar return -EINVAL; 78046bcfad7SDeepthi Dharwar 78146bcfad7SDeepthi Dharwar return 0; 78246bcfad7SDeepthi Dharwar } 78346bcfad7SDeepthi Dharwar 784a36a7fecSSudeep Holla static int acpi_processor_setup_cstates(struct acpi_processor *pr) 78546bcfad7SDeepthi Dharwar { 7861b39e3f8SRafael J. Wysocki int i, count; 78746bcfad7SDeepthi Dharwar struct acpi_processor_cx *cx; 78846bcfad7SDeepthi Dharwar struct cpuidle_state *state; 78946bcfad7SDeepthi Dharwar struct cpuidle_driver *drv = &acpi_idle_driver; 79046bcfad7SDeepthi Dharwar 79146bcfad7SDeepthi Dharwar if (max_cstate == 0) 79246bcfad7SDeepthi Dharwar max_cstate = 1; 79346bcfad7SDeepthi Dharwar 7941b39e3f8SRafael J. Wysocki if (IS_ENABLED(CONFIG_ARCH_HAS_CPU_RELAX)) { 7951b39e3f8SRafael J. Wysocki cpuidle_poll_state_init(drv); 7961b39e3f8SRafael J. Wysocki count = 1; 7971b39e3f8SRafael J. Wysocki } else { 7981b39e3f8SRafael J. Wysocki count = 0; 7991b39e3f8SRafael J. Wysocki } 8001b39e3f8SRafael J. Wysocki 80146bcfad7SDeepthi Dharwar for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 80246bcfad7SDeepthi Dharwar cx = &pr->power.states[i]; 80346bcfad7SDeepthi Dharwar 80446bcfad7SDeepthi Dharwar if (!cx->valid) 80546bcfad7SDeepthi Dharwar continue; 80646bcfad7SDeepthi Dharwar 80746bcfad7SDeepthi Dharwar state = &drv->states[count]; 8084f86d3a8SLen Brown snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i); 809b75d2cd0SWolfram Sang strscpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); 8104f86d3a8SLen Brown state->exit_latency = cx->latency; 8114963f620SLen Brown state->target_residency = cx->latency * latency_factor; 8126491bc0cSRafael J. Wysocki state->enter = acpi_idle_enter; 8134f86d3a8SLen Brown 8144f86d3a8SLen Brown state->flags = 0; 815d6b88ce2SRichard Gong if (cx->type == ACPI_STATE_C1 || cx->type == ACPI_STATE_C2 || 816d6b88ce2SRichard Gong cx->type == ACPI_STATE_C3) { 8171a022e3fSBoris Ostrovsky state->enter_dead = acpi_idle_play_dead; 818fc45e55eSVille Syrjälä if (cx->type != ACPI_STATE_C3) 81946bcfad7SDeepthi Dharwar drv->safe_state_index = count; 8204f86d3a8SLen Brown } 8215f508185SRafael J. Wysocki /* 82228ba086eSRafael J. Wysocki * Halt-induced C1 is not good for ->enter_s2idle, because it 8235f508185SRafael J. Wysocki * re-enables interrupts on exit. Moreover, C1 is generally not 8245f508185SRafael J. Wysocki * particularly interesting from the suspend-to-idle angle, so 8255f508185SRafael J. Wysocki * avoid C1 and the situations in which we may need to fall back 8265f508185SRafael J. Wysocki * to it altogether. 8275f508185SRafael J. Wysocki */ 8285f508185SRafael J. Wysocki if (cx->type != ACPI_STATE_C1 && !acpi_idle_fallback_to_c1(pr)) 82928ba086eSRafael J. Wysocki state->enter_s2idle = acpi_idle_enter_s2idle; 8304f86d3a8SLen Brown 8314f86d3a8SLen Brown count++; 8329a0b8415Svenkatesh.pallipadi@intel.com if (count == CPUIDLE_STATE_MAX) 8339a0b8415Svenkatesh.pallipadi@intel.com break; 8344f86d3a8SLen Brown } 8354f86d3a8SLen Brown 83646bcfad7SDeepthi Dharwar drv->state_count = count; 8374f86d3a8SLen Brown 8384f86d3a8SLen Brown if (!count) 8394f86d3a8SLen Brown return -EINVAL; 8404f86d3a8SLen Brown 8414f86d3a8SLen Brown return 0; 8424f86d3a8SLen Brown } 8434f86d3a8SLen Brown 84435ae7133SSudeep Holla static inline void acpi_processor_cstate_first_run_checks(void) 84535ae7133SSudeep Holla { 84635ae7133SSudeep Holla static int first_run; 84735ae7133SSudeep Holla 84835ae7133SSudeep Holla if (first_run) 84935ae7133SSudeep Holla return; 85035ae7133SSudeep Holla dmi_check_system(processor_power_dmi_table); 85135ae7133SSudeep Holla max_cstate = acpi_processor_cstate_check(max_cstate); 85235ae7133SSudeep Holla if (max_cstate < ACPI_C_STATES_MAX) 85354e05192SRafael J. Wysocki pr_notice("processor limited to max C-state %d\n", max_cstate); 85454e05192SRafael J. Wysocki 85535ae7133SSudeep Holla first_run++; 85635ae7133SSudeep Holla 857bc946388SRafael J. Wysocki if (nocst) 858bc946388SRafael J. Wysocki return; 859bc946388SRafael J. Wysocki 860bc946388SRafael J. Wysocki acpi_processor_claim_cst_control(); 86135ae7133SSudeep Holla } 86235ae7133SSudeep Holla #else 86335ae7133SSudeep Holla 86435ae7133SSudeep Holla static inline int disabled_by_idle_boot_param(void) { return 0; } 86535ae7133SSudeep Holla static inline void acpi_processor_cstate_first_run_checks(void) { } 866a36a7fecSSudeep Holla static int acpi_processor_get_cstate_info(struct acpi_processor *pr) 86735ae7133SSudeep Holla { 86835ae7133SSudeep Holla return -ENODEV; 86935ae7133SSudeep Holla } 87035ae7133SSudeep Holla 87135ae7133SSudeep Holla static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr, 87235ae7133SSudeep Holla struct cpuidle_device *dev) 87335ae7133SSudeep Holla { 87435ae7133SSudeep Holla return -EINVAL; 87535ae7133SSudeep Holla } 87635ae7133SSudeep Holla 877a36a7fecSSudeep Holla static int acpi_processor_setup_cstates(struct acpi_processor *pr) 87835ae7133SSudeep Holla { 87935ae7133SSudeep Holla return -EINVAL; 88035ae7133SSudeep Holla } 88135ae7133SSudeep Holla 88235ae7133SSudeep Holla #endif /* CONFIG_ACPI_PROCESSOR_CSTATE */ 88335ae7133SSudeep Holla 884a36a7fecSSudeep Holla struct acpi_lpi_states_array { 885a36a7fecSSudeep Holla unsigned int size; 886a36a7fecSSudeep Holla unsigned int composite_states_size; 887a36a7fecSSudeep Holla struct acpi_lpi_state *entries; 888a36a7fecSSudeep Holla struct acpi_lpi_state *composite_states[ACPI_PROCESSOR_MAX_POWER]; 889a36a7fecSSudeep Holla }; 890a36a7fecSSudeep Holla 891a36a7fecSSudeep Holla static int obj_get_integer(union acpi_object *obj, u32 *value) 892a36a7fecSSudeep Holla { 893a36a7fecSSudeep Holla if (obj->type != ACPI_TYPE_INTEGER) 894a36a7fecSSudeep Holla return -EINVAL; 895a36a7fecSSudeep Holla 896a36a7fecSSudeep Holla *value = obj->integer.value; 897a36a7fecSSudeep Holla return 0; 898a36a7fecSSudeep Holla } 899a36a7fecSSudeep Holla 900a36a7fecSSudeep Holla static int acpi_processor_evaluate_lpi(acpi_handle handle, 901a36a7fecSSudeep Holla struct acpi_lpi_states_array *info) 902a36a7fecSSudeep Holla { 903a36a7fecSSudeep Holla acpi_status status; 904a36a7fecSSudeep Holla int ret = 0; 905a36a7fecSSudeep Holla int pkg_count, state_idx = 1, loop; 906a36a7fecSSudeep Holla struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 907a36a7fecSSudeep Holla union acpi_object *lpi_data; 908a36a7fecSSudeep Holla struct acpi_lpi_state *lpi_state; 909a36a7fecSSudeep Holla 910a36a7fecSSudeep Holla status = acpi_evaluate_object(handle, "_LPI", NULL, &buffer); 911a36a7fecSSudeep Holla if (ACPI_FAILURE(status)) { 91252af99c3SRafael J. Wysocki acpi_handle_debug(handle, "No _LPI, giving up\n"); 913a36a7fecSSudeep Holla return -ENODEV; 914a36a7fecSSudeep Holla } 915a36a7fecSSudeep Holla 916a36a7fecSSudeep Holla lpi_data = buffer.pointer; 917a36a7fecSSudeep Holla 918a36a7fecSSudeep Holla /* There must be at least 4 elements = 3 elements + 1 package */ 919a36a7fecSSudeep Holla if (!lpi_data || lpi_data->type != ACPI_TYPE_PACKAGE || 920a36a7fecSSudeep Holla lpi_data->package.count < 4) { 921a36a7fecSSudeep Holla pr_debug("not enough elements in _LPI\n"); 922a36a7fecSSudeep Holla ret = -ENODATA; 923a36a7fecSSudeep Holla goto end; 924a36a7fecSSudeep Holla } 925a36a7fecSSudeep Holla 926a36a7fecSSudeep Holla pkg_count = lpi_data->package.elements[2].integer.value; 927a36a7fecSSudeep Holla 928a36a7fecSSudeep Holla /* Validate number of power states. */ 929a36a7fecSSudeep Holla if (pkg_count < 1 || pkg_count != lpi_data->package.count - 3) { 930a36a7fecSSudeep Holla pr_debug("count given by _LPI is not valid\n"); 931a36a7fecSSudeep Holla ret = -ENODATA; 932a36a7fecSSudeep Holla goto end; 933a36a7fecSSudeep Holla } 934a36a7fecSSudeep Holla 935a36a7fecSSudeep Holla lpi_state = kcalloc(pkg_count, sizeof(*lpi_state), GFP_KERNEL); 936a36a7fecSSudeep Holla if (!lpi_state) { 937a36a7fecSSudeep Holla ret = -ENOMEM; 938a36a7fecSSudeep Holla goto end; 939a36a7fecSSudeep Holla } 940a36a7fecSSudeep Holla 941a36a7fecSSudeep Holla info->size = pkg_count; 942a36a7fecSSudeep Holla info->entries = lpi_state; 943a36a7fecSSudeep Holla 944a36a7fecSSudeep Holla /* LPI States start at index 3 */ 945a36a7fecSSudeep Holla for (loop = 3; state_idx <= pkg_count; loop++, state_idx++, lpi_state++) { 946a36a7fecSSudeep Holla union acpi_object *element, *pkg_elem, *obj; 947a36a7fecSSudeep Holla 948a36a7fecSSudeep Holla element = &lpi_data->package.elements[loop]; 949a36a7fecSSudeep Holla if (element->type != ACPI_TYPE_PACKAGE || element->package.count < 7) 950a36a7fecSSudeep Holla continue; 951a36a7fecSSudeep Holla 952a36a7fecSSudeep Holla pkg_elem = element->package.elements; 953a36a7fecSSudeep Holla 954a36a7fecSSudeep Holla obj = pkg_elem + 6; 955a36a7fecSSudeep Holla if (obj->type == ACPI_TYPE_BUFFER) { 956a36a7fecSSudeep Holla struct acpi_power_register *reg; 957a36a7fecSSudeep Holla 958a36a7fecSSudeep Holla reg = (struct acpi_power_register *)obj->buffer.pointer; 959a36a7fecSSudeep Holla if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && 960a36a7fecSSudeep Holla reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) 961a36a7fecSSudeep Holla continue; 962a36a7fecSSudeep Holla 963a36a7fecSSudeep Holla lpi_state->address = reg->address; 964a36a7fecSSudeep Holla lpi_state->entry_method = 965a36a7fecSSudeep Holla reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE ? 966a36a7fecSSudeep Holla ACPI_CSTATE_FFH : ACPI_CSTATE_SYSTEMIO; 967a36a7fecSSudeep Holla } else if (obj->type == ACPI_TYPE_INTEGER) { 968a36a7fecSSudeep Holla lpi_state->entry_method = ACPI_CSTATE_INTEGER; 969a36a7fecSSudeep Holla lpi_state->address = obj->integer.value; 970a36a7fecSSudeep Holla } else { 971a36a7fecSSudeep Holla continue; 972a36a7fecSSudeep Holla } 973a36a7fecSSudeep Holla 974a36a7fecSSudeep Holla /* elements[7,8] skipped for now i.e. Residency/Usage counter*/ 975a36a7fecSSudeep Holla 976a36a7fecSSudeep Holla obj = pkg_elem + 9; 977a36a7fecSSudeep Holla if (obj->type == ACPI_TYPE_STRING) 978b75d2cd0SWolfram Sang strscpy(lpi_state->desc, obj->string.pointer, 979a36a7fecSSudeep Holla ACPI_CX_DESC_LEN); 980a36a7fecSSudeep Holla 981a36a7fecSSudeep Holla lpi_state->index = state_idx; 982a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 0, &lpi_state->min_residency)) { 983a36a7fecSSudeep Holla pr_debug("No min. residency found, assuming 10 us\n"); 984a36a7fecSSudeep Holla lpi_state->min_residency = 10; 985a36a7fecSSudeep Holla } 986a36a7fecSSudeep Holla 987a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 1, &lpi_state->wake_latency)) { 988a36a7fecSSudeep Holla pr_debug("No wakeup residency found, assuming 10 us\n"); 989a36a7fecSSudeep Holla lpi_state->wake_latency = 10; 990a36a7fecSSudeep Holla } 991a36a7fecSSudeep Holla 992a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 2, &lpi_state->flags)) 993a36a7fecSSudeep Holla lpi_state->flags = 0; 994a36a7fecSSudeep Holla 995a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 3, &lpi_state->arch_flags)) 996a36a7fecSSudeep Holla lpi_state->arch_flags = 0; 997a36a7fecSSudeep Holla 998a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 4, &lpi_state->res_cnt_freq)) 999a36a7fecSSudeep Holla lpi_state->res_cnt_freq = 1; 1000a36a7fecSSudeep Holla 1001a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 5, &lpi_state->enable_parent_state)) 1002a36a7fecSSudeep Holla lpi_state->enable_parent_state = 0; 1003a36a7fecSSudeep Holla } 1004a36a7fecSSudeep Holla 1005a36a7fecSSudeep Holla acpi_handle_debug(handle, "Found %d power states\n", state_idx); 1006a36a7fecSSudeep Holla end: 1007a36a7fecSSudeep Holla kfree(buffer.pointer); 1008a36a7fecSSudeep Holla return ret; 1009a36a7fecSSudeep Holla } 1010a36a7fecSSudeep Holla 1011a36a7fecSSudeep Holla /* 1012a36a7fecSSudeep Holla * flat_state_cnt - the number of composite LPI states after the process of flattening 1013a36a7fecSSudeep Holla */ 1014a36a7fecSSudeep Holla static int flat_state_cnt; 1015a36a7fecSSudeep Holla 1016a36a7fecSSudeep Holla /** 1017a36a7fecSSudeep Holla * combine_lpi_states - combine local and parent LPI states to form a composite LPI state 1018a36a7fecSSudeep Holla * 1019a36a7fecSSudeep Holla * @local: local LPI state 1020a36a7fecSSudeep Holla * @parent: parent LPI state 1021a36a7fecSSudeep Holla * @result: composite LPI state 1022a36a7fecSSudeep Holla */ 1023a36a7fecSSudeep Holla static bool combine_lpi_states(struct acpi_lpi_state *local, 1024a36a7fecSSudeep Holla struct acpi_lpi_state *parent, 1025a36a7fecSSudeep Holla struct acpi_lpi_state *result) 1026a36a7fecSSudeep Holla { 1027a36a7fecSSudeep Holla if (parent->entry_method == ACPI_CSTATE_INTEGER) { 1028a36a7fecSSudeep Holla if (!parent->address) /* 0 means autopromotable */ 1029a36a7fecSSudeep Holla return false; 1030a36a7fecSSudeep Holla result->address = local->address + parent->address; 1031a36a7fecSSudeep Holla } else { 1032a36a7fecSSudeep Holla result->address = parent->address; 1033a36a7fecSSudeep Holla } 1034a36a7fecSSudeep Holla 1035a36a7fecSSudeep Holla result->min_residency = max(local->min_residency, parent->min_residency); 1036a36a7fecSSudeep Holla result->wake_latency = local->wake_latency + parent->wake_latency; 1037a36a7fecSSudeep Holla result->enable_parent_state = parent->enable_parent_state; 1038a36a7fecSSudeep Holla result->entry_method = local->entry_method; 1039a36a7fecSSudeep Holla 1040a36a7fecSSudeep Holla result->flags = parent->flags; 1041a36a7fecSSudeep Holla result->arch_flags = parent->arch_flags; 1042a36a7fecSSudeep Holla result->index = parent->index; 1043a36a7fecSSudeep Holla 1044b75d2cd0SWolfram Sang strscpy(result->desc, local->desc, ACPI_CX_DESC_LEN); 1045a36a7fecSSudeep Holla strlcat(result->desc, "+", ACPI_CX_DESC_LEN); 1046a36a7fecSSudeep Holla strlcat(result->desc, parent->desc, ACPI_CX_DESC_LEN); 1047a36a7fecSSudeep Holla return true; 1048a36a7fecSSudeep Holla } 1049a36a7fecSSudeep Holla 1050a36a7fecSSudeep Holla #define ACPI_LPI_STATE_FLAGS_ENABLED BIT(0) 1051a36a7fecSSudeep Holla 1052a36a7fecSSudeep Holla static void stash_composite_state(struct acpi_lpi_states_array *curr_level, 1053a36a7fecSSudeep Holla struct acpi_lpi_state *t) 1054a36a7fecSSudeep Holla { 1055a36a7fecSSudeep Holla curr_level->composite_states[curr_level->composite_states_size++] = t; 1056a36a7fecSSudeep Holla } 1057a36a7fecSSudeep Holla 1058a36a7fecSSudeep Holla static int flatten_lpi_states(struct acpi_processor *pr, 1059a36a7fecSSudeep Holla struct acpi_lpi_states_array *curr_level, 1060a36a7fecSSudeep Holla struct acpi_lpi_states_array *prev_level) 1061a36a7fecSSudeep Holla { 1062a36a7fecSSudeep Holla int i, j, state_count = curr_level->size; 1063a36a7fecSSudeep Holla struct acpi_lpi_state *p, *t = curr_level->entries; 1064a36a7fecSSudeep Holla 1065a36a7fecSSudeep Holla curr_level->composite_states_size = 0; 1066a36a7fecSSudeep Holla for (j = 0; j < state_count; j++, t++) { 1067a36a7fecSSudeep Holla struct acpi_lpi_state *flpi; 1068a36a7fecSSudeep Holla 1069a36a7fecSSudeep Holla if (!(t->flags & ACPI_LPI_STATE_FLAGS_ENABLED)) 1070a36a7fecSSudeep Holla continue; 1071a36a7fecSSudeep Holla 1072a36a7fecSSudeep Holla if (flat_state_cnt >= ACPI_PROCESSOR_MAX_POWER) { 1073a36a7fecSSudeep Holla pr_warn("Limiting number of LPI states to max (%d)\n", 1074a36a7fecSSudeep Holla ACPI_PROCESSOR_MAX_POWER); 1075a36a7fecSSudeep Holla pr_warn("Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n"); 1076a36a7fecSSudeep Holla break; 1077a36a7fecSSudeep Holla } 1078a36a7fecSSudeep Holla 1079a36a7fecSSudeep Holla flpi = &pr->power.lpi_states[flat_state_cnt]; 1080a36a7fecSSudeep Holla 1081a36a7fecSSudeep Holla if (!prev_level) { /* leaf/processor node */ 1082a36a7fecSSudeep Holla memcpy(flpi, t, sizeof(*t)); 1083a36a7fecSSudeep Holla stash_composite_state(curr_level, flpi); 1084a36a7fecSSudeep Holla flat_state_cnt++; 1085a36a7fecSSudeep Holla continue; 1086a36a7fecSSudeep Holla } 1087a36a7fecSSudeep Holla 1088a36a7fecSSudeep Holla for (i = 0; i < prev_level->composite_states_size; i++) { 1089a36a7fecSSudeep Holla p = prev_level->composite_states[i]; 1090a36a7fecSSudeep Holla if (t->index <= p->enable_parent_state && 1091a36a7fecSSudeep Holla combine_lpi_states(p, t, flpi)) { 1092a36a7fecSSudeep Holla stash_composite_state(curr_level, flpi); 1093a36a7fecSSudeep Holla flat_state_cnt++; 1094a36a7fecSSudeep Holla flpi++; 1095a36a7fecSSudeep Holla } 1096a36a7fecSSudeep Holla } 1097a36a7fecSSudeep Holla } 1098a36a7fecSSudeep Holla 1099a36a7fecSSudeep Holla kfree(curr_level->entries); 1100a36a7fecSSudeep Holla return 0; 1101a36a7fecSSudeep Holla } 1102a36a7fecSSudeep Holla 1103eb087f30SMario Limonciello int __weak acpi_processor_ffh_lpi_probe(unsigned int cpu) 1104eb087f30SMario Limonciello { 1105eb087f30SMario Limonciello return -EOPNOTSUPP; 1106eb087f30SMario Limonciello } 1107eb087f30SMario Limonciello 1108a36a7fecSSudeep Holla static int acpi_processor_get_lpi_info(struct acpi_processor *pr) 1109a36a7fecSSudeep Holla { 1110a36a7fecSSudeep Holla int ret, i; 1111a36a7fecSSudeep Holla acpi_status status; 1112a36a7fecSSudeep Holla acpi_handle handle = pr->handle, pr_ahandle; 1113a36a7fecSSudeep Holla struct acpi_device *d = NULL; 1114a36a7fecSSudeep Holla struct acpi_lpi_states_array info[2], *tmp, *prev, *curr; 1115a36a7fecSSudeep Holla 1116eb087f30SMario Limonciello /* make sure our architecture has support */ 1117eb087f30SMario Limonciello ret = acpi_processor_ffh_lpi_probe(pr->id); 1118eb087f30SMario Limonciello if (ret == -EOPNOTSUPP) 1119eb087f30SMario Limonciello return ret; 1120eb087f30SMario Limonciello 1121a36a7fecSSudeep Holla if (!osc_pc_lpi_support_confirmed) 1122a36a7fecSSudeep Holla return -EOPNOTSUPP; 1123a36a7fecSSudeep Holla 1124a36a7fecSSudeep Holla if (!acpi_has_method(handle, "_LPI")) 1125a36a7fecSSudeep Holla return -EINVAL; 1126a36a7fecSSudeep Holla 1127a36a7fecSSudeep Holla flat_state_cnt = 0; 1128a36a7fecSSudeep Holla prev = &info[0]; 1129a36a7fecSSudeep Holla curr = &info[1]; 1130a36a7fecSSudeep Holla handle = pr->handle; 1131a36a7fecSSudeep Holla ret = acpi_processor_evaluate_lpi(handle, prev); 1132a36a7fecSSudeep Holla if (ret) 1133a36a7fecSSudeep Holla return ret; 1134a36a7fecSSudeep Holla flatten_lpi_states(pr, prev, NULL); 1135a36a7fecSSudeep Holla 1136a36a7fecSSudeep Holla status = acpi_get_parent(handle, &pr_ahandle); 1137a36a7fecSSudeep Holla while (ACPI_SUCCESS(status)) { 113899ece713SRafael J. Wysocki d = acpi_fetch_acpi_dev(pr_ahandle); 11392437513aSLi Zhong if (!d) 11402437513aSLi Zhong break; 11412437513aSLi Zhong 1142a36a7fecSSudeep Holla handle = pr_ahandle; 1143a36a7fecSSudeep Holla 1144a36a7fecSSudeep Holla if (strcmp(acpi_device_hid(d), ACPI_PROCESSOR_CONTAINER_HID)) 1145a36a7fecSSudeep Holla break; 1146a36a7fecSSudeep Holla 1147a36a7fecSSudeep Holla /* can be optional ? */ 1148a36a7fecSSudeep Holla if (!acpi_has_method(handle, "_LPI")) 1149a36a7fecSSudeep Holla break; 1150a36a7fecSSudeep Holla 1151a36a7fecSSudeep Holla ret = acpi_processor_evaluate_lpi(handle, curr); 1152a36a7fecSSudeep Holla if (ret) 1153a36a7fecSSudeep Holla break; 1154a36a7fecSSudeep Holla 1155a36a7fecSSudeep Holla /* flatten all the LPI states in this level of hierarchy */ 1156a36a7fecSSudeep Holla flatten_lpi_states(pr, curr, prev); 1157a36a7fecSSudeep Holla 1158a36a7fecSSudeep Holla tmp = prev, prev = curr, curr = tmp; 1159a36a7fecSSudeep Holla 1160a36a7fecSSudeep Holla status = acpi_get_parent(handle, &pr_ahandle); 1161a36a7fecSSudeep Holla } 1162a36a7fecSSudeep Holla 1163a36a7fecSSudeep Holla pr->power.count = flat_state_cnt; 1164a36a7fecSSudeep Holla /* reset the index after flattening */ 1165a36a7fecSSudeep Holla for (i = 0; i < pr->power.count; i++) 1166a36a7fecSSudeep Holla pr->power.lpi_states[i].index = i; 1167a36a7fecSSudeep Holla 1168a36a7fecSSudeep Holla /* Tell driver that _LPI is supported. */ 1169a36a7fecSSudeep Holla pr->flags.has_lpi = 1; 1170a36a7fecSSudeep Holla pr->flags.power = 1; 1171a36a7fecSSudeep Holla 1172a36a7fecSSudeep Holla return 0; 1173a36a7fecSSudeep Holla } 1174a36a7fecSSudeep Holla 1175a36a7fecSSudeep Holla int __weak acpi_processor_ffh_lpi_enter(struct acpi_lpi_state *lpi) 1176a36a7fecSSudeep Holla { 1177a36a7fecSSudeep Holla return -ENODEV; 1178a36a7fecSSudeep Holla } 1179a36a7fecSSudeep Holla 1180a36a7fecSSudeep Holla /** 1181a36a7fecSSudeep Holla * acpi_idle_lpi_enter - enters an ACPI any LPI state 1182a36a7fecSSudeep Holla * @dev: the target CPU 1183a36a7fecSSudeep Holla * @drv: cpuidle driver containing cpuidle state info 1184a36a7fecSSudeep Holla * @index: index of target state 1185a36a7fecSSudeep Holla * 1186a36a7fecSSudeep Holla * Return: 0 for success or negative value for error 1187a36a7fecSSudeep Holla */ 1188a36a7fecSSudeep Holla static int acpi_idle_lpi_enter(struct cpuidle_device *dev, 1189a36a7fecSSudeep Holla struct cpuidle_driver *drv, int index) 1190a36a7fecSSudeep Holla { 1191a36a7fecSSudeep Holla struct acpi_processor *pr; 1192a36a7fecSSudeep Holla struct acpi_lpi_state *lpi; 1193a36a7fecSSudeep Holla 1194a36a7fecSSudeep Holla pr = __this_cpu_read(processors); 1195a36a7fecSSudeep Holla 1196a36a7fecSSudeep Holla if (unlikely(!pr)) 1197a36a7fecSSudeep Holla return -EINVAL; 1198a36a7fecSSudeep Holla 1199a36a7fecSSudeep Holla lpi = &pr->power.lpi_states[index]; 1200a36a7fecSSudeep Holla if (lpi->entry_method == ACPI_CSTATE_FFH) 1201a36a7fecSSudeep Holla return acpi_processor_ffh_lpi_enter(lpi); 1202a36a7fecSSudeep Holla 1203a36a7fecSSudeep Holla return -EINVAL; 1204a36a7fecSSudeep Holla } 1205a36a7fecSSudeep Holla 1206a36a7fecSSudeep Holla static int acpi_processor_setup_lpi_states(struct acpi_processor *pr) 1207a36a7fecSSudeep Holla { 1208a36a7fecSSudeep Holla int i; 1209a36a7fecSSudeep Holla struct acpi_lpi_state *lpi; 1210a36a7fecSSudeep Holla struct cpuidle_state *state; 1211a36a7fecSSudeep Holla struct cpuidle_driver *drv = &acpi_idle_driver; 1212a36a7fecSSudeep Holla 1213a36a7fecSSudeep Holla if (!pr->flags.has_lpi) 1214a36a7fecSSudeep Holla return -EOPNOTSUPP; 1215a36a7fecSSudeep Holla 1216a36a7fecSSudeep Holla for (i = 0; i < pr->power.count && i < CPUIDLE_STATE_MAX; i++) { 1217a36a7fecSSudeep Holla lpi = &pr->power.lpi_states[i]; 1218a36a7fecSSudeep Holla 1219a36a7fecSSudeep Holla state = &drv->states[i]; 1220a36a7fecSSudeep Holla snprintf(state->name, CPUIDLE_NAME_LEN, "LPI-%d", i); 1221b75d2cd0SWolfram Sang strscpy(state->desc, lpi->desc, CPUIDLE_DESC_LEN); 1222a36a7fecSSudeep Holla state->exit_latency = lpi->wake_latency; 1223a36a7fecSSudeep Holla state->target_residency = lpi->min_residency; 1224a36a7fecSSudeep Holla if (lpi->arch_flags) 1225a36a7fecSSudeep Holla state->flags |= CPUIDLE_FLAG_TIMER_STOP; 12260c5ffc3dSPeter Zijlstra if (i != 0 && lpi->entry_method == ACPI_CSTATE_FFH) 12270c5ffc3dSPeter Zijlstra state->flags |= CPUIDLE_FLAG_RCU_IDLE; 1228a36a7fecSSudeep Holla state->enter = acpi_idle_lpi_enter; 1229a36a7fecSSudeep Holla drv->safe_state_index = i; 1230a36a7fecSSudeep Holla } 1231a36a7fecSSudeep Holla 1232a36a7fecSSudeep Holla drv->state_count = i; 1233a36a7fecSSudeep Holla 1234a36a7fecSSudeep Holla return 0; 1235a36a7fecSSudeep Holla } 1236a36a7fecSSudeep Holla 1237a36a7fecSSudeep Holla /** 1238a36a7fecSSudeep Holla * acpi_processor_setup_cpuidle_states- prepares and configures cpuidle 1239a36a7fecSSudeep Holla * global state data i.e. idle routines 1240a36a7fecSSudeep Holla * 1241a36a7fecSSudeep Holla * @pr: the ACPI processor 1242a36a7fecSSudeep Holla */ 1243a36a7fecSSudeep Holla static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr) 1244a36a7fecSSudeep Holla { 1245a36a7fecSSudeep Holla int i; 1246a36a7fecSSudeep Holla struct cpuidle_driver *drv = &acpi_idle_driver; 1247a36a7fecSSudeep Holla 1248a36a7fecSSudeep Holla if (!pr->flags.power_setup_done || !pr->flags.power) 1249a36a7fecSSudeep Holla return -EINVAL; 1250a36a7fecSSudeep Holla 1251a36a7fecSSudeep Holla drv->safe_state_index = -1; 1252dc2251bfSRafael J. Wysocki for (i = ACPI_IDLE_STATE_START; i < CPUIDLE_STATE_MAX; i++) { 1253a36a7fecSSudeep Holla drv->states[i].name[0] = '\0'; 1254a36a7fecSSudeep Holla drv->states[i].desc[0] = '\0'; 1255a36a7fecSSudeep Holla } 1256a36a7fecSSudeep Holla 1257a36a7fecSSudeep Holla if (pr->flags.has_lpi) 1258a36a7fecSSudeep Holla return acpi_processor_setup_lpi_states(pr); 1259a36a7fecSSudeep Holla 1260a36a7fecSSudeep Holla return acpi_processor_setup_cstates(pr); 1261a36a7fecSSudeep Holla } 1262a36a7fecSSudeep Holla 1263a36a7fecSSudeep Holla /** 1264a36a7fecSSudeep Holla * acpi_processor_setup_cpuidle_dev - prepares and configures CPUIDLE 1265a36a7fecSSudeep Holla * device i.e. per-cpu data 1266a36a7fecSSudeep Holla * 1267a36a7fecSSudeep Holla * @pr: the ACPI processor 1268a36a7fecSSudeep Holla * @dev : the cpuidle device 1269a36a7fecSSudeep Holla */ 1270a36a7fecSSudeep Holla static int acpi_processor_setup_cpuidle_dev(struct acpi_processor *pr, 1271a36a7fecSSudeep Holla struct cpuidle_device *dev) 1272a36a7fecSSudeep Holla { 1273a36a7fecSSudeep Holla if (!pr->flags.power_setup_done || !pr->flags.power || !dev) 1274a36a7fecSSudeep Holla return -EINVAL; 1275a36a7fecSSudeep Holla 1276a36a7fecSSudeep Holla dev->cpu = pr->id; 1277a36a7fecSSudeep Holla if (pr->flags.has_lpi) 1278a36a7fecSSudeep Holla return acpi_processor_ffh_lpi_probe(pr->id); 1279a36a7fecSSudeep Holla 1280a36a7fecSSudeep Holla return acpi_processor_setup_cpuidle_cx(pr, dev); 1281a36a7fecSSudeep Holla } 1282a36a7fecSSudeep Holla 1283a36a7fecSSudeep Holla static int acpi_processor_get_power_info(struct acpi_processor *pr) 1284a36a7fecSSudeep Holla { 1285a36a7fecSSudeep Holla int ret; 1286a36a7fecSSudeep Holla 1287a36a7fecSSudeep Holla ret = acpi_processor_get_lpi_info(pr); 1288a36a7fecSSudeep Holla if (ret) 1289a36a7fecSSudeep Holla ret = acpi_processor_get_cstate_info(pr); 1290a36a7fecSSudeep Holla 1291a36a7fecSSudeep Holla return ret; 1292a36a7fecSSudeep Holla } 1293a36a7fecSSudeep Holla 129446bcfad7SDeepthi Dharwar int acpi_processor_hotplug(struct acpi_processor *pr) 12954f86d3a8SLen Brown { 1296dcb84f33SVenkatesh Pallipadi int ret = 0; 1297e8b1b59dSWei Yongjun struct cpuidle_device *dev; 12984f86d3a8SLen Brown 1299d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 130036a91358SVenkatesh Pallipadi return 0; 130136a91358SVenkatesh Pallipadi 13024f86d3a8SLen Brown if (!pr->flags.power_setup_done) 13034f86d3a8SLen Brown return -ENODEV; 13044f86d3a8SLen Brown 1305e8b1b59dSWei Yongjun dev = per_cpu(acpi_cpuidle_device, pr->id); 13064f86d3a8SLen Brown cpuidle_pause_and_lock(); 13073d339dcbSDaniel Lezcano cpuidle_disable_device(dev); 1308a36a7fecSSudeep Holla ret = acpi_processor_get_power_info(pr); 1309a36a7fecSSudeep Holla if (!ret && pr->flags.power) { 1310a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(pr, dev); 13113d339dcbSDaniel Lezcano ret = cpuidle_enable_device(dev); 1312dcb84f33SVenkatesh Pallipadi } 13134f86d3a8SLen Brown cpuidle_resume_and_unlock(); 13144f86d3a8SLen Brown 13154f86d3a8SLen Brown return ret; 13164f86d3a8SLen Brown } 13174f86d3a8SLen Brown 1318a36a7fecSSudeep Holla int acpi_processor_power_state_has_changed(struct acpi_processor *pr) 131946bcfad7SDeepthi Dharwar { 132046bcfad7SDeepthi Dharwar int cpu; 132146bcfad7SDeepthi Dharwar struct acpi_processor *_pr; 13223d339dcbSDaniel Lezcano struct cpuidle_device *dev; 132346bcfad7SDeepthi Dharwar 132446bcfad7SDeepthi Dharwar if (disabled_by_idle_boot_param()) 132546bcfad7SDeepthi Dharwar return 0; 132646bcfad7SDeepthi Dharwar 132746bcfad7SDeepthi Dharwar if (!pr->flags.power_setup_done) 132846bcfad7SDeepthi Dharwar return -ENODEV; 132946bcfad7SDeepthi Dharwar 133046bcfad7SDeepthi Dharwar /* 133146bcfad7SDeepthi Dharwar * FIXME: Design the ACPI notification to make it once per 133246bcfad7SDeepthi Dharwar * system instead of once per-cpu. This condition is a hack 133346bcfad7SDeepthi Dharwar * to make the code that updates C-States be called once. 133446bcfad7SDeepthi Dharwar */ 133546bcfad7SDeepthi Dharwar 13369505626dSPaul E. McKenney if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) { 133746bcfad7SDeepthi Dharwar 133846bcfad7SDeepthi Dharwar /* Protect against cpu-hotplug */ 133995ac7067SSebastian Andrzej Siewior cpus_read_lock(); 13406726655dSJiri Kosina cpuidle_pause_and_lock(); 134146bcfad7SDeepthi Dharwar 134246bcfad7SDeepthi Dharwar /* Disable all cpuidle devices */ 134346bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) { 134446bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu); 134546bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done) 134646bcfad7SDeepthi Dharwar continue; 13473d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu); 13483d339dcbSDaniel Lezcano cpuidle_disable_device(dev); 134946bcfad7SDeepthi Dharwar } 135046bcfad7SDeepthi Dharwar 135146bcfad7SDeepthi Dharwar /* Populate Updated C-state information */ 1352f427e5f1SThomas Schlichter acpi_processor_get_power_info(pr); 135346bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr); 135446bcfad7SDeepthi Dharwar 135546bcfad7SDeepthi Dharwar /* Enable all cpuidle devices */ 135646bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) { 135746bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu); 135846bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done) 135946bcfad7SDeepthi Dharwar continue; 136046bcfad7SDeepthi Dharwar acpi_processor_get_power_info(_pr); 136146bcfad7SDeepthi Dharwar if (_pr->flags.power) { 13623d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu); 1363a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(_pr, dev); 13643d339dcbSDaniel Lezcano cpuidle_enable_device(dev); 136546bcfad7SDeepthi Dharwar } 136646bcfad7SDeepthi Dharwar } 136746bcfad7SDeepthi Dharwar cpuidle_resume_and_unlock(); 136895ac7067SSebastian Andrzej Siewior cpus_read_unlock(); 136946bcfad7SDeepthi Dharwar } 137046bcfad7SDeepthi Dharwar 137146bcfad7SDeepthi Dharwar return 0; 137246bcfad7SDeepthi Dharwar } 137346bcfad7SDeepthi Dharwar 137446bcfad7SDeepthi Dharwar static int acpi_processor_registered; 137546bcfad7SDeepthi Dharwar 1376fe7bf106SPaul Gortmaker int acpi_processor_power_init(struct acpi_processor *pr) 13771da177e4SLinus Torvalds { 137846bcfad7SDeepthi Dharwar int retval; 13793d339dcbSDaniel Lezcano struct cpuidle_device *dev; 13801da177e4SLinus Torvalds 1381d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 138236a91358SVenkatesh Pallipadi return 0; 13831da177e4SLinus Torvalds 138435ae7133SSudeep Holla acpi_processor_cstate_first_run_checks(); 13851da177e4SLinus Torvalds 138635ae7133SSudeep Holla if (!acpi_processor_get_power_info(pr)) 13874f86d3a8SLen Brown pr->flags.power_setup_done = 1; 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds /* 13901da177e4SLinus Torvalds * Install the idle handler if processor power management is supported. 13911da177e4SLinus Torvalds * Note that we use previously set idle handler will be used on 13921da177e4SLinus Torvalds * platforms that only support C1. 13931da177e4SLinus Torvalds */ 139436a91358SVenkatesh Pallipadi if (pr->flags.power) { 139546bcfad7SDeepthi Dharwar /* Register acpi_idle_driver if not already registered */ 139646bcfad7SDeepthi Dharwar if (!acpi_processor_registered) { 139746bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr); 139846bcfad7SDeepthi Dharwar retval = cpuidle_register_driver(&acpi_idle_driver); 139946bcfad7SDeepthi Dharwar if (retval) 140046bcfad7SDeepthi Dharwar return retval; 1401b6ec26fbSSudeep Holla pr_debug("%s registered with cpuidle\n", 140246bcfad7SDeepthi Dharwar acpi_idle_driver.name); 140346bcfad7SDeepthi Dharwar } 14043d339dcbSDaniel Lezcano 14053d339dcbSDaniel Lezcano dev = kzalloc(sizeof(*dev), GFP_KERNEL); 14063d339dcbSDaniel Lezcano if (!dev) 14073d339dcbSDaniel Lezcano return -ENOMEM; 14083d339dcbSDaniel Lezcano per_cpu(acpi_cpuidle_device, pr->id) = dev; 14093d339dcbSDaniel Lezcano 1410a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(pr, dev); 14113d339dcbSDaniel Lezcano 141246bcfad7SDeepthi Dharwar /* Register per-cpu cpuidle_device. Cpuidle driver 141346bcfad7SDeepthi Dharwar * must already be registered before registering device 141446bcfad7SDeepthi Dharwar */ 14153d339dcbSDaniel Lezcano retval = cpuidle_register_device(dev); 141646bcfad7SDeepthi Dharwar if (retval) { 141746bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0) 141846bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver); 141946bcfad7SDeepthi Dharwar return retval; 142046bcfad7SDeepthi Dharwar } 142146bcfad7SDeepthi Dharwar acpi_processor_registered++; 14221da177e4SLinus Torvalds } 1423d550d98dSPatrick Mochel return 0; 14241da177e4SLinus Torvalds } 14251da177e4SLinus Torvalds 142638a991b6SDaniel Lezcano int acpi_processor_power_exit(struct acpi_processor *pr) 14271da177e4SLinus Torvalds { 14283d339dcbSDaniel Lezcano struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id); 14293d339dcbSDaniel Lezcano 1430d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 143136a91358SVenkatesh Pallipadi return 0; 143236a91358SVenkatesh Pallipadi 143346bcfad7SDeepthi Dharwar if (pr->flags.power) { 14343d339dcbSDaniel Lezcano cpuidle_unregister_device(dev); 143546bcfad7SDeepthi Dharwar acpi_processor_registered--; 143646bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0) 143746bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver); 143846bcfad7SDeepthi Dharwar } 14391da177e4SLinus Torvalds 144046bcfad7SDeepthi Dharwar pr->flags.power_setup_done = 0; 1441d550d98dSPatrick Mochel return 0; 14421da177e4SLinus Torvalds } 1443