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 /** 183 * __cpuidle_register_driver: register the driver 184 * @drv: a valid pointer to a struct cpuidle_driver 185 * 186 * Do some sanity checks, initialize the driver, assign the driver to the 187 * global cpuidle driver variable(s) and set up the broadcast timer if the 188 * cpuidle driver has some states that shut down the local timer. 189 * 190 * Returns 0 on success, a negative error code otherwise: 191 * * -EINVAL if the driver pointer is NULL or no idle states are available 192 * * -ENODEV if the cpuidle framework is disabled 193 * * -EBUSY if the driver is already assigned to the global variable(s) 194 */ 195 static int __cpuidle_register_driver(struct cpuidle_driver *drv) 196 { 197 int ret; 198 199 if (!drv || !drv->state_count) 200 return -EINVAL; 201 202 ret = cpuidle_coupled_state_verify(drv); 203 if (ret) 204 return ret; 205 206 if (cpuidle_disabled()) 207 return -ENODEV; 208 209 __cpuidle_driver_init(drv); 210 211 ret = __cpuidle_set_driver(drv); 212 if (ret) 213 return ret; 214 215 if (drv->bctimer) 216 on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer, 217 (void *)1, 1); 218 219 return 0; 220 } 221 222 /** 223 * __cpuidle_unregister_driver - unregister the driver 224 * @drv: a valid pointer to a struct cpuidle_driver 225 * 226 * Check if the driver is no longer in use, reset the global cpuidle driver 227 * variable(s) and disable the timer broadcast notification mechanism if it was 228 * in use. 229 * 230 */ 231 static void __cpuidle_unregister_driver(struct cpuidle_driver *drv) 232 { 233 if (WARN_ON(drv->refcnt > 0)) 234 return; 235 236 if (drv->bctimer) { 237 drv->bctimer = 0; 238 on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer, 239 NULL, 1); 240 } 241 242 __cpuidle_unset_driver(drv); 243 } 244 245 /** 246 * cpuidle_register_driver - registers a driver 247 * @drv: a pointer to a valid struct cpuidle_driver 248 * 249 * Register the driver under a lock to prevent concurrent attempts to 250 * [un]register the driver from occuring at the same time. 251 * 252 * Returns 0 on success, a negative error code (returned by 253 * __cpuidle_register_driver()) otherwise. 254 */ 255 int cpuidle_register_driver(struct cpuidle_driver *drv) 256 { 257 int ret; 258 259 spin_lock(&cpuidle_driver_lock); 260 ret = __cpuidle_register_driver(drv); 261 spin_unlock(&cpuidle_driver_lock); 262 263 return ret; 264 } 265 EXPORT_SYMBOL_GPL(cpuidle_register_driver); 266 267 /** 268 * cpuidle_unregister_driver - unregisters a driver 269 * @drv: a pointer to a valid struct cpuidle_driver 270 * 271 * Unregisters the cpuidle driver under a lock to prevent concurrent attempts 272 * to [un]register the driver from occuring at the same time. @drv has to 273 * match the currently registered driver. 274 */ 275 void cpuidle_unregister_driver(struct cpuidle_driver *drv) 276 { 277 spin_lock(&cpuidle_driver_lock); 278 __cpuidle_unregister_driver(drv); 279 spin_unlock(&cpuidle_driver_lock); 280 } 281 EXPORT_SYMBOL_GPL(cpuidle_unregister_driver); 282 283 /** 284 * cpuidle_get_driver - return the driver tied to the current CPU. 285 * 286 * Returns a struct cpuidle_driver pointer, or NULL if no driver is registered. 287 */ 288 struct cpuidle_driver *cpuidle_get_driver(void) 289 { 290 struct cpuidle_driver *drv; 291 int cpu; 292 293 cpu = get_cpu(); 294 drv = __cpuidle_get_cpu_driver(cpu); 295 put_cpu(); 296 297 return drv; 298 } 299 EXPORT_SYMBOL_GPL(cpuidle_get_driver); 300 301 /** 302 * cpuidle_get_cpu_driver - return the driver registered for a CPU. 303 * @dev: a valid pointer to a struct cpuidle_device 304 * 305 * Returns a struct cpuidle_driver pointer, or NULL if no driver is registered 306 * for the CPU associated with @dev. 307 */ 308 struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev) 309 { 310 if (!dev) 311 return NULL; 312 313 return __cpuidle_get_cpu_driver(dev->cpu); 314 } 315 EXPORT_SYMBOL_GPL(cpuidle_get_cpu_driver); 316 317 /** 318 * cpuidle_driver_ref - get a reference to the driver. 319 * 320 * Increment the reference counter of the cpuidle driver associated with 321 * the current CPU. 322 * 323 * Returns a pointer to the driver, or NULL if the current CPU has no driver. 324 */ 325 struct cpuidle_driver *cpuidle_driver_ref(void) 326 { 327 struct cpuidle_driver *drv; 328 329 spin_lock(&cpuidle_driver_lock); 330 331 drv = cpuidle_get_driver(); 332 if (drv) 333 drv->refcnt++; 334 335 spin_unlock(&cpuidle_driver_lock); 336 return drv; 337 } 338 339 /** 340 * cpuidle_driver_unref - puts down the refcount for the driver 341 * 342 * Decrement the reference counter of the cpuidle driver associated with 343 * the current CPU. 344 */ 345 void cpuidle_driver_unref(void) 346 { 347 struct cpuidle_driver *drv; 348 349 spin_lock(&cpuidle_driver_lock); 350 351 drv = cpuidle_get_driver(); 352 if (drv && !WARN_ON(drv->refcnt <= 0)) 353 drv->refcnt--; 354 355 spin_unlock(&cpuidle_driver_lock); 356 } 357