[PATCH 1/2] powerpc/mpc85xx: add two functions to get suspend state which is standby or mem

[PATCH 1/2] powerpc/mpc85xx: add two functions to get suspend state which is standby or mem

[Dongsheng Wang]

From: Wang Dongsheng <dongsheng.wang@freescale.com>

Add set_pm_suspend_state & pm_suspend_state functions to set/get suspend state.
When system going to sleep, devices can get the system suspend state(STANDBY/MEM)
through pm_suspend_state function and handle different situations.

Signed-off-by: Wang Dongsheng <dongsheng.wang@freescale.com>

diff --git a/arch/powerpc/platforms/85xx/common.c b/arch/powerpc/platforms/85xx/common.c
index b564b5e..3853d43 100644
--- a/arch/powerpc/platforms/85xx/common.c
+++ b/arch/powerpc/platforms/85xx/common.c
@@ -8,6 +8,7 @@
 
 #include <linux/of_irq.h>
 #include <linux/of_platform.h>
+#include <linux/suspend.h>
 
 #include <asm/qe.h>
 #include <sysdev/cpm2_pic.h>
@@ -47,6 +48,19 @@ int __init mpc85xx_common_publish_devices(void)
 {
 	return of_platform_bus_probe(NULL, mpc85xx_common_ids, NULL);
 }
+
+static suspend_state_t pm_state;
+
+void set_pm_suspend_state(suspend_state_t state)
+{
+	pm_state = state;
+}
+
+suspend_state_t pm_suspend_state(void)
+{
+	return pm_state;
+}
+
 #ifdef CONFIG_CPM2
 static void cpm2_cascade(unsigned int irq, struct irq_desc *desc)
 {
diff --git a/arch/powerpc/sysdev/fsl_pmc.c b/arch/powerpc/sysdev/fsl_pmc.c
index 8cf4aa0..0b34c00 100644
--- a/arch/powerpc/sysdev/fsl_pmc.c
+++ b/arch/powerpc/sysdev/fsl_pmc.c
@@ -15,6 +15,7 @@
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/export.h>
+#include <linux/fsl/fsl_pm.h>
 #include <linux/suspend.h>
 #include <linux/delay.h>
 #include <linux/device.h>
@@ -52,12 +53,20 @@ static int pmc_suspend_valid(suspend_state_t state)
 {
 	if (state != PM_SUSPEND_STANDBY)
 		return 0;
+
+	set_pm_suspend_state(state);
 	return 1;
 }
 
+static void pmc_suspend_end(void)
+{
+	set_pm_suspend_state(PM_SUSPEND_ON);
+}
+
 static const struct platform_suspend_ops pmc_suspend_ops = {
 	.valid = pmc_suspend_valid,
 	.enter = pmc_suspend_enter,
+	.end	= pmc_suspend_end,
 };
 
 static int pmc_probe(struct platform_device *ofdev)
@@ -68,6 +77,7 @@ static int pmc_probe(struct platform_device *ofdev)
 
 	pmc_dev = &ofdev->dev;
 	suspend_set_ops(&pmc_suspend_ops);
+	set_pm_suspend_state(PM_SUSPEND_ON);
 	return 0;
 }
 
