4 files changed, 124 insertions, 69 deletions

diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index bec561c14beb..3c1a2fec8cda 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -23,7 +23,7 @@ static int set_no_mwait(const struct dmi_system_id *id)
 {
         printk(KERN_NOTICE PREFIX "%s detected - "
                 "disabling mwait for CPU C-states\n", id->ident);
-        idle_nomwait = 1;
+        boot_option_idle_override = IDLE_NOMWAIT;
         return 0;
 }
 
@@ -283,7 +283,7 @@ acpi_processor_eval_pdc(acpi_handle handle, struct acpi_object_list *pdc_in)
 {
         acpi_status status = AE_OK;
 
-        if (idle_nomwait) {
+        if (boot_option_idle_override == IDLE_NOMWAIT) {
                 /*
                  * If mwait is disabled for CPU C-states, the C2C3_FFH access
                  * mode will be disabled in the parameter of _PDC object.
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index a765b823aa9e..d615b7d69bca 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -79,6 +79,13 @@ module_param(bm_check_disable, uint, 0000);
 static unsigned int latency_factor __read_mostly = 2;
 module_param(latency_factor, uint, 0644);
 
+static int disabled_by_idle_boot_param(void)
+{
+        return boot_option_idle_override == IDLE_POLL ||
+                boot_option_idle_override == IDLE_FORCE_MWAIT ||
+                boot_option_idle_override == IDLE_HALT;
+}
+
 /*
  * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
  * For now disable this. Probably a bug somewhere else.
@@ -455,7 +462,7 @@ static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
                                 continue;
                         }
                         if (cx.type == ACPI_STATE_C1 &&
-                                        (idle_halt || idle_nomwait)) {
+                            (boot_option_idle_override == IDLE_NOMWAIT)) {
                                 /*
                                  * In most cases the C1 space_id obtained from
                                  * _CST object is FIXED_HARDWARE access mode.
@@ -1016,7 +1023,6 @@ static int acpi_processor_setup_cpuidle(struct acpi_processor *pr)
                 state->flags = 0;
                 switch (cx->type) {
                         case ACPI_STATE_C1:
-                        state->flags |= CPUIDLE_FLAG_SHALLOW;
                         if (cx->entry_method == ACPI_CSTATE_FFH)
                                 state->flags |= CPUIDLE_FLAG_TIME_VALID;
 
@@ -1025,16 +1031,13 @@ static int acpi_processor_setup_cpuidle(struct acpi_processor *pr)
                         break;
 
                         case ACPI_STATE_C2:
-                        state->flags |= CPUIDLE_FLAG_BALANCED;
                         state->flags |= CPUIDLE_FLAG_TIME_VALID;
                         state->enter = acpi_idle_enter_simple;
                         dev->safe_state = state;
                         break;
 
                         case ACPI_STATE_C3:
-                        state->flags |= CPUIDLE_FLAG_DEEP;
                         state->flags |= CPUIDLE_FLAG_TIME_VALID;
-                        state->flags |= CPUIDLE_FLAG_CHECK_BM;
                         state->enter = pr->flags.bm_check ?
                                         acpi_idle_enter_bm :
                                         acpi_idle_enter_simple;
@@ -1058,7 +1061,7 @@ int acpi_processor_cst_has_changed(struct acpi_processor *pr)
 {
         int ret = 0;
 
-        if (boot_option_idle_override)
+        if (disabled_by_idle_boot_param())
                 return 0;
 
         if (!pr)
@@ -1089,19 +1092,10 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
         acpi_status status = 0;
         static int first_run;
 
-        if (boot_option_idle_override)
+        if (disabled_by_idle_boot_param())
                 return 0;
 
         if (!first_run) {
-                if (idle_halt) {
-                        /*
-                         * When the boot option of "idle=halt" is added, halt
-                         * is used for CPU IDLE.
-                         * In such case C2/C3 is meaningless. So the max_cstate
-                         * is set to one.
-                         */
-                        max_cstate = 1;
-                }
                 dmi_check_system(processor_power_dmi_table);
                 max_cstate = acpi_processor_cstate_check(max_cstate);
                 if (max_cstate < ACPI_C_STATES_MAX)
@@ -1142,7 +1136,7 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
 int acpi_processor_power_exit(struct acpi_processor *pr,
                               struct acpi_device *device)
 {
-        if (boot_option_idle_override)
+        if (disabled_by_idle_boot_param())
                 return 0;
 
         cpuidle_unregister_device(&pr->power.dev);
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c
index 386888f10df0..bf5092455a8f 100644
--- a/drivers/cpuidle/cpuidle.c
+++ b/drivers/cpuidle/cpuidle.c
@@ -96,7 +96,15 @@ static void cpuidle_idle_call(void)
 
         /* enter the state and update stats */
         dev->last_state = target_state;
+
+        trace_power_start(POWER_CSTATE, next_state, dev->cpu);
+        trace_cpu_idle(next_state, dev->cpu);
+
         dev->last_residency = target_state->enter(dev, target_state);
+
+        trace_power_end(dev->cpu);
+        trace_cpu_idle(PWR_EVENT_EXIT, dev->cpu);
+
         if (dev->last_state)
                 target_state = dev->last_state;
 
@@ -106,8 +114,6 @@ static void cpuidle_idle_call(void)
         /* give the governor an opportunity to reflect on the outcome */
         if (cpuidle_curr_governor->reflect)
                 cpuidle_curr_governor->reflect(dev);
-        trace_power_end(smp_processor_id());
-        trace_cpu_idle(PWR_EVENT_EXIT, smp_processor_id());
 }
 
 /**
@@ -155,6 +161,45 @@ void cpuidle_resume_and_unlock(void)
 
 EXPORT_SYMBOL_GPL(cpuidle_resume_and_unlock);
 
+#ifdef CONFIG_ARCH_HAS_CPU_RELAX
+static int poll_idle(struct cpuidle_device *dev, struct cpuidle_state *st)
+{
+        ktime_t t1, t2;
+        s64 diff;
+        int ret;
+
+        t1 = ktime_get();
+        local_irq_enable();
+        while (!need_resched())
+                cpu_relax();
+
+        t2 = ktime_get();
+        diff = ktime_to_us(ktime_sub(t2, t1));
+        if (diff > INT_MAX)
+                diff = INT_MAX;
+
+        ret = (int) diff;
+        return ret;
+}
+
+static void poll_idle_init(struct cpuidle_device *dev)
+{
+        struct cpuidle_state *state = &dev->states[0];
+
+        cpuidle_set_statedata(state, NULL);
+
+        snprintf(state->name, CPUIDLE_NAME_LEN, "POLL");
+        snprintf(state->desc, CPUIDLE_DESC_LEN, "CPUIDLE CORE POLL IDLE");
+        state->exit_latency = 0;
+        state->target_residency = 0;
+        state->power_usage = -1;
+        state->flags = 0;
+        state->enter = poll_idle;
+}
+#else
+static void poll_idle_init(struct cpuidle_device *dev) {}
+#endif /* CONFIG_ARCH_HAS_CPU_RELAX */
+
 /**
  * cpuidle_enable_device - enables idle PM for a CPU
  * @dev: the CPU
@@ -179,6 +224,8 @@ int cpuidle_enable_device(struct cpuidle_device *dev)
                         return ret;
         }
 
+        poll_idle_init(dev);
+
         if ((ret = cpuidle_add_state_sysfs(dev)))
                 return ret;
 
@@ -233,45 +280,6 @@ void cpuidle_disable_device(struct cpuidle_device *dev)
 
 EXPORT_SYMBOL_GPL(cpuidle_disable_device);
 
-#ifdef CONFIG_ARCH_HAS_CPU_RELAX
-static int poll_idle(struct cpuidle_device *dev, struct cpuidle_state *st)
-{
-        ktime_t t1, t2;
-        s64 diff;
-        int ret;
-
-        t1 = ktime_get();
-        local_irq_enable();
-        while (!need_resched())
-                cpu_relax();
-
-        t2 = ktime_get();
-        diff = ktime_to_us(ktime_sub(t2, t1));
-        if (diff > INT_MAX)
-                diff = INT_MAX;
-
-        ret = (int) diff;
-        return ret;
-}
-
-static void poll_idle_init(struct cpuidle_device *dev)
-{
-        struct cpuidle_state *state = &dev->states[0];
-
-        cpuidle_set_statedata(state, NULL);
-
-        snprintf(state->name, CPUIDLE_NAME_LEN, "C0");
-        snprintf(state->desc, CPUIDLE_DESC_LEN, "CPUIDLE CORE POLL IDLE");
-        state->exit_latency = 0;
-        state->target_residency = 0;
-        state->power_usage = -1;
-        state->flags = CPUIDLE_FLAG_POLL;
-        state->enter = poll_idle;
-}
-#else
-static void poll_idle_init(struct cpuidle_device *dev) {}
-#endif /* CONFIG_ARCH_HAS_CPU_RELAX */
-
 /**
  * __cpuidle_register_device - internal register function called before register
  * and enable routines
@@ -292,8 +300,6 @@ static int __cpuidle_register_device(struct cpuidle_device *dev)
 
         init_completion(&dev->kobj_unregister);
 
-        poll_idle_init(dev);
-
         /*
          * cpuidle driver should set the dev->power_specified bit
          * before registering the device if the driver provides
diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
index 56ac09d6c930..7acb32e7f817 100644
--- a/drivers/idle/intel_idle.c
+++ b/drivers/idle/intel_idle.c
@@ -59,6 +59,8 @@
 #include <linux/hrtimer.h>      /* ktime_get_real() */
 #include <trace/events/power.h>
 #include <linux/sched.h>
+#include <linux/notifier.h>
+#include <linux/cpu.h>
 #include <asm/mwait.h>
 
 #define INTEL_IDLE_VERSION "0.4"
@@ -73,6 +75,7 @@ static int max_cstate = MWAIT_MAX_NUM_CSTATES - 1;
 
 static unsigned int mwait_substates;
 
+#define LAPIC_TIMER_ALWAYS_RELIABLE 0xFFFFFFFF
 /* Reliable LAPIC Timer States, bit 1 for C1 etc.  */
 static unsigned int lapic_timer_reliable_states = (1 << 1);      /* Default to only C1 */
 
@@ -82,6 +85,14 @@ static int intel_idle(struct cpuidle_device *dev, struct cpuidle_state *state);
 static struct cpuidle_state *cpuidle_state_table;
 
 /*
+ * Set this flag for states where the HW flushes the TLB for us
+ * and so we don't need cross-calls to keep it consistent.
+ * If this flag is set, SW flushes the TLB, so even if the
+ * HW doesn't do the flushing, this flag is safe to use.
+ */
+#define CPUIDLE_FLAG_TLB_FLUSHED        0x10000
+
+/*
  * States are indexed by the cstate number,
  * which is also the index into the MWAIT hint array.
  * Thus C0 is a dummy.
@@ -122,7 +133,7 @@ static struct cpuidle_state snb_cstates[MWAIT_MAX_NUM_CSTATES] = {
                 .driver_data = (void *) 0x00,
                 .flags = CPUIDLE_FLAG_TIME_VALID,
                 .exit_latency = 1,
-                .target_residency = 4,
+                .target_residency = 1,
                 .enter = &intel_idle },
         { /* MWAIT C2 */
                 .name = "SNB-C3",
@@ -130,7 +141,7 @@ static struct cpuidle_state snb_cstates[MWAIT_MAX_NUM_CSTATES] = {
                 .driver_data = (void *) 0x10,
                 .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 80,
-                .target_residency = 160,
+                .target_residency = 211,
                 .enter = &intel_idle },
         { /* MWAIT C3 */
                 .name = "SNB-C6",
@@ -138,7 +149,7 @@ static struct cpuidle_state snb_cstates[MWAIT_MAX_NUM_CSTATES] = {
                 .driver_data = (void *) 0x20,
                 .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 104,
-                .target_residency = 208,
+                .target_residency = 345,
                 .enter = &intel_idle },
         { /* MWAIT C4 */
                 .name = "SNB-C7",
@@ -146,7 +157,7 @@ static struct cpuidle_state snb_cstates[MWAIT_MAX_NUM_CSTATES] = {
                 .driver_data = (void *) 0x30,
                 .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
                 .exit_latency = 109,
-                .target_residency = 300,
+                .target_residency = 345,
                 .enter = &intel_idle },
 };
 
@@ -220,8 +231,6 @@ static int intel_idle(struct cpuidle_device *dev, struct cpuidle_state *state)
         kt_before = ktime_get_real();
 
         stop_critical_timings();
-        trace_power_start(POWER_CSTATE, (eax >> 4) + 1, cpu);
-        trace_cpu_idle((eax >> 4) + 1, cpu);
         if (!need_resched()) {
 
                 __monitor((void *)&current_thread_info()->flags, 0, 0);
@@ -243,6 +252,39 @@ static int intel_idle(struct cpuidle_device *dev, struct cpuidle_state *state)
         return usec_delta;
 }
 
+static void __setup_broadcast_timer(void *arg)
+{
+        unsigned long reason = (unsigned long)arg;
+        int cpu = smp_processor_id();
+
+        reason = reason ?
+                CLOCK_EVT_NOTIFY_BROADCAST_ON : CLOCK_EVT_NOTIFY_BROADCAST_OFF;
+
+        clockevents_notify(reason, &cpu);
+}
+
+static int __cpuinit setup_broadcast_cpuhp_notify(struct notifier_block *n,
+                unsigned long action, void *hcpu)
+{
+        int hotcpu = (unsigned long)hcpu;
+
+        switch (action & 0xf) {
+        case CPU_ONLINE:
+                smp_call_function_single(hotcpu, __setup_broadcast_timer,
+                        (void *)true, 1);
+                break;
+        case CPU_DOWN_PREPARE:
+                smp_call_function_single(hotcpu, __setup_broadcast_timer,
+                        (void *)false, 1);
+                break;
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block __cpuinitdata setup_broadcast_notifier = {
+        .notifier_call = setup_broadcast_cpuhp_notify,
+};
+
 /*
  * intel_idle_probe()
  */
@@ -305,7 +347,11 @@ static int intel_idle_probe(void)
         }
 
         if (boot_cpu_has(X86_FEATURE_ARAT))     /* Always Reliable APIC Timer */
-                lapic_timer_reliable_states = 0xFFFFFFFF;
+                lapic_timer_reliable_states = LAPIC_TIMER_ALWAYS_RELIABLE;
+        else {
+                smp_call_function(__setup_broadcast_timer, (void *)true, 1);
+                register_cpu_notifier(&setup_broadcast_notifier);
+        }
 
         pr_debug(PREFIX "v" INTEL_IDLE_VERSION
                 " model 0x%X\n", boot_cpu_data.x86_model);
@@ -403,6 +449,10 @@ static int __init intel_idle_init(void)
 {
         int retval;
 
+        /* Do not load intel_idle at all for now if idle= is passed */
+        if (boot_option_idle_override != IDLE_NO_OVERRIDE)
+                return -ENODEV;
+
         retval = intel_idle_probe();
         if (retval)
                 return retval;
@@ -428,6 +478,11 @@ static void __exit intel_idle_exit(void)
         intel_idle_cpuidle_devices_uninit();
         cpuidle_unregister_driver(&intel_idle_driver);
 
+        if (lapic_timer_reliable_states != LAPIC_TIMER_ALWAYS_RELIABLE) {
+                smp_call_function(__setup_broadcast_timer, (void *)false, 1);
+                unregister_cpu_notifier(&setup_broadcast_notifier);
+        }
+
         return;
 }