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 /* CPUs sharing clock, require sw coordination */ 93 cpumask_var_t cpus; /* Online CPUs only */ 94 cpumask_var_t related_cpus; /* Online + Offline CPUs */ 95 96 unsigned int shared_type; /* ACPI: ANY or ALL affected CPUs 97 should set cpufreq */ 98 unsigned int cpu; /* cpu nr of CPU managing this policy */ 99 unsigned int last_cpu; /* cpu nr of previous CPU that managed 100 * this policy */ 101 struct cpufreq_cpuinfo cpuinfo;/* see above */ 102 103 unsigned int min; /* in kHz */ 104 unsigned int max; /* in kHz */ 105 unsigned int cur; /* in kHz, only needed if cpufreq 106 * governors are used */ 107 unsigned int policy; /* see above */ 108 struct cpufreq_governor *governor; /* see below */ 109 void *governor_data; 110 111 struct work_struct update; /* if update_policy() needs to be 112 * called, but you're in IRQ context */ 113 114 struct cpufreq_real_policy user_policy; 115 116 struct kobject kobj; 117 struct completion kobj_unregister; 118 }; 119 120 #define CPUFREQ_ADJUST (0) 121 #define CPUFREQ_INCOMPATIBLE (1) 122 #define CPUFREQ_NOTIFY (2) 123 #define CPUFREQ_START (3) 124 #define CPUFREQ_UPDATE_POLICY_CPU (4) 125 126 /* Only for ACPI */ 127 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */ 128 #define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */ 129 #define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */ 130 #define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/ 131 132 static inline bool policy_is_shared(struct cpufreq_policy *policy) 133 { 134 return cpumask_weight(policy->cpus) > 1; 135 } 136 137 /******************** cpufreq transition notifiers *******************/ 138 139 #define CPUFREQ_PRECHANGE (0) 140 #define CPUFREQ_POSTCHANGE (1) 141 #define CPUFREQ_RESUMECHANGE (8) 142 #define CPUFREQ_SUSPENDCHANGE (9) 143 144 struct cpufreq_freqs { 145 unsigned int cpu; /* cpu nr */ 146 unsigned int old; 147 unsigned int new; 148 u8 flags; /* flags of cpufreq_driver, see below. */ 149 }; 150 151 152 /** 153 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch safe) 154 * @old: old value 155 * @div: divisor 156 * @mult: multiplier 157 * 158 * 159 * new = old * mult / div 160 */ 161 static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mult) 162 { 163 #if BITS_PER_LONG == 32 164 165 u64 result = ((u64) old) * ((u64) mult); 166 do_div(result, div); 167 return (unsigned long) result; 168 169 #elif BITS_PER_LONG == 64 170 171 unsigned long result = old * ((u64) mult); 172 result /= div; 173 return result; 174 175 #endif 176 }; 177 178 /********************************************************************* 179 * CPUFREQ GOVERNORS * 180 *********************************************************************/ 181 182 #define CPUFREQ_GOV_START 1 183 #define CPUFREQ_GOV_STOP 2 184 #define CPUFREQ_GOV_LIMITS 3 185 #define CPUFREQ_GOV_POLICY_INIT 4 186 #define CPUFREQ_GOV_POLICY_EXIT 5 187 188 struct cpufreq_governor { 189 char name[CPUFREQ_NAME_LEN]; 190 int initialized; 191 int (*governor) (struct cpufreq_policy *policy, 192 unsigned int event); 193 ssize_t (*show_setspeed) (struct cpufreq_policy *policy, 194 char *buf); 195 int (*store_setspeed) (struct cpufreq_policy *policy, 196 unsigned int freq); 197 unsigned int max_transition_latency; /* HW must be able to switch to 198 next freq faster than this value in nano secs or we 199 will fallback to performance governor */ 200 struct list_head governor_list; 201 struct module *owner; 202 }; 203 204 /* 205 * Pass a target to the cpufreq driver. 206 */ 207 extern int cpufreq_driver_target(struct cpufreq_policy *policy, 208 unsigned int target_freq, 209 unsigned int relation); 210 extern int __cpufreq_driver_target(struct cpufreq_policy *policy, 211 unsigned int target_freq, 212 unsigned int relation); 213 214 215 extern int __cpufreq_driver_getavg(struct cpufreq_policy *policy, 216 unsigned int cpu); 217 218 int cpufreq_register_governor(struct cpufreq_governor *governor); 219 void cpufreq_unregister_governor(struct cpufreq_governor *governor); 220 221 222 /********************************************************************* 223 * CPUFREQ DRIVER INTERFACE * 224 *********************************************************************/ 225 226 #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */ 227 #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */ 228 229 struct freq_attr; 230 231 struct cpufreq_driver { 232 struct module *owner; 233 char name[CPUFREQ_NAME_LEN]; 234 u8 flags; 235 /* 236 * This should be set by platforms having multiple clock-domains, i.e. 237 * supporting multiple policies. With this sysfs directories of governor 238 * would be created in cpu/cpu<num>/cpufreq/ directory and so they can 239 * use the same governor with different tunables for different clusters. 240 */ 241 bool have_governor_per_policy; 242 243 /* needed by all drivers */ 244 int (*init) (struct cpufreq_policy *policy); 245 int (*verify) (struct cpufreq_policy *policy); 246 247 /* define one out of two */ 248 int (*setpolicy) (struct cpufreq_policy *policy); 249 int (*target) (struct cpufreq_policy *policy, 250 unsigned int target_freq, 251 unsigned int relation); 252 253 /* should be defined, if possible */ 254 unsigned int (*get) (unsigned int cpu); 255 256 /* optional */ 257 unsigned int (*getavg) (struct cpufreq_policy *policy, 258 unsigned int cpu); 259 int (*bios_limit) (int cpu, unsigned int *limit); 260 261 int (*exit) (struct cpufreq_policy *policy); 262 int (*suspend) (struct cpufreq_policy *policy); 263 int (*resume) (struct cpufreq_policy *policy); 264 struct freq_attr **attr; 265 }; 266 267 /* flags */ 268 269 #define CPUFREQ_STICKY 0x01 /* the driver isn't removed even if 270 * all ->init() calls failed */ 271 #define CPUFREQ_CONST_LOOPS 0x02 /* loops_per_jiffy or other kernel 272 * "constants" aren't affected by 273 * frequency transitions */ 274 #define CPUFREQ_PM_NO_WARN 0x04 /* don't warn on suspend/resume speed 275 * mismatches */ 276 277 int cpufreq_register_driver(struct cpufreq_driver *driver_data); 278 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data); 279 280 281 void cpufreq_notify_transition(struct cpufreq_policy *policy, 282 struct cpufreq_freqs *freqs, unsigned int state); 283 284 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned int min, unsigned int max) 285 { 286 if (policy->min < min) 287 policy->min = min; 288 if (policy->max < min) 289 policy->max = min; 290 if (policy->min > max) 291 policy->min = max; 292 if (policy->max > max) 293 policy->max = max; 294 if (policy->min > policy->max) 295 policy->min = policy->max; 296 return; 297 } 298 299 struct freq_attr { 300 struct attribute attr; 301 ssize_t (*show)(struct cpufreq_policy *, char *); 302 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count); 303 }; 304 305 #define cpufreq_freq_attr_ro(_name) \ 306 static struct freq_attr _name = \ 307 __ATTR(_name, 0444, show_##_name, NULL) 308 309 #define cpufreq_freq_attr_ro_perm(_name, _perm) \ 310 static struct freq_attr _name = \ 311 __ATTR(_name, _perm, show_##_name, NULL) 312 313 #define cpufreq_freq_attr_rw(_name) \ 314 static struct freq_attr _name = \ 315 __ATTR(_name, 0644, show_##_name, store_##_name) 316 317 struct global_attr { 318 struct attribute attr; 319 ssize_t (*show)(struct kobject *kobj, 320 struct attribute *attr, char *buf); 321 ssize_t (*store)(struct kobject *a, struct attribute *b, 322 const char *c, size_t count); 323 }; 324 325 #define define_one_global_ro(_name) \ 326 static struct global_attr _name = \ 327 __ATTR(_name, 0444, show_##_name, NULL) 328 329 #define define_one_global_rw(_name) \ 330 static struct global_attr _name = \ 331 __ATTR(_name, 0644, show_##_name, store_##_name) 332 333 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu); 334 void cpufreq_cpu_put(struct cpufreq_policy *data); 335 const char *cpufreq_get_current_driver(void); 336 337 /********************************************************************* 338 * CPUFREQ 2.6. INTERFACE * 339 *********************************************************************/ 340 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu); 341 int cpufreq_update_policy(unsigned int cpu); 342 bool have_governor_per_policy(void); 343 344 #ifdef CONFIG_CPU_FREQ 345 /* query the current CPU frequency (in kHz). If zero, cpufreq couldn't detect it */ 346 unsigned int cpufreq_get(unsigned int cpu); 347 #else 348 static inline unsigned int cpufreq_get(unsigned int cpu) 349 { 350 return 0; 351 } 352 #endif 353 354 /* query the last known CPU freq (in kHz). If zero, cpufreq couldn't detect it */ 355 #ifdef CONFIG_CPU_FREQ 356 unsigned int cpufreq_quick_get(unsigned int cpu); 357 unsigned int cpufreq_quick_get_max(unsigned int cpu); 358 #else 359 static inline unsigned int cpufreq_quick_get(unsigned int cpu) 360 { 361 return 0; 362 } 363 static inline unsigned int cpufreq_quick_get_max(unsigned int cpu) 364 { 365 return 0; 366 } 367 #endif 368 369 370 /********************************************************************* 371 * CPUFREQ DEFAULT GOVERNOR * 372 *********************************************************************/ 373 374 375 /* 376 Performance governor is fallback governor if any other gov failed to 377 auto load due latency restrictions 378 */ 379 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE 380 extern struct cpufreq_governor cpufreq_gov_performance; 381 #endif 382 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE 383 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_performance) 384 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE) 385 extern struct cpufreq_governor cpufreq_gov_powersave; 386 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_powersave) 387 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE) 388 extern struct cpufreq_governor cpufreq_gov_userspace; 389 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_userspace) 390 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND) 391 extern struct cpufreq_governor cpufreq_gov_ondemand; 392 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_ondemand) 393 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE) 394 extern struct cpufreq_governor cpufreq_gov_conservative; 395 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_conservative) 396 #endif 397 398 399 /********************************************************************* 400 * FREQUENCY TABLE HELPERS * 401 *********************************************************************/ 402 403 #define CPUFREQ_ENTRY_INVALID ~0 404 #define CPUFREQ_TABLE_END ~1 405 406 struct cpufreq_frequency_table { 407 unsigned int index; /* any */ 408 unsigned int frequency; /* kHz - doesn't need to be in ascending 409 * order */ 410 }; 411 412 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, 413 struct cpufreq_frequency_table *table); 414 415 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, 416 struct cpufreq_frequency_table *table); 417 418 int cpufreq_frequency_table_target(struct cpufreq_policy *policy, 419 struct cpufreq_frequency_table *table, 420 unsigned int target_freq, 421 unsigned int relation, 422 unsigned int *index); 423 424 /* the following 3 funtions are for cpufreq core use only */ 425 struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu); 426 427 /* the following are really really optional */ 428 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs; 429 430 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table, 431 unsigned int cpu); 432 void cpufreq_frequency_table_update_policy_cpu(struct cpufreq_policy *policy); 433 434 void cpufreq_frequency_table_put_attr(unsigned int cpu); 435 #endif /* _LINUX_CPUFREQ_H */ 436