cpuidle: consolidate 2.6.22 cpuidle branch into one patch

author Len Brown <len.brown@intel.com>

Wed, 3 Oct 2007 22:58:00 +0000 (18:58 -0400)

committer Len Brown <len.brown@intel.com>

Wed, 10 Oct 2007 04:12:41 +0000 (00:12 -0400)
author Len Brown <len.brown@intel.com>
Wed, 3 Oct 2007 22:58:00 +0000 (18:58 -0400)
committer Len Brown <len.brown@intel.com>
Wed, 10 Oct 2007 04:12:41 +0000 (00:12 -0400)
diff --git a/arch/i386/Kconfig b/arch/i386/Kconfig

index 97b64d7..3328e0a 100644 (file)
--- a/arch/i386/Kconfig
+++ b/arch/i386/Kconfig
@@ -1069,6 +1069,8 @@ endif # APM
  
  source "arch/i386/kernel/cpu/cpufreq/Kconfig"
  
+source "drivers/cpuidle/Kconfig"
+
  endmenu
  
  menu "Bus options (PCI, PCMCIA, EISA, MCA, ISA)"
diff --git a/arch/x86_64/Kconfig b/arch/x86_64/Kconfig

index b4d9089..e8dbb37 100644 (file)
--- a/arch/x86_64/Kconfig
+++ b/arch/x86_64/Kconfig
@@ -706,6 +706,8 @@ source "drivers/acpi/Kconfig"
  
  source "arch/x86_64/kernel/cpufreq/Kconfig"
  
+source "drivers/cpuidle/Kconfig"
+
  endmenu
  
  menu "Bus options (PCI etc.)"
diff --git a/drivers/Makefile b/drivers/Makefile

index f0878b2..10a9c52 100644 (file)
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -76,6 +76,7 @@ obj-$(CONFIG_MCA)             += mca/
  obj-$(CONFIG_EISA)             += eisa/
  obj-$(CONFIG_LGUEST_GUEST)     += lguest/
  obj-$(CONFIG_CPU_FREQ)         += cpufreq/
+obj-$(CONFIG_CPU_IDLE)         += cpuidle/
  obj-$(CONFIG_MMC)              += mmc/
  obj-$(CONFIG_NEW_LEDS)         += leds/
  obj-$(CONFIG_INFINIBAND)       += infiniband/
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c

index 12c09fa..5d14d4f 100644 (file)
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -1042,14 +1042,6 @@ static int __init acpi_wake_gpes_always_on_setup(char *str)
  
  __setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup);
  
-/*
- * max_cstate is defined in the base kernel so modules can
- * change it w/o depending on the state of the processor module.
- */
-unsigned int max_cstate = ACPI_PROCESSOR_MAX_POWER;
-
-EXPORT_SYMBOL(max_cstate);
-
  /*
   * Acquire a spinlock.
   *
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c

index 9f11dc2..a735108 100644 (file)
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -44,6 +44,7 @@
  #include <linux/seq_file.h>
  #include <linux/dmi.h>
  #include <linux/moduleparam.h>
+#include <linux/cpuidle.h>
  
  #include <asm/io.h>
  #include <asm/system.h>
@@ -1049,11 +1050,13 @@ static int __init acpi_processor_init(void)
                 return -ENOMEM;
         acpi_processor_dir->owner = THIS_MODULE;
  
+       result = cpuidle_register_driver(&acpi_idle_driver);
+       if (result < 0)
+               goto out_proc;
+
         result = acpi_bus_register_driver(&acpi_processor_driver);
-       if (result < 0) {
-               remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
-               return result;
-       }
+       if (result < 0)
+               goto out_cpuidle;
  
         acpi_processor_install_hotplug_notify();
  
@@ -1062,11 +1065,18 @@ static int __init acpi_processor_init(void)
         acpi_processor_ppc_init();
  
         return 0;
+
+out_cpuidle:
+       cpuidle_unregister_driver(&acpi_idle_driver);
+
+out_proc:
+       remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
+
+       return result;
  }
  
  static void __exit acpi_processor_exit(void)
  {
-
         acpi_processor_ppc_exit();
  
         acpi_thermal_cpufreq_exit();
@@ -1075,6 +1085,8 @@ static void __exit acpi_processor_exit(void)
  
         acpi_bus_unregister_driver(&acpi_processor_driver);
  
+       cpuidle_unregister_driver(&acpi_idle_driver);
+
         remove_proc_entry(ACPI_PROCESSOR_CLASS, acpi_root_dir);
  
         return;
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c

index f182613..99da6a7 100644 (file)
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -40,6 +40,7 @@
  #include <linux/sched.h>       /* need_resched() */
  #include <linux/latency.h>
  #include <linux/clockchips.h>
+#include <linux/cpuidle.h>
  
  /*
   * Include the apic definitions for x86 to have the APIC timer related defines
@@ -64,14 +65,22 @@ ACPI_MODULE_NAME("processor_idle");
  #define ACPI_PROCESSOR_FILE_POWER      "power"
  #define US_TO_PM_TIMER_TICKS(t)                ((t * (PM_TIMER_FREQUENCY/1000)) / 1000)
  #define PM_TIMER_TICK_NS               (1000000000ULL/PM_TIMER_FREQUENCY)
+#ifndef CONFIG_CPU_IDLE
  #define C2_OVERHEAD                    4       /* 1us (3.579 ticks per us) */
  #define C3_OVERHEAD                    4       /* 1us (3.579 ticks per us) */
  static void (*pm_idle_save) (void) __read_mostly;
-module_param(max_cstate, uint, 0644);
+#else
+#define C2_OVERHEAD                    1       /* 1us */
+#define C3_OVERHEAD                    1       /* 1us */
+#endif
+#define PM_TIMER_TICKS_TO_US(p)                (((p) * 1000)/(PM_TIMER_FREQUENCY/1000))
  
+static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER;
+module_param(max_cstate, uint, 0000);
  static unsigned int nocst __read_mostly;
  module_param(nocst, uint, 0000);
  
+#ifndef CONFIG_CPU_IDLE
  /*
   * bm_history -- bit-mask with a bit per jiffy of bus-master activity
   * 1000 HZ: 0xFFFFFFFF: 32 jiffies = 32ms
@@ -82,9 +91,10 @@ module_param(nocst, uint, 0000);
  static unsigned int bm_history __read_mostly =
      (HZ >= 800 ? 0xFFFFFFFF : ((1U << (HZ / 25)) - 1));
  module_param(bm_history, uint, 0644);
-/* --------------------------------------------------------------------------
-                                Power Management
-   -------------------------------------------------------------------------- */
+
+static int acpi_processor_set_power_policy(struct acpi_processor *pr);
+
+#endif
  
  /*
   * IBM ThinkPad R40e crashes mysteriously when going into C2 or C3.
@@ -177,6 +187,18 @@ static inline u32 ticks_elapsed(u32 t1, u32 t2)
                 return ((0xFFFFFFFF - t1) + t2);
  }
  
+static inline u32 ticks_elapsed_in_us(u32 t1, u32 t2)
+{
+       if (t2 >= t1)
+               return PM_TIMER_TICKS_TO_US(t2 - t1);
+       else if (!(acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER))
+               return PM_TIMER_TICKS_TO_US(((0x00FFFFFF - t1) + t2) & 0x00FFFFFF);
+       else
+               return PM_TIMER_TICKS_TO_US((0xFFFFFFFF - t1) + t2);
+}
+
+#ifndef CONFIG_CPU_IDLE
+
  static void
  acpi_processor_power_activate(struct acpi_processor *pr,
                               struct acpi_processor_cx *new)
@@ -248,6 +270,7 @@ static void acpi_cstate_enter(struct acpi_processor_cx *cstate)
                 unused = inl(acpi_gbl_FADT.xpm_timer_block.address);
         }
  }
+#endif /* !CONFIG_CPU_IDLE */
  
  #ifdef ARCH_APICTIMER_STOPS_ON_C3
  
@@ -342,6 +365,7 @@ int acpi_processor_resume(struct acpi_device * device)
         return 0;
  }
  
+#ifndef CONFIG_CPU_IDLE
  static void acpi_processor_idle(void)
  {
         struct acpi_processor *pr = NULL;
@@ -439,7 +463,7 @@ static void acpi_processor_idle(void)
          * an SMP system. We do it here instead of doing it at _CST/P_LVL
          * detection phase, to work cleanly with logical CPU hotplug.
          */
-       if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) && 
+       if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
             !pr->flags.has_cst && !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
                 cx = &pr->power.states[ACPI_STATE_C1];
  #endif
@@ -739,6 +763,7 @@ static int acpi_processor_set_power_policy(struct acpi_processor *pr)
  
         return 0;
  }
+#endif /* !CONFIG_CPU_IDLE */
  
  static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
  {
@@ -756,7 +781,7 @@ static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
  #ifndef CONFIG_HOTPLUG_CPU
         /*
          * Check for P_LVL2_UP flag before entering C2 and above on
-        * an SMP system. 
+        * an SMP system.
          */
         if ((num_online_cpus() > 1) &&
             !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
@@ -957,7 +982,12 @@ static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx)
          * Normalize the C2 latency to expidite policy
          */
         cx->valid = 1;
+
+#ifndef CONFIG_CPU_IDLE
         cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);
+#else
+       cx->latency_ticks = cx->latency;
+#endif
  
         return;
  }
@@ -1037,7 +1067,12 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
          * use this in our C3 policy
          */
         cx->valid = 1;
+
+#ifndef CONFIG_CPU_IDLE
         cx->latency_ticks = US_TO_PM_TIMER_TICKS(cx->latency);
+#else
+       cx->latency_ticks = cx->latency;
+#endif
  
         return;
  }
@@ -1102,6 +1137,7 @@ static int acpi_processor_get_power_info(struct acpi_processor *pr)
  
         pr->power.count = acpi_processor_power_verify(pr);
  