diff --git a/include/linux/fsl/fsl_pm.h b/include/linux/fsl/fsl_pm.h
new file mode 100644
index 0000000..705ea52
--- /dev/null
+++ b/include/linux/fsl/fsl_pm.h
@@ -0,0 +1,25 @@
+/*
+ * include/linux/fsl/fsl_pm.h
+ *
+ * Definitions for any platform related flags or structures for Freescale
+ * Power Management.
+ *
+ * Author: Wang Dongsheng <dongsheng.wang@freescale.com>
+ *
+ * Copyright 2014 Freescale Semiconductor, Inc
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/suspend.h>
+
+#ifdef CONFIG_FSL_SOC_BOOKE
+extern void set_pm_suspend_state(suspend_state_t state);
+extern suspend_state_t pm_suspend_state(void);
+#else
+static inline void set_pm_suspend_state(suspend_state_t state) { }
+static inline suspend_state_t pm_suspend_state(void) { }
+#endif
-- 
1.8.5

[PATCH 2/2] fsl/mpic_timer: make mpic_timer to support deep sleep feature

[Dongsheng Wang]

From: Wang Dongsheng <dongsheng.wang@freescale.com>

At T104x platfrom the timer clock will be changed when system going to
deep sleep. Add suspend function to switch timer time before system
going to deep sleep, and recovery the time after resume from deep sleep.

Signed-off-by: Wang Dongsheng <dongsheng.wang@freescale.com>

diff --git a/arch/powerpc/sysdev/mpic_timer.c b/arch/powerpc/sysdev/mpic_timer.c
index 9d9b062..737a53d 100644
--- a/arch/powerpc/sysdev/mpic_timer.c
+++ b/arch/powerpc/sysdev/mpic_timer.c
@@ -11,6 +11,7 @@
  * option) any later version.
  */
 
+#include <linux/fsl/fsl_pm.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/module.h>
@@ -18,6 +19,7 @@
 #include <linux/mm.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
+#include <linux/suspend.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/of_device.h>
@@ -26,6 +28,7 @@
 #include <sysdev/fsl_soc.h>
 #include <asm/io.h>
 
+#include <asm/mpc85xx.h>
 #include <asm/mpic_timer.h>
 
 #define FSL_GLOBAL_TIMER		0x1
@@ -71,8 +74,10 @@ struct timer_group_priv {
 	struct timer_regs __iomem	*regs;
 	struct mpic_timer		timer[TIMERS_PER_GROUP];
 	struct list_head		node;
+	unsigned long			idle;
 	unsigned int			timerfreq;
-	unsigned int			idle;
+	unsigned int			suspended_timerfreq;
+	unsigned int			resume_timerfreq;
 	unsigned int			flags;
 	spinlock_t			lock;
 	void __iomem			*group_tcr;
@@ -88,6 +93,7 @@ static struct cascade_priv cascade_timer[] = {
 };
 
 static LIST_HEAD(timer_group_list);
+static int switch_freq_flag;
 
 static void convert_ticks_to_time(struct timer_group_priv *priv,
 		const u64 ticks, struct timeval *time)
@@ -423,6 +429,33 @@ struct mpic_timer *mpic_request_timer(irq_handler_t fn, void *dev,
 }
 EXPORT_SYMBOL(mpic_request_timer);
 
+static void timer_group_get_suspended_freq(struct timer_group_priv *priv)
+{
+	struct device_node *np;
+
+	np = of_find_compatible_node(NULL, NULL, "fsl,qoriq-clockgen-2.0");
+	if (!np) {
+		pr_err("mpic timer: Missing clockgen device node.\n");
+
+		return;
+	}
+
+	of_property_read_u32(np, "clock-frequency", &priv->suspended_timerfreq);
+	of_node_put(np);
+}
+
+static int need_to_switch_freq(void)
+{
+	u32 svr;
+
+	svr = mfspr(SPRN_SVR);
+	if (SVR_SOC_VER(svr) == SVR_T1040 ||
+			SVR_SOC_VER(svr) == SVR_T1042)
+		return 1;
+
+	return 0;
+}
+
 static int timer_group_get_freq(struct device_node *np,
 			struct timer_group_priv *priv)
 {
@@ -437,6 +470,15 @@ static int timer_group_get_freq(struct device_node *np,
 					&priv->timerfreq);
 			of_node_put(dn);
 		}
+
+		/*
+		 * For deep sleep, if system going to deep sleep,
+		 * timer freq will be changed.
+		 */
+		if (need_to_switch_freq()) {
+			timer_group_get_suspended_freq(priv);
+			switch_freq_flag = 1;
+		}
 	}
 
 	if (priv->timerfreq <= 0)
