|
|
@@ -70,23 +70,21 @@ struct cpu_dbs_info_s {
|
|
|
unsigned int freq_lo_jiffies;
|
|
|
unsigned int freq_hi_jiffies;
|
|
|
int cpu;
|
|
|
- unsigned int enable:1,
|
|
|
- sample_type:1;
|
|
|
+ unsigned int sample_type:1;
|
|
|
+ /*
|
|
|
+ * percpu mutex that serializes governor limit change with
|
|
|
+ * do_dbs_timer invocation. We do not want do_dbs_timer to run
|
|
|
+ * when user is changing the governor or limits.
|
|
|
+ */
|
|
|
+ struct mutex timer_mutex;
|
|
|
};
|
|
|
static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info);
|
|
|
|
|
|
static unsigned int dbs_enable; /* number of CPUs using this policy */
|
|
|
|
|
|
/*
|
|
|
- * DEADLOCK ALERT! There is a ordering requirement between cpu_hotplug
|
|
|
- * lock and dbs_mutex. cpu_hotplug lock should always be held before
|
|
|
- * dbs_mutex. If any function that can potentially take cpu_hotplug lock
|
|
|
- * (like __cpufreq_driver_target()) is being called with dbs_mutex taken, then
|
|
|
- * cpu_hotplug lock should be taken before that. Note that cpu_hotplug lock
|
|
|
- * is recursive for the same process. -Venki
|
|
|
- * DEADLOCK ALERT! (2) : do_dbs_timer() must not take the dbs_mutex, because it
|
|
|
- * would deadlock with cancel_delayed_work_sync(), which is needed for proper
|
|
|
- * raceless workqueue teardown.
|
|
|
+ * dbs_mutex protects data in dbs_tuners_ins from concurrent changes on
|
|
|
+ * different CPUs. It protects dbs_enable in governor start/stop.
|
|
|
*/
|
|
|
static DEFINE_MUTEX(dbs_mutex);
|
|
|
|
|
|
@@ -192,13 +190,18 @@ static unsigned int powersave_bias_target(struct cpufreq_policy *policy,
|
|
|
return freq_hi;
|
|
|
}
|
|
|
|
|
|
+static void ondemand_powersave_bias_init_cpu(int cpu)
|
|
|
+{
|
|
|
+ struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, cpu);
|
|
|
+ dbs_info->freq_table = cpufreq_frequency_get_table(cpu);
|
|
|
+ dbs_info->freq_lo = 0;
|
|
|
+}
|
|
|
+
|
|
|
static void ondemand_powersave_bias_init(void)
|
|
|
{
|
|
|
int i;
|
|
|
for_each_online_cpu(i) {
|
|
|
- struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, i);
|
|
|
- dbs_info->freq_table = cpufreq_frequency_get_table(i);
|
|
|
- dbs_info->freq_lo = 0;
|
|
|
+ ondemand_powersave_bias_init_cpu(i);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -240,12 +243,10 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
|
|
|
unsigned int input;
|
|
|
int ret;
|
|
|
ret = sscanf(buf, "%u", &input);
|
|
|
+ if (ret != 1)
|
|
|
+ return -EINVAL;
|
|
|
|
|
|
mutex_lock(&dbs_mutex);
|
|
|
- if (ret != 1) {
|
|
|
- mutex_unlock(&dbs_mutex);
|
|
|
- return -EINVAL;
|
|
|
- }
|
|
|
dbs_tuners_ins.sampling_rate = max(input, min_sampling_rate);
|
|
|
mutex_unlock(&dbs_mutex);
|
|
|
|
|
|
@@ -259,13 +260,12 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
|
|
|
int ret;
|
|
|
ret = sscanf(buf, "%u", &input);
|
|
|
|
|
|
- mutex_lock(&dbs_mutex);
|
|
|
if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD ||
|
|
|
input < MIN_FREQUENCY_UP_THRESHOLD) {
|
|
|
- mutex_unlock(&dbs_mutex);
|
|
|
return -EINVAL;
|
|
|
}
|
|
|
|
|
|
+ mutex_lock(&dbs_mutex);
|
|
|
dbs_tuners_ins.up_threshold = input;
|
|
|
mutex_unlock(&dbs_mutex);
|
|
|
|
|
|
@@ -363,9 +363,6 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
|
|
|
struct cpufreq_policy *policy;
|
|
|
unsigned int j;
|
|
|
|
|
|
- if (!this_dbs_info->enable)
|
|
|
- return;
|
|
|
-
|
|
|
this_dbs_info->freq_lo = 0;
|
|
|
policy = this_dbs_info->cur_policy;
|
|
|
|
|
|
@@ -493,14 +490,7 @@ static void do_dbs_timer(struct work_struct *work)
|
|
|
int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
|
|
|
|
|
|
delay -= jiffies % delay;
|
|
|
-
|
|
|
- if (lock_policy_rwsem_write(cpu) < 0)
|
|
|
- return;
|
|
|
-
|
|
|
- if (!dbs_info->enable) {
|
|
|
- unlock_policy_rwsem_write(cpu);
|
|
|
- return;
|
|
|
- }
|
|
|
+ mutex_lock(&dbs_info->timer_mutex);
|
|
|
|
|
|
/* Common NORMAL_SAMPLE setup */
|
|
|
dbs_info->sample_type = DBS_NORMAL_SAMPLE;
|
|
|
@@ -517,7 +507,7 @@ static void do_dbs_timer(struct work_struct *work)
|
|
|
dbs_info->freq_lo, CPUFREQ_RELATION_H);
|
|
|
}
|
|
|
queue_delayed_work_on(cpu, kondemand_wq, &dbs_info->work, delay);
|
|
|
- unlock_policy_rwsem_write(cpu);
|
|
|
+ mutex_unlock(&dbs_info->timer_mutex);
|
|
|
}
|
|
|
|
|
|
static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
|
|
|
@@ -526,8 +516,6 @@ static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
|
|
|
int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate);
|
|
|
delay -= jiffies % delay;
|
|
|
|
|
|
- dbs_info->enable = 1;
|
|
|
- ondemand_powersave_bias_init();
|
|
|
dbs_info->sample_type = DBS_NORMAL_SAMPLE;
|
|
|
INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer);
|
|
|
queue_delayed_work_on(dbs_info->cpu, kondemand_wq, &dbs_info->work,
|
|
|
@@ -536,7 +524,6 @@ static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
|
|
|
|
|
|
static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)
|
|
|
{
|
|
|
- dbs_info->enable = 0;
|
|
|
cancel_delayed_work_sync(&dbs_info->work);
|
|
|
}
|
|
|
|
|
|
@@ -555,19 +542,15 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
|
|
|
if ((!cpu_online(cpu)) || (!policy->cur))
|
|
|
return -EINVAL;
|
|
|
|
|
|
- if (this_dbs_info->enable) /* Already enabled */
|
|
|
- break;
|
|
|
-
|
|
|
mutex_lock(&dbs_mutex);
|
|
|
- dbs_enable++;
|
|
|
|
|
|
rc = sysfs_create_group(&policy->kobj, &dbs_attr_group);
|
|
|
if (rc) {
|
|
|
- dbs_enable--;
|
|
|
mutex_unlock(&dbs_mutex);
|
|
|
return rc;
|
|
|
}
|
|
|
|
|
|
+ dbs_enable++;
|
|
|
for_each_cpu(j, policy->cpus) {
|
|
|
struct cpu_dbs_info_s *j_dbs_info;
|
|
|
j_dbs_info = &per_cpu(cpu_dbs_info, j);
|
|
|
@@ -581,6 +564,8 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
|
|
|
}
|
|
|
}
|
|
|
this_dbs_info->cpu = cpu;
|
|
|
+ ondemand_powersave_bias_init_cpu(cpu);
|
|
|
+ mutex_init(&this_dbs_info->timer_mutex);
|
|
|
/*
|
|
|
* Start the timerschedule work, when this governor
|
|
|
* is used for first time
|
|
|
@@ -598,29 +583,31 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
|
|
|
max(min_sampling_rate,
|
|
|
latency * LATENCY_MULTIPLIER);
|
|
|
}
|
|
|
- dbs_timer_init(this_dbs_info);
|
|
|
-
|
|
|
mutex_unlock(&dbs_mutex);
|
|
|
+
|
|
|
+ dbs_timer_init(this_dbs_info);
|
|
|
break;
|
|
|
|
|
|
case CPUFREQ_GOV_STOP:
|
|
|
- mutex_lock(&dbs_mutex);
|
|
|
dbs_timer_exit(this_dbs_info);
|
|
|
+
|
|
|
+ mutex_lock(&dbs_mutex);
|
|
|
sysfs_remove_group(&policy->kobj, &dbs_attr_group);
|
|
|
+ mutex_destroy(&this_dbs_info->timer_mutex);
|
|
|
dbs_enable--;
|
|
|
mutex_unlock(&dbs_mutex);
|
|
|
|
|
|
break;
|
|
|
|
|
|
case CPUFREQ_GOV_LIMITS:
|
|
|
- mutex_lock(&dbs_mutex);
|
|
|
+ mutex_lock(&this_dbs_info->timer_mutex);
|
|
|
if (policy->max < this_dbs_info->cur_policy->cur)
|
|
|
__cpufreq_driver_target(this_dbs_info->cur_policy,
|
|
|
policy->max, CPUFREQ_RELATION_H);
|
|
|
else if (policy->min > this_dbs_info->cur_policy->cur)
|
|
|
__cpufreq_driver_target(this_dbs_info->cur_policy,
|
|
|
policy->min, CPUFREQ_RELATION_L);
|
|
|
- mutex_unlock(&dbs_mutex);
|
|
|
+ mutex_unlock(&this_dbs_info->timer_mutex);
|
|
|
break;
|
|
|
}
|
|
|
return 0;
|
Linus Torvalds