diff mbox

[195/228] cpufreq: kirkwood: remove calls to cpufreq_notify_transition()

Message ID 0a512914fd48b2d6db685446f88b9a096eff79a1.1379063063.git.viresh.kumar@linaro.org
State New
Headers show

Commit Message

Viresh Kumar Sept. 13, 2013, 1:02 p.m. UTC 
Most of the drivers do following in their ->target_index() routines:

	struct cpufreq_freqs freqs;
	freqs.old = old freq...
	freqs.new = new freq...

	cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);

	/* Change rate here */

	cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);

This is replicated over all cpufreq drivers today and there doesn't exists a
good enough reason why this shouldn't be moved to cpufreq core instead.

Earlier patches have added support in cpufreq core to do cpufreq notification on
frequency change, this one removes it from this driver.

Some related minor cleanups are also done along with it.

Cc: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
---
 drivers/cpufreq/kirkwood-cpufreq.c | 54 ++++++++++++++------------------------
 1 file changed, 20 insertions(+), 34 deletions(-)

Comments

Andrew Lunn Sept. 13, 2013, 4:18 p.m. UTC | #1 
On Fri, Sep 13, 2013 at 06:32:21PM +0530, Viresh Kumar wrote:

> -	if (freqs.old != freqs.new) {
> -		local_irq_disable();
> -
> -		/* Disable interrupts to the CPU */
> -		reg = readl_relaxed(priv.base);
> -		reg |= CPU_SW_INT_BLK;
> -		writel_relaxed(reg, priv.base);
> -
> -		switch (state) {
> -		case STATE_CPU_FREQ:
> -			clk_disable(priv.powersave_clk);
> -			break;
> -		case STATE_DDR_FREQ:
> -			clk_enable(priv.powersave_clk);
> -			break;
> -		}

Hi Viresh

I see you removed the test that the old and the new frequency are
different. Is this guaranteed by the core? Because if not, you can
lockup the CPU. The call to cpu_do_idle() will never return.

	Thanks
		Andrew
Viresh Kumar Sept. 13, 2013, 4:23 p.m. UTC | #2 
On 13 September 2013 21:48, Andrew Lunn <andrew@lunn.ch> wrote:
> On Fri, Sep 13, 2013 at 06:32:21PM +0530, Viresh Kumar wrote:
>
>> -     if (freqs.old != freqs.new) {
>> -             local_irq_disable();
>> -
>> -             /* Disable interrupts to the CPU */
>> -             reg = readl_relaxed(priv.base);
>> -             reg |= CPU_SW_INT_BLK;
>> -             writel_relaxed(reg, priv.base);
>> -
>> -             switch (state) {
>> -             case STATE_CPU_FREQ:
>> -                     clk_disable(priv.powersave_clk);
>> -                     break;
>> -             case STATE_DDR_FREQ:
>> -                     clk_enable(priv.powersave_clk);
>> -                     break;
>> -             }
>
> Hi Viresh
>
> I see you removed the test that the old and the new frequency are
> different. Is this guaranteed by the core? Because if not, you can
> lockup the CPU. The call to cpu_do_idle() will never return.

Yes, that's guaranteed by core: patch 181..
diff mbox

Patch

diff --git a/drivers/cpufreq/kirkwood-cpufreq.c b/drivers/cpufreq/kirkwood-cpufreq.c
index 0ae4dd7..0767a4e 100644
--- a/drivers/cpufreq/kirkwood-cpufreq.c
+++ b/drivers/cpufreq/kirkwood-cpufreq.c
@@ -58,48 +58,34 @@  static unsigned int kirkwood_cpufreq_get_cpu_frequency(unsigned int cpu)
 static int kirkwood_cpufreq_target(struct cpufreq_policy *policy,
 			    unsigned int index)
 {
-	struct cpufreq_freqs freqs;
 	unsigned int state = kirkwood_freq_table[index].driver_data;
 	unsigned long reg;
 
-	freqs.old = kirkwood_cpufreq_get_cpu_frequency(0);
-	freqs.new = kirkwood_freq_table[index].frequency;
+	local_irq_disable();
 
-	cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
+	/* Disable interrupts to the CPU */
+	reg = readl_relaxed(priv.base);
+	reg |= CPU_SW_INT_BLK;
+	writel_relaxed(reg, priv.base);
 
-	dev_dbg(priv.dev, "Attempting to set frequency to %i KHz\n",
-		kirkwood_freq_table[index].frequency);
-	dev_dbg(priv.dev, "old frequency was %i KHz\n",
-		kirkwood_cpufreq_get_cpu_frequency(0));
-
-	if (freqs.old != freqs.new) {
-		local_irq_disable();
-
-		/* Disable interrupts to the CPU */
-		reg = readl_relaxed(priv.base);
-		reg |= CPU_SW_INT_BLK;
-		writel_relaxed(reg, priv.base);
-
-		switch (state) {
-		case STATE_CPU_FREQ:
-			clk_disable(priv.powersave_clk);
-			break;
-		case STATE_DDR_FREQ:
-			clk_enable(priv.powersave_clk);
-			break;
-		}
+	switch (state) {
+	case STATE_CPU_FREQ:
+		clk_disable(priv.powersave_clk);
+		break;
+	case STATE_DDR_FREQ:
+		clk_enable(priv.powersave_clk);
+		break;
+	}
 
-		/* Wait-for-Interrupt, while the hardware changes frequency */
-		cpu_do_idle();
+	/* Wait-for-Interrupt, while the hardware changes frequency */
+	cpu_do_idle();
 
-		/* Enable interrupts to the CPU */
-		reg = readl_relaxed(priv.base);
-		reg &= ~CPU_SW_INT_BLK;
-		writel_relaxed(reg, priv.base);
+	/* Enable interrupts to the CPU */
+	reg = readl_relaxed(priv.base);
+	reg &= ~CPU_SW_INT_BLK;
+	writel_relaxed(reg, priv.base);
 
-		local_irq_enable();
-	}
-	cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
+	local_irq_enable();
 
 	return 0;
 }