Merge tag 'omap-for-v4.18/soc-signed' of git://git.kernel.org/pub/scm/linux/kernel/git/tmlind/linux-omap into next/soc

SoC changes for omap variants for v4.18 merge window

This series mostly adds saving of power and clock domain registers for
am335x/am437x suspend to RTC only mode. There is also a non-urgent fix
for omap4 PM where we could end up losing GPIO interrupts if bootloader
has LOGICRETSTATE cleared for domains. And there is a clean-up patch for
omap1 to use device properties for at24 eeprom.

* tag 'omap-for-v4.18/soc-signed' of git://git.kernel.org/pub/scm/linux/kernel/git/tmlind/linux-omap:
  ARM: OMAP2+: Make sure LOGICRETSTATE bits are not cleared
  ARM: OMAP2+: prm44xx: Inroduce cpu_pm notifiers for context save/restore
  ARM: OMAP2+: prm44xx: Introduce context save/restore for am43 PRCM IO
  ARM: OMAP2+: powerdomain: Introduce cpu_pm notifiers for context save/restore
  ARM: OMAP2+: Add functions to save and restore powerdomain context
  ARM: OMAP2+: clockdomain: Inroduce cpu_pm notifiers for context save/restore
  ARM: OMAP2+: Add functions to save and restore clockdomain context en-masse.
  ARM: omap1: osk: use device properties for at24 eeprom

Signed-off-by: Olof Johansson <olof@lixom.net>

10 files changed, 424 insertions, 5 deletions

diff --git a/arch/arm/mach-omap1/board-osk.c b/arch/arm/mach-omap1/board-osk.c
index c66372ed29e2..9ffa8d755a59 100644
--- a/arch/arm/mach-omap1/board-osk.c
+++ b/arch/arm/mach-omap1/board-osk.c
@@ -303,22 +303,22 @@ static const struct omap_lcd_config osk_lcd_config __initconst = {
 #ifdef  CONFIG_OMAP_OSK_MISTRAL
 
 #include <linux/input.h>
-#include <linux/platform_data/at24.h>
+#include <linux/property.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>
 
 #include <linux/platform_data/keypad-omap.h>
 
-static struct at24_platform_data at24c04 = {
-        .byte_len       = SZ_4K / 8,
-        .page_size      = 16,
+static const struct property_entry mistral_at24_properties[] = {
+        PROPERTY_ENTRY_U32("pagesize", 16),
+        { }
 };
 
 static struct i2c_board_info __initdata mistral_i2c_board_info[] = {
         {
                 /* NOTE:  powered from LCD supply */
                 I2C_BOARD_INFO("24c04", 0x50),
-                .platform_data  = &at24c04,
+                .properties = mistral_at24_properties,
         },
         /* TODO when driver support is ready:
          *  - optionally ov9640 camera sensor at 0x30
diff --git a/arch/arm/mach-omap2/clockdomain.c b/arch/arm/mach-omap2/clockdomain.c
index b79b1ca9aee9..6d44fe05a3fe 100644
--- a/arch/arm/mach-omap2/clockdomain.c
+++ b/arch/arm/mach-omap2/clockdomain.c
@@ -23,6 +23,7 @@
 #include <linux/limits.h>
 #include <linux/err.h>
 #include <linux/clk-provider.h>
+#include <linux/cpu_pm.h>
 
 #include <linux/io.h>
 
@@ -31,6 +32,7 @@
 #include "soc.h"
 #include "clock.h"
 #include "clockdomain.h"
+#include "pm.h"
 
 /* clkdm_list contains all registered struct clockdomains */
 static LIST_HEAD(clkdm_list);
@@ -39,6 +41,8 @@ static LIST_HEAD(clkdm_list);
 static struct clkdm_autodep *autodeps;
 
 static struct clkdm_ops *arch_clkdm;
+void clkdm_save_context(void);
+void clkdm_restore_context(void);
 
 /* Private functions */
 
@@ -449,6 +453,22 @@ int clkdm_register_autodeps(struct clkdm_autodep *ia)
         return 0;
 }
 
+static int cpu_notifier(struct notifier_block *nb, unsigned long cmd, void *v)
+{
+        switch (cmd) {
+        case CPU_CLUSTER_PM_ENTER:
+                if (enable_off_mode)
+                        clkdm_save_context();
+                break;
+        case CPU_CLUSTER_PM_EXIT:
+                if (enable_off_mode)
+                        clkdm_restore_context();
+                break;
+        }
+
+        return NOTIFY_OK;
+}
+
 /**
  * clkdm_complete_init - set up the clockdomain layer
  *
@@ -460,6 +480,7 @@ int clkdm_register_autodeps(struct clkdm_autodep *ia)
 int clkdm_complete_init(void)
 {
         struct clockdomain *clkdm;
+        static struct notifier_block nb;
 
         if (list_empty(&clkdm_list))
                 return -EACCES;
@@ -474,6 +495,12 @@ int clkdm_complete_init(void)
                 clkdm_clear_all_sleepdeps(clkdm);
         }
 
+        /* Only AM43XX can lose clkdm context during rtc-ddr suspend */
+        if (soc_is_am43xx()) {
+                nb.notifier_call = cpu_notifier;
+                cpu_pm_register_notifier(&nb);
+        }
+
         return 0;
 }
 
@@ -1307,3 +1334,49 @@ int clkdm_hwmod_disable(struct clockdomain *clkdm, struct omap_hwmod *oh)
         return 0;
 }
 
