Merge "cpufreq: interactive: Rearm governor timer at max freq" (b4047745) · Commits · e / devices / android_kernel_sony_msm8994

drivers/cpufreq/cpufreq_interactive.c

+8 −69

Original line number	Diff line number	Diff line
		@@ -54,7 +54,7 @@ struct cpufreq_interactive_cpuinfo {
		u64 floor_validate_time;
		u64 hispeed_validate_time; /* cluster hispeed_validate_time */
		u64 local_hvtime; /* per-cpu hispeed_validate_time */
		u64 max_freq_idle_start_time;
		u64 max_freq_hyst_start_time;
		struct rw_semaphore enable_sem;
		bool reject_notification;
		int governor_enabled;
		@@ -487,9 +487,8 @@ static void cpufreq_interactive_timer(unsigned long data)

		new_freq = pcpu->freq_table[index].frequency;

		if (pcpu->target_freq >= pcpu->policy->max
		&& new_freq < pcpu->target_freq
		&& now - pcpu->max_freq_idle_start_time <
		if (new_freq < pcpu->target_freq &&
		now - pcpu->max_freq_hyst_start_time <
		tunables->max_freq_hysteresis) {
		trace_cpufreq_interactive_notyet(data, cpu_load,
		pcpu->target_freq, pcpu->policy->cur, new_freq);
		@@ -525,12 +524,15 @@ static void cpufreq_interactive_timer(unsigned long data)
		pcpu->floor_validate_time = now;
		}

		if (new_freq == pcpu->policy->max)
		pcpu->max_freq_hyst_start_time = now;

		if (pcpu->target_freq == new_freq) {
		trace_cpufreq_interactive_already(
		data, cpu_load, pcpu->target_freq,
		pcpu->policy->cur, new_freq);
		spin_unlock_irqrestore(&pcpu->target_freq_lock, flags);
		goto rearm_if_notmax;
		goto rearm;
		}

		trace_cpufreq_interactive_target(data, cpu_load, pcpu->target_freq,
		@@ -543,14 +545,6 @@ static void cpufreq_interactive_timer(unsigned long data)
		spin_unlock_irqrestore(&speedchange_cpumask_lock, flags);
		wake_up_process(speedchange_task);

		rearm_if_notmax:
		/*
		* Already set max speed and don't see a need to change that,
		* wait until next idle to re-evaluate, don't need timer.
		*/
		if (pcpu->target_freq == pcpu->policy->max)
		goto exit;

		rearm:
		if (!timer_pending(&pcpu->cpu_timer))
		cpufreq_interactive_timer_resched(data);
		@@ -560,55 +554,6 @@ exit:
		return;
		}

		static void cpufreq_interactive_idle_start(void)
		{
		struct cpufreq_interactive_cpuinfo *pcpu =
		&per_cpu(cpuinfo, smp_processor_id());
		int pending;
		struct cpufreq_interactive_tunables *tunables;
		unsigned long flags;
		u64 now;

		if (!down_read_trylock(&pcpu->enable_sem))
		return;
		if (!pcpu->governor_enabled) {
		up_read(&pcpu->enable_sem);
		return;
		}

		pending = timer_pending(&pcpu->cpu_timer);

		if (pcpu->target_freq != pcpu->policy->min) {
		/*
		* Entering idle while not at lowest speed. On some
		* platforms this can hold the other CPU(s) at that speed
		* even though the CPU is idle. Set a timer to re-evaluate
		* speed so this idle CPU doesn't hold the other CPUs above
		* min indefinitely. This should probably be a quirk of
		* the CPUFreq driver.
		*/
		if (!pending) {
		pcpu->last_evaluated_jiffy = get_jiffies_64();
		cpufreq_interactive_timer_resched(smp_processor_id());

		/*
		* If timer is cancelled because CPU is running at
		* policy->max, record the time CPU first goes to
		* idle.
		*/
		now = ktime_to_us(ktime_get());
		tunables = pcpu->policy->governor_data;
		if (tunables->max_freq_hysteresis) {
		spin_lock_irqsave(&pcpu->target_freq_lock,
		flags);
		pcpu->max_freq_idle_start_time = now;
		spin_unlock_irqrestore(&pcpu->target_freq_lock,
		flags);
		}
		}
		}
		up_read(&pcpu->enable_sem);
		}

		static void cpufreq_interactive_idle_end(void)
		{
		@@ -1469,14 +1414,8 @@ static int cpufreq_interactive_idle_notifier(struct notifier_block *nb,
		unsigned long val,
		void *data)
		{
		switch (val) {
		case IDLE_START:
		cpufreq_interactive_idle_start();
		break;
		case IDLE_END:
		if (val == IDLE_END)
		cpufreq_interactive_idle_end();
		break;
		}

		return 0;
		}