+#ifndef CONFIG_CPU_IDLE
         /*
          * Set Default Policy
          * ------------------
@@ -1113,6 +1149,7 @@ static int acpi_processor_get_power_info(struct acpi_processor *pr)
         result = acpi_processor_set_power_policy(pr);
         if (result)
                 return result;
+#endif
  
         /*
          * if one state of type C2 or C3 is available, mark this
@@ -1129,35 +1166,6 @@ static int acpi_processor_get_power_info(struct acpi_processor *pr)
         return 0;
  }
  
-int acpi_processor_cst_has_changed(struct acpi_processor *pr)
-{
-       int result = 0;
-
-
-       if (!pr)
-               return -EINVAL;
-
-       if (nocst) {
-               return -ENODEV;
-       }
-
-       if (!pr->flags.power_setup_done)
-               return -ENODEV;
-
-       /* Fall back to the default idle loop */
-       pm_idle = pm_idle_save;
-       synchronize_sched();    /* Relies on interrupts forcing exit from idle. */
-
-       pr->flags.power = 0;
-       result = acpi_processor_get_power_info(pr);
-       if ((pr->flags.power == 1) && (pr->flags.power_setup_done))
-               pm_idle = acpi_processor_idle;
-
-       return result;
-}
-
-/* proc interface */
-
  static int acpi_processor_power_seq_show(struct seq_file *seq, void *offset)
  {
         struct acpi_processor *pr = seq->private;
@@ -1239,6 +1247,35 @@ static const struct file_operations acpi_processor_power_fops = {
         .release = single_release,
  };
  
+#ifndef CONFIG_CPU_IDLE
+
+int acpi_processor_cst_has_changed(struct acpi_processor *pr)
+{
+       int result = 0;
+
+
+       if (!pr)
+               return -EINVAL;
+
+       if (nocst) {
+               return -ENODEV;
+       }
+
+       if (!pr->flags.power_setup_done)
+               return -ENODEV;
+
+       /* Fall back to the default idle loop */
+       pm_idle = pm_idle_save;
+       synchronize_sched();    /* Relies on interrupts forcing exit from idle. */
+
+       pr->flags.power = 0;
+       result = acpi_processor_get_power_info(pr);
+       if ((pr->flags.power == 1) && (pr->flags.power_setup_done))
+               pm_idle = acpi_processor_idle;
+
+       return result;
+}
+
  #ifdef CONFIG_SMP
  static void smp_callback(void *v)
  {
@@ -1261,7 +1298,360 @@ static int acpi_processor_latency_notify(struct notifier_block *b,
  static struct notifier_block acpi_processor_latency_notifier = {
         .notifier_call = acpi_processor_latency_notify,
  };
+
+#endif
+
+#else /* CONFIG_CPU_IDLE */
+
+/**
+ * acpi_idle_bm_check - checks if bus master activity was detected
+ */
+static int acpi_idle_bm_check(void)
+{
+       u32 bm_status = 0;
+
+       acpi_get_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status);
+       if (bm_status)
+               acpi_set_register(ACPI_BITREG_BUS_MASTER_STATUS, 1);
+       /*
+        * PIIX4 Erratum #18: Note that BM_STS doesn't always reflect
+        * the true state of bus mastering activity; forcing us to
+        * manually check the BMIDEA bit of each IDE channel.
+        */
+       else if (errata.piix4.bmisx) {
+               if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
+                   || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
+                       bm_status = 1;
+       }
+       return bm_status;
+}
+
+/**
+ * acpi_idle_update_bm_rld - updates the BM_RLD bit depending on target state
+ * @pr: the processor
+ * @target: the new target state
+ */
+static inline void acpi_idle_update_bm_rld(struct acpi_processor *pr,
+                                          struct acpi_processor_cx *target)
+{
+       if (pr->flags.bm_rld_set && target->type != ACPI_STATE_C3) {
+               acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 0);
+               pr->flags.bm_rld_set = 0;
+       }
+
+       if (!pr->flags.bm_rld_set && target->type == ACPI_STATE_C3) {
+               acpi_set_register(ACPI_BITREG_BUS_MASTER_RLD, 1);
+               pr->flags.bm_rld_set = 1;
+       }
+}
+
+/**
+ * acpi_idle_do_entry - a helper function that does C2 and C3 type entry
+ * @cx: cstate data
+ */
+static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx)
+{
+       if (cx->space_id == ACPI_CSTATE_FFH) {
+               /* Call into architectural FFH based C-state */
+               acpi_processor_ffh_cstate_enter(cx);
+       } else {
+               int unused;
+               /* IO port based C-state */
+               inb(cx->address);
+               /* Dummy wait op - must do something useless after P_LVL2 read
+                  because chipsets cannot guarantee that STPCLK# signal
+                  gets asserted in time to freeze execution properly. */
+               unused = inl(acpi_gbl_FADT.xpm_timer_block.address);
+       }
+}
+
+/**
+ * acpi_idle_enter_c1 - enters an ACPI C1 state-type
+ * @dev: the target CPU
+ * @state: the state data
+ *
+ * This is equivalent to the HALT instruction.
+ */
+static int acpi_idle_enter_c1(struct cpuidle_device *dev,
+                             struct cpuidle_state *state)
+{
+       struct acpi_processor *pr;
+       struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
+       pr = processors[smp_processor_id()];
+
+       if (unlikely(!pr))
+               return 0;
+
+       if (pr->flags.bm_check)
+               acpi_idle_update_bm_rld(pr, cx);
+
+       current_thread_info()->status &= ~TS_POLLING;
+       /*
+        * TS_POLLING-cleared state must be visible before we test
+        * NEED_RESCHED:
+        */
+       smp_mb();
+       if (!need_resched())
+               safe_halt();
+       current_thread_info()->status |= TS_POLLING;
+
+       cx->usage++;
+
+       return 0;
+}
+
+/**
+ * acpi_idle_enter_simple - enters an ACPI state without BM handling
+ * @dev: the target CPU
+ * @state: the state data
+ */
+static int acpi_idle_enter_simple(struct cpuidle_device *dev,
+                                 struct cpuidle_state *state)
+{
+       struct acpi_processor *pr;
+       struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
+       u32 t1, t2;
+       pr = processors[smp_processor_id()];
+
+       if (unlikely(!pr))
+               return 0;
+
+       if (pr->flags.bm_check)
+               acpi_idle_update_bm_rld(pr, cx);
+
+       local_irq_disable();
+       current_thread_info()->status &= ~TS_POLLING;
+       /*
+        * TS_POLLING-cleared state must be visible before we test
+        * NEED_RESCHED:
+        */
+       smp_mb();
+
+       if (unlikely(need_resched())) {
+               current_thread_info()->status |= TS_POLLING;
+               local_irq_enable();
+               return 0;
+       }
+
+       if (cx->type == ACPI_STATE_C3)
+               ACPI_FLUSH_CPU_CACHE();
+
+       t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+       acpi_state_timer_broadcast(pr, cx, 1);
+       acpi_idle_do_entry(cx);
+       t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+
+#if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86_TSC)
+       /* TSC could halt in idle, so notify users */
+       mark_tsc_unstable("TSC halts in idle");;
+#endif
+
+       local_irq_enable();
+       current_thread_info()->status |= TS_POLLING;
+
+       cx->usage++;
+
+       acpi_state_timer_broadcast(pr, cx, 0);
+       cx->time += ticks_elapsed(t1, t2);
+       return ticks_elapsed_in_us(t1, t2);
+}
+
+static int c3_cpu_count;
+static DEFINE_SPINLOCK(c3_lock);
+
+/**
+ * acpi_idle_enter_bm - enters C3 with proper BM handling
+ * @dev: the target CPU
+ * @state: the state data
+ *
+ * If BM is detected, the deepest non-C3 idle state is entered instead.
+ */
+static int acpi_idle_enter_bm(struct cpuidle_device *dev,
+                             struct cpuidle_state *state)
+{
+       struct acpi_processor *pr;
+       struct acpi_processor_cx *cx = cpuidle_get_statedata(state);
+       u32 t1, t2;
+       pr = processors[smp_processor_id()];
+
+       if (unlikely(!pr))
+               return 0;
+
+       local_irq_disable();
+       current_thread_info()->status &= ~TS_POLLING;
+       /*
+        * TS_POLLING-cleared state must be visible before we test
+        * NEED_RESCHED:
+        */
+       smp_mb();
+
+       if (unlikely(need_resched())) {
+               current_thread_info()->status |= TS_POLLING;
+               local_irq_enable();
+               return 0;
+       }
+
+       /*
+        * Must be done before busmaster disable as we might need to
+        * access HPET !
+        */
+       acpi_state_timer_broadcast(pr, cx, 1);
+
+       if (acpi_idle_bm_check()) {
+               cx = pr->power.bm_state;
+
+               acpi_idle_update_bm_rld(pr, cx);
+
+               t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+               acpi_idle_do_entry(cx);
+               t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+       } else {
+               acpi_idle_update_bm_rld(pr, cx);
+
+               spin_lock(&c3_lock);
+               c3_cpu_count++;
+               /* Disable bus master arbitration when all CPUs are in C3 */
+               if (c3_cpu_count == num_online_cpus())
+                       acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1);
+               spin_unlock(&c3_lock);
+
+               t1 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+               acpi_idle_do_entry(cx);
+               t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
+
+               spin_lock(&c3_lock);
+               /* Re-enable bus master arbitration */
+               if (c3_cpu_count == num_online_cpus())
+                       acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0);
+               c3_cpu_count--;
+               spin_unlock(&c3_lock);
+       }
+
+#if defined (CONFIG_GENERIC_TIME) && defined (CONFIG_X86_TSC)
+       /* TSC could halt in idle, so notify users */
+       mark_tsc_unstable("TSC halts in idle");
+#endif
+
+       local_irq_enable();
+       current_thread_info()->status |= TS_POLLING;
+
+       cx->usage++;
+
+       acpi_state_timer_broadcast(pr, cx, 0);
+       cx->time += ticks_elapsed(t1, t2);
+       return ticks_elapsed_in_us(t1, t2);
+}
+
+struct cpuidle_driver acpi_idle_driver = {
+       .name =         "acpi_idle",
+       .owner =        THIS_MODULE,
+};
+
+/**
+ * acpi_processor_setup_cpuidle - prepares and configures CPUIDLE
+ * @pr: the ACPI processor
+ */
+static int acpi_processor_setup_cpuidle(struct acpi_processor *pr)
+{
+       int i, count = 0;
+       struct acpi_processor_cx *cx;
+       struct cpuidle_state *state;
+       struct cpuidle_device *dev = &pr->power.dev;
+
+       if (!pr->flags.power_setup_done)
+               return -EINVAL;
+
+       if (pr->flags.power == 0) {
+               return -EINVAL;
+       }
+
+       for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
+               cx = &pr->power.states[i];
+               state = &dev->states[count];
+
+               if (!cx->valid)
+                       continue;
+
+#ifdef CONFIG_HOTPLUG_CPU
+               if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
+                   !pr->flags.has_cst &&
+                   !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
+                       continue;
  #endif
+               cpuidle_set_statedata(state, cx);
+
+               snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i);
+               state->exit_latency = cx->latency;
+               state->target_residency = cx->latency * 6;
+               state->power_usage = cx->power;
+
+               state->flags = 0;
+               switch (cx->type) {
+                       case ACPI_STATE_C1:
+                       state->flags |= CPUIDLE_FLAG_SHALLOW;
+                       state->enter = acpi_idle_enter_c1;
+                       break;
+
+                       case ACPI_STATE_C2:
+                       state->flags |= CPUIDLE_FLAG_BALANCED;
+                       state->flags |= CPUIDLE_FLAG_TIME_VALID;
+                       state->enter = acpi_idle_enter_simple;
+                       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;
+                       break;
+               }
+
+               count++;
+       }
+
+       dev->state_count = count;
+
+       if (!count)
+               return -EINVAL;
+
+       /* find the deepest state that can handle active BM */
+       if (pr->flags.bm_check) {
+               for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++)
+                       if (pr->power.states[i].type == ACPI_STATE_C3)
+                               break;
+               pr->power.bm_state = &pr->power.states[i-1];
+       }
+
+       return 0;
+}
+
+int acpi_processor_cst_has_changed(struct acpi_processor *pr)
+{
+       int ret;
+
+       if (!pr)
+               return -EINVAL;
+
+       if (nocst) {
+               return -ENODEV;
+       }
+
+       if (!pr->flags.power_setup_done)
+               return -ENODEV;
+
+       cpuidle_pause_and_lock();
+       cpuidle_disable_device(&pr->power.dev);
+       acpi_processor_get_power_info(pr);
+       acpi_processor_setup_cpuidle(pr);
+       ret = cpuidle_enable_device(&pr->power.dev);
+       cpuidle_resume_and_unlock();
+
+       return ret;
+}
+
+#endif /* CONFIG_CPU_IDLE */
  
  int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
                               struct acpi_device *device)
