Merge tag 'omap-for-v4.18/soc-signed' of git://git.kernel.org/pub/scm/linux/kernel...
authorOlof Johansson <olof@lixom.net>
Fri, 25 May 2018 21:13:22 +0000 (14:13 -0700)
committerOlof Johansson <olof@lixom.net>
Fri, 25 May 2018 21:13:22 +0000 (14:13 -0700)
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>
arch/arm/mach-omap1/board-osk.c
arch/arm/mach-omap2/clockdomain.c
arch/arm/mach-omap2/clockdomain.h
arch/arm/mach-omap2/cm33xx.c
arch/arm/mach-omap2/cminst44xx.c
arch/arm/mach-omap2/pm44xx.c
arch/arm/mach-omap2/powerdomain.c
arch/arm/mach-omap2/powerdomain.h
arch/arm/mach-omap2/prm33xx.c
arch/arm/mach-omap2/prm44xx.c

index c66372ed29e2229d543e17d9961da2f796bd42bb..9ffa8d755a599344825b53c6363ac22038d21197 100644 (file)
@@ -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
index b79b1ca9aee9edbd96099495e0c6165089c0c01e..6d44fe05a3feb00f3ce11877f52b25ed43863926 100644 (file)
@@ -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);
+}
index 24667a5a9dc0f487759b3635eff014517e8533c8..c7d0953e4aa2db25e43337b31d5e927e272ccde0 100644 (file)
@@ -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);
index 1cc0247a2cb5e81615f9f7b4286d6a804c587c48..084d454f607482622207e73979f6f28629a10b6e 100644 (file)
@@ -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 = {
index 7deefee49fc3c7276cba9e4bc3aca5679f896611..c11ac492b626a5f7ceeb8e3638f772460d2044ad 100644 (file)
@@ -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 = {
index b3870220612e60df778593529d518253085baf2d..78e1ace7d17d64bbfe619cc35e6c4d771fda82b9 100644 (file)
@@ -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;
index 76eb6ec5f157e9753cf7bc9773801a35d55ffd27..27fdef624e97058e475f5f544d2ed0c2eb50e19b 100644 (file)
@@ -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);
+}
index 28a796ce07d7302aed19ce7e5ae25fcbbdb584df..9a907fb14044ea8f05a2ca412fc890b4f0707706 100644 (file)
@@ -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
index ebaf80d72a109fdaabb1fbeb21da6d401119ce8d..d5141669c28dd6cfff6e93713dee669038a80ac3 100644 (file)
@@ -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 = {
index acb95936dfe74c350e9cea47e2b57dcfbb7e28f9..7b95729e83594d330e4f0d5e3205a05b4d0751e1 100644 (file)
@@ -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);
 }