@@ -445,6 +487,7 @@ static int timer_group_get_freq(struct device_node *np,
 	if (priv->flags & FSL_GLOBAL_TIMER) {
 		div = (1 << (MPIC_TIMER_TCR_CLKDIV >> 8)) * 8;
 		priv->timerfreq /= div;
+		priv->suspended_timerfreq /= div;
 	}
 
 	return 0;
@@ -564,14 +607,190 @@ out:
 	kfree(priv);
 }
 
+static void mpic_reset_time(struct mpic_timer *handle, struct timeval *bcr_time,
+				struct timeval *ccr_time)
+{
+	struct timer_group_priv *priv = container_of(handle,
+			struct timer_group_priv, timer[handle->num]);
+
+	u64 ccr_ticks = 0;
+	u64 bcr_ticks = 0;
+
+	/* switch bcr time */
+	convert_time_to_ticks(priv, bcr_time, &bcr_ticks);
+
+	/* switch ccr time */
+	convert_time_to_ticks(priv, ccr_time, &ccr_ticks);
+
+	if (handle->cascade_handle) {
+		u32 tmp_ticks;
+		u32 rem_ticks;
+
+		/* reset ccr ticks to bcr */
+		tmp_ticks = div_u64_rem(ccr_ticks, MAX_TICKS_CASCADE,
+					&rem_ticks);
+		out_be32(&priv->regs[handle->num].gtbcr,
+			tmp_ticks | TIMER_STOP);
+		out_be32(&priv->regs[handle->num - 1].gtbcr, rem_ticks);
+
+		/* start timer */
+		clrbits32(&priv->regs[handle->num].gtbcr, TIMER_STOP);
+
+		/* reset bcr */
+		tmp_ticks = div_u64_rem(bcr_ticks, MAX_TICKS_CASCADE,
+					&rem_ticks);
+		out_be32(&priv->regs[handle->num].gtbcr,
+			tmp_ticks & ~TIMER_STOP);
+		out_be32(&priv->regs[handle->num - 1].gtbcr, rem_ticks);
+	} else {
+		/* reset ccr ticks to bcr */
+		out_be32(&priv->regs[handle->num].gtbcr,
+			ccr_ticks | TIMER_STOP);
+		/* start timer */
+		clrbits32(&priv->regs[handle->num].gtbcr, TIMER_STOP);
+		/* reset bcr */
+		out_be32(&priv->regs[handle->num].gtbcr,
+			bcr_ticks & ~TIMER_STOP);
+	}
+}
+
+static void do_switch_time(struct mpic_timer *handle, unsigned int new_freq)
+{
+	struct timer_group_priv *priv = container_of(handle,
+			struct timer_group_priv, timer[handle->num]);
+	struct timeval ccr_time;
+	struct timeval bcr_time;
+	unsigned int timerfreq;
+	u32 test_stop;
+	u64 ticks;
+
+	test_stop = in_be32(&priv->regs[handle->num].gtbcr);
+	test_stop &= TIMER_STOP;
+	if (test_stop)
+		return;
+
+	/* stop timer, prepare reset time */
+	setbits32(&priv->regs[handle->num].gtbcr, TIMER_STOP);
+
+	/* get bcr time */
+	if (handle->cascade_handle) {
+		u32 tmp_ticks;
+
+		tmp_ticks = in_be32(&priv->regs[handle->num].gtbcr);
+		tmp_ticks &= ~TIMER_STOP;
+		ticks = ((u64)tmp_ticks & UINT_MAX) * (u64)MAX_TICKS_CASCADE;
+		tmp_ticks = in_be32(&priv->regs[handle->num - 1].gtbcr);
+		ticks += tmp_ticks;
+	} else {
+		ticks = in_be32(&priv->regs[handle->num].gtbcr);
+		ticks &= ~TIMER_STOP;
+	}
+	convert_ticks_to_time(priv, ticks, &bcr_time);
+
+	/* get ccr time */
+	mpic_get_remain_time(handle, &ccr_time);
+
+	/* recalculate timer time */
+	timerfreq = priv->timerfreq;
+	priv->timerfreq = new_freq;
+	mpic_reset_time(handle, &bcr_time, &ccr_time);
+	priv->timerfreq = timerfreq;
+}
+
+static void switch_group_timer(struct timer_group_priv *priv,
+				unsigned int new_freq)
+{
+	int i, num;
+
+	for (i = 0; i < TIMERS_PER_GROUP; i++) {
+		num = TIMERS_PER_GROUP - 1 - i;
+		/* cascade */
+		if ((i + 1) < TIMERS_PER_GROUP &&
+				priv->timer[num].cascade_handle) {
+			do_switch_time(&priv->timer[num], new_freq);
+			i++;
+			continue;
+		}
+
+		if (!test_bit(i, &priv->idle))
+			do_switch_time(&priv->timer[num], new_freq);
+	}
+}
+
+static int mpic_timer_suspend(void)
+{
+	struct timer_group_priv *priv;
+	suspend_state_t pm_state;
+
+	pm_state = pm_suspend_state();
+
+	list_for_each_entry(priv, &timer_group_list, node) {
+		/* timer not be used */
+		if (priv->idle == 0xf)
+			continue;
+
+		switch (pm_state) {
+		case PM_SUSPEND_STANDBY:
+			break;
+		case PM_SUSPEND_MEM:
+			if (!switch_freq_flag)
+				continue;
+
+			if (!priv->suspended_timerfreq) {
+				pr_warn("Mpic timer will not be accurate.\n");
+				continue;
+			}
+
+			/* will switch timers, a set of timer */
+			switch_group_timer(priv, priv->suspended_timerfreq);
+
+			/* Software: switch timerfreq to suspended freq */
+			priv->resume_timerfreq = priv->timerfreq;
+			priv->timerfreq = priv->suspended_timerfreq;
+			break;
+		default:
+			break;
+		}
+	}
+
+	return 0;
+}
+
 static void mpic_timer_resume(void)
 {
 	struct timer_group_priv *priv;
+	suspend_state_t pm_state;
+
+	pm_state = pm_suspend_state();
 
 	list_for_each_entry(priv, &timer_group_list, node) {
 		/* Init FSL timer hardware */
 		if (priv->flags & FSL_GLOBAL_TIMER)
 			setbits32(priv->group_tcr, MPIC_TIMER_TCR_CLKDIV);
+
+		/* timer not be used */
+		if (priv->idle == 0xf)
+			continue;
+
+		switch (pm_state) {
+		case PM_SUSPEND_STANDBY:
+			break;
+		case PM_SUSPEND_MEM:
+			if (!switch_freq_flag)
+				continue;
+
+			if (!priv->suspended_timerfreq)
+				continue;
+
+			/* will switch timers, a set of timer */
+			switch_group_timer(priv, priv->resume_timerfreq);
+
+			/* restore timerfreq */
+			priv->timerfreq = priv->resume_timerfreq;
+			break;
+		default:
+			break;
+		}
 	}
 }
 
