mfd: Refactor DB8500 PRCMU reg access

Instead of carrying around the __PRCMU_BASE in every read or
write to the PRCMU registers, move it out to the register
definition file and define registers along with their base
offset so that the code gets easier to read.

Signed-off-by: Mattias Nilsson <mattias.i.nilsson@stericsson.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

1 files changed, 77 insertions, 82 deletions

diff --git a/drivers/mfd/db8500-prcmu.c b/drivers/mfd/db8500-prcmu.c
index 02a15d7cb3b0..b5bd245ca892 100644
--- a/drivers/mfd/db8500-prcmu.c
+++ b/drivers/mfd/db8500-prcmu.c
@@ -412,7 +412,7 @@ struct clk_mgt {
 
 static DEFINE_SPINLOCK(clk_mgt_lock);
 
-#define CLK_MGT_ENTRY(_name)[PRCMU_##_name] = { (PRCM_##_name##_MGT), 0 }
+#define CLK_MGT_ENTRY(_name)[PRCMU_##_name] = { (PRCM_##_name##_MGT_OFF), 0 }
 struct clk_mgt clk_mgt[PRCMU_NUM_REG_CLOCKS] = {
         CLK_MGT_ENTRY(SGACLK),
         CLK_MGT_ENTRY(UARTCLK),
@@ -499,45 +499,41 @@ int prcmu_enable_dsipll(void)
         unsigned int plldsifreq;
 
         /* Clear DSIPLL_RESETN */
-        writel(PRCMU_RESET_DSIPLL, (_PRCMU_BASE + PRCM_APE_RESETN_CLR));
+        writel(PRCMU_RESET_DSIPLL, PRCM_APE_RESETN_CLR);
         /* Unclamp DSIPLL in/out */
-        writel(PRCMU_UNCLAMP_DSIPLL, (_PRCMU_BASE + PRCM_MMIP_LS_CLAMP_CLR));
+        writel(PRCMU_UNCLAMP_DSIPLL, PRCM_MMIP_LS_CLAMP_CLR);
 
         if (prcmu_is_u8400())
                 plldsifreq = PRCMU_PLLDSI_FREQ_SETTING_U8400;
         else
                 plldsifreq = PRCMU_PLLDSI_FREQ_SETTING;
         /* Set DSI PLL FREQ */
-        writel(plldsifreq, (_PRCMU_BASE + PRCM_PLLDSI_FREQ));
-        writel(PRCMU_DSI_PLLOUT_SEL_SETTING,
-                (_PRCMU_BASE + PRCM_DSI_PLLOUT_SEL));
+        writel(plldsifreq, PRCM_PLLDSI_FREQ);
+        writel(PRCMU_DSI_PLLOUT_SEL_SETTING, PRCM_DSI_PLLOUT_SEL);
         /* Enable Escape clocks */
-        writel(PRCMU_ENABLE_ESCAPE_CLOCK_DIV,
-                                        (_PRCMU_BASE + PRCM_DSITVCLK_DIV));
+        writel(PRCMU_ENABLE_ESCAPE_CLOCK_DIV, PRCM_DSITVCLK_DIV);
 
         /* Start DSI PLL */
-        writel(PRCMU_ENABLE_PLLDSI, (_PRCMU_BASE + PRCM_PLLDSI_ENABLE));
+        writel(PRCMU_ENABLE_PLLDSI, PRCM_PLLDSI_ENABLE);
         /* Reset DSI PLL */
-        writel(PRCMU_DSI_RESET_SW, (_PRCMU_BASE + PRCM_DSI_SW_RESET));
+        writel(PRCMU_DSI_RESET_SW, PRCM_DSI_SW_RESET);
         for (i = 0; i < 10; i++) {
-                if ((readl(_PRCMU_BASE + PRCM_PLLDSI_LOCKP) &
-                        PRCMU_PLLDSI_LOCKP_LOCKED)
+                if ((readl(PRCM_PLLDSI_LOCKP) & PRCMU_PLLDSI_LOCKP_LOCKED)
                                         == PRCMU_PLLDSI_LOCKP_LOCKED)
                         break;
                 udelay(100);
         }
         /* Set DSIPLL_RESETN */
-        writel(PRCMU_RESET_DSIPLL, (_PRCMU_BASE + PRCM_APE_RESETN_SET));
+        writel(PRCMU_RESET_DSIPLL, PRCM_APE_RESETN_SET);
         return 0;
 }
 
 int prcmu_disable_dsipll(void)
 {
         /* Disable dsi pll */
-        writel(PRCMU_DISABLE_PLLDSI, (_PRCMU_BASE + PRCM_PLLDSI_ENABLE));
+        writel(PRCMU_DISABLE_PLLDSI, PRCM_PLLDSI_ENABLE);
         /* Disable  escapeclock */
-        writel(PRCMU_DISABLE_ESCAPE_CLOCK_DIV,
-                                        (_PRCMU_BASE + PRCM_DSITVCLK_DIV));
+        writel(PRCMU_DISABLE_ESCAPE_CLOCK_DIV, PRCM_DSITVCLK_DIV);
         return 0;
 }
 
@@ -554,15 +550,15 @@ int prcmu_set_display_clocks(void)
         spin_lock_irqsave(&clk_mgt_lock, flags);
 
         /* Grab the HW semaphore. */
-        while ((readl(_PRCMU_BASE + PRCM_SEM) & PRCM_SEM_PRCM_SEM) != 0)
+        while ((readl(PRCM_SEM) & PRCM_SEM_PRCM_SEM) != 0)
                 cpu_relax();
 
-        writel(dsiclk, (_PRCMU_BASE + PRCM_HDMICLK_MGT));
-        writel(PRCMU_DSI_LP_CLOCK_SETTING, (_PRCMU_BASE + PRCM_TVCLK_MGT));
-        writel(PRCMU_DPI_CLOCK_SETTING, (_PRCMU_BASE + PRCM_LCDCLK_MGT));
+        writel(dsiclk, PRCM_HDMICLK_MGT);
+        writel(PRCMU_DSI_LP_CLOCK_SETTING, PRCM_TVCLK_MGT);
+        writel(PRCMU_DPI_CLOCK_SETTING, PRCM_LCDCLK_MGT);
 
         /* Release the HW semaphore. */
-        writel(0, (_PRCMU_BASE + PRCM_SEM));
+        writel(0, PRCM_SEM);
 
         spin_unlock_irqrestore(&clk_mgt_lock, flags);
 
@@ -578,8 +574,8 @@ void prcmu_enable_spi2(void)
         unsigned long flags;
 
         spin_lock_irqsave(&gpiocr_lock, flags);
-        reg = readl(_PRCMU_BASE + PRCM_GPIOCR);
-        writel(reg | PRCM_GPIOCR_SPI2_SELECT, _PRCMU_BASE + PRCM_GPIOCR);
+        reg = readl(PRCM_GPIOCR);
+        writel(reg | PRCM_GPIOCR_SPI2_SELECT, PRCM_GPIOCR);
         spin_unlock_irqrestore(&gpiocr_lock, flags);
 }
 
@@ -592,8 +588,8 @@ void prcmu_disable_spi2(void)
         unsigned long flags;
 
         spin_lock_irqsave(&gpiocr_lock, flags);
-        reg = readl(_PRCMU_BASE + PRCM_GPIOCR);
-        writel(reg & ~PRCM_GPIOCR_SPI2_SELECT, _PRCMU_BASE + PRCM_GPIOCR);
+        reg = readl(PRCM_GPIOCR);
+        writel(reg & ~PRCM_GPIOCR_SPI2_SELECT, PRCM_GPIOCR);
         spin_unlock_irqrestore(&gpiocr_lock, flags);
 }
 
