1 /* 2 * driver.c - driver support 3 * 4 * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com> 5 * Shaohua Li <shaohua.li@intel.com> 6 * Adam Belay <abelay@novell.com> 7 * 8 * This code is licenced under the GPL. 9 */ 10 11 #include <linux/mutex.h> 12 #include <linux/module.h> 13 #include <linux/sched.h> 14 #include <linux/sched/idle.h> 15 #include <linux/cpuidle.h> 16 #include <linux/cpumask.h> 17 #include <linux/tick.h> 18 #include <linux/cpu.h> 19 20 #include "cpuidle.h" 21 22 DEFINE_SPINLOCK(cpuidle_driver_lock); 23 24 #ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS 25 26 static DEFINE_PER_CPU(struct cpuidle_driver *, cpuidle_drivers); 27 28 /** 29 * __cpuidle_get_cpu_driver - return the cpuidle driver tied to a CPU. 30 * @cpu: the CPU handled by the driver 31 * 32 * Returns a pointer to struct cpuidle_driver or NULL if no driver has been 33 * registered for @cpu. 34 */ 35 static struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu) 36 { 37 return per_cpu(cpuidle_drivers, cpu); 38 } 39 40 /** 41 * __cpuidle_unset_driver - unset per CPU driver variables. 42 * @drv: a valid pointer to a struct cpuidle_driver 43 * 44 * For each CPU in the driver's CPU mask, unset the registered driver per CPU 45 * variable. If @drv is different from the registered driver, the corresponding 46 * variable is not cleared. 47 */ 48 static inline void __cpuidle_unset_driver(struct cpuidle_driver *drv) 49 { 50 int cpu; 51 52 for_each_cpu(cpu, drv->cpumask) { 53 54 if (drv != __cpuidle_get_cpu_driver(cpu)) 55 continue; 56 57 per_cpu(cpuidle_drivers, cpu) = NULL; 58 } 59 } 60 61 /** 62 * __cpuidle_set_driver - set per CPU driver variables for the given driver. 63 * @drv: a valid pointer to a struct cpuidle_driver 64 * 65 * For each CPU in the driver's cpumask, unset the registered driver per CPU 66 * to @drv. 67 * 68 * Returns 0 on success, -EBUSY if the CPUs have driver(s) already. 69 */ 70 static inline int __cpuidle_set_driver(struct cpuidle_driver *drv) 71 { 72 int cpu; 73 74 for_each_cpu(cpu, drv->cpumask) { 75 76 if (__cpuidle_get_cpu_driver(cpu)) { 77 __cpuidle_unset_driver(drv); 78 return -EBUSY; 79 } 80 81 per_cpu(cpuidle_drivers, cpu) = drv; 82 } 83 84 return 0; 85 } 86 87 #else 88 89 static struct cpuidle_driver *cpuidle_curr_driver; 90 91 /** 92 * __cpuidle_get_cpu_driver - return the global cpuidle driver pointer. 93 * @cpu: ignored without the multiple driver support 94 * 95 * Return a pointer to a struct cpuidle_driver object or NULL if no driver was 96 * previously registered. 97 */ 98 static inline struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu) 99 { 100 return cpuidle_curr_driver; 101 } 102 103 /** 104 * __cpuidle_set_driver - assign the global cpuidle driver variable. 105 * @drv: pointer to a struct cpuidle_driver object 106 * 107 * Returns 0 on success, -EBUSY if the driver is already registered. 108 */ 109 static inline int __cpuidle_set_driver(struct cpuidle_driver *drv) 110 { 111 if (cpuidle_curr_driver) 112 return -EBUSY; 113 114 cpuidle_curr_driver = drv; 115 116 return 0; 117 } 118 119 /** 120 * __cpuidle_unset_driver - unset the global cpuidle driver variable. 121 * @drv: a pointer to a struct cpuidle_driver 122 * 123 * Reset the global cpuidle variable to NULL. If @drv does not match the 124 * registered driver, do nothing. 125 */ 126 static inline void __cpuidle_unset_driver(struct cpuidle_driver *drv) 127 { 128 if (drv == cpuidle_curr_driver) 129 cpuidle_curr_driver = NULL; 130 } 131 132 #endif 133 134 /** 135 * cpuidle_setup_broadcast_timer - enable/disable the broadcast timer on a cpu 136 * @arg: a void pointer used to match the SMP cross call API 137 * 138 * If @arg is NULL broadcast is disabled otherwise enabled 139 * 140 * This function is executed per CPU by an SMP cross call. It's not 141 * supposed to be called directly. 142 */ 143 static void cpuidle_setup_broadcast_timer(void *arg) 144 { 145 if (arg) 146 tick_broadcast_enable(); 147 else 148 tick_broadcast_disable(); 149 } 150 151 /** 152 * __cpuidle_driver_init - initialize the driver's internal data 153 * @drv: a valid pointer to a struct cpuidle_driver 154 */ 155 static void __cpuidle_driver_init(struct cpuidle_driver *drv) 156 { 157 int i; 158 159 drv->refcnt = 0; 160 161 /* 162 * Use all possible CPUs as the default, because if the kernel boots 163 * with some CPUs offline and then we online one of them, the CPU 164 * notifier has to know which driver to assign. 165 */ 166 if (!drv->cpumask) 167 drv->cpumask = (struct cpumask *)cpu_possible_mask; 168 169 /* 170 * Look for the timer stop flag in the different states, so that we know 171 * if the broadcast timer has to be set up. The loop is in the reverse 172 * order, because usually one of the deeper states have this flag set. 173 */ 174 for (i = drv->state_count - 1; i >= 0 ; i--) { 175 if (drv->states[i].flags & CPUIDLE_FLAG_TIMER_STOP) { 176 drv->bctimer = 1; 177 break; 178 } 179 } 180 } 181 182 #ifdef CONFIG_ARCH_HAS_CPU_RELAX 183 static int __cpuidle poll_idle(struct cpuidle_device *dev, 184 struct cpuidle_driver *drv, int index) 185 { 186 local_irq_enable(); 187 if (!current_set_polling_and_test()) { 188 while (!need_resched()) 189 cpu_relax(); 190 } 191 current_clr_polling(); 192 193 return index; 194 } 195 196 static void poll_idle_init(struct cpuidle_driver *drv) 197 { 198 struct cpuidle_state *state = &drv->states[0]; 199 200 snprintf(state->name, CPUIDLE_NAME_LEN, "POLL"); 201 snprintf(state->desc, CPUIDLE_DESC_LEN, "CPUIDLE CORE POLL IDLE"); 202 state->exit_latency = 0; 203 state->target_residency = 0; 204 state->power_usage = -1; 205 state->enter = poll_idle; 206 state->disabled = false; 207 } 208 #else 209 static void poll_idle_init(struct cpuidle_driver *drv) {} 210 #endif /* !CONFIG_ARCH_HAS_CPU_RELAX */ 211 212 /** 213 * __cpuidle_register_driver: register the driver 214 * @drv: a valid pointer to a struct cpuidle_driver 215 * 216 * Do some sanity checks, initialize the driver, assign the driver to the 217 * global cpuidle driver variable(s) and set up the broadcast timer if the 218 * cpuidle driver has some states that shut down the local timer. 219 * 220 * Returns 0 on success, a negative error code otherwise: 221 * * -EINVAL if the driver pointer is NULL or no idle states are available 222 * * -ENODEV if the cpuidle framework is disabled 223 * * -EBUSY if the driver is already assigned to the global variable(s) 224 */ 225 static int __cpuidle_register_driver(struct cpuidle_driver *drv) 226 { 227 int ret; 228 229 if (!drv || !drv->state_count) 230 return -EINVAL; 231 232 ret = cpuidle_coupled_state_verify(drv); 233 if (ret) 234 return ret; 235 236 if (cpuidle_disabled()) 237 return -ENODEV; 238 239 __cpuidle_driver_init(drv); 240 241 ret = __cpuidle_set_driver(drv); 242 if (ret) 243 return ret; 244 245 if (drv->bctimer) 246 on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer, 247 (void *)1, 1); 248 249 poll_idle_init(drv); 250 251 return 0; 252 } 253 254 /** 255 * __cpuidle_unregister_driver - unregister the driver 256 * @drv: a valid pointer to a struct cpuidle_driver 257 * 258 * Check if the driver is no longer in use, reset the global cpuidle driver 259 * variable(s) and disable the timer broadcast notification mechanism if it was 260 * in use. 261 * 262 */ 263 static void __cpuidle_unregister_driver(struct cpuidle_driver *drv) 264 { 265 if (WARN_ON(drv->refcnt > 0)) 266 return; 267 268 if (drv->bctimer) { 269 drv->bctimer = 0; 270 on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer, 271 NULL, 1); 272 } 273 274 __cpuidle_unset_driver(drv); 275 } 276 277 /** 278 * cpuidle_register_driver - registers a driver 279 * @drv: a pointer to a valid struct cpuidle_driver 280 * 281 * Register the driver under a lock to prevent concurrent attempts to 282 * [un]register the driver from occuring at the same time. 283 * 284 * Returns 0 on success, a negative error code (returned by 285 * __cpuidle_register_driver()) otherwise. 286 */ 287 int cpuidle_register_driver(struct cpuidle_driver *drv) 288 { 289 int ret; 290 291 spin_lock(&cpuidle_driver_lock); 292 ret = __cpuidle_register_driver(drv); 293 spin_unlock(&cpuidle_driver_lock); 294 295 return ret; 296 } 297 EXPORT_SYMBOL_GPL(cpuidle_register_driver); 298 299 /** 300 * cpuidle_unregister_driver - unregisters a driver 301 * @drv: a pointer to a valid struct cpuidle_driver 302 * 303 * Unregisters the cpuidle driver under a lock to prevent concurrent attempts 304 * to [un]register the driver from occuring at the same time. @drv has to 305 * match the currently registered driver. 306 */ 307 void cpuidle_unregister_driver(struct cpuidle_driver *drv) 308 { 309 spin_lock(&cpuidle_driver_lock); 310 __cpuidle_unregister_driver(drv); 311 spin_unlock(&cpuidle_driver_lock); 312 } 313 EXPORT_SYMBOL_GPL(cpuidle_unregister_driver); 314 315 /** 316 * cpuidle_get_driver - return the driver tied to the current CPU. 317 * 318 * Returns a struct cpuidle_driver pointer, or NULL if no driver is registered. 319 */ 320 struct cpuidle_driver *cpuidle_get_driver(void) 321 { 322 struct cpuidle_driver *drv; 323 int cpu; 324 325 cpu = get_cpu(); 326 drv = __cpuidle_get_cpu_driver(cpu); 327 put_cpu(); 328 329 return drv; 330 } 331 EXPORT_SYMBOL_GPL(cpuidle_get_driver); 332 333 /** 334 * cpuidle_get_cpu_driver - return the driver registered for a CPU. 335 * @dev: a valid pointer to a struct cpuidle_device 336 * 337 * Returns a struct cpuidle_driver pointer, or NULL if no driver is registered 338 * for the CPU associated with @dev. 339 */ 340 struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev) 341 { 342 if (!dev) 343 return NULL; 344 345 return __cpuidle_get_cpu_driver(dev->cpu); 346 } 347 EXPORT_SYMBOL_GPL(cpuidle_get_cpu_driver); 348 349 /** 350 * cpuidle_driver_ref - get a reference to the driver. 351 * 352 * Increment the reference counter of the cpuidle driver associated with 353 * the current CPU. 354 * 355 * Returns a pointer to the driver, or NULL if the current CPU has no driver. 356 */ 357 struct cpuidle_driver *cpuidle_driver_ref(void) 358 { 359 struct cpuidle_driver *drv; 360 361 spin_lock(&cpuidle_driver_lock); 362 363 drv = cpuidle_get_driver(); 364 if (drv) 365 drv->refcnt++; 366 367 spin_unlock(&cpuidle_driver_lock); 368 return drv; 369 } 370 371 /** 372 * cpuidle_driver_unref - puts down the refcount for the driver 373 * 374 * Decrement the reference counter of the cpuidle driver associated with 375 * the current CPU. 376 */ 377 void cpuidle_driver_unref(void) 378 { 379 struct cpuidle_driver *drv; 380 381 spin_lock(&cpuidle_driver_lock); 382 383 drv = cpuidle_get_driver(); 384 if (drv && !WARN_ON(drv->refcnt <= 0)) 385 drv->refcnt--; 386 387 spin_unlock(&cpuidle_driver_lock); 388 } 389