From 2f37bd65518865688b9234afce0d467508d6f465 Mon Sep 17 00:00:00 2001 From: Julius Werner Date: Thu, 19 Feb 2015 14:51:15 -0800 Subject: arm(64): Globally replace writel(v, a) with write32(a, v) This patch is a raw application of the following spatch to src/: @@ expression A, V; @@ - writel(V, A) + write32(A, V) @@ expression A, V; @@ - writew(V, A) + write16(A, V) @@ expression A, V; @@ - writeb(V, A) + write8(A, V) @@ expression A; @@ - readl(A) + read32(A) @@ expression A; @@ - readb(A) + read8(A) BRANCH=none BUG=chromium:444723 TEST=None (depends on next patch) Change-Id: I5dd96490c85ee2bcbc669f08bc6fff0ecc0f9e27 Signed-off-by: Patrick Georgi Original-Commit-Id: 64f643da95d85954c4d4ea91c34a5c69b9b08eb6 Original-Change-Id: I366a2eb5b3a0df2279ebcce572fe814894791c42 Original-Signed-off-by: Julius Werner Original-Reviewed-on: https://chromium-review.googlesource.com/254864 Reviewed-on: http://review.coreboot.org/9836 Tested-by: build bot (Jenkins) Reviewed-by: Stefan Reinauer --- src/soc/samsung/exynos5250/clock.c | 66 ++++----- src/soc/samsung/exynos5250/clock_init.c | 212 ++++++++++++++--------------- src/soc/samsung/exynos5250/cpu.c | 2 +- src/soc/samsung/exynos5250/dmc_common.c | 50 +++---- src/soc/samsung/exynos5250/dmc_init_ddr3.c | 129 +++++++++--------- src/soc/samsung/exynos5250/dp-reg.c | 192 +++++++++++++------------- src/soc/samsung/exynos5250/fb.c | 52 +++---- src/soc/samsung/exynos5250/gpio.c | 28 ++-- src/soc/samsung/exynos5250/i2c.c | 34 ++--- src/soc/samsung/exynos5250/power.c | 2 +- src/soc/samsung/exynos5250/spi.c | 18 +-- src/soc/samsung/exynos5250/timer.c | 7 +- src/soc/samsung/exynos5250/tmu.c | 20 +-- src/soc/samsung/exynos5250/trustzone.c | 10 +- src/soc/samsung/exynos5250/uart.c | 22 +-- src/soc/samsung/exynos5250/usb.c | 69 +++------- 16 files changed, 441 insertions(+), 472 deletions(-) (limited to 'src/soc/samsung/exynos5250') diff --git a/src/soc/samsung/exynos5250/clock.c b/src/soc/samsung/exynos5250/clock.c index 0986f8b9bd..89001ecf14 100644 --- a/src/soc/samsung/exynos5250/clock.c +++ b/src/soc/samsung/exynos5250/clock.c @@ -178,21 +178,21 @@ unsigned long get_pll_clk(int pllreg) switch (pllreg) { case APLL: - r = readl(&exynos_clock->apll_con0); + r = read32(&exynos_clock->apll_con0); break; case BPLL: - r = readl(&exynos_clock->bpll_con0); + r = read32(&exynos_clock->bpll_con0); break; case MPLL: - r = readl(&exynos_clock->mpll_con0); + r = read32(&exynos_clock->mpll_con0); break; case EPLL: - r = readl(&exynos_clock->epll_con0); - k = readl(&exynos_clock->epll_con1); + r = read32(&exynos_clock->epll_con0); + k = read32(&exynos_clock->epll_con1); break; case VPLL: - r = readl(&exynos_clock->vpll_con0); - k = readl(&exynos_clock->vpll_con1); + r = read32(&exynos_clock->vpll_con0); + k = read32(&exynos_clock->vpll_con1); break; default: printk(BIOS_DEBUG, "Unsupported PLL (%d)\n", pllreg); @@ -246,41 +246,41 @@ unsigned long clock_get_periph_rate(enum periph_id peripheral) case PERIPH_ID_UART1: case PERIPH_ID_UART2: case PERIPH_ID_UART3: - src = readl(&exynos_clock->src_peric0); - div = readl(&exynos_clock->div_peric0); + src = read32(&exynos_clock->src_peric0); + div = read32(&exynos_clock->div_peric0); break; case PERIPH_ID_PWM0: case PERIPH_ID_PWM1: case PERIPH_ID_PWM2: case PERIPH_ID_PWM3: case PERIPH_ID_PWM4: - src = readl(&exynos_clock->src_peric0); - div = readl(&exynos_clock->div_peric3); + src = read32(&exynos_clock->src_peric0); + div = read32(&exynos_clock->div_peric3); break; case PERIPH_ID_SPI0: case PERIPH_ID_SPI1: - src = readl(&exynos_clock->src_peric1); - div = readl(&exynos_clock->div_peric1); + src = read32(&exynos_clock->src_peric1); + div = read32(&exynos_clock->div_peric1); break; case PERIPH_ID_SPI2: - src = readl(&exynos_clock->src_peric1); - div = readl(&exynos_clock->div_peric2); + src = read32(&exynos_clock->src_peric1); + div = read32(&exynos_clock->div_peric2); break; case PERIPH_ID_SPI3: case PERIPH_ID_SPI4: - src = readl(&exynos_clock->sclk_src_isp); - div = readl(&exynos_clock->sclk_div_isp); + src = read32(&exynos_clock->sclk_src_isp); + div = read32(&exynos_clock->sclk_div_isp); break; case PERIPH_ID_SATA: - src = readl(&exynos_clock->src_fsys); - div = readl(&exynos_clock->div_fsys0); + src = read32(&exynos_clock->src_fsys); + div = read32(&exynos_clock->div_fsys0); break; case PERIPH_ID_SDMMC0: case PERIPH_ID_SDMMC1: case PERIPH_ID_SDMMC2: case PERIPH_ID_SDMMC3: - src = readl(&exynos_clock->src_fsys); - div = readl(&exynos_clock->div_fsys1); + src = read32(&exynos_clock->src_fsys); + div = read32(&exynos_clock->div_fsys1); break; case PERIPH_ID_I2C0: case PERIPH_ID_I2C1: @@ -291,9 +291,9 @@ unsigned long clock_get_periph_rate(enum periph_id peripheral) case PERIPH_ID_I2C6: case PERIPH_ID_I2C7: sclk = get_pll_clk(MPLL); - sub_div = ((readl(&exynos_clock->div_top1) + sub_div = ((read32(&exynos_clock->div_top1) >> bit_info->div_bit) & 0x7) + 1; - div = ((readl(&exynos_clock->div_top0) + div = ((read32(&exynos_clock->div_top0) >> bit_info->prediv_bit) & 0x7) + 1; return (sclk / sub_div) / div; default: @@ -337,7 +337,7 @@ unsigned long get_arm_clk(void) unsigned int arm_ratio; unsigned int arm2_ratio; - div = readl(&exynos_clock->div_cpu0); + div = read32(&exynos_clock->div_cpu0); /* ARM_RATIO: [2:0], ARM2_RATIO: [30:28] */ arm_ratio = (div >> 0) & 0x7; @@ -383,10 +383,10 @@ void set_mmc_clk(int dev_index, unsigned int div) dev_index -= 2; } - val = readl(addr); + val = read32(addr); val &= ~(0xff << ((dev_index << 4) + 8)); val |= (div & 0xff) << ((dev_index << 4) + 8); - writel(val, addr); + write32(addr, val); } void clock_ll_set_pre_ratio(enum periph_id periph_id, unsigned divisor) @@ -582,10 +582,10 @@ int clock_set_mshci(enum periph_id peripheral) printk(BIOS_DEBUG, "invalid peripheral\n"); return -1; } - tmp = readl(addr) & ~0xff0f; + tmp = read32(addr) & ~0xff0f; for (i = 0; i <= 0xf; i++) { if ((clock / (i + 1)) <= 400) { - writel(tmp | i << 0, addr); + write32(addr, tmp | i << 0); break; } } @@ -599,7 +599,7 @@ int clock_epll_set_rate(unsigned long rate) unsigned int lockcnt; struct stopwatch sw; - epll_con = readl(&exynos_clock->epll_con0); + epll_con = read32(&exynos_clock->epll_con0); epll_con &= ~((EPLL_CON0_LOCK_DET_EN_MASK << EPLL_CON0_LOCK_DET_EN_SHIFT) | EPLL_CON0_MDIV_MASK << EPLL_CON0_MDIV_SHIFT | @@ -627,13 +627,13 @@ int clock_epll_set_rate(unsigned long rate) */ lockcnt = 3000 * epll_div[i].p_div; - writel(lockcnt, &exynos_clock->epll_lock); - writel(epll_con, &exynos_clock->epll_con0); - writel(epll_con_k, &exynos_clock->epll_con1); + write32(&exynos_clock->epll_lock, lockcnt); + write32(&exynos_clock->epll_con0, epll_con); + write32(&exynos_clock->epll_con1, epll_con_k); stopwatch_init_msecs_expire(&sw, TIMEOUT_EPLL_LOCK); - while (!(readl(&exynos_clock->epll_con0) & + while (!(read32(&exynos_clock->epll_con0) & (0x1 << EXYNOS5_EPLLCON0_LOCKED_SHIFT))) { if (stopwatch_expired(&sw)) { printk(BIOS_DEBUG, diff --git a/src/soc/samsung/exynos5250/clock_init.c b/src/soc/samsung/exynos5250/clock_init.c index 409230180b..9cdd729f57 100644 --- a/src/soc/samsung/exynos5250/clock_init.c +++ b/src/soc/samsung/exynos5250/clock_init.c @@ -35,12 +35,12 @@ void system_clock_init(struct mem_timings *mem, clrbits_le32(&exynos_clock->src_cpu, MUX_APLL_SEL_MASK); do { - val = readl(&exynos_clock->mux_stat_cpu); + val = read32(&exynos_clock->mux_stat_cpu); } while ((val | MUX_APLL_SEL_MASK) != val); clrbits_le32(&exynos_clock->src_core1, MUX_MPLL_SEL_MASK); do { - val = readl(&exynos_clock->mux_stat_core1); + val = read32(&exynos_clock->mux_stat_core1); } while ((val | MUX_MPLL_SEL_MASK) != val); clrbits_le32(&exynos_clock->src_top2, MUX_CPLL_SEL_MASK); @@ -50,34 +50,34 @@ void system_clock_init(struct mem_timings *mem, tmp = MUX_CPLL_SEL_MASK | MUX_EPLL_SEL_MASK | MUX_VPLL_SEL_MASK | MUX_GPLL_SEL_MASK; do { - val = readl(&exynos_clock->mux_stat_top2); + val = read32(&exynos_clock->mux_stat_top2); } while ((val | tmp) != val); clrbits_le32(&exynos_clock->src_cdrex, MUX_BPLL_SEL_MASK); do { - val = readl(&exynos_clock->mux_stat_cdrex); + val = read32(&exynos_clock->mux_stat_cdrex); } while ((val | MUX_BPLL_SEL_MASK) != val); /* PLL locktime */ - writel(APLL_LOCK_VAL, &exynos_clock->apll_lock); + write32(&exynos_clock->apll_lock, APLL_LOCK_VAL); - writel(MPLL_LOCK_VAL, &exynos_clock->mpll_lock); + write32(&exynos_clock->mpll_lock, MPLL_LOCK_VAL); - writel(BPLL_LOCK_VAL, &exynos_clock->bpll_lock); + write32(&exynos_clock->bpll_lock, BPLL_LOCK_VAL); - writel(CPLL_LOCK_VAL, &exynos_clock->cpll_lock); + write32(&exynos_clock->cpll_lock, CPLL_LOCK_VAL); - writel(GPLL_LOCK_VAL, &exynos_clock->gpll_lock); + write32(&exynos_clock->gpll_lock, GPLL_LOCK_VAL); - writel(EPLL_LOCK_VAL, &exynos_clock->epll_lock); + write32(&exynos_clock->epll_lock, EPLL_LOCK_VAL); - writel(VPLL_LOCK_VAL, &exynos_clock->vpll_lock); + write32(&exynos_clock->vpll_lock, VPLL_LOCK_VAL); - writel(CLK_REG_DISABLE, &exynos_clock->pll_div2_sel); + write32(&exynos_clock->pll_div2_sel, CLK_REG_DISABLE); - writel(MUX_HPM_SEL_MASK, &exynos_clock->src_cpu); + write32(&exynos_clock->src_cpu, MUX_HPM_SEL_MASK); do { - val = readl(&exynos_clock->mux_stat_cpu); + val = read32(&exynos_clock->mux_stat_cpu); } while ((val | HPM_SEL_SCLK_MPLL) != val); val = arm_clk_ratio->arm2_ratio << 28 @@ -88,35 +88,35 @@ void system_clock_init(struct mem_timings *mem, | arm_clk_ratio->acp_ratio << 8 | arm_clk_ratio->cpud_ratio << 4 | arm_clk_ratio->arm_ratio; - writel(val, &exynos_clock->div_cpu0); + write32(&exynos_clock->div_cpu0, val); do { - val = readl(&exynos_clock->div_stat_cpu0); + val = read32(&exynos_clock->div_stat_cpu0); } while (0 != val); - writel(CLK_DIV_CPU1_VAL, &exynos_clock->div_cpu1); + write32(&exynos_clock->div_cpu1, CLK_DIV_CPU1_VAL); do { - val = readl(&exynos_clock->div_stat_cpu1); + val = read32(&exynos_clock->div_stat_cpu1); } while (0 != val); /* switch A15 clock source to OSC clock before changing APLL */ clrbits_le32(&exynos_clock->src_cpu, APLL_FOUT); /* Set APLL */ - writel(APLL_CON1_VAL, &exynos_clock->apll_con1); + write32(&exynos_clock->apll_con1, APLL_CON1_VAL); val = set_pll(arm_clk_ratio->apll_mdiv, arm_clk_ratio->apll_pdiv, arm_clk_ratio->apll_sdiv); - writel(val, &exynos_clock->apll_con0); - while ((readl(&exynos_clock->apll_con0) & APLL_CON0_LOCKED) == 0) + write32(&exynos_clock->apll_con0, val); + while ((read32(&exynos_clock->apll_con0) & APLL_CON0_LOCKED) == 0) ; /* now it is safe to switch to APLL */ setbits_le32(&exynos_clock->src_cpu, APLL_FOUT); /* Set MPLL */ - writel(MPLL_CON1_VAL, &exynos_clock->mpll_con1); + write32(&exynos_clock->mpll_con1, MPLL_CON1_VAL); val = set_pll(mem->mpll_mdiv, mem->mpll_pdiv, mem->mpll_sdiv); - writel(val, &exynos_clock->mpll_con0); - while ((readl(&exynos_clock->mpll_con0) & MPLL_CON0_LOCKED) == 0) + write32(&exynos_clock->mpll_con0, val); + while ((read32(&exynos_clock->mpll_con0) & MPLL_CON0_LOCKED) == 0) ; /* @@ -127,159 +127,159 @@ void system_clock_init(struct mem_timings *mem, /* Set BPLL */ if (mem->use_bpll) { - writel(BPLL_CON1_VAL, &exynos_clock->bpll_con1); + write32(&exynos_clock->bpll_con1, BPLL_CON1_VAL); val = set_pll(mem->bpll_mdiv, mem->bpll_pdiv, mem->bpll_sdiv); - writel(val, &exynos_clock->bpll_con0); - while ((readl(&exynos_clock->bpll_con0) & BPLL_CON0_LOCKED) == 0) + write32(&exynos_clock->bpll_con0, val); + while ((read32(&exynos_clock->bpll_con0) & BPLL_CON0_LOCKED) == 0) ; setbits_le32(&exynos_clock->pll_div2_sel, MUX_BPLL_FOUT_SEL); } /* Set CPLL */ - writel(CPLL_CON1_VAL, &exynos_clock->cpll_con1); + write32(&exynos_clock->cpll_con1, CPLL_CON1_VAL); val = set_pll(mem->cpll_mdiv, mem->cpll_pdiv, mem->cpll_sdiv); - writel(val, &exynos_clock->cpll_con0); - while ((readl(&exynos_clock->cpll_con0) & CPLL_CON0_LOCKED) == 0) + write32(&exynos_clock->cpll_con0, val); + while ((read32(&exynos_clock->cpll_con0) & CPLL_CON0_LOCKED) == 0) ; /* Set GPLL */ - writel(GPLL_CON1_VAL, &exynos_clock->gpll_con1); + write32(&exynos_clock->gpll_con1, GPLL_CON1_VAL); val = set_pll(mem->gpll_mdiv, mem->gpll_pdiv, mem->gpll_sdiv); - writel(val, &exynos_clock->gpll_con0); - while ((readl(&exynos_clock->gpll_con0) & GPLL_CON0_LOCKED) == 0) + write32(&exynos_clock->gpll_con0, val); + while ((read32(&exynos_clock->gpll_con0) & GPLL_CON0_LOCKED) == 0) ; /* Set EPLL */ - writel(EPLL_CON2_VAL, &exynos_clock->epll_con2); - writel(EPLL_CON1_VAL, &exynos_clock->epll_con1); + write32(&exynos_clock->epll_con2, EPLL_CON2_VAL); + write32(&exynos_clock->epll_con1, EPLL_CON1_VAL); val = set_pll(mem->epll_mdiv, mem->epll_pdiv, mem->epll_sdiv); - writel(val, &exynos_clock->epll_con0); - while ((readl(&exynos_clock->epll_con0) & EPLL_CON0_LOCKED) == 0) + write32(&exynos_clock->epll_con0, val); + while ((read32(&exynos_clock->epll_con0) & EPLL_CON0_LOCKED) == 0) ; /* Set VPLL */ - writel(VPLL_CON2_VAL, &exynos_clock->vpll_con2); - writel(VPLL_CON1_VAL, &exynos_clock->vpll_con1); + write32(&exynos_clock->vpll_con2, VPLL_CON2_VAL); + write32(&exynos_clock->vpll_con1, VPLL_CON1_VAL); val = set_pll(mem->vpll_mdiv, mem->vpll_pdiv, mem->vpll_sdiv); - writel(val, &exynos_clock->vpll_con0); - while ((readl(&exynos_clock->vpll_con0) & VPLL_CON0_LOCKED) == 0) + write32(&exynos_clock->vpll_con0, val); + while ((read32(&exynos_clock->vpll_con0) & VPLL_CON0_LOCKED) == 0) ; - writel(CLK_SRC_CORE0_VAL, &exynos_clock->src_core0); - writel(CLK_DIV_CORE0_VAL, &exynos_clock->div_core0); - while (readl(&exynos_clock->div_stat_core0) != 0) + write32(&exynos_clock->src_core0, CLK_SRC_CORE0_VAL); + write32(&exynos_clock->div_core0, CLK_DIV_CORE0_VAL); + while (read32(&exynos_clock->div_stat_core0) != 0) ; - writel(CLK_DIV_CORE1_VAL, &exynos_clock->div_core1); - while (readl(&exynos_clock->div_stat_core1) != 0) + write32(&exynos_clock->div_core1, CLK_DIV_CORE1_VAL); + while (read32(&exynos_clock->div_stat_core1) != 0) ; - writel(CLK_DIV_SYSRGT_VAL, &exynos_clock->div_sysrgt); - while (readl(&exynos_clock->div_stat_sysrgt) != 0) + write32(&exynos_clock->div_sysrgt, CLK_DIV_SYSRGT_VAL); + while (read32(&exynos_clock->div_stat_sysrgt) != 0) ; - writel(CLK_DIV_ACP_VAL, &exynos_clock->div_acp); - while (readl(&exynos_clock->div_stat_acp) != 0) + write32(&exynos_clock->div_acp, CLK_DIV_ACP_VAL); + while (read32(&exynos_clock->div_stat_acp) != 0) ; - writel(CLK_DIV_SYSLFT_VAL, &exynos_clock->div_syslft); - while (readl(&exynos_clock->div_stat_syslft) != 0) + write32(&exynos_clock->div_syslft, CLK_DIV_SYSLFT_VAL); + while (read32(&exynos_clock->div_stat_syslft) != 0) ; - writel(CLK_SRC_TOP0_VAL, &exynos_clock->src_top0); - writel(CLK_SRC_TOP1_VAL, &exynos_clock->src_top1); - writel(TOP2_VAL, &exynos_clock->src_top2); - writel(CLK_SRC_TOP3_VAL, &exynos_clock->src_top3); + write32(&exynos_clock->src_top0, CLK_SRC_TOP0_VAL); + write32(&exynos_clock->src_top1, CLK_SRC_TOP1_VAL); + write32(&exynos_clock->src_top2, TOP2_VAL); + write32(&exynos_clock->src_top3, CLK_SRC_TOP3_VAL); - writel(CLK_DIV_TOP0_VAL, &exynos_clock->div_top0); - while (readl(&exynos_clock->div_stat_top0)) + write32(&exynos_clock->div_top0, CLK_DIV_TOP0_VAL); + while (read32(&exynos_clock->div_stat_top0)) ; - writel(CLK_DIV_TOP1_VAL, &exynos_clock->div_top1); - while (readl(&exynos_clock->div_stat_top1)) + write32(&exynos_clock->div_top1, CLK_DIV_TOP1_VAL); + while (read32(&exynos_clock->div_stat_top1)) ; - writel(CLK_SRC_LEX_VAL, &exynos_clock->src_lex); + write32(&exynos_clock->src_lex, CLK_SRC_LEX_VAL); while (1) { - val = readl(&exynos_clock->mux_stat_lex); + val = read32(&exynos_clock->mux_stat_lex); if (val == (val | 1)) break; } - writel(CLK_DIV_LEX_VAL, &exynos_clock->div_lex); - while (readl(&exynos_clock->div_stat_lex)) + write32(&exynos_clock->div_lex, CLK_DIV_LEX_VAL); + while (read32(&exynos_clock->div_stat_lex)) ; - writel(CLK_DIV_R0X_VAL, &exynos_clock->div_r0x); - while (readl(&exynos_clock->div_stat_r0x)) + write32(&exynos_clock->div_r0x, CLK_DIV_R0X_VAL); + while (read32(&exynos_clock->div_stat_r0x)) ; - writel(CLK_DIV_R0X_VAL, &exynos_clock->div_r0x); - while (readl(&exynos_clock->div_stat_r0x)) + write32(&exynos_clock->div_r0x, CLK_DIV_R0X_VAL); + while (read32(&exynos_clock->div_stat_r0x)) ; - writel(CLK_DIV_R1X_VAL, &exynos_clock->div_r1x); - while (readl(&exynos_clock->div_stat_r1x)) + write32(&exynos_clock->div_r1x, CLK_DIV_R1X_VAL); + while (read32(&exynos_clock->div_stat_r1x)) ; if (mem->use_bpll) { - writel(MUX_BPLL_SEL_MASK | MUX_MCLK_CDREX_SEL | - MUX_MCLK_DPHY_SEL, &exynos_clock->src_cdrex); + write32(&exynos_clock->src_cdrex, + MUX_BPLL_SEL_MASK | MUX_MCLK_CDREX_SEL | MUX_MCLK_DPHY_SEL); } else { - writel(CLK_REG_DISABLE, &exynos_clock->src_cdrex); + write32(&exynos_clock->src_cdrex, CLK_REG_DISABLE); } - writel(CLK_DIV_CDREX_VAL, &exynos_clock->div_cdrex); - while (readl(&exynos_clock->div_stat_cdrex)) + write32(&exynos_clock->div_cdrex, CLK_DIV_CDREX_VAL); + while (read32(&exynos_clock->div_stat_cdrex)) ; - val = readl(&exynos_clock->src_cpu); + val = read32(&exynos_clock->src_cpu); val |= CLK_SRC_CPU_VAL; - writel(val, &exynos_clock->src_cpu); + write32(&exynos_clock->src_cpu, val); - val = readl(&exynos_clock->src_top2); + val = read32(&exynos_clock->src_top2); val |= CLK_SRC_TOP2_VAL; - writel(val, &exynos_clock->src_top2); + write32(&exynos_clock->src_top2, val); - val = readl(&exynos_clock->src_core1); + val = read32(&exynos_clock->src_core1); val |= CLK_SRC_CORE1_VAL; - writel(val, &exynos_clock->src_core1); + write32(&exynos_clock->src_core1, val); - writel(CLK_SRC_FSYS0_VAL, &exynos_clock->src_fsys); - writel(CLK_DIV_FSYS0_VAL, &exynos_clock->div_fsys0); - while (readl(&exynos_clock->div_stat_fsys0)) + write32(&exynos_clock->src_fsys, CLK_SRC_FSYS0_VAL); + write32(&exynos_clock->div_fsys0, CLK_DIV_FSYS0_VAL); + while (read32(&exynos_clock->div_stat_fsys0)) ; - writel(CLK_REG_DISABLE, &exynos_clock->clkout_cmu_cpu); - writel(CLK_REG_DISABLE, &exynos_clock->clkout_cmu_core); - writel(CLK_REG_DISABLE, &exynos_clock->clkout_cmu_acp); - writel(CLK_REG_DISABLE, &exynos_clock->clkout_cmu_top); - writel(CLK_REG_DISABLE, &exynos_clock->clkout_cmu_lex); - writel(CLK_REG_DISABLE, &exynos_clock->clkout_cmu_r0x); - writel(CLK_REG_DISABLE, &exynos_clock->clkout_cmu_r1x); - writel(CLK_REG_DISABLE, &exynos_clock->clkout_cmu_cdrex); - - writel(CLK_SRC_PERIC0_VAL, &exynos_clock->src_peric0); - writel(CLK_DIV_PERIC0_VAL, &exynos_clock->div_peric0); - - writel(CLK_SRC_PERIC1_VAL, &exynos_clock->src_peric1); - writel(CLK_DIV_PERIC1_VAL, &exynos_clock->div_peric1); - writel(CLK_DIV_PERIC2_VAL, &exynos_clock->div_peric2); - writel(SCLK_SRC_ISP_VAL, &exynos_clock->sclk_src_isp); - writel(SCLK_DIV_ISP_VAL, &exynos_clock->sclk_div_isp); - writel(CLK_DIV_ISP0_VAL, &exynos_clock->div_isp0); - writel(CLK_DIV_ISP1_VAL, &exynos_clock->div_isp1); - writel(CLK_DIV_ISP2_VAL, &exynos_clock->div_isp2); + write32(&exynos_clock->clkout_cmu_cpu, CLK_REG_DISABLE); + write32(&exynos_clock->clkout_cmu_core, CLK_REG_DISABLE); + write32(&exynos_clock->clkout_cmu_acp, CLK_REG_DISABLE); + write32(&exynos_clock->clkout_cmu_top, CLK_REG_DISABLE); + write32(&exynos_clock->clkout_cmu_lex, CLK_REG_DISABLE); + write32(&exynos_clock->clkout_cmu_r0x, CLK_REG_DISABLE); + write32(&exynos_clock->clkout_cmu_r1x, CLK_REG_DISABLE); + write32(&exynos_clock->clkout_cmu_cdrex, CLK_REG_DISABLE); + + write32(&exynos_clock->src_peric0, CLK_SRC_PERIC0_VAL); + write32(&exynos_clock->div_peric0, CLK_DIV_PERIC0_VAL); + + write32(&exynos_clock->src_peric1, CLK_SRC_PERIC1_VAL); + write32(&exynos_clock->div_peric1, CLK_DIV_PERIC1_VAL); + write32(&exynos_clock->div_peric2, CLK_DIV_PERIC2_VAL); + write32(&exynos_clock->sclk_src_isp, SCLK_SRC_ISP_VAL); + write32(&exynos_clock->sclk_div_isp, SCLK_DIV_ISP_VAL); + write32(&exynos_clock->div_isp0, CLK_DIV_ISP0_VAL); + write32(&exynos_clock->div_isp1, CLK_DIV_ISP1_VAL); + write32(&exynos_clock->div_isp2, CLK_DIV_ISP2_VAL); /* FIMD1 SRC CLK SELECTION */ - writel(CLK_SRC_DISP1_0_VAL, &exynos_clock->src_disp1_0); + write32(&exynos_clock->src_disp1_0, CLK_SRC_DISP1_0_VAL); val = MMC2_PRE_RATIO_VAL << MMC2_PRE_RATIO_OFFSET | MMC2_RATIO_VAL << MMC2_RATIO_OFFSET | MMC3_PRE_RATIO_VAL << MMC3_PRE_RATIO_OFFSET | MMC3_RATIO_VAL << MMC3_RATIO_OFFSET; - writel(val, &exynos_clock->div_fsys2); + write32(&exynos_clock->div_fsys2, val); } void clock_gate(void) diff --git a/src/soc/samsung/exynos5250/cpu.c b/src/soc/samsung/exynos5250/cpu.c index cff1466a64..d9f001a57f 100644 --- a/src/soc/samsung/exynos5250/cpu.c +++ b/src/soc/samsung/exynos5250/cpu.c @@ -38,7 +38,7 @@ static unsigned int cpu_rev; static void set_cpu_id(void) { - cpu_id = readl((void *)EXYNOS5_PRO_ID); + cpu_id = read32((void *)EXYNOS5_PRO_ID); cpu_id = (0xC000 | ((cpu_id & 0x00FFF000) >> 12)); /* diff --git a/src/soc/samsung/exynos5250/dmc_common.c b/src/soc/samsung/exynos5250/dmc_common.c index 17dff1ec92..2e64905d9d 100644 --- a/src/soc/samsung/exynos5250/dmc_common.c +++ b/src/soc/samsung/exynos5250/dmc_common.c @@ -45,19 +45,19 @@ int dmc_config_zq(struct mem_timings *mem, val |= mem->zq_mode_dds << PHY_CON16_ZQ_MODE_DDS_SHIFT; val |= mem->zq_mode_term << PHY_CON16_ZQ_MODE_TERM_SHIFT; val |= ZQ_CLK_DIV_EN; - writel(val, &phy0_ctrl->phy_con16); - writel(val, &phy1_ctrl->phy_con16); + write32(&phy0_ctrl->phy_con16, val); + write32(&phy1_ctrl->phy_con16, val); /* Disable termination */ if (mem->zq_mode_noterm) val |= PHY_CON16_ZQ_MODE_NOTERM_MASK; - writel(val, &phy0_ctrl->phy_con16); - writel(val, &phy1_ctrl->phy_con16); + write32(&phy0_ctrl->phy_con16, val); + write32(&phy1_ctrl->phy_con16, val); /* ZQ_MANUAL_START: Enable */ val |= ZQ_MANUAL_STR; - writel(val, &phy0_ctrl->phy_con16); - writel(val, &phy1_ctrl->phy_con16); + write32(&phy0_ctrl->phy_con16, val); + write32(&phy1_ctrl->phy_con16, val); /* ZQ_MANUAL_START: Disable */ val &= ~ZQ_MANUAL_STR; @@ -67,22 +67,22 @@ int dmc_config_zq(struct mem_timings *mem, * we are looping for the ZQ_init to complete. */ i = ZQ_INIT_TIMEOUT; - while ((readl(&phy0_ctrl->phy_con17) & ZQ_DONE) != ZQ_DONE && i > 0) { + while ((read32(&phy0_ctrl->phy_con17) & ZQ_DONE) != ZQ_DONE && i > 0) { udelay(1); i--; } if (!i) return -1; - writel(val, &phy0_ctrl->phy_con16); + write32(&phy0_ctrl->phy_con16, val); i = ZQ_INIT_TIMEOUT; - while ((readl(&phy1_ctrl->phy_con17) & ZQ_DONE) != ZQ_DONE && i > 0) { + while ((read32(&phy1_ctrl->phy_con17) & ZQ_DONE) != ZQ_DONE && i > 0) { udelay(1); i--; } if (!i) return -1; - writel(val, &phy1_ctrl->phy_con16); + write32(&phy1_ctrl->phy_con16, val); return 0; } @@ -93,18 +93,18 @@ void update_reset_dll(struct exynos5_dmc *dmc, enum ddr_mode mode) if (mode == DDR_MODE_DDR3) { val = MEM_TERM_EN | PHY_TERM_EN | DMC_CTRL_SHGATE; - writel(val, &dmc->phycontrol0); + write32(&dmc->phycontrol0, val); } /* Update DLL Information: Force DLL Resynchronization */ - val = readl(&dmc->phycontrol0); + val = read32(&dmc->phycontrol0); val |= FP_RSYNC; - writel(val, &dmc->phycontrol0); + write32(&dmc->phycontrol0, val); /* Reset Force DLL Resynchronization */ - val = readl(&dmc->phycontrol0); + val = read32(&dmc->phycontrol0); val &= ~FP_RSYNC; - writel(val, &dmc->phycontrol0); + write32(&dmc->phycontrol0, val); } void dmc_config_mrs(struct mem_timings *mem, struct exynos5_dmc *dmc) @@ -121,7 +121,7 @@ void dmc_config_mrs(struct mem_timings *mem, struct exynos5_dmc *dmc) mask |= chip << DIRECT_CMD_CHIP_SHIFT; /* Sending NOP command */ - writel(DIRECT_CMD_NOP | mask, &dmc->directcmd); + write32(&dmc->directcmd, DIRECT_CMD_NOP | mask); /* * TODO(alim.akhtar@samsung.com): Do we need these @@ -132,15 +132,15 @@ void dmc_config_mrs(struct mem_timings *mem, struct exynos5_dmc *dmc) /* Sending EMRS/MRS commands */ for (i = 0; i < MEM_TIMINGS_MSR_COUNT; i++) { - writel(mem->direct_cmd_msr[i] | mask, - &dmc->directcmd); + write32(&dmc->directcmd, + mem->direct_cmd_msr[i] | mask); udelay(100); } if (mem->send_zq_init) { /* Sending ZQINIT command */ - writel(DIRECT_CMD_ZQINIT | mask, - &dmc->directcmd); + write32(&dmc->directcmd, + DIRECT_CMD_ZQINIT | mask); /* * FIXME: This was originally sdelay(10000) * in the imported u-boot code. That may have @@ -166,7 +166,7 @@ void dmc_config_prech(struct mem_timings *mem, struct exynos5_dmc *dmc) mask |= chip << DIRECT_CMD_CHIP_SHIFT; /* PALL (all banks precharge) CMD */ - writel(DIRECT_CMD_PALL | mask, &dmc->directcmd); + write32(&dmc->directcmd, DIRECT_CMD_PALL | mask); udelay(100); } } @@ -174,8 +174,8 @@ void dmc_config_prech(struct mem_timings *mem, struct exynos5_dmc *dmc) void dmc_config_memory(struct mem_timings *mem, struct exynos5_dmc *dmc) { - writel(mem->memconfig, &dmc->memconfig0); - writel(mem->memconfig, &dmc->memconfig1); - writel(DMC_MEMBASECONFIG0_VAL, &dmc->membaseconfig0); - writel(DMC_MEMBASECONFIG1_VAL, &dmc->membaseconfig1); + write32(&dmc->memconfig0, mem->memconfig); + write32(&dmc->memconfig1, mem->memconfig); + write32(&dmc->membaseconfig0, DMC_MEMBASECONFIG0_VAL); + write32(&dmc->membaseconfig1, DMC_MEMBASECONFIG1_VAL); } diff --git a/src/soc/samsung/exynos5250/dmc_init_ddr3.c b/src/soc/samsung/exynos5250/dmc_init_ddr3.c index 3b26c206c1..5a3cf3ef06 100644 --- a/src/soc/samsung/exynos5250/dmc_init_ddr3.c +++ b/src/soc/samsung/exynos5250/dmc_init_ddr3.c @@ -31,8 +31,10 @@ static void reset_phy_ctrl(void) { - writel(LPDDR3PHY_CTRL_PHY_RESET_ENABLE, &exynos_clock->lpddr3phy_ctrl); - writel(LPDDR3PHY_CTRL_PHY_RESET_DISABLE, &exynos_clock->lpddr3phy_ctrl); + write32(&exynos_clock->lpddr3phy_ctrl, + LPDDR3PHY_CTRL_PHY_RESET_ENABLE); + write32(&exynos_clock->lpddr3phy_ctrl, + LPDDR3PHY_CTRL_PHY_RESET_DISABLE); #if 0 /* @@ -65,14 +67,14 @@ int ddr3_mem_ctrl_init(struct mem_timings *mem, unsigned long mem_iv_size, (mem->impedance << CA_CKE_DRVR_DS_OFFSET) | (mem->impedance << CA_CS_DRVR_DS_OFFSET) | (mem->impedance << CA_ADR_DRVR_DS_OFFSET); - writel(val, &exynos_phy0_control->phy_con39); - writel(val, &exynos_phy1_control->phy_con39); + write32(&exynos_phy0_control->phy_con39, val); + write32(&exynos_phy1_control->phy_con39, val); /* Set Read Latency and Burst Length for PHY0 and PHY1 */ val = (mem->ctrl_bstlen << PHY_CON42_CTRL_BSTLEN_SHIFT) | (mem->ctrl_rdlat << PHY_CON42_CTRL_RDLAT_SHIFT); - writel(val, &exynos_phy0_control->phy_con42); - writel(val, &exynos_phy1_control->phy_con42); + write32(&exynos_phy0_control->phy_con42, val); + write32(&exynos_phy1_control->phy_con42, val); /* ZQ Calibration */ if (dmc_config_zq(mem, exynos_phy0_control, exynos_phy1_control)){ @@ -81,71 +83,69 @@ int ddr3_mem_ctrl_init(struct mem_timings *mem, unsigned long mem_iv_size, } /* DQ Signal */ - writel(mem->phy0_pulld_dqs, &exynos_phy0_control->phy_con14); - writel(mem->phy1_pulld_dqs, &exynos_phy1_control->phy_con14); + write32(&exynos_phy0_control->phy_con14, mem->phy0_pulld_dqs); + write32(&exynos_phy1_control->phy_con14, mem->phy1_pulld_dqs); - writel(mem->concontrol | (mem->rd_fetch << CONCONTROL_RD_FETCH_SHIFT) - | (mem->dfi_init_start << CONCONTROL_DFI_INIT_START_SHIFT), - &exynos_dmc->concontrol); + write32(&exynos_dmc->concontrol, + mem->concontrol | (mem->rd_fetch << CONCONTROL_RD_FETCH_SHIFT) | (mem->dfi_init_start << CONCONTROL_DFI_INIT_START_SHIFT)); update_reset_dll(exynos_dmc, DDR_MODE_DDR3); /* DQS Signal */ - writel(mem->phy0_dqs, &exynos_phy0_control->phy_con4); - writel(mem->phy1_dqs, &exynos_phy1_control->phy_con4); + write32(&exynos_phy0_control->phy_con4, mem->phy0_dqs); + write32(&exynos_phy1_control->phy_con4, mem->phy1_dqs); - writel(mem->phy0_dq, &exynos_phy0_control->phy_con6); - writel(mem->phy1_dq, &exynos_phy1_control->phy_con6); + write32(&exynos_phy0_control->phy_con6, mem->phy0_dq); + write32(&exynos_phy1_control->phy_con6, mem->phy1_dq); - writel(mem->phy0_tFS, &exynos_phy0_control->phy_con10); - writel(mem->phy1_tFS, &exynos_phy1_control->phy_con10); + write32(&exynos_phy0_control->phy_con10, mem->phy0_tFS); + write32(&exynos_phy1_control->phy_con10, mem->phy1_tFS); val = (mem->ctrl_start_point << PHY_CON12_CTRL_START_POINT_SHIFT) | (mem->ctrl_inc << PHY_CON12_CTRL_INC_SHIFT) | (mem->ctrl_dll_on << PHY_CON12_CTRL_DLL_ON_SHIFT) | (mem->ctrl_ref << PHY_CON12_CTRL_REF_SHIFT); - writel(val, &exynos_phy0_control->phy_con12); - writel(val, &exynos_phy1_control->phy_con12); + write32(&exynos_phy0_control->phy_con12, val); + write32(&exynos_phy1_control->phy_con12, val); /* Start DLL locking */ - writel(val | (mem->ctrl_start << PHY_CON12_CTRL_START_SHIFT), - &exynos_phy0_control->phy_con12); - writel(val | (mem->ctrl_start << PHY_CON12_CTRL_START_SHIFT), - &exynos_phy1_control->phy_con12); + write32(&exynos_phy0_control->phy_con12, + val | (mem->ctrl_start << PHY_CON12_CTRL_START_SHIFT)); + write32(&exynos_phy1_control->phy_con12, + val | (mem->ctrl_start << PHY_CON12_CTRL_START_SHIFT)); update_reset_dll(exynos_dmc, DDR_MODE_DDR3); - writel(mem->concontrol | (mem->rd_fetch << CONCONTROL_RD_FETCH_SHIFT), - &exynos_dmc->concontrol); + write32(&exynos_dmc->concontrol, + mem->concontrol | (mem->rd_fetch << CONCONTROL_RD_FETCH_SHIFT)); /* Memory Channel Inteleaving Size */ - writel(mem->iv_size, &exynos_dmc->ivcontrol); + write32(&exynos_dmc->ivcontrol, mem->iv_size); /* Set DMC MEMCONTROL register */ val = mem->memcontrol & ~DMC_MEMCONTROL_DSREF_ENABLE; - writel(val, &exynos_dmc->memcontrol); + write32(&exynos_dmc->memcontrol, val); - writel(mem->memconfig, &exynos_dmc->memconfig0); - writel(mem->memconfig, &exynos_dmc->memconfig1); - writel(mem->membaseconfig0, &exynos_dmc->membaseconfig0); - writel(mem->membaseconfig1, &exynos_dmc->membaseconfig1); + write32(&exynos_dmc->memconfig0, mem->memconfig); + write32(&exynos_dmc->memconfig1, mem->memconfig); + write32(&exynos_dmc->membaseconfig0, mem->membaseconfig0); + write32(&exynos_dmc->membaseconfig1, mem->membaseconfig1); /* Precharge Configuration */ - writel(mem->prechconfig_tp_cnt << PRECHCONFIG_TP_CNT_SHIFT, - &exynos_dmc->prechconfig); + write32(&exynos_dmc->prechconfig, + mem->prechconfig_tp_cnt << PRECHCONFIG_TP_CNT_SHIFT); /* Power Down mode Configuration */ - writel(mem->dpwrdn_cyc << PWRDNCONFIG_DPWRDN_CYC_SHIFT | - mem->dsref_cyc << PWRDNCONFIG_DSREF_CYC_SHIFT, - &exynos_dmc->pwrdnconfig); + write32(&exynos_dmc->pwrdnconfig, + mem->dpwrdn_cyc << PWRDNCONFIG_DPWRDN_CYC_SHIFT | mem->dsref_cyc << PWRDNCONFIG_DSREF_CYC_SHIFT); /* TimingRow, TimingData, TimingPower and Timingaref * values as per Memory AC parameters */ - writel(mem->timing_ref, &exynos_dmc->timingref); - writel(mem->timing_row, &exynos_dmc->timingrow); - writel(mem->timing_data, &exynos_dmc->timingdata); - writel(mem->timing_power, &exynos_dmc->timingpower); + write32(&exynos_dmc->timingref, mem->timing_ref); + write32(&exynos_dmc->timingrow, mem->timing_row); + write32(&exynos_dmc->timingdata, mem->timing_data); + write32(&exynos_dmc->timingpower, mem->timing_power); /* Send PALL command */ dmc_config_prech(mem, exynos_dmc); @@ -162,19 +162,19 @@ int ddr3_mem_ctrl_init(struct mem_timings *mem, unsigned long mem_iv_size, if (mem->gate_leveling_enable) { val = PHY_CON0_RESET_VAL; val |= P0_CMD_EN; - writel(val, &exynos_phy0_control->phy_con0); - writel(val, &exynos_phy1_control->phy_con0); + write32(&exynos_phy0_control->phy_con0, val); + write32(&exynos_phy1_control->phy_con0, val); val = PHY_CON2_RESET_VAL; val |= INIT_DESKEW_EN; - writel(val, &exynos_phy0_control->phy_con2); - writel(val, &exynos_phy1_control->phy_con2); + write32(&exynos_phy0_control->phy_con2, val); + write32(&exynos_phy1_control->phy_con2, val); val = PHY_CON0_RESET_VAL; val |= P0_CMD_EN; val |= BYTE_RDLVL_EN; - writel(val, &exynos_phy0_control->phy_con0); - writel(val, &exynos_phy1_control->phy_con0); + write32(&exynos_phy0_control->phy_con0, val); + write32(&exynos_phy1_control->phy_con0, val); val = (mem->ctrl_start_point << PHY_CON12_CTRL_START_POINT_SHIFT) | @@ -182,30 +182,30 @@ int ddr3_mem_ctrl_init(struct mem_timings *mem, unsigned long mem_iv_size, (mem->ctrl_force << PHY_CON12_CTRL_FORCE_SHIFT) | (mem->ctrl_start << PHY_CON12_CTRL_START_SHIFT) | (mem->ctrl_ref << PHY_CON12_CTRL_REF_SHIFT); - writel(val, &exynos_phy0_control->phy_con12); - writel(val, &exynos_phy1_control->phy_con12); + write32(&exynos_phy0_control->phy_con12, val); + write32(&exynos_phy1_control->phy_con12, val); val = PHY_CON2_RESET_VAL; val |= INIT_DESKEW_EN; val |= RDLVL_GATE_EN; - writel(val, &exynos_phy0_control->phy_con2); - writel(val, &exynos_phy1_control->phy_con2); + write32(&exynos_phy0_control->phy_con2, val); + write32(&exynos_phy1_control->phy_con2, val); val = PHY_CON0_RESET_VAL; val |= P0_CMD_EN; val |= BYTE_RDLVL_EN; val |= CTRL_SHGATE; - writel(val, &exynos_phy0_control->phy_con0); - writel(val, &exynos_phy1_control->phy_con0); + write32(&exynos_phy0_control->phy_con0, val); + write32(&exynos_phy1_control->phy_con0, val); val = PHY_CON1_RESET_VAL; val &= ~(CTRL_GATEDURADJ_MASK); - writel(val, &exynos_phy0_control->phy_con1); - writel(val, &exynos_phy1_control->phy_con1); + write32(&exynos_phy0_control->phy_con1, val); + write32(&exynos_phy1_control->phy_con1, val); - writel(CTRL_RDLVL_GATE_ENABLE, &exynos_dmc->rdlvl_config); + write32(&exynos_dmc->rdlvl_config, CTRL_RDLVL_GATE_ENABLE); i = RDLVL_COMPLETE_TIMEOUT; - while ((readl(&exynos_dmc->phystatus) & + while ((read32(&exynos_dmc->phystatus) & (RDLVL_COMPLETE_CHO | RDLVL_COMPLETE_CH1)) != (RDLVL_COMPLETE_CHO | RDLVL_COMPLETE_CH1) && i > 0) { /* @@ -219,10 +219,10 @@ int ddr3_mem_ctrl_init(struct mem_timings *mem, unsigned long mem_iv_size, printk(BIOS_EMERG, "Timeout on RDLVL. No DRAM.\n"); return SETUP_ERR_RDLV_COMPLETE_TIMEOUT; } - writel(CTRL_RDLVL_GATE_DISABLE, &exynos_dmc->rdlvl_config); + write32(&exynos_dmc->rdlvl_config, CTRL_RDLVL_GATE_DISABLE); - writel(0, &exynos_phy0_control->phy_con14); - writel(0, &exynos_phy1_control->phy_con14); + write32(&exynos_phy0_control->phy_con14, 0); + write32(&exynos_phy1_control->phy_con14, 0); val = (mem->ctrl_start_point << PHY_CON12_CTRL_START_POINT_SHIFT) | @@ -231,8 +231,8 @@ int ddr3_mem_ctrl_init(struct mem_timings *mem, unsigned long mem_iv_size, (mem->ctrl_start << PHY_CON12_CTRL_START_SHIFT) | (mem->ctrl_dll_on << PHY_CON12_CTRL_DLL_ON_SHIFT) | (mem->ctrl_ref << PHY_CON12_CTRL_REF_SHIFT); - writel(val, &exynos_phy0_control->phy_con12); - writel(val, &exynos_phy1_control->phy_con12); + write32(&exynos_phy0_control->phy_con12, val); + write32(&exynos_phy1_control->phy_con12, val); update_reset_dll(exynos_dmc, DDR_MODE_DDR3); } @@ -240,11 +240,10 @@ int ddr3_mem_ctrl_init(struct mem_timings *mem, unsigned long mem_iv_size, /* Send PALL command */ dmc_config_prech(mem, exynos_dmc); - writel(mem->memcontrol, &exynos_dmc->memcontrol); + write32(&exynos_dmc->memcontrol, mem->memcontrol); /* Set DMC Concontrol and enable auto-refresh counter */ - writel(mem->concontrol | (mem->rd_fetch << CONCONTROL_RD_FETCH_SHIFT) - | (mem->aref_en << CONCONTROL_AREF_EN_SHIFT), - &exynos_dmc->concontrol); + write32(&exynos_dmc->concontrol, + mem->concontrol | (mem->rd_fetch << CONCONTROL_RD_FETCH_SHIFT) | (mem->aref_en << CONCONTROL_AREF_EN_SHIFT)); return 0; } diff --git a/src/soc/samsung/exynos5250/dp-reg.c b/src/soc/samsung/exynos5250/dp-reg.c index a2c0aa482d..75dadba022 100644 --- a/src/soc/samsung/exynos5250/dp-reg.c +++ b/src/soc/samsung/exynos5250/dp-reg.c @@ -35,7 +35,7 @@ void s5p_dp_reset(struct s5p_dp_device *dp) u32 reg; struct exynos5_dp *base = dp->base; - writel(RESET_DP_TX, &base->dp_tx_sw_reset); + write32(&base->dp_tx_sw_reset, RESET_DP_TX); /* Stop Video */ clrbits_le32(&base->video_ctl_1, VIDEO_EN); @@ -44,73 +44,73 @@ void s5p_dp_reset(struct s5p_dp_device *dp) reg = MASTER_VID_FUNC_EN_N | SLAVE_VID_FUNC_EN_N | AUD_FIFO_FUNC_EN_N | AUD_FUNC_EN_N | HDCP_FUNC_EN_N | SW_FUNC_EN_N; - writel(reg, &base->func_en_1); + write32(&base->func_en_1, reg); reg = SSC_FUNC_EN_N | AUX_FUNC_EN_N | SERDES_FIFO_FUNC_EN_N | LS_CLK_DOMAIN_FUNC_EN_N; - writel(reg, &base->func_en_2); + write32(&base->func_en_2, reg); udelay(20); reg = LANE3_MAP_LOGIC_LANE_3 | LANE2_MAP_LOGIC_LANE_2 | LANE1_MAP_LOGIC_LANE_1 | LANE0_MAP_LOGIC_LANE_0; - writel(reg, &base->lane_map); + write32(&base->lane_map, reg); - writel(0x0, &base->sys_ctl_1); - writel(0x40, &base->sys_ctl_2); - writel(0x0, &base->sys_ctl_3); - writel(0x0, &base->sys_ctl_4); + write32(&base->sys_ctl_1, 0x0); + write32(&base->sys_ctl_2, 0x40); + write32(&base->sys_ctl_3, 0x0); + write32(&base->sys_ctl_4, 0x0); - writel(0x0, &base->pkt_send_ctl); - writel(0x0, &base->dp_hdcp_ctl); + write32(&base->pkt_send_ctl, 0x0); + write32(&base->dp_hdcp_ctl, 0x0); - writel(0x5e, &base->dp_hpd_deglitch_l); - writel(0x1a, &base->dp_hpd_deglitch_h); + write32(&base->dp_hpd_deglitch_l, 0x5e); + write32(&base->dp_hpd_deglitch_h, 0x1a); - writel(0x10, &base->dp_debug_ctl); + write32(&base->dp_debug_ctl, 0x10); - writel(0x0, &base->dp_phy_test); + write32(&base->dp_phy_test, 0x0); - writel(0x0, &base->dp_video_fifo_thrd); - writel(0x20, &base->dp_audio_margin); + write32(&base->dp_video_fifo_thrd, 0x0); + write32(&base->dp_audio_margin, 0x20); - writel(0x4, &base->m_vid_gen_filter_th); - writel(0x2, &base->m_aud_gen_filter_th); + write32(&base->m_vid_gen_filter_th, 0x4); + write32(&base->m_aud_gen_filter_th, 0x2); - writel(0x00000101, &base->soc_general_ctl); + write32(&base->soc_general_ctl, 0x00000101); /* Set Analog Parameters */ - writel(0x10, &base->analog_ctl_1); - writel(0x0C, &base->analog_ctl_2); - writel(0x85, &base->analog_ctl_3); - writel(0x66, &base->pll_filter_ctl_1); - writel(0x0, &base->tx_amp_tuning_ctl); + write32(&base->analog_ctl_1, 0x10); + write32(&base->analog_ctl_2, 0x0C); + write32(&base->analog_ctl_3, 0x85); + write32(&base->pll_filter_ctl_1, 0x66); + write32(&base->tx_amp_tuning_ctl, 0x0); /* Set interrupt pin assertion polarity as high */ - writel(INT_POL0 | INT_POL1, &base->int_ctl); + write32(&base->int_ctl, INT_POL0 | INT_POL1); /* Clear pending registers */ - writel(0xff, &base->common_int_sta_1); - writel(0x4f, &base->common_int_sta_2); - writel(0xe0, &base->common_int_sta_3); - writel(0xe7, &base->common_int_sta_4); - writel(0x63, &base->dp_int_sta); + write32(&base->common_int_sta_1, 0xff); + write32(&base->common_int_sta_2, 0x4f); + write32(&base->common_int_sta_3, 0xe0); + write32(&base->common_int_sta_4, 0xe7); + write32(&base->dp_int_sta, 0x63); /* 0:mask,1: unmask */ - writel(0x00, &base->common_int_mask_1); - writel(0x00, &base->common_int_mask_2); - writel(0x00, &base->common_int_mask_3); - writel(0x00, &base->common_int_mask_4); - writel(0x00, &base->int_sta_mask); + write32(&base->common_int_mask_1, 0x00); + write32(&base->common_int_mask_2, 0x00); + write32(&base->common_int_mask_3, 0x00); + write32(&base->common_int_mask_4, 0x00); + write32(&base->int_sta_mask, 0x00); } unsigned int s5p_dp_get_pll_lock_status(struct s5p_dp_device *dp) { u32 reg; - reg = readl(&dp->base->dp_debug_ctl); + reg = read32(&dp->base->dp_debug_ctl); if (reg & PLL_LOCK) return PLL_LOCKED; else @@ -123,10 +123,10 @@ int s5p_dp_init_analog_func(struct s5p_dp_device *dp) struct stopwatch sw; struct exynos5_dp *base = dp->base; - writel(0x00, &base->dp_phy_pd); + write32(&base->dp_phy_pd, 0x00); reg = PLL_LOCK_CHG; - writel(reg, &base->common_int_sta_1); + write32(&base->common_int_sta_1, reg); clrbits_le32(&base->dp_debug_ctl, (F_PLL_LOCK | PLL_LOCK_CTRL)); @@ -159,7 +159,7 @@ void s5p_dp_init_aux(struct s5p_dp_device *dp) /* Clear interrupts related to AUX channel */ reg = RPLY_RECEIV | AUX_ERR; - writel(reg, &base->dp_int_sta); + write32(&base->dp_int_sta, reg); /* Disable AUX channel module */ setbits_le32(&base->func_en_2, AUX_FUNC_EN_N); @@ -168,12 +168,12 @@ void s5p_dp_init_aux(struct s5p_dp_device *dp) reg = (3 & AUX_BIT_PERIOD_MASK) << AUX_BIT_PERIOD_SHIFT; reg |= (0 & AUX_HW_RETRY_COUNT_MASK) << AUX_HW_RETRY_COUNT_SHIFT; reg |= (AUX_HW_RETRY_INTERVAL_600_US << AUX_HW_RETRY_INTERVAL_SHIFT); - writel(reg, &base->aux_hw_retry_ctl) ; + write32(&base->aux_hw_retry_ctl, reg); /* Receive AUX Channel DEFER commands equal to DEFFER_COUNT*64 */ reg = DEFER_CTRL_EN; reg |= (1 & DEFER_COUNT_MASK) << DEFER_COUNT_SHIFT; - writel(reg, &base->aux_ch_defer_dtl); + write32(&base->aux_ch_defer_dtl, reg); /* Enable AUX channel module */ clrbits_le32(&base->func_en_2, AUX_FUNC_EN_N); @@ -188,24 +188,24 @@ int s5p_dp_start_aux_transaction(struct s5p_dp_device *dp) setbits_le32(&base->aux_ch_ctl_2, AUX_EN); /* Is AUX CH command reply received? */ - reg = readl(&base->dp_int_sta); + reg = read32(&base->dp_int_sta); while (!(reg & RPLY_RECEIV)) - reg = readl(&base->dp_int_sta); + reg = read32(&base->dp_int_sta); /* Clear interrupt source for AUX CH command reply */ - writel(RPLY_RECEIV, &base->dp_int_sta); + write32(&base->dp_int_sta, RPLY_RECEIV); /* Clear interrupt source for AUX CH access error */ - reg = readl(&base->dp_int_sta); + reg = read32(&base->dp_int_sta); if (reg & AUX_ERR) { printk(BIOS_ERR, "%s: AUX_ERR encountered, dp_int_sta: " "0x%02x\n", __func__, reg); - writel(AUX_ERR, &base->dp_int_sta); + write32(&base->dp_int_sta, AUX_ERR); return -1; } /* Check AUX CH error access status */ - reg = readl(&base->dp_int_sta); + reg = read32(&base->dp_int_sta); if ((reg & AUX_STATUS_MASK) != 0) { printk(BIOS_ERR, "AUX CH error happens: %d\n\n", reg & AUX_STATUS_MASK); @@ -226,22 +226,22 @@ int s5p_dp_write_byte_to_dpcd(struct s5p_dp_device *dp, for (i = 0; i < MAX_AUX_RETRY_COUNT; i++) { /* Clear AUX CH data buffer */ - writel(BUF_CLR, &base->buf_data_ctl); + write32(&base->buf_data_ctl, BUF_CLR); /* Select DPCD device address */ reg = reg_addr >> AUX_ADDR_7_0_SHIFT; reg &= AUX_ADDR_7_0_MASK; - writel(reg, &base->aux_addr_7_0); + write32(&base->aux_addr_7_0, reg); reg = reg_addr >> AUX_ADDR_15_8_SHIFT; reg &= AUX_ADDR_15_8_MASK; - writel(reg, &base->aux_addr_15_8); + write32(&base->aux_addr_15_8, reg); reg = reg_addr >> AUX_ADDR_19_16_SHIFT; reg &= AUX_ADDR_19_16_MASK; - writel(reg, &base->aux_addr_19_16); + write32(&base->aux_addr_19_16, reg); /* Write data buffer */ reg = (unsigned int)data; - writel(reg, &base->buf_data_0); + write32(&base->buf_data_0, reg); /* * Set DisplayPort transaction and write 1 byte @@ -249,7 +249,7 @@ int s5p_dp_write_byte_to_dpcd(struct s5p_dp_device *dp, * If Bit 3 is 0, I2C transaction. */ reg = AUX_TX_COMM_DP_TRANSACTION | AUX_TX_COMM_WRITE; - writel(reg, &base->aux_ch_ctl_1); + write32(&base->aux_ch_ctl_1, reg); /* Start AUX transaction */ retval = s5p_dp_start_aux_transaction(dp); @@ -273,18 +273,18 @@ int s5p_dp_read_byte_from_dpcd(struct s5p_dp_device *dp, for (i = 0; i < MAX_AUX_RETRY_COUNT; i++) { /* Clear AUX CH data buffer */ - writel(BUF_CLR, &base->buf_data_ctl); + write32(&base->buf_data_ctl, BUF_CLR); /* Select DPCD device address */ reg = reg_addr >> AUX_ADDR_7_0_SHIFT; reg &= AUX_ADDR_7_0_MASK; - writel(reg, &base->aux_addr_7_0); + write32(&base->aux_addr_7_0, reg); reg = reg_addr >> AUX_ADDR_15_8_SHIFT; reg &= AUX_ADDR_15_8_MASK; - writel(reg, &base->aux_addr_15_8); + write32(&base->aux_addr_15_8, reg); reg = reg_addr >> AUX_ADDR_19_16_SHIFT; reg &= AUX_ADDR_19_16_MASK; - writel(reg, &base->aux_addr_19_16); + write32(&base->aux_addr_19_16, reg); /* * Set DisplayPort transaction and read 1 byte @@ -292,7 +292,7 @@ int s5p_dp_read_byte_from_dpcd(struct s5p_dp_device *dp, * If Bit 3 is 0, I2C transaction. */ reg = AUX_TX_COMM_DP_TRANSACTION | AUX_TX_COMM_READ; - writel(reg, &base->aux_ch_ctl_1); + write32(&base->aux_ch_ctl_1, reg); /* Start AUX transaction */ retval = s5p_dp_start_aux_transaction(dp); @@ -304,7 +304,7 @@ int s5p_dp_read_byte_from_dpcd(struct s5p_dp_device *dp, /* Read data buffer */ if (!retval) { - reg = readl(&base->buf_data_0); + reg = read32(&base->buf_data_0); *data = (unsigned char)(reg & 0xff); } @@ -317,17 +317,17 @@ void s5p_dp_init_video(struct s5p_dp_device *dp) struct exynos5_dp *base = dp->base; reg = VSYNC_DET | VID_FORMAT_CHG | VID_CLK_CHG; - writel(reg, &base->common_int_sta_1); + write32(&base->common_int_sta_1, reg); reg = 0x0; - writel(reg, &base->sys_ctl_1); + write32(&base->sys_ctl_1, reg); reg = (4 & CHA_CRI_MASK) << CHA_CRI_SHIFT; reg |= CHA_CTRL; - writel(reg, &base->sys_ctl_2); + write32(&base->sys_ctl_2, reg); reg = 0x0; - writel(reg, &base->sys_ctl_3); + write32(&base->sys_ctl_3, reg); } void s5p_dp_set_video_color_format(struct s5p_dp_device *dp, @@ -343,16 +343,16 @@ void s5p_dp_set_video_color_format(struct s5p_dp_device *dp, reg = (dynamic_range << IN_D_RANGE_SHIFT) | (color_depth << IN_BPC_SHIFT) | (color_space << IN_COLOR_F_SHIFT); - writel(reg, &base->video_ctl_2); + write32(&base->video_ctl_2, reg); /* Set Input Color YCbCr Coefficients to ITU601 or ITU709 */ - reg = readl(&base->video_ctl_3); + reg = read32(&base->video_ctl_3); reg &= ~IN_YC_COEFFI_MASK; if (coeff) reg |= IN_YC_COEFFI_ITU709; else reg |= IN_YC_COEFFI_ITU601; - writel(reg, &base->video_ctl_3); + write32(&base->video_ctl_3, reg); } int s5p_dp_is_slave_video_stream_clock_on(struct s5p_dp_device *dp) @@ -360,18 +360,18 @@ int s5p_dp_is_slave_video_stream_clock_on(struct s5p_dp_device *dp) u32 reg; struct exynos5_dp *base = dp->base; - reg = readl(&base->sys_ctl_1); - writel(reg, &base->sys_ctl_1); + reg = read32(&base->sys_ctl_1); + write32(&base->sys_ctl_1, reg); - reg = readl(&base->sys_ctl_1); + reg = read32(&base->sys_ctl_1); if (!(reg & DET_STA)) return -1; - reg = readl(&base->sys_ctl_2); - writel(reg, &base->sys_ctl_2); + reg = read32(&base->sys_ctl_2); + write32(&base->sys_ctl_2, reg); - reg = readl(&base->sys_ctl_2); + reg = read32(&base->sys_ctl_2); if (reg & CHA_STA) { printk(BIOS_DEBUG, "Input stream clk is changing\n"); @@ -393,28 +393,28 @@ void s5p_dp_set_video_cr_mn(struct s5p_dp_device *dp, setbits_le32(&base->sys_ctl_4, FIX_M_VID); reg = m_value >> M_VID_0_VALUE_SHIFT; - writel(reg, &base->m_vid_0); + write32(&base->m_vid_0, reg); reg = (m_value >> M_VID_1_VALUE_SHIFT); - writel(reg, &base->m_vid_1); + write32(&base->m_vid_1, reg); reg = (m_value >> M_VID_2_VALUE_SHIFT); - writel(reg, &base->m_vid_2); + write32(&base->m_vid_2, reg); reg = n_value >> N_VID_0_VALUE_SHIFT; - writel(reg, &base->n_vid_0); + write32(&base->n_vid_0, reg); reg = (n_value >> N_VID_1_VALUE_SHIFT); - writel(reg, &base->n_vid_1); + write32(&base->n_vid_1, reg); reg = (n_value >> N_VID_2_VALUE_SHIFT); - writel(reg, &base->n_vid_2); + write32(&base->n_vid_2, reg); } else { clrbits_le32(&base->sys_ctl_4, FIX_M_VID); - writel(0x00, &base->n_vid_0); - writel(0x80, &base->n_vid_1); - writel(0x00, &base->n_vid_2); + write32(&base->n_vid_0, 0x00); + write32(&base->n_vid_1, 0x80); + write32(&base->n_vid_2, 0x00); } } @@ -423,10 +423,10 @@ void s5p_dp_enable_video_master(struct s5p_dp_device *dp) u32 reg; struct exynos5_dp *base = dp->base; - reg = readl(&base->soc_general_ctl); + reg = read32(&base->soc_general_ctl); reg &= ~VIDEO_MODE_MASK; reg |= VIDEO_MODE_SLAVE_MODE; - writel(reg, &base->soc_general_ctl); + write32(&base->soc_general_ctl, reg); } int s5p_dp_is_video_stream_on(struct s5p_dp_device *dp) @@ -439,10 +439,10 @@ int s5p_dp_is_video_stream_on(struct s5p_dp_device *dp) stopwatch_init_msecs_expire(&sw, STREAM_ON_TIMEOUT); do { - reg = readl(&base->common_int_sta_1); + reg = read32(&base->common_int_sta_1); if (reg & VSYNC_DET) { i++; - writel(reg | VSYNC_DET, &base->common_int_sta_1); + write32(&base->common_int_sta_1, reg | VSYNC_DET); } if (i == 4) break; @@ -462,28 +462,28 @@ void s5p_dp_config_video_slave_mode(struct s5p_dp_device *dp, u32 reg; struct exynos5_dp *base = dp->base; - reg = readl(&base->func_en_1); + reg = read32(&base->func_en_1); reg &= ~(MASTER_VID_FUNC_EN_N|SLAVE_VID_FUNC_EN_N); reg |= MASTER_VID_FUNC_EN_N; - writel(reg, &base->func_en_1); + write32(&base->func_en_1, reg); - reg = readl(&base->video_ctl_10); + reg = read32(&base->video_ctl_10); reg &= ~INTERACE_SCAN_CFG; reg |= (video_info->interlaced << 2); - writel(reg, &base->video_ctl_10); + write32(&base->video_ctl_10, reg); - reg = readl(&base->video_ctl_10); + reg = read32(&base->video_ctl_10); reg &= ~VSYNC_POLARITY_CFG; reg |= (video_info->v_sync_polarity << 1); - writel(reg, &base->video_ctl_10); + write32(&base->video_ctl_10, reg); - reg = readl(&base->video_ctl_10); + reg = read32(&base->video_ctl_10); reg &= ~HSYNC_POLARITY_CFG; reg |= (video_info->h_sync_polarity << 0); - writel(reg, &base->video_ctl_10); + write32(&base->video_ctl_10, reg); reg = AUDIO_MODE_SPDIF_MODE | VIDEO_MODE_SLAVE_MODE; - writel(reg, &base->soc_general_ctl); + write32(&base->soc_general_ctl, reg); } void s5p_dp_wait_hw_link_training_done(struct s5p_dp_device *dp) @@ -491,7 +491,7 @@ void s5p_dp_wait_hw_link_training_done(struct s5p_dp_device *dp) u32 reg; struct exynos5_dp *base = dp->base; - reg = readl(&base->dp_hw_link_training); + reg = read32(&base->dp_hw_link_training); while (reg & HW_TRAINING_EN) - reg = readl(&base->dp_hw_link_training); + reg = read32(&base->dp_hw_link_training); } diff --git a/src/soc/samsung/exynos5250/fb.c b/src/soc/samsung/exynos5250/fb.c index 3c7c5ef27b..befb0debf0 100644 --- a/src/soc/samsung/exynos5250/fb.c +++ b/src/soc/samsung/exynos5250/fb.c @@ -122,48 +122,48 @@ void fb_init(unsigned long int fb_size, void *lcdbase, fb_size = ALIGN(fb_size, 4096); - writel(pd->ivclk | pd->fixvclk, &exynos_disp_ctrl->vidcon1); + write32(&exynos_disp_ctrl->vidcon1, pd->ivclk | pd->fixvclk); val = ENVID_ON | ENVID_F_ON | (pd->clkval_f << CLKVAL_F_OFFSET); - writel(val, &exynos_fimd->vidcon0); + write32(&exynos_fimd->vidcon0, val); val = (pd->vsync << VSYNC_PULSE_WIDTH_OFFSET) | (pd->lower_margin << V_FRONT_PORCH_OFFSET) | (pd->upper_margin << V_BACK_PORCH_OFFSET); - writel(val, &exynos_disp_ctrl->vidtcon0); + write32(&exynos_disp_ctrl->vidtcon0, val); val = (pd->hsync << HSYNC_PULSE_WIDTH_OFFSET) | (pd->right_margin << H_FRONT_PORCH_OFFSET) | (pd->left_margin << H_BACK_PORCH_OFFSET); - writel(val, &exynos_disp_ctrl->vidtcon1); + write32(&exynos_disp_ctrl->vidtcon1, val); val = ((pd->xres - 1) << HOZVAL_OFFSET) | ((pd->yres - 1) << LINEVAL_OFFSET); - writel(val, &exynos_disp_ctrl->vidtcon2); + write32(&exynos_disp_ctrl->vidtcon2, val); - writel((unsigned int)lcdbase, &exynos_fimd->vidw00add0b0); - writel((unsigned int)lcdbase + fb_size, &exynos_fimd->vidw00add1b0); + write32(&exynos_fimd->vidw00add0b0, (unsigned int)lcdbase); + write32(&exynos_fimd->vidw00add1b0, (unsigned int)lcdbase + fb_size); - writel(pd->xres * 2, &exynos_fimd->vidw00add2); + write32(&exynos_fimd->vidw00add2, pd->xres * 2); val = ((pd->xres - 1) << OSD_RIGHTBOTX_F_OFFSET); val |= ((pd->yres - 1) << OSD_RIGHTBOTY_F_OFFSET); - writel(val, &exynos_fimd->vidosd0b); - writel(pd->xres * pd->yres, &exynos_fimd->vidosd0c); + write32(&exynos_fimd->vidosd0b, val); + write32(&exynos_fimd->vidosd0c, pd->xres * pd->yres); setbits_le32(&exynos_fimd->shadowcon, CHANNEL0_EN); val = BPPMODE_F_RGB_16BIT_565 << BPPMODE_F_OFFSET; val |= ENWIN_F_ENABLE | HALF_WORD_SWAP_EN; - writel(val, &exynos_fimd->wincon0); + write32(&exynos_fimd->wincon0, val); /* DPCLKCON_ENABLE */ - writel(1 << 1, &exynos_fimd->dpclkcon); + write32(&exynos_fimd->dpclkcon, 1 << 1); } #ifdef UNUSED_CODE void exynos_fimd_disable(void) { - writel(0, &exynos_fimd->wincon0); + write32(&exynos_fimd->wincon0, 0); clrbits_le32(&exynos_fimd->shadowcon, CHANNEL0_EN); } #endif @@ -328,18 +328,18 @@ static int s5p_dp_set_lane_lane_pre_emphasis(struct s5p_dp_device *dp, reg = pre_emphasis << PRE_EMPHASIS_SET_SHIFT; switch (lane) { case 0: - writel(reg, &base->ln0_link_trn_ctl); + write32(&base->ln0_link_trn_ctl, reg); break; case 1: - writel(reg, &base->ln1_link_trn_ctl); + write32(&base->ln1_link_trn_ctl, reg); break; case 2: - writel(reg, &base->ln2_link_trn_ctl); + write32(&base->ln2_link_trn_ctl, reg); break; case 3: - writel(reg, &base->ln3_link_trn_ctl); + write32(&base->ln3_link_trn_ctl, reg); break; default: printk(BIOS_DEBUG, "%s: Invalid lane %d\n", __func__, lane); @@ -432,7 +432,7 @@ static int s5p_dp_hw_link_training(struct s5p_dp_device *dp, } /* All DP analog module power up */ - writel(0x00, &base->dp_phy_pd); + write32(&base->dp_phy_pd, 0x00); /* Initialize by reading RX's DPCD */ s5p_dp_get_max_rx_bandwidth(dp, &dp->link_train.link_rate); @@ -463,21 +463,21 @@ static int s5p_dp_hw_link_training(struct s5p_dp_device *dp, dp->link_train.link_rate = max_rate; /* Set link rate and count as you want to establish*/ - writel(dp->link_train.lane_count, &base->lane_count_set); - writel(dp->link_train.link_rate, &base->link_bw_set); + write32(&base->lane_count_set, dp->link_train.lane_count); + write32(&base->link_bw_set, dp->link_train.link_rate); /* Set sink to D0 (Sink Not Ready) mode. */ s5p_dp_write_byte_to_dpcd(dp, DPCD_ADDR_SINK_POWER_STATE, DPCD_SET_POWER_STATE_D0); /* Start HW link training */ - writel(HW_TRAINING_EN, &base->dp_hw_link_training); + write32(&base->dp_hw_link_training, HW_TRAINING_EN); /* Wait until HW link training done */ s5p_dp_wait_hw_link_training_done(dp); /* Get hardware link training status */ - data = readl(&base->dp_hw_link_training); + data = read32(&base->dp_hw_link_training); printk(BIOS_SPEW, "hardware link training status: 0x%08x\n", data); if (data != 0) { printk(BIOS_ERR, " H/W link training failure: 0x%x\n", data); @@ -485,11 +485,11 @@ static int s5p_dp_hw_link_training(struct s5p_dp_device *dp, } /* Get Link Bandwidth */ - data = readl(&base->link_bw_set); + data = read32(&base->link_bw_set); dp->link_train.link_rate = data; - data = readl(&base->lane_count_set); + data = read32(&base->lane_count_set); dp->link_train.lane_count = data; printk(BIOS_SPEW, "Done training: Link bandwidth: 0x%x, lane_count: %d\n", dp->link_train.link_rate, data); @@ -541,8 +541,8 @@ int dp_controller_init(struct s5p_dp_device *dp_device) /* Enable enhanced mode */ setbits_le32(&base->sys_ctl_4, ENHANCED); - writel(dp->link_train.lane_count, &base->lane_count_set); - writel(dp->link_train.link_rate, &base->link_bw_set); + write32(&base->lane_count_set, dp->link_train.lane_count); + write32(&base->link_bw_set, dp->link_train.link_rate); s5p_dp_init_video(dp); ret = s5p_dp_config_video(dp, dp->video_info); diff --git a/src/soc/samsung/exynos5250/gpio.c b/src/soc/samsung/exynos5250/gpio.c index 203aa03a42..c7a84197d0 100644 --- a/src/soc/samsung/exynos5250/gpio.c +++ b/src/soc/samsung/exynos5250/gpio.c @@ -82,10 +82,10 @@ void gpio_cfg_pin(int gpio, int cfg) unsigned int value; struct gpio_bank *bank = gpio_get_bank(gpio); - value = readl(&bank->con); + value = read32(&bank->con); value &= ~CON_MASK(GPIO_BIT(gpio)); value |= CON_SFR(GPIO_BIT(gpio), cfg); - writel(value, &bank->con); + write32(&bank->con, value); } static int gpio_get_cfg(int gpio) @@ -93,7 +93,7 @@ static int gpio_get_cfg(int gpio) struct gpio_bank *bank = gpio_get_bank(gpio); int shift = GPIO_BIT(gpio) << 2; - return (readl(&bank->con) & CON_MASK(GPIO_BIT(gpio))) >> shift; + return (read32(&bank->con) & CON_MASK(GPIO_BIT(gpio))) >> shift; } void gpio_set_pull(int gpio, int mode) @@ -101,7 +101,7 @@ void gpio_set_pull(int gpio, int mode) unsigned int value; struct gpio_bank *bank = gpio_get_bank(gpio); - value = readl(&bank->pull); + value = read32(&bank->pull); value &= ~PULL_MASK(GPIO_BIT(gpio)); switch (mode) { @@ -113,7 +113,7 @@ void gpio_set_pull(int gpio, int mode) break; } - writel(value, &bank->pull); + write32(&bank->pull, value); } void gpio_set_drv(int gpio, int mode) @@ -121,7 +121,7 @@ void gpio_set_drv(int gpio, int mode) unsigned int value; struct gpio_bank *bank = gpio_get_bank(gpio); - value = readl(&bank->drv); + value = read32(&bank->drv); value &= ~DRV_MASK(GPIO_BIT(gpio)); switch (mode) { @@ -135,7 +135,7 @@ void gpio_set_drv(int gpio, int mode) return; } - writel(value, &bank->drv); + write32(&bank->drv, value); } void gpio_set_rate(int gpio, int mode) @@ -143,7 +143,7 @@ void gpio_set_rate(int gpio, int mode) unsigned int value; struct gpio_bank *bank = gpio_get_bank(gpio); - value = readl(&bank->drv); + value = read32(&bank->drv); value &= ~RATE_MASK(GPIO_BIT(gpio)); switch (mode) { @@ -155,7 +155,7 @@ void gpio_set_rate(int gpio, int mode) return; } - writel(value, &bank->drv); + write32(&bank->drv, value); } int gpio_direction_input(unsigned gpio) @@ -170,11 +170,11 @@ int gpio_direction_output(unsigned gpio, int value) unsigned int val; struct gpio_bank *bank = gpio_get_bank(gpio); - val = readl(&bank->dat); + val = read32(&bank->dat); val &= ~DAT_MASK(GPIO_BIT(gpio)); if (value) val |= DAT_SET(GPIO_BIT(gpio)); - writel(val, &bank->dat); + write32(&bank->dat, val); gpio_cfg_pin(gpio, GPIO_OUTPUT); @@ -186,7 +186,7 @@ int gpio_get_value(unsigned gpio) unsigned int value; struct gpio_bank *bank = gpio_get_bank(gpio); - value = readl(&bank->dat); + value = read32(&bank->dat); return !!(value & DAT_MASK(GPIO_BIT(gpio))); } @@ -195,11 +195,11 @@ int gpio_set_value(unsigned gpio, int value) unsigned int val; struct gpio_bank *bank = gpio_get_bank(gpio); - val = readl(&bank->dat); + val = read32(&bank->dat); val &= ~DAT_MASK(GPIO_BIT(gpio)); if (value) val |= DAT_SET(GPIO_BIT(gpio)); - writel(val, &bank->dat); + write32(&bank->dat, val); return 0; } diff --git a/src/soc/samsung/exynos5250/i2c.c b/src/soc/samsung/exynos5250/i2c.c index f92182a77a..e9eed406e5 100644 --- a/src/soc/samsung/exynos5250/i2c.c +++ b/src/soc/samsung/exynos5250/i2c.c @@ -117,34 +117,34 @@ static struct s3c24x0_i2c_bus i2c_busses[] = { static int i2c_int_pending(struct i2c_regs *regs) { - return readb(®s->con) & I2cConIntPending; + return read8(®s->con) & I2cConIntPending; } static void i2c_clear_int(struct i2c_regs *regs) { - writeb(readb(®s->con) & ~I2cConIntPending, ®s->con); + write8(®s->con, read8(®s->con) & ~I2cConIntPending); } static void i2c_ack_enable(struct i2c_regs *regs) { - writeb(readb(®s->con) | I2cConAckGen, ®s->con); + write8(®s->con, read8(®s->con) | I2cConAckGen); } static void i2c_ack_disable(struct i2c_regs *regs) { - writeb(readb(®s->con) & ~I2cConAckGen, ®s->con); + write8(®s->con, read8(®s->con) & ~I2cConAckGen); } static int i2c_got_ack(struct i2c_regs *regs) { - return !(readb(®s->stat) & I2cStatAck); + return !(read8(®s->stat) & I2cStatAck); } static int i2c_wait_for_idle(struct i2c_regs *regs) { int timeout = 1000 * 100; // 1s. while (timeout--) { - if (!(readb(®s->stat) & I2cStatBusy)) + if (!(read8(®s->stat) & I2cStatBusy)) return 0; udelay(10); } @@ -169,17 +169,17 @@ static int i2c_wait_for_int(struct i2c_regs *regs) static int i2c_send_stop(struct i2c_regs *regs) { - uint8_t mode = readb(®s->stat) & (I2cStatModeMask); - writeb(mode | I2cStatEnable, ®s->stat); + uint8_t mode = read8(®s->stat) & (I2cStatModeMask); + write8(®s->stat, mode | I2cStatEnable); i2c_clear_int(regs); return i2c_wait_for_idle(regs); } static int i2c_send_start(struct i2c_regs *regs, int read, int chip) { - writeb(chip << 1, ®s->ds); + write8(®s->ds, chip << 1); uint8_t mode = read ? I2cStatMasterRecv : I2cStatMasterXmit; - writeb(mode | I2cStatStartStop | I2cStatEnable, ®s->stat); + write8(®s->stat, mode | I2cStatStartStop | I2cStatEnable); i2c_clear_int(regs); if (i2c_wait_for_int(regs)) @@ -201,7 +201,7 @@ static int i2c_xmit_buf(struct i2c_regs *regs, uint8_t *data, int len) int i; for (i = 0; i < len; i++) { - writeb(data[i], ®s->ds); + write8(®s->ds, data[i]); i2c_clear_int(regs); if (i2c_wait_for_int(regs)) @@ -231,7 +231,7 @@ static int i2c_recv_buf(struct i2c_regs *regs, uint8_t *data, int len) if (i2c_wait_for_int(regs)) return 1; - data[i] = readb(®s->ds); + data[i] = read8(®s->ds); } return 0; @@ -246,7 +246,7 @@ int platform_i2c_transfer(unsigned bus, struct i2c_seg *segments, int seg_count) if (!regs || i2c_wait_for_idle(regs)) return 1; - writeb(I2cStatMasterXmit | I2cStatEnable, ®s->stat); + write8(®s->stat, I2cStatMasterXmit | I2cStatEnable); int i; for (i = 0; i < seg_count; i++) { @@ -286,11 +286,11 @@ void i2c_init(unsigned bus, int speed, int slaveadd) // Set prescaler, divisor according to freq, also set ACKGEN, IRQ. val = (div & 0x0f) | 0xa0 | ((pres == 512) ? 0x40 : 0); - writel(val, &i2c->regs->con); + write32(&i2c->regs->con, val); // Init to SLAVE RECEIVE mode and clear I2CADDn. - writel(0, &i2c->regs->stat); - writel(slaveadd, &i2c->regs->add); + write32(&i2c->regs->stat, 0); + write32(&i2c->regs->add, slaveadd); // program Master Transmit (and implicit STOP). - writel(I2cStatMasterXmit | I2cStatEnable, &i2c->regs->stat); + write32(&i2c->regs->stat, I2cStatMasterXmit | I2cStatEnable); } diff --git a/src/soc/samsung/exynos5250/power.c b/src/soc/samsung/exynos5250/power.c index c7d491dd23..1b8aaa67d1 100644 --- a/src/soc/samsung/exynos5250/power.c +++ b/src/soc/samsung/exynos5250/power.c @@ -89,5 +89,5 @@ void power_enable_xclkout(void) void power_release_uart_retention(void) { - writel(1 << 28, &exynos_power->padret_uart_opt); + write32(&exynos_power->padret_uart_opt, 1 << 28); } diff --git a/src/soc/samsung/exynos5250/spi.c b/src/soc/samsung/exynos5250/spi.c index 33a8c740f7..fed3aa7518 100644 --- a/src/soc/samsung/exynos5250/spi.c +++ b/src/soc/samsung/exynos5250/spi.c @@ -46,25 +46,25 @@ static void exynos_spi_rx_tx(struct exynos_spi *regs, int todo, out_bytes = in_bytes = todo; setbits_le32(®s->ch_cfg, SPI_CH_RST); clrbits_le32(®s->ch_cfg, SPI_CH_RST); - writel(((todo * 8) / 32) | SPI_PACKET_CNT_EN, ®s->pkt_cnt); + write32(®s->pkt_cnt, ((todo * 8) / 32) | SPI_PACKET_CNT_EN); while (in_bytes) { uint32_t spi_sts; int temp; - spi_sts = readl(®s->spi_sts); + spi_sts = read32(®s->spi_sts); rx_lvl = ((spi_sts >> 15) & 0x7f); tx_lvl = ((spi_sts >> 6) & 0x7f); while (tx_lvl < 32 && out_bytes) { // TODO The "writing" (tx) is not supported now; that's // why we write garbage to keep driving FIFO clock. temp = 0xffffffff; - writel(temp, ®s->tx_data); + write32(®s->tx_data, temp); out_bytes -= 4; tx_lvl += 4; } while (rx_lvl >= 4 && in_bytes) { - temp = readl(®s->rx_data); + temp = read32(®s->rx_data); if (rxp) *rxp++ = temp; in_bytes -= 4; @@ -79,9 +79,9 @@ int exynos_spi_open(struct exynos_spi *regs) /* set the spi1 GPIO */ /* set pktcnt and enable it */ - writel(4 | SPI_PACKET_CNT_EN, ®s->pkt_cnt); + write32(®s->pkt_cnt, 4 | SPI_PACKET_CNT_EN); /* set FB_CLK_SEL */ - writel(SPI_FB_DELAY_180, ®s->fb_clk); + write32(®s->fb_clk, SPI_FB_DELAY_180); /* set CH_WIDTH and BUS_WIDTH as word */ setbits_le32(®s->mode_cfg, SPI_MODE_CH_WIDTH_WORD | SPI_MODE_BUS_WIDTH_WORD); @@ -109,10 +109,10 @@ int exynos_spi_read(struct exynos_spi *regs, void *dest, u32 len, u32 off) clrbits_le32(®s->cs_reg, SPI_SLAVE_SIG_INACT); /* CS low */ /* Send read instruction (0x3h) followed by a 24 bit addr */ - writel((SF_READ_DATA_CMD << 24) | off, ®s->tx_data); + write32(®s->tx_data, (SF_READ_DATA_CMD << 24) | off); /* waiting for TX done */ - while (!(readl(®s->spi_sts) & SPI_ST_TX_DONE)); + while (!(read32(®s->spi_sts) & SPI_ST_TX_DONE)); for (upto = 0, i = 0; upto < len; upto += todo, i++) { todo = MIN(len - upto, (1 << 15)); @@ -132,7 +132,7 @@ int exynos_spi_close(struct exynos_spi *regs) */ clrbits_le32(®s->mode_cfg, SPI_MODE_CH_WIDTH_WORD | SPI_MODE_BUS_WIDTH_WORD); - writel(0, ®s->swap_cfg); + write32(®s->swap_cfg, 0); /* * Flush spi tx, rx fifos and reset the SPI controller diff --git a/src/soc/samsung/exynos5250/timer.c b/src/soc/samsung/exynos5250/timer.c index 1e25771dbd..2abaf3bc5d 100644 --- a/src/soc/samsung/exynos5250/timer.c +++ b/src/soc/samsung/exynos5250/timer.c @@ -27,16 +27,15 @@ static const uint32_t clocks_per_usec = MCT_HZ/1000000; static uint64_t mct_raw_value(void) { - uint64_t upper = readl(&exynos_mct->g_cnt_u); - uint64_t lower = readl(&exynos_mct->g_cnt_l); + uint64_t upper = read32(&exynos_mct->g_cnt_u); + uint64_t lower = read32(&exynos_mct->g_cnt_l); return (upper << 32) | lower; } void init_timer(void) { - writel(readl(&exynos_mct->g_tcon) | (0x1 << 8), - &exynos_mct->g_tcon); + write32(&exynos_mct->g_tcon, read32(&exynos_mct->g_tcon) | (0x1 << 8)); } void timer_monotonic_get(struct mono_time *mt) diff --git a/src/soc/samsung/exynos5250/tmu.c b/src/soc/samsung/exynos5250/tmu.c index bde11a2550..51e7ad8894 100644 --- a/src/soc/samsung/exynos5250/tmu.c +++ b/src/soc/samsung/exynos5250/tmu.c @@ -80,7 +80,7 @@ static int get_cur_temp(struct tmu_info *info) struct tmu_reg *reg = (struct tmu_reg *)info->tmu_base; /* Temperature code range between min 25 and max 125 */ - cur_temp = readl(®->current_temp) & 0xff; + cur_temp = read32(®->current_temp) & 0xff; /* Calibrate current temperature */ if (cur_temp) @@ -142,10 +142,10 @@ static void tmu_setup_parameters(struct tmu_info *info) struct tmu_reg *reg = (struct tmu_reg *)info->tmu_base; /* Must reload for using efuse value at EXYNOS */ - writel(TRIMINFO_RELOAD, ®->triminfo_control); + write32(®->triminfo_control, TRIMINFO_RELOAD); /* Get the compensation parameter */ - te_temp = readl(®->triminfo); + te_temp = read32(®->triminfo); info->te1 = te_temp & TRIM_INFO_MASK; info->te2 = ((te_temp >> 8) & TRIM_INFO_MASK); @@ -169,8 +169,8 @@ static void tmu_setup_parameters(struct tmu_info *info) (hwtrip_code << 24)); /* Set interrupt level */ - writel(rising_value, ®->threshold_temp_rise); - writel(cooling_temp, ®->threshold_temp_fall); + write32(®->threshold_temp_rise, rising_value); + write32(®->threshold_temp_fall, cooling_temp); /* * Need to init all register settings after getting parameter info @@ -183,20 +183,20 @@ static void tmu_setup_parameters(struct tmu_info *info) * TODO(bhthompson): rewrite this code such that we are not performing * a hard wipe of tmu_control and re verify functionality. */ - writel(data->slope, ®->tmu_control); + write32(®->tmu_control, data->slope); - writel(INTCLEARALL, ®->intclear); + write32(®->intclear, INTCLEARALL); /* TMU core enable */ - con = readl(®->tmu_control); + con = read32(®->tmu_control); con |= (info->tmu_mux << 20) | THERM_TRIP_EN | CORE_EN; - writel(con, ®->tmu_control); + write32(®->tmu_control, con); /* Enable HW thermal trip */ power_enable_hw_thermal_trip(); /* LEV1 LEV2 interrupt enable */ - writel(INTEN_RISE1 | INTEN_RISE2, ®->inten); + write32(®->inten, INTEN_RISE1 | INTEN_RISE2); } /* diff --git a/src/soc/samsung/exynos5250/trustzone.c b/src/soc/samsung/exynos5250/trustzone.c index c4d3bc64b6..4a8141eeaf 100644 --- a/src/soc/samsung/exynos5250/trustzone.c +++ b/src/soc/samsung/exynos5250/trustzone.c @@ -31,14 +31,14 @@ void trustzone_init(void) tzpc = (struct exynos_tzpc *)addr; if (addr == TZPC0_BASE) - writel(R0SIZE, &tzpc->r0size); + write32(&tzpc->r0size, R0SIZE); - writel(DECPROTXSET, &tzpc->decprot0set); - writel(DECPROTXSET, &tzpc->decprot1set); + write32(&tzpc->decprot0set, DECPROTXSET); + write32(&tzpc->decprot1set, DECPROTXSET); if (addr != TZPC9_BASE) { - writel(DECPROTXSET, &tzpc->decprot2set); - writel(DECPROTXSET, &tzpc->decprot3set); + write32(&tzpc->decprot2set, DECPROTXSET); + write32(&tzpc->decprot3set, DECPROTXSET); } } } diff --git a/src/soc/samsung/exynos5250/uart.c b/src/soc/samsung/exynos5250/uart.c index c23cfed347..81386b7ec4 100644 --- a/src/soc/samsung/exynos5250/uart.c +++ b/src/soc/samsung/exynos5250/uart.c @@ -66,7 +66,7 @@ static void serial_setbrg_dev(struct s5p_uart *uart) uclk = clock_get_periph_rate(PERIPH_ID_UART3); val = uclk / default_baudrate(); - writel(val / 16 - 1, &uart->ubrdiv); + write32(&uart->ubrdiv, val / 16 - 1); /* * FIXME(dhendrix): the original uart.h had a "br_rest" value which @@ -91,12 +91,12 @@ static void exynos5_init_dev(struct s5p_uart *uart) exynos_pinmux_uart3(); /* enable FIFOs */ - writel(0x1, &uart->ufcon); - writel(0, &uart->umcon); + write32(&uart->ufcon, 0x1); + write32(&uart->umcon, 0); /* 8N1 */ - writel(0x3, &uart->ulcon); + write32(&uart->ulcon, 0x3); /* No interrupts, no DMA, pure polling */ - writel(0x245, &uart->ucon); + write32(&uart->ucon, 0x245); serial_setbrg_dev(uart); } @@ -117,7 +117,7 @@ static int exynos5_uart_err_check(struct s5p_uart *uart, int op) else mask = 0xf; - return readl(&uart->uerstat) & mask; + return read32(&uart->uerstat) & mask; } /* @@ -128,13 +128,13 @@ static int exynos5_uart_err_check(struct s5p_uart *uart, int op) static unsigned char exynos5_uart_rx_byte(struct s5p_uart *uart) { /* wait for character to arrive */ - while (!(readl(&uart->ufstat) & (RX_FIFO_COUNT_MASK | + while (!(read32(&uart->ufstat) & (RX_FIFO_COUNT_MASK | RX_FIFO_FULL_MASK))) { if (exynos5_uart_err_check(uart, 0)) return 0; } - return readb(&uart->urxh) & 0xff; + return read8(&uart->urxh) & 0xff; } /* @@ -143,17 +143,17 @@ static unsigned char exynos5_uart_rx_byte(struct s5p_uart *uart) static void exynos5_uart_tx_byte(struct s5p_uart *uart, unsigned char data) { /* wait for room in the tx FIFO */ - while ((readl(&uart->ufstat) & TX_FIFO_FULL_MASK)) { + while ((read32(&uart->ufstat) & TX_FIFO_FULL_MASK)) { if (exynos5_uart_err_check(uart, 1)) return; } - writeb(data, &uart->utxh); + write8(&uart->utxh, data); } static void exynos5_uart_tx_flush(struct s5p_uart *uart) { - while (readl(&uart->ufstat) & 0x1ff0000); + while (read32(&uart->ufstat) & 0x1ff0000); } uintptr_t uart_platform_base(int idx) diff --git a/src/soc/samsung/exynos5250/usb.c b/src/soc/samsung/exynos5250/usb.c index 8a91497e1f..3f6833657b 100644 --- a/src/soc/samsung/exynos5250/usb.c +++ b/src/soc/samsung/exynos5250/usb.c @@ -51,23 +51,13 @@ static void setup_dwc3(struct exynos5_usb_drd_dwc3 *dwc3) /* Set relevant registers to default values (clearing all reset bits) */ - writel(0x1 << 24 | /* activate PHY low power states */ - 0x4 << 19 | /* low power delay value */ - 0x1 << 18 | /* activate PHY low power delay */ - 0x1 << 17 | /* enable SuperSpeed PHY suspend */ - 0x1 << 1 | /* default Tx deemphasis value */ - 0, &dwc3->usb3pipectl); + write32(&dwc3->usb3pipectl, + 0x1 << 24 | 0x4 << 19 | 0x1 << 18 | 0x1 << 17 | 0x1 << 1 | 0); /* Configure PHY clock turnaround for 8-bit UTMI+, disable suspend */ - writel(0x9 << 10 | /* PHY clock turnaround for 8-bit UTMI+ */ - 0x1 << 8 | /* enable PHY sleep in L1 */ - 0x1 << 6 | /* enable PHY suspend */ - 0, &dwc3->usb2phycfg); - - writel(0x5dc << 19 | /* suspend clock scale for 24MHz */ - 0x1 << 16 | /* retry SS three times (bugfix from U-Boot) */ - 0x1 << 12 | /* port capability HOST */ - 0, &dwc3->ctl); + write32(&dwc3->usb2phycfg, 0x9 << 10 | 0x1 << 8 | 0x1 << 6 | 0); + + write32(&dwc3->ctl, 0x5dc << 19 | 0x1 << 16 | 0x1 << 12 | 0); } void setup_usb_drd_dwc3() @@ -84,44 +74,25 @@ static void setup_drd_phy(struct exynos5_usb_drd_phy *phy) setbits_le32(&phy->linksystem, 0x1 << 27 | 0x20 << 1); /* Disable OTG, ID0 and DRVVBUS, do not force sleep/suspend */ - writel(1 << 6, &phy->utmi); - - writel(0x88 << 23 | /* spread spectrum refclk selector */ - 0x1 << 20 | /* enable spread spectrum */ - 0x1 << 19 | /* enable prescaler refclk */ - 0x68 << 11 | /* multiplier for 24MHz refclk */ - 0x5 << 5 | /* select 24MHz refclk (weird, from U-Boot) */ - 0x1 << 4 | /* power supply in normal operating mode */ - 0x3 << 2 | /* use external refclk (undocumented on 5420?)*/ - 0x1 << 1 | /* force port reset */ - 0x1 << 0 | /* normal operating mode */ - 0, &phy->clkrst); - - writel(0x9 << 26 | /* LOS level */ - 0x3 << 22 | /* TX VREF tune */ - 0x1 << 20 | /* TX rise tune */ - 0x1 << 18 | /* TX res tune */ - 0x3 << 13 | /* TX HS X Vtune */ - 0x3 << 9 | /* TX FS/LS tune */ - 0x3 << 6 | /* SQRX tune */ - 0x4 << 3 | /* OTG tune */ - 0x4 << 0 | /* comp disc tune */ - 0, &phy->param0); - - writel(0x7f << 19 | /* reserved */ - 0x7f << 12 | /* Tx launch amplitude */ - 0x20 << 6 | /* Tx deemphasis 6dB */ - 0x1c << 0 | /* Tx deemphasis 3.5dB (value from U-Boot) */ - 0, &phy->param1); + write32(&phy->utmi, 1 << 6); + + write32(&phy->clkrst, + 0x88 << 23 | 0x1 << 20 | 0x1 << 19 | 0x68 << 11 | 0x5 << 5 | 0x1 << 4 | 0x3 << 2 | 0x1 << 1 | 0x1 << 0 | 0); + + write32(&phy->param0, + 0x9 << 26 | 0x3 << 22 | 0x1 << 20 | 0x1 << 18 | 0x3 << 13 | 0x3 << 9 | 0x3 << 6 | 0x4 << 3 | 0x4 << 0 | 0); + + write32(&phy->param1, + 0x7f << 19 | 0x7f << 12 | 0x20 << 6 | 0x1c << 0 | 0); /* disable all test features */ - writel(0, &phy->test); + write32(&phy->test, 0); /* UTMI clock select? ("must be 0x1") */ - writel(0x1 << 2, &phy->utmiclksel); + write32(&phy->utmiclksel, 0x1 << 2); /* Samsung magic, undocumented (from U-Boot) */ - writel(0x0, &phy->resume); + write32(&phy->resume, 0x0); udelay(10); clrbits_le32(&phy->clkrst, 0x1 << 1); /* deassert port reset */ @@ -144,7 +115,7 @@ void setup_usb_host_phy(int hsic_gpio) printk(BIOS_DEBUG, "Powering up USB HOST PHY (%s HSIC)\n", hsic_gpio ? "with" : "without"); - hostphy_ctrl0 = readl(&exynos_usb_host_phy->usbphyctrl0); + hostphy_ctrl0 = read32(&exynos_usb_host_phy->usbphyctrl0); hostphy_ctrl0 &= ~(HOST_CTRL0_FSEL_MASK | HOST_CTRL0_COMMONON_N | /* HOST Phy setting */ @@ -158,7 +129,7 @@ void setup_usb_host_phy(int hsic_gpio) /* HOST Phy setting */ HOST_CTRL0_LINKSWRST | HOST_CTRL0_UTMISWRST); - writel(hostphy_ctrl0, &exynos_usb_host_phy->usbphyctrl0); + write32(&exynos_usb_host_phy->usbphyctrl0, hostphy_ctrl0); udelay(10); clrbits_le32(&exynos_usb_host_phy->usbphyctrl0, HOST_CTRL0_LINKSWRST | -- cgit v1.2.3