@@ -701,7 +697,7 @@ int prcmu_config_clkout(u8 clkout, u8 source, u8 div)
 
         spin_lock_irqsave(&clkout_lock, flags);
 
-        val = readl(_PRCMU_BASE + PRCM_CLKOCR);
+        val = readl(PRCM_CLKOCR);
         if (val & div_mask) {
                 if (div) {
                         if ((val & mask) != bits) {
@@ -715,7 +711,7 @@ int prcmu_config_clkout(u8 clkout, u8 source, u8 div)
                         }
                 }
         }
-        writel((bits | (val & ~mask)), (_PRCMU_BASE + PRCM_CLKOCR));
+        writel((bits | (val & ~mask)), PRCM_CLKOCR);
         requests[clkout] += (div ? 1 : -1);
 
 unlock_and_return:
@@ -732,7 +728,7 @@ int prcmu_set_power_state(u8 state, bool keep_ulp_clk, bool keep_ap_pll)
 
         spin_lock_irqsave(&mb0_transfer.lock, flags);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(0))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(0))
                 cpu_relax();
 
         writeb(MB0H_POWER_STATE_TRANS, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB0));
@@ -741,7 +737,7 @@ int prcmu_set_power_state(u8 state, bool keep_ulp_clk, bool keep_ap_pll)
         writeb((keep_ulp_clk ? 1 : 0),
                 (tcdm_base + PRCM_REQ_MB0_ULP_CLOCK_STATE));
         writeb(0, (tcdm_base + PRCM_REQ_MB0_DO_NOT_WFI));
