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()) { 112ddc081a1SVenkatesh Pallipadi safe_halt(); 11371e93d15SVenki Pallipadi 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 */ 327*b697b812SRafael 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 460*b697b812SRafael 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 526fa583f71SYin Fengwei static void wait_for_freeze(void) 527fa583f71SYin Fengwei { 528fa583f71SYin Fengwei #ifdef CONFIG_X86 529fa583f71SYin Fengwei /* No delay is needed if we are in guest */ 530fa583f71SYin Fengwei if (boot_cpu_has(X86_FEATURE_HYPERVISOR)) 531fa583f71SYin Fengwei return; 532e400ad8bSDave Hansen /* 533e400ad8bSDave Hansen * Modern (>=Nehalem) Intel systems use ACPI via intel_idle, 534e400ad8bSDave Hansen * not this code. Assume that any Intel systems using this 535e400ad8bSDave Hansen * are ancient and may need the dummy wait. This also assumes 536e400ad8bSDave Hansen * that the motivating chipset issue was Intel-only. 537e400ad8bSDave Hansen */ 538e400ad8bSDave Hansen if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL) 539e400ad8bSDave Hansen return; 540fa583f71SYin Fengwei #endif 541e400ad8bSDave Hansen /* 542e400ad8bSDave Hansen * Dummy wait op - must do something useless after P_LVL2 read 543e400ad8bSDave Hansen * because chipsets cannot guarantee that STPCLK# signal gets 544e400ad8bSDave Hansen * asserted in time to freeze execution properly 545e400ad8bSDave Hansen * 546e400ad8bSDave Hansen * This workaround has been in place since the original ACPI 547e400ad8bSDave Hansen * implementation was merged, circa 2002. 548e400ad8bSDave Hansen * 549e400ad8bSDave Hansen * If a profile is pointing to this instruction, please first 550e400ad8bSDave Hansen * consider moving your system to a more modern idle 551e400ad8bSDave Hansen * mechanism. 552e400ad8bSDave Hansen */ 553fa583f71SYin Fengwei inl(acpi_gbl_FADT.xpm_timer_block.address); 554fa583f71SYin Fengwei } 555fa583f71SYin Fengwei 5564f86d3a8SLen Brown /** 557b00783fdSRafael J. Wysocki * acpi_idle_do_entry - enter idle state using the appropriate method 5584f86d3a8SLen Brown * @cx: cstate data 559bc71bec9Svenkatesh.pallipadi@intel.com * 560bc71bec9Svenkatesh.pallipadi@intel.com * Caller disables interrupt before call and enables interrupt after return. 5614f86d3a8SLen Brown */ 5626727ad9eSChris Metcalf static void __cpuidle acpi_idle_do_entry(struct acpi_processor_cx *cx) 5634f86d3a8SLen Brown { 5642a606a18SStephane Eranian perf_lopwr_cb(true); 5652a606a18SStephane Eranian 566bc71bec9Svenkatesh.pallipadi@intel.com if (cx->entry_method == ACPI_CSTATE_FFH) { 5674f86d3a8SLen Brown /* Call into architectural FFH based C-state */ 5684f86d3a8SLen Brown acpi_processor_ffh_cstate_enter(cx); 569bc71bec9Svenkatesh.pallipadi@intel.com } else if (cx->entry_method == ACPI_CSTATE_HALT) { 570bc71bec9Svenkatesh.pallipadi@intel.com acpi_safe_halt(); 5714f86d3a8SLen Brown } else { 5724f86d3a8SLen Brown /* IO port based C-state */ 5734f86d3a8SLen Brown inb(cx->address); 574fa583f71SYin Fengwei wait_for_freeze(); 5754f86d3a8SLen Brown } 5762a606a18SStephane Eranian 5772a606a18SStephane Eranian perf_lopwr_cb(false); 5784f86d3a8SLen Brown } 5794f86d3a8SLen Brown 5804f86d3a8SLen Brown /** 5811a022e3fSBoris Ostrovsky * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining) 5821a022e3fSBoris Ostrovsky * @dev: the target CPU 5831a022e3fSBoris Ostrovsky * @index: the index of suggested state 5841a022e3fSBoris Ostrovsky */ 5851a022e3fSBoris Ostrovsky static int acpi_idle_play_dead(struct cpuidle_device *dev, int index) 5861a022e3fSBoris Ostrovsky { 5876240a10dSAlex Shi struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 5881a022e3fSBoris Ostrovsky 5891a022e3fSBoris Ostrovsky ACPI_FLUSH_CPU_CACHE(); 5901a022e3fSBoris Ostrovsky 5911a022e3fSBoris Ostrovsky while (1) { 5921a022e3fSBoris Ostrovsky 5931a022e3fSBoris Ostrovsky if (cx->entry_method == ACPI_CSTATE_HALT) 59454f70077SLuck, Tony safe_halt(); 5951a022e3fSBoris Ostrovsky else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) { 5961a022e3fSBoris Ostrovsky inb(cx->address); 597fa583f71SYin Fengwei wait_for_freeze(); 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 6451fecfdbbSPeter Zijlstra /* If we can skip BM, demote to a safe state. */ 6461fecfdbbSPeter Zijlstra if (!cx->bm_sts_skip && acpi_idle_bm_check()) { 6471fecfdbbSPeter Zijlstra dis_bm = false; 6481fecfdbbSPeter Zijlstra index = drv->safe_state_index; 6491fecfdbbSPeter Zijlstra if (index >= 0) { 6501fecfdbbSPeter Zijlstra cx = this_cpu_read(acpi_cstate[index]); 6511fecfdbbSPeter Zijlstra } else { 6521fecfdbbSPeter Zijlstra cx = &safe_cx; 6531fecfdbbSPeter Zijlstra index = -EBUSY; 6541fecfdbbSPeter Zijlstra } 6551fecfdbbSPeter Zijlstra } 6561fecfdbbSPeter Zijlstra 6571fecfdbbSPeter Zijlstra if (dis_bm) { 658e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock); 6594f86d3a8SLen Brown c3_cpu_count++; 6604f86d3a8SLen Brown /* Disable bus master arbitration when all CPUs are in C3 */ 6614f86d3a8SLen Brown if (c3_cpu_count == num_online_cpus()) 66250ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1); 663e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock); 664c9c860e5SVenkatesh Pallipadi } 6654f86d3a8SLen Brown 666e67198ccSFrederic Weisbecker ct_idle_enter(); 6671fecfdbbSPeter Zijlstra 6684f86d3a8SLen Brown acpi_idle_do_entry(cx); 6694f86d3a8SLen Brown 670e67198ccSFrederic Weisbecker ct_idle_exit(); 6711fecfdbbSPeter Zijlstra 6724f86d3a8SLen Brown /* Re-enable bus master arbitration */ 6731fecfdbbSPeter Zijlstra if (dis_bm) { 674e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock); 67550ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0); 6764f86d3a8SLen Brown c3_cpu_count--; 677e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock); 6784f86d3a8SLen Brown } 6791fecfdbbSPeter Zijlstra 6801fecfdbbSPeter Zijlstra return index; 6816491bc0cSRafael J. Wysocki } 6826491bc0cSRafael J. Wysocki 683409dfdcaSGuilherme G. Piccoli static int __cpuidle acpi_idle_enter(struct cpuidle_device *dev, 6846491bc0cSRafael J. Wysocki struct cpuidle_driver *drv, int index) 6856491bc0cSRafael J. Wysocki { 6866491bc0cSRafael J. Wysocki struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 6876491bc0cSRafael J. Wysocki struct acpi_processor *pr; 6886491bc0cSRafael J. Wysocki 6896491bc0cSRafael J. Wysocki pr = __this_cpu_read(processors); 6906491bc0cSRafael J. Wysocki if (unlikely(!pr)) 6916491bc0cSRafael J. Wysocki return -EINVAL; 6926491bc0cSRafael J. Wysocki 6936491bc0cSRafael J. Wysocki if (cx->type != ACPI_STATE_C1) { 6941fecfdbbSPeter Zijlstra if (cx->type == ACPI_STATE_C3 && pr->flags.bm_check) 6951fecfdbbSPeter Zijlstra return acpi_idle_enter_bm(drv, pr, cx, index); 6961fecfdbbSPeter Zijlstra 6971fecfdbbSPeter Zijlstra /* C2 to C1 demotion. */ 6985f508185SRafael J. Wysocki if (acpi_idle_fallback_to_c1(pr) && num_online_cpus() > 1) { 699dc2251bfSRafael J. Wysocki index = ACPI_IDLE_STATE_START; 7006491bc0cSRafael J. Wysocki cx = per_cpu(acpi_cstate[index], dev->cpu); 7016491bc0cSRafael J. Wysocki } 7026491bc0cSRafael J. Wysocki } 7036491bc0cSRafael J. Wysocki 7046491bc0cSRafael J. Wysocki if (cx->type == ACPI_STATE_C3) 7056491bc0cSRafael J. Wysocki ACPI_FLUSH_CPU_CACHE(); 7066491bc0cSRafael J. Wysocki 7076491bc0cSRafael J. Wysocki acpi_idle_do_entry(cx); 7086491bc0cSRafael J. Wysocki 709e978aa7dSDeepthi Dharwar return index; 7104f86d3a8SLen Brown } 7114f86d3a8SLen Brown 712409dfdcaSGuilherme G. Piccoli static int __cpuidle acpi_idle_enter_s2idle(struct cpuidle_device *dev, 7135f508185SRafael J. Wysocki struct cpuidle_driver *drv, int index) 7145f508185SRafael J. Wysocki { 7155f508185SRafael J. Wysocki struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); 7165f508185SRafael J. Wysocki 7175f508185SRafael J. Wysocki if (cx->type == ACPI_STATE_C3) { 7185f508185SRafael J. Wysocki struct acpi_processor *pr = __this_cpu_read(processors); 7195f508185SRafael J. Wysocki 7205f508185SRafael J. Wysocki if (unlikely(!pr)) 7210a398945SNeal Liu return 0; 7225f508185SRafael J. Wysocki 7235f508185SRafael J. Wysocki if (pr->flags.bm_check) { 7241fecfdbbSPeter Zijlstra u8 bm_sts_skip = cx->bm_sts_skip; 7251fecfdbbSPeter Zijlstra 7261fecfdbbSPeter Zijlstra /* Don't check BM_STS, do an unconditional ARB_DIS for S2IDLE */ 7271fecfdbbSPeter Zijlstra cx->bm_sts_skip = 1; 7281fecfdbbSPeter Zijlstra acpi_idle_enter_bm(drv, pr, cx, index); 7291fecfdbbSPeter Zijlstra cx->bm_sts_skip = bm_sts_skip; 7301fecfdbbSPeter Zijlstra 7310a398945SNeal Liu return 0; 7325f508185SRafael J. Wysocki } else { 7335f508185SRafael J. Wysocki ACPI_FLUSH_CPU_CACHE(); 7345f508185SRafael J. Wysocki } 7355f508185SRafael J. Wysocki } 7365f508185SRafael J. Wysocki acpi_idle_do_entry(cx); 737efe97112SNeal Liu 738efe97112SNeal Liu return 0; 7395f508185SRafael J. Wysocki } 7405f508185SRafael J. Wysocki 7416ef0f086SDaniel Lezcano static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr, 7426ef0f086SDaniel Lezcano struct cpuidle_device *dev) 7434f86d3a8SLen Brown { 744dc2251bfSRafael J. Wysocki int i, count = ACPI_IDLE_STATE_START; 7454f86d3a8SLen Brown struct acpi_processor_cx *cx; 746aa6b43d5SPeter Zijlstra struct cpuidle_state *state; 7474f86d3a8SLen Brown 748615dfd93SLen Brown if (max_cstate == 0) 749615dfd93SLen Brown max_cstate = 1; 750615dfd93SLen Brown 7514f86d3a8SLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 752a889a23aSPeter Zijlstra state = &acpi_idle_driver.states[count]; 7534f86d3a8SLen Brown cx = &pr->power.states[i]; 7544f86d3a8SLen Brown 7554f86d3a8SLen Brown if (!cx->valid) 7564f86d3a8SLen Brown continue; 7574f86d3a8SLen Brown 7586240a10dSAlex Shi per_cpu(acpi_cstate[count], dev->cpu) = cx; 7594f86d3a8SLen Brown 760a889a23aSPeter Zijlstra if (lapic_timer_needs_broadcast(pr, cx)) 761aa6b43d5SPeter Zijlstra state->flags |= CPUIDLE_FLAG_TIMER_STOP; 762a889a23aSPeter Zijlstra 7631fecfdbbSPeter Zijlstra if (cx->type == ACPI_STATE_C3) { 764a889a23aSPeter Zijlstra state->flags |= CPUIDLE_FLAG_TLB_FLUSHED; 7651fecfdbbSPeter Zijlstra if (pr->flags.bm_check) 7661fecfdbbSPeter Zijlstra state->flags |= CPUIDLE_FLAG_RCU_IDLE; 7671fecfdbbSPeter Zijlstra } 768aa6b43d5SPeter Zijlstra 76946bcfad7SDeepthi Dharwar count++; 77046bcfad7SDeepthi Dharwar if (count == CPUIDLE_STATE_MAX) 77146bcfad7SDeepthi Dharwar break; 77246bcfad7SDeepthi Dharwar } 77346bcfad7SDeepthi Dharwar 77446bcfad7SDeepthi Dharwar if (!count) 77546bcfad7SDeepthi Dharwar return -EINVAL; 77646bcfad7SDeepthi Dharwar 77746bcfad7SDeepthi Dharwar return 0; 77846bcfad7SDeepthi Dharwar } 77946bcfad7SDeepthi Dharwar 780a36a7fecSSudeep Holla static int acpi_processor_setup_cstates(struct acpi_processor *pr) 78146bcfad7SDeepthi Dharwar { 7821b39e3f8SRafael J. Wysocki int i, count; 78346bcfad7SDeepthi Dharwar struct acpi_processor_cx *cx; 78446bcfad7SDeepthi Dharwar struct cpuidle_state *state; 78546bcfad7SDeepthi Dharwar struct cpuidle_driver *drv = &acpi_idle_driver; 78646bcfad7SDeepthi Dharwar 78746bcfad7SDeepthi Dharwar if (max_cstate == 0) 78846bcfad7SDeepthi Dharwar max_cstate = 1; 78946bcfad7SDeepthi Dharwar 7901b39e3f8SRafael J. Wysocki if (IS_ENABLED(CONFIG_ARCH_HAS_CPU_RELAX)) { 7911b39e3f8SRafael J. Wysocki cpuidle_poll_state_init(drv); 7921b39e3f8SRafael J. Wysocki count = 1; 7931b39e3f8SRafael J. Wysocki } else { 7941b39e3f8SRafael J. Wysocki count = 0; 7951b39e3f8SRafael J. Wysocki } 7961b39e3f8SRafael J. Wysocki 79746bcfad7SDeepthi Dharwar for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 79846bcfad7SDeepthi Dharwar cx = &pr->power.states[i]; 79946bcfad7SDeepthi Dharwar 80046bcfad7SDeepthi Dharwar if (!cx->valid) 80146bcfad7SDeepthi Dharwar continue; 80246bcfad7SDeepthi Dharwar 80346bcfad7SDeepthi Dharwar state = &drv->states[count]; 8044f86d3a8SLen Brown snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i); 805b75d2cd0SWolfram Sang strscpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); 8064f86d3a8SLen Brown state->exit_latency = cx->latency; 8074963f620SLen Brown state->target_residency = cx->latency * latency_factor; 8086491bc0cSRafael J. Wysocki state->enter = acpi_idle_enter; 8094f86d3a8SLen Brown 8104f86d3a8SLen Brown state->flags = 0; 811d6b88ce2SRichard Gong if (cx->type == ACPI_STATE_C1 || cx->type == ACPI_STATE_C2 || 812d6b88ce2SRichard Gong cx->type == ACPI_STATE_C3) { 8131a022e3fSBoris Ostrovsky state->enter_dead = acpi_idle_play_dead; 814fc45e55eSVille Syrjälä if (cx->type != ACPI_STATE_C3) 81546bcfad7SDeepthi Dharwar drv->safe_state_index = count; 8164f86d3a8SLen Brown } 8175f508185SRafael J. Wysocki /* 81828ba086eSRafael J. Wysocki * Halt-induced C1 is not good for ->enter_s2idle, because it 8195f508185SRafael J. Wysocki * re-enables interrupts on exit. Moreover, C1 is generally not 8205f508185SRafael J. Wysocki * particularly interesting from the suspend-to-idle angle, so 8215f508185SRafael J. Wysocki * avoid C1 and the situations in which we may need to fall back 8225f508185SRafael J. Wysocki * to it altogether. 8235f508185SRafael J. Wysocki */ 8245f508185SRafael J. Wysocki if (cx->type != ACPI_STATE_C1 && !acpi_idle_fallback_to_c1(pr)) 82528ba086eSRafael J. Wysocki state->enter_s2idle = acpi_idle_enter_s2idle; 8264f86d3a8SLen Brown 8274f86d3a8SLen Brown count++; 8289a0b8415Svenkatesh.pallipadi@intel.com if (count == CPUIDLE_STATE_MAX) 8299a0b8415Svenkatesh.pallipadi@intel.com break; 8304f86d3a8SLen Brown } 8314f86d3a8SLen Brown 83246bcfad7SDeepthi Dharwar drv->state_count = count; 8334f86d3a8SLen Brown 8344f86d3a8SLen Brown if (!count) 8354f86d3a8SLen Brown return -EINVAL; 8364f86d3a8SLen Brown 8374f86d3a8SLen Brown return 0; 8384f86d3a8SLen Brown } 8394f86d3a8SLen Brown 84035ae7133SSudeep Holla static inline void acpi_processor_cstate_first_run_checks(void) 84135ae7133SSudeep Holla { 84235ae7133SSudeep Holla static int first_run; 84335ae7133SSudeep Holla 84435ae7133SSudeep Holla if (first_run) 84535ae7133SSudeep Holla return; 84635ae7133SSudeep Holla dmi_check_system(processor_power_dmi_table); 84735ae7133SSudeep Holla max_cstate = acpi_processor_cstate_check(max_cstate); 84835ae7133SSudeep Holla if (max_cstate < ACPI_C_STATES_MAX) 84954e05192SRafael J. Wysocki pr_notice("processor limited to max C-state %d\n", max_cstate); 85054e05192SRafael J. Wysocki 85135ae7133SSudeep Holla first_run++; 85235ae7133SSudeep Holla 853bc946388SRafael J. Wysocki if (nocst) 854bc946388SRafael J. Wysocki return; 855bc946388SRafael J. Wysocki 856bc946388SRafael J. Wysocki acpi_processor_claim_cst_control(); 85735ae7133SSudeep Holla } 85835ae7133SSudeep Holla #else 85935ae7133SSudeep Holla 86035ae7133SSudeep Holla static inline int disabled_by_idle_boot_param(void) { return 0; } 86135ae7133SSudeep Holla static inline void acpi_processor_cstate_first_run_checks(void) { } 862a36a7fecSSudeep Holla static int acpi_processor_get_cstate_info(struct acpi_processor *pr) 86335ae7133SSudeep Holla { 86435ae7133SSudeep Holla return -ENODEV; 86535ae7133SSudeep Holla } 86635ae7133SSudeep Holla 86735ae7133SSudeep Holla static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr, 86835ae7133SSudeep Holla struct cpuidle_device *dev) 86935ae7133SSudeep Holla { 87035ae7133SSudeep Holla return -EINVAL; 87135ae7133SSudeep Holla } 87235ae7133SSudeep Holla 873a36a7fecSSudeep Holla static int acpi_processor_setup_cstates(struct acpi_processor *pr) 87435ae7133SSudeep Holla { 87535ae7133SSudeep Holla return -EINVAL; 87635ae7133SSudeep Holla } 87735ae7133SSudeep Holla 87835ae7133SSudeep Holla #endif /* CONFIG_ACPI_PROCESSOR_CSTATE */ 87935ae7133SSudeep Holla 880a36a7fecSSudeep Holla struct acpi_lpi_states_array { 881a36a7fecSSudeep Holla unsigned int size; 882a36a7fecSSudeep Holla unsigned int composite_states_size; 883a36a7fecSSudeep Holla struct acpi_lpi_state *entries; 884a36a7fecSSudeep Holla struct acpi_lpi_state *composite_states[ACPI_PROCESSOR_MAX_POWER]; 885a36a7fecSSudeep Holla }; 886a36a7fecSSudeep Holla 887a36a7fecSSudeep Holla static int obj_get_integer(union acpi_object *obj, u32 *value) 888a36a7fecSSudeep Holla { 889a36a7fecSSudeep Holla if (obj->type != ACPI_TYPE_INTEGER) 890a36a7fecSSudeep Holla return -EINVAL; 891a36a7fecSSudeep Holla 892a36a7fecSSudeep Holla *value = obj->integer.value; 893a36a7fecSSudeep Holla return 0; 894a36a7fecSSudeep Holla } 895a36a7fecSSudeep Holla 896a36a7fecSSudeep Holla static int acpi_processor_evaluate_lpi(acpi_handle handle, 897a36a7fecSSudeep Holla struct acpi_lpi_states_array *info) 898a36a7fecSSudeep Holla { 899a36a7fecSSudeep Holla acpi_status status; 900a36a7fecSSudeep Holla int ret = 0; 901a36a7fecSSudeep Holla int pkg_count, state_idx = 1, loop; 902a36a7fecSSudeep Holla struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 903a36a7fecSSudeep Holla union acpi_object *lpi_data; 904a36a7fecSSudeep Holla struct acpi_lpi_state *lpi_state; 905a36a7fecSSudeep Holla 906a36a7fecSSudeep Holla status = acpi_evaluate_object(handle, "_LPI", NULL, &buffer); 907a36a7fecSSudeep Holla if (ACPI_FAILURE(status)) { 90852af99c3SRafael J. Wysocki acpi_handle_debug(handle, "No _LPI, giving up\n"); 909a36a7fecSSudeep Holla return -ENODEV; 910a36a7fecSSudeep Holla } 911a36a7fecSSudeep Holla 912a36a7fecSSudeep Holla lpi_data = buffer.pointer; 913a36a7fecSSudeep Holla 914a36a7fecSSudeep Holla /* There must be at least 4 elements = 3 elements + 1 package */ 915a36a7fecSSudeep Holla if (!lpi_data || lpi_data->type != ACPI_TYPE_PACKAGE || 916a36a7fecSSudeep Holla lpi_data->package.count < 4) { 917a36a7fecSSudeep Holla pr_debug("not enough elements in _LPI\n"); 918a36a7fecSSudeep Holla ret = -ENODATA; 919a36a7fecSSudeep Holla goto end; 920a36a7fecSSudeep Holla } 921a36a7fecSSudeep Holla 922a36a7fecSSudeep Holla pkg_count = lpi_data->package.elements[2].integer.value; 923a36a7fecSSudeep Holla 924a36a7fecSSudeep Holla /* Validate number of power states. */ 925a36a7fecSSudeep Holla if (pkg_count < 1 || pkg_count != lpi_data->package.count - 3) { 926a36a7fecSSudeep Holla pr_debug("count given by _LPI is not valid\n"); 927a36a7fecSSudeep Holla ret = -ENODATA; 928a36a7fecSSudeep Holla goto end; 929a36a7fecSSudeep Holla } 930a36a7fecSSudeep Holla 931a36a7fecSSudeep Holla lpi_state = kcalloc(pkg_count, sizeof(*lpi_state), GFP_KERNEL); 932a36a7fecSSudeep Holla if (!lpi_state) { 933a36a7fecSSudeep Holla ret = -ENOMEM; 934a36a7fecSSudeep Holla goto end; 935a36a7fecSSudeep Holla } 936a36a7fecSSudeep Holla 937a36a7fecSSudeep Holla info->size = pkg_count; 938a36a7fecSSudeep Holla info->entries = lpi_state; 939a36a7fecSSudeep Holla 940a36a7fecSSudeep Holla /* LPI States start at index 3 */ 941a36a7fecSSudeep Holla for (loop = 3; state_idx <= pkg_count; loop++, state_idx++, lpi_state++) { 942a36a7fecSSudeep Holla union acpi_object *element, *pkg_elem, *obj; 943a36a7fecSSudeep Holla 944a36a7fecSSudeep Holla element = &lpi_data->package.elements[loop]; 945a36a7fecSSudeep Holla if (element->type != ACPI_TYPE_PACKAGE || element->package.count < 7) 946a36a7fecSSudeep Holla continue; 947a36a7fecSSudeep Holla 948a36a7fecSSudeep Holla pkg_elem = element->package.elements; 949a36a7fecSSudeep Holla 950a36a7fecSSudeep Holla obj = pkg_elem + 6; 951a36a7fecSSudeep Holla if (obj->type == ACPI_TYPE_BUFFER) { 952a36a7fecSSudeep Holla struct acpi_power_register *reg; 953a36a7fecSSudeep Holla 954a36a7fecSSudeep Holla reg = (struct acpi_power_register *)obj->buffer.pointer; 955a36a7fecSSudeep Holla if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && 956a36a7fecSSudeep Holla reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) 957a36a7fecSSudeep Holla continue; 958a36a7fecSSudeep Holla 959a36a7fecSSudeep Holla lpi_state->address = reg->address; 960a36a7fecSSudeep Holla lpi_state->entry_method = 961a36a7fecSSudeep Holla reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE ? 962a36a7fecSSudeep Holla ACPI_CSTATE_FFH : ACPI_CSTATE_SYSTEMIO; 963a36a7fecSSudeep Holla } else if (obj->type == ACPI_TYPE_INTEGER) { 964a36a7fecSSudeep Holla lpi_state->entry_method = ACPI_CSTATE_INTEGER; 965a36a7fecSSudeep Holla lpi_state->address = obj->integer.value; 966a36a7fecSSudeep Holla } else { 967a36a7fecSSudeep Holla continue; 968a36a7fecSSudeep Holla } 969a36a7fecSSudeep Holla 970a36a7fecSSudeep Holla /* elements[7,8] skipped for now i.e. Residency/Usage counter*/ 971a36a7fecSSudeep Holla 972a36a7fecSSudeep Holla obj = pkg_elem + 9; 973a36a7fecSSudeep Holla if (obj->type == ACPI_TYPE_STRING) 974b75d2cd0SWolfram Sang strscpy(lpi_state->desc, obj->string.pointer, 975a36a7fecSSudeep Holla ACPI_CX_DESC_LEN); 976a36a7fecSSudeep Holla 977a36a7fecSSudeep Holla lpi_state->index = state_idx; 978a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 0, &lpi_state->min_residency)) { 979a36a7fecSSudeep Holla pr_debug("No min. residency found, assuming 10 us\n"); 980a36a7fecSSudeep Holla lpi_state->min_residency = 10; 981a36a7fecSSudeep Holla } 982a36a7fecSSudeep Holla 983a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 1, &lpi_state->wake_latency)) { 984a36a7fecSSudeep Holla pr_debug("No wakeup residency found, assuming 10 us\n"); 985a36a7fecSSudeep Holla lpi_state->wake_latency = 10; 986a36a7fecSSudeep Holla } 987a36a7fecSSudeep Holla 988a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 2, &lpi_state->flags)) 989a36a7fecSSudeep Holla lpi_state->flags = 0; 990a36a7fecSSudeep Holla 991a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 3, &lpi_state->arch_flags)) 992a36a7fecSSudeep Holla lpi_state->arch_flags = 0; 993a36a7fecSSudeep Holla 994a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 4, &lpi_state->res_cnt_freq)) 995a36a7fecSSudeep Holla lpi_state->res_cnt_freq = 1; 996a36a7fecSSudeep Holla 997a36a7fecSSudeep Holla if (obj_get_integer(pkg_elem + 5, &lpi_state->enable_parent_state)) 998a36a7fecSSudeep Holla lpi_state->enable_parent_state = 0; 999a36a7fecSSudeep Holla } 1000a36a7fecSSudeep Holla 1001a36a7fecSSudeep Holla acpi_handle_debug(handle, "Found %d power states\n", state_idx); 1002a36a7fecSSudeep Holla end: 1003a36a7fecSSudeep Holla kfree(buffer.pointer); 1004a36a7fecSSudeep Holla return ret; 1005a36a7fecSSudeep Holla } 1006a36a7fecSSudeep Holla 1007a36a7fecSSudeep Holla /* 1008a36a7fecSSudeep Holla * flat_state_cnt - the number of composite LPI states after the process of flattening 1009a36a7fecSSudeep Holla */ 1010a36a7fecSSudeep Holla static int flat_state_cnt; 1011a36a7fecSSudeep Holla 1012a36a7fecSSudeep Holla /** 1013a36a7fecSSudeep Holla * combine_lpi_states - combine local and parent LPI states to form a composite LPI state 1014a36a7fecSSudeep Holla * 1015a36a7fecSSudeep Holla * @local: local LPI state 1016a36a7fecSSudeep Holla * @parent: parent LPI state 1017a36a7fecSSudeep Holla * @result: composite LPI state 1018a36a7fecSSudeep Holla */ 1019a36a7fecSSudeep Holla static bool combine_lpi_states(struct acpi_lpi_state *local, 1020a36a7fecSSudeep Holla struct acpi_lpi_state *parent, 1021a36a7fecSSudeep Holla struct acpi_lpi_state *result) 1022a36a7fecSSudeep Holla { 1023a36a7fecSSudeep Holla if (parent->entry_method == ACPI_CSTATE_INTEGER) { 1024a36a7fecSSudeep Holla if (!parent->address) /* 0 means autopromotable */ 1025a36a7fecSSudeep Holla return false; 1026a36a7fecSSudeep Holla result->address = local->address + parent->address; 1027a36a7fecSSudeep Holla } else { 1028a36a7fecSSudeep Holla result->address = parent->address; 1029a36a7fecSSudeep Holla } 1030a36a7fecSSudeep Holla 1031a36a7fecSSudeep Holla result->min_residency = max(local->min_residency, parent->min_residency); 1032a36a7fecSSudeep Holla result->wake_latency = local->wake_latency + parent->wake_latency; 1033a36a7fecSSudeep Holla result->enable_parent_state = parent->enable_parent_state; 1034a36a7fecSSudeep Holla result->entry_method = local->entry_method; 1035a36a7fecSSudeep Holla 1036a36a7fecSSudeep Holla result->flags = parent->flags; 1037a36a7fecSSudeep Holla result->arch_flags = parent->arch_flags; 1038a36a7fecSSudeep Holla result->index = parent->index; 1039a36a7fecSSudeep Holla 1040b75d2cd0SWolfram Sang strscpy(result->desc, local->desc, ACPI_CX_DESC_LEN); 1041a36a7fecSSudeep Holla strlcat(result->desc, "+", ACPI_CX_DESC_LEN); 1042a36a7fecSSudeep Holla strlcat(result->desc, parent->desc, ACPI_CX_DESC_LEN); 1043a36a7fecSSudeep Holla return true; 1044a36a7fecSSudeep Holla } 1045a36a7fecSSudeep Holla 1046a36a7fecSSudeep Holla #define ACPI_LPI_STATE_FLAGS_ENABLED BIT(0) 1047a36a7fecSSudeep Holla 1048a36a7fecSSudeep Holla static void stash_composite_state(struct acpi_lpi_states_array *curr_level, 1049a36a7fecSSudeep Holla struct acpi_lpi_state *t) 1050a36a7fecSSudeep Holla { 1051a36a7fecSSudeep Holla curr_level->composite_states[curr_level->composite_states_size++] = t; 1052a36a7fecSSudeep Holla } 1053a36a7fecSSudeep Holla 1054a36a7fecSSudeep Holla static int flatten_lpi_states(struct acpi_processor *pr, 1055a36a7fecSSudeep Holla struct acpi_lpi_states_array *curr_level, 1056a36a7fecSSudeep Holla struct acpi_lpi_states_array *prev_level) 1057a36a7fecSSudeep Holla { 1058a36a7fecSSudeep Holla int i, j, state_count = curr_level->size; 1059a36a7fecSSudeep Holla struct acpi_lpi_state *p, *t = curr_level->entries; 1060a36a7fecSSudeep Holla 1061a36a7fecSSudeep Holla curr_level->composite_states_size = 0; 1062a36a7fecSSudeep Holla for (j = 0; j < state_count; j++, t++) { 1063a36a7fecSSudeep Holla struct acpi_lpi_state *flpi; 1064a36a7fecSSudeep Holla 1065a36a7fecSSudeep Holla if (!(t->flags & ACPI_LPI_STATE_FLAGS_ENABLED)) 1066a36a7fecSSudeep Holla continue; 1067a36a7fecSSudeep Holla 1068a36a7fecSSudeep Holla if (flat_state_cnt >= ACPI_PROCESSOR_MAX_POWER) { 1069a36a7fecSSudeep Holla pr_warn("Limiting number of LPI states to max (%d)\n", 1070a36a7fecSSudeep Holla ACPI_PROCESSOR_MAX_POWER); 1071a36a7fecSSudeep Holla pr_warn("Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n"); 1072a36a7fecSSudeep Holla break; 1073a36a7fecSSudeep Holla } 1074a36a7fecSSudeep Holla 1075a36a7fecSSudeep Holla flpi = &pr->power.lpi_states[flat_state_cnt]; 1076a36a7fecSSudeep Holla 1077a36a7fecSSudeep Holla if (!prev_level) { /* leaf/processor node */ 1078a36a7fecSSudeep Holla memcpy(flpi, t, sizeof(*t)); 1079a36a7fecSSudeep Holla stash_composite_state(curr_level, flpi); 1080a36a7fecSSudeep Holla flat_state_cnt++; 1081a36a7fecSSudeep Holla continue; 1082a36a7fecSSudeep Holla } 1083a36a7fecSSudeep Holla 1084a36a7fecSSudeep Holla for (i = 0; i < prev_level->composite_states_size; i++) { 1085a36a7fecSSudeep Holla p = prev_level->composite_states[i]; 1086a36a7fecSSudeep Holla if (t->index <= p->enable_parent_state && 1087a36a7fecSSudeep Holla combine_lpi_states(p, t, flpi)) { 1088a36a7fecSSudeep Holla stash_composite_state(curr_level, flpi); 1089a36a7fecSSudeep Holla flat_state_cnt++; 1090a36a7fecSSudeep Holla flpi++; 1091a36a7fecSSudeep Holla } 1092a36a7fecSSudeep Holla } 1093a36a7fecSSudeep Holla } 1094a36a7fecSSudeep Holla 1095a36a7fecSSudeep Holla kfree(curr_level->entries); 1096a36a7fecSSudeep Holla return 0; 1097a36a7fecSSudeep Holla } 1098a36a7fecSSudeep Holla 1099eb087f30SMario Limonciello int __weak acpi_processor_ffh_lpi_probe(unsigned int cpu) 1100eb087f30SMario Limonciello { 1101eb087f30SMario Limonciello return -EOPNOTSUPP; 1102eb087f30SMario Limonciello } 1103eb087f30SMario Limonciello 1104a36a7fecSSudeep Holla static int acpi_processor_get_lpi_info(struct acpi_processor *pr) 1105a36a7fecSSudeep Holla { 1106a36a7fecSSudeep Holla int ret, i; 1107a36a7fecSSudeep Holla acpi_status status; 1108a36a7fecSSudeep Holla acpi_handle handle = pr->handle, pr_ahandle; 1109a36a7fecSSudeep Holla struct acpi_device *d = NULL; 1110a36a7fecSSudeep Holla struct acpi_lpi_states_array info[2], *tmp, *prev, *curr; 1111a36a7fecSSudeep Holla 1112eb087f30SMario Limonciello /* make sure our architecture has support */ 1113eb087f30SMario Limonciello ret = acpi_processor_ffh_lpi_probe(pr->id); 1114eb087f30SMario Limonciello if (ret == -EOPNOTSUPP) 1115eb087f30SMario Limonciello return ret; 1116eb087f30SMario Limonciello 1117a36a7fecSSudeep Holla if (!osc_pc_lpi_support_confirmed) 1118a36a7fecSSudeep Holla return -EOPNOTSUPP; 1119a36a7fecSSudeep Holla 1120a36a7fecSSudeep Holla if (!acpi_has_method(handle, "_LPI")) 1121a36a7fecSSudeep Holla return -EINVAL; 1122a36a7fecSSudeep Holla 1123a36a7fecSSudeep Holla flat_state_cnt = 0; 1124a36a7fecSSudeep Holla prev = &info[0]; 1125a36a7fecSSudeep Holla curr = &info[1]; 1126a36a7fecSSudeep Holla handle = pr->handle; 1127a36a7fecSSudeep Holla ret = acpi_processor_evaluate_lpi(handle, prev); 1128a36a7fecSSudeep Holla if (ret) 1129a36a7fecSSudeep Holla return ret; 1130a36a7fecSSudeep Holla flatten_lpi_states(pr, prev, NULL); 1131a36a7fecSSudeep Holla 1132a36a7fecSSudeep Holla status = acpi_get_parent(handle, &pr_ahandle); 1133a36a7fecSSudeep Holla while (ACPI_SUCCESS(status)) { 113499ece713SRafael J. Wysocki d = acpi_fetch_acpi_dev(pr_ahandle); 11352437513aSLi Zhong if (!d) 11362437513aSLi Zhong break; 11372437513aSLi Zhong 1138a36a7fecSSudeep Holla handle = pr_ahandle; 1139a36a7fecSSudeep Holla 1140a36a7fecSSudeep Holla if (strcmp(acpi_device_hid(d), ACPI_PROCESSOR_CONTAINER_HID)) 1141a36a7fecSSudeep Holla break; 1142a36a7fecSSudeep Holla 1143a36a7fecSSudeep Holla /* can be optional ? */ 1144a36a7fecSSudeep Holla if (!acpi_has_method(handle, "_LPI")) 1145a36a7fecSSudeep Holla break; 1146a36a7fecSSudeep Holla 1147a36a7fecSSudeep Holla ret = acpi_processor_evaluate_lpi(handle, curr); 1148a36a7fecSSudeep Holla if (ret) 1149a36a7fecSSudeep Holla break; 1150a36a7fecSSudeep Holla 1151a36a7fecSSudeep Holla /* flatten all the LPI states in this level of hierarchy */ 1152a36a7fecSSudeep Holla flatten_lpi_states(pr, curr, prev); 1153a36a7fecSSudeep Holla 1154a36a7fecSSudeep Holla tmp = prev, prev = curr, curr = tmp; 1155a36a7fecSSudeep Holla 1156a36a7fecSSudeep Holla status = acpi_get_parent(handle, &pr_ahandle); 1157a36a7fecSSudeep Holla } 1158a36a7fecSSudeep Holla 1159a36a7fecSSudeep Holla pr->power.count = flat_state_cnt; 1160a36a7fecSSudeep Holla /* reset the index after flattening */ 1161a36a7fecSSudeep Holla for (i = 0; i < pr->power.count; i++) 1162a36a7fecSSudeep Holla pr->power.lpi_states[i].index = i; 1163a36a7fecSSudeep Holla 1164a36a7fecSSudeep Holla /* Tell driver that _LPI is supported. */ 1165a36a7fecSSudeep Holla pr->flags.has_lpi = 1; 1166a36a7fecSSudeep Holla pr->flags.power = 1; 1167a36a7fecSSudeep Holla 1168a36a7fecSSudeep Holla return 0; 1169a36a7fecSSudeep Holla } 1170a36a7fecSSudeep Holla 1171a36a7fecSSudeep Holla int __weak acpi_processor_ffh_lpi_enter(struct acpi_lpi_state *lpi) 1172a36a7fecSSudeep Holla { 1173a36a7fecSSudeep Holla return -ENODEV; 1174a36a7fecSSudeep Holla } 1175a36a7fecSSudeep Holla 1176a36a7fecSSudeep Holla /** 1177a36a7fecSSudeep Holla * acpi_idle_lpi_enter - enters an ACPI any LPI state 1178a36a7fecSSudeep Holla * @dev: the target CPU 1179a36a7fecSSudeep Holla * @drv: cpuidle driver containing cpuidle state info 1180a36a7fecSSudeep Holla * @index: index of target state 1181a36a7fecSSudeep Holla * 1182a36a7fecSSudeep Holla * Return: 0 for success or negative value for error 1183a36a7fecSSudeep Holla */ 1184a36a7fecSSudeep Holla static int acpi_idle_lpi_enter(struct cpuidle_device *dev, 1185a36a7fecSSudeep Holla struct cpuidle_driver *drv, int index) 1186a36a7fecSSudeep Holla { 1187a36a7fecSSudeep Holla struct acpi_processor *pr; 1188a36a7fecSSudeep Holla struct acpi_lpi_state *lpi; 1189a36a7fecSSudeep Holla 1190a36a7fecSSudeep Holla pr = __this_cpu_read(processors); 1191a36a7fecSSudeep Holla 1192a36a7fecSSudeep Holla if (unlikely(!pr)) 1193a36a7fecSSudeep Holla return -EINVAL; 1194a36a7fecSSudeep Holla 1195a36a7fecSSudeep Holla lpi = &pr->power.lpi_states[index]; 1196a36a7fecSSudeep Holla if (lpi->entry_method == ACPI_CSTATE_FFH) 1197a36a7fecSSudeep Holla return acpi_processor_ffh_lpi_enter(lpi); 1198a36a7fecSSudeep Holla 1199a36a7fecSSudeep Holla return -EINVAL; 1200a36a7fecSSudeep Holla } 1201a36a7fecSSudeep Holla 1202a36a7fecSSudeep Holla static int acpi_processor_setup_lpi_states(struct acpi_processor *pr) 1203a36a7fecSSudeep Holla { 1204a36a7fecSSudeep Holla int i; 1205a36a7fecSSudeep Holla struct acpi_lpi_state *lpi; 1206a36a7fecSSudeep Holla struct cpuidle_state *state; 1207a36a7fecSSudeep Holla struct cpuidle_driver *drv = &acpi_idle_driver; 1208a36a7fecSSudeep Holla 1209a36a7fecSSudeep Holla if (!pr->flags.has_lpi) 1210a36a7fecSSudeep Holla return -EOPNOTSUPP; 1211a36a7fecSSudeep Holla 1212a36a7fecSSudeep Holla for (i = 0; i < pr->power.count && i < CPUIDLE_STATE_MAX; i++) { 1213a36a7fecSSudeep Holla lpi = &pr->power.lpi_states[i]; 1214a36a7fecSSudeep Holla 1215a36a7fecSSudeep Holla state = &drv->states[i]; 1216a36a7fecSSudeep Holla snprintf(state->name, CPUIDLE_NAME_LEN, "LPI-%d", i); 1217b75d2cd0SWolfram Sang strscpy(state->desc, lpi->desc, CPUIDLE_DESC_LEN); 1218a36a7fecSSudeep Holla state->exit_latency = lpi->wake_latency; 1219a36a7fecSSudeep Holla state->target_residency = lpi->min_residency; 1220a36a7fecSSudeep Holla if (lpi->arch_flags) 1221a36a7fecSSudeep Holla state->flags |= CPUIDLE_FLAG_TIMER_STOP; 1222a36a7fecSSudeep Holla state->enter = acpi_idle_lpi_enter; 1223a36a7fecSSudeep Holla drv->safe_state_index = i; 1224a36a7fecSSudeep Holla } 1225a36a7fecSSudeep Holla 1226a36a7fecSSudeep Holla drv->state_count = i; 1227a36a7fecSSudeep Holla 1228a36a7fecSSudeep Holla return 0; 1229a36a7fecSSudeep Holla } 1230a36a7fecSSudeep Holla 1231a36a7fecSSudeep Holla /** 1232a36a7fecSSudeep Holla * acpi_processor_setup_cpuidle_states- prepares and configures cpuidle 1233a36a7fecSSudeep Holla * global state data i.e. idle routines 1234a36a7fecSSudeep Holla * 1235a36a7fecSSudeep Holla * @pr: the ACPI processor 1236a36a7fecSSudeep Holla */ 1237a36a7fecSSudeep Holla static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr) 1238a36a7fecSSudeep Holla { 1239a36a7fecSSudeep Holla int i; 1240a36a7fecSSudeep Holla struct cpuidle_driver *drv = &acpi_idle_driver; 1241a36a7fecSSudeep Holla 1242a36a7fecSSudeep Holla if (!pr->flags.power_setup_done || !pr->flags.power) 1243a36a7fecSSudeep Holla return -EINVAL; 1244a36a7fecSSudeep Holla 1245a36a7fecSSudeep Holla drv->safe_state_index = -1; 1246dc2251bfSRafael J. Wysocki for (i = ACPI_IDLE_STATE_START; i < CPUIDLE_STATE_MAX; i++) { 1247a36a7fecSSudeep Holla drv->states[i].name[0] = '\0'; 1248a36a7fecSSudeep Holla drv->states[i].desc[0] = '\0'; 1249a36a7fecSSudeep Holla } 1250a36a7fecSSudeep Holla 1251a36a7fecSSudeep Holla if (pr->flags.has_lpi) 1252a36a7fecSSudeep Holla return acpi_processor_setup_lpi_states(pr); 1253a36a7fecSSudeep Holla 1254a36a7fecSSudeep Holla return acpi_processor_setup_cstates(pr); 1255a36a7fecSSudeep Holla } 1256a36a7fecSSudeep Holla 1257a36a7fecSSudeep Holla /** 1258a36a7fecSSudeep Holla * acpi_processor_setup_cpuidle_dev - prepares and configures CPUIDLE 1259a36a7fecSSudeep Holla * device i.e. per-cpu data 1260a36a7fecSSudeep Holla * 1261a36a7fecSSudeep Holla * @pr: the ACPI processor 1262a36a7fecSSudeep Holla * @dev : the cpuidle device 1263a36a7fecSSudeep Holla */ 1264a36a7fecSSudeep Holla static int acpi_processor_setup_cpuidle_dev(struct acpi_processor *pr, 1265a36a7fecSSudeep Holla struct cpuidle_device *dev) 1266a36a7fecSSudeep Holla { 1267a36a7fecSSudeep Holla if (!pr->flags.power_setup_done || !pr->flags.power || !dev) 1268a36a7fecSSudeep Holla return -EINVAL; 1269a36a7fecSSudeep Holla 1270a36a7fecSSudeep Holla dev->cpu = pr->id; 1271a36a7fecSSudeep Holla if (pr->flags.has_lpi) 1272a36a7fecSSudeep Holla return acpi_processor_ffh_lpi_probe(pr->id); 1273a36a7fecSSudeep Holla 1274a36a7fecSSudeep Holla return acpi_processor_setup_cpuidle_cx(pr, dev); 1275a36a7fecSSudeep Holla } 1276a36a7fecSSudeep Holla 1277a36a7fecSSudeep Holla static int acpi_processor_get_power_info(struct acpi_processor *pr) 1278a36a7fecSSudeep Holla { 1279a36a7fecSSudeep Holla int ret; 1280a36a7fecSSudeep Holla 1281a36a7fecSSudeep Holla ret = acpi_processor_get_lpi_info(pr); 1282a36a7fecSSudeep Holla if (ret) 1283a36a7fecSSudeep Holla ret = acpi_processor_get_cstate_info(pr); 1284a36a7fecSSudeep Holla 1285a36a7fecSSudeep Holla return ret; 1286a36a7fecSSudeep Holla } 1287a36a7fecSSudeep Holla 128846bcfad7SDeepthi Dharwar int acpi_processor_hotplug(struct acpi_processor *pr) 12894f86d3a8SLen Brown { 1290dcb84f33SVenkatesh Pallipadi int ret = 0; 1291e8b1b59dSWei Yongjun struct cpuidle_device *dev; 12924f86d3a8SLen Brown 1293d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 129436a91358SVenkatesh Pallipadi return 0; 129536a91358SVenkatesh Pallipadi 12964f86d3a8SLen Brown if (!pr->flags.power_setup_done) 12974f86d3a8SLen Brown return -ENODEV; 12984f86d3a8SLen Brown 1299e8b1b59dSWei Yongjun dev = per_cpu(acpi_cpuidle_device, pr->id); 13004f86d3a8SLen Brown cpuidle_pause_and_lock(); 13013d339dcbSDaniel Lezcano cpuidle_disable_device(dev); 1302a36a7fecSSudeep Holla ret = acpi_processor_get_power_info(pr); 1303a36a7fecSSudeep Holla if (!ret && pr->flags.power) { 1304a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(pr, dev); 13053d339dcbSDaniel Lezcano ret = cpuidle_enable_device(dev); 1306dcb84f33SVenkatesh Pallipadi } 13074f86d3a8SLen Brown cpuidle_resume_and_unlock(); 13084f86d3a8SLen Brown 13094f86d3a8SLen Brown return ret; 13104f86d3a8SLen Brown } 13114f86d3a8SLen Brown 1312a36a7fecSSudeep Holla int acpi_processor_power_state_has_changed(struct acpi_processor *pr) 131346bcfad7SDeepthi Dharwar { 131446bcfad7SDeepthi Dharwar int cpu; 131546bcfad7SDeepthi Dharwar struct acpi_processor *_pr; 13163d339dcbSDaniel Lezcano struct cpuidle_device *dev; 131746bcfad7SDeepthi Dharwar 131846bcfad7SDeepthi Dharwar if (disabled_by_idle_boot_param()) 131946bcfad7SDeepthi Dharwar return 0; 132046bcfad7SDeepthi Dharwar 132146bcfad7SDeepthi Dharwar if (!pr->flags.power_setup_done) 132246bcfad7SDeepthi Dharwar return -ENODEV; 132346bcfad7SDeepthi Dharwar 132446bcfad7SDeepthi Dharwar /* 132546bcfad7SDeepthi Dharwar * FIXME: Design the ACPI notification to make it once per 132646bcfad7SDeepthi Dharwar * system instead of once per-cpu. This condition is a hack 132746bcfad7SDeepthi Dharwar * to make the code that updates C-States be called once. 132846bcfad7SDeepthi Dharwar */ 132946bcfad7SDeepthi Dharwar 13309505626dSPaul E. McKenney if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) { 133146bcfad7SDeepthi Dharwar 133246bcfad7SDeepthi Dharwar /* Protect against cpu-hotplug */ 133395ac7067SSebastian Andrzej Siewior cpus_read_lock(); 13346726655dSJiri Kosina cpuidle_pause_and_lock(); 133546bcfad7SDeepthi Dharwar 133646bcfad7SDeepthi Dharwar /* Disable all cpuidle devices */ 133746bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) { 133846bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu); 133946bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done) 134046bcfad7SDeepthi Dharwar continue; 13413d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu); 13423d339dcbSDaniel Lezcano cpuidle_disable_device(dev); 134346bcfad7SDeepthi Dharwar } 134446bcfad7SDeepthi Dharwar 134546bcfad7SDeepthi Dharwar /* Populate Updated C-state information */ 1346f427e5f1SThomas Schlichter acpi_processor_get_power_info(pr); 134746bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr); 134846bcfad7SDeepthi Dharwar 134946bcfad7SDeepthi Dharwar /* Enable all cpuidle devices */ 135046bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) { 135146bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu); 135246bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done) 135346bcfad7SDeepthi Dharwar continue; 135446bcfad7SDeepthi Dharwar acpi_processor_get_power_info(_pr); 135546bcfad7SDeepthi Dharwar if (_pr->flags.power) { 13563d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu); 1357a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(_pr, dev); 13583d339dcbSDaniel Lezcano cpuidle_enable_device(dev); 135946bcfad7SDeepthi Dharwar } 136046bcfad7SDeepthi Dharwar } 136146bcfad7SDeepthi Dharwar cpuidle_resume_and_unlock(); 136295ac7067SSebastian Andrzej Siewior cpus_read_unlock(); 136346bcfad7SDeepthi Dharwar } 136446bcfad7SDeepthi Dharwar 136546bcfad7SDeepthi Dharwar return 0; 136646bcfad7SDeepthi Dharwar } 136746bcfad7SDeepthi Dharwar 136846bcfad7SDeepthi Dharwar static int acpi_processor_registered; 136946bcfad7SDeepthi Dharwar 1370fe7bf106SPaul Gortmaker int acpi_processor_power_init(struct acpi_processor *pr) 13711da177e4SLinus Torvalds { 137246bcfad7SDeepthi Dharwar int retval; 13733d339dcbSDaniel Lezcano struct cpuidle_device *dev; 13741da177e4SLinus Torvalds 1375d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 137636a91358SVenkatesh Pallipadi return 0; 13771da177e4SLinus Torvalds 137835ae7133SSudeep Holla acpi_processor_cstate_first_run_checks(); 13791da177e4SLinus Torvalds 138035ae7133SSudeep Holla if (!acpi_processor_get_power_info(pr)) 13814f86d3a8SLen Brown pr->flags.power_setup_done = 1; 13821da177e4SLinus Torvalds 13831da177e4SLinus Torvalds /* 13841da177e4SLinus Torvalds * Install the idle handler if processor power management is supported. 13851da177e4SLinus Torvalds * Note that we use previously set idle handler will be used on 13861da177e4SLinus Torvalds * platforms that only support C1. 13871da177e4SLinus Torvalds */ 138836a91358SVenkatesh Pallipadi if (pr->flags.power) { 138946bcfad7SDeepthi Dharwar /* Register acpi_idle_driver if not already registered */ 139046bcfad7SDeepthi Dharwar if (!acpi_processor_registered) { 139146bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr); 139246bcfad7SDeepthi Dharwar retval = cpuidle_register_driver(&acpi_idle_driver); 139346bcfad7SDeepthi Dharwar if (retval) 139446bcfad7SDeepthi Dharwar return retval; 1395b6ec26fbSSudeep Holla pr_debug("%s registered with cpuidle\n", 139646bcfad7SDeepthi Dharwar acpi_idle_driver.name); 139746bcfad7SDeepthi Dharwar } 13983d339dcbSDaniel Lezcano 13993d339dcbSDaniel Lezcano dev = kzalloc(sizeof(*dev), GFP_KERNEL); 14003d339dcbSDaniel Lezcano if (!dev) 14013d339dcbSDaniel Lezcano return -ENOMEM; 14023d339dcbSDaniel Lezcano per_cpu(acpi_cpuidle_device, pr->id) = dev; 14033d339dcbSDaniel Lezcano 1404a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(pr, dev); 14053d339dcbSDaniel Lezcano 140646bcfad7SDeepthi Dharwar /* Register per-cpu cpuidle_device. Cpuidle driver 140746bcfad7SDeepthi Dharwar * must already be registered before registering device 140846bcfad7SDeepthi Dharwar */ 14093d339dcbSDaniel Lezcano retval = cpuidle_register_device(dev); 141046bcfad7SDeepthi Dharwar if (retval) { 141146bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0) 141246bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver); 141346bcfad7SDeepthi Dharwar return retval; 141446bcfad7SDeepthi Dharwar } 141546bcfad7SDeepthi Dharwar acpi_processor_registered++; 14161da177e4SLinus Torvalds } 1417d550d98dSPatrick Mochel return 0; 14181da177e4SLinus Torvalds } 14191da177e4SLinus Torvalds 142038a991b6SDaniel Lezcano int acpi_processor_power_exit(struct acpi_processor *pr) 14211da177e4SLinus Torvalds { 14223d339dcbSDaniel Lezcano struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id); 14233d339dcbSDaniel Lezcano 1424d1896049SThomas Renninger if (disabled_by_idle_boot_param()) 142536a91358SVenkatesh Pallipadi return 0; 142636a91358SVenkatesh Pallipadi 142746bcfad7SDeepthi Dharwar if (pr->flags.power) { 14283d339dcbSDaniel Lezcano cpuidle_unregister_device(dev); 142946bcfad7SDeepthi Dharwar acpi_processor_registered--; 143046bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0) 143146bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver); 143246bcfad7SDeepthi Dharwar } 14331da177e4SLinus Torvalds 143446bcfad7SDeepthi Dharwar pr->flags.power_setup_done = 0; 1435d550d98dSPatrick Mochel return 0; 14361da177e4SLinus Torvalds } 1437