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