@@ -1279,7 +1669,7 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
                                "ACPI: processor limited to max C-state %d\n",
                                max_cstate);
                 first_run++;
-#ifdef CONFIG_SMP
+#if !defined (CONFIG_CPU_IDLE) && defined (CONFIG_SMP)
                 register_latency_notifier(&acpi_processor_latency_notifier);
  #endif
         }
@@ -1297,6 +1687,7 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
         }
  
         acpi_processor_get_power_info(pr);
+       pr->flags.power_setup_done = 1;
  
         /*
          * Install the idle handler if processor power management is supported.
@@ -1304,6 +1695,13 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
          * platforms that only support C1.
          */
         if ((pr->flags.power) && (!boot_option_idle_override)) {
+#ifdef CONFIG_CPU_IDLE
+               acpi_processor_setup_cpuidle(pr);
+               pr->power.dev.cpu = pr->id;
+               if (cpuidle_register_device(&pr->power.dev))
+                       return -EIO;
+#endif
+
                 printk(KERN_INFO PREFIX "CPU%d (power states:", pr->id);
                 for (i = 1; i <= pr->power.count; i++)
                         if (pr->power.states[i].valid)
@@ -1311,10 +1709,12 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
                                        pr->power.states[i].type);
                 printk(")\n");
  
+#ifndef CONFIG_CPU_IDLE
                 if (pr->id == 0) {
                         pm_idle_save = pm_idle;
                         pm_idle = acpi_processor_idle;
                 }
+#endif
         }
  
         /* 'power' [R] */
@@ -1328,21 +1728,24 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
                 entry->owner = THIS_MODULE;
         }
  
-       pr->flags.power_setup_done = 1;
-
         return 0;
  }
  
  int acpi_processor_power_exit(struct acpi_processor *pr,
                               struct acpi_device *device)
  {
-
+#ifdef CONFIG_CPU_IDLE
+       if ((pr->flags.power) && (!boot_option_idle_override))
+               cpuidle_unregister_device(&pr->power.dev);
+#endif
         pr->flags.power_setup_done = 0;
  
         if (acpi_device_dir(device))
                 remove_proc_entry(ACPI_PROCESSOR_FILE_POWER,
                                   acpi_device_dir(device));
  
+#ifndef CONFIG_CPU_IDLE
+
         /* Unregister the idle handler when processor #0 is removed. */
         if (pr->id == 0) {
                 pm_idle = pm_idle_save;
@@ -1357,6 +1760,7 @@ int acpi_processor_power_exit(struct acpi_processor *pr,
                 unregister_latency_notifier(&acpi_processor_latency_notifier);
  #endif
         }
+#endif
  
         return 0;
  }
diff --git a/drivers/cpuidle/Kconfig b/drivers/cpuidle/Kconfig

new file mode 100644 (file)

index 0000000..3bed412
--- /dev/null
+++ b/drivers/cpuidle/Kconfig
@@ -0,0 +1,20 @@
+
+config CPU_IDLE
+       bool "CPU idle PM support"
+       help
+         CPU idle is a generic framework for supporting software-controlled
+         idle processor power management.  It includes modular cross-platform
+         governors that can be swapped during runtime.
+
+         If you're using a mobile platform that supports CPU idle PM (e.g.
+         an ACPI-capable notebook), you should say Y here.
+
+config CPU_IDLE_GOV_LADDER
+       bool
+       depends on CPU_IDLE
+       default y
+
+config CPU_IDLE_GOV_MENU
+       bool
+       depends on CPU_IDLE && NO_HZ
+       default y
diff --git a/drivers/cpuidle/Makefile b/drivers/cpuidle/Makefile

new file mode 100644 (file)

index 0000000..5634f88
--- /dev/null
+++ b/drivers/cpuidle/Makefile
@@ -0,0 +1,5 @@
+#
+# Makefile for cpuidle.
+#
+
+obj-y += cpuidle.o driver.o governor.o sysfs.o governors/
diff --git a/drivers/cpuidle/cpuidle.c b/drivers/cpuidle/cpuidle.c

new file mode 100644 (file)

