Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0-only */
       2                 :            : /*
       3                 :            :  * drivers/cpufreq/cpufreq_governor.h
       4                 :            :  *
       5                 :            :  * Header file for CPUFreq governors common code
       6                 :            :  *
       7                 :            :  * Copyright    (C) 2001 Russell King
       8                 :            :  *              (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
       9                 :            :  *              (C) 2003 Jun Nakajima <jun.nakajima@intel.com>
      10                 :            :  *              (C) 2009 Alexander Clouter <alex@digriz.org.uk>
      11                 :            :  *              (c) 2012 Viresh Kumar <viresh.kumar@linaro.org>
      12                 :            :  */
      13                 :            : 
      14                 :            : #ifndef _CPUFREQ_GOVERNOR_H
      15                 :            : #define _CPUFREQ_GOVERNOR_H
      16                 :            : 
      17                 :            : #include <linux/atomic.h>
      18                 :            : #include <linux/irq_work.h>
      19                 :            : #include <linux/cpufreq.h>
      20                 :            : #include <linux/sched/cpufreq.h>
      21                 :            : #include <linux/kernel_stat.h>
      22                 :            : #include <linux/module.h>
      23                 :            : #include <linux/mutex.h>
      24                 :            : 
      25                 :            : /* Ondemand Sampling types */
      26                 :            : enum {OD_NORMAL_SAMPLE, OD_SUB_SAMPLE};
      27                 :            : 
      28                 :            : /*
      29                 :            :  * Abbreviations:
      30                 :            :  * dbs: used as a shortform for demand based switching It helps to keep variable
      31                 :            :  *      names smaller, simpler
      32                 :            :  * cdbs: common dbs
      33                 :            :  * od_*: On-demand governor
      34                 :            :  * cs_*: Conservative governor
      35                 :            :  */
      36                 :            : 
      37                 :            : /* Governor demand based switching data (per-policy or global). */
      38                 :            : struct dbs_data {
      39                 :            :         struct gov_attr_set attr_set;
      40                 :            :         void *tuners;
      41                 :            :         unsigned int ignore_nice_load;
      42                 :            :         unsigned int sampling_rate;
      43                 :            :         unsigned int sampling_down_factor;
      44                 :            :         unsigned int up_threshold;
      45                 :            :         unsigned int io_is_busy;
      46                 :            : };
      47                 :            : 
      48                 :            : static inline struct dbs_data *to_dbs_data(struct gov_attr_set *attr_set)
      49                 :            : {
      50                 :            :         return container_of(attr_set, struct dbs_data, attr_set);
      51                 :            : }
      52                 :            : 
      53                 :            : #define gov_show_one(_gov, file_name)                                   \
      54                 :            : static ssize_t show_##file_name                                         \
      55                 :            : (struct gov_attr_set *attr_set, char *buf)                              \
      56                 :            : {                                                                       \
      57                 :            :         struct dbs_data *dbs_data = to_dbs_data(attr_set);              \
      58                 :            :         struct _gov##_dbs_tuners *tuners = dbs_data->tuners;         \
      59                 :            :         return sprintf(buf, "%u\n", tuners->file_name);                    \
      60                 :            : }
      61                 :            : 
      62                 :            : #define gov_show_one_common(file_name)                                  \
      63                 :            : static ssize_t show_##file_name                                         \
      64                 :            : (struct gov_attr_set *attr_set, char *buf)                              \
      65                 :            : {                                                                       \
      66                 :            :         struct dbs_data *dbs_data = to_dbs_data(attr_set);              \
      67                 :            :         return sprintf(buf, "%u\n", dbs_data->file_name);          \
      68                 :            : }
      69                 :            : 
      70                 :            : #define gov_attr_ro(_name)                                              \
      71                 :            : static struct governor_attr _name =                                     \
      72                 :            : __ATTR(_name, 0444, show_##_name, NULL)
      73                 :            : 
      74                 :            : #define gov_attr_rw(_name)                                              \
      75                 :            : static struct governor_attr _name =                                     \
      76                 :            : __ATTR(_name, 0644, show_##_name, store_##_name)
      77                 :            : 
      78                 :            : /* Common to all CPUs of a policy */
      79                 :            : struct policy_dbs_info {
      80                 :            :         struct cpufreq_policy *policy;
      81                 :            :         /*
      82                 :            :          * Per policy mutex that serializes load evaluation from limit-change
      83                 :            :          * and work-handler.
      84                 :            :          */
      85                 :            :         struct mutex update_mutex;
      86                 :            : 
      87                 :            :         u64 last_sample_time;
      88                 :            :         s64 sample_delay_ns;
      89                 :            :         atomic_t work_count;
      90                 :            :         struct irq_work irq_work;
      91                 :            :         struct work_struct work;
      92                 :            :         /* dbs_data may be shared between multiple policy objects */
      93                 :            :         struct dbs_data *dbs_data;
      94                 :            :         struct list_head list;
      95                 :            :         /* Multiplier for increasing sample delay temporarily. */
      96                 :            :         unsigned int rate_mult;
      97                 :            :         unsigned int idle_periods;      /* For conservative */
      98                 :            :         /* Status indicators */
      99                 :            :         bool is_shared;         /* This object is used by multiple CPUs */
     100                 :            :         bool work_in_progress;  /* Work is being queued up or in progress */
     101                 :            : };
     102                 :            : 
     103                 :            : static inline void gov_update_sample_delay(struct policy_dbs_info *policy_dbs,
     104                 :            :                                            unsigned int delay_us)
     105                 :            : {
     106                 :          0 :         policy_dbs->sample_delay_ns = delay_us * NSEC_PER_USEC;
     107                 :            : }
     108                 :            : 
     109                 :            : /* Per cpu structures */
     110                 :            : struct cpu_dbs_info {
     111                 :            :         u64 prev_cpu_idle;
     112                 :            :         u64 prev_update_time;
     113                 :            :         u64 prev_cpu_nice;
     114                 :            :         /*
     115                 :            :          * Used to keep track of load in the previous interval. However, when
     116                 :            :          * explicitly set to zero, it is used as a flag to ensure that we copy
     117                 :            :          * the previous load to the current interval only once, upon the first
     118                 :            :          * wake-up from idle.
     119                 :            :          */
     120                 :            :         unsigned int prev_load;
     121                 :            :         struct update_util_data update_util;
     122                 :            :         struct policy_dbs_info *policy_dbs;
     123                 :            : };
     124                 :            : 
     125                 :            : /* Common Governor data across policies */
     126                 :            : struct dbs_governor {
     127                 :            :         struct cpufreq_governor gov;
     128                 :            :         struct kobj_type kobj_type;
     129                 :            : 
     130                 :            :         /*
     131                 :            :          * Common data for platforms that don't set
     132                 :            :          * CPUFREQ_HAVE_GOVERNOR_PER_POLICY
     133                 :            :          */
     134                 :            :         struct dbs_data *gdbs_data;
     135                 :            : 
     136                 :            :         unsigned int (*gov_dbs_update)(struct cpufreq_policy *policy);
     137                 :            :         struct policy_dbs_info *(*alloc)(void);
     138                 :            :         void (*free)(struct policy_dbs_info *policy_dbs);
     139                 :            :         int (*init)(struct dbs_data *dbs_data);
     140                 :            :         void (*exit)(struct dbs_data *dbs_data);
     141                 :            :         void (*start)(struct cpufreq_policy *policy);
     142                 :            : };
     143                 :            : 
     144                 :            : static inline struct dbs_governor *dbs_governor_of(struct cpufreq_policy *policy)
     145                 :            : {
     146                 :          0 :         return container_of(policy->governor, struct dbs_governor, gov);
     147                 :            : }
     148                 :            : 
     149                 :            : /* Governor callback routines */
     150                 :            : int cpufreq_dbs_governor_init(struct cpufreq_policy *policy);
     151                 :            : void cpufreq_dbs_governor_exit(struct cpufreq_policy *policy);
     152                 :            : int cpufreq_dbs_governor_start(struct cpufreq_policy *policy);
     153                 :            : void cpufreq_dbs_governor_stop(struct cpufreq_policy *policy);
     154                 :            : void cpufreq_dbs_governor_limits(struct cpufreq_policy *policy);
     155                 :            : 
     156                 :            : #define CPUFREQ_DBS_GOVERNOR_INITIALIZER(_name_)                        \
     157                 :            :         {                                                               \
     158                 :            :                 .name = _name_,                                         \
     159                 :            :                 .dynamic_switching = true,                              \
     160                 :            :                 .owner = THIS_MODULE,                                   \
     161                 :            :                 .init = cpufreq_dbs_governor_init,                      \
     162                 :            :                 .exit = cpufreq_dbs_governor_exit,                      \
     163                 :            :                 .start = cpufreq_dbs_governor_start,                    \
     164                 :            :                 .stop = cpufreq_dbs_governor_stop,                      \
     165                 :            :                 .limits = cpufreq_dbs_governor_limits,                  \
     166                 :            :         }
     167                 :            : 
     168                 :            : /* Governor specific operations */
     169                 :            : struct od_ops {
     170                 :            :         unsigned int (*powersave_bias_target)(struct cpufreq_policy *policy,
     171                 :            :                         unsigned int freq_next, unsigned int relation);
     172                 :            : };
     173                 :            : 
     174                 :            : unsigned int dbs_update(struct cpufreq_policy *policy);
     175                 :            : void od_register_powersave_bias_handler(unsigned int (*f)
     176                 :            :                 (struct cpufreq_policy *, unsigned int, unsigned int),
     177                 :            :                 unsigned int powersave_bias);
     178                 :            : void od_unregister_powersave_bias_handler(void);
     179                 :            : ssize_t store_sampling_rate(struct gov_attr_set *attr_set, const char *buf,
     180                 :            :                             size_t count);
     181                 :            : void gov_update_cpu_data(struct dbs_data *dbs_data);
     182                 :            : #endif /* _CPUFREQ_GOVERNOR_H */