cpuidle: Single/Global registration of idle states

This patch makes the cpuidle_states structure global (single copy)
instead of per-cpu. The statistics needed on per-cpu basis
by the governor are kept per-cpu. This simplifies the cpuidle
subsystem as state registration is done by single cpu only.
Having single copy of cpuidle_states saves memory. Rare case
of asymmetric C-states can be handled within the cpuidle driver
and architectures such as POWER do not have asymmetric C-states.

Having single/global registration of all the idle states,
dynamic C-state transitions on x86 are handled by
the boot cpu. Here, the boot cpu  would disable all the devices,
re-populate the states and later enable all the devices,
irrespective of the cpu that would receive the notification first.

Reference:
https://lkml.org/lkml/2011/4/25/83

Signed-off-by: Deepthi Dharwar <deepthi@linux.vnet.ibm.com>
Signed-off-by: Trinabh Gupta <g.trinabh@gmail.com>
Tested-by: Jean Pihet <j-pihet@ti.com>
Reviewed-by: Kevin Hilman <khilman@ti.com>
Acked-by: Arjan van de Ven <arjan@linux.intel.com>
Acked-by: Kevin Hilman <khilman@ti.com>
Signed-off-by: Len Brown <len.brown@intel.com>

2 files changed, 29 insertions, 19 deletions