index 0000000..fdf4106
--- /dev/null
+++ b/drivers/cpuidle/cpuidle.c
@@ -0,0 +1,295 @@
+/*
+ * cpuidle.c - core cpuidle infrastructure
+ *
+ * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *               Shaohua Li <shaohua.li@intel.com>
+ *               Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/kernel.h>
+#include <linux/mutex.h>
+#include <linux/sched.h>
+#include <linux/notifier.h>
+#include <linux/latency.h>
+#include <linux/cpu.h>
+#include <linux/cpuidle.h>
+
+#include "cpuidle.h"
+
+DEFINE_PER_CPU(struct cpuidle_device *, cpuidle_devices);
+EXPORT_PER_CPU_SYMBOL_GPL(cpuidle_devices);
+
+DEFINE_MUTEX(cpuidle_lock);
+LIST_HEAD(cpuidle_detected_devices);
+static void (*pm_idle_old)(void);
+
+static int enabled_devices;
+
+/**
+ * cpuidle_idle_call - the main idle loop
+ *
+ * NOTE: no locks or semaphores should be used here
+ */
+static void cpuidle_idle_call(void)
+{
+       struct cpuidle_device *dev = __get_cpu_var(cpuidle_devices);
+       struct cpuidle_state *target_state;
+       int next_state;
+
+       /* check if the device is ready */
+       if (!dev || !dev->enabled) {
+               if (pm_idle_old)
+                       pm_idle_old();
+               else
+                       local_irq_enable();
+               return;
+       }
+
+       /* ask the governor for the next state */
+       next_state = cpuidle_curr_governor->select(dev);
+       if (need_resched())
+               return;
+       target_state = &dev->states[next_state];
+
+       /* enter the state and update stats */
+       dev->last_residency = target_state->enter(dev, target_state);
+       dev->last_state = target_state;
+       target_state->time += dev->last_residency;
+       target_state->usage++;
+
+       /* give the governor an opportunity to reflect on the outcome */
+       if (cpuidle_curr_governor->reflect)
+               cpuidle_curr_governor->reflect(dev);
+}
+
+/**
+ * cpuidle_install_idle_handler - installs the cpuidle idle loop handler
+ */
+void cpuidle_install_idle_handler(void)
+{
+       if (enabled_devices && (pm_idle != cpuidle_idle_call)) {
+               /* Make sure all changes finished before we switch to new idle */
+               smp_wmb();
+               pm_idle = cpuidle_idle_call;
+       }
+}
+
+/**
+ * cpuidle_uninstall_idle_handler - uninstalls the cpuidle idle loop handler
+ */
+void cpuidle_uninstall_idle_handler(void)
+{
+       if (enabled_devices && (pm_idle != pm_idle_old)) {
+               pm_idle = pm_idle_old;
+               cpu_idle_wait();
+       }
+}
+
+/**
+ * cpuidle_pause_and_lock - temporarily disables CPUIDLE
+ */
+void cpuidle_pause_and_lock(void)
+{
+       mutex_lock(&cpuidle_lock);
+       cpuidle_uninstall_idle_handler();
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_pause_and_lock);
+
+/**
+ * cpuidle_resume_and_unlock - resumes CPUIDLE operation
+ */
+void cpuidle_resume_and_unlock(void)
+{
+       cpuidle_install_idle_handler();
+       mutex_unlock(&cpuidle_lock);
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_resume_and_unlock);
+
+/**
+ * cpuidle_enable_device - enables idle PM for a CPU
+ * @dev: the CPU
+ *
+ * This function must be called between cpuidle_pause_and_lock and
+ * cpuidle_resume_and_unlock when used externally.
+ */
+int cpuidle_enable_device(struct cpuidle_device *dev)
+{
+       int ret, i;
+
+       if (dev->enabled)
+               return 0;
+       if (!cpuidle_curr_driver || !cpuidle_curr_governor)
+               return -EIO;
+       if (!dev->state_count)
+               return -EINVAL;
+
+       if ((ret = cpuidle_add_state_sysfs(dev)))
+               return ret;
+
+       if (cpuidle_curr_governor->enable &&
+           (ret = cpuidle_curr_governor->enable(dev)))
+               goto fail_sysfs;
+
+       for (i = 0; i < dev->state_count; i++) {
+               dev->states[i].usage = 0;
+               dev->states[i].time = 0;
+       }
+       dev->last_residency = 0;
+       dev->last_state = NULL;
+
+       smp_wmb();
+
+       dev->enabled = 1;
+
+       enabled_devices++;
+       return 0;
+
+fail_sysfs:
+       cpuidle_remove_state_sysfs(dev);
+
+       return ret;
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_enable_device);
+
+/**
+ * cpuidle_disable_device - disables idle PM for a CPU
+ * @dev: the CPU
+ *
+ * This function must be called between cpuidle_pause_and_lock and
+ * cpuidle_resume_and_unlock when used externally.
+ */
+void cpuidle_disable_device(struct cpuidle_device *dev)
+{
+       if (!dev->enabled)
+               return;
+       if (!cpuidle_curr_driver || !cpuidle_curr_governor)
+               return;
+
+       dev->enabled = 0;
+
+       if (cpuidle_curr_governor->disable)
+               cpuidle_curr_governor->disable(dev);
+
+       cpuidle_remove_state_sysfs(dev);
+       enabled_devices--;
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_disable_device);
+
+/**
+ * cpuidle_register_device - registers a CPU's idle PM feature
+ * @dev: the cpu
+ */
+int cpuidle_register_device(struct cpuidle_device *dev)
+{
+       int ret;
+       struct sys_device *sys_dev = get_cpu_sysdev((unsigned long)dev->cpu);
+
+       if (!sys_dev)
+               return -EINVAL;
+       if (!try_module_get(cpuidle_curr_driver->owner))
+               return -EINVAL;
+
+       init_completion(&dev->kobj_unregister);
+
+       mutex_lock(&cpuidle_lock);
+
+       per_cpu(cpuidle_devices, dev->cpu) = dev;
+       list_add(&dev->device_list, &cpuidle_detected_devices);
+       if ((ret = cpuidle_add_sysfs(sys_dev))) {
+               mutex_unlock(&cpuidle_lock);
+               module_put(cpuidle_curr_driver->owner);
+               return ret;
+       }
+
+       cpuidle_enable_device(dev);
+       cpuidle_install_idle_handler();
+
+       mutex_unlock(&cpuidle_lock);
+
+       return 0;
+
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_register_device);
+
+/**
+ * cpuidle_unregister_device - unregisters a CPU's idle PM feature
+ * @dev: the cpu
+ */
+void cpuidle_unregister_device(struct cpuidle_device *dev)
+{
+       struct sys_device *sys_dev = get_cpu_sysdev((unsigned long)dev->cpu);
+
+       cpuidle_pause_and_lock();
+
+       cpuidle_disable_device(dev);
+
+       cpuidle_remove_sysfs(sys_dev);
+       list_del(&dev->device_list);
+       wait_for_completion(&dev->kobj_unregister);
+       per_cpu(cpuidle_devices, dev->cpu) = NULL;
+
+       cpuidle_resume_and_unlock();
+
+       module_put(cpuidle_curr_driver->owner);
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_unregister_device);
+
+#ifdef CONFIG_SMP
+
+static void smp_callback(void *v)
+{
+       /* we already woke the CPU up, nothing more to do */
+}
+
+/*
+ * This function gets called when a part of the kernel has a new latency
+ * requirement.  This means we need to get all processors out of their C-state,
+ * and then recalculate a new suitable C-state. Just do a cross-cpu IPI; that
+ * wakes them all right up.
+ */
+static int cpuidle_latency_notify(struct notifier_block *b,
+               unsigned long l, void *v)
+{
+       smp_call_function(smp_callback, NULL, 0, 1);
+       return NOTIFY_OK;
+}
+
+static struct notifier_block cpuidle_latency_notifier = {
+       .notifier_call = cpuidle_latency_notify,
+};
+
+#define latency_notifier_init(x) do { register_latency_notifier(x); } while (0)
+
+#else /* CONFIG_SMP */
+
+#define latency_notifier_init(x) do { } while (0)
+
+#endif /* CONFIG_SMP */
+
+/**
+ * cpuidle_init - core initializer
+ */
+static int __init cpuidle_init(void)
+{
+       int ret;
+
+       pm_idle_old = pm_idle;
+
+       ret = cpuidle_add_class_sysfs(&cpu_sysdev_class);
+       if (ret)
+               return ret;
+
+       latency_notifier_init(&cpuidle_latency_notifier);
+
+       return 0;
+}
+
+core_initcall(cpuidle_init);
diff --git a/drivers/cpuidle/cpuidle.h b/drivers/cpuidle/cpuidle.h

new file mode 100644 (file)

index 0000000..9476ba3
--- /dev/null
+++ b/drivers/cpuidle/cpuidle.h
@@ -0,0 +1,33 @@
+/*
+ * cpuidle.h - The internal header file
+ */
+
+#ifndef __DRIVER_CPUIDLE_H
+#define __DRIVER_CPUIDLE_H
+
+#include <linux/sysdev.h>
+
+/* For internal use only */
+extern struct cpuidle_governor *cpuidle_curr_governor;
+extern struct cpuidle_driver *cpuidle_curr_driver;
+extern struct list_head cpuidle_governors;
+extern struct list_head cpuidle_detected_devices;
+extern struct mutex cpuidle_lock;
+extern spinlock_t cpuidle_driver_lock;
+
+/* idle loop */
+extern void cpuidle_install_idle_handler(void);
+extern void cpuidle_uninstall_idle_handler(void);
+
+/* governors */
+extern int cpuidle_switch_governor(struct cpuidle_governor *gov);
+
+/* sysfs */
+extern int cpuidle_add_class_sysfs(struct sysdev_class *cls);
+extern void cpuidle_remove_class_sysfs(struct sysdev_class *cls);
+extern int cpuidle_add_state_sysfs(struct cpuidle_device *device);
+extern void cpuidle_remove_state_sysfs(struct cpuidle_device *device);
+extern int cpuidle_add_sysfs(struct sys_device *sysdev);
+extern void cpuidle_remove_sysfs(struct sys_device *sysdev);
+
+#endif /* __DRIVER_CPUIDLE_H */
diff --git a/drivers/cpuidle/driver.c b/drivers/cpuidle/driver.c

new file mode 100644 (file)

index 0000000..2257004
--- /dev/null
+++ b/drivers/cpuidle/driver.c
@@ -0,0 +1,56 @@
+/*
+ * driver.c - driver support
+ *
+ * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *               Shaohua Li <shaohua.li@intel.com>
+ *               Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/mutex.h>
+#include <linux/module.h>
+#include <linux/cpuidle.h>
+
+#include "cpuidle.h"
+
+struct cpuidle_driver *cpuidle_curr_driver;
+DEFINE_SPINLOCK(cpuidle_driver_lock);
+
+/**
+ * cpuidle_register_driver - registers a driver
+ * @drv: the driver
+ */
+int cpuidle_register_driver(struct cpuidle_driver *drv)
+{
+       if (!drv)
+               return -EINVAL;
+
+       spin_lock(&cpuidle_driver_lock);
+       if (cpuidle_curr_driver) {
+               spin_unlock(&cpuidle_driver_lock);
+               return -EBUSY;
+       }
+       cpuidle_curr_driver = drv;
+       spin_unlock(&cpuidle_driver_lock);
+
+       return 0;
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_register_driver);
+
+/**
+ * cpuidle_unregister_driver - unregisters a driver
+ * @drv: the driver
+ */
+void cpuidle_unregister_driver(struct cpuidle_driver *drv)
+{
+       if (!drv)
+               return;
+
+       spin_lock(&cpuidle_driver_lock);
+       cpuidle_curr_driver = NULL;
+       spin_unlock(&cpuidle_driver_lock);
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);
diff --git a/drivers/cpuidle/governor.c b/drivers/cpuidle/governor.c

new file mode 100644 (file)

index 0000000..bb699cb
--- /dev/null
+++ b/drivers/cpuidle/governor.c
@@ -0,0 +1,141 @@
+/*
+ * governor.c - governor support
+ *
+ * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *               Shaohua Li <shaohua.li@intel.com>
+ *               Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/mutex.h>
+#include <linux/module.h>
+#include <linux/cpuidle.h>
+
+#include "cpuidle.h"
+
+LIST_HEAD(cpuidle_governors);
+struct cpuidle_governor *cpuidle_curr_governor;
+
+/**
+ * __cpuidle_find_governor - finds a governor of the specified name
+ * @str: the name
+ *
+ * Must be called with cpuidle_lock aquired.
+ */
+static struct cpuidle_governor * __cpuidle_find_governor(const char *str)
+{
+       struct cpuidle_governor *gov;
+
+       list_for_each_entry(gov, &cpuidle_governors, governor_list)
+               if (!strnicmp(str, gov->name, CPUIDLE_NAME_LEN))
+                       return gov;
+
+       return NULL;
+}
+
+/**
+ * cpuidle_switch_governor - changes the governor
+ * @gov: the new target governor
+ *
+ * NOTE: "gov" can be NULL to specify disabled
+ * Must be called with cpuidle_lock aquired.
+ */
+int cpuidle_switch_governor(struct cpuidle_governor *gov)
+{
+       struct cpuidle_device *dev;
+
+       if (gov == cpuidle_curr_governor)
+               return 0;
+
+       cpuidle_uninstall_idle_handler();
+
+       if (cpuidle_curr_governor) {
+               list_for_each_entry(dev, &cpuidle_detected_devices, device_list)
+                       cpuidle_disable_device(dev);
+               module_put(cpuidle_curr_governor->owner);
+       }
+
+       cpuidle_curr_governor = gov;
+
+       if (gov) {
+               if (!try_module_get(cpuidle_curr_governor->owner))
+                       return -EINVAL;
+               list_for_each_entry(dev, &cpuidle_detected_devices, device_list)
+                       cpuidle_enable_device(dev);
+               cpuidle_install_idle_handler();
+               printk(KERN_INFO "cpuidle: using governor %s\n", gov->name);
+       }
+
+       return 0;
+}
+
+/**
+ * cpuidle_register_governor - registers a governor
+ * @gov: the governor
+ */
+int cpuidle_register_governor(struct cpuidle_governor *gov)
+{
+       int ret = -EEXIST;
+
+       if (!gov || !gov->select)
+               return -EINVAL;
+
+       mutex_lock(&cpuidle_lock);
+       if (__cpuidle_find_governor(gov->name) == NULL) {
+               ret = 0;
+               list_add_tail(&gov->governor_list, &cpuidle_governors);
+               if (!cpuidle_curr_governor ||
+                   cpuidle_curr_governor->rating < gov->rating)
+                       cpuidle_switch_governor(gov);
+       }
+       mutex_unlock(&cpuidle_lock);
+
+       return ret;
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_register_governor);
+
+/**
+ * cpuidle_replace_governor - find a replacement governor
+ * @exclude_rating: the rating that will be skipped while looking for
+ * new governor.
+ */
+static struct cpuidle_governor *cpuidle_replace_governor(int exclude_rating)
+{
+       struct cpuidle_governor *gov;
+       struct cpuidle_governor *ret_gov = NULL;
+       unsigned int max_rating = 0;
+
+       list_for_each_entry(gov, &cpuidle_governors, governor_list) {
+               if (gov->rating == exclude_rating)
+                       continue;
+               if (gov->rating > max_rating) {
+                       max_rating = gov->rating;
+                       ret_gov = gov;
+               }
+       }
+
+       return ret_gov;
+}
+
+/**
+ * cpuidle_unregister_governor - unregisters a governor
+ * @gov: the governor
+ */
+void cpuidle_unregister_governor(struct cpuidle_governor *gov)
+{
+       if (!gov)
+               return;
+
+       mutex_lock(&cpuidle_lock);
+       if (gov == cpuidle_curr_governor) {
+               struct cpuidle_governor *new_gov;
+               new_gov = cpuidle_replace_governor(gov->rating);
+               cpuidle_switch_governor(new_gov);
+       }
+       list_del(&gov->governor_list);
+       mutex_unlock(&cpuidle_lock);
+}
+
+EXPORT_SYMBOL_GPL(cpuidle_unregister_governor);
diff --git a/drivers/cpuidle/governors/Makefile b/drivers/cpuidle/governors/Makefile

