1 /* 2 * ladder.c - the residency ladder algorithm 3 * 4 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> 5 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> 6 * Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de> 7 * 8 * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com> 9 * Shaohua Li <shaohua.li@intel.com> 10 * Adam Belay <abelay@novell.com> 11 * 12 * This code is licenced under the GPL. 13 */ 14 15 #include <linux/kernel.h> 16 #include <linux/cpuidle.h> 17 #include <linux/pm_qos.h> 18 #include <linux/jiffies.h> 19 #include <linux/tick.h> 20 21 #include <asm/io.h> 22 #include <linux/uaccess.h> 23 24 #define PROMOTION_COUNT 4 25 #define DEMOTION_COUNT 1 26 27 struct ladder_device_state { 28 struct { 29 u32 promotion_count; 30 u32 demotion_count; 31 u32 promotion_time; 32 u32 demotion_time; 33 } threshold; 34 struct { 35 int promotion_count; 36 int demotion_count; 37 } stats; 38 }; 39 40 struct ladder_device { 41 struct ladder_device_state states[CPUIDLE_STATE_MAX]; 42 int last_state_idx; 43 }; 44 45 static DEFINE_PER_CPU(struct ladder_device, ladder_devices); 46 47 /** 48 * ladder_do_selection - prepares private data for a state change 49 * @ldev: the ladder device 50 * @old_idx: the current state index 51 * @new_idx: the new target state index 52 */ 53 static inline void ladder_do_selection(struct ladder_device *ldev, 54 int old_idx, int new_idx) 55 { 56 ldev->states[old_idx].stats.promotion_count = 0; 57 ldev->states[old_idx].stats.demotion_count = 0; 58 ldev->last_state_idx = new_idx; 59 } 60 61 /** 62 * ladder_select_state - selects the next state to enter 63 * @drv: cpuidle driver 64 * @dev: the CPU 65 */ 66 static int ladder_select_state(struct cpuidle_driver *drv, 67 struct cpuidle_device *dev) 68 { 69 struct ladder_device *ldev = this_cpu_ptr(&ladder_devices); 70 struct ladder_device_state *last_state; 71 int last_residency, last_idx = ldev->last_state_idx; 72 int latency_req = pm_qos_request(PM_QOS_CPU_DMA_LATENCY); 73 74 /* Special case when user has set very strict latency requirement */ 75 if (unlikely(latency_req == 0)) { 76 ladder_do_selection(ldev, last_idx, 0); 77 return 0; 78 } 79 80 last_state = &ldev->states[last_idx]; 81 82 last_residency = cpuidle_get_last_residency(dev) - drv->states[last_idx].exit_latency; 83 84 /* consider promotion */ 85 if (last_idx < drv->state_count - 1 && 86 !drv->states[last_idx + 1].disabled && 87 !dev->states_usage[last_idx + 1].disable && 88 last_residency > last_state->threshold.promotion_time && 89 drv->states[last_idx + 1].exit_latency <= latency_req) { 90 last_state->stats.promotion_count++; 91 last_state->stats.demotion_count = 0; 92 if (last_state->stats.promotion_count >= last_state->threshold.promotion_count) { 93 ladder_do_selection(ldev, last_idx, last_idx + 1); 94 return last_idx + 1; 95 } 96 } 97 98 /* consider demotion */ 99 if (last_idx > CPUIDLE_DRIVER_STATE_START && 100 (drv->states[last_idx].disabled || 101 dev->states_usage[last_idx].disable || 102 drv->states[last_idx].exit_latency > latency_req)) { 103 int i; 104 105 for (i = last_idx - 1; i > CPUIDLE_DRIVER_STATE_START; i--) { 106 if (drv->states[i].exit_latency <= latency_req) 107 break; 108 } 109 ladder_do_selection(ldev, last_idx, i); 110 return i; 111 } 112 113 if (last_idx > CPUIDLE_DRIVER_STATE_START && 114 last_residency < last_state->threshold.demotion_time) { 115 last_state->stats.demotion_count++; 116 last_state->stats.promotion_count = 0; 117 if (last_state->stats.demotion_count >= last_state->threshold.demotion_count) { 118 ladder_do_selection(ldev, last_idx, last_idx - 1); 119 return last_idx - 1; 120 } 121 } 122 123 /* otherwise remain at the current state */ 124 return last_idx; 125 } 126 127 /** 128 * ladder_enable_device - setup for the governor 129 * @drv: cpuidle driver 130 * @dev: the CPU 131 */ 132 static int ladder_enable_device(struct cpuidle_driver *drv, 133 struct cpuidle_device *dev) 134 { 135 int i; 136 struct ladder_device *ldev = &per_cpu(ladder_devices, dev->cpu); 137 struct ladder_device_state *lstate; 138 struct cpuidle_state *state; 139 140 ldev->last_state_idx = CPUIDLE_DRIVER_STATE_START; 141 142 for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++) { 143 state = &drv->states[i]; 144 lstate = &ldev->states[i]; 145 146 lstate->stats.promotion_count = 0; 147 lstate->stats.demotion_count = 0; 148 149 lstate->threshold.promotion_count = PROMOTION_COUNT; 150 lstate->threshold.demotion_count = DEMOTION_COUNT; 151 152 if (i < drv->state_count - 1) 153 lstate->threshold.promotion_time = state->exit_latency; 154 if (i > CPUIDLE_DRIVER_STATE_START) 155 lstate->threshold.demotion_time = state->exit_latency; 156 } 157 158 return 0; 159 } 160 161 /** 162 * ladder_reflect - update the correct last_state_idx 163 * @dev: the CPU 164 * @index: the index of actual state entered 165 */ 166 static void ladder_reflect(struct cpuidle_device *dev, int index) 167 { 168 struct ladder_device *ldev = this_cpu_ptr(&ladder_devices); 169 if (index > 0) 170 ldev->last_state_idx = index; 171 } 172 173 static struct cpuidle_governor ladder_governor = { 174 .name = "ladder", 175 .rating = 10, 176 .enable = ladder_enable_device, 177 .select = ladder_select_state, 178 .reflect = ladder_reflect, 179 }; 180 181 /** 182 * init_ladder - initializes the governor 183 */ 184 static int __init init_ladder(void) 185 { 186 /* 187 * When NO_HZ is disabled, or when booting with nohz=off, the ladder 188 * governor is better so give it a higher rating than the menu 189 * governor. 190 */ 191 if (!tick_nohz_enabled) 192 ladder_governor.rating = 25; 193 194 return cpuidle_register_governor(&ladder_governor); 195 } 196 197 postcore_initcall(init_ladder); 198