@@ -581,6 +800,7 @@ static const struct of_device_id mpic_timer_ids[] = {
 };
 
 static struct syscore_ops mpic_timer_syscore_ops = {
+	.suspend = mpic_timer_suspend,
 	.resume = mpic_timer_resume,
 };
 
-- 
1.8.5

Re: [PATCH 1/2] powerpc/mpc85xx: add two functions to get suspend state which is standby or mem

[Scott Wood]

On Mon, 2014-04-14 at 10:24 +0800, Dongsheng Wang wrote:
> From: Wang Dongsheng <dongsheng.wang@freescale.com>
> 
> Add set_pm_suspend_state & pm_suspend_state functions to set/get suspend state.
> When system going to sleep, devices can get the system suspend state(STANDBY/MEM)
> through pm_suspend_state function and handle different situations.
> 
> Signed-off-by: Wang Dongsheng <dongsheng.wang@freescale.com>
> 
> diff --git a/arch/powerpc/platforms/85xx/common.c b/arch/powerpc/platforms/85xx/common.c
> index b564b5e..3853d43 100644
> --- a/arch/powerpc/platforms/85xx/common.c
> +++ b/arch/powerpc/platforms/85xx/common.c
> @@ -8,6 +8,7 @@
>  
>  #include <linux/of_irq.h>
>  #include <linux/of_platform.h>
> +#include <linux/suspend.h>
>  
>  #include <asm/qe.h>
>  #include <sysdev/cpm2_pic.h>
> @@ -47,6 +48,19 @@ int __init mpc85xx_common_publish_devices(void)
>  {
>  	return of_platform_bus_probe(NULL, mpc85xx_common_ids, NULL);
>  }
> +
> +static suspend_state_t pm_state;
> +
> +void set_pm_suspend_state(suspend_state_t state)
> +{
> +	pm_state = state;
> +}
> +
> +suspend_state_t pm_suspend_state(void)
> +{
> +	return pm_state;
> +}

