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
disabled_by_idle_boot_param(void)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 */
set_max_cstate(const struct dmi_system_id * id)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 */
acpi_safe_halt(void)1096727ad9eSChris Metcalf static void __cpuidle acpi_safe_halt(void)
110ddc081a1SVenkatesh Pallipadi {
111ea811747SPeter Zijlstra if (!tif_need_resched()) {
1128ce78470SPeter Zijlstra raw_safe_halt();
1138ce78470SPeter 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 */
lapic_timer_check_state(int state,struct acpi_processor * pr,struct acpi_processor_cx * cx)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
__lapic_timer_propagate_broadcast(void * arg)148918aae42SHidetoshi Seto static void __lapic_timer_propagate_broadcast(void *arg)
149169a0abbSThomas Gleixner {
150fbf757e5SZhou jie struct acpi_processor *pr = 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
lapic_timer_propagate_broadcast(struct acpi_processor * pr)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 */
lapic_timer_needs_broadcast(struct acpi_processor * pr,struct acpi_processor_cx * cx)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
lapic_timer_check_state(int state,struct acpi_processor * pr,struct acpi_processor_cx * cstate)1737e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr,
174169a0abbSThomas Gleixner struct acpi_processor_cx *cstate) { }
lapic_timer_propagate_broadcast(struct acpi_processor * pr)1757e275cc4SLen Brown static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { }
176aa6b43d5SPeter Zijlstra
lapic_timer_needs_broadcast(struct acpi_processor * pr,struct acpi_processor_cx * cx)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)
tsc_check_state(int state)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
tsc_check_state(int state)208520daf72SLen Brown static void tsc_check_state(int state) { return; }
209ddb25f9aSAndi Kleen #endif
210ddb25f9aSAndi Kleen
acpi_processor_get_power_info_fadt(struct acpi_processor * pr)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
acpi_processor_get_power_info_default(struct acpi_processor * pr)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
acpi_processor_get_power_info_cst(struct acpi_processor * pr)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
acpi_processor_power_verify_c3(struct acpi_processor * pr,struct acpi_processor_cx * cx)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
acpi_cst_latency_cmp(const void * a,const void * b)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 }
acpi_cst_latency_swap(void * a,void * b,int n)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
acpi_processor_power_verify(struct acpi_processor * pr)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
acpi_processor_get_cstate_info(struct acpi_processor * pr)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 */
acpi_idle_bm_check(void)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
io_idle(unsigned long addr)5268ce78470SPeter Zijlstra static __cpuidle void io_idle(unsigned long addr)
527fa583f71SYin Fengwei {
5288ce78470SPeter Zijlstra /* IO port based C-state */
5298ce78470SPeter Zijlstra inb(addr);
5308ce78470SPeter 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 */
acpi_idle_do_entry(struct acpi_processor_cx * cx)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 {
5758ce78470SPeter 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 */
acpi_idle_play_dead(struct cpuidle_device * dev,int index)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)
59573111754SDavid Woodhouse raw_safe_halt();
5961a022e3fSBoris Ostrovsky else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) {
5978ce78470SPeter Zijlstra io_idle(cx->address);
5981a022e3fSBoris Ostrovsky } else
5991a022e3fSBoris Ostrovsky return -ENODEV;
6001a022e3fSBoris Ostrovsky }
6011a022e3fSBoris Ostrovsky
6021a022e3fSBoris Ostrovsky /* Never reached */
6031a022e3fSBoris Ostrovsky return 0;
6041a022e3fSBoris Ostrovsky }
6051a022e3fSBoris Ostrovsky
acpi_idle_fallback_to_c1(struct acpi_processor * pr)6066a123d6aSPeter Zijlstra static __always_inline bool acpi_idle_fallback_to_c1(struct acpi_processor *pr)
607adcb2623SRafael J. Wysocki {
6085f508185SRafael J. Wysocki return IS_ENABLED(CONFIG_HOTPLUG_CPU) && !pr->flags.has_cst &&
6095f508185SRafael J. Wysocki !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED);
610adcb2623SRafael J. Wysocki }
611adcb2623SRafael J. Wysocki
6124f86d3a8SLen Brown static int c3_cpu_count;
613e12f65f7SThomas Gleixner static DEFINE_RAW_SPINLOCK(c3_lock);
6144f86d3a8SLen Brown
6154f86d3a8SLen Brown /**
6164f86d3a8SLen Brown * acpi_idle_enter_bm - enters C3 with proper BM handling
6171fecfdbbSPeter Zijlstra * @drv: cpuidle driver
6186491bc0cSRafael J. Wysocki * @pr: Target processor
6196491bc0cSRafael J. Wysocki * @cx: Target state context
6201fecfdbbSPeter Zijlstra * @index: index of target state
6214f86d3a8SLen Brown */
acpi_idle_enter_bm(struct cpuidle_driver * drv,struct acpi_processor * pr,struct acpi_processor_cx * cx,int index)622409dfdcaSGuilherme G. Piccoli static int __cpuidle acpi_idle_enter_bm(struct cpuidle_driver *drv,
6231fecfdbbSPeter Zijlstra struct acpi_processor *pr,
6241fecfdbbSPeter Zijlstra struct acpi_processor_cx *cx,
6251fecfdbbSPeter Zijlstra int index)
6264f86d3a8SLen Brown {
6271fecfdbbSPeter Zijlstra static struct acpi_processor_cx safe_cx = {
6281fecfdbbSPeter Zijlstra .entry_method = ACPI_CSTATE_HALT,
6291fecfdbbSPeter Zijlstra };
6301fecfdbbSPeter Zijlstra
6314f86d3a8SLen Brown /*
632c9c860e5SVenkatesh Pallipadi * disable bus master
633c9c860e5SVenkatesh Pallipadi * bm_check implies we need ARB_DIS
634c9c860e5SVenkatesh Pallipadi * bm_control implies whether we can do ARB_DIS
635c9c860e5SVenkatesh Pallipadi *
6361fecfdbbSPeter Zijlstra * That leaves a case where bm_check is set and bm_control is not set.
6371fecfdbbSPeter Zijlstra * In that case we cannot do much, we enter C3 without doing anything.
638c9c860e5SVenkatesh Pallipadi */
6391fecfdbbSPeter Zijlstra bool dis_bm = pr->flags.bm_control;
6401fecfdbbSPeter Zijlstra
641a01353cfSPeter Zijlstra instrumentation_begin();
642a01353cfSPeter Zijlstra
6431fecfdbbSPeter Zijlstra /* If we can skip BM, demote to a safe state. */
6441fecfdbbSPeter Zijlstra if (!cx->bm_sts_skip && acpi_idle_bm_check()) {
6451fecfdbbSPeter Zijlstra dis_bm = false;
6461fecfdbbSPeter Zijlstra index = drv->safe_state_index;
6471fecfdbbSPeter Zijlstra if (index >= 0) {
6481fecfdbbSPeter Zijlstra cx = this_cpu_read(acpi_cstate[index]);
6491fecfdbbSPeter Zijlstra } else {
6501fecfdbbSPeter Zijlstra cx = &safe_cx;
6511fecfdbbSPeter Zijlstra index = -EBUSY;
6521fecfdbbSPeter Zijlstra }
6531fecfdbbSPeter Zijlstra }
6541fecfdbbSPeter Zijlstra
6551fecfdbbSPeter Zijlstra if (dis_bm) {
656e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock);
6574f86d3a8SLen Brown c3_cpu_count++;
6584f86d3a8SLen Brown /* Disable bus master arbitration when all CPUs are in C3 */
6594f86d3a8SLen Brown if (c3_cpu_count == num_online_cpus())
66050ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1);
661e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock);
662c9c860e5SVenkatesh Pallipadi }
6634f86d3a8SLen Brown
664a01353cfSPeter Zijlstra ct_cpuidle_enter();
6651fecfdbbSPeter Zijlstra
6664f86d3a8SLen Brown acpi_idle_do_entry(cx);
6674f86d3a8SLen Brown
668a01353cfSPeter Zijlstra ct_cpuidle_exit();
6691fecfdbbSPeter Zijlstra
6704f86d3a8SLen Brown /* Re-enable bus master arbitration */
6711fecfdbbSPeter Zijlstra if (dis_bm) {
672e12f65f7SThomas Gleixner raw_spin_lock(&c3_lock);
67350ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0);
6744f86d3a8SLen Brown c3_cpu_count--;
675e12f65f7SThomas Gleixner raw_spin_unlock(&c3_lock);
6764f86d3a8SLen Brown }
6771fecfdbbSPeter Zijlstra
678a01353cfSPeter Zijlstra instrumentation_end();
679a01353cfSPeter Zijlstra
6801fecfdbbSPeter Zijlstra return index;
6816491bc0cSRafael J. Wysocki }
6826491bc0cSRafael J. Wysocki
acpi_idle_enter(struct cpuidle_device * dev,struct cpuidle_driver * drv,int index)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
acpi_idle_enter_s2idle(struct cpuidle_device * dev,struct cpuidle_driver * drv,int index)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
acpi_processor_setup_cpuidle_cx(struct acpi_processor * pr,struct cpuidle_device * dev)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
acpi_processor_setup_cstates(struct acpi_processor * pr)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
acpi_processor_cstate_first_run_checks(void)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
disabled_by_idle_boot_param(void)86035ae7133SSudeep Holla static inline int disabled_by_idle_boot_param(void) { return 0; }
acpi_processor_cstate_first_run_checks(void)86135ae7133SSudeep Holla static inline void acpi_processor_cstate_first_run_checks(void) { }
acpi_processor_get_cstate_info(struct acpi_processor * pr)862a36a7fecSSudeep Holla static int acpi_processor_get_cstate_info(struct acpi_processor *pr)
86335ae7133SSudeep Holla {
86435ae7133SSudeep Holla return -ENODEV;
86535ae7133SSudeep Holla }
86635ae7133SSudeep Holla
acpi_processor_setup_cpuidle_cx(struct acpi_processor * pr,struct cpuidle_device * dev)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
acpi_processor_setup_cstates(struct acpi_processor * pr)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
obj_get_integer(union acpi_object * obj,u32 * value)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
acpi_processor_evaluate_lpi(acpi_handle handle,struct acpi_lpi_states_array * info)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 */
combine_lpi_states(struct acpi_lpi_state * local,struct acpi_lpi_state * parent,struct acpi_lpi_state * result)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
stash_composite_state(struct acpi_lpi_states_array * curr_level,struct acpi_lpi_state * t)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
flatten_lpi_states(struct acpi_processor * pr,struct acpi_lpi_states_array * curr_level,struct acpi_lpi_states_array * prev_level)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
acpi_processor_ffh_lpi_probe(unsigned int cpu)1099eb087f30SMario Limonciello int __weak acpi_processor_ffh_lpi_probe(unsigned int cpu)
1100eb087f30SMario Limonciello {
1101eb087f30SMario Limonciello return -EOPNOTSUPP;
1102eb087f30SMario Limonciello }
1103eb087f30SMario Limonciello
acpi_processor_get_lpi_info(struct acpi_processor * pr)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
acpi_processor_ffh_lpi_enter(struct acpi_lpi_state * lpi)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 */
acpi_idle_lpi_enter(struct cpuidle_device * dev,struct cpuidle_driver * drv,int index)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
acpi_processor_setup_lpi_states(struct acpi_processor * pr)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;
12204785aa80SOza Pawandeep state->flags |= arch_get_idle_state_flags(lpi->arch_flags);
12210c5ffc3dSPeter Zijlstra if (i != 0 && lpi->entry_method == ACPI_CSTATE_FFH)
12220c5ffc3dSPeter Zijlstra state->flags |= CPUIDLE_FLAG_RCU_IDLE;
1223a36a7fecSSudeep Holla state->enter = acpi_idle_lpi_enter;
1224a36a7fecSSudeep Holla drv->safe_state_index = i;
1225a36a7fecSSudeep Holla }
1226a36a7fecSSudeep Holla
1227a36a7fecSSudeep Holla drv->state_count = i;
1228a36a7fecSSudeep Holla
1229a36a7fecSSudeep Holla return 0;
1230a36a7fecSSudeep Holla }
1231a36a7fecSSudeep Holla
1232a36a7fecSSudeep Holla /**
1233a36a7fecSSudeep Holla * acpi_processor_setup_cpuidle_states- prepares and configures cpuidle
1234a36a7fecSSudeep Holla * global state data i.e. idle routines
1235a36a7fecSSudeep Holla *
1236a36a7fecSSudeep Holla * @pr: the ACPI processor
1237a36a7fecSSudeep Holla */
acpi_processor_setup_cpuidle_states(struct acpi_processor * pr)1238a36a7fecSSudeep Holla static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
1239a36a7fecSSudeep Holla {
1240a36a7fecSSudeep Holla int i;
1241a36a7fecSSudeep Holla struct cpuidle_driver *drv = &acpi_idle_driver;
1242a36a7fecSSudeep Holla
1243a36a7fecSSudeep Holla if (!pr->flags.power_setup_done || !pr->flags.power)
1244a36a7fecSSudeep Holla return -EINVAL;
1245a36a7fecSSudeep Holla
1246a36a7fecSSudeep Holla drv->safe_state_index = -1;
1247dc2251bfSRafael J. Wysocki for (i = ACPI_IDLE_STATE_START; i < CPUIDLE_STATE_MAX; i++) {
1248a36a7fecSSudeep Holla drv->states[i].name[0] = '\0';
1249a36a7fecSSudeep Holla drv->states[i].desc[0] = '\0';
1250a36a7fecSSudeep Holla }
1251a36a7fecSSudeep Holla
1252a36a7fecSSudeep Holla if (pr->flags.has_lpi)
1253a36a7fecSSudeep Holla return acpi_processor_setup_lpi_states(pr);
1254a36a7fecSSudeep Holla
1255a36a7fecSSudeep Holla return acpi_processor_setup_cstates(pr);
1256a36a7fecSSudeep Holla }
1257a36a7fecSSudeep Holla
1258a36a7fecSSudeep Holla /**
1259a36a7fecSSudeep Holla * acpi_processor_setup_cpuidle_dev - prepares and configures CPUIDLE
1260a36a7fecSSudeep Holla * device i.e. per-cpu data
1261a36a7fecSSudeep Holla *
1262a36a7fecSSudeep Holla * @pr: the ACPI processor
1263a36a7fecSSudeep Holla * @dev : the cpuidle device
1264a36a7fecSSudeep Holla */
acpi_processor_setup_cpuidle_dev(struct acpi_processor * pr,struct cpuidle_device * dev)1265a36a7fecSSudeep Holla static int acpi_processor_setup_cpuidle_dev(struct acpi_processor *pr,
1266a36a7fecSSudeep Holla struct cpuidle_device *dev)
1267a36a7fecSSudeep Holla {
1268a36a7fecSSudeep Holla if (!pr->flags.power_setup_done || !pr->flags.power || !dev)
1269a36a7fecSSudeep Holla return -EINVAL;
1270a36a7fecSSudeep Holla
1271a36a7fecSSudeep Holla dev->cpu = pr->id;
1272a36a7fecSSudeep Holla if (pr->flags.has_lpi)
1273a36a7fecSSudeep Holla return acpi_processor_ffh_lpi_probe(pr->id);
1274a36a7fecSSudeep Holla
1275a36a7fecSSudeep Holla return acpi_processor_setup_cpuidle_cx(pr, dev);
1276a36a7fecSSudeep Holla }
1277a36a7fecSSudeep Holla
acpi_processor_get_power_info(struct acpi_processor * pr)1278a36a7fecSSudeep Holla static int acpi_processor_get_power_info(struct acpi_processor *pr)
1279a36a7fecSSudeep Holla {
1280a36a7fecSSudeep Holla int ret;
1281a36a7fecSSudeep Holla
1282a36a7fecSSudeep Holla ret = acpi_processor_get_lpi_info(pr);
1283a36a7fecSSudeep Holla if (ret)
1284a36a7fecSSudeep Holla ret = acpi_processor_get_cstate_info(pr);
1285a36a7fecSSudeep Holla
1286a36a7fecSSudeep Holla return ret;
1287a36a7fecSSudeep Holla }
1288a36a7fecSSudeep Holla
acpi_processor_hotplug(struct acpi_processor * pr)128946bcfad7SDeepthi Dharwar int acpi_processor_hotplug(struct acpi_processor *pr)
12904f86d3a8SLen Brown {
1291dcb84f33SVenkatesh Pallipadi int ret = 0;
1292e8b1b59dSWei Yongjun struct cpuidle_device *dev;
12934f86d3a8SLen Brown
1294d1896049SThomas Renninger if (disabled_by_idle_boot_param())
129536a91358SVenkatesh Pallipadi return 0;
129636a91358SVenkatesh Pallipadi
12974f86d3a8SLen Brown if (!pr->flags.power_setup_done)
12984f86d3a8SLen Brown return -ENODEV;
12994f86d3a8SLen Brown
1300e8b1b59dSWei Yongjun dev = per_cpu(acpi_cpuidle_device, pr->id);
13014f86d3a8SLen Brown cpuidle_pause_and_lock();
13023d339dcbSDaniel Lezcano cpuidle_disable_device(dev);
1303a36a7fecSSudeep Holla ret = acpi_processor_get_power_info(pr);
1304a36a7fecSSudeep Holla if (!ret && pr->flags.power) {
1305a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(pr, dev);
13063d339dcbSDaniel Lezcano ret = cpuidle_enable_device(dev);
1307dcb84f33SVenkatesh Pallipadi }
13084f86d3a8SLen Brown cpuidle_resume_and_unlock();
13094f86d3a8SLen Brown
13104f86d3a8SLen Brown return ret;
13114f86d3a8SLen Brown }
13124f86d3a8SLen Brown
acpi_processor_power_state_has_changed(struct acpi_processor * pr)1313a36a7fecSSudeep Holla int acpi_processor_power_state_has_changed(struct acpi_processor *pr)
131446bcfad7SDeepthi Dharwar {
131546bcfad7SDeepthi Dharwar int cpu;
131646bcfad7SDeepthi Dharwar struct acpi_processor *_pr;
13173d339dcbSDaniel Lezcano struct cpuidle_device *dev;
131846bcfad7SDeepthi Dharwar
131946bcfad7SDeepthi Dharwar if (disabled_by_idle_boot_param())
132046bcfad7SDeepthi Dharwar return 0;
132146bcfad7SDeepthi Dharwar
132246bcfad7SDeepthi Dharwar if (!pr->flags.power_setup_done)
132346bcfad7SDeepthi Dharwar return -ENODEV;
132446bcfad7SDeepthi Dharwar
132546bcfad7SDeepthi Dharwar /*
132646bcfad7SDeepthi Dharwar * FIXME: Design the ACPI notification to make it once per
132746bcfad7SDeepthi Dharwar * system instead of once per-cpu. This condition is a hack
132846bcfad7SDeepthi Dharwar * to make the code that updates C-States be called once.
132946bcfad7SDeepthi Dharwar */
133046bcfad7SDeepthi Dharwar
13319505626dSPaul E. McKenney if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) {
133246bcfad7SDeepthi Dharwar
133346bcfad7SDeepthi Dharwar /* Protect against cpu-hotplug */
133495ac7067SSebastian Andrzej Siewior cpus_read_lock();
13356726655dSJiri Kosina cpuidle_pause_and_lock();
133646bcfad7SDeepthi Dharwar
133746bcfad7SDeepthi Dharwar /* Disable all cpuidle devices */
133846bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) {
133946bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu);
134046bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done)
134146bcfad7SDeepthi Dharwar continue;
13423d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu);
13433d339dcbSDaniel Lezcano cpuidle_disable_device(dev);
134446bcfad7SDeepthi Dharwar }
134546bcfad7SDeepthi Dharwar
134646bcfad7SDeepthi Dharwar /* Populate Updated C-state information */
1347f427e5f1SThomas Schlichter acpi_processor_get_power_info(pr);
134846bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr);
134946bcfad7SDeepthi Dharwar
135046bcfad7SDeepthi Dharwar /* Enable all cpuidle devices */
135146bcfad7SDeepthi Dharwar for_each_online_cpu(cpu) {
135246bcfad7SDeepthi Dharwar _pr = per_cpu(processors, cpu);
135346bcfad7SDeepthi Dharwar if (!_pr || !_pr->flags.power_setup_done)
135446bcfad7SDeepthi Dharwar continue;
135546bcfad7SDeepthi Dharwar acpi_processor_get_power_info(_pr);
135646bcfad7SDeepthi Dharwar if (_pr->flags.power) {
13573d339dcbSDaniel Lezcano dev = per_cpu(acpi_cpuidle_device, cpu);
1358a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(_pr, dev);
13593d339dcbSDaniel Lezcano cpuidle_enable_device(dev);
136046bcfad7SDeepthi Dharwar }
136146bcfad7SDeepthi Dharwar }
136246bcfad7SDeepthi Dharwar cpuidle_resume_and_unlock();
136395ac7067SSebastian Andrzej Siewior cpus_read_unlock();
136446bcfad7SDeepthi Dharwar }
136546bcfad7SDeepthi Dharwar
136646bcfad7SDeepthi Dharwar return 0;
136746bcfad7SDeepthi Dharwar }
136846bcfad7SDeepthi Dharwar
136946bcfad7SDeepthi Dharwar static int acpi_processor_registered;
137046bcfad7SDeepthi Dharwar
acpi_processor_power_init(struct acpi_processor * pr)1371fe7bf106SPaul Gortmaker int acpi_processor_power_init(struct acpi_processor *pr)
13721da177e4SLinus Torvalds {
137346bcfad7SDeepthi Dharwar int retval;
13743d339dcbSDaniel Lezcano struct cpuidle_device *dev;
13751da177e4SLinus Torvalds
1376d1896049SThomas Renninger if (disabled_by_idle_boot_param())
137736a91358SVenkatesh Pallipadi return 0;
13781da177e4SLinus Torvalds
137935ae7133SSudeep Holla acpi_processor_cstate_first_run_checks();
13801da177e4SLinus Torvalds
138135ae7133SSudeep Holla if (!acpi_processor_get_power_info(pr))
13824f86d3a8SLen Brown pr->flags.power_setup_done = 1;
13831da177e4SLinus Torvalds
13841da177e4SLinus Torvalds /*
13851da177e4SLinus Torvalds * Install the idle handler if processor power management is supported.
13861da177e4SLinus Torvalds * Note that we use previously set idle handler will be used on
13871da177e4SLinus Torvalds * platforms that only support C1.
13881da177e4SLinus Torvalds */
138936a91358SVenkatesh Pallipadi if (pr->flags.power) {
139046bcfad7SDeepthi Dharwar /* Register acpi_idle_driver if not already registered */
139146bcfad7SDeepthi Dharwar if (!acpi_processor_registered) {
139246bcfad7SDeepthi Dharwar acpi_processor_setup_cpuidle_states(pr);
139346bcfad7SDeepthi Dharwar retval = cpuidle_register_driver(&acpi_idle_driver);
139446bcfad7SDeepthi Dharwar if (retval)
139546bcfad7SDeepthi Dharwar return retval;
1396b6ec26fbSSudeep Holla pr_debug("%s registered with cpuidle\n",
139746bcfad7SDeepthi Dharwar acpi_idle_driver.name);
139846bcfad7SDeepthi Dharwar }
13993d339dcbSDaniel Lezcano
14003d339dcbSDaniel Lezcano dev = kzalloc(sizeof(*dev), GFP_KERNEL);
14013d339dcbSDaniel Lezcano if (!dev)
14023d339dcbSDaniel Lezcano return -ENOMEM;
14033d339dcbSDaniel Lezcano per_cpu(acpi_cpuidle_device, pr->id) = dev;
14043d339dcbSDaniel Lezcano
1405a36a7fecSSudeep Holla acpi_processor_setup_cpuidle_dev(pr, dev);
14063d339dcbSDaniel Lezcano
140746bcfad7SDeepthi Dharwar /* Register per-cpu cpuidle_device. Cpuidle driver
140846bcfad7SDeepthi Dharwar * must already be registered before registering device
140946bcfad7SDeepthi Dharwar */
14103d339dcbSDaniel Lezcano retval = cpuidle_register_device(dev);
141146bcfad7SDeepthi Dharwar if (retval) {
141246bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0)
141346bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver);
141446bcfad7SDeepthi Dharwar return retval;
141546bcfad7SDeepthi Dharwar }
141646bcfad7SDeepthi Dharwar acpi_processor_registered++;
14171da177e4SLinus Torvalds }
1418d550d98dSPatrick Mochel return 0;
14191da177e4SLinus Torvalds }
14201da177e4SLinus Torvalds
acpi_processor_power_exit(struct acpi_processor * pr)142138a991b6SDaniel Lezcano int acpi_processor_power_exit(struct acpi_processor *pr)
14221da177e4SLinus Torvalds {
14233d339dcbSDaniel Lezcano struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id);
14243d339dcbSDaniel Lezcano
1425d1896049SThomas Renninger if (disabled_by_idle_boot_param())
142636a91358SVenkatesh Pallipadi return 0;
142736a91358SVenkatesh Pallipadi
142846bcfad7SDeepthi Dharwar if (pr->flags.power) {
14293d339dcbSDaniel Lezcano cpuidle_unregister_device(dev);
143046bcfad7SDeepthi Dharwar acpi_processor_registered--;
143146bcfad7SDeepthi Dharwar if (acpi_processor_registered == 0)
143246bcfad7SDeepthi Dharwar cpuidle_unregister_driver(&acpi_idle_driver);
1433*3d48e5beSArmin Wolf
1434*3d48e5beSArmin Wolf kfree(dev);
143546bcfad7SDeepthi Dharwar }
14361da177e4SLinus Torvalds
143746bcfad7SDeepthi Dharwar pr->flags.power_setup_done = 0;
1438d550d98dSPatrick Mochel return 0;
14391da177e4SLinus Torvalds }
1440