cpufreq: conservative: Update sample_delay_ns immediately

[deliverable/linux.git] / drivers / cpufreq / cpufreq_ondemand.c

diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 38301c6b31c78f7ad4b6516a97f9e36979f2c4d0..12213823cc93ed442d2382446df8fa428a955354 100644 (file)
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -221,75 +221,6 @@ static unsigned int od_dbs_timer(struct cpufreq_policy *policy)
 /************************** sysfs interface ************************/
 static struct dbs_governor od_dbs_gov;
 
-/**
- * update_sampling_rate - update sampling rate effective immediately if needed.
- * @new_rate: new sampling rate
- *
- * If new rate is smaller than the old, simply updating
- * dbs.sampling_rate might not be appropriate. For example, if the
- * original sampling_rate was 1 second and the requested new sampling rate is 10
- * ms because the user needs immediate reaction from ondemand governor, but not
- * sure if higher frequency will be required or not, then, the governor may
- * change the sampling rate too late; up to 1 second later. Thus, if we are
- * reducing the sampling rate, we need to make the new value effective
- * immediately.
- *
- * On the other hand, if new rate is larger than the old, then we may evaluate
- * the load too soon, and it might we worth updating sample_delay_ns then as
- * well.
- *
- * This must be called with dbs_data->mutex held, otherwise traversing
- * policy_dbs_list isn't safe.
- */
-static void update_sampling_rate(struct dbs_data *dbs_data,
-               unsigned int new_rate)
-{
-       struct policy_dbs_info *policy_dbs;
-
-       dbs_data->sampling_rate = new_rate = max(new_rate,
-                       dbs_data->min_sampling_rate);
-
-       /*
-        * We are operating under dbs_data->mutex and so the list and its
-        * entries can't be freed concurrently.
-        */
-       list_for_each_entry(policy_dbs, &dbs_data->policy_dbs_list, list) {
-               mutex_lock(&policy_dbs->timer_mutex);
-               /*
-                * On 32-bit architectures this may race with the
-                * sample_delay_ns read in dbs_update_util_handler(), but that
-                * really doesn't matter.  If the read returns a value that's
-                * too big, the sample will be skipped, but the next invocation
-                * of dbs_update_util_handler() (when the update has been
-                * completed) will take a sample.  If the returned value is too
-                * small, the sample will be taken immediately, but that isn't a
-                * problem, as we want the new rate to take effect immediately
-                * anyway.
-                *
-                * If this runs in parallel with dbs_work_handler(), we may end
-                * up overwriting the sample_delay_ns value that it has just
-                * written, but the difference should not be too big and it will
-                * be corrected next time a sample is taken, so it shouldn't be
-                * significant.
-                */
-               gov_update_sample_delay(policy_dbs, new_rate);
-               mutex_unlock(&policy_dbs->timer_mutex);
-       }
-}
-
-static ssize_t store_sampling_rate(struct dbs_data *dbs_data, const char *buf,
-               size_t count)
-{
-       unsigned int input;
-       int ret;
-       ret = sscanf(buf, "%u", &input);
-       if (ret != 1)
-               return -EINVAL;
-
-       update_sampling_rate(dbs_data, input);
-       return count;
-}
-
 static ssize_t store_io_is_busy(struct dbs_data *dbs_data, const char *buf,
                size_t count)
 {