-        writel(MBOX_BIT(0), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(0), PRCM_MBOX_CPU_SET);
 
         spin_unlock_irqrestore(&mb0_transfer.lock, flags);
 
@@ -770,12 +766,12 @@ static void config_wakeups(void)
                 return;
 
         for (i = 0; i < 2; i++) {
-                while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(0))
+                while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(0))
                         cpu_relax();
                 writel(dbb_events, (tcdm_base + PRCM_REQ_MB0_WAKEUP_8500));
                 writel(abb_events, (tcdm_base + PRCM_REQ_MB0_WAKEUP_4500));
                 writeb(header[i], (tcdm_base + PRCM_MBOX_HEADER_REQ_MB0));
-                writel(MBOX_BIT(0), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+                writel(MBOX_BIT(0), PRCM_MBOX_CPU_SET);
         }
         last_dbb_events = dbb_events;
         last_abb_events = abb_events;
@@ -840,14 +836,14 @@ int prcmu_set_arm_opp(u8 opp)
 
         mutex_lock(&mb1_transfer.lock);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(1))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(1))
                 cpu_relax();
 
         writeb(MB1H_ARM_APE_OPP, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB1));
         writeb(opp, (tcdm_base + PRCM_REQ_MB1_ARM_OPP));
         writeb(APE_NO_CHANGE, (tcdm_base + PRCM_REQ_MB1_APE_OPP));
 
-        writel(MBOX_BIT(1), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(1), PRCM_MBOX_CPU_SET);
         wait_for_completion(&mb1_transfer.work);
 
         if ((mb1_transfer.ack.header != MB1H_ARM_APE_OPP) ||
@@ -876,7 +872,7 @@ int prcmu_get_arm_opp(void)
  */
 int prcmu_get_ddr_opp(void)
 {
-        return readb(_PRCMU_BASE + PRCM_DDR_SUBSYS_APE_MINBW);
+        return readb(PRCM_DDR_SUBSYS_APE_MINBW);
 }
 
 /**
@@ -892,7 +888,7 @@ int prcmu_set_ddr_opp(u8 opp)
                 return -EINVAL;
         /* Changing the DDR OPP can hang the hardware pre-v21 */
         if (cpu_is_u8500v20_or_later() && !cpu_is_u8500v20())
-                writeb(opp, (_PRCMU_BASE + PRCM_DDR_SUBSYS_APE_MINBW));
+                writeb(opp, PRCM_DDR_SUBSYS_APE_MINBW);
 
         return 0;
 }
@@ -909,14 +905,14 @@ int prcmu_set_ape_opp(u8 opp)
 
         mutex_lock(&mb1_transfer.lock);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(1))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(1))
                 cpu_relax();
 
         writeb(MB1H_ARM_APE_OPP, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB1));
         writeb(ARM_NO_CHANGE, (tcdm_base + PRCM_REQ_MB1_ARM_OPP));
         writeb(opp, (tcdm_base + PRCM_REQ_MB1_APE_OPP));
 
