Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bc505475 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

cpufreq: governor: Rearrange governor data structures 



The struct policy_dbs_info objects representing per-policy governor
data are not accessible directly from the corresponding policy
objects.  To access them, one has to get a pointer to the
struct cpu_dbs_info of policy->cpu and use the policy_dbs field of
that which isn't really straightforward.

To address that rearrange the governor data structures so the
governor_data pointer in struct cpufreq_policy will point to
struct policy_dbs_info (instead of struct dbs_data) and that will
contain a pointer to struct dbs_data.

Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: default avatarViresh Kumar <viresh.kumar@linaro.org>
parent e9751894

drivers/cpufreq/amd_freq_sensitivity.c

+2 −1
Original line number Diff line number Diff line
@@ -45,7 +45,8 @@ static unsigned int amd_powersave_bias_target(struct cpufreq_policy *policy, 
	long d_actual, d_reference;

	struct msr actual, reference;

	struct cpu_data_t *data = &per_cpu(cpu_data, policy->cpu);

	struct dbs_data *od_data = policy->governor_data;

	struct policy_dbs_info *policy_dbs = policy->governor_data;

	struct dbs_data *od_data = policy_dbs->dbs_data;

	struct od_dbs_tuners *od_tuners = od_data->tuners;

	struct od_cpu_dbs_info_s *od_info =

		dbs_governor_of(policy)->get_cpu_dbs_info_s(policy->cpu);

drivers/cpufreq/cpufreq_conservative.c

+4 −2
Original line number Diff line number Diff line
@@ -48,7 +48,8 @@ static void cs_check_cpu(int cpu, unsigned int load) 
{

	struct cs_cpu_dbs_info_s *dbs_info = &per_cpu(cs_cpu_dbs_info, cpu);

	struct cpufreq_policy *policy = dbs_info->cdbs.policy_dbs->policy;

	struct dbs_data *dbs_data = policy->governor_data;

	struct policy_dbs_info *policy_dbs = policy->governor_data;

	struct dbs_data *dbs_data = policy_dbs->dbs_data;

	struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;



	/*
@@ -104,7 +105,8 @@ static void cs_check_cpu(int cpu, unsigned int load) 


static unsigned int cs_dbs_timer(struct cpufreq_policy *policy)

{

	struct dbs_data *dbs_data = policy->governor_data;

	struct policy_dbs_info *policy_dbs = policy->governor_data;

	struct dbs_data *dbs_data = policy_dbs->dbs_data;

	struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;



	dbs_check_cpu(policy);

drivers/cpufreq/cpufreq_governor.c

+36 −38
Original line number Diff line number Diff line
@@ -35,8 +35,8 @@ void dbs_check_cpu(struct cpufreq_policy *policy) 
{

	int cpu = policy->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 policy_dbs_info *policy_dbs = policy->governor_data;

	struct dbs_data *dbs_data = policy_dbs->dbs_data;

	struct od_dbs_tuners *od_tuners = dbs_data->tuners;

	struct cs_dbs_tuners *cs_tuners = dbs_data->tuners;

	unsigned int sampling_rate;
@@ -95,6 +95,7 @@ void dbs_check_cpu(struct cpufreq_policy *policy) 
		j_cdbs->prev_cpu_idle = cur_idle_time;



		if (ignore_nice) {

			struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);

			u64 cur_nice;

			unsigned long cur_nice_jiffies;
@@ -292,7 +293,7 @@ static void set_sampling_rate(struct dbs_data *dbs_data, 
	}

}



static int alloc_policy_dbs_info(struct cpufreq_policy *policy,

static struct policy_dbs_info *alloc_policy_dbs_info(struct cpufreq_policy *policy,

						     struct dbs_governor *gov)

{

	struct policy_dbs_info *policy_dbs;
@@ -301,7 +302,7 @@ static int alloc_policy_dbs_info(struct cpufreq_policy *policy, 
	/* Allocate memory for the common information for policy->cpus */

	policy_dbs = kzalloc(sizeof(*policy_dbs), GFP_KERNEL);

	if (!policy_dbs)

		return -ENOMEM;

		return NULL;



	/* Set policy_dbs for all CPUs, online+offline */

	for_each_cpu(j, policy->related_cpus)
@@ -311,7 +312,7 @@ static int alloc_policy_dbs_info(struct cpufreq_policy *policy, 
	atomic_set(&policy_dbs->skip_work, 0);

	init_irq_work(&policy_dbs->irq_work, dbs_irq_work);

	INIT_WORK(&policy_dbs->work, dbs_work_handler);

	return 0;

	return policy_dbs;

}



static void free_policy_dbs_info(struct cpufreq_policy *policy,
@@ -333,6 +334,7 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy) 
{

	struct dbs_governor *gov = dbs_governor_of(policy);

	struct dbs_data *dbs_data = gov->gdbs_data;

	struct policy_dbs_info *policy_dbs;

	unsigned int latency;

	int ret;
@@ -340,26 +342,26 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy) 
	if (policy->governor_data)

		return -EBUSY;



	if (dbs_data) {

		if (WARN_ON(have_governor_per_policy()))

			return -EINVAL;



		ret = alloc_policy_dbs_info(policy, gov);

		if (ret)

			return ret;

	policy_dbs = alloc_policy_dbs_info(policy, gov);

	if (!policy_dbs)

		return -ENOMEM;



	if (dbs_data) {

		if (WARN_ON(have_governor_per_policy())) {

			ret = -EINVAL;

			goto free_policy_dbs_info;

		}

		dbs_data->usage_count++;

		policy->governor_data = dbs_data;

		policy_dbs->dbs_data = dbs_data;

		policy->governor_data = policy_dbs;

		return 0;

	}



	dbs_data = kzalloc(sizeof(*dbs_data), GFP_KERNEL);

	if (!dbs_data)

		return -ENOMEM;



	ret = alloc_policy_dbs_info(policy, gov);

	if (ret)

		goto free_dbs_data;

	if (!dbs_data) {

		ret = -ENOMEM;

		goto free_policy_dbs_info;

	}



	dbs_data->usage_count = 1;
@@ -381,7 +383,8 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy) 
	if (!have_governor_per_policy())

		gov->gdbs_data = dbs_data;



	policy->governor_data = dbs_data;

	policy_dbs->dbs_data = dbs_data;

	policy->governor_data = policy_dbs;



	ret = sysfs_create_group(get_governor_parent_kobj(policy),

				 get_sysfs_attr(gov));
@@ -396,21 +399,21 @@ static int cpufreq_governor_init(struct cpufreq_policy *policy) 
	if (!have_governor_per_policy())

		gov->gdbs_data = NULL;

	gov->exit(dbs_data, !policy->governor->initialized);

	kfree(dbs_data);



free_policy_dbs_info:

	free_policy_dbs_info(policy, gov);

free_dbs_data:

	kfree(dbs_data);

	return ret;

}



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 cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);

	struct policy_dbs_info *policy_dbs = policy->governor_data;

	struct dbs_data *dbs_data = policy_dbs->dbs_data;



	/* State should be equivalent to INIT */

	if (!cdbs->policy_dbs || cdbs->policy_dbs->policy)

	if (policy_dbs->policy)

		return -EBUSY;



	if (!--dbs_data->usage_count) {
@@ -435,17 +438,16 @@ static int cpufreq_governor_exit(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 policy_dbs_info *policy_dbs = policy->governor_data;

	struct dbs_data *dbs_data = policy_dbs->dbs_data;

	unsigned int sampling_rate, ignore_nice, j, cpu = policy->cpu;

	struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);

	struct policy_dbs_info *policy_dbs = cdbs->policy_dbs;

	int io_busy = 0;



	if (!policy->cur)

		return -EINVAL;



	/* State should be equivalent to INIT */

	if (!policy_dbs || policy_dbs->policy)

	if (policy_dbs->policy)

		return -EBUSY;



	if (gov->governor == GOV_CONSERVATIVE) {
@@ -501,12 +503,10 @@ static int cpufreq_governor_start(struct cpufreq_policy *policy) 


static int cpufreq_governor_stop(struct cpufreq_policy *policy)

{

	struct dbs_governor *gov = dbs_governor_of(policy);

	struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);

	struct policy_dbs_info *policy_dbs = cdbs->policy_dbs;

	struct policy_dbs_info *policy_dbs = policy->governor_data;



	/* State should be equivalent to START */

	if (!policy_dbs || !policy_dbs->policy)

	if (!policy_dbs->policy)

		return -EBUSY;



	gov_cancel_work(policy_dbs);
@@ -517,12 +517,10 @@ static int cpufreq_governor_stop(struct cpufreq_policy *policy) 


static int cpufreq_governor_limits(struct cpufreq_policy *policy)

{

	struct dbs_governor *gov = dbs_governor_of(policy);

	struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);

	struct policy_dbs_info *policy_dbs = cdbs->policy_dbs;

	struct policy_dbs_info *policy_dbs = policy->governor_data;



	/* State should be equivalent to START */

	if (!policy_dbs || !policy_dbs->policy)

	if (!policy_dbs->policy)

		return -EBUSY;



	mutex_lock(&policy_dbs->timer_mutex);

drivers/cpufreq/cpufreq_governor.h

+15 −12
Original line number Diff line number Diff line
@@ -85,7 +85,8 @@ static ssize_t show_##file_name##_gov_sys \ 
static ssize_t show_##file_name##_gov_pol				\

(struct cpufreq_policy *policy, char *buf)				\

{									\

	struct dbs_data *dbs_data = policy->governor_data;		\

	struct policy_dbs_info *policy_dbs = policy->governor_data;	\

	struct dbs_data *dbs_data = policy_dbs->dbs_data;		\

	struct _gov##_dbs_tuners *tuners = dbs_data->tuners;		\

	return sprintf(buf, "%u\n", tuners->file_name);			\

}
@@ -101,8 +102,8 @@ static ssize_t store_##file_name##_gov_sys \ 
static ssize_t store_##file_name##_gov_pol				\

(struct cpufreq_policy *policy, const char *buf, size_t count)		\

{									\

	struct dbs_data *dbs_data = policy->governor_data;		\

	return store_##file_name(dbs_data, buf, count);			\

	struct policy_dbs_info *policy_dbs = policy->governor_data;	\

	return store_##file_name(policy_dbs->dbs_data, buf, count);			\

}



#define show_store_one(_gov, file_name)					\
@@ -130,6 +131,13 @@ static void *get_cpu_dbs_info_s(int cpu) \ 
 * cs_*: Conservative governor

 */



/* Governor demand based switching data (per-policy or global). */

struct dbs_data {

	unsigned int min_sampling_rate;

	int usage_count;

	void *tuners;

};



/* Common to all CPUs of a policy */

struct policy_dbs_info {

	struct cpufreq_policy *policy;
@@ -144,6 +152,8 @@ struct policy_dbs_info { 
	atomic_t skip_work;

	struct irq_work irq_work;

	struct work_struct work;

	/* dbs_data may be shared between multiple policy objects */

	struct dbs_data *dbs_data;

};



static inline void gov_update_sample_delay(struct policy_dbs_info *policy_dbs,
@@ -204,7 +214,6 @@ struct cs_dbs_tuners { 
};



/* Common Governor data across policies */

struct dbs_data;

struct dbs_governor {

	struct cpufreq_governor gov;
@@ -236,13 +245,6 @@ 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 */

struct dbs_data {

	unsigned int min_sampling_rate;

	int usage_count;

	void *tuners;

};



/* Governor specific ops, will be passed to dbs_data->gov_ops */

struct od_ops {

	void (*powersave_bias_init_cpu)(int cpu);
@@ -273,7 +275,8 @@ static ssize_t show_sampling_rate_min_gov_sys \ 
static ssize_t show_sampling_rate_min_gov_pol				\

(struct cpufreq_policy *policy, char *buf)				\

{									\

	struct dbs_data *dbs_data = policy->governor_data;		\

	struct policy_dbs_info *policy_dbs = policy->governor_data;	\

	struct dbs_data *dbs_data = policy_dbs->dbs_data;		\

	return sprintf(buf, "%u\n", dbs_data->min_sampling_rate);	\

}

drivers/cpufreq/cpufreq_ondemand.c

+11 −7
Original line number Diff line number Diff line
@@ -78,7 +78,8 @@ static unsigned int generic_powersave_bias_target(struct cpufreq_policy *policy, 
	unsigned int jiffies_total, jiffies_hi, jiffies_lo;

	struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info,

						   policy->cpu);

	struct dbs_data *dbs_data = policy->governor_data;

	struct policy_dbs_info *policy_dbs = policy->governor_data;

	struct dbs_data *dbs_data = policy_dbs->dbs_data;

	struct od_dbs_tuners *od_tuners = dbs_data->tuners;



	if (!dbs_info->freq_table) {
@@ -130,7 +131,8 @@ static void ondemand_powersave_bias_init(void) 


static void dbs_freq_increase(struct cpufreq_policy *policy, unsigned int freq)

{

	struct dbs_data *dbs_data = policy->governor_data;

	struct policy_dbs_info *policy_dbs = policy->governor_data;

	struct dbs_data *dbs_data = policy_dbs->dbs_data;

	struct od_dbs_tuners *od_tuners = dbs_data->tuners;



	if (od_tuners->powersave_bias)
@@ -151,8 +153,9 @@ static void dbs_freq_increase(struct cpufreq_policy *policy, unsigned int freq) 
static void od_check_cpu(int cpu, unsigned int load)

{

	struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, cpu);

	struct cpufreq_policy *policy = dbs_info->cdbs.policy_dbs->policy;

	struct dbs_data *dbs_data = policy->governor_data;

	struct policy_dbs_info *policy_dbs = dbs_info->cdbs.policy_dbs;

	struct cpufreq_policy *policy = policy_dbs->policy;

	struct dbs_data *dbs_data = policy_dbs->dbs_data;

	struct od_dbs_tuners *od_tuners = dbs_data->tuners;



	dbs_info->freq_lo = 0;
@@ -189,7 +192,8 @@ static void od_check_cpu(int cpu, unsigned int load) 


static unsigned int od_dbs_timer(struct cpufreq_policy *policy)

{

	struct dbs_data *dbs_data = policy->governor_data;

	struct policy_dbs_info *policy_dbs = policy->governor_data;

	struct dbs_data *dbs_data = policy_dbs->dbs_data;

	struct od_cpu_dbs_info_s *dbs_info = &per_cpu(od_cpu_dbs_info, policy->cpu);

	struct od_dbs_tuners *od_tuners = dbs_data->tuners;

	int delay = 0, sample_type = dbs_info->sample_type;
@@ -277,7 +281,7 @@ static void update_sampling_rate(struct dbs_data *dbs_data, 
		 * policy will be governed by dbs_data, otherwise there can be

		 * multiple policies that are governed by the same dbs_data.

		 */

		if (dbs_data == policy->governor_data) {

		if (dbs_data == policy_dbs->dbs_data) {

			mutex_lock(&policy_dbs->timer_mutex);

			/*

			 * On 32-bit architectures this may race with the
@@ -586,7 +590,7 @@ static void od_set_powersave_bias(unsigned int powersave_bias) 
		if (policy->governor != CPU_FREQ_GOV_ONDEMAND)

			continue;



		dbs_data = policy->governor_data;

		dbs_data = policy_dbs->dbs_data;

		od_tuners = dbs_data->tuners;

		od_tuners->powersave_bias = default_powersave_bias;

	}