hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cpufreq: governor: Drop the gov pointer from struct dbs_data 

Since it is possible to obtain a pointer to struct dbs_governor
from a pointer to the struct governor embedded in it with the help
of container_of(), the additional gov pointer in struct dbs_data
isn't really necessary.

Drop that pointer and make the code using it reach the dbs_governor
object via policy->governor.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
This commit is contained in:
Rafael J. Wysocki 2016-02-07 16:09:51 +01:00
parent 906a6e5aae
commit ea59ee0dc9
5 changed files with 39 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/cpufreq/amd_freq_sensitivity.c
View File

@ -48,7 +48,7 @@ static unsigned int amd_powersave_bias_target(struct cpufreq_policy *policy,
struct dbs_data *od_data = policy->governor_data; struct dbs_data *od_data = policy->governor_data;
struct od_dbs_tuners *od_tuners = od_data->tuners; struct od_dbs_tuners *od_tuners = od_data->tuners;
struct od_cpu_dbs_info_s *od_info = struct od_cpu_dbs_info_s *od_info =
od_data->gov->get_cpu_dbs_info_s(policy->cpu); dbs_governor_of(policy)->get_cpu_dbs_info_s(policy->cpu);
if (!od_info->freq_table) if (!od_info->freq_table)
return freq_next; return freq_next;

2
drivers/cpufreq/cpufreq_conservative.c
View File

@ -107,7 +107,7 @@ static unsigned int cs_dbs_timer(struct cpufreq_policy *policy)
struct dbs_data *dbs_data = policy->governor_data; struct dbs_data *dbs_data = policy->governor_data;
struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
dbs_check_cpu(dbs_data, policy->cpu); dbs_check_cpu(policy, policy->cpu);
return delay_for_sampling_rate(cs_tuners->sampling_rate); return delay_for_sampling_rate(cs_tuners->sampling_rate);
} }

63
drivers/cpufreq/cpufreq_governor.c
View File