+/**
+ * _clkdm_save_context - save the context for the control of this clkdm
+ *
+ * Due to a suspend or hibernation operation, the state of the registers
+ * controlling this clkdm will be lost, save their context.
+ */
+static int _clkdm_save_context(struct clockdomain *clkdm, void *ununsed)
+{
+        if (!arch_clkdm || !arch_clkdm->clkdm_save_context)
+                return -EINVAL;
+
+        return arch_clkdm->clkdm_save_context(clkdm);
+}
+
+/**
+ * _clkdm_restore_context - restore context for control of this clkdm
+ *
+ * Restore the register values for this clockdomain.
+ */
+static int _clkdm_restore_context(struct clockdomain *clkdm, void *ununsed)
+{
+        if (!arch_clkdm || !arch_clkdm->clkdm_restore_context)
+                return -EINVAL;
+
+        return arch_clkdm->clkdm_restore_context(clkdm);
+}
+
+/**
+ * clkdm_save_context - Saves the context for each registered clkdm
+ *
+ * Save the context for each registered clockdomain.
+ */
+void clkdm_save_context(void)
+{
+        clkdm_for_each(_clkdm_save_context, NULL);
+}
+
+/**
+ * clkdm_restore_context - Restores the context for each registered clkdm
+ *
+ * Restore the context for each registered clockdomain.
+ */
+void clkdm_restore_context(void)
+{
+        clkdm_for_each(_clkdm_restore_context, NULL);
+}
diff --git a/arch/arm/mach-omap2/clockdomain.h b/arch/arm/mach-omap2/clockdomain.h
index 24667a5a9dc0..c7d0953e4aa2 100644
--- a/arch/arm/mach-omap2/clockdomain.h
+++ b/arch/arm/mach-omap2/clockdomain.h
@@ -141,6 +141,7 @@ struct clockdomain {
         int usecount;
         int forcewake_count;
         struct list_head node;
+        u32 context;
 };
 
 /**
@@ -159,6 +160,8 @@ struct clockdomain {
  * @clkdm_deny_idle: Disable hw supervised idle transitions for clock domain
  * @clkdm_clk_enable: Put the clkdm in right state for a clock enable
  * @clkdm_clk_disable: Put the clkdm in right state for a clock disable
+ * @clkdm_save_context: Save the current clkdm context
+ * @clkdm_restore_context: Restore the clkdm context
  */
 struct clkdm_ops {
         int     (*clkdm_add_wkdep)(struct clockdomain *clkdm1, struct clockdomain *clkdm2);
@@ -175,6 +178,8 @@ struct clkdm_ops {
         void    (*clkdm_deny_idle)(struct clockdomain *clkdm);
         int     (*clkdm_clk_enable)(struct clockdomain *clkdm);
         int     (*clkdm_clk_disable)(struct clockdomain *clkdm);
+        int     (*clkdm_save_context)(struct clockdomain *clkdm);
+        int     (*clkdm_restore_context)(struct clockdomain *clkdm);
 };
 
 int clkdm_register_platform_funcs(struct clkdm_ops *co);
@@ -214,6 +219,9 @@ int clkdm_clk_disable(struct clockdomain *clkdm, struct clk *clk);
 int clkdm_hwmod_enable(struct clockdomain *clkdm, struct omap_hwmod *oh);
 int clkdm_hwmod_disable(struct clockdomain *clkdm, struct omap_hwmod *oh);
 
+void clkdm_save_context(void);
+void clkdm_restore_context(void);
+
 extern void __init omap242x_clockdomains_init(void);
 extern void __init omap243x_clockdomains_init(void);
 extern void __init omap3xxx_clockdomains_init(void);
diff --git a/arch/arm/mach-omap2/cm33xx.c b/arch/arm/mach-omap2/cm33xx.c
index 1cc0247a2cb5..084d454f6074 100644
--- a/arch/arm/mach-omap2/cm33xx.c
+++ b/arch/arm/mach-omap2/cm33xx.c
@@ -72,6 +72,17 @@ static inline u32 am33xx_cm_rmw_reg_bits(u32 mask, u32 bits, s16 inst, s16 idx)
         return v;
 }
 