-        writel(MBOX_BIT(1), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(1), PRCM_MBOX_CPU_SET);
         wait_for_completion(&mb1_transfer.work);
 
         if ((mb1_transfer.ack.header != MB1H_ARM_APE_OPP) ||
@@ -966,12 +962,12 @@ int prcmu_request_ape_opp_100_voltage(bool enable)
                 header = MB1H_RELEASE_APE_OPP_100_VOLT;
         }
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(1))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(1))
                 cpu_relax();
 
         writeb(header, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB1));
 
-        writel(MBOX_BIT(1), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(1), PRCM_MBOX_CPU_SET);
         wait_for_completion(&mb1_transfer.work);
 
         if ((mb1_transfer.ack.header != header) ||
@@ -995,13 +991,13 @@ int prcmu_release_usb_wakeup_state(void)
 
         mutex_lock(&mb1_transfer.lock);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(1))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(1))
                 cpu_relax();
 
         writeb(MB1H_RELEASE_USB_WAKEUP,
                 (tcdm_base + PRCM_MBOX_HEADER_REQ_MB1));
 
-        writel(MBOX_BIT(1), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(1), PRCM_MBOX_CPU_SET);
         wait_for_completion(&mb1_transfer.work);
 
         if ((mb1_transfer.ack.header != MB1H_RELEASE_USB_WAKEUP) ||
@@ -1048,7 +1044,7 @@ int prcmu_set_epod(u16 epod_id, u8 epod_state)
         mutex_lock(&mb2_transfer.lock);
 
         /* wait for mailbox */
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(2))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(2))
                 cpu_relax();
 
         /* fill in mailbox */
@@ -1058,7 +1054,7 @@ int prcmu_set_epod(u16 epod_id, u8 epod_state)
 
         writeb(MB2H_DPS, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB2));
 
-        writel(MBOX_BIT(2), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(2), PRCM_MBOX_CPU_SET);
 
         /*
          * The current firmware version does not handle errors correctly,
@@ -1145,13 +1141,13 @@ static int request_sysclk(bool enable)
 
         spin_lock_irqsave(&mb3_transfer.lock, flags);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(3))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(3))
                 cpu_relax();
 
         writeb((enable ? ON : OFF), (tcdm_base + PRCM_REQ_MB3_SYSCLK_MGT));
 
         writeb(MB3H_SYSCLK, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB3));
-        writel(MBOX_BIT(3), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(3), PRCM_MBOX_CPU_SET);
 
         spin_unlock_irqrestore(&mb3_transfer.lock, flags);
 
@@ -1177,7 +1173,7 @@ static int request_timclk(bool enable)
 
         if (!enable)
                 val |= PRCM_TCR_STOP_TIMERS;
-        writel(val, (_PRCMU_BASE + PRCM_TCR));
+        writel(val, PRCM_TCR);
 
         return 0;
 }
@@ -1190,7 +1186,7 @@ static int request_reg_clock(u8 clock, bool enable)
         spin_lock_irqsave(&clk_mgt_lock, flags);
 
         /* Grab the HW semaphore. */
-        while ((readl(_PRCMU_BASE + PRCM_SEM) & PRCM_SEM_PRCM_SEM) != 0)
+        while ((readl(PRCM_SEM) & PRCM_SEM_PRCM_SEM) != 0)
                 cpu_relax();
 
         val = readl(_PRCMU_BASE + clk_mgt[clock].offset);
@@ -1203,7 +1199,7 @@ static int request_reg_clock(u8 clock, bool enable)
         writel(val, (_PRCMU_BASE + clk_mgt[clock].offset));
 
         /* Release the HW semaphore. */
-        writel(0, (_PRCMU_BASE + PRCM_SEM));
+        writel(0, PRCM_SEM);
 
         spin_unlock_irqrestore(&clk_mgt_lock, flags);
 
@@ -1238,7 +1234,7 @@ int prcmu_config_esram0_deep_sleep(u8 state)
 
         mutex_lock(&mb4_transfer.lock);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(4))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(4))
                 cpu_relax();
 
         writeb(MB4H_MEM_ST, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB4));
@@ -1248,7 +1244,7 @@ int prcmu_config_esram0_deep_sleep(u8 state)
                (tcdm_base + PRCM_REQ_MB4_DDR_ST_AP_DEEP_IDLE));
         writeb(state, (tcdm_base + PRCM_REQ_MB4_ESRAM0_ST));
 
