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 /********************************************************************* 599 * FREQUENCY TABLE HELPERS * 600 *********************************************************************/ 601 602 /* Special Values of .frequency field */ 603 #define CPUFREQ_ENTRY_INVALID ~0u 604 #define CPUFREQ_TABLE_END ~1u 605 /* Special Values of .flags field */ 606 #define CPUFREQ_BOOST_FREQ (1 << 0) 607 608 struct cpufreq_frequency_table { 609 unsigned int flags; 610 unsigned int driver_data; /* driver specific data, not used by core */ 611 unsigned int frequency; /* kHz - doesn't need to be in ascending 612 * order */ 613 }; 614 615 #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP) 616 int dev_pm_opp_init_cpufreq_table(struct device *dev, 617 struct cpufreq_frequency_table **table); 618 void dev_pm_opp_free_cpufreq_table(struct device *dev, 619 struct cpufreq_frequency_table **table); 620 #else 621 static inline int dev_pm_opp_init_cpufreq_table(struct device *dev, 622 struct cpufreq_frequency_table 623 **table) 624 { 625 return -EINVAL; 626 } 627 628 static inline void dev_pm_opp_free_cpufreq_table(struct device *dev, 629 struct cpufreq_frequency_table 630 **table) 631 { 632 } 633 #endif 634 635 /* 636 * cpufreq_for_each_entry - iterate over a cpufreq_frequency_table 637 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 638 * @table: the cpufreq_frequency_table * to iterate over. 639 */ 640 641 #define cpufreq_for_each_entry(pos, table) \ 642 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) 643 644 /* 645 * cpufreq_for_each_entry_idx - iterate over a cpufreq_frequency_table 646 * with index 647 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 648 * @table: the cpufreq_frequency_table * to iterate over. 649 * @idx: the table entry currently being processed 650 */ 651 652 #define cpufreq_for_each_entry_idx(pos, table, idx) \ 653 for (pos = table, idx = 0; pos->frequency != CPUFREQ_TABLE_END; \ 654 pos++, idx++) 655 656 /* 657 * cpufreq_for_each_valid_entry - iterate over a cpufreq_frequency_table 658 * excluding CPUFREQ_ENTRY_INVALID frequencies. 659 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 660 * @table: the cpufreq_frequency_table * to iterate over. 661 */ 662 663 #define cpufreq_for_each_valid_entry(pos, table) \ 664 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) \ 665 if (pos->frequency == CPUFREQ_ENTRY_INVALID) \ 666 continue; \ 667 else 668 669 /* 670 * cpufreq_for_each_valid_entry_idx - iterate with index over a cpufreq 671 * frequency_table excluding CPUFREQ_ENTRY_INVALID frequencies. 672 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 673 * @table: the cpufreq_frequency_table * to iterate over. 674 * @idx: the table entry currently being processed 675 */ 676 677 #define cpufreq_for_each_valid_entry_idx(pos, table, idx) \ 678 cpufreq_for_each_entry_idx(pos, table, idx) \ 679 if (pos->frequency == CPUFREQ_ENTRY_INVALID) \ 680 continue; \ 681 else 682 683 684 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, 685 struct cpufreq_frequency_table *table); 686 687 int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, 688 struct cpufreq_frequency_table *table); 689 int cpufreq_generic_frequency_table_verify(struct cpufreq_policy *policy); 690 691 int cpufreq_table_index_unsorted(struct cpufreq_policy *policy, 692 unsigned int target_freq, 693 unsigned int relation); 694 int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy, 695 unsigned int freq); 696 697 ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf); 698 699 #ifdef CONFIG_CPU_FREQ 700 int cpufreq_boost_trigger_state(int state); 701 int cpufreq_boost_enabled(void); 702 int cpufreq_enable_boost_support(void); 703 bool policy_has_boost_freq(struct cpufreq_policy *policy); 704 705 /* Find lowest freq at or above target in a table in ascending order */ 706 static inline int cpufreq_table_find_index_al(struct cpufreq_policy *policy, 707 unsigned int target_freq) 708 { 709 struct cpufreq_frequency_table *table = policy->freq_table; 710 struct cpufreq_frequency_table *pos; 711 unsigned int freq; 712 int idx, best = -1; 713 714 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 715 freq = pos->frequency; 716 717 if (freq >= target_freq) 718 return idx; 719 720 best = idx; 721 } 722 723 return best; 724 } 725 726 /* Find lowest freq at or above target in a table in descending order */ 727 static inline int cpufreq_table_find_index_dl(struct cpufreq_policy *policy, 728 unsigned int target_freq) 729 { 730 struct cpufreq_frequency_table *table = policy->freq_table; 731 struct cpufreq_frequency_table *pos; 732 unsigned int freq; 733 int idx, best = -1; 734 735 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 736 freq = pos->frequency; 737 738 if (freq == target_freq) 739 return idx; 740 741 if (freq > target_freq) { 742 best = idx; 743 continue; 744 } 745 746 /* No freq found above target_freq */ 747 if (best == -1) 748 return idx; 749 750 return best; 751 } 752 753 return best; 754 } 755 756 /* Works only on sorted freq-tables */ 757 static inline int cpufreq_table_find_index_l(struct cpufreq_policy *policy, 758 unsigned int target_freq) 759 { 760 target_freq = clamp_val(target_freq, policy->min, policy->max); 761 762 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING) 763 return cpufreq_table_find_index_al(policy, target_freq); 764 else 765 return cpufreq_table_find_index_dl(policy, target_freq); 766 } 767 768 /* Find highest freq at or below target in a table in ascending order */ 769 static inline int cpufreq_table_find_index_ah(struct cpufreq_policy *policy, 770 unsigned int target_freq) 771 { 772 struct cpufreq_frequency_table *table = policy->freq_table; 773 struct cpufreq_frequency_table *pos; 774 unsigned int freq; 775 int idx, best = -1; 776 777 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 778 freq = pos->frequency; 779 780 if (freq == target_freq) 781 return idx; 782 783 if (freq < target_freq) { 784 best = idx; 785 continue; 786 } 787 788 /* No freq found below target_freq */ 789 if (best == -1) 790 return idx; 791 792 return best; 793 } 794 795 return best; 796 } 797 798 /* Find highest freq at or below target in a table in descending order */ 799 static inline int cpufreq_table_find_index_dh(struct cpufreq_policy *policy, 800 unsigned int target_freq) 801 { 802 struct cpufreq_frequency_table *table = policy->freq_table; 803 struct cpufreq_frequency_table *pos; 804 unsigned int freq; 805 int idx, best = -1; 806 807 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 808 freq = pos->frequency; 809 810 if (freq <= target_freq) 811 return idx; 812 813 best = idx; 814 } 815 816 return best; 817 } 818 819 /* Works only on sorted freq-tables */ 820 static inline int cpufreq_table_find_index_h(struct cpufreq_policy *policy, 821 unsigned int target_freq) 822 { 823 target_freq = clamp_val(target_freq, policy->min, policy->max); 824 825 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING) 826 return cpufreq_table_find_index_ah(policy, target_freq); 827 else 828 return cpufreq_table_find_index_dh(policy, target_freq); 829 } 830 831 /* Find closest freq to target in a table in ascending order */ 832 static inline int cpufreq_table_find_index_ac(struct cpufreq_policy *policy, 833 unsigned int target_freq) 834 { 835 struct cpufreq_frequency_table *table = policy->freq_table; 836 struct cpufreq_frequency_table *pos; 837 unsigned int freq; 838 int idx, best = -1; 839 840 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 841 freq = pos->frequency; 842 843 if (freq == target_freq) 844 return idx; 845 846 if (freq < target_freq) { 847 best = idx; 848 continue; 849 } 850 851 /* No freq found below target_freq */ 852 if (best == -1) 853 return idx; 854 855 /* Choose the closest freq */ 856 if (target_freq - table[best].frequency > freq - target_freq) 857 return idx; 858 859 return best; 860 } 861 862 return best; 863 } 864 865 /* Find closest freq to target in a table in descending order */ 866 static inline int cpufreq_table_find_index_dc(struct cpufreq_policy *policy, 867 unsigned int target_freq) 868 { 869 struct cpufreq_frequency_table *table = policy->freq_table; 870 struct cpufreq_frequency_table *pos; 871 unsigned int freq; 872 int idx, best = -1; 873 874 cpufreq_for_each_valid_entry_idx(pos, table, idx) { 875 freq = pos->frequency; 876 877 if (freq == target_freq) 878 return idx; 879 880 if (freq > target_freq) { 881 best = idx; 882 continue; 883 } 884 885 /* No freq found above target_freq */ 886 if (best == -1) 887 return idx; 888 889 /* Choose the closest freq */ 890 if (table[best].frequency - target_freq > target_freq - freq) 891 return idx; 892 893 return best; 894 } 895 896 return best; 897 } 898 899 /* Works only on sorted freq-tables */ 900 static inline int cpufreq_table_find_index_c(struct cpufreq_policy *policy, 901 unsigned int target_freq) 902 { 903 target_freq = clamp_val(target_freq, policy->min, policy->max); 904 905 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING) 906 return cpufreq_table_find_index_ac(policy, target_freq); 907 else 908 return cpufreq_table_find_index_dc(policy, target_freq); 909 } 910 911 static inline int cpufreq_frequency_table_target(struct cpufreq_policy *policy, 912 unsigned int target_freq, 913 unsigned int relation) 914 { 915 if (unlikely(policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED)) 916 return cpufreq_table_index_unsorted(policy, target_freq, 917 relation); 918 919 switch (relation) { 920 case CPUFREQ_RELATION_L: 921 return cpufreq_table_find_index_l(policy, target_freq); 922 case CPUFREQ_RELATION_H: 923 return cpufreq_table_find_index_h(policy, target_freq); 924 case CPUFREQ_RELATION_C: 925 return cpufreq_table_find_index_c(policy, target_freq); 926 default: 927 pr_err("%s: Invalid relation: %d\n", __func__, relation); 928 return -EINVAL; 929 } 930 } 931 932 static inline int cpufreq_table_count_valid_entries(const struct cpufreq_policy *policy) 933 { 934 struct cpufreq_frequency_table *pos; 935 int count = 0; 936 937 if (unlikely(!policy->freq_table)) 938 return 0; 939 940 cpufreq_for_each_valid_entry(pos, policy->freq_table) 941 count++; 942 943 return count; 944 } 945 #else 946 static inline int cpufreq_boost_trigger_state(int state) 947 { 948 return 0; 949 } 950 static inline int cpufreq_boost_enabled(void) 951 { 952 return 0; 953 } 954 955 static inline int cpufreq_enable_boost_support(void) 956 { 957 return -EINVAL; 958 } 959 960 static inline bool policy_has_boost_freq(struct cpufreq_policy *policy) 961 { 962 return false; 963 } 964 #endif 965 966 #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL) 967 void sched_cpufreq_governor_change(struct cpufreq_policy *policy, 968 struct cpufreq_governor *old_gov); 969 #else 970 static inline void sched_cpufreq_governor_change(struct cpufreq_policy *policy, 971 struct cpufreq_governor *old_gov) { } 972 #endif 973 974 extern void arch_freq_prepare_all(void); 975 extern unsigned int arch_freq_get_on_cpu(int cpu); 976 977 extern void arch_set_freq_scale(struct cpumask *cpus, unsigned long cur_freq, 978 unsigned long max_freq); 979 980 /* the following are really really optional */ 981 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs; 982 extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs; 983 extern struct freq_attr *cpufreq_generic_attr[]; 984 int cpufreq_table_validate_and_sort(struct cpufreq_policy *policy); 985 986 unsigned int cpufreq_generic_get(unsigned int cpu); 987 void cpufreq_generic_init(struct cpufreq_policy *policy, 988 struct cpufreq_frequency_table *table, 989 unsigned int transition_latency); 990 #endif /* _LINUX_CPUFREQ_H */ 991