11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * processor_idle - idle state submodule to the ACPI processor driver 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 51da177e4SLinus Torvalds * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6c5ab81caSDominik Brodowski * Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de> 71da177e4SLinus Torvalds * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com> 81da177e4SLinus Torvalds * - Added processor hotplug support 902df8b93SVenkatesh Pallipadi * Copyright (C) 2005 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com> 1002df8b93SVenkatesh Pallipadi * - Added support for C3 on SMP 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 131da177e4SLinus Torvalds * 141da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 151da177e4SLinus Torvalds * it under the terms of the GNU General Public License as published by 161da177e4SLinus Torvalds * the Free Software Foundation; either version 2 of the License, or (at 171da177e4SLinus Torvalds * your option) any later version. 181da177e4SLinus Torvalds * 191da177e4SLinus Torvalds * This program is distributed in the hope that it will be useful, but 201da177e4SLinus Torvalds * WITHOUT ANY WARRANTY; without even the implied warranty of 211da177e4SLinus Torvalds * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 221da177e4SLinus Torvalds * General Public License for more details. 231da177e4SLinus Torvalds * 241da177e4SLinus Torvalds * You should have received a copy of the GNU General Public License along 251da177e4SLinus Torvalds * with this program; if not, write to the Free Software Foundation, Inc., 261da177e4SLinus Torvalds * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 271da177e4SLinus Torvalds * 281da177e4SLinus Torvalds * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 291da177e4SLinus Torvalds */ 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds #include <linux/kernel.h> 321da177e4SLinus Torvalds #include <linux/module.h> 331da177e4SLinus Torvalds #include <linux/init.h> 341da177e4SLinus Torvalds #include <linux/cpufreq.h> 351da177e4SLinus Torvalds #include <linux/proc_fs.h> 361da177e4SLinus Torvalds #include <linux/seq_file.h> 371da177e4SLinus Torvalds #include <linux/acpi.h> 381da177e4SLinus Torvalds #include <linux/dmi.h> 391da177e4SLinus Torvalds #include <linux/moduleparam.h> 404e57b681STim Schmielau #include <linux/sched.h> /* need_resched() */ 41f011e2e2SMark Gross #include <linux/pm_qos_params.h> 42e9e2cdb4SThomas Gleixner #include <linux/clockchips.h> 434f86d3a8SLen Brown #include <linux/cpuidle.h> 44ba84be23SRussell King #include <linux/irqflags.h> 451da177e4SLinus Torvalds 463434933bSThomas Gleixner /* 473434933bSThomas Gleixner * Include the apic definitions for x86 to have the APIC timer related defines 483434933bSThomas Gleixner * available also for UP (on SMP it gets magically included via linux/smp.h). 493434933bSThomas Gleixner * asm/acpi.h is not an option, as it would require more include magic. Also 503434933bSThomas Gleixner * creating an empty asm-ia64/apic.h would just trade pest vs. cholera. 513434933bSThomas Gleixner */ 523434933bSThomas Gleixner #ifdef CONFIG_X86 533434933bSThomas Gleixner #include <asm/apic.h> 543434933bSThomas Gleixner #endif 553434933bSThomas Gleixner 561da177e4SLinus Torvalds #include <asm/io.h> 571da177e4SLinus Torvalds #include <asm/uaccess.h> 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds #include <acpi/acpi_bus.h> 601da177e4SLinus Torvalds #include <acpi/processor.h> 61c1e3b377SZhao Yakui #include <asm/processor.h> 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds #define ACPI_PROCESSOR_CLASS "processor" 641da177e4SLinus Torvalds #define _COMPONENT ACPI_PROCESSOR_COMPONENT 65f52fd66dSLen Brown ACPI_MODULE_NAME("processor_idle"); 661da177e4SLinus Torvalds #define ACPI_PROCESSOR_FILE_POWER "power" 672aa44d05SIngo Molnar #define PM_TIMER_TICK_NS (1000000000ULL/PM_TIMER_FREQUENCY) 684f86d3a8SLen Brown #define C2_OVERHEAD 1 /* 1us */ 694f86d3a8SLen Brown #define C3_OVERHEAD 1 /* 1us */ 704f86d3a8SLen Brown #define PM_TIMER_TICKS_TO_US(p) (((p) * 1000)/(PM_TIMER_FREQUENCY/1000)) 711da177e4SLinus Torvalds 724f86d3a8SLen Brown static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER; 734f86d3a8SLen Brown module_param(max_cstate, uint, 0000); 74b6835052SAndreas Mohr static unsigned int nocst __read_mostly; 751da177e4SLinus Torvalds module_param(nocst, uint, 0000); 761da177e4SLinus Torvalds 7725de5718SLen Brown static unsigned int latency_factor __read_mostly = 2; 784963f620SLen Brown module_param(latency_factor, uint, 0644); 791da177e4SLinus Torvalds 80ff69f2bbSalex.shi static s64 us_to_pm_timer_ticks(s64 t) 81ff69f2bbSalex.shi { 82ff69f2bbSalex.shi return div64_u64(t * PM_TIMER_FREQUENCY, 1000000); 83ff69f2bbSalex.shi } 841da177e4SLinus Torvalds /* 851da177e4SLinus Torvalds * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3. 861da177e4SLinus Torvalds * For now disable this. Probably a bug somewhere else. 871da177e4SLinus Torvalds * 881da177e4SLinus Torvalds * To skip this limit, boot/load with a large max_cstate limit. 891da177e4SLinus Torvalds */ 901855256cSJeff Garzik static int set_max_cstate(const struct dmi_system_id *id) 911da177e4SLinus Torvalds { 921da177e4SLinus Torvalds if (max_cstate > ACPI_PROCESSOR_MAX_POWER) 931da177e4SLinus Torvalds return 0; 941da177e4SLinus Torvalds 953d35600aSLen Brown printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate." 961da177e4SLinus Torvalds " Override with \"processor.max_cstate=%d\"\n", id->ident, 973d35600aSLen Brown (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1); 981da177e4SLinus Torvalds 993d35600aSLen Brown max_cstate = (long)id->driver_data; 1001da177e4SLinus Torvalds 1011da177e4SLinus Torvalds return 0; 1021da177e4SLinus Torvalds } 1031da177e4SLinus Torvalds 1047ded5689SAshok Raj /* Actually this shouldn't be __cpuinitdata, would be better to fix the 1057ded5689SAshok Raj callers to only run once -AK */ 1067ded5689SAshok Raj static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = { 107335f16beSDavid Shaohua Li { set_max_cstate, "Clevo 5600D", { 108876c184bSThomas Rosner DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"), 109876c184bSThomas Rosner DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")}, 110335f16beSDavid Shaohua Li (void *)2}, 1111da177e4SLinus Torvalds {}, 1121da177e4SLinus Torvalds }; 1131da177e4SLinus Torvalds 1144f86d3a8SLen Brown 1152e906655Svenkatesh.pallipadi@intel.com /* 1162e906655Svenkatesh.pallipadi@intel.com * Callers should disable interrupts before the call and enable 1172e906655Svenkatesh.pallipadi@intel.com * interrupts after return. 1182e906655Svenkatesh.pallipadi@intel.com */ 119ddc081a1SVenkatesh Pallipadi static void acpi_safe_halt(void) 120ddc081a1SVenkatesh Pallipadi { 121ddc081a1SVenkatesh Pallipadi current_thread_info()->status &= ~TS_POLLING; 122ddc081a1SVenkatesh Pallipadi /* 123ddc081a1SVenkatesh Pallipadi * TS_POLLING-cleared state must be visible before we 124ddc081a1SVenkatesh Pallipadi * test NEED_RESCHED: 125ddc081a1SVenkatesh Pallipadi */ 126ddc081a1SVenkatesh Pallipadi smp_mb(); 12771e93d15SVenki Pallipadi if (!need_resched()) { 128ddc081a1SVenkatesh Pallipadi safe_halt(); 12971e93d15SVenki Pallipadi local_irq_disable(); 13071e93d15SVenki Pallipadi } 131ddc081a1SVenkatesh Pallipadi current_thread_info()->status |= TS_POLLING; 132ddc081a1SVenkatesh Pallipadi } 133ddc081a1SVenkatesh Pallipadi 134169a0abbSThomas Gleixner #ifdef ARCH_APICTIMER_STOPS_ON_C3 135169a0abbSThomas Gleixner 136169a0abbSThomas Gleixner /* 137169a0abbSThomas Gleixner * Some BIOS implementations switch to C3 in the published C2 state. 138296d93cdSLinus Torvalds * This seems to be a common problem on AMD boxen, but other vendors 139296d93cdSLinus Torvalds * are affected too. We pick the most conservative approach: we assume 140296d93cdSLinus Torvalds * that the local APIC stops in both C2 and C3. 141169a0abbSThomas Gleixner */ 1427e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr, 143169a0abbSThomas Gleixner struct acpi_processor_cx *cx) 144169a0abbSThomas Gleixner { 145169a0abbSThomas Gleixner struct acpi_processor_power *pwr = &pr->power; 146e585bef8SThomas Gleixner u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2; 147169a0abbSThomas Gleixner 148db954b58SVenkatesh Pallipadi if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT)) 149db954b58SVenkatesh Pallipadi return; 150db954b58SVenkatesh Pallipadi 15187ad57baSShaohua Li if (boot_cpu_has(X86_FEATURE_AMDC1E)) 15287ad57baSShaohua Li type = ACPI_STATE_C1; 15387ad57baSShaohua Li 154169a0abbSThomas Gleixner /* 155169a0abbSThomas Gleixner * Check, if one of the previous states already marked the lapic 156169a0abbSThomas Gleixner * unstable 157169a0abbSThomas Gleixner */ 158169a0abbSThomas Gleixner if (pwr->timer_broadcast_on_state < state) 159169a0abbSThomas Gleixner return; 160169a0abbSThomas Gleixner 161e585bef8SThomas Gleixner if (cx->type >= type) 162169a0abbSThomas Gleixner pr->power.timer_broadcast_on_state = state; 163169a0abbSThomas Gleixner } 164169a0abbSThomas Gleixner 165*f833bab8SSuresh Siddha static void lapic_timer_propagate_broadcast(void *arg) 166169a0abbSThomas Gleixner { 167*f833bab8SSuresh Siddha struct acpi_processor *pr = (struct acpi_processor *) arg; 168e9e2cdb4SThomas Gleixner unsigned long reason; 169e9e2cdb4SThomas Gleixner 170e9e2cdb4SThomas Gleixner reason = pr->power.timer_broadcast_on_state < INT_MAX ? 171e9e2cdb4SThomas Gleixner CLOCK_EVT_NOTIFY_BROADCAST_ON : CLOCK_EVT_NOTIFY_BROADCAST_OFF; 172e9e2cdb4SThomas Gleixner 173e9e2cdb4SThomas Gleixner clockevents_notify(reason, &pr->id); 174e9e2cdb4SThomas Gleixner } 175e9e2cdb4SThomas Gleixner 176e9e2cdb4SThomas Gleixner /* Power(C) State timer broadcast control */ 1777e275cc4SLen Brown static void lapic_timer_state_broadcast(struct acpi_processor *pr, 178e9e2cdb4SThomas Gleixner struct acpi_processor_cx *cx, 179e9e2cdb4SThomas Gleixner int broadcast) 180e9e2cdb4SThomas Gleixner { 181e9e2cdb4SThomas Gleixner int state = cx - pr->power.states; 182e9e2cdb4SThomas Gleixner 183e9e2cdb4SThomas Gleixner if (state >= pr->power.timer_broadcast_on_state) { 184e9e2cdb4SThomas Gleixner unsigned long reason; 185e9e2cdb4SThomas Gleixner 186e9e2cdb4SThomas Gleixner reason = broadcast ? CLOCK_EVT_NOTIFY_BROADCAST_ENTER : 187e9e2cdb4SThomas Gleixner CLOCK_EVT_NOTIFY_BROADCAST_EXIT; 188e9e2cdb4SThomas Gleixner clockevents_notify(reason, &pr->id); 189e9e2cdb4SThomas Gleixner } 190169a0abbSThomas Gleixner } 191169a0abbSThomas Gleixner 192169a0abbSThomas Gleixner #else 193169a0abbSThomas Gleixner 1947e275cc4SLen Brown static void lapic_timer_check_state(int state, struct acpi_processor *pr, 195169a0abbSThomas Gleixner struct acpi_processor_cx *cstate) { } 1967e275cc4SLen Brown static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { } 1977e275cc4SLen Brown static void lapic_timer_state_broadcast(struct acpi_processor *pr, 198e9e2cdb4SThomas Gleixner struct acpi_processor_cx *cx, 199e9e2cdb4SThomas Gleixner int broadcast) 200e9e2cdb4SThomas Gleixner { 201e9e2cdb4SThomas Gleixner } 202169a0abbSThomas Gleixner 203169a0abbSThomas Gleixner #endif 204169a0abbSThomas Gleixner 205b04e7bdbSThomas Gleixner /* 206b04e7bdbSThomas Gleixner * Suspend / resume control 207b04e7bdbSThomas Gleixner */ 208b04e7bdbSThomas Gleixner static int acpi_idle_suspend; 209815ab0fdSLen Brown static u32 saved_bm_rld; 210815ab0fdSLen Brown 211815ab0fdSLen Brown static void acpi_idle_bm_rld_save(void) 212815ab0fdSLen Brown { 213815ab0fdSLen Brown acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld); 214815ab0fdSLen Brown } 215815ab0fdSLen Brown static void acpi_idle_bm_rld_restore(void) 216815ab0fdSLen Brown { 217815ab0fdSLen Brown u32 resumed_bm_rld; 218815ab0fdSLen Brown 219815ab0fdSLen Brown acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld); 220815ab0fdSLen Brown 221815ab0fdSLen Brown if (resumed_bm_rld != saved_bm_rld) 222815ab0fdSLen Brown acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld); 223815ab0fdSLen Brown } 224b04e7bdbSThomas Gleixner 225b04e7bdbSThomas Gleixner int acpi_processor_suspend(struct acpi_device * device, pm_message_t state) 226b04e7bdbSThomas Gleixner { 227815ab0fdSLen Brown if (acpi_idle_suspend == 1) 228815ab0fdSLen Brown return 0; 229815ab0fdSLen Brown 230815ab0fdSLen Brown acpi_idle_bm_rld_save(); 231b04e7bdbSThomas Gleixner acpi_idle_suspend = 1; 232b04e7bdbSThomas Gleixner return 0; 233b04e7bdbSThomas Gleixner } 234b04e7bdbSThomas Gleixner 235b04e7bdbSThomas Gleixner int acpi_processor_resume(struct acpi_device * device) 236b04e7bdbSThomas Gleixner { 237815ab0fdSLen Brown if (acpi_idle_suspend == 0) 238815ab0fdSLen Brown return 0; 239815ab0fdSLen Brown 240815ab0fdSLen Brown acpi_idle_bm_rld_restore(); 241b04e7bdbSThomas Gleixner acpi_idle_suspend = 0; 242b04e7bdbSThomas Gleixner return 0; 243b04e7bdbSThomas Gleixner } 244b04e7bdbSThomas Gleixner 24561331168SPavel Machek #if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86) 246520daf72SLen Brown static void tsc_check_state(int state) 247ddb25f9aSAndi Kleen { 248ddb25f9aSAndi Kleen switch (boot_cpu_data.x86_vendor) { 249ddb25f9aSAndi Kleen case X86_VENDOR_AMD: 25040fb1715SVenki Pallipadi case X86_VENDOR_INTEL: 251ddb25f9aSAndi Kleen /* 252ddb25f9aSAndi Kleen * AMD Fam10h TSC will tick in all 253ddb25f9aSAndi Kleen * C/P/S0/S1 states when this bit is set. 254ddb25f9aSAndi Kleen */ 25540fb1715SVenki Pallipadi if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC)) 256520daf72SLen Brown return; 25740fb1715SVenki Pallipadi 258ddb25f9aSAndi Kleen /*FALL THROUGH*/ 259ddb25f9aSAndi Kleen default: 260520daf72SLen Brown /* TSC could halt in idle, so notify users */ 261520daf72SLen Brown if (state > ACPI_STATE_C1) 262520daf72SLen Brown mark_tsc_unstable("TSC halts in idle"); 263ddb25f9aSAndi Kleen } 264ddb25f9aSAndi Kleen } 265520daf72SLen Brown #else 266520daf72SLen Brown static void tsc_check_state(int state) { return; } 267ddb25f9aSAndi Kleen #endif 268ddb25f9aSAndi Kleen 2691da177e4SLinus Torvalds static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr) 2701da177e4SLinus Torvalds { 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds if (!pr) 273d550d98dSPatrick Mochel return -EINVAL; 2741da177e4SLinus Torvalds 2751da177e4SLinus Torvalds if (!pr->pblk) 276d550d98dSPatrick Mochel return -ENODEV; 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds /* if info is obtained from pblk/fadt, type equals state */ 2791da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; 2801da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; 2811da177e4SLinus Torvalds 2824c033552SVenkatesh Pallipadi #ifndef CONFIG_HOTPLUG_CPU 2834c033552SVenkatesh Pallipadi /* 2844c033552SVenkatesh Pallipadi * Check for P_LVL2_UP flag before entering C2 and above on 2854c033552SVenkatesh Pallipadi * an SMP system. 2864c033552SVenkatesh Pallipadi */ 287ad71860aSAlexey Starikovskiy if ((num_online_cpus() > 1) && 288cee324b1SAlexey Starikovskiy !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED)) 289d550d98dSPatrick Mochel return -ENODEV; 2904c033552SVenkatesh Pallipadi #endif 2914c033552SVenkatesh Pallipadi 2921da177e4SLinus Torvalds /* determine C2 and C3 address from pblk */ 2931da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4; 2941da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5; 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds /* determine latencies from FADT */ 297cee324b1SAlexey Starikovskiy pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.C2latency; 298cee324b1SAlexey Starikovskiy pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.C3latency; 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, 3011da177e4SLinus Torvalds "lvl2[0x%08x] lvl3[0x%08x]\n", 3021da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C2].address, 3031da177e4SLinus Torvalds pr->power.states[ACPI_STATE_C3].address)); 3041da177e4SLinus Torvalds 305d550d98dSPatrick Mochel return 0; 3061da177e4SLinus Torvalds } 3071da177e4SLinus Torvalds 308991528d7SVenkatesh Pallipadi static int acpi_processor_get_power_info_default(struct acpi_processor *pr) 309acf05f4bSVenkatesh Pallipadi { 310991528d7SVenkatesh Pallipadi if (!pr->power.states[ACPI_STATE_C1].valid) { 311cf824788SJanosch Machowinski /* set the first C-State to C1 */ 312991528d7SVenkatesh Pallipadi /* all processors need to support C1 */ 313acf05f4bSVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; 314acf05f4bSVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].valid = 1; 3150fda6b40SVenkatesh Pallipadi pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT; 316991528d7SVenkatesh Pallipadi } 317991528d7SVenkatesh Pallipadi /* the C0 state only exists as a filler in our array */ 318991528d7SVenkatesh Pallipadi pr->power.states[ACPI_STATE_C0].valid = 1; 319d550d98dSPatrick Mochel return 0; 320acf05f4bSVenkatesh Pallipadi } 321acf05f4bSVenkatesh Pallipadi 3221da177e4SLinus Torvalds static int acpi_processor_get_power_info_cst(struct acpi_processor *pr) 3231da177e4SLinus Torvalds { 3241da177e4SLinus Torvalds acpi_status status = 0; 3251da177e4SLinus Torvalds acpi_integer count; 326cf824788SJanosch Machowinski int current_count; 3271da177e4SLinus Torvalds int i; 3281da177e4SLinus Torvalds struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 3291da177e4SLinus Torvalds union acpi_object *cst; 3301da177e4SLinus Torvalds 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds if (nocst) 333d550d98dSPatrick Mochel return -ENODEV; 3341da177e4SLinus Torvalds 335991528d7SVenkatesh Pallipadi current_count = 0; 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer); 3381da177e4SLinus Torvalds if (ACPI_FAILURE(status)) { 3391da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n")); 340d550d98dSPatrick Mochel return -ENODEV; 3411da177e4SLinus Torvalds } 3421da177e4SLinus Torvalds 34350dd0969SJan Engelhardt cst = buffer.pointer; 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds /* There must be at least 2 elements */ 3461da177e4SLinus Torvalds if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) { 3476468463aSLen Brown printk(KERN_ERR PREFIX "not enough elements in _CST\n"); 3481da177e4SLinus Torvalds status = -EFAULT; 3491da177e4SLinus Torvalds goto end; 3501da177e4SLinus Torvalds } 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds count = cst->package.elements[0].integer.value; 3531da177e4SLinus Torvalds 3541da177e4SLinus Torvalds /* Validate number of power states. */ 3551da177e4SLinus Torvalds if (count < 1 || count != cst->package.count - 1) { 3566468463aSLen Brown printk(KERN_ERR PREFIX "count given by _CST is not valid\n"); 3571da177e4SLinus Torvalds status = -EFAULT; 3581da177e4SLinus Torvalds goto end; 3591da177e4SLinus Torvalds } 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds /* Tell driver that at least _CST is supported. */ 3621da177e4SLinus Torvalds pr->flags.has_cst = 1; 3631da177e4SLinus Torvalds 3641da177e4SLinus Torvalds for (i = 1; i <= count; i++) { 3651da177e4SLinus Torvalds union acpi_object *element; 3661da177e4SLinus Torvalds union acpi_object *obj; 3671da177e4SLinus Torvalds struct acpi_power_register *reg; 3681da177e4SLinus Torvalds struct acpi_processor_cx cx; 3691da177e4SLinus Torvalds 3701da177e4SLinus Torvalds memset(&cx, 0, sizeof(cx)); 3711da177e4SLinus Torvalds 37250dd0969SJan Engelhardt element = &(cst->package.elements[i]); 3731da177e4SLinus Torvalds if (element->type != ACPI_TYPE_PACKAGE) 3741da177e4SLinus Torvalds continue; 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds if (element->package.count != 4) 3771da177e4SLinus Torvalds continue; 3781da177e4SLinus Torvalds 37950dd0969SJan Engelhardt obj = &(element->package.elements[0]); 3801da177e4SLinus Torvalds 3811da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_BUFFER) 3821da177e4SLinus Torvalds continue; 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds reg = (struct acpi_power_register *)obj->buffer.pointer; 3851da177e4SLinus Torvalds 3861da177e4SLinus Torvalds if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && 3871da177e4SLinus Torvalds (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) 3881da177e4SLinus Torvalds continue; 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds /* There should be an easy way to extract an integer... */ 39150dd0969SJan Engelhardt obj = &(element->package.elements[1]); 3921da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 3931da177e4SLinus Torvalds continue; 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds cx.type = obj->integer.value; 396991528d7SVenkatesh Pallipadi /* 397991528d7SVenkatesh Pallipadi * Some buggy BIOSes won't list C1 in _CST - 398991528d7SVenkatesh Pallipadi * Let acpi_processor_get_power_info_default() handle them later 399991528d7SVenkatesh Pallipadi */ 400991528d7SVenkatesh Pallipadi if (i == 1 && cx.type != ACPI_STATE_C1) 401991528d7SVenkatesh Pallipadi current_count++; 4021da177e4SLinus Torvalds 403991528d7SVenkatesh Pallipadi cx.address = reg->address; 404991528d7SVenkatesh Pallipadi cx.index = current_count + 1; 4051da177e4SLinus Torvalds 406bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_SYSTEMIO; 407991528d7SVenkatesh Pallipadi if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { 408991528d7SVenkatesh Pallipadi if (acpi_processor_ffh_cstate_probe 409991528d7SVenkatesh Pallipadi (pr->id, &cx, reg) == 0) { 410bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_FFH; 411bc71bec9Svenkatesh.pallipadi@intel.com } else if (cx.type == ACPI_STATE_C1) { 412991528d7SVenkatesh Pallipadi /* 413991528d7SVenkatesh Pallipadi * C1 is a special case where FIXED_HARDWARE 414991528d7SVenkatesh Pallipadi * can be handled in non-MWAIT way as well. 415991528d7SVenkatesh Pallipadi * In that case, save this _CST entry info. 416991528d7SVenkatesh Pallipadi * Otherwise, ignore this info and continue. 417991528d7SVenkatesh Pallipadi */ 418bc71bec9Svenkatesh.pallipadi@intel.com cx.entry_method = ACPI_CSTATE_HALT; 4194fcb2fcdSVenkatesh Pallipadi snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 420bc71bec9Svenkatesh.pallipadi@intel.com } else { 4211da177e4SLinus Torvalds continue; 422991528d7SVenkatesh Pallipadi } 423da5e09a1SZhao Yakui if (cx.type == ACPI_STATE_C1 && 424da5e09a1SZhao Yakui (idle_halt || idle_nomwait)) { 425c1e3b377SZhao Yakui /* 426c1e3b377SZhao Yakui * In most cases the C1 space_id obtained from 427c1e3b377SZhao Yakui * _CST object is FIXED_HARDWARE access mode. 428c1e3b377SZhao Yakui * But when the option of idle=halt is added, 429c1e3b377SZhao Yakui * the entry_method type should be changed from 430c1e3b377SZhao Yakui * CSTATE_FFH to CSTATE_HALT. 431da5e09a1SZhao Yakui * When the option of idle=nomwait is added, 432da5e09a1SZhao Yakui * the C1 entry_method type should be 433da5e09a1SZhao Yakui * CSTATE_HALT. 434c1e3b377SZhao Yakui */ 435c1e3b377SZhao Yakui cx.entry_method = ACPI_CSTATE_HALT; 436c1e3b377SZhao Yakui snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT"); 437c1e3b377SZhao Yakui } 4384fcb2fcdSVenkatesh Pallipadi } else { 4394fcb2fcdSVenkatesh Pallipadi snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x", 4404fcb2fcdSVenkatesh Pallipadi cx.address); 441991528d7SVenkatesh Pallipadi } 4421da177e4SLinus Torvalds 4430fda6b40SVenkatesh Pallipadi if (cx.type == ACPI_STATE_C1) { 4440fda6b40SVenkatesh Pallipadi cx.valid = 1; 4450fda6b40SVenkatesh Pallipadi } 4464fcb2fcdSVenkatesh Pallipadi 44750dd0969SJan Engelhardt obj = &(element->package.elements[2]); 4481da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 4491da177e4SLinus Torvalds continue; 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds cx.latency = obj->integer.value; 4521da177e4SLinus Torvalds 45350dd0969SJan Engelhardt obj = &(element->package.elements[3]); 4541da177e4SLinus Torvalds if (obj->type != ACPI_TYPE_INTEGER) 4551da177e4SLinus Torvalds continue; 4561da177e4SLinus Torvalds 4571da177e4SLinus Torvalds cx.power = obj->integer.value; 4581da177e4SLinus Torvalds 459cf824788SJanosch Machowinski current_count++; 460cf824788SJanosch Machowinski memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx)); 461cf824788SJanosch Machowinski 462cf824788SJanosch Machowinski /* 463cf824788SJanosch Machowinski * We support total ACPI_PROCESSOR_MAX_POWER - 1 464cf824788SJanosch Machowinski * (From 1 through ACPI_PROCESSOR_MAX_POWER - 1) 465cf824788SJanosch Machowinski */ 466cf824788SJanosch Machowinski if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) { 467cf824788SJanosch Machowinski printk(KERN_WARNING 468cf824788SJanosch Machowinski "Limiting number of power states to max (%d)\n", 469cf824788SJanosch Machowinski ACPI_PROCESSOR_MAX_POWER); 470cf824788SJanosch Machowinski printk(KERN_WARNING 471cf824788SJanosch Machowinski "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n"); 472cf824788SJanosch Machowinski break; 473cf824788SJanosch Machowinski } 4741da177e4SLinus Torvalds } 4751da177e4SLinus Torvalds 4764be44fcdSLen Brown ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n", 477cf824788SJanosch Machowinski current_count)); 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds /* Validate number of power states discovered */ 480cf824788SJanosch Machowinski if (current_count < 2) 4816d93c648SVenkatesh Pallipadi status = -EFAULT; 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds end: 48402438d87SLen Brown kfree(buffer.pointer); 4851da177e4SLinus Torvalds 486d550d98dSPatrick Mochel return status; 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx) 4901da177e4SLinus Torvalds { 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds if (!cx->address) 493d550d98dSPatrick Mochel return; 4941da177e4SLinus Torvalds 4951da177e4SLinus Torvalds /* 4961da177e4SLinus Torvalds * C2 latency must be less than or equal to 100 4971da177e4SLinus Torvalds * microseconds. 4981da177e4SLinus Torvalds */ 4991da177e4SLinus Torvalds else if (cx->latency > ACPI_PROCESSOR_MAX_C2_LATENCY) { 5001da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, 5014be44fcdSLen Brown "latency too large [%d]\n", cx->latency)); 502d550d98dSPatrick Mochel return; 5031da177e4SLinus Torvalds } 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds /* 5061da177e4SLinus Torvalds * Otherwise we've met all of our C2 requirements. 5071da177e4SLinus Torvalds * Normalize the C2 latency to expidite policy 5081da177e4SLinus Torvalds */ 5091da177e4SLinus Torvalds cx->valid = 1; 5104f86d3a8SLen Brown 5114f86d3a8SLen Brown cx->latency_ticks = cx->latency; 5121da177e4SLinus Torvalds 513d550d98dSPatrick Mochel return; 5141da177e4SLinus Torvalds } 5151da177e4SLinus Torvalds 5164be44fcdSLen Brown static void acpi_processor_power_verify_c3(struct acpi_processor *pr, 5171da177e4SLinus Torvalds struct acpi_processor_cx *cx) 5181da177e4SLinus Torvalds { 519ee1ca48fSPallipadi, Venkatesh static int bm_check_flag = -1; 520ee1ca48fSPallipadi, Venkatesh static int bm_control_flag = -1; 52102df8b93SVenkatesh Pallipadi 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds if (!cx->address) 524d550d98dSPatrick Mochel return; 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds /* 5271da177e4SLinus Torvalds * C3 latency must be less than or equal to 1000 5281da177e4SLinus Torvalds * microseconds. 5291da177e4SLinus Torvalds */ 5301da177e4SLinus Torvalds else if (cx->latency > ACPI_PROCESSOR_MAX_C3_LATENCY) { 5311da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, 5324be44fcdSLen Brown "latency too large [%d]\n", cx->latency)); 533d550d98dSPatrick Mochel return; 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds /* 5371da177e4SLinus Torvalds * PIIX4 Erratum #18: We don't support C3 when Type-F (fast) 5381da177e4SLinus Torvalds * DMA transfers are used by any ISA device to avoid livelock. 5391da177e4SLinus Torvalds * Note that we could disable Type-F DMA (as recommended by 5401da177e4SLinus Torvalds * the erratum), but this is known to disrupt certain ISA 5411da177e4SLinus Torvalds * devices thus we take the conservative approach. 5421da177e4SLinus Torvalds */ 5431da177e4SLinus Torvalds else if (errata.piix4.fdma) { 5441da177e4SLinus Torvalds ACPI_DEBUG_PRINT((ACPI_DB_INFO, 5451da177e4SLinus Torvalds "C3 not supported on PIIX4 with Type-F DMA\n")); 546d550d98dSPatrick Mochel return; 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds 54902df8b93SVenkatesh Pallipadi /* All the logic here assumes flags.bm_check is same across all CPUs */ 550ee1ca48fSPallipadi, Venkatesh if (bm_check_flag == -1) { 55102df8b93SVenkatesh Pallipadi /* Determine whether bm_check is needed based on CPU */ 55202df8b93SVenkatesh Pallipadi acpi_processor_power_init_bm_check(&(pr->flags), pr->id); 55302df8b93SVenkatesh Pallipadi bm_check_flag = pr->flags.bm_check; 554ee1ca48fSPallipadi, Venkatesh bm_control_flag = pr->flags.bm_control; 55502df8b93SVenkatesh Pallipadi } else { 55602df8b93SVenkatesh Pallipadi pr->flags.bm_check = bm_check_flag; 557ee1ca48fSPallipadi, Venkatesh pr->flags.bm_control = bm_control_flag; 55802df8b93SVenkatesh Pallipadi } 55902df8b93SVenkatesh Pallipadi 56002df8b93SVenkatesh Pallipadi if (pr->flags.bm_check) { 56102df8b93SVenkatesh Pallipadi if (!pr->flags.bm_control) { 562ed3110efSVenki Pallipadi if (pr->flags.has_cst != 1) { 563ed3110efSVenki Pallipadi /* bus mastering control is necessary */ 56402df8b93SVenkatesh Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 565ed3110efSVenki Pallipadi "C3 support requires BM control\n")); 566ed3110efSVenki Pallipadi return; 567ed3110efSVenki Pallipadi } else { 568ed3110efSVenki Pallipadi /* Here we enter C3 without bus mastering */ 569ed3110efSVenki Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 570ed3110efSVenki Pallipadi "C3 support without BM control\n")); 571ed3110efSVenki Pallipadi } 57202df8b93SVenkatesh Pallipadi } 57302df8b93SVenkatesh Pallipadi } else { 57402df8b93SVenkatesh Pallipadi /* 57502df8b93SVenkatesh Pallipadi * WBINVD should be set in fadt, for C3 state to be 57602df8b93SVenkatesh Pallipadi * supported on when bm_check is not required. 57702df8b93SVenkatesh Pallipadi */ 578cee324b1SAlexey Starikovskiy if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) { 57902df8b93SVenkatesh Pallipadi ACPI_DEBUG_PRINT((ACPI_DB_INFO, 58002df8b93SVenkatesh Pallipadi "Cache invalidation should work properly" 58102df8b93SVenkatesh Pallipadi " for C3 to be enabled on SMP systems\n")); 582d550d98dSPatrick Mochel return; 58302df8b93SVenkatesh Pallipadi } 58402df8b93SVenkatesh Pallipadi } 58502df8b93SVenkatesh Pallipadi 5861da177e4SLinus Torvalds /* 5871da177e4SLinus Torvalds * Otherwise we've met all of our C3 requirements. 5881da177e4SLinus Torvalds * Normalize the C3 latency to expidite policy. Enable 5891da177e4SLinus Torvalds * checking of bus mastering status (bm_check) so we can 5901da177e4SLinus Torvalds * use this in our C3 policy 5911da177e4SLinus Torvalds */ 5921da177e4SLinus Torvalds cx->valid = 1; 5934f86d3a8SLen Brown 5944f86d3a8SLen Brown cx->latency_ticks = cx->latency; 59531878dd8SLen Brown /* 59631878dd8SLen Brown * On older chipsets, BM_RLD needs to be set 59731878dd8SLen Brown * in order for Bus Master activity to wake the 59831878dd8SLen Brown * system from C3. Newer chipsets handle DMA 59931878dd8SLen Brown * during C3 automatically and BM_RLD is a NOP. 60031878dd8SLen Brown * In either case, the proper way to 60131878dd8SLen Brown * handle BM_RLD is to set it and leave it set. 60231878dd8SLen Brown */ 60350ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 1); 6041da177e4SLinus Torvalds 605d550d98dSPatrick Mochel return; 6061da177e4SLinus Torvalds } 6071da177e4SLinus Torvalds 6081da177e4SLinus Torvalds static int acpi_processor_power_verify(struct acpi_processor *pr) 6091da177e4SLinus Torvalds { 6101da177e4SLinus Torvalds unsigned int i; 6111da177e4SLinus Torvalds unsigned int working = 0; 6126eb0a0fdSVenkatesh Pallipadi 613169a0abbSThomas Gleixner pr->power.timer_broadcast_on_state = INT_MAX; 6146eb0a0fdSVenkatesh Pallipadi 615a0bf284bSLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 6161da177e4SLinus Torvalds struct acpi_processor_cx *cx = &pr->power.states[i]; 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds switch (cx->type) { 6191da177e4SLinus Torvalds case ACPI_STATE_C1: 6201da177e4SLinus Torvalds cx->valid = 1; 6211da177e4SLinus Torvalds break; 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds case ACPI_STATE_C2: 6241da177e4SLinus Torvalds acpi_processor_power_verify_c2(cx); 6251da177e4SLinus Torvalds break; 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds case ACPI_STATE_C3: 6281da177e4SLinus Torvalds acpi_processor_power_verify_c3(pr, cx); 6291da177e4SLinus Torvalds break; 6301da177e4SLinus Torvalds } 6317e275cc4SLen Brown if (!cx->valid) 6327e275cc4SLen Brown continue; 6331da177e4SLinus Torvalds 6347e275cc4SLen Brown lapic_timer_check_state(i, pr, cx); 6357e275cc4SLen Brown tsc_check_state(cx->type); 6361da177e4SLinus Torvalds working++; 6371da177e4SLinus Torvalds } 6381da177e4SLinus Torvalds 639*f833bab8SSuresh Siddha smp_call_function_single(pr->id, lapic_timer_propagate_broadcast, 640*f833bab8SSuresh Siddha pr, 1); 641bd663347SAndi Kleen 6421da177e4SLinus Torvalds return (working); 6431da177e4SLinus Torvalds } 6441da177e4SLinus Torvalds 6454be44fcdSLen Brown static int acpi_processor_get_power_info(struct acpi_processor *pr) 6461da177e4SLinus Torvalds { 6471da177e4SLinus Torvalds unsigned int i; 6481da177e4SLinus Torvalds int result; 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds /* NOTE: the idle thread may not be running while calling 6521da177e4SLinus Torvalds * this function */ 6531da177e4SLinus Torvalds 654991528d7SVenkatesh Pallipadi /* Zero initialize all the C-states info. */ 655991528d7SVenkatesh Pallipadi memset(pr->power.states, 0, sizeof(pr->power.states)); 656991528d7SVenkatesh Pallipadi 6571da177e4SLinus Torvalds result = acpi_processor_get_power_info_cst(pr); 6586d93c648SVenkatesh Pallipadi if (result == -ENODEV) 659c5a114f1SDarrick J. Wong result = acpi_processor_get_power_info_fadt(pr); 6606d93c648SVenkatesh Pallipadi 661991528d7SVenkatesh Pallipadi if (result) 662991528d7SVenkatesh Pallipadi return result; 663991528d7SVenkatesh Pallipadi 664991528d7SVenkatesh Pallipadi acpi_processor_get_power_info_default(pr); 665991528d7SVenkatesh Pallipadi 666cf824788SJanosch Machowinski pr->power.count = acpi_processor_power_verify(pr); 6671da177e4SLinus Torvalds 6681da177e4SLinus Torvalds /* 6691da177e4SLinus Torvalds * if one state of type C2 or C3 is available, mark this 6701da177e4SLinus Torvalds * CPU as being "idle manageable" 6711da177e4SLinus Torvalds */ 6721da177e4SLinus Torvalds for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) { 673acf05f4bSVenkatesh Pallipadi if (pr->power.states[i].valid) { 6741da177e4SLinus Torvalds pr->power.count = i; 6752203d6edSLinus Torvalds if (pr->power.states[i].type >= ACPI_STATE_C2) 6761da177e4SLinus Torvalds pr->flags.power = 1; 6771da177e4SLinus Torvalds } 678acf05f4bSVenkatesh Pallipadi } 6791da177e4SLinus Torvalds 680d550d98dSPatrick Mochel return 0; 6811da177e4SLinus Torvalds } 6821da177e4SLinus Torvalds 6831da177e4SLinus Torvalds static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset) 6841da177e4SLinus Torvalds { 68550dd0969SJan Engelhardt struct acpi_processor *pr = seq->private; 6861da177e4SLinus Torvalds unsigned int i; 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds if (!pr) 6901da177e4SLinus Torvalds goto end; 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds seq_printf(seq, "active state: C%zd\n" 6931da177e4SLinus Torvalds "max_cstate: C%d\n" 6945c87579eSArjan van de Ven "maximum allowed latency: %d usec\n", 6951da177e4SLinus Torvalds pr->power.state ? pr->power.state - pr->power.states : 0, 69692614610SLen Brown max_cstate, pm_qos_requirement(PM_QOS_CPU_DMA_LATENCY)); 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds seq_puts(seq, "states:\n"); 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds for (i = 1; i <= pr->power.count; i++) { 7011da177e4SLinus Torvalds seq_printf(seq, " %cC%d: ", 7024be44fcdSLen Brown (&pr->power.states[i] == 7034be44fcdSLen Brown pr->power.state ? '*' : ' '), i); 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds if (!pr->power.states[i].valid) { 7061da177e4SLinus Torvalds seq_puts(seq, "<not supported>\n"); 7071da177e4SLinus Torvalds continue; 7081da177e4SLinus Torvalds } 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds switch (pr->power.states[i].type) { 7111da177e4SLinus Torvalds case ACPI_STATE_C1: 7121da177e4SLinus Torvalds seq_printf(seq, "type[C1] "); 7131da177e4SLinus Torvalds break; 7141da177e4SLinus Torvalds case ACPI_STATE_C2: 7151da177e4SLinus Torvalds seq_printf(seq, "type[C2] "); 7161da177e4SLinus Torvalds break; 7171da177e4SLinus Torvalds case ACPI_STATE_C3: 7181da177e4SLinus Torvalds seq_printf(seq, "type[C3] "); 7191da177e4SLinus Torvalds break; 7201da177e4SLinus Torvalds default: 7211da177e4SLinus Torvalds seq_printf(seq, "type[--] "); 7221da177e4SLinus Torvalds break; 7231da177e4SLinus Torvalds } 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds if (pr->power.states[i].promotion.state) 7261da177e4SLinus Torvalds seq_printf(seq, "promotion[C%zd] ", 7271da177e4SLinus Torvalds (pr->power.states[i].promotion.state - 7281da177e4SLinus Torvalds pr->power.states)); 7291da177e4SLinus Torvalds else 7301da177e4SLinus Torvalds seq_puts(seq, "promotion[--] "); 7311da177e4SLinus Torvalds 7321da177e4SLinus Torvalds if (pr->power.states[i].demotion.state) 7331da177e4SLinus Torvalds seq_printf(seq, "demotion[C%zd] ", 7341da177e4SLinus Torvalds (pr->power.states[i].demotion.state - 7351da177e4SLinus Torvalds pr->power.states)); 7361da177e4SLinus Torvalds else 7371da177e4SLinus Torvalds seq_puts(seq, "demotion[--] "); 7381da177e4SLinus Torvalds 739a3c6598fSDominik Brodowski seq_printf(seq, "latency[%03d] usage[%08d] duration[%020llu]\n", 7401da177e4SLinus Torvalds pr->power.states[i].latency, 741a3c6598fSDominik Brodowski pr->power.states[i].usage, 742b0b7eaafSAlexey Starikovskiy (unsigned long long)pr->power.states[i].time); 7431da177e4SLinus Torvalds } 7441da177e4SLinus Torvalds 7451da177e4SLinus Torvalds end: 746d550d98dSPatrick Mochel return 0; 7471da177e4SLinus Torvalds } 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds static int acpi_processor_power_open_fs(struct inode *inode, struct file *file) 7501da177e4SLinus Torvalds { 7511da177e4SLinus Torvalds return single_open(file, acpi_processor_power_seq_show, 7521da177e4SLinus Torvalds PDE(inode)->data); 7531da177e4SLinus Torvalds } 7541da177e4SLinus Torvalds 755d7508032SArjan van de Ven static const struct file_operations acpi_processor_power_fops = { 756cf7acfabSDenis V. Lunev .owner = THIS_MODULE, 7571da177e4SLinus Torvalds .open = acpi_processor_power_open_fs, 7581da177e4SLinus Torvalds .read = seq_read, 7591da177e4SLinus Torvalds .llseek = seq_lseek, 7601da177e4SLinus Torvalds .release = single_release, 7611da177e4SLinus Torvalds }; 7621da177e4SLinus Torvalds 7634f86d3a8SLen Brown 7644f86d3a8SLen Brown /** 7654f86d3a8SLen Brown * acpi_idle_bm_check - checks if bus master activity was detected 7664f86d3a8SLen Brown */ 7674f86d3a8SLen Brown static int acpi_idle_bm_check(void) 7684f86d3a8SLen Brown { 7694f86d3a8SLen Brown u32 bm_status = 0; 7704f86d3a8SLen Brown 77150ffba1bSBob Moore acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status); 7724f86d3a8SLen Brown if (bm_status) 77350ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, 1); 7744f86d3a8SLen Brown /* 7754f86d3a8SLen Brown * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect 7764f86d3a8SLen Brown * the true state of bus mastering activity; forcing us to 7774f86d3a8SLen Brown * manually check the BMIDEA bit of each IDE channel. 7784f86d3a8SLen Brown */ 7794f86d3a8SLen Brown else if (errata.piix4.bmisx) { 7804f86d3a8SLen Brown if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01) 7814f86d3a8SLen Brown || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01)) 7824f86d3a8SLen Brown bm_status = 1; 7834f86d3a8SLen Brown } 7844f86d3a8SLen Brown return bm_status; 7854f86d3a8SLen Brown } 7864f86d3a8SLen Brown 7874f86d3a8SLen Brown /** 7884f86d3a8SLen Brown * acpi_idle_do_entry - a helper function that does C2 and C3 type entry 7894f86d3a8SLen Brown * @cx: cstate data 790bc71bec9Svenkatesh.pallipadi@intel.com * 791bc71bec9Svenkatesh.pallipadi@intel.com * Caller disables interrupt before call and enables interrupt after return. 7924f86d3a8SLen Brown */ 7934f86d3a8SLen Brown static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx) 7944f86d3a8SLen Brown { 795dcf30997SSteven Rostedt /* Don't trace irqs off for idle */ 796dcf30997SSteven Rostedt stop_critical_timings(); 797bc71bec9Svenkatesh.pallipadi@intel.com if (cx->entry_method == ACPI_CSTATE_FFH) { 7984f86d3a8SLen Brown /* Call into architectural FFH based C-state */ 7994f86d3a8SLen Brown acpi_processor_ffh_cstate_enter(cx); 800bc71bec9Svenkatesh.pallipadi@intel.com } else if (cx->entry_method == ACPI_CSTATE_HALT) { 801bc71bec9Svenkatesh.pallipadi@intel.com acpi_safe_halt(); 8024f86d3a8SLen Brown } else { 8034f86d3a8SLen Brown int unused; 8044f86d3a8SLen Brown /* IO port based C-state */ 8054f86d3a8SLen Brown inb(cx->address); 8064f86d3a8SLen Brown /* Dummy wait op - must do something useless after P_LVL2 read 8074f86d3a8SLen Brown because chipsets cannot guarantee that STPCLK# signal 8084f86d3a8SLen Brown gets asserted in time to freeze execution properly. */ 8094f86d3a8SLen Brown unused = inl(acpi_gbl_FADT.xpm_timer_block.address); 8104f86d3a8SLen Brown } 811dcf30997SSteven Rostedt start_critical_timings(); 8124f86d3a8SLen Brown } 8134f86d3a8SLen Brown 8144f86d3a8SLen Brown /** 8154f86d3a8SLen Brown * acpi_idle_enter_c1 - enters an ACPI C1 state-type 8164f86d3a8SLen Brown * @dev: the target CPU 8174f86d3a8SLen Brown * @state: the state data 8184f86d3a8SLen Brown * 8194f86d3a8SLen Brown * This is equivalent to the HALT instruction. 8204f86d3a8SLen Brown */ 8214f86d3a8SLen Brown static int acpi_idle_enter_c1(struct cpuidle_device *dev, 8224f86d3a8SLen Brown struct cpuidle_state *state) 8234f86d3a8SLen Brown { 824ff69f2bbSalex.shi ktime_t kt1, kt2; 825ff69f2bbSalex.shi s64 idle_time; 8264f86d3a8SLen Brown struct acpi_processor *pr; 8274f86d3a8SLen Brown struct acpi_processor_cx *cx = cpuidle_get_statedata(state); 8289b12e18cSvenkatesh.pallipadi@intel.com 829706546d0SMike Travis pr = __get_cpu_var(processors); 8304f86d3a8SLen Brown 8314f86d3a8SLen Brown if (unlikely(!pr)) 8324f86d3a8SLen Brown return 0; 8334f86d3a8SLen Brown 8342e906655Svenkatesh.pallipadi@intel.com local_irq_disable(); 835b077fbadSVenkatesh Pallipadi 836b077fbadSVenkatesh Pallipadi /* Do not access any ACPI IO ports in suspend path */ 837b077fbadSVenkatesh Pallipadi if (acpi_idle_suspend) { 838b077fbadSVenkatesh Pallipadi local_irq_enable(); 8397d60e8abSShaohua Li cpu_relax(); 840b077fbadSVenkatesh Pallipadi return 0; 841b077fbadSVenkatesh Pallipadi } 842b077fbadSVenkatesh Pallipadi 8437e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 1); 844ff69f2bbSalex.shi kt1 = ktime_get_real(); 845bc71bec9Svenkatesh.pallipadi@intel.com acpi_idle_do_entry(cx); 846ff69f2bbSalex.shi kt2 = ktime_get_real(); 847ff69f2bbSalex.shi idle_time = ktime_to_us(ktime_sub(kt2, kt1)); 8484f86d3a8SLen Brown 8492e906655Svenkatesh.pallipadi@intel.com local_irq_enable(); 8504f86d3a8SLen Brown cx->usage++; 8517e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 0); 8524f86d3a8SLen Brown 853ff69f2bbSalex.shi return idle_time; 8544f86d3a8SLen Brown } 8554f86d3a8SLen Brown 8564f86d3a8SLen Brown /** 8574f86d3a8SLen Brown * acpi_idle_enter_simple - enters an ACPI state without BM handling 8584f86d3a8SLen Brown * @dev: the target CPU 8594f86d3a8SLen Brown * @state: the state data 8604f86d3a8SLen Brown */ 8614f86d3a8SLen Brown static int acpi_idle_enter_simple(struct cpuidle_device *dev, 8624f86d3a8SLen Brown struct cpuidle_state *state) 8634f86d3a8SLen Brown { 8644f86d3a8SLen Brown struct acpi_processor *pr; 8654f86d3a8SLen Brown struct acpi_processor_cx *cx = cpuidle_get_statedata(state); 866ff69f2bbSalex.shi ktime_t kt1, kt2; 867ff69f2bbSalex.shi s64 idle_time; 868ff69f2bbSalex.shi s64 sleep_ticks = 0; 86950629118SVenkatesh Pallipadi 870706546d0SMike Travis pr = __get_cpu_var(processors); 8714f86d3a8SLen Brown 8724f86d3a8SLen Brown if (unlikely(!pr)) 8734f86d3a8SLen Brown return 0; 8744f86d3a8SLen Brown 875e196441bSLen Brown if (acpi_idle_suspend) 876e196441bSLen Brown return(acpi_idle_enter_c1(dev, state)); 877e196441bSLen Brown 8784f86d3a8SLen Brown local_irq_disable(); 8794f86d3a8SLen Brown current_thread_info()->status &= ~TS_POLLING; 8804f86d3a8SLen Brown /* 8814f86d3a8SLen Brown * TS_POLLING-cleared state must be visible before we test 8824f86d3a8SLen Brown * NEED_RESCHED: 8834f86d3a8SLen Brown */ 8844f86d3a8SLen Brown smp_mb(); 8854f86d3a8SLen Brown 8864f86d3a8SLen Brown if (unlikely(need_resched())) { 8874f86d3a8SLen Brown current_thread_info()->status |= TS_POLLING; 8884f86d3a8SLen Brown local_irq_enable(); 8894f86d3a8SLen Brown return 0; 8904f86d3a8SLen Brown } 8914f86d3a8SLen Brown 892e17bcb43SThomas Gleixner /* 893e17bcb43SThomas Gleixner * Must be done before busmaster disable as we might need to 894e17bcb43SThomas Gleixner * access HPET ! 895e17bcb43SThomas Gleixner */ 8967e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 1); 897e17bcb43SThomas Gleixner 8984f86d3a8SLen Brown if (cx->type == ACPI_STATE_C3) 8994f86d3a8SLen Brown ACPI_FLUSH_CPU_CACHE(); 9004f86d3a8SLen Brown 901ff69f2bbSalex.shi kt1 = ktime_get_real(); 90250629118SVenkatesh Pallipadi /* Tell the scheduler that we are going deep-idle: */ 90350629118SVenkatesh Pallipadi sched_clock_idle_sleep_event(); 9044f86d3a8SLen Brown acpi_idle_do_entry(cx); 905ff69f2bbSalex.shi kt2 = ktime_get_real(); 906ff69f2bbSalex.shi idle_time = ktime_to_us(ktime_sub(kt2, kt1)); 9074f86d3a8SLen Brown 908ff69f2bbSalex.shi sleep_ticks = us_to_pm_timer_ticks(idle_time); 90950629118SVenkatesh Pallipadi 91050629118SVenkatesh Pallipadi /* Tell the scheduler how much we idled: */ 91150629118SVenkatesh Pallipadi sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS); 9124f86d3a8SLen Brown 9134f86d3a8SLen Brown local_irq_enable(); 9144f86d3a8SLen Brown current_thread_info()->status |= TS_POLLING; 9154f86d3a8SLen Brown 9164f86d3a8SLen Brown cx->usage++; 9174f86d3a8SLen Brown 9187e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 0); 91950629118SVenkatesh Pallipadi cx->time += sleep_ticks; 920ff69f2bbSalex.shi return idle_time; 9214f86d3a8SLen Brown } 9224f86d3a8SLen Brown 9234f86d3a8SLen Brown static int c3_cpu_count; 9244f86d3a8SLen Brown static DEFINE_SPINLOCK(c3_lock); 9254f86d3a8SLen Brown 9264f86d3a8SLen Brown /** 9274f86d3a8SLen Brown * acpi_idle_enter_bm - enters C3 with proper BM handling 9284f86d3a8SLen Brown * @dev: the target CPU 9294f86d3a8SLen Brown * @state: the state data 9304f86d3a8SLen Brown * 9314f86d3a8SLen Brown * If BM is detected, the deepest non-C3 idle state is entered instead. 9324f86d3a8SLen Brown */ 9334f86d3a8SLen Brown static int acpi_idle_enter_bm(struct cpuidle_device *dev, 9344f86d3a8SLen Brown struct cpuidle_state *state) 9354f86d3a8SLen Brown { 9364f86d3a8SLen Brown struct acpi_processor *pr; 9374f86d3a8SLen Brown struct acpi_processor_cx *cx = cpuidle_get_statedata(state); 938ff69f2bbSalex.shi ktime_t kt1, kt2; 939ff69f2bbSalex.shi s64 idle_time; 940ff69f2bbSalex.shi s64 sleep_ticks = 0; 941ff69f2bbSalex.shi 94250629118SVenkatesh Pallipadi 943706546d0SMike Travis pr = __get_cpu_var(processors); 9444f86d3a8SLen Brown 9454f86d3a8SLen Brown if (unlikely(!pr)) 9464f86d3a8SLen Brown return 0; 9474f86d3a8SLen Brown 948e196441bSLen Brown if (acpi_idle_suspend) 949e196441bSLen Brown return(acpi_idle_enter_c1(dev, state)); 950e196441bSLen Brown 951ddc081a1SVenkatesh Pallipadi if (acpi_idle_bm_check()) { 952ddc081a1SVenkatesh Pallipadi if (dev->safe_state) { 953addbad46SVenkatesh Pallipadi dev->last_state = dev->safe_state; 954ddc081a1SVenkatesh Pallipadi return dev->safe_state->enter(dev, dev->safe_state); 955ddc081a1SVenkatesh Pallipadi } else { 9562e906655Svenkatesh.pallipadi@intel.com local_irq_disable(); 957ddc081a1SVenkatesh Pallipadi acpi_safe_halt(); 9582e906655Svenkatesh.pallipadi@intel.com local_irq_enable(); 959ddc081a1SVenkatesh Pallipadi return 0; 960ddc081a1SVenkatesh Pallipadi } 961ddc081a1SVenkatesh Pallipadi } 962ddc081a1SVenkatesh Pallipadi 9634f86d3a8SLen Brown local_irq_disable(); 9644f86d3a8SLen Brown current_thread_info()->status &= ~TS_POLLING; 9654f86d3a8SLen Brown /* 9664f86d3a8SLen Brown * TS_POLLING-cleared state must be visible before we test 9674f86d3a8SLen Brown * NEED_RESCHED: 9684f86d3a8SLen Brown */ 9694f86d3a8SLen Brown smp_mb(); 9704f86d3a8SLen Brown 9714f86d3a8SLen Brown if (unlikely(need_resched())) { 9724f86d3a8SLen Brown current_thread_info()->status |= TS_POLLING; 9734f86d3a8SLen Brown local_irq_enable(); 9744f86d3a8SLen Brown return 0; 9754f86d3a8SLen Brown } 9764f86d3a8SLen Brown 977996520c1SVenki Pallipadi acpi_unlazy_tlb(smp_processor_id()); 978996520c1SVenki Pallipadi 97950629118SVenkatesh Pallipadi /* Tell the scheduler that we are going deep-idle: */ 98050629118SVenkatesh Pallipadi sched_clock_idle_sleep_event(); 9814f86d3a8SLen Brown /* 9824f86d3a8SLen Brown * Must be done before busmaster disable as we might need to 9834f86d3a8SLen Brown * access HPET ! 9844f86d3a8SLen Brown */ 9857e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 1); 9864f86d3a8SLen Brown 987f461ddeaSLen Brown kt1 = ktime_get_real(); 988c9c860e5SVenkatesh Pallipadi /* 989c9c860e5SVenkatesh Pallipadi * disable bus master 990c9c860e5SVenkatesh Pallipadi * bm_check implies we need ARB_DIS 991c9c860e5SVenkatesh Pallipadi * !bm_check implies we need cache flush 992c9c860e5SVenkatesh Pallipadi * bm_control implies whether we can do ARB_DIS 993c9c860e5SVenkatesh Pallipadi * 994c9c860e5SVenkatesh Pallipadi * That leaves a case where bm_check is set and bm_control is 995c9c860e5SVenkatesh Pallipadi * not set. In that case we cannot do much, we enter C3 996c9c860e5SVenkatesh Pallipadi * without doing anything. 997c9c860e5SVenkatesh Pallipadi */ 998c9c860e5SVenkatesh Pallipadi if (pr->flags.bm_check && pr->flags.bm_control) { 9994f86d3a8SLen Brown spin_lock(&c3_lock); 10004f86d3a8SLen Brown c3_cpu_count++; 10014f86d3a8SLen Brown /* Disable bus master arbitration when all CPUs are in C3 */ 10024f86d3a8SLen Brown if (c3_cpu_count == num_online_cpus()) 100350ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1); 10044f86d3a8SLen Brown spin_unlock(&c3_lock); 1005c9c860e5SVenkatesh Pallipadi } else if (!pr->flags.bm_check) { 1006c9c860e5SVenkatesh Pallipadi ACPI_FLUSH_CPU_CACHE(); 1007c9c860e5SVenkatesh Pallipadi } 10084f86d3a8SLen Brown 10094f86d3a8SLen Brown acpi_idle_do_entry(cx); 10104f86d3a8SLen Brown 10114f86d3a8SLen Brown /* Re-enable bus master arbitration */ 1012c9c860e5SVenkatesh Pallipadi if (pr->flags.bm_check && pr->flags.bm_control) { 1013c9c860e5SVenkatesh Pallipadi spin_lock(&c3_lock); 101450ffba1bSBob Moore acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0); 10154f86d3a8SLen Brown c3_cpu_count--; 10164f86d3a8SLen Brown spin_unlock(&c3_lock); 10174f86d3a8SLen Brown } 1018f461ddeaSLen Brown kt2 = ktime_get_real(); 1019f461ddeaSLen Brown idle_time = ktime_to_us(ktime_sub(kt2, kt1)); 10204f86d3a8SLen Brown 1021ff69f2bbSalex.shi sleep_ticks = us_to_pm_timer_ticks(idle_time); 102250629118SVenkatesh Pallipadi /* Tell the scheduler how much we idled: */ 102350629118SVenkatesh Pallipadi sched_clock_idle_wakeup_event(sleep_ticks*PM_TIMER_TICK_NS); 10244f86d3a8SLen Brown 10254f86d3a8SLen Brown local_irq_enable(); 10264f86d3a8SLen Brown current_thread_info()->status |= TS_POLLING; 10274f86d3a8SLen Brown 10284f86d3a8SLen Brown cx->usage++; 10294f86d3a8SLen Brown 10307e275cc4SLen Brown lapic_timer_state_broadcast(pr, cx, 0); 103150629118SVenkatesh Pallipadi cx->time += sleep_ticks; 1032ff69f2bbSalex.shi return idle_time; 10334f86d3a8SLen Brown } 10344f86d3a8SLen Brown 10354f86d3a8SLen Brown struct cpuidle_driver acpi_idle_driver = { 10364f86d3a8SLen Brown .name = "acpi_idle", 10374f86d3a8SLen Brown .owner = THIS_MODULE, 10384f86d3a8SLen Brown }; 10394f86d3a8SLen Brown 10404f86d3a8SLen Brown /** 10414f86d3a8SLen Brown * acpi_processor_setup_cpuidle - prepares and configures CPUIDLE 10424f86d3a8SLen Brown * @pr: the ACPI processor 10434f86d3a8SLen Brown */ 10444f86d3a8SLen Brown static int acpi_processor_setup_cpuidle(struct acpi_processor *pr) 10454f86d3a8SLen Brown { 10469a0b8415Svenkatesh.pallipadi@intel.com int i, count = CPUIDLE_DRIVER_STATE_START; 10474f86d3a8SLen Brown struct acpi_processor_cx *cx; 10484f86d3a8SLen Brown struct cpuidle_state *state; 10494f86d3a8SLen Brown struct cpuidle_device *dev = &pr->power.dev; 10504f86d3a8SLen Brown 10514f86d3a8SLen Brown if (!pr->flags.power_setup_done) 10524f86d3a8SLen Brown return -EINVAL; 10534f86d3a8SLen Brown 10544f86d3a8SLen Brown if (pr->flags.power == 0) { 10554f86d3a8SLen Brown return -EINVAL; 10564f86d3a8SLen Brown } 10574f86d3a8SLen Brown 1058dcb84f33SVenkatesh Pallipadi dev->cpu = pr->id; 10594fcb2fcdSVenkatesh Pallipadi for (i = 0; i < CPUIDLE_STATE_MAX; i++) { 10604fcb2fcdSVenkatesh Pallipadi dev->states[i].name[0] = '\0'; 10614fcb2fcdSVenkatesh Pallipadi dev->states[i].desc[0] = '\0'; 10624fcb2fcdSVenkatesh Pallipadi } 10634fcb2fcdSVenkatesh Pallipadi 1064615dfd93SLen Brown if (max_cstate == 0) 1065615dfd93SLen Brown max_cstate = 1; 1066615dfd93SLen Brown 10674f86d3a8SLen Brown for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) { 10684f86d3a8SLen Brown cx = &pr->power.states[i]; 10694f86d3a8SLen Brown state = &dev->states[count]; 10704f86d3a8SLen Brown 10714f86d3a8SLen Brown if (!cx->valid) 10724f86d3a8SLen Brown continue; 10734f86d3a8SLen Brown 10744f86d3a8SLen Brown #ifdef CONFIG_HOTPLUG_CPU 10754f86d3a8SLen Brown if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) && 10764f86d3a8SLen Brown !pr->flags.has_cst && 10774f86d3a8SLen Brown !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED)) 10784f86d3a8SLen Brown continue; 10794f86d3a8SLen Brown #endif 10804f86d3a8SLen Brown cpuidle_set_statedata(state, cx); 10814f86d3a8SLen Brown 10824f86d3a8SLen Brown snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i); 10834fcb2fcdSVenkatesh Pallipadi strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); 10844f86d3a8SLen Brown state->exit_latency = cx->latency; 10854963f620SLen Brown state->target_residency = cx->latency * latency_factor; 10864f86d3a8SLen Brown state->power_usage = cx->power; 10874f86d3a8SLen Brown 10884f86d3a8SLen Brown state->flags = 0; 10894f86d3a8SLen Brown switch (cx->type) { 10904f86d3a8SLen Brown case ACPI_STATE_C1: 10914f86d3a8SLen Brown state->flags |= CPUIDLE_FLAG_SHALLOW; 10928e92b660SVenki Pallipadi if (cx->entry_method == ACPI_CSTATE_FFH) 10939b12e18cSvenkatesh.pallipadi@intel.com state->flags |= CPUIDLE_FLAG_TIME_VALID; 10948e92b660SVenki Pallipadi 10954f86d3a8SLen Brown state->enter = acpi_idle_enter_c1; 1096ddc081a1SVenkatesh Pallipadi dev->safe_state = state; 10974f86d3a8SLen Brown break; 10984f86d3a8SLen Brown 10994f86d3a8SLen Brown case ACPI_STATE_C2: 11004f86d3a8SLen Brown state->flags |= CPUIDLE_FLAG_BALANCED; 11014f86d3a8SLen Brown state->flags |= CPUIDLE_FLAG_TIME_VALID; 11024f86d3a8SLen Brown state->enter = acpi_idle_enter_simple; 1103ddc081a1SVenkatesh Pallipadi dev->safe_state = state; 11044f86d3a8SLen Brown break; 11054f86d3a8SLen Brown 11064f86d3a8SLen Brown case ACPI_STATE_C3: 11074f86d3a8SLen Brown state->flags |= CPUIDLE_FLAG_DEEP; 11084f86d3a8SLen Brown state->flags |= CPUIDLE_FLAG_TIME_VALID; 11094f86d3a8SLen Brown state->flags |= CPUIDLE_FLAG_CHECK_BM; 11104f86d3a8SLen Brown state->enter = pr->flags.bm_check ? 11114f86d3a8SLen Brown acpi_idle_enter_bm : 11124f86d3a8SLen Brown acpi_idle_enter_simple; 11134f86d3a8SLen Brown break; 11144f86d3a8SLen Brown } 11154f86d3a8SLen Brown 11164f86d3a8SLen Brown count++; 11179a0b8415Svenkatesh.pallipadi@intel.com if (count == CPUIDLE_STATE_MAX) 11189a0b8415Svenkatesh.pallipadi@intel.com break; 11194f86d3a8SLen Brown } 11204f86d3a8SLen Brown 11214f86d3a8SLen Brown dev->state_count = count; 11224f86d3a8SLen Brown 11234f86d3a8SLen Brown if (!count) 11244f86d3a8SLen Brown return -EINVAL; 11254f86d3a8SLen Brown 11264f86d3a8SLen Brown return 0; 11274f86d3a8SLen Brown } 11284f86d3a8SLen Brown 11294f86d3a8SLen Brown int acpi_processor_cst_has_changed(struct acpi_processor *pr) 11304f86d3a8SLen Brown { 1131dcb84f33SVenkatesh Pallipadi int ret = 0; 11324f86d3a8SLen Brown 113336a91358SVenkatesh Pallipadi if (boot_option_idle_override) 113436a91358SVenkatesh Pallipadi return 0; 113536a91358SVenkatesh Pallipadi 11364f86d3a8SLen Brown if (!pr) 11374f86d3a8SLen Brown return -EINVAL; 11384f86d3a8SLen Brown 11394f86d3a8SLen Brown if (nocst) { 11404f86d3a8SLen Brown return -ENODEV; 11414f86d3a8SLen Brown } 11424f86d3a8SLen Brown 11434f86d3a8SLen Brown if (!pr->flags.power_setup_done) 11444f86d3a8SLen Brown return -ENODEV; 11454f86d3a8SLen Brown 11464f86d3a8SLen Brown cpuidle_pause_and_lock(); 11474f86d3a8SLen Brown cpuidle_disable_device(&pr->power.dev); 11484f86d3a8SLen Brown acpi_processor_get_power_info(pr); 1149dcb84f33SVenkatesh Pallipadi if (pr->flags.power) { 11504f86d3a8SLen Brown acpi_processor_setup_cpuidle(pr); 11514f86d3a8SLen Brown ret = cpuidle_enable_device(&pr->power.dev); 1152dcb84f33SVenkatesh Pallipadi } 11534f86d3a8SLen Brown cpuidle_resume_and_unlock(); 11544f86d3a8SLen Brown 11554f86d3a8SLen Brown return ret; 11564f86d3a8SLen Brown } 11574f86d3a8SLen Brown 11587af8b660SPierre Ossman int __cpuinit acpi_processor_power_init(struct acpi_processor *pr, 11594be44fcdSLen Brown struct acpi_device *device) 11601da177e4SLinus Torvalds { 11611da177e4SLinus Torvalds acpi_status status = 0; 1162b6835052SAndreas Mohr static int first_run; 11631da177e4SLinus Torvalds struct proc_dir_entry *entry = NULL; 11641da177e4SLinus Torvalds unsigned int i; 11651da177e4SLinus Torvalds 116636a91358SVenkatesh Pallipadi if (boot_option_idle_override) 116736a91358SVenkatesh Pallipadi return 0; 11681da177e4SLinus Torvalds 11691da177e4SLinus Torvalds if (!first_run) { 1170c1e3b377SZhao Yakui if (idle_halt) { 1171c1e3b377SZhao Yakui /* 1172c1e3b377SZhao Yakui * When the boot option of "idle=halt" is added, halt 1173c1e3b377SZhao Yakui * is used for CPU IDLE. 1174c1e3b377SZhao Yakui * In such case C2/C3 is meaningless. So the max_cstate 1175c1e3b377SZhao Yakui * is set to one. 1176c1e3b377SZhao Yakui */ 1177c1e3b377SZhao Yakui max_cstate = 1; 1178c1e3b377SZhao Yakui } 11791da177e4SLinus Torvalds dmi_check_system(processor_power_dmi_table); 1180c1c30634SAlexey Starikovskiy max_cstate = acpi_processor_cstate_check(max_cstate); 11811da177e4SLinus Torvalds if (max_cstate < ACPI_C_STATES_MAX) 11824be44fcdSLen Brown printk(KERN_NOTICE 11834be44fcdSLen Brown "ACPI: processor limited to max C-state %d\n", 11844be44fcdSLen Brown max_cstate); 11851da177e4SLinus Torvalds first_run++; 11861da177e4SLinus Torvalds } 11871da177e4SLinus Torvalds 118802df8b93SVenkatesh Pallipadi if (!pr) 1189d550d98dSPatrick Mochel return -EINVAL; 119002df8b93SVenkatesh Pallipadi 1191cee324b1SAlexey Starikovskiy if (acpi_gbl_FADT.cst_control && !nocst) { 11924be44fcdSLen Brown status = 1193cee324b1SAlexey Starikovskiy acpi_os_write_port(acpi_gbl_FADT.smi_command, acpi_gbl_FADT.cst_control, 8); 11941da177e4SLinus Torvalds if (ACPI_FAILURE(status)) { 1195a6fc6720SThomas Renninger ACPI_EXCEPTION((AE_INFO, status, 1196a6fc6720SThomas Renninger "Notifying BIOS of _CST ability failed")); 11971da177e4SLinus Torvalds } 11981da177e4SLinus Torvalds } 11991da177e4SLinus Torvalds 12001da177e4SLinus Torvalds acpi_processor_get_power_info(pr); 12014f86d3a8SLen Brown pr->flags.power_setup_done = 1; 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds /* 12041da177e4SLinus Torvalds * Install the idle handler if processor power management is supported. 12051da177e4SLinus Torvalds * Note that we use previously set idle handler will be used on 12061da177e4SLinus Torvalds * platforms that only support C1. 12071da177e4SLinus Torvalds */ 120836a91358SVenkatesh Pallipadi if (pr->flags.power) { 12094f86d3a8SLen Brown acpi_processor_setup_cpuidle(pr); 12104f86d3a8SLen Brown if (cpuidle_register_device(&pr->power.dev)) 12114f86d3a8SLen Brown return -EIO; 12124f86d3a8SLen Brown 12131da177e4SLinus Torvalds printk(KERN_INFO PREFIX "CPU%d (power states:", pr->id); 12141da177e4SLinus Torvalds for (i = 1; i <= pr->power.count; i++) 12151da177e4SLinus Torvalds if (pr->power.states[i].valid) 12164be44fcdSLen Brown printk(" C%d[C%d]", i, 12174be44fcdSLen Brown pr->power.states[i].type); 12181da177e4SLinus Torvalds printk(")\n"); 12191da177e4SLinus Torvalds } 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds /* 'power' [R] */ 1222cf7acfabSDenis V. Lunev entry = proc_create_data(ACPI_PROCESSOR_FILE_POWER, 1223cf7acfabSDenis V. Lunev S_IRUGO, acpi_device_dir(device), 1224cf7acfabSDenis V. Lunev &acpi_processor_power_fops, 1225cf7acfabSDenis V. Lunev acpi_driver_data(device)); 12261da177e4SLinus Torvalds if (!entry) 1227a6fc6720SThomas Renninger return -EIO; 1228d550d98dSPatrick Mochel return 0; 12291da177e4SLinus Torvalds } 12301da177e4SLinus Torvalds 12314be44fcdSLen Brown int acpi_processor_power_exit(struct acpi_processor *pr, 12324be44fcdSLen Brown struct acpi_device *device) 12331da177e4SLinus Torvalds { 123436a91358SVenkatesh Pallipadi if (boot_option_idle_override) 123536a91358SVenkatesh Pallipadi return 0; 123636a91358SVenkatesh Pallipadi 12374f86d3a8SLen Brown cpuidle_unregister_device(&pr->power.dev); 12381da177e4SLinus Torvalds pr->flags.power_setup_done = 0; 12391da177e4SLinus Torvalds 12401da177e4SLinus Torvalds if (acpi_device_dir(device)) 12414be44fcdSLen Brown remove_proc_entry(ACPI_PROCESSOR_FILE_POWER, 12424be44fcdSLen Brown acpi_device_dir(device)); 12431da177e4SLinus Torvalds 1244d550d98dSPatrick Mochel return 0; 12451da177e4SLinus Torvalds } 1246