-        writel(MBOX_BIT(4), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(4), PRCM_MBOX_CPU_SET);
         wait_for_completion(&mb4_transfer.work);
 
         mutex_unlock(&mb4_transfer.lock);
@@ -1260,13 +1256,13 @@ int prcmu_config_hotdog(u8 threshold)
 {
         mutex_lock(&mb4_transfer.lock);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(4))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(4))
                 cpu_relax();
 
         writeb(threshold, (tcdm_base + PRCM_REQ_MB4_HOTDOG_THRESHOLD));
         writeb(MB4H_HOTDOG, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB4));
 
-        writel(MBOX_BIT(4), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(4), PRCM_MBOX_CPU_SET);
         wait_for_completion(&mb4_transfer.work);
 
         mutex_unlock(&mb4_transfer.lock);
@@ -1278,7 +1274,7 @@ int prcmu_config_hotmon(u8 low, u8 high)
 {
         mutex_lock(&mb4_transfer.lock);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(4))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(4))
                 cpu_relax();
 
         writeb(low, (tcdm_base + PRCM_REQ_MB4_HOTMON_LOW));
@@ -1287,7 +1283,7 @@ int prcmu_config_hotmon(u8 low, u8 high)
                 (tcdm_base + PRCM_REQ_MB4_HOTMON_CONFIG));
         writeb(MB4H_HOTMON, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB4));
 
-        writel(MBOX_BIT(4), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(4), PRCM_MBOX_CPU_SET);
         wait_for_completion(&mb4_transfer.work);
 
         mutex_unlock(&mb4_transfer.lock);
@@ -1299,13 +1295,13 @@ static int config_hot_period(u16 val)
 {
         mutex_lock(&mb4_transfer.lock);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(4))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(4))
                 cpu_relax();
 
         writew(val, (tcdm_base + PRCM_REQ_MB4_HOT_PERIOD));
         writeb(MB4H_HOT_PERIOD, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB4));
 
-        writel(MBOX_BIT(4), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(4), PRCM_MBOX_CPU_SET);
         wait_for_completion(&mb4_transfer.work);
 
         mutex_unlock(&mb4_transfer.lock);
@@ -1345,7 +1341,7 @@ int prcmu_set_clock_divider(u8 clock, u8 divider)
         spin_lock_irqsave(&clk_mgt_lock, flags);
 
         /* Grab the HW semaphore. */
-        while ((readl(_PRCMU_BASE + PRCM_SEM) & PRCM_SEM_PRCM_SEM) != 0)
+        while ((readl(PRCM_SEM) & PRCM_SEM_PRCM_SEM) != 0)
                 cpu_relax();
 
         val = readl(_PRCMU_BASE + clk_mgt[clock].offset);
@@ -1354,7 +1350,7 @@ int prcmu_set_clock_divider(u8 clock, u8 divider)
         writel(val, (_PRCMU_BASE + clk_mgt[clock].offset));
 
         /* Release the HW semaphore. */
-        writel(0, (_PRCMU_BASE + PRCM_SEM));
+        writel(0, PRCM_SEM);
 
         spin_unlock_irqrestore(&clk_mgt_lock, flags);
 
@@ -1380,7 +1376,7 @@ int prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size)
 
         mutex_lock(&mb5_transfer.lock);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(5))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(5))
                 cpu_relax();
 
         writeb(PRCMU_I2C_READ(slave), (tcdm_base + PRCM_REQ_MB5_I2C_SLAVE_OP));
@@ -1388,7 +1384,7 @@ int prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size)
         writeb(reg, (tcdm_base + PRCM_REQ_MB5_I2C_REG));
         writeb(0, (tcdm_base + PRCM_REQ_MB5_I2C_VAL));
 
-        writel(MBOX_BIT(5), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(5), PRCM_MBOX_CPU_SET);
 
         if (!wait_for_completion_timeout(&mb5_transfer.work,
                                 msecs_to_jiffies(20000))) {
@@ -1426,7 +1422,7 @@ int prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size)
 
         mutex_lock(&mb5_transfer.lock);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(5))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(5))
                 cpu_relax();
 
         writeb(PRCMU_I2C_WRITE(slave), (tcdm_base + PRCM_REQ_MB5_I2C_SLAVE_OP));