diff --git a/drivers/cpuidle/governors/ladder.c b/drivers/cpuidle/governors/ladder.c
index 6a686a76711f..ef6b9e4727a7 100644
--- a/drivers/cpuidle/governors/ladder.c
+++ b/drivers/cpuidle/governors/ladder.c
@@ -60,9 +60,11 @@ static inline void ladder_do_selection(struct ladder_device *ldev,
 
 /**
  * ladder_select_state - selects the next state to enter
+ * @drv: cpuidle driver
  * @dev: the CPU
  */
-static int ladder_select_state(struct cpuidle_device *dev)
+static int ladder_select_state(struct cpuidle_driver *drv,
+                                struct cpuidle_device *dev)
 {
         struct ladder_device *ldev = &__get_cpu_var(ladder_devices);
         struct ladder_device_state *last_state;
@@ -77,15 +79,17 @@ static int ladder_select_state(struct cpuidle_device *dev)
 
         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;
+        if (drv->states[last_idx].flags & CPUIDLE_FLAG_TIME_VALID) {
+                last_residency = cpuidle_get_last_residency(dev) - \
+                                         drv->states[last_idx].exit_latency;
+        }
         else
                 last_residency = last_state->threshold.promotion_time + 1;
 
         /* consider promotion */
-        if (last_idx < dev->state_count - 1 &&
+        if (last_idx < drv->state_count - 1 &&
             last_residency > last_state->threshold.promotion_time &&
-            dev->states[last_idx + 1].exit_latency <= latency_req) {
+            drv->states[last_idx + 1].exit_latency <= latency_req) {
                 last_state->stats.promotion_count++;
                 last_state->stats.demotion_count = 0;
                 if (last_state->stats.promotion_count >= last_state->threshold.promotion_count) {
@@ -96,11 +100,11 @@ static int ladder_select_state(struct cpuidle_device *dev)
 
         /* consider demotion */
         if (last_idx > CPUIDLE_DRIVER_STATE_START &&
-            dev->states[last_idx].exit_latency > latency_req) {
+            drv->states[last_idx].exit_latency > latency_req) {
                 int i;
 
                 for (i = last_idx - 1; i > CPUIDLE_DRIVER_STATE_START; i--) {
-                        if (dev->states[i].exit_latency <= latency_req)
+                        if (drv->states[i].exit_latency <= latency_req)
                                 break;
                 }
                 ladder_do_selection(ldev, last_idx, i);
@@ -123,9 +127,11 @@ static int ladder_select_state(struct cpuidle_device *dev)
 
 /**
  * ladder_enable_device - setup for the governor
+ * @drv: cpuidle driver
  * @dev: the CPU
  */
-static int ladder_enable_device(struct cpuidle_device *dev)
+static int ladder_enable_device(struct cpuidle_driver *drv,
+                                struct cpuidle_device *dev)
 {
         int i;
         struct ladder_device *ldev = &per_cpu(ladder_devices, dev->cpu);
@@ -134,8 +140,8 @@ static int ladder_enable_device(struct cpuidle_device *dev)
 
         ldev->last_state_idx = CPUIDLE_DRIVER_STATE_START;
 
-        for (i = 0; i < dev->state_count; i++) {
-                state = &dev->states[i];
+        for (i = 0; i < drv->state_count; i++) {
+                state = &drv->states[i];
                 lstate = &ldev->states[i];
 
                 lstate->stats.promotion_count = 0;
@@ -144,7 +150,7 @@ static int ladder_enable_device(struct cpuidle_device *dev)
                 lstate->threshold.promotion_count = PROMOTION_COUNT;
                 lstate->threshold.demotion_count = DEMOTION_COUNT;
 
-                if (i < dev->state_count - 1)
+                if (i < drv->state_count - 1)
                         lstate->threshold.promotion_time = state->exit_latency;
                 if (i > 0)
                         lstate->threshold.demotion_time = state->exit_latency;
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index af724e823c8e..bcbe88142135 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -182,7 +182,7 @@ static inline int performance_multiplier(void)
 
 static DEFINE_PER_CPU(struct menu_device, menu_devices);
 
-static void menu_update(struct cpuidle_device *dev);
+static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev);
 
 /* This implements DIV_ROUND_CLOSEST but avoids 64 bit division */
 static u64 div_round64(u64 dividend, u32 divisor)
@@ -228,9 +228,10 @@ static void detect_repeating_patterns(struct menu_device *data)
 
 /**
  * menu_select - selects the next idle state to enter
+ * @drv: cpuidle driver containing state data
  * @dev: the CPU
  */
-static int menu_select(struct cpuidle_device *dev)
+static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev)
 {
         struct menu_device *data = &__get_cpu_var(menu_devices);
         int latency_req = pm_qos_request(PM_QOS_CPU_DMA_LATENCY);
@@ -240,7 +241,7 @@ static int menu_select(struct cpuidle_device *dev)
         struct timespec t;
 
         if (data->needs_update) {
-                menu_update(dev);
+                menu_update(drv, dev);
                 data->needs_update = 0;
         }
 
@@ -285,8 +286,8 @@ static int menu_select(struct cpuidle_device *dev)
          * Find the idle state with the lowest power while satisfying
          * our constraints.
          */
-        for (i = CPUIDLE_DRIVER_STATE_START; i < dev->state_count; i++) {
-                struct cpuidle_state *s = &dev->states[i];
+        for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++) {
+                struct cpuidle_state *s = &drv->states[i];
 
                 if (s->target_residency > data->predicted_us)
                         continue;
@@ -323,14 +324,15 @@ static void menu_reflect(struct cpuidle_device *dev, int index)
 
 /**
  * menu_update - attempts to guess what happened after entry
+ * @drv: cpuidle driver containing state data
  * @dev: the CPU
  */
-static void menu_update(struct cpuidle_device *dev)
+static void menu_update(struct cpuidle_driver *drv, struct cpuidle_device *dev)
 {
         struct menu_device *data = &__get_cpu_var(menu_devices);
         int last_idx = data->last_state_idx;
         unsigned int last_idle_us = cpuidle_get_last_residency(dev);
-        struct cpuidle_state *target = &dev->states[last_idx];
+        struct cpuidle_state *target = &drv->states[last_idx];
         unsigned int measured_us;
         u64 new_factor;
 
@@ -384,9 +386,11 @@ static void menu_update(struct cpuidle_device *dev)
 
 /**
  * menu_enable_device - scans a CPU's states and does setup
+ * @drv: cpuidle driver
  * @dev: the CPU
  */
-static int menu_enable_device(struct cpuidle_device *dev)
+static int menu_enable_device(struct cpuidle_driver *drv,
+                                struct cpuidle_device *dev)
 {
         struct menu_device *data = &per_cpu(menu_devices, dev->cpu);