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