new file mode 100644 (file)

index 0000000..1b51272
--- /dev/null
+++ b/drivers/cpuidle/governors/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for cpuidle governors.
+#
+
+obj-$(CONFIG_CPU_IDLE_GOV_LADDER) += ladder.o
+obj-$(CONFIG_CPU_IDLE_GOV_MENU) += menu.o
diff --git a/drivers/cpuidle/governors/ladder.c b/drivers/cpuidle/governors/ladder.c

new file mode 100644 (file)

index 0000000..eb666ec
--- /dev/null
+++ b/drivers/cpuidle/governors/ladder.c
@@ -0,0 +1,166 @@
+/*
+ * ladder.c - the residency ladder algorithm
+ *
+ *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
+ *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
+ *  Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de>
+ *
+ * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *               Shaohua Li <shaohua.li@intel.com>
+ *               Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/kernel.h>
+#include <linux/cpuidle.h>
+#include <linux/latency.h>
+#include <linux/moduleparam.h>
+#include <linux/jiffies.h>
+
+#include <asm/io.h>
+#include <asm/uaccess.h>
+
+#define PROMOTION_COUNT 4
+#define DEMOTION_COUNT 1
+
+struct ladder_device_state {
+       struct {
+               u32 promotion_count;
+               u32 demotion_count;
+               u32 promotion_time;
+               u32 demotion_time;
+       } threshold;
+       struct {
+               int promotion_count;
+               int demotion_count;
+       } stats;
+};
+
+struct ladder_device {
+       struct ladder_device_state states[CPUIDLE_STATE_MAX];
+       int last_state_idx;
+};
+
+static DEFINE_PER_CPU(struct ladder_device, ladder_devices);
+
+/**
+ * ladder_do_selection - prepares private data for a state change
+ * @ldev: the ladder device
+ * @old_idx: the current state index
+ * @new_idx: the new target state index
+ */
+static inline void ladder_do_selection(struct ladder_device *ldev,
+                                      int old_idx, int new_idx)
+{
+       ldev->states[old_idx].stats.promotion_count = 0;
+       ldev->states[old_idx].stats.demotion_count = 0;
+       ldev->last_state_idx = new_idx;
+}
+
+/**
+ * ladder_select_state - selects the next state to enter
+ * @dev: the CPU
+ */
+static int ladder_select_state(struct cpuidle_device *dev)
+{
+       struct ladder_device *ldev = &__get_cpu_var(ladder_devices);
+       struct ladder_device_state *last_state;
+       int last_residency, last_idx = ldev->last_state_idx;
+
+       if (unlikely(!ldev))
+               return 0;
+
+       last_state = &ldev->states[last_idx];
+
+       if (dev->states[last_idx].flags & CPUIDLE_FLAG_TIME_VALID)
+               last_residency = cpuidle_get_last_residency(dev) - dev->states[last_idx].exit_latency;
+       else
+               last_residency = last_state->threshold.promotion_time + 1;
+
+       /* consider promotion */
+       if (last_idx < dev->state_count - 1 &&
+           last_residency > last_state->threshold.promotion_time &&
+           dev->states[last_idx + 1].exit_latency <= system_latency_constraint()) {
+               last_state->stats.promotion_count++;
+               last_state->stats.demotion_count = 0;
+               if (last_state->stats.promotion_count >= last_state->threshold.promotion_count) {
+                       ladder_do_selection(ldev, last_idx, last_idx + 1);
+                       return last_idx + 1;
+               }
+       }
+
+       /* consider demotion */
+       if (last_idx > 0 &&
+           last_residency < last_state->threshold.demotion_time) {
+               last_state->stats.demotion_count++;
+               last_state->stats.promotion_count = 0;
+               if (last_state->stats.demotion_count >= last_state->threshold.demotion_count) {
+                       ladder_do_selection(ldev, last_idx, last_idx - 1);
+                       return last_idx - 1;
+               }
+       }
+
+       /* otherwise remain at the current state */
+       return last_idx;
+}
+
+/**
+ * ladder_enable_device - setup for the governor
+ * @dev: the CPU
+ */
+static int ladder_enable_device(struct cpuidle_device *dev)
+{
+       int i;
+       struct ladder_device *ldev = &per_cpu(ladder_devices, dev->cpu);
+       struct ladder_device_state *lstate;
+       struct cpuidle_state *state;
+
+       ldev->last_state_idx = 0;
+
+       for (i = 0; i < dev->state_count; i++) {
+               state = &dev->states[i];
+               lstate = &ldev->states[i];
+
+               lstate->stats.promotion_count = 0;
+               lstate->stats.demotion_count = 0;
+
+               lstate->threshold.promotion_count = PROMOTION_COUNT;
+               lstate->threshold.demotion_count = DEMOTION_COUNT;
+
+               if (i < dev->state_count - 1)
+                       lstate->threshold.promotion_time = state->exit_latency;
+               if (i > 0)
+                       lstate->threshold.demotion_time = state->exit_latency;
+       }
+
+       return 0;
+}
+
+static struct cpuidle_governor ladder_governor = {
+       .name =         "ladder",
+       .rating =       10,
+       .enable =       ladder_enable_device,
+       .select =       ladder_select_state,
+       .owner =        THIS_MODULE,
+};
+
+/**
+ * init_ladder - initializes the governor
+ */
+static int __init init_ladder(void)
+{
+       return cpuidle_register_governor(&ladder_governor);
+}
+
+/**
+ * exit_ladder - exits the governor
+ */
+static void __exit exit_ladder(void)
+{
+       cpuidle_unregister_governor(&ladder_governor);
+}
+
+MODULE_LICENSE("GPL");
+module_init(init_ladder);
+module_exit(exit_ladder);
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c

new file mode 100644 (file)

index 0000000..299d45c
--- /dev/null
+++ b/drivers/cpuidle/governors/menu.c
@@ -0,0 +1,137 @@
+/*
+ * menu.c - the menu idle governor
+ *
+ * Copyright (C) 2006-2007 Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/kernel.h>
+#include <linux/cpuidle.h>
+#include <linux/latency.h>
+#include <linux/time.h>
+#include <linux/ktime.h>
+#include <linux/hrtimer.h>
+#include <linux/tick.h>
+
+#define BREAK_FUZZ     4       /* 4 us */
+
+struct menu_device {
+       int             last_state_idx;
+
+       unsigned int    expected_us;
+       unsigned int    predicted_us;
+       unsigned int    last_measured_us;
+       unsigned int    elapsed_us;
+};
+
+static DEFINE_PER_CPU(struct menu_device, menu_devices);
+
+/**
+ * menu_select - selects the next idle state to enter
+ * @dev: the CPU
+ */
+static int menu_select(struct cpuidle_device *dev)
+{
+       struct menu_device *data = &__get_cpu_var(menu_devices);
+       int i;
+
+       /* determine the expected residency time */
+       data->expected_us =
+               (u32) ktime_to_ns(tick_nohz_get_sleep_length()) / 1000;
+
+       /* find the deepest idle state that satisfies our constraints */
+       for (i = 1; i < dev->state_count; i++) {
+               struct cpuidle_state *s = &dev->states[i];
+
+               if (s->target_residency > data->expected_us)
+                       break;
+               if (s->target_residency > data->predicted_us)
+                       break;
+               if (s->exit_latency > system_latency_constraint())
+                       break;
+       }
+
+       data->last_state_idx = i - 1;
+       return i - 1;
+}
+
+/**
+ * menu_reflect - attempts to guess what happened after entry
+ * @dev: the CPU
+ *
+ * NOTE: it's important to be fast here because this operation will add to
+ *       the overall exit latency.
+ */
+static void menu_reflect(struct cpuidle_device *dev)
+{
+       struct menu_device *data = &__get_cpu_var(menu_devices);
+       int last_idx = data->last_state_idx;
+       unsigned int measured_us =
+               cpuidle_get_last_residency(dev) + data->elapsed_us;
+       struct cpuidle_state *target = &dev->states[last_idx];
+
+       /*
+        * Ugh, this idle state doesn't support residency measurements, so we
+        * are basically lost in the dark.  As a compromise, assume we slept
+        * for one full standard timer tick.  However, be aware that this
+        * could potentially result in a suboptimal state transition.
+        */
+       if (!(target->flags & CPUIDLE_FLAG_TIME_VALID))
+               measured_us = USEC_PER_SEC / HZ;
+
+       /* Predict time remaining until next break event */
+       if (measured_us + BREAK_FUZZ < data->expected_us - target->exit_latency) {
+               data->predicted_us = max(measured_us, data->last_measured_us);
+               data->last_measured_us = measured_us;
+               data->elapsed_us = 0;
+       } else {
+               if (data->elapsed_us < data->elapsed_us + measured_us)
+                       data->elapsed_us = measured_us;
+               else
+                       data->elapsed_us = -1;
+               data->predicted_us = max(measured_us, data->last_measured_us);
+       }
+}
+
+/**
+ * menu_enable_device - scans a CPU's states and does setup
+ * @dev: the CPU
+ */
+static int menu_enable_device(struct cpuidle_device *dev)
+{
+       struct menu_device *data = &per_cpu(menu_devices, dev->cpu);
+
+       memset(data, 0, sizeof(struct menu_device));
+
+       return 0;
+}
+
+static struct cpuidle_governor menu_governor = {
+       .name =         "menu",
+       .rating =       20,
+       .enable =       menu_enable_device,
+       .select =       menu_select,
+       .reflect =      menu_reflect,
+       .owner =        THIS_MODULE,
+};
+
+/**
+ * init_menu - initializes the governor
+ */
+static int __init init_menu(void)
+{
+       return cpuidle_register_governor(&menu_governor);
+}
+
+/**
+ * exit_menu - exits the governor
+ */
+static void __exit exit_menu(void)
+{
+       cpuidle_unregister_governor(&menu_governor);
+}
+
+MODULE_LICENSE("GPL");
+module_init(init_menu);
+module_exit(exit_menu);
diff --git a/drivers/cpuidle/sysfs.c b/drivers/cpuidle/sysfs.c