+static inline u32 am33xx_cm_read_reg_bits(u16 inst, s16 idx, u32 mask)
+{
+        u32 v;
+
+        v = am33xx_cm_read_reg(inst, idx);
+        v &= mask;
+        v >>= __ffs(mask);
+
+        return v;
+}
+
 /**
  * _clkctrl_idlest - read a CM_*_CLKCTRL register; mask & shift IDLEST bitfield
  * @inst: CM instance register offset (*_INST macro)
@@ -338,6 +349,46 @@ static u32 am33xx_cm_xlate_clkctrl(u8 part, u16 inst, u16 offset)
         return cm_base.pa + inst + offset;
 }
 
+/**
+ * am33xx_clkdm_save_context - Save the clockdomain transition context
+ * @clkdm: The clockdomain pointer whose context needs to be saved
+ *
+ * Save the clockdomain transition context.
+ */
+static int am33xx_clkdm_save_context(struct clockdomain *clkdm)
+{
+        clkdm->context = am33xx_cm_read_reg_bits(clkdm->cm_inst,
+                                                 clkdm->clkdm_offs,
+                                                 AM33XX_CLKTRCTRL_MASK);
+
+        return 0;
+}
+
+/**
+ * am33xx_restore_save_context - Restore the clockdomain transition context
+ * @clkdm: The clockdomain pointer whose context needs to be restored
+ *
+ * Restore the clockdomain transition context.
+ */
+static int am33xx_clkdm_restore_context(struct clockdomain *clkdm)
+{
+        switch (clkdm->context) {
+        case OMAP34XX_CLKSTCTRL_DISABLE_AUTO:
+                am33xx_clkdm_deny_idle(clkdm);
+                break;
+        case OMAP34XX_CLKSTCTRL_FORCE_SLEEP:
+                am33xx_clkdm_sleep(clkdm);
+                break;
+        case OMAP34XX_CLKSTCTRL_FORCE_WAKEUP:
+                am33xx_clkdm_wakeup(clkdm);
+                break;
+        case OMAP34XX_CLKSTCTRL_ENABLE_AUTO:
+                am33xx_clkdm_allow_idle(clkdm);
+                break;
+        }
+        return 0;
+}
+
 struct clkdm_ops am33xx_clkdm_operations = {
         .clkdm_sleep            = am33xx_clkdm_sleep,
         .clkdm_wakeup           = am33xx_clkdm_wakeup,
@@ -345,6 +396,8 @@ struct clkdm_ops am33xx_clkdm_operations = {
         .clkdm_deny_idle        = am33xx_clkdm_deny_idle,
         .clkdm_clk_enable       = am33xx_clkdm_clk_enable,
         .clkdm_clk_disable      = am33xx_clkdm_clk_disable,
+        .clkdm_save_context     = am33xx_clkdm_save_context,
+        .clkdm_restore_context  = am33xx_clkdm_restore_context,
 };
 
 static const struct cm_ll_data am33xx_cm_ll_data = {
diff --git a/arch/arm/mach-omap2/cminst44xx.c b/arch/arm/mach-omap2/cminst44xx.c
index 7deefee49fc3..c11ac492b626 100644
--- a/arch/arm/mach-omap2/cminst44xx.c
+++ b/arch/arm/mach-omap2/cminst44xx.c
@@ -481,6 +481,47 @@ static u32 omap4_cminst_xlate_clkctrl(u8 part, u16 inst, u16 offset)
         return _cm_bases[part].pa + inst + offset;
 }
 
+/**
+ * omap4_clkdm_save_context - Save the clockdomain modulemode context
+ * @clkdm: The clockdomain pointer whose context needs to be saved
+ *
+ * Save the clockdomain modulemode context.
+ */
+static int omap4_clkdm_save_context(struct clockdomain *clkdm)
+{
+        clkdm->context = omap4_cminst_read_inst_reg(clkdm->prcm_partition,
+                                                    clkdm->cm_inst,
+                                                    clkdm->clkdm_offs +
+                                                    OMAP4_CM_CLKSTCTRL);
+        clkdm->context &= OMAP4430_MODULEMODE_MASK;
+        return 0;
+}
+
+/**
+ * omap4_clkdm_restore_context - Restore the clockdomain modulemode context
+ * @clkdm: The clockdomain pointer whose context needs to be restored
+ *
+ * Restore the clockdomain modulemode context.
+ */
+static int omap4_clkdm_restore_context(struct clockdomain *clkdm)
+{
+        switch (clkdm->context) {
+        case OMAP34XX_CLKSTCTRL_DISABLE_AUTO:
+                omap4_clkdm_deny_idle(clkdm);
+                break;
+        case OMAP34XX_CLKSTCTRL_FORCE_SLEEP:
+                omap4_clkdm_sleep(clkdm);
+                break;
+        case OMAP34XX_CLKSTCTRL_FORCE_WAKEUP:
+                omap4_clkdm_wakeup(clkdm);
+                break;
+        case OMAP34XX_CLKSTCTRL_ENABLE_AUTO:
+                omap4_clkdm_allow_idle(clkdm);
+                break;
+        }
+        return 0;
+}
+
 struct clkdm_ops omap4_clkdm_operations = {
         .clkdm_add_wkdep        = omap4_clkdm_add_wkup_sleep_dep,
         .clkdm_del_wkdep        = omap4_clkdm_del_wkup_sleep_dep,
@@ -496,6 +537,8 @@ struct clkdm_ops omap4_clkdm_operations = {
         .clkdm_deny_idle        = omap4_clkdm_deny_idle,
         .clkdm_clk_enable       = omap4_clkdm_clk_enable,
         .clkdm_clk_disable      = omap4_clkdm_clk_disable,
+        .clkdm_save_context     = omap4_clkdm_save_context,
+        .clkdm_restore_context  = omap4_clkdm_restore_context,
 };
 
 struct clkdm_ops am43xx_clkdm_operations = {
diff --git a/arch/arm/mach-omap2/pm44xx.c b/arch/arm/mach-omap2/pm44xx.c
index b3870220612e..78e1ace7d17d 100644
--- a/arch/arm/mach-omap2/pm44xx.c
+++ b/arch/arm/mach-omap2/pm44xx.c
@@ -131,6 +131,19 @@ static int __init pwrdms_setup(struct powerdomain *pwrdm, void *unused)
                 return 0;
         }
 
+        /*
+         * Bootloader or kexec boot may have LOGICRETSTATE cleared
+         * for some domains. This is the case when kexec booting from
+         * Android kernels that support off mode for example.
+         * Make sure it's set at least for core and per, otherwise
+         * we currently will see lost GPIO interrupts for wlcore and
+         * smsc911x at least if per hits retention during idle.
+         */
+        if (!strncmp(pwrdm->name, "core", 4) ||
+            !strncmp(pwrdm->name, "l4per", 5) ||
+            !strncmp(pwrdm->name, "wkup", 4))
+                pwrdm_set_logic_retst(pwrdm, PWRDM_POWER_RET);
+
         pwrst = kmalloc(sizeof(struct power_state), GFP_ATOMIC);
         if (!pwrst)
                 return -ENOMEM;
diff --git a/arch/arm/mach-omap2/powerdomain.c b/arch/arm/mach-omap2/powerdomain.c
index 76eb6ec5f157..27fdef624e97 100644
--- a/arch/arm/mach-omap2/powerdomain.c
+++ b/arch/arm/mach-omap2/powerdomain.c
@@ -14,6 +14,7 @@
  */
 #undef DEBUG
 
+#include <linux/cpu_pm.h>
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/list.h>
@@ -39,6 +40,9 @@
 
 #define PWRDM_TRACE_STATES_FLAG (1<<31)
 
+void pwrdms_save_context(void);
+void pwrdms_restore_context(void);
+
 enum {
         PWRDM_STATE_NOW = 0,
         PWRDM_STATE_PREV,
@@ -333,6 +337,22 @@ int pwrdm_register_pwrdms(struct powerdomain **ps)
         return 0;
 }
 
+static int cpu_notifier(struct notifier_block *nb, unsigned long cmd, void *v)
+{
+        switch (cmd) {
+        case CPU_CLUSTER_PM_ENTER:
+                if (enable_off_mode)
+                        pwrdms_save_context();
+                break;
+        case CPU_CLUSTER_PM_EXIT:
+                if (enable_off_mode)
+                        pwrdms_restore_context();
+                break;
+        }
+
+        return NOTIFY_OK;
+}
+
 /**
  * pwrdm_complete_init - set up the powerdomain layer
  *
@@ -347,6 +367,7 @@ int pwrdm_register_pwrdms(struct powerdomain **ps)
 int pwrdm_complete_init(void)
 {
         struct powerdomain *temp_p;
+        static struct notifier_block nb;
 
         if (list_empty(&pwrdm_list))
                 return -EACCES;
@@ -354,6 +375,12 @@ int pwrdm_complete_init(void)
         list_for_each_entry(temp_p, &pwrdm_list, node)
                 pwrdm_set_next_pwrst(temp_p, PWRDM_POWER_ON);
 
+        /* Only AM43XX can lose pwrdm context during rtc-ddr suspend */
+        if (soc_is_am43xx()) {
+                nb.notifier_call = cpu_notifier;
+                cpu_pm_register_notifier(&nb);
+        }
+
         return 0;
 }
 
@@ -1199,3 +1226,63 @@ bool pwrdm_can_ever_lose_context(struct powerdomain *pwrdm)
 
         return 0;
 }
