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/cpu.h> 13 #include <linux/cpumask.h> 14 #include <linux/completion.h> 15 #include <linux/kobject.h> 16 #include <linux/notifier.h> 17 #include <linux/of.h> 18 #include <linux/pm_opp.h> 19 #include <linux/pm_qos.h> 20 #include <linux/spinlock.h> 21 #include <linux/sysfs.h> 22 23 /********************************************************************* 24 * CPUFREQ INTERFACE * 25 *********************************************************************/ 26 /* 27 * Frequency values here are CPU kHz 28 * 29 * Maximum transition latency is in nanoseconds - if it's unknown, 30 * CPUFREQ_ETERNAL shall be used. 31 */ 32 33 #define CPUFREQ_ETERNAL (-1) 34 #define CPUFREQ_NAME_LEN 16 35 /* Print length for names. Extra 1 space for accommodating '\n' in prints */ 36 #define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1) 37 38 struct cpufreq_governor; 39 40 enum cpufreq_table_sorting { 41 CPUFREQ_TABLE_UNSORTED, 42 CPUFREQ_TABLE_SORTED_ASCENDING, 43 CPUFREQ_TABLE_SORTED_DESCENDING 44 }; 45 46 struct cpufreq_cpuinfo { 47 unsigned int max_freq; 48 unsigned int min_freq; 49 50 /* in 10^(-9) s = nanoseconds */ 51 unsigned int transition_latency; 52 }; 53 54 struct cpufreq_policy { 55 /* CPUs sharing clock, require sw coordination */ 56 cpumask_var_t cpus; /* Online CPUs only */ 57 cpumask_var_t related_cpus; /* Online + Offline CPUs */ 58 cpumask_var_t real_cpus; /* Related and present */ 59 60 unsigned int shared_type; /* ACPI: ANY or ALL affected CPUs 61 should set cpufreq */ 62 unsigned int cpu; /* cpu managing this policy, must be online */ 63 64 struct clk *clk; 65 struct cpufreq_cpuinfo cpuinfo;/* see above */ 66 67 unsigned int min; /* in kHz */ 68 unsigned int max; /* in kHz */ 69 unsigned int cur; /* in kHz, only needed if cpufreq 70 * governors are used */ 71 unsigned int suspend_freq; /* freq to set during suspend */ 72 73 unsigned int policy; /* see above */ 74 unsigned int last_policy; /* policy before unplug */ 75 struct cpufreq_governor *governor; /* see below */ 76 void *governor_data; 77 char last_governor[CPUFREQ_NAME_LEN]; /* last governor used */ 78 79 struct work_struct update; /* if update_policy() needs to be 80 * called, but you're in IRQ context */ 81 82 struct freq_constraints constraints; 83 struct freq_qos_request *min_freq_req; 84 struct freq_qos_request *max_freq_req; 85 86 struct cpufreq_frequency_table *freq_table; 87 enum cpufreq_table_sorting freq_table_sorted; 88 89 struct list_head policy_list; 90 struct kobject kobj; 91 struct completion kobj_unregister; 92 93 /* 94 * The rules for this semaphore: 95 * - Any routine that wants to read from the policy structure will 96 * do a down_read on this semaphore. 97 * - Any routine that will write to the policy structure and/or may take away 98 * the policy altogether (eg. CPU hotplug), will hold this lock in write 99 * mode before doing so. 100 */ 101 struct rw_semaphore rwsem; 102 103 /* 104 * Fast switch flags: 105 * - fast_switch_possible should be set by the driver if it can 106 * guarantee that frequency can be changed on any CPU sharing the 107 * policy and that the change will affect all of the policy CPUs then. 108 * - fast_switch_enabled is to be set by governors that support fast 109 * frequency switching with the help of cpufreq_enable_fast_switch(). 110 */ 111 bool fast_switch_possible; 112 bool fast_switch_enabled; 113 114 /* 115 * Set if the CPUFREQ_GOV_STRICT_TARGET flag is set for the current 116 * governor. 117 */ 118 bool strict_target; 119 120 /* 121 * Set if inefficient frequencies were found in the frequency table. 122 * This indicates if the relation flag CPUFREQ_RELATION_E can be 123 * honored. 124 */ 125 bool efficiencies_available; 126 127 /* 128 * Preferred average time interval between consecutive invocations of 129 * the driver to set the frequency for this policy. To be set by the 130 * scaling driver (0, which is the default, means no preference). 131 */ 132 unsigned int transition_delay_us; 133 134 /* 135 * Remote DVFS flag (Not added to the driver structure as we don't want 136 * to access another structure from scheduler hotpath). 137 * 138 * Should be set if CPUs can do DVFS on behalf of other CPUs from 139 * different cpufreq policies. 140 */ 141 bool dvfs_possible_from_any_cpu; 142 143 /* Cached frequency lookup from cpufreq_driver_resolve_freq. */ 144 unsigned int cached_target_freq; 145 unsigned int cached_resolved_idx; 146 147 /* Synchronization for frequency transitions */ 148 bool transition_ongoing; /* Tracks transition status */ 149 spinlock_t transition_lock; 150 wait_queue_head_t transition_wait; 151 struct task_struct *transition_task; /* Task which is doing the transition */ 152 153 /* cpufreq-stats */ 154 struct cpufreq_stats *stats; 155 156 /* For cpufreq driver's internal use */ 157 void *driver_data; 158 159 /* Pointer to the cooling device if used for thermal mitigation */ 160 struct thermal_cooling_device *cdev; 161 162 struct notifier_block nb_min; 163 struct notifier_block nb_max; 164 }; 165 166 /* 167 * Used for passing new cpufreq policy data to the cpufreq driver's ->verify() 168 * callback for sanitization. That callback is only expected to modify the min 169 * and max values, if necessary, and specifically it must not update the 170 * frequency table. 171 */ 172 struct cpufreq_policy_data { 173 struct cpufreq_cpuinfo cpuinfo; 174 struct cpufreq_frequency_table *freq_table; 175 unsigned int cpu; 176 unsigned int min; /* in kHz */ 177 unsigned int max; /* in kHz */ 178 }; 179 180 struct cpufreq_freqs { 181 struct cpufreq_policy *policy; 182 unsigned int old; 183 unsigned int new; 184 u8 flags; /* flags of cpufreq_driver, see below. */ 185 }; 186 187 /* Only for ACPI */ 188 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */ 189 #define CPUFREQ_SHARED_TYPE_HW (1) /* HW does needed coordination */ 190 #define CPUFREQ_SHARED_TYPE_ALL (2) /* All dependent CPUs should set freq */ 191 #define CPUFREQ_SHARED_TYPE_ANY (3) /* Freq can be set from any dependent CPU*/ 192 193 #ifdef CONFIG_CPU_FREQ 194 struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu); 195 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu); 196 void cpufreq_cpu_put(struct cpufreq_policy *policy); 197 #else 198 static inline struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu) 199 { 200 return NULL; 201 } 202 static inline struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu) 203 { 204 return NULL; 205 } 206 static inline void cpufreq_cpu_put(struct cpufreq_policy *policy) { } 207 #endif 208 209 static inline bool policy_is_inactive(struct cpufreq_policy *policy) 210 { 211 return cpumask_empty(policy->cpus); 212 } 213 214 static inline bool policy_is_shared(struct cpufreq_policy *policy) 215 { 216 return cpumask_weight(policy->cpus) > 1; 217 } 218 219 #ifdef CONFIG_CPU_FREQ 220 unsigned int cpufreq_get(unsigned int cpu); 221 unsigned int cpufreq_quick_get(unsigned int cpu); 222 unsigned int cpufreq_quick_get_max(unsigned int cpu); 223 unsigned int cpufreq_get_hw_max_freq(unsigned int cpu); 224 void disable_cpufreq(void); 225 226 u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy); 227 228 struct cpufreq_policy *cpufreq_cpu_acquire(unsigned int cpu); 229 void cpufreq_cpu_release(struct cpufreq_policy *policy); 230 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu); 231 void refresh_frequency_limits(struct cpufreq_policy *policy); 232 void cpufreq_update_policy(unsigned int cpu); 233 void cpufreq_update_limits(unsigned int cpu); 234 bool have_governor_per_policy(void); 235 bool cpufreq_supports_freq_invariance(void); 236 struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy); 237 void cpufreq_enable_fast_switch(struct cpufreq_policy *policy); 238 void cpufreq_disable_fast_switch(struct cpufreq_policy *policy); 239 bool has_target_index(void); 240 #else 241 static inline unsigned int cpufreq_get(unsigned int cpu) 242 { 243 return 0; 244 } 245 static inline unsigned int cpufreq_quick_get(unsigned int cpu) 246 { 247 return 0; 248 } 249 static inline unsigned int cpufreq_quick_get_max(unsigned int cpu) 250 { 251 return 0; 252 } 253 static inline unsigned int cpufreq_get_hw_max_freq(unsigned int cpu) 254 { 255 return 0; 256 } 257 static inline bool cpufreq_supports_freq_invariance(void) 258 { 259 return false; 260 } 261 static inline void disable_cpufreq(void) { } 262 #endif 263 264 #ifdef CONFIG_CPU_FREQ_STAT 265 void cpufreq_stats_create_table(struct cpufreq_policy *policy); 266 void cpufreq_stats_free_table(struct cpufreq_policy *policy); 267 void cpufreq_stats_record_transition(struct cpufreq_policy *policy, 268 unsigned int new_freq); 269 #else 270 static inline void cpufreq_stats_create_table(struct cpufreq_policy *policy) { } 271 static inline void cpufreq_stats_free_table(struct cpufreq_policy *policy) { } 272 static inline void cpufreq_stats_record_transition(struct cpufreq_policy *policy, 273 unsigned int new_freq) { } 274 #endif /* CONFIG_CPU_FREQ_STAT */ 275 276 /********************************************************************* 277 * CPUFREQ DRIVER INTERFACE * 278 *********************************************************************/ 279 280 #define CPUFREQ_RELATION_L 0 /* lowest frequency at or above target */ 281 #define CPUFREQ_RELATION_H 1 /* highest frequency below or at target */ 282 #define CPUFREQ_RELATION_C 2 /* closest frequency to target */ 283 /* relation flags */ 284 #define CPUFREQ_RELATION_E BIT(2) /* Get if possible an efficient frequency */ 285 286 #define CPUFREQ_RELATION_LE (CPUFREQ_RELATION_L | CPUFREQ_RELATION_E) 287 #define CPUFREQ_RELATION_HE (CPUFREQ_RELATION_H | CPUFREQ_RELATION_E) 288 #define CPUFREQ_RELATION_CE (CPUFREQ_RELATION_C | CPUFREQ_RELATION_E) 289 290 struct freq_attr { 291 struct attribute attr; 292 ssize_t (*show)(struct cpufreq_policy *, char *); 293 ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count); 294 }; 295 296 #define cpufreq_freq_attr_ro(_name) \ 297 static struct freq_attr _name = \ 298 __ATTR(_name, 0444, show_##_name, NULL) 299 300 #define cpufreq_freq_attr_ro_perm(_name, _perm) \ 301 static struct freq_attr _name = \ 302 __ATTR(_name, _perm, show_##_name, NULL) 303 304 #define cpufreq_freq_attr_rw(_name) \ 305 static struct freq_attr _name = \ 306 __ATTR(_name, 0644, show_##_name, store_##_name) 307 308 #define cpufreq_freq_attr_wo(_name) \ 309 static struct freq_attr _name = \ 310 __ATTR(_name, 0200, NULL, store_##_name) 311 312 #define define_one_global_ro(_name) \ 313 static struct kobj_attribute _name = \ 314 __ATTR(_name, 0444, show_##_name, NULL) 315 316 #define define_one_global_rw(_name) \ 317 static struct kobj_attribute _name = \ 318 __ATTR(_name, 0644, show_##_name, store_##_name) 319 320 321 struct cpufreq_driver { 322 char name[CPUFREQ_NAME_LEN]; 323 u16 flags; 324 void *driver_data; 325 326 /* needed by all drivers */ 327 int (*init)(struct cpufreq_policy *policy); 328 int (*verify)(struct cpufreq_policy_data *policy); 329 330 /* define one out of two */ 331 int (*setpolicy)(struct cpufreq_policy *policy); 332 333 int (*target)(struct cpufreq_policy *policy, 334 unsigned int target_freq, 335 unsigned int relation); /* Deprecated */ 336 int (*target_index)(struct cpufreq_policy *policy, 337 unsigned int index); 338 unsigned int (*fast_switch)(struct cpufreq_policy *policy, 339 unsigned int target_freq); 340 /* 341 * ->fast_switch() replacement for drivers that use an internal 342 * representation of performance levels and can pass hints other than 343 * the target performance level to the hardware. 344 */ 345 void (*adjust_perf)(unsigned int cpu, 346 unsigned long min_perf, 347 unsigned long target_perf, 348 unsigned long capacity); 349 350 /* 351 * Only for drivers with target_index() and CPUFREQ_ASYNC_NOTIFICATION 352 * unset. 353 * 354 * get_intermediate should return a stable intermediate frequency 355 * platform wants to switch to and target_intermediate() should set CPU 356 * to that frequency, before jumping to the frequency corresponding 357 * to 'index'. Core will take care of sending notifications and driver 358 * doesn't have to handle them in target_intermediate() or 359 * target_index(). 360 * 361 * Drivers can return '0' from get_intermediate() in case they don't 362 * wish to switch to intermediate frequency for some target frequency. 363 * In that case core will directly call ->target_index(). 364 */ 365 unsigned int (*get_intermediate)(struct cpufreq_policy *policy, 366 unsigned int index); 367 int (*target_intermediate)(struct cpufreq_policy *policy, 368 unsigned int index); 369 370 /* should be defined, if possible */ 371 unsigned int (*get)(unsigned int cpu); 372 373 /* Called to update policy limits on firmware notifications. */ 374 void (*update_limits)(unsigned int cpu); 375 376 /* optional */ 377 int (*bios_limit)(int cpu, unsigned int *limit); 378 379 int (*online)(struct cpufreq_policy *policy); 380 int (*offline)(struct cpufreq_policy *policy); 381 int (*exit)(struct cpufreq_policy *policy); 382 int (*suspend)(struct cpufreq_policy *policy); 383 int (*resume)(struct cpufreq_policy *policy); 384 385 /* Will be called after the driver is fully initialized */ 386 void (*ready)(struct cpufreq_policy *policy); 387 388 struct freq_attr **attr; 389 390 /* platform specific boost support code */ 391 bool boost_enabled; 392 int (*set_boost)(struct cpufreq_policy *policy, int state); 393 394 /* 395 * Set by drivers that want to register with the energy model after the 396 * policy is properly initialized, but before the governor is started. 397 */ 398 void (*register_em)(struct cpufreq_policy *policy); 399 }; 400 401 /* flags */ 402 403 /* 404 * Set by drivers that need to update internal upper and lower boundaries along 405 * with the target frequency and so the core and governors should also invoke 406 * the diver if the target frequency does not change, but the policy min or max 407 * may have changed. 408 */ 409 #define CPUFREQ_NEED_UPDATE_LIMITS BIT(0) 410 411 /* loops_per_jiffy or other kernel "constants" aren't affected by frequency transitions */ 412 #define CPUFREQ_CONST_LOOPS BIT(1) 413 414 /* 415 * Set by drivers that want the core to automatically register the cpufreq 416 * driver as a thermal cooling device. 417 */ 418 #define CPUFREQ_IS_COOLING_DEV BIT(2) 419 420 /* 421 * This should be set by platforms having multiple clock-domains, i.e. 422 * supporting multiple policies. With this sysfs directories of governor would 423 * be created in cpu/cpu<num>/cpufreq/ directory and so they can use the same 424 * governor with different tunables for different clusters. 425 */ 426 #define CPUFREQ_HAVE_GOVERNOR_PER_POLICY BIT(3) 427 428 /* 429 * Driver will do POSTCHANGE notifications from outside of their ->target() 430 * routine and so must set cpufreq_driver->flags with this flag, so that core 431 * can handle them specially. 432 */ 433 #define CPUFREQ_ASYNC_NOTIFICATION BIT(4) 434 435 /* 436 * Set by drivers which want cpufreq core to check if CPU is running at a 437 * frequency present in freq-table exposed by the driver. For these drivers if 438 * CPU is found running at an out of table freq, we will try to set it to a freq 439 * from the table. And if that fails, we will stop further boot process by 440 * issuing a BUG_ON(). 441 */ 442 #define CPUFREQ_NEED_INITIAL_FREQ_CHECK BIT(5) 443 444 /* 445 * Set by drivers to disallow use of governors with "dynamic_switching" flag 446 * set. 447 */ 448 #define CPUFREQ_NO_AUTO_DYNAMIC_SWITCHING BIT(6) 449 450 int cpufreq_register_driver(struct cpufreq_driver *driver_data); 451 void cpufreq_unregister_driver(struct cpufreq_driver *driver_data); 452 453 bool cpufreq_driver_test_flags(u16 flags); 454 const char *cpufreq_get_current_driver(void); 455 void *cpufreq_get_driver_data(void); 456 457 static inline int cpufreq_thermal_control_enabled(struct cpufreq_driver *drv) 458 { 459 return IS_ENABLED(CONFIG_CPU_THERMAL) && 460 (drv->flags & CPUFREQ_IS_COOLING_DEV); 461 } 462 463 static inline void cpufreq_verify_within_limits(struct cpufreq_policy_data *policy, 464 unsigned int min, 465 unsigned int max) 466 { 467 if (policy->min < min) 468 policy->min = min; 469 if (policy->max < min) 470 policy->max = min; 471 if (policy->min > max) 472 policy->min = max; 473 if (policy->max > max) 474 policy->max = max; 475 if (policy->min > policy->max) 476 policy->min = policy->max; 477 return; 478 } 479 480 static inline void 481 cpufreq_verify_within_cpu_limits(struct cpufreq_policy_data *policy) 482 { 483 cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq, 484 policy->cpuinfo.max_freq); 485 } 486 487 #ifdef CONFIG_CPU_FREQ 488 void cpufreq_suspend(void); 489 void cpufreq_resume(void); 490 int cpufreq_generic_suspend(struct cpufreq_policy *policy); 491 #else 492 static inline void cpufreq_suspend(void) {} 493 static inline void cpufreq_resume(void) {} 494 #endif 495 496 /********************************************************************* 497 * CPUFREQ NOTIFIER INTERFACE * 498 *********************************************************************/ 499 500 #define CPUFREQ_TRANSITION_NOTIFIER (0) 501 #define CPUFREQ_POLICY_NOTIFIER (1) 502 503 /* Transition notifiers */ 504 #define CPUFREQ_PRECHANGE (0) 505 #define CPUFREQ_POSTCHANGE (1) 506 507 /* Policy Notifiers */ 508 #define CPUFREQ_CREATE_POLICY (0) 509 #define CPUFREQ_REMOVE_POLICY (1) 510 511 #ifdef CONFIG_CPU_FREQ 512 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list); 513 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list); 514 515 void cpufreq_freq_transition_begin(struct cpufreq_policy *policy, 516 struct cpufreq_freqs *freqs); 517 void cpufreq_freq_transition_end(struct cpufreq_policy *policy, 518 struct cpufreq_freqs *freqs, int transition_failed); 519 520 #else /* CONFIG_CPU_FREQ */ 521 static inline int cpufreq_register_notifier(struct notifier_block *nb, 522 unsigned int list) 523 { 524 return 0; 525 } 526 static inline int cpufreq_unregister_notifier(struct notifier_block *nb, 527 unsigned int list) 528 { 529 return 0; 530 } 531 #endif /* !CONFIG_CPU_FREQ */ 532 533 /** 534 * cpufreq_scale - "old * mult / div" calculation for large values (32-bit-arch 535 * safe) 536 * @old: old value 537 * @div: divisor 538 * @mult: multiplier 539 * 540 * 541 * new = old * mult / div 542 */ 543 static inline unsigned long cpufreq_scale(unsigned long old, u_int div, 544 u_int mult) 545 { 546 #if BITS_PER_LONG == 32 547 u64 result = ((u64) old) * ((u64) mult); 548 do_div(result, div); 549 return (unsigned long) result; 550 551 #elif BITS_PER_LONG == 64 552 unsigned long result = old * ((u64) mult); 553 result /= div; 554 return result; 555 #endif 556 } 557 558 /********************************************************************* 559 * CPUFREQ GOVERNORS * 560 *********************************************************************/ 561 562 #define CPUFREQ_POLICY_UNKNOWN (0) 563 /* 564 * If (cpufreq_driver->target) exists, the ->governor decides what frequency 565 * within the limits is used. If (cpufreq_driver->setpolicy> exists, these 566 * two generic policies are available: 567 */ 568 #define CPUFREQ_POLICY_POWERSAVE (1) 569 #define CPUFREQ_POLICY_PERFORMANCE (2) 570 571 /* 572 * The polling frequency depends on the capability of the processor. Default 573 * polling frequency is 1000 times the transition latency of the processor. The 574 * ondemand governor will work on any processor with transition latency <= 10ms, 575 * using appropriate sampling rate. 576 */ 577 #define LATENCY_MULTIPLIER (1000) 578 579 struct cpufreq_governor { 580 char name[CPUFREQ_NAME_LEN]; 581 int (*init)(struct cpufreq_policy *policy); 582 void (*exit)(struct cpufreq_policy *policy); 583 int (*start)(struct cpufreq_policy *policy); 584 void (*stop)(struct cpufreq_policy *policy); 585 void (*limits)(struct cpufreq_policy *policy); 586 ssize_t (*show_setspeed) (struct cpufreq_policy *policy, 587 char *buf); 588 int (*store_setspeed) (struct cpufreq_policy *policy, 589 unsigned int freq); 590 struct list_head governor_list; 591 struct module *owner; 592 u8 flags; 593 }; 594 595 /* Governor flags */ 596 597 /* For governors which change frequency dynamically by themselves */ 598 #define CPUFREQ_GOV_DYNAMIC_SWITCHING BIT(0) 599 600 /* For governors wanting the target frequency to be set exactly */ 601 #define CPUFREQ_GOV_STRICT_TARGET BIT(1) 602 603 604 /* Pass a target to the cpufreq driver */ 605 unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy, 606 unsigned int target_freq); 607 void cpufreq_driver_adjust_perf(unsigned int cpu, 608 unsigned long min_perf, 609 unsigned long target_perf, 610 unsigned long capacity); 611 bool cpufreq_driver_has_adjust_perf(void); 612 int cpufreq_driver_target(struct cpufreq_policy *policy, 613 unsigned int target_freq, 614 unsigned int relation); 615 int __cpufreq_driver_target(struct cpufreq_policy *policy, 616 unsigned int target_freq, 617 unsigned int relation); 618 unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy, 619 unsigned int target_freq); 620 unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy *policy); 621 int cpufreq_register_governor(struct cpufreq_governor *governor); 622 void cpufreq_unregister_governor(struct cpufreq_governor *governor); 623 int cpufreq_start_governor(struct cpufreq_policy *policy); 624 void cpufreq_stop_governor(struct cpufreq_policy *policy); 625 626 #define cpufreq_governor_init(__governor) \ 627 static int __init __governor##_init(void) \ 628 { \ 629 return cpufreq_register_governor(&__governor); \ 630 } \ 631 core_initcall(__governor##_init) 632 633 #define cpufreq_governor_exit(__governor) \ 634 static void __exit __governor##_exit(void) \ 635 { \ 636 return cpufreq_unregister_governor(&__governor); \ 637 } \ 638 module_exit(__governor##_exit) 639 640 struct cpufreq_governor *cpufreq_default_governor(void); 641 struct cpufreq_governor *cpufreq_fallback_governor(void); 642 643 static inline void cpufreq_policy_apply_limits(struct cpufreq_policy *policy) 644 { 645 if (policy->max < policy->cur) 646 __cpufreq_driver_target(policy, policy->max, 647 CPUFREQ_RELATION_HE); 648 else if (policy->min > policy->cur) 649 __cpufreq_driver_target(policy, policy->min, 650 CPUFREQ_RELATION_LE); 651 } 652 653 /* Governor attribute set */ 654 struct gov_attr_set { 655 struct kobject kobj; 656 struct list_head policy_list; 657 struct mutex update_lock; 658 int usage_count; 659 }; 660 661 /* sysfs ops for cpufreq governors */ 662 extern const struct sysfs_ops governor_sysfs_ops; 663 664 static inline struct gov_attr_set *to_gov_attr_set(struct kobject *kobj) 665 { 666 return container_of(kobj, struct gov_attr_set, kobj); 667 } 668 669 void gov_attr_set_init(struct gov_attr_set *attr_set, struct list_head *list_node); 670 void gov_attr_set_get(struct gov_attr_set *attr_set, struct list_head *list_node); 671 unsigned int gov_attr_set_put(struct gov_attr_set *attr_set, struct list_head *list_node); 672 673 /* Governor sysfs attribute */ 674 struct governor_attr { 675 struct attribute attr; 676 ssize_t (*show)(struct gov_attr_set *attr_set, char *buf); 677 ssize_t (*store)(struct gov_attr_set *attr_set, const char *buf, 678 size_t count); 679 }; 680 681 /********************************************************************* 682 * FREQUENCY TABLE HELPERS * 683 *********************************************************************/ 684 685 /* Special Values of .frequency field */ 686 #define CPUFREQ_ENTRY_INVALID ~0u 687 #define CPUFREQ_TABLE_END ~1u 688 /* Special Values of .flags field */ 689 #define CPUFREQ_BOOST_FREQ (1 << 0) 690 #define CPUFREQ_INEFFICIENT_FREQ (1 << 1) 691 692 struct cpufreq_frequency_table { 693 unsigned int flags; 694 unsigned int driver_data; /* driver specific data, not used by core */ 695 unsigned int frequency; /* kHz - doesn't need to be in ascending 696 * order */ 697 }; 698 699 #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP) 700 int dev_pm_opp_init_cpufreq_table(struct device *dev, 701 struct cpufreq_frequency_table **table); 702 void dev_pm_opp_free_cpufreq_table(struct device *dev, 703 struct cpufreq_frequency_table **table); 704 #else 705 static inline int dev_pm_opp_init_cpufreq_table(struct device *dev, 706 struct cpufreq_frequency_table 707 **table) 708 { 709 return -EINVAL; 710 } 711 712 static inline void dev_pm_opp_free_cpufreq_table(struct device *dev, 713 struct cpufreq_frequency_table 714 **table) 715 { 716 } 717 #endif 718 719 /* 720 * cpufreq_for_each_entry - iterate over a cpufreq_frequency_table 721 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 722 * @table: the cpufreq_frequency_table * to iterate over. 723 */ 724 725 #define cpufreq_for_each_entry(pos, table) \ 726 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) 727 728 /* 729 * cpufreq_for_each_entry_idx - iterate over a cpufreq_frequency_table 730 * with index 731 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 732 * @table: the cpufreq_frequency_table * to iterate over. 733 * @idx: the table entry currently being processed 734 */ 735 736 #define cpufreq_for_each_entry_idx(pos, table, idx) \ 737 for (pos = table, idx = 0; pos->frequency != CPUFREQ_TABLE_END; \ 738 pos++, idx++) 739 740 /* 741 * cpufreq_for_each_valid_entry - iterate over a cpufreq_frequency_table 742 * excluding CPUFREQ_ENTRY_INVALID frequencies. 743 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 744 * @table: the cpufreq_frequency_table * to iterate over. 745 */ 746 747 #define cpufreq_for_each_valid_entry(pos, table) \ 748 for (pos = table; pos->frequency != CPUFREQ_TABLE_END; pos++) \ 749 if (pos->frequency == CPUFREQ_ENTRY_INVALID) \ 750 continue; \ 751 else 752 753 /* 754 * cpufreq_for_each_valid_entry_idx - iterate with index over a cpufreq 755 * frequency_table excluding CPUFREQ_ENTRY_INVALID frequencies. 756 * @pos: the cpufreq_frequency_table * to use as a loop cursor. 757 * @table: the cpufreq_frequency_table * to iterate over. 758 * @idx: the table entry currently being processed 759 */ 760 761 #define cpufreq_for_each_valid_entry_idx(pos, table, idx) \ 762 cpufreq_for_each_entry_idx(pos, table, idx) \ 763 if (pos->frequency == CPUFREQ_ENTRY_INVALID) \ 764 continue; \ 765 else 766 767 /** 768 * cpufreq_for_each_efficient_entry_idx - iterate with index over a cpufreq 769 * frequency_table excluding CPUFREQ_ENTRY_INVALID and 770 * CPUFREQ_INEFFICIENT_FREQ frequencies. 771 * @pos: the &struct cpufreq_frequency_table to use as a loop cursor. 772 * @table: the &struct cpufreq_frequency_table to iterate over. 773 * @idx: the table entry currently being processed. 774 * @efficiencies: set to true to only iterate over efficient frequencies. 775 */ 776 777 #define cpufreq_for_each_efficient_entry_idx(pos, table, idx, efficiencies) \ 778 cpufreq_for_each_valid_entry_idx(pos, table, idx) \ 779 if (efficiencies && (pos->flags & CPUFREQ_INEFFICIENT_FREQ)) \ 780 continue; \ 781 else 782 783 784 int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, 785 struct cpufreq_frequency_table *table); 786 787 int cpufreq_frequency_table_verify(struct cpufreq_policy_data *policy, 788 struct cpufreq_frequency_table *table); 789 int cpufreq_generic_frequency_table_verify(struct cpufreq_policy_data *policy); 790 791 int cpufreq_table_index_unsorted(struct cpufreq_policy *policy, 792 unsigned int target_freq, 793 unsigned int relation); 794 int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy, 795 unsigned int freq); 796 797 ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf); 798 799 #ifdef CONFIG_CPU_FREQ 800 int cpufreq_boost_trigger_state(int state); 801 int cpufreq_boost_enabled(void); 802 int cpufreq_enable_boost_support(void); 803 bool policy_has_boost_freq(struct cpufreq_policy *policy); 804 805 /* Find lowest freq at or above target in a table in ascending order */ 806 static inline int cpufreq_table_find_index_al(struct cpufreq_policy *policy, 807 unsigned int target_freq, 808 bool efficiencies) 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_efficient_entry_idx(pos, table, idx, efficiencies) { 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 /* Find lowest freq at or above target in a table in descending order */ 828 static inline int cpufreq_table_find_index_dl(struct cpufreq_policy *policy, 829 unsigned int target_freq, 830 bool efficiencies) 831 { 832 struct cpufreq_frequency_table *table = policy->freq_table; 833 struct cpufreq_frequency_table *pos; 834 unsigned int freq; 835 int idx, best = -1; 836 837 cpufreq_for_each_efficient_entry_idx(pos, table, idx, efficiencies) { 838 freq = pos->frequency; 839 840 if (freq == target_freq) 841 return idx; 842 843 if (freq > target_freq) { 844 best = idx; 845 continue; 846 } 847 848 /* No freq found above target_freq */ 849 if (best == -1) 850 return idx; 851 852 return best; 853 } 854 855 return best; 856 } 857 858 /* Works only on sorted freq-tables */ 859 static inline int cpufreq_table_find_index_l(struct cpufreq_policy *policy, 860 unsigned int target_freq, 861 bool efficiencies) 862 { 863 target_freq = clamp_val(target_freq, policy->min, policy->max); 864 865 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING) 866 return cpufreq_table_find_index_al(policy, target_freq, 867 efficiencies); 868 else 869 return cpufreq_table_find_index_dl(policy, target_freq, 870 efficiencies); 871 } 872 873 /* Find highest freq at or below target in a table in ascending order */ 874 static inline int cpufreq_table_find_index_ah(struct cpufreq_policy *policy, 875 unsigned int target_freq, 876 bool efficiencies) 877 { 878 struct cpufreq_frequency_table *table = policy->freq_table; 879 struct cpufreq_frequency_table *pos; 880 unsigned int freq; 881 int idx, best = -1; 882 883 cpufreq_for_each_efficient_entry_idx(pos, table, idx, efficiencies) { 884 freq = pos->frequency; 885 886 if (freq == target_freq) 887 return idx; 888 889 if (freq < target_freq) { 890 best = idx; 891 continue; 892 } 893 894 /* No freq found below target_freq */ 895 if (best == -1) 896 return idx; 897 898 return best; 899 } 900 901 return best; 902 } 903 904 /* Find highest freq at or below target in a table in descending order */ 905 static inline int cpufreq_table_find_index_dh(struct cpufreq_policy *policy, 906 unsigned int target_freq, 907 bool efficiencies) 908 { 909 struct cpufreq_frequency_table *table = policy->freq_table; 910 struct cpufreq_frequency_table *pos; 911 unsigned int freq; 912 int idx, best = -1; 913 914 cpufreq_for_each_efficient_entry_idx(pos, table, idx, efficiencies) { 915 freq = pos->frequency; 916 917 if (freq <= target_freq) 918 return idx; 919 920 best = idx; 921 } 922 923 return best; 924 } 925 926 /* Works only on sorted freq-tables */ 927 static inline int cpufreq_table_find_index_h(struct cpufreq_policy *policy, 928 unsigned int target_freq, 929 bool efficiencies) 930 { 931 target_freq = clamp_val(target_freq, policy->min, policy->max); 932 933 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING) 934 return cpufreq_table_find_index_ah(policy, target_freq, 935 efficiencies); 936 else 937 return cpufreq_table_find_index_dh(policy, target_freq, 938 efficiencies); 939 } 940 941 /* Find closest freq to target in a table in ascending order */ 942 static inline int cpufreq_table_find_index_ac(struct cpufreq_policy *policy, 943 unsigned int target_freq, 944 bool efficiencies) 945 { 946 struct cpufreq_frequency_table *table = policy->freq_table; 947 struct cpufreq_frequency_table *pos; 948 unsigned int freq; 949 int idx, best = -1; 950 951 cpufreq_for_each_efficient_entry_idx(pos, table, idx, efficiencies) { 952 freq = pos->frequency; 953 954 if (freq == target_freq) 955 return idx; 956 957 if (freq < target_freq) { 958 best = idx; 959 continue; 960 } 961 962 /* No freq found below target_freq */ 963 if (best == -1) 964 return idx; 965 966 /* Choose the closest freq */ 967 if (target_freq - table[best].frequency > freq - target_freq) 968 return idx; 969 970 return best; 971 } 972 973 return best; 974 } 975 976 /* Find closest freq to target in a table in descending order */ 977 static inline int cpufreq_table_find_index_dc(struct cpufreq_policy *policy, 978 unsigned int target_freq, 979 bool efficiencies) 980 { 981 struct cpufreq_frequency_table *table = policy->freq_table; 982 struct cpufreq_frequency_table *pos; 983 unsigned int freq; 984 int idx, best = -1; 985 986 cpufreq_for_each_efficient_entry_idx(pos, table, idx, efficiencies) { 987 freq = pos->frequency; 988 989 if (freq == target_freq) 990 return idx; 991 992 if (freq > target_freq) { 993 best = idx; 994 continue; 995 } 996 997 /* No freq found above target_freq */ 998 if (best == -1) 999 return idx; 1000 1001 /* Choose the closest freq */ 1002 if (table[best].frequency - target_freq > target_freq - freq) 1003 return idx; 1004 1005 return best; 1006 } 1007 1008 return best; 1009 } 1010 1011 /* Works only on sorted freq-tables */ 1012 static inline int cpufreq_table_find_index_c(struct cpufreq_policy *policy, 1013 unsigned int target_freq, 1014 bool efficiencies) 1015 { 1016 target_freq = clamp_val(target_freq, policy->min, policy->max); 1017 1018 if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING) 1019 return cpufreq_table_find_index_ac(policy, target_freq, 1020 efficiencies); 1021 else 1022 return cpufreq_table_find_index_dc(policy, target_freq, 1023 efficiencies); 1024 } 1025 1026 static inline int cpufreq_frequency_table_target(struct cpufreq_policy *policy, 1027 unsigned int target_freq, 1028 unsigned int relation) 1029 { 1030 bool efficiencies = policy->efficiencies_available && 1031 (relation & CPUFREQ_RELATION_E); 1032 int idx; 1033 1034 /* cpufreq_table_index_unsorted() has no use for this flag anyway */ 1035 relation &= ~CPUFREQ_RELATION_E; 1036 1037 if (unlikely(policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED)) 1038 return cpufreq_table_index_unsorted(policy, target_freq, 1039 relation); 1040 retry: 1041 switch (relation) { 1042 case CPUFREQ_RELATION_L: 1043 idx = cpufreq_table_find_index_l(policy, target_freq, 1044 efficiencies); 1045 break; 1046 case CPUFREQ_RELATION_H: 1047 idx = cpufreq_table_find_index_h(policy, target_freq, 1048 efficiencies); 1049 break; 1050 case CPUFREQ_RELATION_C: 1051 idx = cpufreq_table_find_index_c(policy, target_freq, 1052 efficiencies); 1053 break; 1054 default: 1055 WARN_ON_ONCE(1); 1056 return 0; 1057 } 1058 1059 if (idx < 0 && efficiencies) { 1060 efficiencies = false; 1061 goto retry; 1062 } 1063 1064 return idx; 1065 } 1066 1067 static inline int cpufreq_table_count_valid_entries(const struct cpufreq_policy *policy) 1068 { 1069 struct cpufreq_frequency_table *pos; 1070 int count = 0; 1071 1072 if (unlikely(!policy->freq_table)) 1073 return 0; 1074 1075 cpufreq_for_each_valid_entry(pos, policy->freq_table) 1076 count++; 1077 1078 return count; 1079 } 1080 1081 /** 1082 * cpufreq_table_set_inefficient() - Mark a frequency as inefficient 1083 * @policy: the &struct cpufreq_policy containing the inefficient frequency 1084 * @frequency: the inefficient frequency 1085 * 1086 * The &struct cpufreq_policy must use a sorted frequency table 1087 * 1088 * Return: %0 on success or a negative errno code 1089 */ 1090 1091 static inline int 1092 cpufreq_table_set_inefficient(struct cpufreq_policy *policy, 1093 unsigned int frequency) 1094 { 1095 struct cpufreq_frequency_table *pos; 1096 1097 /* Not supported */ 1098 if (policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED) 1099 return -EINVAL; 1100 1101 cpufreq_for_each_valid_entry(pos, policy->freq_table) { 1102 if (pos->frequency == frequency) { 1103 pos->flags |= CPUFREQ_INEFFICIENT_FREQ; 1104 policy->efficiencies_available = true; 1105 return 0; 1106 } 1107 } 1108 1109 return -EINVAL; 1110 } 1111 1112 static inline int parse_perf_domain(int cpu, const char *list_name, 1113 const char *cell_name, 1114 struct of_phandle_args *args) 1115 { 1116 struct device_node *cpu_np; 1117 int ret; 1118 1119 cpu_np = of_cpu_device_node_get(cpu); 1120 if (!cpu_np) 1121 return -ENODEV; 1122 1123 ret = of_parse_phandle_with_args(cpu_np, list_name, cell_name, 0, 1124 args); 1125 if (ret < 0) 1126 return ret; 1127 1128 of_node_put(cpu_np); 1129 1130 return 0; 1131 } 1132 1133 static inline int of_perf_domain_get_sharing_cpumask(int pcpu, const char *list_name, 1134 const char *cell_name, struct cpumask *cpumask, 1135 struct of_phandle_args *pargs) 1136 { 1137 int cpu, ret; 1138 struct of_phandle_args args; 1139 1140 ret = parse_perf_domain(pcpu, list_name, cell_name, pargs); 1141 if (ret < 0) 1142 return ret; 1143 1144 cpumask_set_cpu(pcpu, cpumask); 1145 1146 for_each_possible_cpu(cpu) { 1147 if (cpu == pcpu) 1148 continue; 1149 1150 ret = parse_perf_domain(cpu, list_name, cell_name, &args); 1151 if (ret < 0) 1152 continue; 1153 1154 if (pargs->np == args.np && pargs->args_count == args.args_count && 1155 !memcmp(pargs->args, args.args, sizeof(args.args[0]) * args.args_count)) 1156 cpumask_set_cpu(cpu, cpumask); 1157 1158 of_node_put(args.np); 1159 } 1160 1161 return 0; 1162 } 1163 #else 1164 static inline int cpufreq_boost_trigger_state(int state) 1165 { 1166 return 0; 1167 } 1168 static inline int cpufreq_boost_enabled(void) 1169 { 1170 return 0; 1171 } 1172 1173 static inline int cpufreq_enable_boost_support(void) 1174 { 1175 return -EINVAL; 1176 } 1177 1178 static inline bool policy_has_boost_freq(struct cpufreq_policy *policy) 1179 { 1180 return false; 1181 } 1182 1183 static inline int 1184 cpufreq_table_set_inefficient(struct cpufreq_policy *policy, 1185 unsigned int frequency) 1186 { 1187 return -EINVAL; 1188 } 1189 1190 static inline int of_perf_domain_get_sharing_cpumask(int pcpu, const char *list_name, 1191 const char *cell_name, struct cpumask *cpumask, 1192 struct of_phandle_args *pargs) 1193 { 1194 return -EOPNOTSUPP; 1195 } 1196 #endif 1197 1198 #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL) 1199 void sched_cpufreq_governor_change(struct cpufreq_policy *policy, 1200 struct cpufreq_governor *old_gov); 1201 #else 1202 static inline void sched_cpufreq_governor_change(struct cpufreq_policy *policy, 1203 struct cpufreq_governor *old_gov) { } 1204 #endif 1205 1206 extern unsigned int arch_freq_get_on_cpu(int cpu); 1207 1208 #ifndef arch_set_freq_scale 1209 static __always_inline 1210 void arch_set_freq_scale(const struct cpumask *cpus, 1211 unsigned long cur_freq, 1212 unsigned long max_freq) 1213 { 1214 } 1215 #endif 1216 /* the following are really really optional */ 1217 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs; 1218 extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs; 1219 extern struct freq_attr *cpufreq_generic_attr[]; 1220 int cpufreq_table_validate_and_sort(struct cpufreq_policy *policy); 1221 1222 unsigned int cpufreq_generic_get(unsigned int cpu); 1223 void cpufreq_generic_init(struct cpufreq_policy *policy, 1224 struct cpufreq_frequency_table *table, 1225 unsigned int transition_latency); 1226 1227 static inline void cpufreq_register_em_with_opp(struct cpufreq_policy *policy) 1228 { 1229 dev_pm_opp_of_register_em(get_cpu_device(policy->cpu), 1230 policy->related_cpus); 1231 } 1232 #endif /* _LINUX_CPUFREQ_H */ 1233