new file mode 100644 (file)

index 0000000..0f3515e
--- /dev/null
+++ b/drivers/cpuidle/sysfs.c
@@ -0,0 +1,361 @@
+/*
+ * sysfs.c - sysfs support
+ *
+ * (C) 2006-2007 Shaohua Li <shaohua.li@intel.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#include <linux/kernel.h>
+#include <linux/cpuidle.h>
+#include <linux/sysfs.h>
+#include <linux/cpu.h>
+
+#include "cpuidle.h"
+
+static unsigned int sysfs_switch;
+static int __init cpuidle_sysfs_setup(char *unused)
+{
+       sysfs_switch = 1;
+       return 1;
+}
+__setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);
+
+static ssize_t show_available_governors(struct sys_device *dev, char *buf)
+{
+       ssize_t i = 0;
+       struct cpuidle_governor *tmp;
+
+       mutex_lock(&cpuidle_lock);
+       list_for_each_entry(tmp, &cpuidle_governors, governor_list) {
+               if (i >= (ssize_t) ((PAGE_SIZE/sizeof(char)) - CPUIDLE_NAME_LEN - 2))
+                       goto out;
+               i += scnprintf(&buf[i], CPUIDLE_NAME_LEN, "%s ", tmp->name);
+       }
+
+out:
+       i+= sprintf(&buf[i], "\n");
+       mutex_unlock(&cpuidle_lock);
+       return i;
+}
+
+static ssize_t show_current_driver(struct sys_device *dev, char *buf)
+{
+       ssize_t ret;
+
+       spin_lock(&cpuidle_driver_lock);
+       if (cpuidle_curr_driver)
+               ret = sprintf(buf, "%s\n", cpuidle_curr_driver->name);
+       else
+               ret = sprintf(buf, "none\n");
+       spin_unlock(&cpuidle_driver_lock);
+
+       return ret;
+}
+
+static ssize_t show_current_governor(struct sys_device *dev, char *buf)
+{
+       ssize_t ret;
+
+       mutex_lock(&cpuidle_lock);
+       if (cpuidle_curr_governor)
+               ret = sprintf(buf, "%s\n", cpuidle_curr_governor->name);
+       else
+               ret = sprintf(buf, "none\n");
+       mutex_unlock(&cpuidle_lock);
+
+       return ret;
+}
+
+static ssize_t store_current_governor(struct sys_device *dev,
+       const char *buf, size_t count)
+{
+       char gov_name[CPUIDLE_NAME_LEN];
+       int ret = -EINVAL;
+       size_t len = count;
+       struct cpuidle_governor *gov;
+
+       if (!len || len >= sizeof(gov_name))
+               return -EINVAL;
+
+       memcpy(gov_name, buf, len);
+       gov_name[len] = '\0';
+       if (gov_name[len - 1] == '\n')
+               gov_name[--len] = '\0';
+
+       mutex_lock(&cpuidle_lock);
+
+       list_for_each_entry(gov, &cpuidle_governors, governor_list) {
+               if (strlen(gov->name) == len && !strcmp(gov->name, gov_name)) {
+                       ret = cpuidle_switch_governor(gov);
+                       break;
+               }
+       }
+
+       mutex_unlock(&cpuidle_lock);
+
+       if (ret)
+               return ret;
+       else
+               return count;
+}
+
+static SYSDEV_ATTR(current_driver, 0444, show_current_driver, NULL);
+static SYSDEV_ATTR(current_governor_ro, 0444, show_current_governor, NULL);
+
+static struct attribute *cpuclass_default_attrs[] = {
+       &attr_current_driver.attr,
+       &attr_current_governor_ro.attr,
+       NULL
+};
+
+static SYSDEV_ATTR(available_governors, 0444, show_available_governors, NULL);
+static SYSDEV_ATTR(current_governor, 0644, show_current_governor,
+       store_current_governor);
+
+static struct attribute *cpuclass_switch_attrs[] = {
+       &attr_available_governors.attr,
+       &attr_current_driver.attr,
+       &attr_current_governor.attr,
+       NULL
+};
+
+static struct attribute_group cpuclass_attr_group = {
+       .attrs = cpuclass_default_attrs,
+       .name = "cpuidle",
+};
+
+/**
+ * cpuidle_add_class_sysfs - add CPU global sysfs attributes
+ */
+int cpuidle_add_class_sysfs(struct sysdev_class *cls)
+{
+       if (sysfs_switch)
+               cpuclass_attr_group.attrs = cpuclass_switch_attrs;
+
+       return sysfs_create_group(&cls->kset.kobj, &cpuclass_attr_group);
+}
+
+/**
+ * cpuidle_remove_class_sysfs - remove CPU global sysfs attributes
+ */
+void cpuidle_remove_class_sysfs(struct sysdev_class *cls)
+{
+       sysfs_remove_group(&cls->kset.kobj, &cpuclass_attr_group);
+}
+
+struct cpuidle_attr {
+       struct attribute attr;
+       ssize_t (*show)(struct cpuidle_device *, char *);
+       ssize_t (*store)(struct cpuidle_device *, const char *, size_t count);
+};
+
+#define define_one_ro(_name, show) \
+       static struct cpuidle_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
+#define define_one_rw(_name, show, store) \
+       static struct cpuidle_attr attr_##_name = __ATTR(_name, 0644, show, store)
+
+#define kobj_to_cpuidledev(k) container_of(k, struct cpuidle_device, kobj)
+#define attr_to_cpuidleattr(a) container_of(a, struct cpuidle_attr, attr)
+static ssize_t cpuidle_show(struct kobject * kobj, struct attribute * attr ,char * buf)
+{
+       int ret = -EIO;
+       struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
+       struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);
+
+       if (cattr->show) {
+               mutex_lock(&cpuidle_lock);
+               ret = cattr->show(dev, buf);
+               mutex_unlock(&cpuidle_lock);
+       }
+       return ret;
+}
+
+static ssize_t cpuidle_store(struct kobject * kobj, struct attribute * attr,
+                    const char * buf, size_t count)
+{
+       int ret = -EIO;
+       struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
+       struct cpuidle_attr * cattr = attr_to_cpuidleattr(attr);
+
+       if (cattr->store) {
+               mutex_lock(&cpuidle_lock);
+               ret = cattr->store(dev, buf, count);
+               mutex_unlock(&cpuidle_lock);
+       }
+       return ret;
+}
+
+static struct sysfs_ops cpuidle_sysfs_ops = {
+       .show = cpuidle_show,
+       .store = cpuidle_store,
+};
+
+static void cpuidle_sysfs_release(struct kobject *kobj)
+{
+       struct cpuidle_device *dev = kobj_to_cpuidledev(kobj);
+
+       complete(&dev->kobj_unregister);
+}
+
+static struct kobj_type ktype_cpuidle = {
+       .sysfs_ops = &cpuidle_sysfs_ops,
+       .release = cpuidle_sysfs_release,
+};
+
+struct cpuidle_state_attr {
+       struct attribute attr;
+       ssize_t (*show)(struct cpuidle_state *, char *);
+       ssize_t (*store)(struct cpuidle_state *, const char *, size_t);
+};
+
+#define define_one_state_ro(_name, show) \
+static struct cpuidle_state_attr attr_##_name = __ATTR(_name, 0444, show, NULL)
+
+#define define_show_state_function(_name) \
+static ssize_t show_state_##_name(struct cpuidle_state *state, char *buf) \
+{ \
+       return sprintf(buf, "%u\n", state->_name);\
+}
+
+static ssize_t show_state_name(struct cpuidle_state *state, char *buf)
+{
+       return sprintf(buf, "%s\n", state->name);
+}
+
+define_show_state_function(exit_latency)
+define_show_state_function(power_usage)
+define_show_state_function(usage)
+define_show_state_function(time)
+define_one_state_ro(name, show_state_name);
+define_one_state_ro(latency, show_state_exit_latency);
+define_one_state_ro(power, show_state_power_usage);
+define_one_state_ro(usage, show_state_usage);
+define_one_state_ro(time, show_state_time);
+
+static struct attribute *cpuidle_state_default_attrs[] = {
+       &attr_name.attr,
+       &attr_latency.attr,
+       &attr_power.attr,
+       &attr_usage.attr,
+       &attr_time.attr,
+       NULL
+};
+
+#define kobj_to_state_obj(k) container_of(k, struct cpuidle_state_kobj, kobj)
+#define kobj_to_state(k) (kobj_to_state_obj(k)->state)
+#define attr_to_stateattr(a) container_of(a, struct cpuidle_state_attr, attr)
+static ssize_t cpuidle_state_show(struct kobject * kobj,
+       struct attribute * attr ,char * buf)
+{
+       int ret = -EIO;
+       struct cpuidle_state *state = kobj_to_state(kobj);
+       struct cpuidle_state_attr * cattr = attr_to_stateattr(attr);
+
+       if (cattr->show)
+               ret = cattr->show(state, buf);
+
+       return ret;
+}
+
+static struct sysfs_ops cpuidle_state_sysfs_ops = {
+       .show = cpuidle_state_show,
+};
+
+static void cpuidle_state_sysfs_release(struct kobject *kobj)
+{
+       struct cpuidle_state_kobj *state_obj = kobj_to_state_obj(kobj);
+
+       complete(&state_obj->kobj_unregister);
+}
+
+static struct kobj_type ktype_state_cpuidle = {
+       .sysfs_ops = &cpuidle_state_sysfs_ops,
+       .default_attrs = cpuidle_state_default_attrs,
+       .release = cpuidle_state_sysfs_release,
+};
+
+static void inline cpuidle_free_state_kobj(struct cpuidle_device *device, int i)
+{
+       kobject_unregister(&device->kobjs[i]->kobj);
+       wait_for_completion(&device->kobjs[i]->kobj_unregister);
+       kfree(device->kobjs[i]);
+       device->kobjs[i] = NULL;
+}
+
+/**
+ * cpuidle_add_driver_sysfs - adds driver-specific sysfs attributes
+ * @device: the target device
+ */
+int cpuidle_add_state_sysfs(struct cpuidle_device *device)
+{
+       int i, ret = -ENOMEM;
+       struct cpuidle_state_kobj *kobj;
+
+       /* state statistics */
+       for (i = 0; i < device->state_count; i++) {
+               kobj = kzalloc(sizeof(struct cpuidle_state_kobj), GFP_KERNEL);
+               if (!kobj)
+                       goto error_state;
+               kobj->state = &device->states[i];
+               init_completion(&kobj->kobj_unregister);
+
+               kobj->kobj.parent = &device->kobj;
+               kobj->kobj.ktype = &ktype_state_cpuidle;
+               kobject_set_name(&kobj->kobj, "state%d", i);
+               ret = kobject_register(&kobj->kobj);
+               if (ret) {
+                       kfree(kobj);
+                       goto error_state;
+               }
+               device->kobjs[i] = kobj;
+       }
+
+       return 0;
+
+error_state:
+       for (i = i - 1; i >= 0; i--)
+               cpuidle_free_state_kobj(device, i);
+       return ret;
+}
+
+/**
+ * cpuidle_remove_driver_sysfs - removes driver-specific sysfs attributes
+ * @device: the target device
+ */
+void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
+{
+       int i;
+
+       for (i = 0; i < device->state_count; i++)
+               cpuidle_free_state_kobj(device, i);
+}
+
+/**
+ * cpuidle_add_sysfs - creates a sysfs instance for the target device
+ * @sysdev: the target device
+ */
+int cpuidle_add_sysfs(struct sys_device *sysdev)
+{
+       int cpu = sysdev->id;
+       struct cpuidle_device *dev;
+
+       dev = per_cpu(cpuidle_devices, cpu);
+       dev->kobj.parent = &sysdev->kobj;
+       dev->kobj.ktype = &ktype_cpuidle;
+       kobject_set_name(&dev->kobj, "%s", "cpuidle");
+       return kobject_register(&dev->kobj);
+}
+
+/**
+ * cpuidle_remove_sysfs - deletes a sysfs instance on the target device
+ * @sysdev: the target device
+ */
+void cpuidle_remove_sysfs(struct sys_device *sysdev)
+{
+       int cpu = sysdev->id;
+       struct cpuidle_device *dev;
+
+       dev = per_cpu(cpuidle_devices, cpu);
+       kobject_unregister(&dev->kobj);
+}
diff --git a/drivers/net/wireless/ipw2100.c b/drivers/net/wireless/ipw2100.c

