1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 /* 3 * linux/include/linux/cpufreq.h 4 * 5 * Copyright (C) 2001 Russell King 6 * (C) 2002 - 2003 Dominik Brodowski <[email protected]> 7 */ 8 #ifndef _LINUX_CPUFREQ_H 9 #define _LINUX_CPUFREQ_H 10 11 #include <linux/clk.h> 12 #include <linux/cpumask.h> 13 #include <linux/completion.h> 14 #include <linux/kobject.h> 15 #include <linux/notifier.h> 16 #include <linux/spinlock.h> 17 #include <linux/sysfs.h> 18 19 /********************************************************************* 20 * CPUFREQ INTERFACE * 21 *********************************************************************/ 22 /* 23 * Frequency values here are CPU kHz 24 * 25 * Maximum transition latency is in nanoseconds - if it's unknown, 26 * CPUFREQ_ETERNAL shall be used. 27 */ 28 29 #define CPUFREQ_ETERNAL (-1) 30 #define CPUFREQ_NAME_LEN 16 31 /* Print length for names. Extra 1 space for accommodating '\n' in prints */ 32 #define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1) 33 34 struct cpufreq_governor; 35 36 enum cpufreq_table_sorting { 37 CPUFREQ_TABLE_UNSORTED, 38 CPUFREQ_TABLE_SORTED_ASCENDING, 39 CPUFREQ_TABLE_SORTED_DESCENDING 40 }; 41 42 struct cpufreq_cpuinfo { 43 unsigned int max_freq; 44 unsigned int min_freq; 45 46 /* in 10^(-9) s = nanoseconds */ 47 unsigned int transition_latency; 48 }; 49 50 struct cpufreq_policy { 51 /* CPUs sharing clock, require sw coordination */ 52 cpumask_var_t cpus; /* Online CPUs only */ 53 cpumask_var_t related_cpus; /* Online + Offline CPUs */ 54 cpumask_var_t real_cpus; /* Related and present */ 55 56 unsigned int shared_type; /* ACPI: ANY or ALL affected CPUs 57 should set cpufreq */ 58 unsigned int cpu; /* cpu managing this policy, must be online */ 59 60 struct clk *clk; 61 struct cpufreq_cpuinfo cpuinfo;/* see above */ 62 63 unsigned int min; /* in kHz */ 64 unsigned int max; /* in kHz */ 65 unsigned int cur; /* in kHz, only needed if cpufreq 66 * governors are used */ 67 unsigned int restore_freq; /* = policy->cur before transition */ 68 unsigned int suspend_freq; /* freq to set during suspend */ 69 70 unsigned int policy; /* see above */ 71 unsigned int last_policy; /* policy before unplug */ 72 struct cpufreq_governor *governor; /* see below */ 73 void *governor_data; 74 char last_governor[CPUFREQ_NAME_LEN]; /* last governor used */ 75 76 struct work_struct update; /* if update_policy() needs to be 77 * called, but you're in IRQ context */ 78 79 struct dev_pm_qos_request *min_freq_req; 80 struct dev_pm_qos_request *max_freq_req; 81 struct cpufreq_frequency_table *freq_table; 82 enum cpufreq_table_sorting freq_table_sorted; 83 84 struct list_head policy_list; 85 struct kobject kobj; 86 struct completion kobj_unregister; 87 88 /* 89 * The rules for this semaphore: 90 * - Any routine that wants to read from the policy structure will 91 * do a down_read on this semaphore. 92 * - Any routine that will write to the policy structure and/or may take away 93 * the policy altogether (eg. CPU hotplug), will hold this lock in write 94 * mode before doing so. 95 */ 96 struct rw_semaphore rwsem; 97 98 /* 99 * Fast switch flags: 100 * - fast_switch_possible should be set by the driver if it can 101 * guarantee that frequency can be changed on any CPU sharing the 102 * policy and that the change will affect all of the policy CPUs then. 103 * - fast_switch_enabled is to be set by governors that support fast 104 * frequency switching with the help of cpufreq_enable_fast_switch(). 105 */ 106 bool fast_switch_possible; 107 bool fast_switch_enabled; 108 109 /* 110 * Preferred average time interval between consecutive invocations of 111 * the driver to set the frequency for this policy. To be set by the 112 * scaling driver (0, which is the default, means no preference). 113 */ 114 unsigned int transition_delay_us; 115 116 /* 117 * Remote DVFS flag (Not added to the driver structure as we don't want 118 * to access another structure from scheduler hotpath). 119 * 120 * Should be set if CPUs can do DVFS on behalf of other CPUs from 121 * different cpufreq policies. 122 */ 123 bool dvfs_possible_from_any_cpu; 124 125 /* Cached frequency lookup from cpufreq_driver_resolve_freq. */ 126 unsigned int cached_target_freq; 127 int cached_resolved_idx; 128 129 /* Synchronization for frequency transitions */ 130 bool transition_ongoing; /* Tracks transition status */ 131 spinlock_t transition_lock; 132 wait_queue_head_t transition_wait; 133 struct task_struct *transition_task; /* Task which is doing the transition */ 134 135 /* cpufreq-stats */ 136 struct cpufreq_stats *stats; 137 138 /* For cpufreq driver's internal use */ 139 void *driver_data; 140 141 /* Pointer to the cooling device if used for thermal mitigation */ 142 struct thermal_cooling_device *cdev; 143 144 struct notifier_block nb_min; 145 struct notifier_block nb_max; 146 }; 147 148 struct cpufreq_freqs { 149 struct cpufreq_policy *policy; 150 unsigned int old; 151 unsigned int new; 152 u8 flags; /* flags of cpufreq_driver, see below. */ 153 }; 154 155 /* Only for ACPI */ 156 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */ 157 #define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */ 158 #define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */ 159 #define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/ 160 161 #ifdef CONFIG_CPU_FREQ 162 struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu); 163 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu); 164 void cpufreq_cpu_put(struct cpufreq_policy *policy); 165 #else 166 static inline struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu) 167 { 168 return NULL; 169 } 170 static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu) 171 { 172 return NULL; 173 } 174 static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { } 175 #endif 176 177 static inline bool policy_is_inactive(struct cpufreq_policy *policy) 178 { 179 return cpumask_empty(policy->cpus); 180 } 181 182 static inline bool policy_is_shared(struct cpufreq_policy *policy) 183 { 184 return cpumask_weight(policy->cpus) > 1; 185 } 186 187 /* /sys/devices/system/cpu/cpufreq: entry point for global variables */ 188 extern struct kobject *cpufreq_global_kobject; 189 190 #ifdef CONFIG_CPU_FREQ 191 unsigned int cpufreq_get(unsigned int cpu); 192 unsigned int cpufreq_quick_get(unsigned int cpu); 193 unsigned int cpufreq_quick_get_max(unsigned int cpu); 194 void disable_cpufreq(void); 195 196 u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy); 197 198 struct cpufreq_policy *cpufreq_cpu_acquire(unsigned int cpu); 199 void cpufreq_cpu_release(struct cpufreq_policy *policy); 200 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu); 201 int cpufreq_set_policy(struct cpufreq_policy *policy, 202 struct cpufreq_policy *new_policy); 203 void refresh_frequency_limits(struct cpufreq_policy *policy); 204 void cpufreq_update_policy(unsigned int cpu); 205 void cpufreq_update_limits(unsigned int cpu); 206 bool have_governor_per_policy(void); 207 struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy); 208 void cpufreq_enable_fast_switch(struct cpufreq_policy *policy); 209 void cpufreq_disable_fast_switch(struct cpufreq_policy *policy); 210 #else 211 static inline unsigned int cpufreq_get(unsigned int cpu) 212 { 213 return 0; 214 } 215 static inline unsigned int cpufreq_quick_get(unsigned int cpu) 216 { 217 return 0; 218 } 219 static inline unsigned int cpufreq_quick_get_max(unsigned int cpu) 220 { 221 return 0; 222 } 223 static inline void disable_cpufreq(void) { } 224 #endif 225 226 #ifdef CONFIG_CPU_FREQ_STAT 227 void cpufreq_stats_create_table(struct cpufreq_policy *policy); 228 void cpufreq_stats_free_table(struct cpufreq_policy *policy); 229 void cpufreq_stats_record_transition(struct cpufreq_policy *policy, 230 unsigned int new_freq); 231 #else 232 static inline void cpufreq_stats_create_table(struct cpufreq_policy *policy) { } 233 static inline void cpufreq_stats_free_table(struct cpufreq_policy *policy) { } 234 static inline void cpufreq_stats_record_transition(struct cpufreq_policy *policy, 235 unsigned int new_freq) { } 236 #endif /* CONFIG_CPU_FREQ_STAT */ 237 238 /********************************************************************* 239 * CPUFREQ DRIVER INTERFACE * 240 *********************************************************************/ 241 242 #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */ 243 #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */ 244 #define CPUFREQ_RELATION_C 2 /* closest frequency to target */ 245 246 struct freq_attr { 247 struct attribute attr; 248 ssize_t (*show)(struct cpufreq_policy *, char *); 249 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count); 250 }; 251 252 #define cpufreq_freq_attr_ro(_name) \ 253 static struct freq_attr _name = \ 254 __ATTR(_name, 0444, show_##_name, NULL) 255 256 #define cpufreq_freq_attr_ro_perm(_name, _perm) \ 257 static struct freq_attr _name = \ 258 __ATTR(_name, _perm, show_##_name, NULL) 259 260 #define cpufreq_freq_attr_rw(_name) \ 261 static struct freq_attr _name = \ 262 __ATTR(_name, 0644, show_##_name, store_##_name) 263 264 #define cpufreq_freq_attr_wo(_name) \ 265 static struct freq_attr _name = \ 266 __ATTR(_name, 0200, NULL, store_##_name) 267 268 #define define_one_global_ro(_name) \ 269 static struct kobj_attribute _name = \ 270 __ATTR(_name, 0444, show_##_name, NULL) 271 272 #define define_one_global_rw(_name) \ 273 static struct kobj_attribute _name = \ 274 __ATTR(_name, 0644, show_##_name, store_##_name) 275 276 277 struct cpufreq_driver { 278 char name[CPUFREQ_NAME_LEN]; 279 u8 flags; 280 void *driver_data; 281 282 /* needed by all drivers */ 283 int (*init)(struct cpufreq_policy *policy); 284 int (*verify)(struct cpufreq_policy *policy); 285 286 /* define one out of two */ 287 int (*setpolicy)(struct cpufreq_policy *policy); 288 289 /* 290 * On failure, should always restore frequency to policy->restore_freq 291 * (i.e. old freq). 292 */ 293 int (*target)(struct cpufreq_policy *policy, 294 unsigned int target_freq, 295 unsigned int relation); /* Deprecated */ 296 int (*target_index)(struct cpufreq_policy *policy, 297 unsigned int index); 298 unsigned int (*fast_switch)(struct cpufreq_policy *policy, 299 unsigned int target_freq); 300 301 /* 302 * Caches and returns the lowest driver-supported frequency greater than 303 * or equal to the target frequency, subject to any driver limitations. 304 * Does not set the frequency. Only to be implemented for drivers with 305 * target(). 306 */ 307 unsigned int (*resolve_freq)(struct cpufreq_policy *policy, 308 unsigned int target_freq); 309 310 /* 311 * Only for drivers with target_index() and CPUFREQ_ASYNC_NOTIFICATION 312 * unset. 313 * 314 * get_intermediate should return a stable intermediate frequency 315 * platform wants to switch to and target_intermediate() should set CPU 316 * to to that frequency, before jumping to the frequency corresponding 317 * to 'index'. Core will take care of sending notifications and driver 318 * doesn't have to handle them in target_intermediate() or 319 * target_index(). 320 * 321 * Drivers can return '0' from get_intermediate() in case they don't 322 * wish to switch to intermediate frequency for some target frequency. 323 * In that case core will directly call ->target_index(). 324 */ 325 unsigned int (*get_intermediate)(struct cpufreq_policy *policy, 326 unsigned int index); 327 int (*target_intermediate)(struct cpufreq_policy *policy, 328 unsigned int index); 329 330 /* should be defined, if possible */ 331 unsigned int (*get)(unsigned int cpu); 332 333 /* Called to update policy limits on firmware notifications. */ 334 void (*update_limits)(unsigned int cpu); 335 336 /* optional */ 337 int (*bios_limit)(int cpu, unsigned int *limit); 338 339 int (*online)(struct cpufreq_policy *policy); 340 int (*offline)(struct cpufreq_policy *policy); 341 int (*exit)(struct cpufreq_policy *policy); 342 void (*stop_cpu)(struct cpufreq_policy *policy); 343 int (*suspend)(struct cpufreq_policy *policy); 344 int (*resume)(struct cpufreq_policy *policy); 345 346 /* Will be called after the driver is fully initialized */ 347 void (*ready)(struct cpufreq_policy *policy); 348 349 struct freq_attr **attr; 350 351 /* platform specific boost support code */ 352 bool boost_enabled; 353 int (*set_boost)(int state); 354 }; 355 356 /* flags */ 357 358 /* driver isn't removed even if all ->init() calls failed */ 359 #define CPUFREQ_STICKY BIT(0) 360 361 /* loops_per_jiffy or other kernel "constants" aren't affected by frequency transitions */ 362 #define CPUFREQ_CONST_LOOPS BIT(1) 363 364 /* don't warn on suspend/resume speed mismatches */ 365 #define CPUFREQ_PM_NO_WARN BIT(2) 366 367 /* 368 * This should be set by platforms having multiple clock-domains, i.e. 369 * supporting multiple policies. With this sysfs directories of governor would 370 * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same 371 * governor with different tunables for different clusters. 372 */ 373 #define CPUFREQ_HAVE_GOVERNOR_PER_POLICY BIT(3) 374 375 /* 376 * Driver will do POSTCHANGE notifications from outside of their ->target() 377 * routine and so must set cpufreq_driver->flags with this flag, so that core 378 * can handle them specially. 379 */ 380 #define CPUFREQ_ASYNC_NOTIFICATION BIT(4) 381 382 /* 383 * Set by drivers which want cpufreq core to check if CPU is running at a 384 * frequency present in freq-table exposed by the driver. For these drivers if 385 * CPU is found running at an out of table freq, we will try to set it to a freq 386 * from the table. And if that fails, we will stop further boot process by 387 * issuing a BUG_ON(). 388 */ 389 #define CPUFREQ_NEED_INITIAL_FREQ_CHECK BIT(5) 390 391 /* 392 * Set by drivers to disallow use of governors with "dynamic_switching" flag 393 * set. 394 */ 395 #define CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING BIT(6) 396 397 /* 398 * Set by drivers that want the core to automatically register the cpufreq 399 * driver as a thermal cooling device. 400 */ 401 #define CPUFREQ_IS_COOLING_DEV BIT(7) 402 403 int cpufreq_register_driver(struct cpufreq_driver *driver_data); 404 int cpufreq_unregister_driver(struct cpufreq_driver *driver_data); 405 406 const char *cpufreq_get_current_driver(void); 407 void *cpufreq_get_driver_data(void); 408 409 static inline int cpufreq_thermal_control_enabled(struct cpufreq_driver *drv) 410 { 411 return IS_ENABLED(CONFIG_CPU_THERMAL) && 412 (drv->flags & CPUFREQ_IS_COOLING_DEV); 413 } 414 415 static inline void cpufreq_verify_within_limits(struct cpufreq_policy *policy, 416 unsigned int min, unsigned int max) 417 { 418 if (policy->min < min) 419 policy->min = min; 420 if (policy->max < min) 421 policy->max = min; 422 if (policy->min > max) 423 policy->min = max; 424 if (policy->max > max) 425 policy->max = max; 426 if (policy->min > policy->max) 427 policy->min = policy->max; 428 return; 429 } 430 431 static inline void 432 cpufreq_verify_within_cpu_limits(struct cpufreq_policy *policy) 433 { 434 cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq, 435 policy->cpuinfo.max_freq); 436 } 437 438 #ifdef CONFIG_CPU_FREQ 439 void cpufreq_suspend(void); 440 void cpufreq_resume(void); 441 int cpufreq_generic_suspend(struct cpufreq_policy *policy); 442 #else 443 static inline void cpufreq_suspend(void) {} 444 static inline void cpufreq_resume(void) {} 445 #endif 446 447 /********************************************************************* 448 * CPUFREQ NOTIFIER INTERFACE * 449 *********************************************************************/ 450 451 #define CPUFREQ_TRANSITION_NOTIFIER (0) 452 #define CPUFREQ_POLICY_NOTIFIER (1) 453 454 /* Transition notifiers */ 455 #define CPUFREQ_PRECHANGE (0) 456 #define CPUFREQ_POSTCHANGE (1) 457 458 /* Policy Notifiers */ 459 #define CPUFREQ_ADJUST (0) 460 #define CPUFREQ_NOTIFY (1) 461 462 #ifdef CONFIG_CPU_FREQ 463 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list); 464 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list); 465 466 void cpufreq_freq_transition_begin(struct cpufreq_policy *policy, 467 struct cpufreq_freqs *freqs); 468 void cpufreq_freq_transition_end(struct cpufreq_policy *policy, 469 struct cpufreq_freqs *freqs, int transition_failed); 470 471 #else /* CONFIG_CPU_FREQ */ 472 static inline int cpufreq_register_notifier(struct notifier_block *nb, 473 unsigned int list) 474 { 475 return 0; 476 } 477 static inline int cpufreq_unregister_notifier(struct notifier_block *nb, 478 unsigned int list) 479 { 480 return 0; 481 } 482 #endif /* !CONFIG_CPU_FREQ */ 483 484 /** 485 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch 486 * safe) 487 * @old: old value 488 * @div: divisor 489 * @mult: multiplier 490 * 491 * 492 * new = old * mult / div 493 */ 494 static inline unsigned long cpufreq_scale(unsigned long old, u_int div, 495 u_int mult) 496 { 497 #if BITS_PER_LONG == 32 498 u64 result = ((u64) old) * ((u64) mult); 499 do_div(result, div); 500 return (unsigned long) result; 501 502 #elif BITS_PER_LONG == 64 503 unsigned long result = old * ((u64) mult); 504 result /= div; 505 return result; 506 #endif 507 } 508 509 /********************************************************************* 510 * CPUFREQ GOVERNORS * 511 *********************************************************************/ 512 513 /* 514 * If (cpufreq_driver->target) exists, the ->governor decides what frequency 515 * within the limits is used. If (cpufreq_driver->setpolicy> exists, these 516 * two generic policies are available: 517 */ 518 #define CPUFREQ_POLICY_POWERSAVE (1) 519 #define CPUFREQ_POLICY_PERFORMANCE (2) 520 521 /* 522 * The polling frequency depends on the capability of the processor. Default 523 * polling frequency is 1000 times the transition latency of the processor. The 524 * ondemand governor will work on any processor with transition latency <= 10ms, 525 * using appropriate sampling rate. 526 */ 527 #define LATENCY_MULTIPLIER (1000) 528 529 struct cpufreq_governor { 530 char name[CPUFREQ_NAME_LEN]; 531 int (*init)(struct cpufreq_policy *policy); 532 void (*exit)(struct cpufreq_policy *policy); 533 int (*start)(struct cpufreq_policy *policy); 534 void (*stop)(struct cpufreq_policy *policy); 535 void (*limits)(struct cpufreq_policy *policy); 536 ssize_t (*show_setspeed) (struct cpufreq_policy *policy, 537 char *buf); 538 int (*store_setspeed) (struct cpufreq_policy *policy, 539 unsigned int freq); 540 /* For governors which change frequency dynamically by themselves */ 541 bool dynamic_switching; 542 struct list_head governor_list; 543 struct module *owner; 544 }; 545 546 /* Pass a target to the cpufreq driver */ 547 unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy, 548 unsigned int target_freq); 549 int cpufreq_driver_target(struct cpufreq_policy *policy, 550 unsigned int target_freq, 551 unsigned int relation); 552 int __cpufreq_driver_target(struct cpufreq_policy *policy, 553 unsigned int target_freq, 554 unsigned int relation); 555 unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy, 556 unsigned int target_freq); 557 unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy *policy); 558 int cpufreq_register_governor(struct cpufreq_governor *governor); 559 void cpufreq_unregister_governor(struct cpufreq_governor *governor); 560 561 struct cpufreq_governor *cpufreq_default_governor(void); 562 struct cpufreq_governor *cpufreq_fallback_governor(void); 563 564 static inline void cpufreq_policy_apply_limits(struct cpufreq_policy *policy) 565 { 566 if (policy->max < policy->cur) 567 __cpufreq_driver_target(policy, policy->max, CPUFREQ_RELATION_H); 568 else if (policy->min > policy->cur) 569 __cpufreq_driver_target(policy, policy->min, CPUFREQ_RELATION_L); 570 } 571 572 /* Governor attribute set */ 573 struct gov_attr_set { 574 struct kobject kobj; 575 struct list_head policy_list; 576 struct mutex update_lock; 577 int usage_count; 578 }; 579 580 /* sysfs ops for cpufreq governors */ 581 extern const struct sysfs_ops governor_sysfs_ops; 582 583 void gov_attr_set_init(struct gov_attr_set *attr_set, struct list_head *list_node); 584 void gov_attr_set_get(struct gov_attr_set *attr_set, struct list_head *list_node); 585 unsigned int gov_attr_set_put(struct gov_attr_set *attr_set, struct list_head *list_node); 586 587 /* Governor sysfs attribute */ 588 struct governor_attr { 589 struct attribute attr; 590 ssize_t (*show)(struct gov_attr_set *attr_set, char *buf); 591 ssize_t (*store)(struct gov_attr_set *attr_set, const char *buf, 592 size_t count); 593 }; 594 595 static inline bool cpufreq_this_cpu_can_update(struct cpufreq_policy *policy) 596 { 597 /* 598 * Allow remote callbacks if: 599 * - dvfs_possible_from_any_cpu flag is set 600 * - the local and remote CPUs share cpufreq policy 601 */ 602 return policy->dvfs_possible_from_any_cpu || 603 cpumask_test_cpu(smp_processor_id(), policy->cpus); 604 } 605 606 /********************************************************************* 607 * FREQUENCY TABLE HELPERS * 608 *********************************************************************/ 609 610 /* Special Values of .frequency field */ 611 #define CPUFREQ_ENTRY_INVALID ~0u 612 #define CPUFREQ_TABLE_END ~1u 613 /* Special Values of .flags field */ 614 #define CPUFREQ_BOOST_FREQ (1 << 0) 615 616 struct cpufreq_frequency_table { 617 unsigned int flags; 618 unsigned int driver_data; /* driver specific data, not used by core */ 619 unsigned int frequency; /* kHz - doesn't need to be in ascending 620 * order */ 621 }; 622 623 #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP) 624 int dev_pm_opp_init_cpufreq_table(struct device *dev, 625 struct cpufreq_frequency_table **table); 626 void dev_pm_opp_free_cpufreq_table(struct device *dev, 627 struct cpufreq_frequency_table **table); 628 #else 629 static inline int dev_pm_opp_init_cpufreq_table(struct device *dev, 630 struct cpufreq_frequency_table 631 **table) 632 { 633 return -EINVAL; 634 } 635 636 static inline void dev_pm_opp_free_cpufreq_table(struct device *dev, 637 struct cpufreq_frequency_table 638 **table) 639 { 640 } 641 #endif 642 643 /* 644 * cpufreq_for_each_entry - iterate over a cpufreq_frequency_table 645 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 646 * @table: the cpufreq_frequency_table * to iterate over. 647 */ 648 649 #define cpufreq_for_each_entry(pos, table) \ 650 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) 651 652 /* 653 * cpufreq_for_each_entry_idx - iterate over a cpufreq_frequency_table 654 * with index 655 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 656 * @table: the cpufreq_frequency_table * to iterate over. 657 * @idx: the table entry currently being processed 658 */ 659 660 #define cpufreq_for_each_entry_idx(pos, table, idx) \ 661 for (pos = table, idx = 0; pos->frequency != CPUFREQ_TABLE_END; \ 662 pos++, idx++) 663 664 /* 665 * cpufreq_for_each_valid_entry - iterate over a cpufreq_frequency_table 666 * excluding CPUFREQ_ENTRY_INVALID frequencies. 667 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 668 * @table: the cpufreq_frequency_table * to iterate over. 669 */ 670 671 #define cpufreq_for_each_valid_entry(pos, table) \ 672 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) \ 673 if (pos->frequency == CPUFREQ_ENTRY_INVALID) \ 674 continue; \ 675 else 676 677 /* 678 * cpufreq_for_each_valid_entry_idx - iterate with index over a cpufreq 679 * frequency_table excluding CPUFREQ_ENTRY_INVALID frequencies. 680 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 681 * @table: the cpufreq_frequency_table * to iterate over. 682 * @idx: the table entry currently being processed 683 */ 684 685 #define cpufreq_for_each_valid_entry_idx(pos, table, idx) \ 686 cpufreq_for_each_entry_idx(pos, table, idx) \ 687 if (pos->frequency == CPUFREQ_ENTRY_INVALID) \ 688 continue; \ 689 else 690 691 692 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, 693 struct cpufreq_frequency_table *table); 694 695 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, 696 struct cpufreq_frequency_table *table); 697 int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy); 698 699 int cpufreq_table_index_unsorted(struct cpufreq_policy *policy, 700 unsigned int target_freq, 701 unsigned int relation); 702 int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy, 703 unsigned int freq); 704 705 ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf); 706 707 #ifdef CONFIG_CPU_FREQ 708 int cpufreq_boost_trigger_state(int state); 709 int cpufreq_boost_enabled(void); 710 int cpufreq_enable_boost_support(void); 711 bool policy_has_boost_freq(struct cpufreq_policy *policy); 712 713 /* Find lowest freq at or above target in a table in ascending order */ 714 static inline int cpufreq_table_find_index_al(struct cpufreq_policy *policy, 715 unsigned int target_freq) 716 { 717 struct cpufreq_frequency_table *table = policy->freq_table; 718 struct cpufreq_frequency_table *pos; 719 unsigned int freq; 720 int idx, best = -1; 721 722 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 723 freq = pos->frequency; 724 725 if (freq >= target_freq) 726 return idx; 727 728 best = idx; 729 } 730 731 return best; 732 } 733 734 /* Find lowest freq at or above target in a table in descending order */ 735 static inline int cpufreq_table_find_index_dl(struct cpufreq_policy *policy, 736 unsigned int target_freq) 737 { 738 struct cpufreq_frequency_table *table = policy->freq_table; 739 struct cpufreq_frequency_table *pos; 740 unsigned int freq; 741 int idx, best = -1; 742 743 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 744 freq = pos->frequency; 745 746 if (freq == target_freq) 747 return idx; 748 749 if (freq > target_freq) { 750 best = idx; 751 continue; 752 } 753 754 /* No freq found above target_freq */ 755 if (best == -1) 756 return idx; 757 758 return best; 759 } 760 761 return best; 762 } 763 764 /* Works only on sorted freq-tables */ 765 static inline int cpufreq_table_find_index_l(struct cpufreq_policy *policy, 766 unsigned int target_freq) 767 { 768 target_freq = clamp_val(target_freq, policy->min, policy->max); 769 770 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING) 771 return cpufreq_table_find_index_al(policy, target_freq); 772 else 773 return cpufreq_table_find_index_dl(policy, target_freq); 774 } 775 776 /* Find highest freq at or below target in a table in ascending order */ 777 static inline int cpufreq_table_find_index_ah(struct cpufreq_policy *policy, 778 unsigned int target_freq) 779 { 780 struct cpufreq_frequency_table *table = policy->freq_table; 781 struct cpufreq_frequency_table *pos; 782 unsigned int freq; 783 int idx, best = -1; 784 785 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 786 freq = pos->frequency; 787 788 if (freq == target_freq) 789 return idx; 790 791 if (freq < target_freq) { 792 best = idx; 793 continue; 794 } 795 796 /* No freq found below target_freq */ 797 if (best == -1) 798 return idx; 799 800 return best; 801 } 802 803 return best; 804 } 805 806 /* Find highest freq at or below target in a table in descending order */ 807 static inline int cpufreq_table_find_index_dh(struct cpufreq_policy *policy, 808 unsigned int target_freq) 809 { 810 struct cpufreq_frequency_table *table = policy->freq_table; 811 struct cpufreq_frequency_table *pos; 812 unsigned int freq; 813 int idx, best = -1; 814 815 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 816 freq = pos->frequency; 817 818 if (freq <= target_freq) 819 return idx; 820 821 best = idx; 822 } 823 824 return best; 825 } 826 827 /* Works only on sorted freq-tables */ 828 static inline int cpufreq_table_find_index_h(struct cpufreq_policy *policy, 829 unsigned int target_freq) 830 { 831 target_freq = clamp_val(target_freq, policy->min, policy->max); 832 833 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING) 834 return cpufreq_table_find_index_ah(policy, target_freq); 835 else 836 return cpufreq_table_find_index_dh(policy, target_freq); 837 } 838 839 /* Find closest freq to target in a table in ascending order */ 840 static inline int cpufreq_table_find_index_ac(struct cpufreq_policy *policy, 841 unsigned int target_freq) 842 { 843 struct cpufreq_frequency_table *table = policy->freq_table; 844 struct cpufreq_frequency_table *pos; 845 unsigned int freq; 846 int idx, best = -1; 847 848 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 849 freq = pos->frequency; 850 851 if (freq == target_freq) 852 return idx; 853 854 if (freq < target_freq) { 855 best = idx; 856 continue; 857 } 858 859 /* No freq found below target_freq */ 860 if (best == -1) 861 return idx; 862 863 /* Choose the closest freq */ 864 if (target_freq - table[best].frequency > freq - target_freq) 865 return idx; 866 867 return best; 868 } 869 870 return best; 871 } 872 873 /* Find closest freq to target in a table in descending order */ 874 static inline int cpufreq_table_find_index_dc(struct cpufreq_policy *policy, 875 unsigned int target_freq) 876 { 877 struct cpufreq_frequency_table *table = policy->freq_table; 878 struct cpufreq_frequency_table *pos; 879 unsigned int freq; 880 int idx, best = -1; 881 882 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 883 freq = pos->frequency; 884 885 if (freq == target_freq) 886 return idx; 887 888 if (freq > target_freq) { 889 best = idx; 890 continue; 891 } 892 893 /* No freq found above target_freq */ 894 if (best == -1) 895 return idx; 896 897 /* Choose the closest freq */ 898 if (table[best].frequency - target_freq > target_freq - freq) 899 return idx; 900 901 return best; 902 } 903 904 return best; 905 } 906 907 /* Works only on sorted freq-tables */ 908 static inline int cpufreq_table_find_index_c(struct cpufreq_policy *policy, 909 unsigned int target_freq) 910 { 911 target_freq = clamp_val(target_freq, policy->min, policy->max); 912 913 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING) 914 return cpufreq_table_find_index_ac(policy, target_freq); 915 else 916 return cpufreq_table_find_index_dc(policy, target_freq); 917 } 918 919 static inline int cpufreq_frequency_table_target(struct cpufreq_policy *policy, 920 unsigned int target_freq, 921 unsigned int relation) 922 { 923 if (unlikely(policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED)) 924 return cpufreq_table_index_unsorted(policy, target_freq, 925 relation); 926 927 switch (relation) { 928 case CPUFREQ_RELATION_L: 929 return cpufreq_table_find_index_l(policy, target_freq); 930 case CPUFREQ_RELATION_H: 931 return cpufreq_table_find_index_h(policy, target_freq); 932 case CPUFREQ_RELATION_C: 933 return cpufreq_table_find_index_c(policy, target_freq); 934 default: 935 pr_err("%s: Invalid relation: %d\n", __func__, relation); 936 return -EINVAL; 937 } 938 } 939 940 static inline int cpufreq_table_count_valid_entries(const struct cpufreq_policy *policy) 941 { 942 struct cpufreq_frequency_table *pos; 943 int count = 0; 944 945 if (unlikely(!policy->freq_table)) 946 return 0; 947 948 cpufreq_for_each_valid_entry(pos, policy->freq_table) 949 count++; 950 951 return count; 952 } 953 #else 954 static inline int cpufreq_boost_trigger_state(int state) 955 { 956 return 0; 957 } 958 static inline int cpufreq_boost_enabled(void) 959 { 960 return 0; 961 } 962 963 static inline int cpufreq_enable_boost_support(void) 964 { 965 return -EINVAL; 966 } 967 968 static inline bool policy_has_boost_freq(struct cpufreq_policy *policy) 969 { 970 return false; 971 } 972 #endif 973 974 #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL) 975 void sched_cpufreq_governor_change(struct cpufreq_policy *policy, 976 struct cpufreq_governor *old_gov); 977 #else 978 static inline void sched_cpufreq_governor_change(struct cpufreq_policy *policy, 979 struct cpufreq_governor *old_gov) { } 980 #endif 981 982 extern void arch_freq_prepare_all(void); 983 extern unsigned int arch_freq_get_on_cpu(int cpu); 984 985 extern void arch_set_freq_scale(struct cpumask *cpus, unsigned long cur_freq, 986 unsigned long max_freq); 987 988 /* the following are really really optional */ 989 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs; 990 extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs; 991 extern struct freq_attr *cpufreq_generic_attr[]; 992 int cpufreq_table_validate_and_sort(struct cpufreq_policy *policy); 993 994 unsigned int cpufreq_generic_get(unsigned int cpu); 995 void cpufreq_generic_init(struct cpufreq_policy *policy, 996 struct cpufreq_frequency_table *table, 997 unsigned int transition_latency); 998 #endif /* _LINUX_CPUFREQ_H */ 999