@ -25,28 +25,27 @@
DEFINE_MUTEX(dbs_data_mutex); DEFINE_MUTEX(dbs_data_mutex);
EXPORT_SYMBOL_GPL(dbs_data_mutex); EXPORT_SYMBOL_GPL(dbs_data_mutex);
static struct attribute_group *get_sysfs_attr(struct dbs_data *dbs_data) static struct attribute_group *get_sysfs_attr(struct dbs_governor *gov)
{ {
if (have_governor_per_policy()) return have_governor_per_policy() ?
return dbs_data->gov->attr_group_gov_pol; gov->attr_group_gov_pol : gov->attr_group_gov_sys;
else
return dbs_data->gov->attr_group_gov_sys;
} }
void dbs_check_cpu(struct dbs_data *dbs_data, int cpu) void dbs_check_cpu(struct cpufreq_policy *policy, int cpu)
{ {
struct cpu_dbs_info *cdbs = dbs_data->gov->get_cpu_cdbs(cpu); struct dbs_governor *gov = dbs_governor_of(policy);
struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
struct dbs_data *dbs_data = policy->governor_data;
struct od_dbs_tuners *od_tuners = dbs_data->tuners; struct od_dbs_tuners *od_tuners = dbs_data->tuners;
struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
struct cpufreq_policy *policy = cdbs->shared->policy;
unsigned int sampling_rate; unsigned int sampling_rate;
unsigned int max_load = 0; unsigned int max_load = 0;
unsigned int ignore_nice; unsigned int ignore_nice;
unsigned int j; unsigned int j;
if (dbs_data->gov->governor == GOV_ONDEMAND) { if (gov->governor == GOV_ONDEMAND) {
struct od_cpu_dbs_info_s *od_dbs_info = struct od_cpu_dbs_info_s *od_dbs_info =
dbs_data->gov->get_cpu_dbs_info_s(cpu); gov->get_cpu_dbs_info_s(cpu);
/* /*
* Sometimes, the ondemand governor uses an additional * Sometimes, the ondemand governor uses an additional
@ -71,7 +70,7 @@ void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
unsigned int load; unsigned int load;
int io_busy = 0; int io_busy = 0;
j_cdbs = dbs_data->gov->get_cpu_cdbs(j); j_cdbs = gov->get_cpu_cdbs(j);
/* /*
* For the purpose of ondemand, waiting for disk IO is * For the purpose of ondemand, waiting for disk IO is
@ -79,7 +78,7 @@ void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
* not that the system is actually idle. So do not add * not that the system is actually idle. So do not add
* the iowait time to the cpu idle time. * the iowait time to the cpu idle time.
*/ */
if (dbs_data->gov->governor == GOV_ONDEMAND) if (gov->governor == GOV_ONDEMAND)
io_busy = od_tuners->io_is_busy; io_busy = od_tuners->io_is_busy;
cur_idle_time = get_cpu_idle_time(j, &cur_wall_time, io_busy); cur_idle_time = get_cpu_idle_time(j, &cur_wall_time, io_busy);
@ -160,7 +159,7 @@ void dbs_check_cpu(struct dbs_data *dbs_data, int cpu)
max_load = load; max_load = load;
} }
dbs_data->gov->gov_check_cpu(cpu, max_load); gov->gov_check_cpu(cpu, max_load);
} }
EXPORT_SYMBOL_GPL(dbs_check_cpu); EXPORT_SYMBOL_GPL(dbs_check_cpu);
@ -168,14 +167,14 @@ void gov_set_update_util(struct cpu_common_dbs_info *shared,
unsigned int delay_us) unsigned int delay_us)
{ {
struct cpufreq_policy *policy = shared->policy; struct cpufreq_policy *policy = shared->policy;
struct dbs_data *dbs_data = policy->governor_data; struct dbs_governor *gov = dbs_governor_of(policy);
int cpu; int cpu;
gov_update_sample_delay(shared, delay_us); gov_update_sample_delay(shared, delay_us);
shared->last_sample_time = 0; shared->last_sample_time = 0;
for_each_cpu(cpu, policy->cpus) { for_each_cpu(cpu, policy->cpus) {
struct cpu_dbs_info *cdbs = dbs_data->gov->get_cpu_cdbs(cpu); struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
cpufreq_set_update_util_data(cpu, &cdbs->update_util); cpufreq_set_update_util_data(cpu, &cdbs->update_util);
} }
@ -212,18 +211,18 @@ static void dbs_work_handler(struct work_struct *work)
struct cpu_common_dbs_info *shared = container_of(work, struct struct cpu_common_dbs_info *shared = container_of(work, struct
cpu_common_dbs_info, work); cpu_common_dbs_info, work);
struct cpufreq_policy *policy; struct cpufreq_policy *policy;
struct dbs_data *dbs_data; struct dbs_governor *gov;
unsigned int delay; unsigned int delay;
policy = shared->policy; policy = shared->policy;
dbs_data = policy->governor_data; gov = dbs_governor_of(policy);
/* /*
* Make sure cpufreq_governor_limits() isn't evaluating load or the * Make sure cpufreq_governor_limits() isn't evaluating load or the
* ondemand governor isn't updating the sampling rate in parallel. * ondemand governor isn't updating the sampling rate in parallel.
*/ */
mutex_lock(&shared->timer_mutex); mutex_lock(&shared->timer_mutex);
delay = dbs_data->gov->gov_dbs_timer(policy); delay = gov->gov_dbs_timer(policy);
shared->sample_delay_ns = jiffies_to_nsecs(delay); shared->sample_delay_ns = jiffies_to_nsecs(delay);
mutex_unlock(&shared->timer_mutex); mutex_unlock(&shared->timer_mutex);
@ -280,9 +279,10 @@ static void dbs_update_util_handler(struct update_util_data *data, u64 time,
} }
static void set_sampling_rate(struct dbs_data *dbs_data, static void set_sampling_rate(struct dbs_data *dbs_data,
unsigned int sampling_rate) struct dbs_governor *gov,
unsigned int sampling_rate)
{ {
if (dbs_data->gov->governor == GOV_CONSERVATIVE) { if (gov->governor == GOV_CONSERVATIVE) {
struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;
cs_tuners->sampling_rate = sampling_rate; cs_tuners->sampling_rate = sampling_rate;
} else { } else {
@ -330,8 +330,7 @@ static void free_common_dbs_info(struct cpufreq_policy *policy,
static int cpufreq_governor_init(struct cpufreq_policy *policy) static int cpufreq_governor_init(struct cpufreq_policy *policy)
{ {
struct dbs_governor *gov = container_of(policy->governor, struct dbs_governor *gov = dbs_governor_of(policy);
struct dbs_governor, gov);
struct dbs_data *dbs_data = gov->gdbs_data; struct dbs_data *dbs_data = gov->gdbs_data;
unsigned int latency; unsigned int latency;
int ret; int ret;
@ -361,7 +360,6 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy)
if (ret) if (ret)
goto free_dbs_data; goto free_dbs_data;
dbs_data->gov = gov;
dbs_data->usage_count = 1; dbs_data->usage_count = 1;
ret = gov->init(dbs_data, !policy->governor->initialized); ret = gov->init(dbs_data, !policy->governor->initialized);
@ -376,7 +374,7 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy)
/* Bring kernel and HW constraints together */ /* Bring kernel and HW constraints together */
dbs_data->min_sampling_rate = max(dbs_data->min_sampling_rate, dbs_data->min_sampling_rate = max(dbs_data->min_sampling_rate,
MIN_LATENCY_MULTIPLIER * latency); MIN_LATENCY_MULTIPLIER * latency);
set_sampling_rate(dbs_data, max(dbs_data->min_sampling_rate, set_sampling_rate(dbs_data, gov, max(dbs_data->min_sampling_rate,
latency * LATENCY_MULTIPLIER)); latency * LATENCY_MULTIPLIER));
if (!have_governor_per_policy()) if (!have_governor_per_policy())
@ -385,7 +383,7 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy)
policy->governor_data = dbs_data; policy->governor_data = dbs_data;
ret = sysfs_create_group(get_governor_parent_kobj(policy), ret = sysfs_create_group(get_governor_parent_kobj(policy),
get_sysfs_attr(dbs_data)); get_sysfs_attr(gov));
if (ret) if (ret)
goto reset_gdbs_data; goto reset_gdbs_data;
@ -406,8 +404,8 @@ free_dbs_data:
static int cpufreq_governor_exit(struct cpufreq_policy *policy) static int cpufreq_governor_exit(struct cpufreq_policy *policy)
{ {
struct dbs_governor *gov = dbs_governor_of(policy);
struct dbs_data *dbs_data = policy->governor_data; struct dbs_data *dbs_data = policy->governor_data;
struct dbs_governor *gov = dbs_data->gov;
struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu); struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);
/* State should be equivalent to INIT */ /* State should be equivalent to INIT */
@ -416,7 +414,7 @@ static int cpufreq_governor_exit(struct cpufreq_policy *policy)
if (!--dbs_data->usage_count) { if (!--dbs_data->usage_count) {
sysfs_remove_group(get_governor_parent_kobj(policy), sysfs_remove_group(get_governor_parent_kobj(policy),
get_sysfs_attr(dbs_data)); get_sysfs_attr(gov));
policy->governor_data = NULL; policy->governor_data = NULL;
@ -435,8 +433,8 @@ static int cpufreq_governor_exit(struct cpufreq_policy *policy)
static int cpufreq_governor_start(struct cpufreq_policy *policy) static int cpufreq_governor_start(struct cpufreq_policy *policy)
{ {
struct dbs_governor *gov = dbs_governor_of(policy);
struct dbs_data *dbs_data = policy->governor_data; struct dbs_data *dbs_data = policy->governor_data;
struct dbs_governor *gov = dbs_data->gov;
unsigned int sampling_rate, ignore_nice, j, cpu = policy->cpu; unsigned int sampling_rate, ignore_nice, j, cpu = policy->cpu;
struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu); struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
struct cpu_common_dbs_info *shared = cdbs->shared; struct cpu_common_dbs_info *shared = cdbs->shared;
@ -502,8 +500,8 @@ static int cpufreq_governor_start(struct cpufreq_policy *policy)
static int cpufreq_governor_stop(struct cpufreq_policy *policy) static int cpufreq_governor_stop(struct cpufreq_policy *policy)
{ {
struct dbs_data *dbs_data = policy->governor_data; struct dbs_governor *gov = dbs_governor_of(policy);
struct cpu_dbs_info *cdbs = dbs_data->gov->get_cpu_cdbs(policy->cpu); struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);
struct cpu_common_dbs_info *shared = cdbs->shared; struct cpu_common_dbs_info *shared = cdbs->shared;
/* State should be equivalent to START */ /* State should be equivalent to START */
@ -518,8 +516,7 @@ static int cpufreq_governor_stop(struct cpufreq_policy *policy)
static int cpufreq_governor_limits(struct cpufreq_policy *policy) static int cpufreq_governor_limits(struct cpufreq_policy *policy)
{ {
struct dbs_data *dbs_data = policy->governor_data; struct dbs_governor *gov = dbs_governor_of(policy);
struct dbs_governor *gov = dbs_data->gov;
unsigned int cpu = policy->cpu; unsigned int cpu = policy->cpu;
struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu); struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
@ -534,7 +531,7 @@ static int cpufreq_governor_limits(struct cpufreq_policy *policy)
else if (policy->min > cdbs->shared->policy->cur) else if (policy->min > cdbs->shared->policy->cur)
__cpufreq_driver_target(cdbs->shared->policy, policy->min, __cpufreq_driver_target(cdbs->shared->policy, policy->min,
CPUFREQ_RELATION_L); CPUFREQ_RELATION_L);
dbs_check_cpu(dbs_data, cpu); dbs_check_cpu(policy, cpu);
mutex_unlock(&cdbs->shared->timer_mutex); mutex_unlock(&cdbs->shared->timer_mutex);
return 0; return 0;

8
drivers/cpufreq/cpufreq_governor.h
View File

@ -231,9 +231,13 @@ struct dbs_governor {
void *gov_ops; void *gov_ops;
}; };
static inline struct dbs_governor *dbs_governor_of(struct cpufreq_policy *policy)
{
return container_of(policy->governor, struct dbs_governor, gov);
}
/* Governor Per policy data */ /* Governor Per policy data */
struct dbs_data { struct dbs_data {
struct dbs_governor *gov;
unsigned int min_sampling_rate; unsigned int min_sampling_rate;
int usage_count; int usage_count;
void *tuners; void *tuners;
@ -275,7 +279,7 @@ static ssize_t show_sampling_rate_min_gov_pol \
extern struct mutex dbs_data_mutex; extern struct mutex dbs_data_mutex;
extern struct mutex cpufreq_governor_lock; extern struct mutex cpufreq_governor_lock;
void dbs_check_cpu(struct dbs_data *dbs_data, int cpu); void dbs_check_cpu(struct cpufreq_policy *policy, int cpu);
int cpufreq_governor_dbs(struct cpufreq_policy *policy, unsigned int event); int cpufreq_governor_dbs(struct cpufreq_policy *policy, unsigned int event);
void od_register_powersave_bias_handler(unsigned int (*f) void od_register_powersave_bias_handler(unsigned int (*f)
(struct cpufreq_policy *, unsigned int, unsigned int), (struct cpufreq_policy *, unsigned int, unsigned int),

2
drivers/cpufreq/cpufreq_ondemand.c
View File

@ -203,7 +203,7 @@ static unsigned int od_dbs_timer(struct cpufreq_policy *policy)
__cpufreq_driver_target(policy, dbs_info->freq_lo, __cpufreq_driver_target(policy, dbs_info->freq_lo,
CPUFREQ_RELATION_H); CPUFREQ_RELATION_H);
} else { } else {
dbs_check_cpu(dbs_data, cpu); dbs_check_cpu(policy, cpu);
if (dbs_info->freq_lo) { if (dbs_info->freq_lo) {
/* Setup timer for SUB_SAMPLE */ /* Setup timer for SUB_SAMPLE */
dbs_info->sample_type = OD_SUB_SAMPLE; dbs_info->sample_type = OD_SUB_SAMPLE;