1 /* 2 * linux/include/linux/cpufreq.h 3 * 4 * Copyright (C) 2001 Russell King 5 * (C) 2002 - 2003 Dominik Brodowski <[email protected]> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #ifndef _LINUX_CPUFREQ_H 12 #define _LINUX_CPUFREQ_H 13 14 #include <asm/cputime.h> 15 #include <linux/mutex.h> 16 #include <linux/notifier.h> 17 #include <linux/threads.h> 18 #include <linux/kobject.h> 19 #include <linux/sysfs.h> 20 #include <linux/completion.h> 21 #include <linux/workqueue.h> 22 #include <linux/cpumask.h> 23 #include <asm/div64.h> 24 25 #define CPUFREQ_NAME_LEN 16 26 /* Print length for names. Extra 1 space for accomodating '\n' in prints */ 27 #define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1) 28 29 30 /********************************************************************* 31 * CPUFREQ NOTIFIER INTERFACE * 32 *********************************************************************/ 33 34 #define CPUFREQ_TRANSITION_NOTIFIER (0) 35 #define CPUFREQ_POLICY_NOTIFIER (1) 36 37 #ifdef CONFIG_CPU_FREQ 38 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list); 39 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list); 40 extern void disable_cpufreq(void); 41 #else /* CONFIG_CPU_FREQ */ 42 static inline int cpufreq_register_notifier(struct notifier_block *nb, 43 unsigned int list) 44 { 45 return 0; 46 } 47 static inline int cpufreq_unregister_notifier(struct notifier_block *nb, 48 unsigned int list) 49 { 50 return 0; 51 } 52 static inline void disable_cpufreq(void) { } 53 #endif /* CONFIG_CPU_FREQ */ 54 55 /* if (cpufreq_driver->target) exists, the ->governor decides what frequency 56 * within the limits is used. If (cpufreq_driver->setpolicy> exists, these 57 * two generic policies are available: 58 */ 59 60 #define CPUFREQ_POLICY_POWERSAVE (1) 61 #define CPUFREQ_POLICY_PERFORMANCE (2) 62 63 /* Frequency values here are CPU kHz so that hardware which doesn't run 64 * with some frequencies can complain without having to guess what per 65 * cent / per mille means. 66 * Maximum transition latency is in nanoseconds - if it's unknown, 67 * CPUFREQ_ETERNAL shall be used. 68 */ 69 70 struct cpufreq_governor; 71 72 /* /sys/devices/system/cpu/cpufreq: entry point for global variables */ 73 extern struct kobject *cpufreq_global_kobject; 74 75 #define CPUFREQ_ETERNAL (-1) 76 struct cpufreq_cpuinfo { 77 unsigned int max_freq; 78 unsigned int min_freq; 79 80 /* in 10^(-9) s = nanoseconds */ 81 unsigned int transition_latency; 82 }; 83 84 struct cpufreq_real_policy { 85 unsigned int min; /* in kHz */ 86 unsigned int max; /* in kHz */ 87 unsigned int policy; /* see above */ 88 struct cpufreq_governor *governor; /* see below */ 89 }; 90 91 struct cpufreq_policy { 92 cpumask_var_t cpus; /* CPUs requiring sw coordination */ 93 cpumask_var_t related_cpus; /* CPUs with any coordination */ 94 unsigned int shared_type; /* ANY or ALL affected CPUs 95 should set cpufreq */ 96 unsigned int cpu; /* cpu nr of registered CPU */ 97 struct cpufreq_cpuinfo cpuinfo;/* see above */ 98 99 unsigned int min; /* in kHz */ 100 unsigned int max; /* in kHz */ 101 unsigned int cur; /* in kHz, only needed if cpufreq 102 * governors are used */ 103 unsigned int policy; /* see above */ 104 struct cpufreq_governor *governor; /* see below */ 105 106 struct work_struct update; /* if update_policy() needs to be 107 * called, but you're in IRQ context */ 108 109 struct cpufreq_real_policy user_policy; 110 111 struct kobject kobj; 112 struct completion kobj_unregister; 113 }; 114 115 #define CPUFREQ_ADJUST (0) 116 #define CPUFREQ_INCOMPATIBLE (1) 117 #define CPUFREQ_NOTIFY (2) 118 #define CPUFREQ_START (3) 119 120 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */ 121 #define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */ 122 #define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */ 123 #define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/ 124 125 /******************** cpufreq transition notifiers *******************/ 126 127 #define CPUFREQ_PRECHANGE (0) 128 #define CPUFREQ_POSTCHANGE (1) 129 #define CPUFREQ_RESUMECHANGE (8) 130 #define CPUFREQ_SUSPENDCHANGE (9) 131 132 struct cpufreq_freqs { 133 unsigned int cpu; /* cpu nr */ 134 unsigned int old; 135 unsigned int new; 136 u8 flags; /* flags of cpufreq_driver, see below. */ 137 }; 138 139 140 /** 141 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch safe) 142 * @old: old value 143 * @div: divisor 144 * @mult: multiplier 145 * 146 * 147 * new = old * mult / div 148 */ 149 static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mult) 150 { 151 #if BITS_PER_LONG == 32 152 153 u64 result = ((u64) old) * ((u64) mult); 154 do_div(result, div); 155 return (unsigned long) result; 156 157 #elif BITS_PER_LONG == 64 158 159 unsigned long result = old * ((u64) mult); 160 result /= div; 161 return result; 162 163 #endif 164 }; 165 166 /********************************************************************* 167 * CPUFREQ GOVERNORS * 168 *********************************************************************/ 169 170 #define CPUFREQ_GOV_START 1 171 #define CPUFREQ_GOV_STOP 2 172 #define CPUFREQ_GOV_LIMITS 3 173 174 struct cpufreq_governor { 175 char name[CPUFREQ_NAME_LEN]; 176 int (*governor) (struct cpufreq_policy *policy, 177 unsigned int event); 178 ssize_t (*show_setspeed) (struct cpufreq_policy *policy, 179 char *buf); 180 int (*store_setspeed) (struct cpufreq_policy *policy, 181 unsigned int freq); 182 unsigned int max_transition_latency; /* HW must be able to switch to 183 next freq faster than this value in nano secs or we 184 will fallback to performance governor */ 185 struct list_head governor_list; 186 struct module *owner; 187 }; 188 189 /* 190 * Pass a target to the cpufreq driver. 191 */ 192 extern int cpufreq_driver_target(struct cpufreq_policy *policy, 193 unsigned int target_freq, 194 unsigned int relation); 195 extern int __cpufreq_driver_target(struct cpufreq_policy *policy, 196 unsigned int target_freq, 197 unsigned int relation); 198 199 200 extern int __cpufreq_driver_getavg(struct cpufreq_policy *policy, 201 unsigned int cpu); 202 203 int cpufreq_register_governor(struct cpufreq_governor *governor); 204 void cpufreq_unregister_governor(struct cpufreq_governor *governor); 205 206 207 /********************************************************************* 208 * CPUFREQ DRIVER INTERFACE * 209 *********************************************************************/ 210 211 #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */ 212 #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */ 213 214 struct freq_attr; 215 216 struct cpufreq_driver { 217 struct module *owner; 218 char name[CPUFREQ_NAME_LEN]; 219 u8 flags; 220 221 /* needed by all drivers */ 222 int (*init) (struct cpufreq_policy *policy); 223 int (*verify) (struct cpufreq_policy *policy); 224 225 /* define one out of two */ 226 int (*setpolicy) (struct cpufreq_policy *policy); 227 int (*target) (struct cpufreq_policy *policy, 228 unsigned int target_freq, 229 unsigned int relation); 230 231 /* should be defined, if possible */ 232 unsigned int (*get) (unsigned int cpu); 233 234 /* optional */ 235 unsigned int (*getavg) (struct cpufreq_policy *policy, 236 unsigned int cpu); 237 int (*bios_limit) (int cpu, unsigned int *limit); 238 239 int (*exit) (struct cpufreq_policy *policy); 240 int (*suspend) (struct cpufreq_policy *policy); 241 int (*resume) (struct cpufreq_policy *policy); 242 struct freq_attr **attr; 243 }; 244 245 /* flags */ 246 247 #define CPUFREQ_STICKY 0x01 /* the driver isn't removed even if 248 * all ->init() calls failed */ 249 #define CPUFREQ_CONST_LOOPS 0x02 /* loops_per_jiffy or other kernel 250 * "constants" aren't affected by 251 * frequency transitions */ 252 #define CPUFREQ_PM_NO_WARN 0x04 /* don't warn on suspend/resume speed 253 * mismatches */ 254 255 int cpufreq_register_driver(struct cpufreq_driver *driver_data); 256 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data); 257 258 259 void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state); 260 261 262 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned int min, unsigned int max) 263 { 264 if (policy->min < min) 265 policy->min = min; 266 if (policy->max < min) 267 policy->max = min; 268 if (policy->min > max) 269 policy->min = max; 270 if (policy->max > max) 271 policy->max = max; 272 if (policy->min > policy->max) 273 policy->min = policy->max; 274 return; 275 } 276 277 struct freq_attr { 278 struct attribute attr; 279 ssize_t (*show)(struct cpufreq_policy *, char *); 280 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count); 281 }; 282 283 #define cpufreq_freq_attr_ro(_name) \ 284 static struct freq_attr _name = \ 285 __ATTR(_name, 0444, show_##_name, NULL) 286 287 #define cpufreq_freq_attr_ro_perm(_name, _perm) \ 288 static struct freq_attr _name = \ 289 __ATTR(_name, _perm, show_##_name, NULL) 290 291 #define cpufreq_freq_attr_rw(_name) \ 292 static struct freq_attr _name = \ 293 __ATTR(_name, 0644, show_##_name, store_##_name) 294 295 struct global_attr { 296 struct attribute attr; 297 ssize_t (*show)(struct kobject *kobj, 298 struct attribute *attr, char *buf); 299 ssize_t (*store)(struct kobject *a, struct attribute *b, 300 const char *c, size_t count); 301 }; 302 303 #define define_one_global_ro(_name) \ 304 static struct global_attr _name = \ 305 __ATTR(_name, 0444, show_##_name, NULL) 306 307 #define define_one_global_rw(_name) \ 308 static struct global_attr _name = \ 309 __ATTR(_name, 0644, show_##_name, store_##_name) 310 311 312 /********************************************************************* 313 * CPUFREQ 2.6. INTERFACE * 314 *********************************************************************/ 315 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu); 316 int cpufreq_update_policy(unsigned int cpu); 317 318 #ifdef CONFIG_CPU_FREQ 319 /* query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it */ 320 unsigned int cpufreq_get(unsigned int cpu); 321 #else 322 static inline unsigned int cpufreq_get(unsigned int cpu) 323 { 324 return 0; 325 } 326 #endif 327 328 /* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it */ 329 #ifdef CONFIG_CPU_FREQ 330 unsigned int cpufreq_quick_get(unsigned int cpu); 331 unsigned int cpufreq_quick_get_max(unsigned int cpu); 332 #else 333 static inline unsigned int cpufreq_quick_get(unsigned int cpu) 334 { 335 return 0; 336 } 337 static inline unsigned int cpufreq_quick_get_max(unsigned int cpu) 338 { 339 return 0; 340 } 341 #endif 342 343 344 /********************************************************************* 345 * CPUFREQ DEFAULT GOVERNOR * 346 *********************************************************************/ 347 348 349 /* 350 Performance governor is fallback governor if any other gov failed to 351 auto load due latency restrictions 352 */ 353 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE 354 extern struct cpufreq_governor cpufreq_gov_performance; 355 #endif 356 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE 357 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_performance) 358 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE) 359 extern struct cpufreq_governor cpufreq_gov_powersave; 360 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_powersave) 361 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE) 362 extern struct cpufreq_governor cpufreq_gov_userspace; 363 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_userspace) 364 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND) 365 extern struct cpufreq_governor cpufreq_gov_ondemand; 366 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_ondemand) 367 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE) 368 extern struct cpufreq_governor cpufreq_gov_conservative; 369 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_conservative) 370 #endif 371 372 373 /********************************************************************* 374 * FREQUENCY TABLE HELPERS * 375 *********************************************************************/ 376 377 #define CPUFREQ_ENTRY_INVALID ~0 378 #define CPUFREQ_TABLE_END ~1 379 380 struct cpufreq_frequency_table { 381 unsigned int index; /* any */ 382 unsigned int frequency; /* kHz - doesn't need to be in ascending 383 * order */ 384 }; 385 386 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, 387 struct cpufreq_frequency_table *table); 388 389 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, 390 struct cpufreq_frequency_table *table); 391 392 int cpufreq_frequency_table_target(struct cpufreq_policy *policy, 393 struct cpufreq_frequency_table *table, 394 unsigned int target_freq, 395 unsigned int relation, 396 unsigned int *index); 397 398 /* the following 3 funtions are for cpufreq core use only */ 399 struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu); 400 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu); 401 void cpufreq_cpu_put(struct cpufreq_policy *data); 402 403 /* the following are really really optional */ 404 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs; 405 406 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table, 407 unsigned int cpu); 408 409 void cpufreq_frequency_table_put_attr(unsigned int cpu); 410 #endif /* _LINUX_CPUFREQ_H */ 411