index 8990585..e8a94b7 100644 (file)
--- a/drivers/net/wireless/ipw2100.c
+++ b/drivers/net/wireless/ipw2100.c
@@ -1858,14 +1858,6 @@ static void ipw2100_down(struct ipw2100_priv *priv)
  
         modify_acceptable_latency("ipw2100", INFINITE_LATENCY);
  
-#ifdef ACPI_CSTATE_LIMIT_DEFINED
-       if (priv->config & CFG_C3_DISABLED) {
-               IPW_DEBUG_INFO(": Resetting C3 transitions.\n");
-               acpi_set_cstate_limit(priv->cstate_limit);
-               priv->config &= ~CFG_C3_DISABLED;
-       }
-#endif
-
         /* We have to signal any supplicant if we are disassociating */
         if (associated)
                 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
@@ -2088,14 +2080,6 @@ static void isr_indicate_rf_kill(struct ipw2100_priv *priv, u32 status)
         /* RF_KILL is now enabled (else we wouldn't be here) */
         priv->status |= STATUS_RF_KILL_HW;
  
-#ifdef ACPI_CSTATE_LIMIT_DEFINED
-       if (priv->config & CFG_C3_DISABLED) {
-               IPW_DEBUG_INFO(": Resetting C3 transitions.\n");
-               acpi_set_cstate_limit(priv->cstate_limit);
-               priv->config &= ~CFG_C3_DISABLED;
-       }
-#endif
-
         /* Make sure the RF Kill check timer is running */
         priv->stop_rf_kill = 0;
         cancel_delayed_work(&priv->rf_kill);
@@ -2326,23 +2310,10 @@ static void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i)
         u32 match, reg;
         int j;
  #endif
-#ifdef ACPI_CSTATE_LIMIT_DEFINED
-       int limit;
-#endif
  
         IPW_DEBUG_INFO(": PCI latency error detected at 0x%04zX.\n",
                        i * sizeof(struct ipw2100_status));
  
