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