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 <linux/clk.h> 15 #include <linux/cpumask.h> 16 #include <linux/completion.h> 17 #include <linux/kobject.h> 18 #include <linux/notifier.h> 19 #include <linux/sysfs.h> 20 21 /********************************************************************* 22 * CPUFREQ INTERFACE * 23 *********************************************************************/ 24 /* 25 * Frequency values here are CPU kHz 26 * 27 * Maximum transition latency is in nanoseconds - if it's unknown, 28 * CPUFREQ_ETERNAL shall be used. 29 */ 30 31 #define CPUFREQ_ETERNAL (-1) 32 #define CPUFREQ_NAME_LEN 16 33 /* Print length for names. Extra 1 space for accomodating '\n' in prints */ 34 #define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1) 35 36 struct cpufreq_governor; 37 38 struct cpufreq_freqs { 39 unsigned int cpu; /* cpu nr */ 40 unsigned int old; 41 unsigned int new; 42 u8 flags; /* flags of cpufreq_driver, see below. */ 43 }; 44 45 struct cpufreq_cpuinfo { 46 unsigned int max_freq; 47 unsigned int min_freq; 48 49 /* in 10^(-9) s = nanoseconds */ 50 unsigned int transition_latency; 51 }; 52 53 struct cpufreq_real_policy { 54 unsigned int min; /* in kHz */ 55 unsigned int max; /* in kHz */ 56 unsigned int policy; /* see above */ 57 struct cpufreq_governor *governor; /* see below */ 58 }; 59 60 struct cpufreq_policy { 61 /* CPUs sharing clock, require sw coordination */ 62 cpumask_var_t cpus; /* Online CPUs only */ 63 cpumask_var_t related_cpus; /* Online + Offline CPUs */ 64 65 unsigned int shared_type; /* ACPI: ANY or ALL affected CPUs 66 should set cpufreq */ 67 unsigned int cpu; /* cpu nr of CPU managing this policy */ 68 unsigned int last_cpu; /* cpu nr of previous CPU that managed 69 * this policy */ 70 struct clk *clk; 71 struct cpufreq_cpuinfo cpuinfo;/* see above */ 72 73 unsigned int min; /* in kHz */ 74 unsigned int max; /* in kHz */ 75 unsigned int cur; /* in kHz, only needed if cpufreq 76 * governors are used */ 77 unsigned int policy; /* see above */ 78 struct cpufreq_governor *governor; /* see below */ 79 void *governor_data; 80 bool governor_enabled; /* governor start/stop flag */ 81 82 struct work_struct update; /* if update_policy() needs to be 83 * called, but you're in IRQ context */ 84 85 struct cpufreq_real_policy user_policy; 86 87 struct list_head policy_list; 88 struct kobject kobj; 89 struct completion kobj_unregister; 90 91 /* 92 * The rules for this semaphore: 93 * - Any routine that wants to read from the policy structure will 94 * do a down_read on this semaphore. 95 * - Any routine that will write to the policy structure and/or may take away 96 * the policy altogether (eg. CPU hotplug), will hold this lock in write 97 * mode before doing so. 98 * 99 * Additional rules: 100 * - Lock should not be held across 101 * __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT); 102 */ 103 struct rw_semaphore rwsem; 104 }; 105 106 /* Only for ACPI */ 107 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */ 108 #define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */ 109 #define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */ 110 #define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/ 111 112 #ifdef CONFIG_CPU_FREQ 113 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu); 114 void cpufreq_cpu_put(struct cpufreq_policy *policy); 115 #else 116 static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu) 117 { 118 return NULL; 119 } 120 static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { } 121 #endif 122 123 static inline bool policy_is_shared(struct cpufreq_policy *policy) 124 { 125 return cpumask_weight(policy->cpus) > 1; 126 } 127 128 /* /sys/devices/system/cpu/cpufreq: entry point for global variables */ 129 extern struct kobject *cpufreq_global_kobject; 130 int cpufreq_get_global_kobject(void); 131 void cpufreq_put_global_kobject(void); 132 int cpufreq_sysfs_create_file(const struct attribute *attr); 133 void cpufreq_sysfs_remove_file(const struct attribute *attr); 134 135 #ifdef CONFIG_CPU_FREQ 136 unsigned int cpufreq_get(unsigned int cpu); 137 unsigned int cpufreq_quick_get(unsigned int cpu); 138 unsigned int cpufreq_quick_get_max(unsigned int cpu); 139 void disable_cpufreq(void); 140 141 u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy); 142 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu); 143 int cpufreq_update_policy(unsigned int cpu); 144 bool have_governor_per_policy(void); 145 struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy); 146 #else 147 static inline unsigned int cpufreq_get(unsigned int cpu) 148 { 149 return 0; 150 } 151 static inline unsigned int cpufreq_quick_get(unsigned int cpu) 152 { 153 return 0; 154 } 155 static inline unsigned int cpufreq_quick_get_max(unsigned int cpu) 156 { 157 return 0; 158 } 159 static inline void disable_cpufreq(void) { } 160 #endif 161 162 /********************************************************************* 163 * CPUFREQ DRIVER INTERFACE * 164 *********************************************************************/ 165 166 #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */ 167 #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */ 168 169 struct freq_attr { 170 struct attribute attr; 171 ssize_t (*show)(struct cpufreq_policy *, char *); 172 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count); 173 }; 174 175 #define cpufreq_freq_attr_ro(_name) \ 176 static struct freq_attr _name = \ 177 __ATTR(_name, 0444, show_##_name, NULL) 178 179 #define cpufreq_freq_attr_ro_perm(_name, _perm) \ 180 static struct freq_attr _name = \ 181 __ATTR(_name, _perm, show_##_name, NULL) 182 183 #define cpufreq_freq_attr_rw(_name) \ 184 static struct freq_attr _name = \ 185 __ATTR(_name, 0644, show_##_name, store_##_name) 186 187 struct global_attr { 188 struct attribute attr; 189 ssize_t (*show)(struct kobject *kobj, 190 struct attribute *attr, char *buf); 191 ssize_t (*store)(struct kobject *a, struct attribute *b, 192 const char *c, size_t count); 193 }; 194 195 #define define_one_global_ro(_name) \ 196 static struct global_attr _name = \ 197 __ATTR(_name, 0444, show_##_name, NULL) 198 199 #define define_one_global_rw(_name) \ 200 static struct global_attr _name = \ 201 __ATTR(_name, 0644, show_##_name, store_##_name) 202 203 204 struct cpufreq_driver { 205 char name[CPUFREQ_NAME_LEN]; 206 u8 flags; 207 208 /* needed by all drivers */ 209 int (*init) (struct cpufreq_policy *policy); 210 int (*verify) (struct cpufreq_policy *policy); 211 212 /* define one out of two */ 213 int (*setpolicy) (struct cpufreq_policy *policy); 214 int (*target) (struct cpufreq_policy *policy, /* Deprecated */ 215 unsigned int target_freq, 216 unsigned int relation); 217 int (*target_index) (struct cpufreq_policy *policy, 218 unsigned int index); 219 220 /* should be defined, if possible */ 221 unsigned int (*get) (unsigned int cpu); 222 223 /* optional */ 224 int (*bios_limit) (int cpu, unsigned int *limit); 225 226 int (*exit) (struct cpufreq_policy *policy); 227 int (*suspend) (struct cpufreq_policy *policy); 228 int (*resume) (struct cpufreq_policy *policy); 229 struct freq_attr **attr; 230 231 /* platform specific boost support code */ 232 bool boost_supported; 233 bool boost_enabled; 234 int (*set_boost) (int state); 235 }; 236 237 /* flags */ 238 #define CPUFREQ_STICKY (1 << 0) /* driver isn't removed even if 239 all ->init() calls failed */ 240 #define CPUFREQ_CONST_LOOPS (1 << 1) /* loops_per_jiffy or other 241 kernel "constants" aren't 242 affected by frequency 243 transitions */ 244 #define CPUFREQ_PM_NO_WARN (1 << 2) /* don't warn on suspend/resume 245 speed mismatches */ 246 247 /* 248 * This should be set by platforms having multiple clock-domains, i.e. 249 * supporting multiple policies. With this sysfs directories of governor would 250 * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same 251 * governor with different tunables for different clusters. 252 */ 253 #define CPUFREQ_HAVE_GOVERNOR_PER_POLICY (1 << 3) 254 255 /* 256 * Driver will do POSTCHANGE notifications from outside of their ->target() 257 * routine and so must set cpufreq_driver->flags with this flag, so that core 258 * can handle them specially. 259 */ 260 #define CPUFREQ_ASYNC_NOTIFICATION (1 << 4) 261 262 /* 263 * Set by drivers which want cpufreq core to check if CPU is running at a 264 * frequency present in freq-table exposed by the driver. For these drivers if 265 * CPU is found running at an out of table freq, we will try to set it to a freq 266 * from the table. And if that fails, we will stop further boot process by 267 * issuing a BUG_ON(). 268 */ 269 #define CPUFREQ_NEED_INITIAL_FREQ_CHECK (1 << 5) 270 271 int cpufreq_register_driver(struct cpufreq_driver *driver_data); 272 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data); 273 274 const char *cpufreq_get_current_driver(void); 275 276 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, 277 unsigned int min, unsigned int max) 278 { 279 if (policy->min < min) 280 policy->min = min; 281 if (policy->max < min) 282 policy->max = min; 283 if (policy->min > max) 284 policy->min = max; 285 if (policy->max > max) 286 policy->max = max; 287 if (policy->min > policy->max) 288 policy->min = policy->max; 289 return; 290 } 291 292 static inline void 293 cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy) 294 { 295 cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq, 296 policy->cpuinfo.max_freq); 297 } 298 299 /********************************************************************* 300 * CPUFREQ NOTIFIER INTERFACE * 301 *********************************************************************/ 302 303 #define CPUFREQ_TRANSITION_NOTIFIER (0) 304 #define CPUFREQ_POLICY_NOTIFIER (1) 305 306 /* Transition notifiers */ 307 #define CPUFREQ_PRECHANGE (0) 308 #define CPUFREQ_POSTCHANGE (1) 309 #define CPUFREQ_RESUMECHANGE (8) 310 #define CPUFREQ_SUSPENDCHANGE (9) 311 312 /* Policy Notifiers */ 313 #define CPUFREQ_ADJUST (0) 314 #define CPUFREQ_INCOMPATIBLE (1) 315 #define CPUFREQ_NOTIFY (2) 316 #define CPUFREQ_START (3) 317 #define CPUFREQ_UPDATE_POLICY_CPU (4) 318 #define CPUFREQ_CREATE_POLICY (5) 319 #define CPUFREQ_REMOVE_POLICY (6) 320 321 #ifdef CONFIG_CPU_FREQ 322 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list); 323 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list); 324 325 void cpufreq_notify_transition(struct cpufreq_policy *policy, 326 struct cpufreq_freqs *freqs, unsigned int state); 327 void cpufreq_notify_post_transition(struct cpufreq_policy *policy, 328 struct cpufreq_freqs *freqs, int transition_failed); 329 330 #else /* CONFIG_CPU_FREQ */ 331 static inline int cpufreq_register_notifier(struct notifier_block *nb, 332 unsigned int list) 333 { 334 return 0; 335 } 336 static inline int cpufreq_unregister_notifier(struct notifier_block *nb, 337 unsigned int list) 338 { 339 return 0; 340 } 341 #endif /* !CONFIG_CPU_FREQ */ 342 343 /** 344 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch 345 * safe) 346 * @old: old value 347 * @div: divisor 348 * @mult: multiplier 349 * 350 * 351 * new = old * mult / div 352 */ 353 static inline unsigned long cpufreq_scale(unsigned long old, u_int div, 354 u_int mult) 355 { 356 #if BITS_PER_LONG == 32 357 u64 result = ((u64) old) * ((u64) mult); 358 do_div(result, div); 359 return (unsigned long) result; 360 361 #elif BITS_PER_LONG == 64 362 unsigned long result = old * ((u64) mult); 363 result /= div; 364 return result; 365 #endif 366 } 367 368 /********************************************************************* 369 * CPUFREQ GOVERNORS * 370 *********************************************************************/ 371 372 /* 373 * If (cpufreq_driver->target) exists, the ->governor decides what frequency 374 * within the limits is used. If (cpufreq_driver->setpolicy> exists, these 375 * two generic policies are available: 376 */ 377 #define CPUFREQ_POLICY_POWERSAVE (1) 378 #define CPUFREQ_POLICY_PERFORMANCE (2) 379 380 /* Governor Events */ 381 #define CPUFREQ_GOV_START 1 382 #define CPUFREQ_GOV_STOP 2 383 #define CPUFREQ_GOV_LIMITS 3 384 #define CPUFREQ_GOV_POLICY_INIT 4 385 #define CPUFREQ_GOV_POLICY_EXIT 5 386 387 struct cpufreq_governor { 388 char name[CPUFREQ_NAME_LEN]; 389 int initialized; 390 int (*governor) (struct cpufreq_policy *policy, 391 unsigned int event); 392 ssize_t (*show_setspeed) (struct cpufreq_policy *policy, 393 char *buf); 394 int (*store_setspeed) (struct cpufreq_policy *policy, 395 unsigned int freq); 396 unsigned int max_transition_latency; /* HW must be able to switch to 397 next freq faster than this value in nano secs or we 398 will fallback to performance governor */ 399 struct list_head governor_list; 400 struct module *owner; 401 }; 402 403 /* Pass a target to the cpufreq driver */ 404 int cpufreq_driver_target(struct cpufreq_policy *policy, 405 unsigned int target_freq, 406 unsigned int relation); 407 int __cpufreq_driver_target(struct cpufreq_policy *policy, 408 unsigned int target_freq, 409 unsigned int relation); 410 int cpufreq_register_governor(struct cpufreq_governor *governor); 411 void cpufreq_unregister_governor(struct cpufreq_governor *governor); 412 413 /* CPUFREQ DEFAULT GOVERNOR */ 414 /* 415 * Performance governor is fallback governor if any other gov failed to auto 416 * load due latency restrictions 417 */ 418 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE 419 extern struct cpufreq_governor cpufreq_gov_performance; 420 #endif 421 #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE 422 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_performance) 423 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE) 424 extern struct cpufreq_governor cpufreq_gov_powersave; 425 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_powersave) 426 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE) 427 extern struct cpufreq_governor cpufreq_gov_userspace; 428 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_userspace) 429 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND) 430 extern struct cpufreq_governor cpufreq_gov_ondemand; 431 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_ondemand) 432 #elif defined(CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE) 433 extern struct cpufreq_governor cpufreq_gov_conservative; 434 #define CPUFREQ_DEFAULT_GOVERNOR (&cpufreq_gov_conservative) 435 #endif 436 437 /********************************************************************* 438 * FREQUENCY TABLE HELPERS * 439 *********************************************************************/ 440 441 #define CPUFREQ_ENTRY_INVALID ~0 442 #define CPUFREQ_TABLE_END ~1 443 #define CPUFREQ_BOOST_FREQ ~2 444 445 struct cpufreq_frequency_table { 446 unsigned int driver_data; /* driver specific data, not used by core */ 447 unsigned int frequency; /* kHz - doesn't need to be in ascending 448 * order */ 449 }; 450 451 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, 452 struct cpufreq_frequency_table *table); 453 454 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, 455 struct cpufreq_frequency_table *table); 456 int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy); 457 458 int cpufreq_frequency_table_target(struct cpufreq_policy *policy, 459 struct cpufreq_frequency_table *table, 460 unsigned int target_freq, 461 unsigned int relation, 462 unsigned int *index); 463 int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy, 464 unsigned int freq); 465 466 void cpufreq_frequency_table_update_policy_cpu(struct cpufreq_policy *policy); 467 ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf); 468 469 #ifdef CONFIG_CPU_FREQ 470 int cpufreq_boost_trigger_state(int state); 471 int cpufreq_boost_supported(void); 472 int cpufreq_boost_enabled(void); 473 #else 474 static inline int cpufreq_boost_trigger_state(int state) 475 { 476 return 0; 477 } 478 static inline int cpufreq_boost_supported(void) 479 { 480 return 0; 481 } 482 static inline int cpufreq_boost_enabled(void) 483 { 484 return 0; 485 } 486 #endif 487 /* the following funtion is for cpufreq core use only */ 488 struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu); 489 490 /* the following are really really optional */ 491 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs; 492 extern struct freq_attr *cpufreq_generic_attr[]; 493 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table, 494 unsigned int cpu); 495 void cpufreq_frequency_table_put_attr(unsigned int cpu); 496 int cpufreq_table_validate_and_show(struct cpufreq_policy *policy, 497 struct cpufreq_frequency_table *table); 498 499 unsigned int cpufreq_generic_get(unsigned int cpu); 500 int cpufreq_generic_init(struct cpufreq_policy *policy, 501 struct cpufreq_frequency_table *table, 502 unsigned int transition_latency); 503 static inline int cpufreq_generic_exit(struct cpufreq_policy *policy) 504 { 505 cpufreq_frequency_table_put_attr(policy->cpu); 506 return 0; 507 } 508 509 #endif /* _LINUX_CPUFREQ_H */ 510