-#ifdef ACPI_CSTATE_LIMIT_DEFINED
-       IPW_DEBUG_INFO(": Disabling C3 transitions.\n");
-       limit = acpi_get_cstate_limit();
-       if (limit > 2) {
-               priv->cstate_limit = limit;
-               acpi_set_cstate_limit(2);
-               priv->config |= CFG_C3_DISABLED;
-       }
-#endif
-
  #ifdef IPW2100_DEBUG_C3
         /* Halt the fimrware so we can get a good image */
         write_register(priv->net_dev, IPW_REG_RESET_REG,
diff --git a/drivers/net/wireless/ipw2100.h b/drivers/net/wireless/ipw2100.h

index de7d384..2b8be24 100644 (file)
--- a/drivers/net/wireless/ipw2100.h
+++ b/drivers/net/wireless/ipw2100.h
@@ -479,7 +479,6 @@ enum {
  #define CFG_ASSOCIATE           (1<<6)
  #define CFG_FIXED_RATE          (1<<7)
  #define CFG_ADHOC_CREATE        (1<<8)
-#define CFG_C3_DISABLED         (1<<9)
  #define CFG_PASSIVE_SCAN        (1<<10)
  #ifdef CONFIG_IPW2100_MONITOR
  #define CFG_CRC_CHECK           (1<<11)
@@ -508,7 +507,6 @@ struct ipw2100_priv {
         u8 bssid[ETH_ALEN];
         u8 channel;
         int last_mode;
-       int cstate_limit;
  
         unsigned long connect_start;
         unsigned long last_reset;
diff --git a/include/acpi/processor.h b/include/acpi/processor.h

index 99934a9..26d79f6 100644 (file)
--- a/include/acpi/processor.h
+++ b/include/acpi/processor.h
@@ -3,6 +3,7 @@
  
  #include <linux/kernel.h>
  #include <linux/cpu.h>
+#include <linux/cpuidle.h>
  
  #include <asm/acpi.h>
  
@@ -75,7 +76,9 @@ struct acpi_processor_cx {
  };
  
  struct acpi_processor_power {
+       struct cpuidle_device dev;
         struct acpi_processor_cx *state;
+       struct acpi_processor_cx *bm_state;
         unsigned long bm_check_timestamp;
         u32 default_state;
         u32 bm_activity;
@@ -199,6 +202,7 @@ struct acpi_processor_flags {
         u8 bm_check:1;
         u8 has_cst:1;
         u8 power_setup_done:1;
+       u8 bm_rld_set:1;
  };
  
  struct acpi_processor {
@@ -322,6 +326,7 @@ int acpi_processor_power_exit(struct acpi_processor *pr,
                               struct acpi_device *device);
  int acpi_processor_suspend(struct acpi_device * device, pm_message_t state);
  int acpi_processor_resume(struct acpi_device * device);
+extern struct cpuidle_driver acpi_idle_driver;
  
  /* in processor_thermal.c */
  int acpi_processor_get_limit_info(struct acpi_processor *pr);
diff --git a/include/linux/acpi.h b/include/linux/acpi.h

index bf5e000..8ccedf7 100644 (file)
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -189,32 +189,6 @@ extern int ec_transaction(u8 command,
  extern int acpi_blacklisted(void);
  extern void acpi_bios_year(char *s);
  
-#define        ACPI_CSTATE_LIMIT_DEFINED       /* for driver builds */
-#ifdef CONFIG_ACPI
-
-/*
- * Set highest legal C-state
- * 0: C0 okay, but not C1
- * 1: C1 okay, but not C2
- * 2: C2 okay, but not C3 etc.
- */
-
-extern unsigned int max_cstate;
-
-static inline unsigned int acpi_get_cstate_limit(void)
-{
-       return max_cstate;
-}
-static inline void acpi_set_cstate_limit(unsigned int new_limit)
-{
-       max_cstate = new_limit;
-       return;
-}
-#else
-static inline unsigned int acpi_get_cstate_limit(void) { return 0; }
-static inline void acpi_set_cstate_limit(unsigned int new_limit) { return; }
-#endif
-
  #ifdef CONFIG_ACPI_NUMA
  int acpi_get_pxm(acpi_handle handle);
  int acpi_get_node(acpi_handle *handle);
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h

new file mode 100644 (file)

index 0000000..16a5154
--- /dev/null
+++ b/include/linux/cpuidle.h
@@ -0,0 +1,180 @@
+/*
+ * cpuidle.h - a generic framework for CPU idle power management
+ *
+ * (C) 2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *          Shaohua Li <shaohua.li@intel.com>
+ *          Adam Belay <abelay@novell.com>
+ *
+ * This code is licenced under the GPL.
+ */
+
+#ifndef _LINUX_CPUIDLE_H
+#define _LINUX_CPUIDLE_H
+
+#include <linux/percpu.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/kobject.h>
+#include <linux/completion.h>
+
+#define CPUIDLE_STATE_MAX      8
+#define CPUIDLE_NAME_LEN       16
+
+struct cpuidle_device;
+
+
+/****************************
+ * CPUIDLE DEVICE INTERFACE *
+ ****************************/
+
+struct cpuidle_state {
+       char            name[CPUIDLE_NAME_LEN];
+       void            *driver_data;
+
+       unsigned int    flags;
+       unsigned int    exit_latency; /* in US */
+       unsigned int    power_usage; /* in mW */
+       unsigned int    target_residency; /* in US */
+
+       unsigned int    usage;
+       unsigned int    time; /* in US */
+
+       int (*enter)    (struct cpuidle_device *dev,
+                        struct cpuidle_state *state);
+};
+
+/* Idle State Flags */
+#define CPUIDLE_FLAG_TIME_VALID        (0x01) /* is residency time measurable? */
+#define CPUIDLE_FLAG_CHECK_BM  (0x02) /* BM activity will exit state */
+#define CPUIDLE_FLAG_SHALLOW   (0x10) /* low latency, minimal savings */
+#define CPUIDLE_FLAG_BALANCED  (0x20) /* medium latency, moderate savings */
+#define CPUIDLE_FLAG_DEEP      (0x40) /* high latency, large savings */
+
+#define CPUIDLE_DRIVER_FLAGS_MASK (0xFFFF0000)
+
+/**
+ * cpuidle_get_statedata - retrieves private driver state data
+ * @state: the state
+ */
+static inline void * cpuidle_get_statedata(struct cpuidle_state *state)
+{
+       return state->driver_data;
+}
+
+/**
+ * cpuidle_set_statedata - stores private driver state data
+ * @state: the state
+ * @data: the private data
+ */
+static inline void
+cpuidle_set_statedata(struct cpuidle_state *state, void *data)
+{
+       state->driver_data = data;
+}
+
+struct cpuidle_state_kobj {
+       struct cpuidle_state *state;
+       struct completion kobj_unregister;
+       struct kobject kobj;
+};
+
+struct cpuidle_device {
+       int                     enabled:1;
+       unsigned int            cpu;
+
+       int                     last_residency;
+       int                     state_count;
+       struct cpuidle_state    states[CPUIDLE_STATE_MAX];
+       struct cpuidle_state_kobj *kobjs[CPUIDLE_STATE_MAX];
+       struct cpuidle_state    *last_state;
+
+       struct list_head        device_list;
+       struct kobject          kobj;
+       struct completion       kobj_unregister;
+       void                    *governor_data;
+};
+
+DECLARE_PER_CPU(struct cpuidle_device *, cpuidle_devices);
+
+/**
+ * cpuidle_get_last_residency - retrieves the last state's residency time
+ * @dev: the target CPU
+ *
+ * NOTE: this value is invalid if CPUIDLE_FLAG_TIME_VALID isn't set
+ */
+static inline int cpuidle_get_last_residency(struct cpuidle_device *dev)
+{
+       return dev->last_residency;
+}
+
+
+/****************************
+ * CPUIDLE DRIVER INTERFACE *
+ ****************************/
+
+struct cpuidle_driver {
+       char                    name[CPUIDLE_NAME_LEN];
+       struct module           *owner;
+};
+
+#ifdef CONFIG_CPU_IDLE
+
+extern int cpuidle_register_driver(struct cpuidle_driver *drv);
+extern void cpuidle_unregister_driver(struct cpuidle_driver *drv);
+extern int cpuidle_register_device(struct cpuidle_device *dev);
+extern void cpuidle_unregister_device(struct cpuidle_device *dev);
+
+extern void cpuidle_pause_and_lock(void);
+extern void cpuidle_resume_and_unlock(void);
+extern int cpuidle_enable_device(struct cpuidle_device *dev);
+extern void cpuidle_disable_device(struct cpuidle_device *dev);
+
+#else
+
+static inline int cpuidle_register_driver(struct cpuidle_driver *drv)
+{return 0;}
+static inline void cpuidle_unregister_driver(struct cpuidle_driver *drv) { }
+static inline int cpuidle_register_device(struct cpuidle_device *dev)
+{return 0;}
+static inline void cpuidle_unregister_device(struct cpuidle_device *dev) { }
+
+static inline void cpuidle_pause_and_lock(void) { }
+static inline void cpuidle_resume_and_unlock(void) { }
+static inline int cpuidle_enable_device(struct cpuidle_device *dev)
+{return 0;}
+static inline void cpuidle_disable_device(struct cpuidle_device *dev) { }
+
+#endif
+
+/******************************
+ * CPUIDLE GOVERNOR INTERFACE *
+ ******************************/
+
+struct cpuidle_governor {
+       char                    name[CPUIDLE_NAME_LEN];
+       struct list_head        governor_list;
+       unsigned int            rating;
+
+       int  (*enable)          (struct cpuidle_device *dev);
+       void (*disable)         (struct cpuidle_device *dev);
+
+       int  (*select)          (struct cpuidle_device *dev);
+       void (*reflect)         (struct cpuidle_device *dev);
+
+       struct module           *owner;
+};
+
+#ifdef CONFIG_CPU_IDLE
+
+extern int cpuidle_register_governor(struct cpuidle_governor *gov);
+extern void cpuidle_unregister_governor(struct cpuidle_governor *gov);
+
+#else
+
+static inline int cpuidle_register_governor(struct cpuidle_governor *gov)
+{return 0;}
+static inline void cpuidle_unregister_governor(struct cpuidle_governor *gov) { }
+
+#endif
+
+#endif /* _LINUX_CPUIDLE_H */
diff --git a/include/linux/tick.h b/include/linux/tick.h

index 9a7252e..f4a1395 100644 (file)
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -40,6 +40,7 @@ enum tick_nohz_mode {
   * @idle_sleeps:       Number of idle calls, where the sched tick was stopped
   * @idle_entrytime:    Time when the idle call was entered
   * @idle_sleeptime:    Sum of the time slept in idle with sched tick stopped
+ * @sleep_length:      Duration of the current idle sleep
   */
  struct tick_sched {
         struct hrtimer                  sched_timer;
@@ -52,6 +53,7 @@ struct tick_sched {
         unsigned long                   idle_sleeps;
         ktime_t                         idle_entrytime;
         ktime_t                         idle_sleeptime;
+       ktime_t                         sleep_length;
         unsigned long                   last_jiffies;
         unsigned long                   next_jiffies;
         ktime_t                         idle_expires;
@@ -100,10 +102,17 @@ static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }
  extern void tick_nohz_stop_sched_tick(void);
  extern void tick_nohz_restart_sched_tick(void);
  extern void tick_nohz_update_jiffies(void);
+extern ktime_t tick_nohz_get_sleep_length(void);
  # else
  static inline void tick_nohz_stop_sched_tick(void) { }
  static inline void tick_nohz_restart_sched_tick(void) { }
  static inline void tick_nohz_update_jiffies(void) { }
+static inline ktime_t tick_nohz_get_sleep_length(void)
+{
+       ktime_t len = { .tv64 = NSEC_PER_SEC/HZ };
+
+       return len;
+}
  # endif /* !NO_HZ */
  
  #endif
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c

index 8c3fef1..637519a 100644 (file)
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -153,6 +153,7 @@ void tick_nohz_stop_sched_tick(void)
         unsigned long seq, last_jiffies, next_jiffies, delta_jiffies, flags;
         struct tick_sched *ts;
         ktime_t last_update, expires, now, delta;
+       struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;
         int cpu;
  
         local_irq_save(flags);
@@ -302,10 +303,25 @@ void tick_nohz_stop_sched_tick(void)
  out:
         ts->next_jiffies = next_jiffies;
         ts->last_jiffies = last_jiffies;
+       ts->sleep_length = ktime_sub(dev->next_event, now);
  end:
         local_irq_restore(flags);
  }
  
+/**
+ * tick_nohz_get_sleep_length - return the length of the current sleep
+ *
+ * Called from power state control code with interrupts disabled
+ */
+ktime_t tick_nohz_get_sleep_length(void)
+{
+       struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
+
+       return ts->sleep_length;
+}
+
+EXPORT_SYMBOL_GPL(tick_nohz_get_sleep_length);
+
  /**
   * nohz_restart_sched_tick - restart the idle tick from the idle task
   *
author	Len Brown <len.brown@intel.com>
	Wed, 3 Oct 2007 22:58:00 +0000 (18:58 -0400)
committer	Len Brown <len.brown@intel.com>
	Wed, 10 Oct 2007 04:12:41 +0000 (00:12 -0400)
arch/i386/Kconfig		patch \| blob \| history
arch/x86_64/Kconfig		patch \| blob \| history
drivers/Makefile		patch \| blob \| history
drivers/acpi/osl.c		patch \| blob \| history
drivers/acpi/processor_core.c		patch \| blob \| history
drivers/acpi/processor_idle.c		patch \| blob \| history
drivers/cpuidle/Kconfig	[new file with mode: 0644]	patch \| blob
drivers/cpuidle/Makefile	[new file with mode: 0644]	patch \| blob
drivers/cpuidle/cpuidle.c	[new file with mode: 0644]	patch \| blob
drivers/cpuidle/cpuidle.h	[new file with mode: 0644]	patch \| blob
drivers/cpuidle/driver.c	[new file with mode: 0644]	patch \| blob
drivers/cpuidle/governor.c	[new file with mode: 0644]	patch \| blob
drivers/cpuidle/governors/Makefile	[new file with mode: 0644]	patch \| blob
drivers/cpuidle/governors/ladder.c	[new file with mode: 0644]	patch \| blob
drivers/cpuidle/governors/menu.c	[new file with mode: 0644]	patch \| blob
drivers/cpuidle/sysfs.c	[new file with mode: 0644]	patch \| blob
drivers/net/wireless/ipw2100.c		patch \| blob \| history
drivers/net/wireless/ipw2100.h		patch \| blob \| history
include/acpi/processor.h		patch \| blob \| history
include/linux/acpi.h		patch \| blob \| history
include/linux/cpuidle.h	[new file with mode: 0644]	patch \| blob
include/linux/tick.h		patch \| blob \| history
kernel/time/tick-sched.c		patch \| blob \| history