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