These need to be namespaced to indicate that they apply only to mpc85xx.
Where do you plan on using these from, that mpc85xx can be safely
assumed?

This seems like a feature that should be implemented in generic code
instead.

-Scott

Re: [PATCH 2/2] fsl/mpic_timer: make mpic_timer to support deep sleep feature

[Scott Wood]

On Mon, 2014-04-14 at 10:24 +0800, Dongsheng Wang wrote:
> From: Wang Dongsheng <dongsheng.wang@freescale.com>
> 
> At T104x platfrom the timer clock will be changed when system going to
> deep sleep.

Could you elaborate on what is changing and why?

> +#include <asm/mpc85xx.h>
>  #include <asm/mpic_timer.h>

So much for, "The driver currently is only tested on fsl chip, but it
can potentially support other global timers complying to OpenPIC
standard."

>  #define FSL_GLOBAL_TIMER		0x1
> @@ -71,8 +74,10 @@ struct timer_group_priv {
>  	struct timer_regs __iomem	*regs;
>  	struct mpic_timer		timer[TIMERS_PER_GROUP];
>  	struct list_head		node;
> +	unsigned long			idle;
>  	unsigned int			timerfreq;
> -	unsigned int			idle;

Why?

> +	unsigned int			suspended_timerfreq;
> +	unsigned int			resume_timerfreq;
>  	unsigned int			flags;
>  	spinlock_t			lock;
>  	void __iomem			*group_tcr;
> @@ -88,6 +93,7 @@ static struct cascade_priv cascade_timer[] = {
>  };
>  
>  static LIST_HEAD(timer_group_list);
> +static int switch_freq_flag;

Needs documentation, and based on "_flag" it should probably be a bool.

>  static void convert_ticks_to_time(struct timer_group_priv *priv,
>  		const u64 ticks, struct timeval *time)
> @@ -423,6 +429,33 @@ struct mpic_timer *mpic_request_timer(irq_handler_t fn, void *dev,
>  }
>  EXPORT_SYMBOL(mpic_request_timer);
>  
> +static void timer_group_get_suspended_freq(struct timer_group_priv *priv)
> +{
> +	struct device_node *np;
> +
> +	np = of_find_compatible_node(NULL, NULL, "fsl,qoriq-clockgen-2.0");
> +	if (!np) {
> +		pr_err("mpic timer: Missing clockgen device node.\n");

Why is it an error to not have a 2.0 QorIQ clockgen?

> +		return;
> +	}
> +
> +	of_property_read_u32(np, "clock-frequency", &priv->suspended_timerfreq);
> +	of_node_put(np);

Shouldn't this go through the clock API?

> +}
> +
> +static int need_to_switch_freq(void)
> +{
> +	u32 svr;
> +
> +	svr = mfspr(SPRN_SVR);
> +	if (SVR_SOC_VER(svr) == SVR_T1040 ||
> +			SVR_SOC_VER(svr) == SVR_T1042)
> +		return 1;

Explain why this is specific to T104x.

-Scott

RE: [PATCH 1/2] powerpc/mpc85xx: add two functions to get suspend state which is standby or mem

[Dongsheng.Wang]
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RE: [PATCH 2/2] fsl/mpic_timer: make mpic_timer to support deep sleep feature

[Dongsheng.Wang]
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Re: [PATCH 1/2] powerpc/mpc85xx: add two functions to get suspend state which is standby or mem

[Scott Wood]

On Mon, 2014-04-14 at 21:19 -0500, Wang Dongsheng-B40534 wrote:
> 
> > -----Original Message-----
> > From: Wood Scott-B07421
> > Sent: Tuesday, April 15, 2014 7:27 AM
> > To: Wang Dongsheng-B40534
> > Cc: Jin Zhengxiong-R64188; Li Yang-Leo-R58472; Zhao Chenhui-B35336; linuxppc-
> > dev@lists.ozlabs.org
> > Subject: Re: [PATCH 1/2] powerpc/mpc85xx: add two functions to get suspend state
> > which is standby or mem
> > 
> > On Mon, 2014-04-14 at 10:24 +0800, Dongsheng Wang wrote:
> > > From: Wang Dongsheng <dongsheng.wang@freescale.com>
> > >
> > > Add set_pm_suspend_state & pm_suspend_state functions to set/get suspend state.
> > > When system going to sleep, devices can get the system suspend
> > > state(STANDBY/MEM) through pm_suspend_state function and handle different
> > situations.
> > >
> > > Signed-off-by: Wang Dongsheng <dongsheng.wang@freescale.com>
> > >
> > > diff --git a/arch/powerpc/platforms/85xx/common.c
> > > b/arch/powerpc/platforms/85xx/common.c
> > > index b564b5e..3853d43 100644
> > > --- a/arch/powerpc/platforms/85xx/common.c
> > > +++ b/arch/powerpc/platforms/85xx/common.c
> > > @@ -8,6 +8,7 @@
> > >
> > >  #include <linux/of_irq.h>
> > >  #include <linux/of_platform.h>
> > > +#include <linux/suspend.h>
> > >
> > >  #include <asm/qe.h>
> > >  #include <sysdev/cpm2_pic.h>
> > > @@ -47,6 +48,19 @@ int __init mpc85xx_common_publish_devices(void)
> > >  {
> > >  	return of_platform_bus_probe(NULL, mpc85xx_common_ids, NULL);  }
> > > +
> > > +static suspend_state_t pm_state;
> > > +
> > > +void set_pm_suspend_state(suspend_state_t state) {
> > > +	pm_state = state;
> > > +}
> > > +
> > > +suspend_state_t pm_suspend_state(void) {
> > > +	return pm_state;
> > > +}
> > 
> > These need to be namespaced to indicate that they apply only to mpc85xx.
> > Where do you plan on using these from, that mpc85xx can be safely assumed?
> > 
> 
> Mpic timer and PCIe driver.

The PCIe driver is not mpc85xx-specific.

-Scott

Re: [PATCH 2/2] fsl/mpic_timer: make mpic_timer to support deep sleep feature

[Scott Wood]

On Mon, 2014-04-14 at 22:23 -0500, Wang Dongsheng-B40534 wrote:
> 
> > -----Original Message-----
> > From: Wood Scott-B07421
> > Sent: Tuesday, April 15, 2014 7:36 AM
> > To: Wang Dongsheng-B40534
> > Cc: Jin Zhengxiong-R64188; Li Yang-Leo-R58472; Zhao Chenhui-B35336; linuxppc-
> > dev@lists.ozlabs.org
> > Subject: Re: [PATCH 2/2] fsl/mpic_timer: make mpic_timer to support deep sleep
> > feature
> > 
> > On Mon, 2014-04-14 at 10:24 +0800, Dongsheng Wang wrote:
> > > From: Wang Dongsheng <dongsheng.wang@freescale.com>
> > >
> > > At T104x platfrom the timer clock will be changed when system going to
> > > deep sleep.
> > 
> > Could you elaborate on what is changing and why?
> > 
> 
> Okay.
> 
> > > +#include <asm/mpc85xx.h>
> > >  #include <asm/mpic_timer.h>
> > 
> > So much for, "The driver currently is only tested on fsl chip, but it can
> > potentially support other global timers complying to OpenPIC standard."
> > 
> > >  #define FSL_GLOBAL_TIMER		0x1
> > > @@ -71,8 +74,10 @@ struct timer_group_priv {
> > >  	struct timer_regs __iomem	*regs;
> > >  	struct mpic_timer		timer[TIMERS_PER_GROUP];
> > >  	struct list_head		node;
> > > +	unsigned long			idle;
> > >  	unsigned int			timerfreq;
> > > -	unsigned int			idle;
> > 
> > Why?
> > 
> 
> Um... It shouldn't be happened...i will remove this.
> 
> > > +	unsigned int			suspended_timerfreq;
> > > +	unsigned int			resume_timerfreq;
> > >  	unsigned int			flags;
> > >  	spinlock_t			lock;
> > >  	void __iomem			*group_tcr;
> > > @@ -88,6 +93,7 @@ static struct cascade_priv cascade_timer[] = {  };
> > >
> > >  static LIST_HEAD(timer_group_list);
> > > +static int switch_freq_flag;
> > 
> > Needs documentation, and based on "_flag" it should probably be a bool.
> > 
> 
> Okay.
> 
> > >  static void convert_ticks_to_time(struct timer_group_priv *priv,
> > >  		const u64 ticks, struct timeval *time) @@ -423,6 +429,33 @@ struct
> > > mpic_timer *mpic_request_timer(irq_handler_t fn, void *dev,  }
> > > EXPORT_SYMBOL(mpic_request_timer);
> > >
> > > +static void timer_group_get_suspended_freq(struct timer_group_priv
> > > +*priv) {
> > > +	struct device_node *np;
> > > +
> > > +	np = of_find_compatible_node(NULL, NULL, "fsl,qoriq-clockgen-2.0");
> > > +	if (!np) {
> > > +		pr_err("mpic timer: Missing clockgen device node.\n");
> > 
> > Why is it an error to not have a 2.0 QorIQ clockgen?
> > 
> 
> This will affect the accuracy of the timer. But not means the timer cannot work.
> Maybe you are right, this pr_err should be a pr_warn.

What I mean is, what if the mpic timer driver is used with deep sleep on
a different chip such as mpc8536?

> > > +		return;
> > > +	}
> > > +
> > > +	of_property_read_u32(np, "clock-frequency", &priv->suspended_timerfreq);
> > > +	of_node_put(np);
> > 
> > Shouldn't this go through the clock API?
> > 
> 
> Sorry, I'm not clear about clock API, you mean fsl_get_sys_freq()? Or ?

No, I mean drivers/clk/

Though I suppose manually reading clock-frequency is OK, as the
clock-frequency on the clockgen node predated the introduction of clock
bindings to the device tree.

Don't use fsl_get_sys_freq().

> The timer operates on sys_ref_clk frequency during deep sleep. And The timer runs on
> platform clock/2 during normal operation.

Sigh...  I wish hardware people would consult us before doing screwy
things like this.  If the platform clock is unavailable in deep sleep
(Can that really be true?  Surely there are other wakeup sources that
need it), why not run it at sys_ref_clk all the time?

Where is this documented?

> > > +static int need_to_switch_freq(void)
> > > +{
> > > +	u32 svr;
> > > +
> > > +	svr = mfspr(SPRN_SVR);
> > > +	if (SVR_SOC_VER(svr) == SVR_T1040 ||
> > > +			SVR_SOC_VER(svr) == SVR_T1042)
> > > +		return 1;
> > 
> > Explain why this is specific to T104x.
> > 
> 
> Mpic timer freq will be change when system going to deep sleep. So we need to recalculate the time.

Do any other chips with deep sleep have this problem?

-Scott

RE: [PATCH 2/2] fsl/mpic_timer: make mpic_timer to support deep sleep feature

[Dongsheng.Wang]
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