@@ -1434,7 +1430,7 @@ int prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size)
         writeb(reg, (tcdm_base + PRCM_REQ_MB5_I2C_REG));
         writeb(*value, (tcdm_base + PRCM_REQ_MB5_I2C_VAL));
 
-        writel(MBOX_BIT(5), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(5), PRCM_MBOX_CPU_SET);
 
         if (!wait_for_completion_timeout(&mb5_transfer.work,
                                 msecs_to_jiffies(20000))) {
@@ -1459,14 +1455,13 @@ void prcmu_ac_wake_req(void)
 
         mutex_lock(&mb0_transfer.ac_wake_lock);
 
-        val = readl(_PRCMU_BASE + PRCM_HOSTACCESS_REQ);
+        val = readl(PRCM_HOSTACCESS_REQ);
         if (val & PRCM_HOSTACCESS_REQ_HOSTACCESS_REQ)
                 goto unlock_and_return;
 
         atomic_set(&ac_wake_req_state, 1);
 
-        writel((val | PRCM_HOSTACCESS_REQ_HOSTACCESS_REQ),
-                (_PRCMU_BASE + PRCM_HOSTACCESS_REQ));
+        writel((val | PRCM_HOSTACCESS_REQ_HOSTACCESS_REQ), PRCM_HOSTACCESS_REQ);
 
         if (!wait_for_completion_timeout(&mb0_transfer.ac_wake_work,
                         msecs_to_jiffies(20000))) {
@@ -1487,12 +1482,12 @@ void prcmu_ac_sleep_req()
 
         mutex_lock(&mb0_transfer.ac_wake_lock);
 
-        val = readl(_PRCMU_BASE + PRCM_HOSTACCESS_REQ);
+        val = readl(PRCM_HOSTACCESS_REQ);
         if (!(val & PRCM_HOSTACCESS_REQ_HOSTACCESS_REQ))
                 goto unlock_and_return;
 
         writel((val & ~PRCM_HOSTACCESS_REQ_HOSTACCESS_REQ),
-                (_PRCMU_BASE + PRCM_HOSTACCESS_REQ));
+                PRCM_HOSTACCESS_REQ);
 
         if (!wait_for_completion_timeout(&mb0_transfer.ac_wake_work,
                         msecs_to_jiffies(20000))) {
@@ -1520,7 +1515,7 @@ bool prcmu_is_ac_wake_requested(void)
 void prcmu_system_reset(u16 reset_code)
 {
         writew(reset_code, (tcdm_base + PRCM_SW_RST_REASON));
-        writel(1, (_PRCMU_BASE + PRCM_APE_SOFTRST));
+        writel(1, PRCM_APE_SOFTRST);
 }
 
 /**
@@ -1530,11 +1525,11 @@ void prcmu_modem_reset(void)
 {
         mutex_lock(&mb1_transfer.lock);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(1))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(1))
                 cpu_relax();
 
         writeb(MB1H_RESET_MODEM, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB1));
-        writel(MBOX_BIT(1), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(1), PRCM_MBOX_CPU_SET);
         wait_for_completion(&mb1_transfer.work);
 
         /*
@@ -1551,11 +1546,11 @@ static void ack_dbb_wakeup(void)
 
         spin_lock_irqsave(&mb0_transfer.lock, flags);
 
-        while (readl(_PRCMU_BASE + PRCM_MBOX_CPU_VAL) & MBOX_BIT(0))
+        while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(0))
                 cpu_relax();
 
         writeb(MB0H_READ_WAKEUP_ACK, (tcdm_base + PRCM_MBOX_HEADER_REQ_MB0));
-        writel(MBOX_BIT(0), (_PRCMU_BASE + PRCM_MBOX_CPU_SET));
+        writel(MBOX_BIT(0), PRCM_MBOX_CPU_SET);
 
         spin_unlock_irqrestore(&mb0_transfer.lock, flags);
 }
@@ -1600,7 +1595,7 @@ static bool read_mailbox_0(void)
                 r = false;
                 break;
         }
-        writel(MBOX_BIT(0), (_PRCMU_BASE + PRCM_ARM_IT1_CLR));
+        writel(MBOX_BIT(0), PRCM_ARM_IT1_CLR);
         return r;
 }
 
@@ -1613,7 +1608,7 @@ static bool read_mailbox_1(void)
                 PRCM_ACK_MB1_CURRENT_APE_OPP);
         mb1_transfer.ack.ape_voltage_status = readb(tcdm_base +
                 PRCM_ACK_MB1_APE_VOLTAGE_STATUS);
-        writel(MBOX_BIT(1), (_PRCMU_BASE + PRCM_ARM_IT1_CLR));
+        writel(MBOX_BIT(1), PRCM_ARM_IT1_CLR);
         complete(&mb1_transfer.work);
         return false;
 }
@@ -1621,14 +1616,14 @@ static bool read_mailbox_1(void)
 static bool read_mailbox_2(void)
 {
         mb2_transfer.ack.status = readb(tcdm_base + PRCM_ACK_MB2_DPS_STATUS);
-        writel(MBOX_BIT(2), (_PRCMU_BASE + PRCM_ARM_IT1_CLR));
+        writel(MBOX_BIT(2), PRCM_ARM_IT1_CLR);
         complete(&mb2_transfer.work);
         return false;
 }
 
 static bool read_mailbox_3(void)
 {
-        writel(MBOX_BIT(3), (_PRCMU_BASE + PRCM_ARM_IT1_CLR));
+        writel(MBOX_BIT(3), PRCM_ARM_IT1_CLR);
         return false;
 }
 
@@ -1650,7 +1645,7 @@ static bool read_mailbox_4(void)
                 break;
         }
 
-        writel(MBOX_BIT(4), (_PRCMU_BASE + PRCM_ARM_IT1_CLR));
+        writel(MBOX_BIT(4), PRCM_ARM_IT1_CLR);
 
         if (do_complete)
                 complete(&mb4_transfer.work);
@@ -1662,20 +1657,20 @@ static bool read_mailbox_5(void)
 {
         mb5_transfer.ack.status = readb(tcdm_base + PRCM_ACK_MB5_I2C_STATUS);
         mb5_transfer.ack.value = readb(tcdm_base + PRCM_ACK_MB5_I2C_VAL);
-        writel(MBOX_BIT(5), (_PRCMU_BASE + PRCM_ARM_IT1_CLR));
+        writel(MBOX_BIT(5), PRCM_ARM_IT1_CLR);
         complete(&mb5_transfer.work);
         return false;
 }
 
 static bool read_mailbox_6(void)
 {
-        writel(MBOX_BIT(6), (_PRCMU_BASE + PRCM_ARM_IT1_CLR));
+        writel(MBOX_BIT(6), PRCM_ARM_IT1_CLR);
         return false;
 }
 
 static bool read_mailbox_7(void)
 {
-        writel(MBOX_BIT(7), (_PRCMU_BASE + PRCM_ARM_IT1_CLR));
+        writel(MBOX_BIT(7), PRCM_ARM_IT1_CLR);
         return false;
 }
 
@@ -1696,7 +1691,7 @@ static irqreturn_t prcmu_irq_handler(int irq, void *data)
         u8 n;
         irqreturn_t r;
 
-        bits = (readl(_PRCMU_BASE + PRCM_ARM_IT1_VAL) & ALL_MBOX_BITS);
+        bits = (readl(PRCM_ARM_IT1_VAL) & ALL_MBOX_BITS);
         if (unlikely(!bits))
                 return IRQ_NONE;
 
@@ -2025,7 +2020,7 @@ static int __init db8500_prcmu_probe(struct platform_device *pdev)
                 return -ENODEV;
 
         /* Clean up the mailbox interrupts after pre-kernel code. */
-        writel(ALL_MBOX_BITS, (_PRCMU_BASE + PRCM_ARM_IT1_CLR));
+        writel(ALL_MBOX_BITS, PRCM_ARM_IT1_CLR);
 
         err = request_threaded_irq(IRQ_DB8500_PRCMU1, prcmu_irq_handler,
                 prcmu_irq_thread_fn, IRQF_NO_SUSPEND, "prcmu", NULL);