+
+/**
+ * pwrdm_save_context - save powerdomain registers
+ *
+ * Register state is going to be lost due to a suspend or hibernate
+ * event. Save the powerdomain registers.
+ */
+static int pwrdm_save_context(struct powerdomain *pwrdm, void *unused)
+{
+        if (arch_pwrdm && arch_pwrdm->pwrdm_save_context)
+                arch_pwrdm->pwrdm_save_context(pwrdm);
+        return 0;
+}
+
+/**
+ * pwrdm_save_context - restore powerdomain registers
+ *
+ * Restore powerdomain control registers after a suspend or resume
+ * event.
+ */
+static int pwrdm_restore_context(struct powerdomain *pwrdm, void *unused)
+{
+        if (arch_pwrdm && arch_pwrdm->pwrdm_restore_context)
+                arch_pwrdm->pwrdm_restore_context(pwrdm);
+        return 0;
+}
+
+static int pwrdm_lost_power(struct powerdomain *pwrdm, void *unused)
+{
+        int state;
+
+        /*
+         * Power has been lost across all powerdomains, increment the
+         * counter.
+         */
+
+        state = pwrdm_read_pwrst(pwrdm);
+        if (state != PWRDM_POWER_OFF) {
+                pwrdm->state_counter[state]++;
+                pwrdm->state_counter[PWRDM_POWER_OFF]++;
+        }
+        pwrdm->state = state;
+
+        return 0;
+}
+
+void pwrdms_save_context(void)
+{
+        pwrdm_for_each(pwrdm_save_context, NULL);
+}
+
+void pwrdms_restore_context(void)
+{
+        pwrdm_for_each(pwrdm_restore_context, NULL);
+}
+
+void pwrdms_lost_power(void)
+{
+        pwrdm_for_each(pwrdm_lost_power, NULL);
+}
diff --git a/arch/arm/mach-omap2/powerdomain.h b/arch/arm/mach-omap2/powerdomain.h
index 28a796ce07d7..9a907fb14044 100644
--- a/arch/arm/mach-omap2/powerdomain.h
+++ b/arch/arm/mach-omap2/powerdomain.h
@@ -144,6 +144,7 @@ struct powerdomain {
         s64 timer;
         s64 state_timer[PWRDM_MAX_PWRSTS];
 #endif
+        u32 context;
 };
 
 /**
@@ -198,6 +199,8 @@ struct pwrdm_ops {
         int     (*pwrdm_set_lowpwrstchange)(struct powerdomain *pwrdm);
         int     (*pwrdm_wait_transition)(struct powerdomain *pwrdm);
         int     (*pwrdm_has_voltdm)(void);
+        void    (*pwrdm_save_context)(struct powerdomain *pwrdm);
+        void    (*pwrdm_restore_context)(struct powerdomain *pwrdm);
 };
 
 int pwrdm_register_platform_funcs(struct pwrdm_ops *custom_funcs);
@@ -273,4 +276,8 @@ extern struct powerdomain gfx_omap2_pwrdm;
 extern void pwrdm_lock(struct powerdomain *pwrdm);
 extern void pwrdm_unlock(struct powerdomain *pwrdm);
 
+extern void pwrdms_save_context(void);
+extern void pwrdms_restore_context(void);
+
+extern void pwrdms_lost_power(void);
 #endif
diff --git a/arch/arm/mach-omap2/prm33xx.c b/arch/arm/mach-omap2/prm33xx.c
index ebaf80d72a10..d5141669c28d 100644
--- a/arch/arm/mach-omap2/prm33xx.c
+++ b/arch/arm/mach-omap2/prm33xx.c
@@ -342,6 +342,35 @@ static void am33xx_prm_global_warm_sw_reset(void)
                                   AM33XX_PRM_RSTCTRL_OFFSET);
 }
 
+static void am33xx_pwrdm_save_context(struct powerdomain *pwrdm)
+{
+        pwrdm->context = am33xx_prm_read_reg(pwrdm->prcm_offs,
+                                                pwrdm->pwrstctrl_offs);
+        /*
+         * Do not save LOWPOWERSTATECHANGE, writing a 1 indicates a request,
+         * reading back a 1 indicates a request in progress.
+         */
+        pwrdm->context &= ~AM33XX_LOWPOWERSTATECHANGE_MASK;
+}
+
+static void am33xx_pwrdm_restore_context(struct powerdomain *pwrdm)
+{
+        int st, ctrl;
+
+        st = am33xx_prm_read_reg(pwrdm->prcm_offs,
+                                 pwrdm->pwrstst_offs);
+
+        am33xx_prm_write_reg(pwrdm->context, pwrdm->prcm_offs,
+                             pwrdm->pwrstctrl_offs);
+
+        /* Make sure we only wait for a transition if there is one */
+        st &= OMAP_POWERSTATEST_MASK;
+        ctrl = OMAP_POWERSTATEST_MASK & pwrdm->context;
+
+        if (st != ctrl)
+                am33xx_pwrdm_wait_transition(pwrdm);
+}
+
 struct pwrdm_ops am33xx_pwrdm_operations = {
         .pwrdm_set_next_pwrst           = am33xx_pwrdm_set_next_pwrst,
         .pwrdm_read_next_pwrst          = am33xx_pwrdm_read_next_pwrst,
@@ -357,6 +386,8 @@ struct pwrdm_ops am33xx_pwrdm_operations = {
         .pwrdm_set_mem_retst            = am33xx_pwrdm_set_mem_retst,
         .pwrdm_wait_transition          = am33xx_pwrdm_wait_transition,
         .pwrdm_has_voltdm               = am33xx_check_vcvp,
+        .pwrdm_save_context             = am33xx_pwrdm_save_context,
+        .pwrdm_restore_context          = am33xx_pwrdm_restore_context,
 };
 
 static struct prm_ll_data am33xx_prm_ll_data = {
diff --git a/arch/arm/mach-omap2/prm44xx.c b/arch/arm/mach-omap2/prm44xx.c
index acb95936dfe7..7b95729e8359 100644
--- a/arch/arm/mach-omap2/prm44xx.c
+++ b/arch/arm/mach-omap2/prm44xx.c
@@ -12,6 +12,7 @@
  * published by the Free Software Foundation.
  */
 
+#include <linux/cpu_pm.h>
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
@@ -30,6 +31,7 @@
 #include "prcm44xx.h"
 #include "prminst44xx.h"
 #include "powerdomain.h"
+#include "pm.h"
 
 /* Static data */
 
@@ -57,6 +59,13 @@ static struct omap_prcm_irq_setup omap4_prcm_irq_setup = {
         .reconfigure_io_chain   = &omap44xx_prm_reconfigure_io_chain,
 };
 
+struct omap_prm_irq_context {
+        unsigned long irq_enable;
+        unsigned long pm_ctrl;
+};
+
+static struct omap_prm_irq_context omap_prm_context;
+
 /*
  * omap44xx_prm_reset_src_map - map from bits in the PRM_RSTST
  *   hardware register (which are specific to OMAP44xx SoCs) to reset
@@ -667,6 +676,54 @@ static int omap4_check_vcvp(void)
         return 0;
 }
 
+/**
+ * omap4_pwrdm_save_context - Saves the powerdomain state
+ * @pwrdm: pointer to individual powerdomain
+ *
+ * The function saves the powerdomain state control information.
+ * This is needed in rtc+ddr modes where we lose powerdomain context.
+ */
+static void omap4_pwrdm_save_context(struct powerdomain *pwrdm)
+{
+        pwrdm->context = omap4_prminst_read_inst_reg(pwrdm->prcm_partition,
+                                                     pwrdm->prcm_offs,
+                                                     pwrdm->pwrstctrl_offs);
+
+        /*
+         * Do not save LOWPOWERSTATECHANGE, writing a 1 indicates a request,
+         * reading back a 1 indicates a request in progress.
+         */
+        pwrdm->context &= ~OMAP4430_LOWPOWERSTATECHANGE_MASK;
+}
+
+/**
+ * omap4_pwrdm_restore_context - Restores the powerdomain state
+ * @pwrdm: pointer to individual powerdomain
+ *
+ * The function restores the powerdomain state control information.
+ * This is needed in rtc+ddr modes where we lose powerdomain context.
+ */
+static void omap4_pwrdm_restore_context(struct powerdomain *pwrdm)
+{
+        int st, ctrl;
+
+        st = omap4_prminst_read_inst_reg(pwrdm->prcm_partition,
+                                         pwrdm->prcm_offs,
+                                         pwrdm->pwrstctrl_offs);
+
+        omap4_prminst_write_inst_reg(pwrdm->context,
+                                     pwrdm->prcm_partition,
+                                     pwrdm->prcm_offs,
+                                     pwrdm->pwrstctrl_offs);
+
+        /* Make sure we only wait for a transition if there is one */
+        st &= OMAP_POWERSTATEST_MASK;
+        ctrl = OMAP_POWERSTATEST_MASK & pwrdm->context;
+
+        if (st != ctrl)
+                omap4_pwrdm_wait_transition(pwrdm);
+}
+
 struct pwrdm_ops omap4_pwrdm_operations = {
         .pwrdm_set_next_pwrst   = omap4_pwrdm_set_next_pwrst,
         .pwrdm_read_next_pwrst  = omap4_pwrdm_read_next_pwrst,
@@ -685,10 +742,50 @@ struct pwrdm_ops omap4_pwrdm_operations = {
         .pwrdm_set_mem_retst    = omap4_pwrdm_set_mem_retst,
         .pwrdm_wait_transition  = omap4_pwrdm_wait_transition,
         .pwrdm_has_voltdm       = omap4_check_vcvp,
+        .pwrdm_save_context     = omap4_pwrdm_save_context,
+        .pwrdm_restore_context  = omap4_pwrdm_restore_context,
 };
 
 static int omap44xx_prm_late_init(void);
 
+void prm_save_context(void)
+{
+        omap_prm_context.irq_enable =
+                        omap4_prm_read_inst_reg(AM43XX_PRM_OCP_SOCKET_INST,
+                                                omap4_prcm_irq_setup.mask);
+
+        omap_prm_context.pm_ctrl =
+                        omap4_prm_read_inst_reg(AM43XX_PRM_DEVICE_INST,
+                                                omap4_prcm_irq_setup.pm_ctrl);
+}
+
+void prm_restore_context(void)
+{
+        omap4_prm_write_inst_reg(omap_prm_context.irq_enable,
+                                 OMAP4430_PRM_OCP_SOCKET_INST,
+                                 omap4_prcm_irq_setup.mask);
+
+        omap4_prm_write_inst_reg(omap_prm_context.pm_ctrl,
+                                 AM43XX_PRM_DEVICE_INST,
+                                 omap4_prcm_irq_setup.pm_ctrl);
+}
+
+static int cpu_notifier(struct notifier_block *nb, unsigned long cmd, void *v)
+{
+        switch (cmd) {
+        case CPU_CLUSTER_PM_ENTER:
+                if (enable_off_mode)
+                        prm_save_context();
+                break;
+        case CPU_CLUSTER_PM_EXIT:
+                if (enable_off_mode)
+                        prm_restore_context();
+                break;
+        }
+
+        return NOTIFY_OK;
+}
+
 /*
  * XXX document
  */
@@ -709,6 +806,7 @@ static const struct omap_prcm_init_data *prm_init_data;
 
 int __init omap44xx_prm_init(const struct omap_prcm_init_data *data)
 {
+        static struct notifier_block nb;
         omap_prm_base_init();
 
         prm_init_data = data;
@@ -730,6 +828,12 @@ int __init omap44xx_prm_init(const struct omap_prcm_init_data *data)
                 omap4_prcm_irq_setup.mask = AM43XX_PRM_IRQENABLE_MPU_OFFSET;
         }
 
+        /* Only AM43XX can lose prm context during rtc-ddr suspend */
+        if (soc_is_am43xx()) {
+                nb.notifier_call = cpu_notifier;
+                cpu_pm_register_notifier(&nb);
+        }
+
         return prm_register(&omap44xx_prm_ll_data);
 }