summaryrefslogtreecommitdiff
path: root/src/soc/nvidia/tegra124
diff options
context:
space:
mode:
Diffstat (limited to 'src/soc/nvidia/tegra124')
-rw-r--r--src/soc/nvidia/tegra124/clock.c148
-rw-r--r--src/soc/nvidia/tegra124/display.c4
-rw-r--r--src/soc/nvidia/tegra124/lp0/tegra_lp0_resume.c85
-rw-r--r--src/soc/nvidia/tegra124/power.c6
-rw-r--r--src/soc/nvidia/tegra124/sdram.c532
-rw-r--r--src/soc/nvidia/tegra124/spi.c23
-rw-r--r--src/soc/nvidia/tegra124/uart.c18
7 files changed, 411 insertions, 405 deletions
diff --git a/src/soc/nvidia/tegra124/clock.c b/src/soc/nvidia/tegra124/clock.c
index dc1d1dbe8a..1d124b220f 100644
--- a/src/soc/nvidia/tegra124/clock.c
+++ b/src/soc/nvidia/tegra124/clock.c
@@ -163,7 +163,7 @@ struct {
*/
static u32 clock_get_osc_bits(void)
{
- return (readl(&clk_rst->osc_ctrl) & OSC_FREQ_MASK) >> OSC_FREQ_SHIFT;
+ return (read32(&clk_rst->osc_ctrl) & OSC_FREQ_MASK) >> OSC_FREQ_SHIFT;
}
int clock_get_osc_khz(void)
@@ -173,7 +173,7 @@ int clock_get_osc_khz(void)
int clock_get_pll_input_khz(void)
{
- u32 osc_ctrl = readl(&clk_rst->osc_ctrl);
+ u32 osc_ctrl = read32(&clk_rst->osc_ctrl);
u32 osc_bits = (osc_ctrl & OSC_FREQ_MASK) >> OSC_FREQ_SHIFT;
u32 pll_ref_div = (osc_ctrl & OSC_PREDIV_MASK) >> OSC_PREDIV_SHIFT;
return osc_table[osc_bits].khz >> pll_ref_div;
@@ -186,11 +186,11 @@ void clock_init_arm_generic_timer(void)
set_cntfrq(freq);
// Record the system timer frequency.
- writel(freq, &sysctr->cntfid0);
+ write32(&sysctr->cntfid0, freq);
// Enable the system counter.
uint32_t cntcr = read32(&sysctr->cntcr);
cntcr |= SYSCTR_CNTCR_EN | SYSCTR_CNTCR_HDBG;
- writel(cntcr, &sysctr->cntcr);
+ write32(&sysctr->cntcr, cntcr);
}
#define SOR0_CLK_SEL0 (1 << 14)
@@ -221,18 +221,18 @@ static void init_pll(u32 *base, u32 *misc, const union pll_fields pll, u32 lock)
pll.div.lfcon << PLL_MISC_LFCON_SHIFT;
/* Write dividers but BYPASS the PLL while we're messing with it. */
- writel(dividers | PLL_BASE_BYPASS, base);
+ write32(base, dividers | PLL_BASE_BYPASS);
/*
* Set Lock bit, CPCON and LFCON fields (default to 0 if it doesn't
* exist for this PLL)
*/
- writel(lock | misc_con, misc);
+ write32(misc, lock | misc_con);
/* Enable PLL and take it back out of BYPASS */
- writel(dividers | PLL_BASE_ENABLE, base);
+ write32(base, dividers | PLL_BASE_ENABLE);
/* Wait for lock ready */
- while (!(readl(base) & PLL_BASE_LOCK));
+ while (!(read32(base) & PLL_BASE_LOCK));
}
static void init_utmip_pll(void)
@@ -243,14 +243,14 @@ static void init_utmip_pll(void)
clrbits_le32(&clk_rst->utmip_pll_cfg2, 1 << 30); /* PHY_XTAL_CLKEN */
udelay(1);
- writel(80 << 16 | 1 << 8 | 0, &clk_rst->utmip_pll_cfg0); /* 960MHz * 1 / 80 == 12 MHz */
+ write32(&clk_rst->utmip_pll_cfg0, 80 << 16 | 1 << 8 | 0); /* 960MHz * 1 / 80 == 12 MHz */
- writel(CEIL_DIV(khz, 8000) << 27 | 0 << 16 | 0 << 14 | 0 << 12 | CEIL_DIV(khz, 102) << 0 | 0,
- &clk_rst->utmip_pll_cfg1);
+ write32(&clk_rst->utmip_pll_cfg1,
+ CEIL_DIV(khz, 8000) << 27 | 0 << 16 | 0 << 14 | 0 << 12 | CEIL_DIV(khz, 102) << 0 | 0);
/* TODO: TRM can't decide if actv is 5us or 10us, keep an eye on it */
- writel(0 << 24 | CEIL_DIV(khz, 3200) << 18 | CEIL_DIV(khz, 256) << 6 | 0 << 4 | 0 << 2 | 0 << 0 | 0,
- &clk_rst->utmip_pll_cfg2);
+ write32(&clk_rst->utmip_pll_cfg2,
+ 0 << 24 | CEIL_DIV(khz, 3200) << 18 | CEIL_DIV(khz, 256) << 6 | 0 << 4 | 0 << 2 | 0 << 0 | 0);
setbits_le32(&clk_rst->utmip_pll_cfg2, 1 << 30); /* PHY_XTAL_CLKEN */
}
@@ -274,12 +274,12 @@ static void graphics_pll(void)
* that it is needed.
*/
u32 scfg = (1<<28) | (1<<24) | (1<<22);
- writel(scfg, cfg);
+ write32(cfg, scfg);
init_pll(&clk_rst->plldp_base, &clk_rst->plldp_misc,
osc_table[osc].plldp, PLLDPD2_MISC_LOCK_ENABLE);
/* leave dither and undoc bits set, release clamp */
scfg = (1<<28) | (1<<24);
- writel(scfg, cfg);
+ write32(cfg, scfg);
/* disp1 will be set when panel information (pixel clock) is
* retrieved (clock_display).
@@ -387,8 +387,8 @@ clock_display(u32 frequency)
* been determined through trial and error (must lead to div 13 at 24MHz). */
void clock_early_uart(void)
{
- writel(CLK_M << CLK_SOURCE_SHIFT | CLK_UART_DIV_OVERRIDE | CLK_DIVIDER(TEGRA_CLK_M_KHZ, 1900),
- &clk_rst->clk_src_uarta);
+ write32(&clk_rst->clk_src_uarta,
+ CLK_M << CLK_SOURCE_SHIFT | CLK_UART_DIV_OVERRIDE | CLK_DIVIDER(TEGRA_CLK_M_KHZ, 1900));
setbits_le32(&clk_rst->clk_out_enb_l, CLK_L_UARTA);
udelay(2);
clrbits_le32(&clk_rst->rst_dev_l, CLK_L_UARTA);
@@ -438,22 +438,22 @@ void clock_sdram(u32 m, u32 n, u32 p, u32 setup, u32 ph45, u32 ph90,
* values after coldboot reset).
*/
- writel(misc1, &clk_rst->pllm_misc1);
- writel(misc2, &clk_rst->pllm_misc2);
+ write32(&clk_rst->pllm_misc1, misc1);
+ write32(&clk_rst->pllm_misc2, misc2);
/* PLLM.BASE needs BYPASS=0, different from general init_pll */
- base = readl(&clk_rst->pllm_base);
+ base = read32(&clk_rst->pllm_base);
base &= ~(PLLCMX_BASE_DIVN_MASK | PLLCMX_BASE_DIVM_MASK |
PLLM_BASE_DIVP_MASK | PLL_BASE_BYPASS);
base |= ((m << PLL_BASE_DIVM_SHIFT) | (n << PLL_BASE_DIVN_SHIFT) |
(p << PLL_BASE_DIVP_SHIFT));
- writel(base, &clk_rst->pllm_base);
+ write32(&clk_rst->pllm_base, base);
setbits_le32(&clk_rst->pllm_base, PLL_BASE_ENABLE);
/* stable_time is required, before we can start to check lock. */
udelay(stable_time);
- while (!(readl(&clk_rst->pllm_base) & PLL_BASE_LOCK)) {
+ while (!(read32(&clk_rst->pllm_base) & PLL_BASE_LOCK)) {
udelay(1);
}
/*
@@ -467,7 +467,7 @@ void clock_sdram(u32 m, u32 n, u32 p, u32 setup, u32 ph45, u32 ph90,
/* Enable and start MEM(MC) and EMC. */
clock_enable_clear_reset(0, CLK_H_MEM | CLK_H_EMC, 0, 0, 0, 0);
- writel(emc_source, &clk_rst->clk_src_emc);
+ write32(&clk_rst->clk_src_emc, emc_source);
udelay(IO_STABILIZATION_DELAY);
}
@@ -475,24 +475,24 @@ void clock_cpu0_config(void *entry)
{
void * const evp_cpu_reset = (uint8_t *)TEGRA_EVP_BASE + 0x100;
- writel((uintptr_t)_estack, &maincpu_stack_pointer);
- writel((uintptr_t)entry, &maincpu_entry_point);
- writel((uintptr_t)&maincpu_setup, evp_cpu_reset);
+ write32(&maincpu_stack_pointer, (uintptr_t)_estack);
+ write32(&maincpu_entry_point, (uintptr_t)entry);
+ write32(evp_cpu_reset, (uintptr_t)&maincpu_setup);
/* Set active CPU cluster to G */
clrbits_le32(&flow->cluster_control, 1);
// Set up cclk_brst and divider.
- writel((CRC_CCLK_BRST_POL_PLLX_OUT0 << 0) | (CRC_CCLK_BRST_POL_PLLX_OUT0 << 4) | (CRC_CCLK_BRST_POL_PLLX_OUT0 << 8) | (CRC_CCLK_BRST_POL_PLLX_OUT0 << 12) | (CRC_CCLK_BRST_POL_CPU_STATE_RUN << 28),
- &clk_rst->cclk_brst_pol);
- writel(CRC_SUPER_CCLK_DIVIDER_SUPER_CDIV_ENB,
- &clk_rst->super_cclk_div);
+ write32(&clk_rst->cclk_brst_pol,
+ (CRC_CCLK_BRST_POL_PLLX_OUT0 << 0) | (CRC_CCLK_BRST_POL_PLLX_OUT0 << 4) | (CRC_CCLK_BRST_POL_PLLX_OUT0 << 8) | (CRC_CCLK_BRST_POL_PLLX_OUT0 << 12) | (CRC_CCLK_BRST_POL_CPU_STATE_RUN << 28));
+ write32(&clk_rst->super_cclk_div,
+ CRC_SUPER_CCLK_DIVIDER_SUPER_CDIV_ENB);
// Enable the clocks for CPUs 0-3.
uint32_t cpu_cmplx_clr = read32(&clk_rst->clk_cpu_cmplx_clr);
cpu_cmplx_clr |= CRC_CLK_CLR_CPU0_STP | CRC_CLK_CLR_CPU1_STP |
CRC_CLK_CLR_CPU2_STP | CRC_CLK_CLR_CPU3_STP;
- writel(cpu_cmplx_clr, &clk_rst->clk_cpu_cmplx_clr);
+ write32(&clk_rst->clk_cpu_cmplx_clr, cpu_cmplx_clr);
// Enable other CPU related clocks.
setbits_le32(&clk_rst->clk_out_enb_l, CLK_L_CPU);
@@ -503,23 +503,23 @@ void clock_cpu0_config(void *entry)
void clock_cpu0_remove_reset(void)
{
// Disable the reset on the non-CPU parts of the fast cluster.
- writel(CRC_RST_CPUG_CLR_NONCPU, &clk_rst->rst_cpug_cmplx_clr);
+ write32(&clk_rst->rst_cpug_cmplx_clr, CRC_RST_CPUG_CLR_NONCPU);
// Disable the various resets on the CPUs.
- writel(CRC_RST_CPUG_CLR_CPU0 | CRC_RST_CPUG_CLR_CPU1 | CRC_RST_CPUG_CLR_CPU2 | CRC_RST_CPUG_CLR_CPU3 | CRC_RST_CPUG_CLR_DBG0 | CRC_RST_CPUG_CLR_DBG1 | CRC_RST_CPUG_CLR_DBG2 | CRC_RST_CPUG_CLR_DBG3 | CRC_RST_CPUG_CLR_CORE0 | CRC_RST_CPUG_CLR_CORE1 | CRC_RST_CPUG_CLR_CORE2 | CRC_RST_CPUG_CLR_CORE3 | CRC_RST_CPUG_CLR_CX0 | CRC_RST_CPUG_CLR_CX1 | CRC_RST_CPUG_CLR_CX2 | CRC_RST_CPUG_CLR_CX3 | CRC_RST_CPUG_CLR_L2 | CRC_RST_CPUG_CLR_PDBG,
- &clk_rst->rst_cpug_cmplx_clr);
+ write32(&clk_rst->rst_cpug_cmplx_clr,
+ CRC_RST_CPUG_CLR_CPU0 | CRC_RST_CPUG_CLR_CPU1 | CRC_RST_CPUG_CLR_CPU2 | CRC_RST_CPUG_CLR_CPU3 | CRC_RST_CPUG_CLR_DBG0 | CRC_RST_CPUG_CLR_DBG1 | CRC_RST_CPUG_CLR_DBG2 | CRC_RST_CPUG_CLR_DBG3 | CRC_RST_CPUG_CLR_CORE0 | CRC_RST_CPUG_CLR_CORE1 | CRC_RST_CPUG_CLR_CORE2 | CRC_RST_CPUG_CLR_CORE3 | CRC_RST_CPUG_CLR_CX0 | CRC_RST_CPUG_CLR_CX1 | CRC_RST_CPUG_CLR_CX2 | CRC_RST_CPUG_CLR_CX3 | CRC_RST_CPUG_CLR_L2 | CRC_RST_CPUG_CLR_PDBG);
// Disable the reset on the non-CPU parts of the slow cluster.
- writel(CRC_RST_CPULP_CLR_NONCPU, &clk_rst->rst_cpulp_cmplx_clr);
+ write32(&clk_rst->rst_cpulp_cmplx_clr, CRC_RST_CPULP_CLR_NONCPU);
// Disable the various resets on the LP CPU.
- writel(CRC_RST_CPULP_CLR_CPU0 | CRC_RST_CPULP_CLR_DBG0 | CRC_RST_CPULP_CLR_CORE0 | CRC_RST_CPULP_CLR_CX0 | CRC_RST_CPULP_CLR_L2 | CRC_RST_CPULP_CLR_PDBG,
- &clk_rst->rst_cpulp_cmplx_clr);
+ write32(&clk_rst->rst_cpulp_cmplx_clr,
+ CRC_RST_CPULP_CLR_CPU0 | CRC_RST_CPULP_CLR_DBG0 | CRC_RST_CPULP_CLR_CORE0 | CRC_RST_CPULP_CLR_CX0 | CRC_RST_CPULP_CLR_L2 | CRC_RST_CPULP_CLR_PDBG);
}
void clock_halt_avp(void)
{
for (;;) {
- writel(FLOW_EVENT_JTAG | FLOW_EVENT_LIC_IRQ | FLOW_EVENT_GIC_IRQ | FLOW_MODE_WAITEVENT,
- &flow->halt_cop_events);
+ write32(&flow->halt_cop_events,
+ FLOW_EVENT_JTAG | FLOW_EVENT_LIC_IRQ | FLOW_EVENT_GIC_IRQ | FLOW_MODE_WAITEVENT);
}
}
@@ -528,7 +528,7 @@ void clock_init(void)
u32 osc = clock_get_osc_bits();
/* Set PLLC dynramp_step A to 0x2b and B to 0xb (from U-Boot -- why? */
- writel(0x2b << 17 | 0xb << 9, &clk_rst->pllc_misc2);
+ write32(&clk_rst->pllc_misc2, 0x2b << 17 | 0xb << 9);
/* Max out the AVP clock before everything else (need PLLC for that). */
init_pll(&clk_rst->pllc_base, &clk_rst->pllc_misc,
@@ -536,12 +536,12 @@ void clock_init(void)
/* Typical ratios are 1:2:2 or 1:2:3 sclk:hclk:pclk (See: APB DMA
* features section in the TRM). */
- writel(TEGRA_HCLK_RATIO << HCLK_DIVISOR_SHIFT | TEGRA_PCLK_RATIO << PCLK_DIVISOR_SHIFT,
- &clk_rst->clk_sys_rate);
- writel(CLK_DIVIDER(TEGRA_PLLC_KHZ, TEGRA_SCLK_KHZ) << PLL_OUT_RATIO_SHIFT | PLL_OUT_CLKEN | PLL_OUT_RSTN,
- &clk_rst->pllc_out);
- writel(SCLK_SYS_STATE_RUN << SCLK_SYS_STATE_SHIFT | SCLK_SOURCE_PLLC_OUT1 << SCLK_RUN_SHIFT,
- &clk_rst->sclk_brst_pol); /* sclk = 300 MHz */
+ write32(&clk_rst->clk_sys_rate,
+ TEGRA_HCLK_RATIO << HCLK_DIVISOR_SHIFT | TEGRA_PCLK_RATIO << PCLK_DIVISOR_SHIFT);
+ write32(&clk_rst->pllc_out,
+ CLK_DIVIDER(TEGRA_PLLC_KHZ, TEGRA_SCLK_KHZ) << PLL_OUT_RATIO_SHIFT | PLL_OUT_CLKEN | PLL_OUT_RSTN);
+ write32(&clk_rst->sclk_brst_pol,
+ SCLK_SYS_STATE_RUN << SCLK_SYS_STATE_SHIFT | SCLK_SOURCE_PLLC_OUT1 << SCLK_RUN_SHIFT); /* sclk = 300 MHz */
/* Change the oscillator drive strength (from U-Boot -- why?) */
clrsetbits_le32(&clk_rst->osc_ctrl, OSC_XOFS_MASK,
@@ -559,10 +559,10 @@ void clock_init(void)
clrbits_le32(&clk_rst->pllx_misc3, PLLX_IDDQ_MASK);
/* Set up PLLP_OUT(1|2|3|4) divisor to generate (9.6|48|102|204)MHz */
- writel((CLK_DIVIDER(TEGRA_PLLP_KHZ, 9600) << PLL_OUT_RATIO_SHIFT | PLL_OUT_OVR | PLL_OUT_CLKEN | PLL_OUT_RSTN) << PLL_OUT1_SHIFT | (CLK_DIVIDER(TEGRA_PLLP_KHZ, 48000) << PLL_OUT_RATIO_SHIFT | PLL_OUT_OVR | PLL_OUT_CLKEN | PLL_OUT_RSTN) << PLL_OUT2_SHIFT,
- &clk_rst->pllp_outa);
- writel((CLK_DIVIDER(TEGRA_PLLP_KHZ, 102000) << PLL_OUT_RATIO_SHIFT | PLL_OUT_OVR | PLL_OUT_CLKEN | PLL_OUT_RSTN) << PLL_OUT3_SHIFT | (CLK_DIVIDER(TEGRA_PLLP_KHZ, 204000) << PLL_OUT_RATIO_SHIFT | PLL_OUT_OVR | PLL_OUT_CLKEN | PLL_OUT_RSTN) << PLL_OUT4_SHIFT,
- &clk_rst->pllp_outb);
+ write32(&clk_rst->pllp_outa,
+ (CLK_DIVIDER(TEGRA_PLLP_KHZ, 9600) << PLL_OUT_RATIO_SHIFT | PLL_OUT_OVR | PLL_OUT_CLKEN | PLL_OUT_RSTN) << PLL_OUT1_SHIFT | (CLK_DIVIDER(TEGRA_PLLP_KHZ, 48000) << PLL_OUT_RATIO_SHIFT | PLL_OUT_OVR | PLL_OUT_CLKEN | PLL_OUT_RSTN) << PLL_OUT2_SHIFT);
+ write32(&clk_rst->pllp_outb,
+ (CLK_DIVIDER(TEGRA_PLLP_KHZ, 102000) << PLL_OUT_RATIO_SHIFT | PLL_OUT_OVR | PLL_OUT_CLKEN | PLL_OUT_RSTN) << PLL_OUT3_SHIFT | (CLK_DIVIDER(TEGRA_PLLP_KHZ, 204000) << PLL_OUT_RATIO_SHIFT | PLL_OUT_OVR | PLL_OUT_CLKEN | PLL_OUT_RSTN) << PLL_OUT4_SHIFT);
/* init pllx */
init_pll(&clk_rst->pllx_base, &clk_rst->pllx_misc,
@@ -578,62 +578,62 @@ void clock_init(void)
void clock_enable_clear_reset(u32 l, u32 h, u32 u, u32 v, u32 w, u32 x)
{
- if (l) writel(l, &clk_rst->clk_enb_l_set);
- if (h) writel(h, &clk_rst->clk_enb_h_set);
- if (u) writel(u, &clk_rst->clk_enb_u_set);
- if (v) writel(v, &clk_rst->clk_enb_v_set);
- if (w) writel(w, &clk_rst->clk_enb_w_set);
- if (x) writel(x, &clk_rst->clk_enb_x_set);
+ if (l) write32(&clk_rst->clk_enb_l_set, l);
+ if (h) write32(&clk_rst->clk_enb_h_set, h);
+ if (u) write32(&clk_rst->clk_enb_u_set, u);
+ if (v) write32(&clk_rst->clk_enb_v_set, v);
+ if (w) write32(&clk_rst->clk_enb_w_set, w);
+ if (x) write32(&clk_rst->clk_enb_x_set, x);
/* Give clocks time to stabilize. */
udelay(IO_STABILIZATION_DELAY);
- if (l) writel(l, &clk_rst->rst_dev_l_clr);
- if (h) writel(h, &clk_rst->rst_dev_h_clr);
- if (u) writel(u, &clk_rst->rst_dev_u_clr);
- if (v) writel(v, &clk_rst->rst_dev_v_clr);
- if (w) writel(w, &clk_rst->rst_dev_w_clr);
- if (x) writel(x, &clk_rst->rst_dev_x_clr);
+ if (l) write32(&clk_rst->rst_dev_l_clr, l);
+ if (h) write32(&clk_rst->rst_dev_h_clr, h);
+ if (u) write32(&clk_rst->rst_dev_u_clr, u);
+ if (v) write32(&clk_rst->rst_dev_v_clr, v);
+ if (w) write32(&clk_rst->rst_dev_w_clr, w);
+ if (x) write32(&clk_rst->rst_dev_x_clr, x);
}
void clock_reset_l(u32 bit)
{
- writel(bit, &clk_rst->rst_dev_l_set);
+ write32(&clk_rst->rst_dev_l_set, bit);
udelay(1);
- writel(bit, &clk_rst->rst_dev_l_clr);
+ write32(&clk_rst->rst_dev_l_clr, bit);
}
void clock_reset_h(u32 bit)
{
- writel(bit, &clk_rst->rst_dev_h_set);
+ write32(&clk_rst->rst_dev_h_set, bit);
udelay(1);
- writel(bit, &clk_rst->rst_dev_h_clr);
+ write32(&clk_rst->rst_dev_h_clr, bit);
}
void clock_reset_u(u32 bit)
{
- writel(bit, &clk_rst->rst_dev_u_set);
+ write32(&clk_rst->rst_dev_u_set, bit);
udelay(1);
- writel(bit, &clk_rst->rst_dev_u_clr);
+ write32(&clk_rst->rst_dev_u_clr, bit);
}
void clock_reset_v(u32 bit)
{
- writel(bit, &clk_rst->rst_dev_v_set);
+ write32(&clk_rst->rst_dev_v_set, bit);
udelay(1);
- writel(bit, &clk_rst->rst_dev_v_clr);
+ write32(&clk_rst->rst_dev_v_clr, bit);
}
void clock_reset_w(u32 bit)
{
- writel(bit, &clk_rst->rst_dev_w_set);
+ write32(&clk_rst->rst_dev_w_set, bit);
udelay(1);
- writel(bit, &clk_rst->rst_dev_w_clr);
+ write32(&clk_rst->rst_dev_w_clr, bit);
}
void clock_reset_x(u32 bit)
{
- writel(bit, &clk_rst->rst_dev_x_set);
+ write32(&clk_rst->rst_dev_x_set, bit);
udelay(1);
- writel(bit, &clk_rst->rst_dev_x_clr);
+ write32(&clk_rst->rst_dev_x_clr, bit);
}
diff --git a/src/soc/nvidia/tegra124/display.c b/src/soc/nvidia/tegra124/display.c
index 71fff1c93e..7273090eec 100644
--- a/src/soc/nvidia/tegra124/display.c
+++ b/src/soc/nvidia/tegra124/display.c
@@ -53,7 +53,7 @@ unsigned long READL(void * p)
if (dump > 1)
printk(BIOS_SPEW, "readl %p\n", p);
- value = readl(p);
+ value = read32(p);
if (dump)
printk(BIOS_SPEW, "readl %p %08lx\n", p, value);
return value;
@@ -63,7 +63,7 @@ void WRITEL(unsigned long value, void * p)
{
if (dump)
printk(BIOS_SPEW, "writel %p %08lx\n", p, value);
- writel(value, p);
+ write32(p, value);
}
/* return in 1000ths of a Hertz */
diff --git a/src/soc/nvidia/tegra124/lp0/tegra_lp0_resume.c b/src/soc/nvidia/tegra124/lp0/tegra_lp0_resume.c
index 9418e152da..2ed2103d15 100644
--- a/src/soc/nvidia/tegra124/lp0/tegra_lp0_resume.c
+++ b/src/soc/nvidia/tegra124/lp0/tegra_lp0_resume.c
@@ -282,17 +282,17 @@ inline static void write32(uint32_t val, void *addr)
inline static void setbits32(uint32_t bits, void *addr)
{
- writel(read32(addr) | bits, addr);
+ write32(addr, read32(addr) | bits);
}
inline static void clrbits32(uint32_t bits, void *addr)
{
- writel(read32(addr) & ~bits, addr);
+ write32(addr, read32(addr) & ~bits);
}
static void __attribute__((noreturn)) reset(void)
{
- writel(SWR_TRIG_SYS_RST, clk_rst_rst_devices_l_ptr);
+ write32(clk_rst_rst_devices_l_ptr, SWR_TRIG_SYS_RST);
halt();
}
@@ -337,7 +337,7 @@ static void config_oscillator(void)
osc_ctrl &= ~OSC_XOFS_MASK;
osc_ctrl |= (xofs << OSC_XOFS_SHIFT);
osc_ctrl |= OSC_XOE;
- writel(osc_ctrl, clk_rst_osc_ctrl_ptr);
+ write32(clk_rst_osc_ctrl_ptr, osc_ctrl);
}
static void config_pllu(void)
@@ -382,17 +382,17 @@ static void config_pllu(void)
// Configure PLLU.
uint32_t base = PLLU_BYPASS | PLLU_OVERRIDE |
(divn << PLLU_DIVN_SHIFT) | (divm << PLLU_DIVM_SHIFT);
- writel(base, clk_rst_pllu_base_ptr);
+ write32(clk_rst_pllu_base_ptr, base);
uint32_t misc = (cpcon << PLLU_CPCON_SHIFT) |
(lfcon << PLLU_LFCON_SHIFT);
- writel(misc, clk_rst_pllu_misc_ptr);
+ write32(clk_rst_pllu_misc_ptr, misc);
// Enable PLLU.
base &= ~PLLU_BYPASS;
base |= PLLU_ENABLE;
- writel(base, clk_rst_pllu_base_ptr);
+ write32(clk_rst_pllu_base_ptr, base);
misc |= PLLU_LOCK_ENABLE;
- writel(misc, clk_rst_pllu_misc_ptr);
+ write32(clk_rst_pllu_misc_ptr, misc);
}
static void config_tsc(void)
@@ -400,26 +400,26 @@ static void config_tsc(void)
// Tell the TSC the oscillator frequency.
switch (get_osc_freq()) {
case OSC_FREQ_12:
- writel(12000000, sysctr_cntfid0_ptr);
+ write32(sysctr_cntfid0_ptr, 12000000);
break;
case OSC_FREQ_48:
- writel(48000000, sysctr_cntfid0_ptr);
+ write32(sysctr_cntfid0_ptr, 48000000);
break;
case OSC_FREQ_16P8:
- writel(16800000, sysctr_cntfid0_ptr);
+ write32(sysctr_cntfid0_ptr, 16800000);
break;
case OSC_FREQ_19P2:
- writel(19200000, sysctr_cntfid0_ptr);
+ write32(sysctr_cntfid0_ptr, 19200000);
break;
case OSC_FREQ_38P4:
- writel(38400000, sysctr_cntfid0_ptr);
+ write32(sysctr_cntfid0_ptr, 38400000);
break;
case OSC_FREQ_26:
- writel(26000000, sysctr_cntfid0_ptr);
+ write32(sysctr_cntfid0_ptr, 26000000);
break;
default:
// Default to 13MHz.
- writel(13000000, sysctr_cntfid0_ptr);
+ write32(sysctr_cntfid0_ptr, 13000000);
break;
}
@@ -430,8 +430,8 @@ static void config_tsc(void)
static void enable_cpu_clocks(void)
{
// Enable the CPU complex clock.
- writel(CLK_ENB_CPU, clk_rst_clk_enb_l_set_ptr);
- writel(CLK_ENB_CPUG | CLK_ENB_CPULP, clk_rst_clk_enb_v_set_ptr);
+ write32(clk_rst_clk_enb_l_set_ptr, CLK_ENB_CPU);
+ write32(clk_rst_clk_enb_v_set_ptr, CLK_ENB_CPUG | CLK_ENB_CPULP);
}
@@ -441,7 +441,7 @@ static void enable_cpu_clocks(void)
static void config_core_sight(void)
{
// Enable the CoreSight clock.
- writel(CLK_ENB_CSITE, clk_rst_clk_out_enb_u_set_ptr);
+ write32(clk_rst_clk_out_enb_u_set_ptr, CLK_ENB_CSITE);
/*
* De-assert CoreSight reset.
@@ -449,22 +449,22 @@ static void config_core_sight(void)
* now. It will be restored to its original clock source
* when the CPU-side restoration code runs.
*/
- writel(SWR_CSITE_RST, clk_rst_rst_dev_u_clr_ptr);
+ write32(clk_rst_rst_dev_u_clr_ptr, SWR_CSITE_RST);
}
static void config_mselect(void)
{
// Set MSELECT clock source to PLLP with 1:4 divider.
- writel((6 << MSELECT_CLK_DIV_SHIFT) | MSELECT_CLK_SRC_PLLP_OUT0,
- clk_rst_clk_src_mselect_ptr);
+ write32(clk_rst_clk_src_mselect_ptr,
+ (6 << MSELECT_CLK_DIV_SHIFT) | MSELECT_CLK_SRC_PLLP_OUT0);
// Enable clock to MSELECT.
- writel(CLK_ENB_MSELECT, clk_rst_clk_enb_v_set_ptr);
+ write32(clk_rst_clk_enb_v_set_ptr, CLK_ENB_MSELECT);
udelay(2);
// Bring MSELECT out of reset.
- writel(SWR_MSELECT_RST, clk_rst_rst_dev_v_clr_ptr);
+ write32(clk_rst_rst_dev_v_clr_ptr, SWR_MSELECT_RST);
}
@@ -474,16 +474,16 @@ static void config_mselect(void)
static void clear_cpu_resets(void)
{
// Take the non-cpu of the G and LP clusters out of reset.
- writel(CLR_NONCPURESET, clk_rst_rst_cpulp_cmplx_clr_ptr);
- writel(CLR_NONCPURESET, clk_rst_rst_cpug_cmplx_clr_ptr);
+ write32(clk_rst_rst_cpulp_cmplx_clr_ptr, CLR_NONCPURESET);
+ write32(clk_rst_rst_cpug_cmplx_clr_ptr, CLR_NONCPURESET);
// Clear software controlled reset of the slow cluster.
- writel(CLR_CPURESET0 | CLR_DBGRESET0 | CLR_CORERESET0 | CLR_CXRESET0,
- clk_rst_rst_cpulp_cmplx_clr_ptr);
+ write32(clk_rst_rst_cpulp_cmplx_clr_ptr,
+ CLR_CPURESET0 | CLR_DBGRESET0 | CLR_CORERESET0 | CLR_CXRESET0);
// Clear software controlled reset of the fast cluster.
- writel(CLR_CPURESET0 | CLR_DBGRESET0 | CLR_CORERESET0 | CLR_CXRESET0 | CLR_CPURESET1 | CLR_DBGRESET1 | CLR_CORERESET1 | CLR_CXRESET1 | CLR_CPURESET2 | CLR_DBGRESET2 | CLR_CORERESET2 | CLR_CXRESET2 | CLR_CPURESET3 | CLR_DBGRESET3 | CLR_CORERESET3 | CLR_CXRESET3,
- clk_rst_rst_cpug_cmplx_clr_ptr);
+ write32(clk_rst_rst_cpug_cmplx_clr_ptr,
+ CLR_CPURESET0 | CLR_DBGRESET0 | CLR_CORERESET0 | CLR_CXRESET0 | CLR_CPURESET1 | CLR_DBGRESET1 | CLR_CORERESET1 | CLR_CXRESET1 | CLR_CPURESET2 | CLR_DBGRESET2 | CLR_CORERESET2 | CLR_CXRESET2 | CLR_CPURESET3 | CLR_DBGRESET3 | CLR_CORERESET3 | CLR_CXRESET3);
}
@@ -513,7 +513,8 @@ static void power_on_partition(unsigned id)
uint32_t bit = 0x1 << id;
if (!(read32(pmc_ctlr_pwrgate_status_ptr) & bit)) {
// Partition is not on. Turn it on.
- writel(id | PWRGATE_TOGGLE_START, pmc_ctlr_pwrgate_toggle_ptr);
+ write32(pmc_ctlr_pwrgate_toggle_ptr,
+ id | PWRGATE_TOGGLE_START);
// Wait until the partition is powerd on.
while (!(read32(pmc_ctlr_pwrgate_status_ptr) & bit))
@@ -543,8 +544,8 @@ static void power_on_main_cpu(void)
*/
uint32_t orig_timer = read32(pmc_ctlr_cpupwrgood_timer_ptr);
- writel(orig_timer * (204000000 / 32768),
- pmc_ctlr_cpupwrgood_timer_ptr);
+ write32(pmc_ctlr_cpupwrgood_timer_ptr,
+ orig_timer * (204000000 / 32768));
if (wakeup_on_lp()) {
power_on_partition(PARTID_C1NC);
@@ -556,7 +557,7 @@ static void power_on_main_cpu(void)
}
// Restore the original PMC_CPUPWRGOOD_TIMER.
- writel(orig_timer, pmc_ctlr_cpupwrgood_timer_ptr);
+ write32(pmc_ctlr_cpupwrgood_timer_ptr, orig_timer);
}
@@ -578,17 +579,17 @@ void lp0_resume(void)
flow_ctlr_cluster_control_ptr);
// Program SUPER_CCLK_DIVIDER.
- writel(SUPER_CDIV_ENB, clk_rst_super_cclk_div_ptr);
+ write32(clk_rst_super_cclk_div_ptr, SUPER_CDIV_ENB);
config_core_sight();
config_pllu();
// Set the CPU reset vector.
- writel(get_wakeup_vector(), evp_cpu_reset_ptr);
+ write32(evp_cpu_reset_ptr, get_wakeup_vector());
// Select CPU complex clock source.
- writel(CCLK_PLLP_BURST_POLICY, clk_rst_cclk_burst_policy_ptr);
+ write32(clk_rst_cclk_burst_policy_ptr, CCLK_PLLP_BURST_POLICY);
config_mselect();
@@ -599,14 +600,14 @@ void lp0_resume(void)
uint32_t ack_width = read32(clk_rst_cpu_softrst_ctrl2_ptr);
ack_width &= ~CAR2PMC_CPU_ACK_WIDTH_MASK;
ack_width |= 408 << CAR2PMC_CPU_ACK_WIDTH_SHIFT;
- writel(ack_width, clk_rst_cpu_softrst_ctrl2_ptr);
+ write32(clk_rst_cpu_softrst_ctrl2_ptr, ack_width);
config_tsc();
// Disable VPR.
- writel(0, mc_video_protect_size_mb_ptr);
- writel(VIDEO_PROTECT_WRITE_ACCESS_DISABLE,
- mc_video_protect_reg_ctrl_ptr);
+ write32(mc_video_protect_size_mb_ptr, 0);
+ write32(mc_video_protect_reg_ctrl_ptr,
+ VIDEO_PROTECT_WRITE_ACCESS_DISABLE);
enable_cpu_clocks();
@@ -619,8 +620,8 @@ void lp0_resume(void)
// Halt the AVP.
while (1)
- writel(FLOW_MODE_STOP | EVENT_JTAG,
- flow_ctlr_halt_cop_events_ptr);
+ write32(flow_ctlr_halt_cop_events_ptr,
+ FLOW_MODE_STOP | EVENT_JTAG);
}
diff --git a/src/soc/nvidia/tegra124/power.c b/src/soc/nvidia/tegra124/power.c
index b31d3a7781..962a8e12e3 100644
--- a/src/soc/nvidia/tegra124/power.c
+++ b/src/soc/nvidia/tegra124/power.c
@@ -48,7 +48,7 @@ static void power_ungate_partition(uint32_t id)
pwrgate_toggle &= ~(PMC_PWRGATE_TOGGLE_PARTID_MASK);
pwrgate_toggle |= (id << PMC_PWRGATE_TOGGLE_PARTID_SHIFT);
pwrgate_toggle |= PMC_PWRGATE_TOGGLE_START;
- writel(pwrgate_toggle, &pmc->pwrgate_toggle);
+ write32(&pmc->pwrgate_toggle, pwrgate_toggle);
// Wait for the request to be accepted.
while (read32(&pmc->pwrgate_toggle) & PMC_PWRGATE_TOGGLE_START)
@@ -73,12 +73,12 @@ void power_enable_and_ungate_cpu(void)
* Set CPUPWRGOOD_TIMER - APB clock is 1/2 of SCLK (150MHz),
* set it for 5ms as per SysEng (5ms * PCLK_KHZ * 1000 / 1s).
*/
- writel((TEGRA_PCLK_KHZ * 5), &pmc->cpupwrgood_timer);
+ write32(&pmc->cpupwrgood_timer, (TEGRA_PCLK_KHZ * 5));
uint32_t cntrl = read32(&pmc->cntrl);
cntrl &= ~PMC_CNTRL_CPUPWRREQ_POLARITY;
cntrl |= PMC_CNTRL_CPUPWRREQ_OE;
- writel(cntrl, &pmc->cntrl);
+ write32(&pmc->cntrl, cntrl);
power_ungate_partition(POWER_PARTID_CRAIL);
diff --git a/src/soc/nvidia/tegra124/sdram.c b/src/soc/nvidia/tegra124/sdram.c
index d094c18594..dc6fd92544 100644
--- a/src/soc/nvidia/tegra124/sdram.c
+++ b/src/soc/nvidia/tegra124/sdram.c
@@ -33,7 +33,7 @@
static void sdram_patch(uintptr_t addr, uint32_t value)
{
if (addr)
- writel(value, (uint32_t*)addr);
+ write32((uint32_t *)addr, value);
}
static void writebits(uint32_t value, uint32_t *addr, uint32_t mask)
@@ -46,7 +46,7 @@ static void sdram_configure_pmc(const struct sdram_params *param,
struct tegra_pmc_regs *regs)
{
/* VDDP Select */
- writel(param->PmcVddpSel, &regs->vddp_sel);
+ write32(&regs->vddp_sel, param->PmcVddpSel);
udelay(param->PmcVddpSelWait);
/* Set DDR pad voltage */
@@ -62,7 +62,7 @@ static void sdram_configure_pmc(const struct sdram_params *param,
writebits(param->PmcNoIoPower, &regs->no_iopower,
(PMC_NO_IOPOWER_MEM_MASK | PMC_NO_IOPOWER_MEM_COMP_MASK));
- writel(param->PmcRegShort, &regs->reg_short);
+ write32(&regs->reg_short, param->PmcRegShort);
}
static void sdram_start_clocks(const struct sdram_params *param)
@@ -102,148 +102,151 @@ static void sdram_deassert_sel_dpd(const struct sdram_params *param,
static void sdram_set_swizzle(const struct sdram_params *param,
struct tegra_emc_regs *regs)
{
- writel(param->EmcSwizzleRank0ByteCfg, &regs->swizzle_rank0_byte_cfg);
- writel(param->EmcSwizzleRank0Byte0, &regs->swizzle_rank0_byte0);
- writel(param->EmcSwizzleRank0Byte1, &regs->swizzle_rank0_byte1);
- writel(param->EmcSwizzleRank0Byte2, &regs->swizzle_rank0_byte2);
- writel(param->EmcSwizzleRank0Byte3, &regs->swizzle_rank0_byte3);
- writel(param->EmcSwizzleRank1ByteCfg, &regs->swizzle_rank1_byte_cfg);
- writel(param->EmcSwizzleRank1Byte0, &regs->swizzle_rank1_byte0);
- writel(param->EmcSwizzleRank1Byte1, &regs->swizzle_rank1_byte1);
- writel(param->EmcSwizzleRank1Byte2, &regs->swizzle_rank1_byte2);
- writel(param->EmcSwizzleRank1Byte3, &regs->swizzle_rank1_byte3);
+ write32(&regs->swizzle_rank0_byte_cfg, param->EmcSwizzleRank0ByteCfg);
+ write32(&regs->swizzle_rank0_byte0, param->EmcSwizzleRank0Byte0);
+ write32(&regs->swizzle_rank0_byte1, param->EmcSwizzleRank0Byte1);
+ write32(&regs->swizzle_rank0_byte2, param->EmcSwizzleRank0Byte2);
+ write32(&regs->swizzle_rank0_byte3, param->EmcSwizzleRank0Byte3);
+ write32(&regs->swizzle_rank1_byte_cfg, param->EmcSwizzleRank1ByteCfg);
+ write32(&regs->swizzle_rank1_byte0, param->EmcSwizzleRank1Byte0);
+ write32(&regs->swizzle_rank1_byte1, param->EmcSwizzleRank1Byte1);
+ write32(&regs->swizzle_rank1_byte2, param->EmcSwizzleRank1Byte2);
+ write32(&regs->swizzle_rank1_byte3, param->EmcSwizzleRank1Byte3);
}
static void sdram_set_pad_controls(const struct sdram_params *param,
struct tegra_emc_regs *regs)
{
/* Program the pad controls */
- writel(param->EmcXm2CmdPadCtrl, &regs->xm2cmdpadctrl);
- writel(param->EmcXm2CmdPadCtrl2, &regs->xm2cmdpadctrl2);
- writel(param->EmcXm2CmdPadCtrl3, &regs->xm2cmdpadctrl3);
- writel(param->EmcXm2CmdPadCtrl4, &regs->xm2cmdpadctrl4);
- writel(param->EmcXm2CmdPadCtrl5, &regs->xm2cmdpadctrl5);
+ write32(&regs->xm2cmdpadctrl, param->EmcXm2CmdPadCtrl);
+ write32(&regs->xm2cmdpadctrl2, param->EmcXm2CmdPadCtrl2);
+ write32(&regs->xm2cmdpadctrl3, param->EmcXm2CmdPadCtrl3);
+ write32(&regs->xm2cmdpadctrl4, param->EmcXm2CmdPadCtrl4);
+ write32(&regs->xm2cmdpadctrl5, param->EmcXm2CmdPadCtrl5);
- writel(param->EmcXm2DqsPadCtrl, &regs->xm2dqspadctrl);
- writel(param->EmcXm2DqsPadCtrl2, &regs->xm2dqspadctrl2);
- writel(param->EmcXm2DqsPadCtrl3, &regs->xm2dqspadctrl3);
- writel(param->EmcXm2DqsPadCtrl4, &regs->xm2dqspadctrl4);
- writel(param->EmcXm2DqsPadCtrl5, &regs->xm2dqspadctrl5);
- writel(param->EmcXm2DqsPadCtrl6, &regs->xm2dqspadctrl6);
+ write32(&regs->xm2dqspadctrl, param->EmcXm2DqsPadCtrl);
+ write32(&regs->xm2dqspadctrl2, param->EmcXm2DqsPadCtrl2);
+ write32(&regs->xm2dqspadctrl3, param->EmcXm2DqsPadCtrl3);
+ write32(&regs->xm2dqspadctrl4, param->EmcXm2DqsPadCtrl4);
+ write32(&regs->xm2dqspadctrl5, param->EmcXm2DqsPadCtrl5);
+ write32(&regs->xm2dqspadctrl6, param->EmcXm2DqsPadCtrl6);
- writel(param->EmcXm2DqPadCtrl, &regs->xm2dqpadctrl);
- writel(param->EmcXm2DqPadCtrl2, &regs->xm2dqpadctrl2);
- writel(param->EmcXm2DqPadCtrl3, &regs->xm2dqpadctrl3);
+ write32(&regs->xm2dqpadctrl, param->EmcXm2DqPadCtrl);
+ write32(&regs->xm2dqpadctrl2, param->EmcXm2DqPadCtrl2);
+ write32(&regs->xm2dqpadctrl3, param->EmcXm2DqPadCtrl3);
- writel(param->EmcXm2ClkPadCtrl, &regs->xm2clkpadctrl);
- writel(param->EmcXm2ClkPadCtrl2, &regs->xm2clkpadctrl2);
+ write32(&regs->xm2clkpadctrl, param->EmcXm2ClkPadCtrl);
+ write32(&regs->xm2clkpadctrl2, param->EmcXm2ClkPadCtrl2);
- writel(param->EmcXm2CompPadCtrl, &regs->xm2comppadctrl);
+ write32(&regs->xm2comppadctrl, param->EmcXm2CompPadCtrl);
- writel(param->EmcXm2VttGenPadCtrl, &regs->xm2vttgenpadctrl);
- writel(param->EmcXm2VttGenPadCtrl2, &regs->xm2vttgenpadctrl2);
- writel(param->EmcXm2VttGenPadCtrl3, &regs->xm2vttgenpadctrl3);
+ write32(&regs->xm2vttgenpadctrl, param->EmcXm2VttGenPadCtrl);
+ write32(&regs->xm2vttgenpadctrl2, param->EmcXm2VttGenPadCtrl2);
+ write32(&regs->xm2vttgenpadctrl3, param->EmcXm2VttGenPadCtrl3);
- writel(param->EmcCttTermCtrl, &regs->ctt_term_ctrl);
+ write32(&regs->ctt_term_ctrl, param->EmcCttTermCtrl);
}
static void sdram_trigger_emc_timing_update(struct tegra_emc_regs *regs)
{
- writel(EMC_TIMING_CONTROL_TIMING_UPDATE, &regs->timing_control);
+ write32(&regs->timing_control, EMC_TIMING_CONTROL_TIMING_UPDATE);
}
static void sdram_init_mc(const struct sdram_params *param,
struct tegra_mc_regs *regs)
{
/* Initialize MC VPR settings */
- writel(param->McDisplaySnapRing, &regs->display_snap_ring);
- writel(param->McVideoProtectBom, &regs->video_protect_bom);
- writel(param->McVideoProtectBomAdrHi, &regs->video_protect_bom_adr_hi);
- writel(param->McVideoProtectSizeMb, &regs->video_protect_size_mb);
- writel(param->McVideoProtectVprOverride,
- &regs->video_protect_vpr_override);
- writel(param->McVideoProtectVprOverride1,
- &regs->video_protect_vpr_override1);
- writel(param->McVideoProtectGpuOverride0,
- &regs->video_protect_gpu_override_0);
- writel(param->McVideoProtectGpuOverride1,
- &regs->video_protect_gpu_override_1);
+ write32(&regs->display_snap_ring, param->McDisplaySnapRing);
+ write32(&regs->video_protect_bom, param->McVideoProtectBom);
+ write32(&regs->video_protect_bom_adr_hi,
+ param->McVideoProtectBomAdrHi);
+ write32(&regs->video_protect_size_mb, param->McVideoProtectSizeMb);
+ write32(&regs->video_protect_vpr_override,
+ param->McVideoProtectVprOverride);
+ write32(&regs->video_protect_vpr_override1,
+ param->McVideoProtectVprOverride1);
+ write32(&regs->video_protect_gpu_override_0,
+ param->McVideoProtectGpuOverride0);
+ write32(&regs->video_protect_gpu_override_1,
+ param->McVideoProtectGpuOverride1);
/* Program SDRAM geometry paarameters */
- writel(param->McEmemAdrCfg, &regs->emem_adr_cfg);
- writel(param->McEmemAdrCfgDev0, &regs->emem_adr_cfg_dev0);
- writel(param->McEmemAdrCfgDev1, &regs->emem_adr_cfg_dev1);
+ write32(&regs->emem_adr_cfg, param->McEmemAdrCfg);
+ write32(&regs->emem_adr_cfg_dev0, param->McEmemAdrCfgDev0);
+ write32(&regs->emem_adr_cfg_dev1, param->McEmemAdrCfgDev1);
/* Program bank swizzling */
- writel(param->McEmemAdrCfgBankMask0, &regs->emem_bank_swizzle_cfg0);
- writel(param->McEmemAdrCfgBankMask1, &regs->emem_bank_swizzle_cfg1);
- writel(param->McEmemAdrCfgBankMask2, &regs->emem_bank_swizzle_cfg2);
- writel(param->McEmemAdrCfgBankSwizzle3, &regs->emem_bank_swizzle_cfg3);
+ write32(&regs->emem_bank_swizzle_cfg0, param->McEmemAdrCfgBankMask0);
+ write32(&regs->emem_bank_swizzle_cfg1, param->McEmemAdrCfgBankMask1);
+ write32(&regs->emem_bank_swizzle_cfg2, param->McEmemAdrCfgBankMask2);
+ write32(&regs->emem_bank_swizzle_cfg3,
+ param->McEmemAdrCfgBankSwizzle3);
/* Program external memory aperature (base and size) */
- writel(param->McEmemCfg, &regs->emem_cfg);
+ write32(&regs->emem_cfg, param->McEmemCfg);
/* Program SEC carveout (base and size) */
- writel(param->McSecCarveoutBom, &regs->sec_carveout_bom);
- writel(param->McSecCarveoutAdrHi, &regs->sec_carveout_adr_hi);
- writel(param->McSecCarveoutSizeMb, &regs->sec_carveout_size_mb);
+ write32(&regs->sec_carveout_bom, param->McSecCarveoutBom);
+ write32(&regs->sec_carveout_adr_hi, param->McSecCarveoutAdrHi);
+ write32(&regs->sec_carveout_size_mb, param->McSecCarveoutSizeMb);
/* Program MTS carveout (base and size) */
- writel(param->McMtsCarveoutBom, &regs->mts_carveout_bom);
- writel(param->McMtsCarveoutAdrHi, &regs->mts_carveout_adr_hi);
- writel(param->McMtsCarveoutSizeMb, &regs->mts_carveout_size_mb);
+ write32(&regs->mts_carveout_bom, param->McMtsCarveoutBom);
+ write32(&regs->mts_carveout_adr_hi, param->McMtsCarveoutAdrHi);
+ write32(&regs->mts_carveout_size_mb, param->McMtsCarveoutSizeMb);
/* Program the memory arbiter */
- writel(param->McEmemArbCfg, &regs->emem_arb_cfg);
- writel(param->McEmemArbOutstandingReq, &regs->emem_arb_outstanding_req);
- writel(param->McEmemArbTimingRcd, &regs->emem_arb_timing_rcd);
- writel(param->McEmemArbTimingRp, &regs->emem_arb_timing_rp);
- writel(param->McEmemArbTimingRc, &regs->emem_arb_timing_rc);
- writel(param->McEmemArbTimingRas, &regs->emem_arb_timing_ras);
- writel(param->McEmemArbTimingFaw, &regs->emem_arb_timing_faw);
- writel(param->McEmemArbTimingRrd, &regs->emem_arb_timing_rrd);
- writel(param->McEmemArbTimingRap2Pre, &regs->emem_arb_timing_rap2pre);
- writel(param->McEmemArbTimingWap2Pre, &regs->emem_arb_timing_wap2pre);
- writel(param->McEmemArbTimingR2R, &regs->emem_arb_timing_r2r);
- writel(param->McEmemArbTimingW2W, &regs->emem_arb_timing_w2w);
- writel(param->McEmemArbTimingR2W, &regs->emem_arb_timing_r2w);
- writel(param->McEmemArbTimingW2R, &regs->emem_arb_timing_w2r);
- writel(param->McEmemArbDaTurns, &regs->emem_arb_da_turns);
- writel(param->McEmemArbDaCovers, &regs->emem_arb_da_covers);
- writel(param->McEmemArbMisc0, &regs->emem_arb_misc0);
- writel(param->McEmemArbMisc1, &regs->emem_arb_misc1);
- writel(param->McEmemArbRing1Throttle, &regs->emem_arb_ring1_throttle);
- writel(param->McEmemArbOverride, &regs->emem_arb_override);
- writel(param->McEmemArbOverride1, &regs->emem_arb_override_1);
- writel(param->McEmemArbRsv, &regs->emem_arb_rsv);
+ write32(&regs->emem_arb_cfg, param->McEmemArbCfg);
+ write32(&regs->emem_arb_outstanding_req,
+ param->McEmemArbOutstandingReq);
+ write32(&regs->emem_arb_timing_rcd, param->McEmemArbTimingRcd);
+ write32(&regs->emem_arb_timing_rp, param->McEmemArbTimingRp);
+ write32(&regs->emem_arb_timing_rc, param->McEmemArbTimingRc);
+ write32(&regs->emem_arb_timing_ras, param->McEmemArbTimingRas);
+ write32(&regs->emem_arb_timing_faw, param->McEmemArbTimingFaw);
+ write32(&regs->emem_arb_timing_rrd, param->McEmemArbTimingRrd);
+ write32(&regs->emem_arb_timing_rap2pre, param->McEmemArbTimingRap2Pre);
+ write32(&regs->emem_arb_timing_wap2pre, param->McEmemArbTimingWap2Pre);
+ write32(&regs->emem_arb_timing_r2r, param->McEmemArbTimingR2R);
+ write32(&regs->emem_arb_timing_w2w, param->McEmemArbTimingW2W);
+ write32(&regs->emem_arb_timing_r2w, param->McEmemArbTimingR2W);
+ write32(&regs->emem_arb_timing_w2r, param->McEmemArbTimingW2R);
+ write32(&regs->emem_arb_da_turns, param->McEmemArbDaTurns);
+ write32(&regs->emem_arb_da_covers, param->McEmemArbDaCovers);
+ write32(&regs->emem_arb_misc0, param->McEmemArbMisc0);
+ write32(&regs->emem_arb_misc1, param->McEmemArbMisc1);
+ write32(&regs->emem_arb_ring1_throttle, param->McEmemArbRing1Throttle);
+ write32(&regs->emem_arb_override, param->McEmemArbOverride);
+ write32(&regs->emem_arb_override_1, param->McEmemArbOverride1);
+ write32(&regs->emem_arb_rsv, param->McEmemArbRsv);
/* Program extra snap levels for display client */
- writel(param->McDisExtraSnapLevels, &regs->dis_extra_snap_levels);
+ write32(&regs->dis_extra_snap_levels, param->McDisExtraSnapLevels);
/* Trigger MC timing update */
- writel(MC_TIMING_CONTROL_TIMING_UPDATE, &regs->timing_control);
+ write32(&regs->timing_control, MC_TIMING_CONTROL_TIMING_UPDATE);
/* Program second-level clock enable overrides */
- writel(param->McClkenOverride, &regs->clken_override);
+ write32(&regs->clken_override, param->McClkenOverride);
/* Program statistics gathering */
- writel(param->McStatControl, &regs->stat_control);
+ write32(&regs->stat_control, param->McStatControl);
}
static void sdram_init_emc(const struct sdram_params *param,
struct tegra_emc_regs *regs)
{
/* Program SDRAM geometry parameters */
- writel(param->EmcAdrCfg, &regs->adr_cfg);
+ write32(&regs->adr_cfg, param->EmcAdrCfg);
/* Program second-level clock enable overrides */
- writel(param->EmcClkenOverride, &regs->clken_override);
+ write32(&regs->clken_override, param->EmcClkenOverride);
/* Program EMC pad auto calibration */
- writel(param->EmcAutoCalInterval, &regs->auto_cal_interval);
- writel(param->EmcAutoCalConfig2, &regs->auto_cal_config2);
- writel(param->EmcAutoCalConfig3, &regs->auto_cal_config3);
- writel(param->EmcAutoCalConfig, &regs->auto_cal_config);
+ write32(&regs->auto_cal_interval, param->EmcAutoCalInterval);
+ write32(&regs->auto_cal_config2, param->EmcAutoCalConfig2);
+ write32(&regs->auto_cal_config3, param->EmcAutoCalConfig3);
+ write32(&regs->auto_cal_config, param->EmcAutoCalConfig);
udelay(param->EmcAutoCalWait);
}
@@ -251,129 +254,129 @@ static void sdram_set_emc_timing(const struct sdram_params *param,
struct tegra_emc_regs *regs)
{
/* Program EMC timing configuration */
- writel(param->EmcCfg2, &regs->cfg_2);
- writel(param->EmcCfgPipe, &regs->cfg_pipe);
- writel(param->EmcDbg, &regs->dbg);
- writel(param->EmcCmdQ, &regs->cmdq);
- writel(param->EmcMc2EmcQ, &regs->mc2emcq);
- writel(param->EmcMrsWaitCnt, &regs->mrs_wait_cnt);
- writel(param->EmcMrsWaitCnt2, &regs->mrs_wait_cnt2);
- writel(param->EmcFbioCfg5, &regs->fbio_cfg5);
- writel(param->EmcRc, &regs->rc);
- writel(param->EmcRfc, &regs->rfc);
- writel(param->EmcRfcSlr, &regs->rfc_slr);
- writel(param->EmcRas, &regs->ras);
- writel(param->EmcRp, &regs->rp);
- writel(param->EmcR2r, &regs->r2r);
- writel(param->EmcW2w, &regs->w2w);
- writel(param->EmcR2w, &regs->r2w);
- writel(param->EmcW2r, &regs->w2r);
- writel(param->EmcR2p, &regs->r2p);
- writel(param->EmcW2p, &regs->w2p);
- writel(param->EmcRdRcd, &regs->rd_rcd);
- writel(param->EmcWrRcd, &regs->wr_rcd);
- writel(param->EmcRrd, &regs->rrd);
- writel(param->EmcRext, &regs->rext);
- writel(param->EmcWext, &regs->wext);
- writel(param->EmcWdv, &regs->wdv);
- writel(param->EmcWdvMask, &regs->wdv_mask);
- writel(param->EmcQUse, &regs->quse);
- writel(param->EmcQuseWidth, &regs->quse_width);
- writel(param->EmcIbdly, &regs->ibdly);
- writel(param->EmcEInput, &regs->einput);
- writel(param->EmcEInputDuration, &regs->einput_duration);
- writel(param->EmcPutermExtra, &regs->puterm_extra);
- writel(param->EmcPutermWidth, &regs->puterm_width);
- writel(param->EmcPutermAdj, &regs->puterm_adj);
- writel(param->EmcCdbCntl1, &regs->cdb_cntl_1);
- writel(param->EmcCdbCntl2, &regs->cdb_cntl_2);
- writel(param->EmcCdbCntl3, &regs->cdb_cntl_3);
- writel(param->EmcQRst, &regs->qrst);
- writel(param->EmcQSafe, &regs->qsafe);
- writel(param->EmcRdv, &regs->rdv);
- writel(param->EmcRdvMask, &regs->rdv_mask);
- writel(param->EmcQpop, &regs->qpop);
- writel(param->EmcCtt, &regs->ctt);
- writel(param->EmcCttDuration, &regs->ctt_duration);
- writel(param->EmcRefresh, &regs->refresh);
- writel(param->EmcBurstRefreshNum, &regs->burst_refresh_num);
- writel(param->EmcPreRefreshReqCnt, &regs->pre_refresh_req_cnt);
- writel(param->EmcPdEx2Wr, &regs->pdex2wr);
- writel(param->EmcPdEx2Rd, &regs->pdex2rd);
- writel(param->EmcPChg2Pden, &regs->pchg2pden);
- writel(param->EmcAct2Pden, &regs->act2pden);
- writel(param->EmcAr2Pden, &regs->ar2pden);
- writel(param->EmcRw2Pden, &regs->rw2pden);
- writel(param->EmcTxsr, &regs->txsr);
- writel(param->EmcTxsrDll, &regs->txsrdll);
- writel(param->EmcTcke, &regs->tcke);
- writel(param->EmcTckesr, &regs->tckesr);
- writel(param->EmcTpd, &regs->tpd);
- writel(param->EmcTfaw, &regs->tfaw);
- writel(param->EmcTrpab, &regs->trpab);
- writel(param->EmcTClkStable, &regs->tclkstable);
- writel(param->EmcTClkStop, &regs->tclkstop);
- writel(param->EmcTRefBw, &regs->trefbw);
- writel(param->EmcOdtWrite, &regs->odt_write);
- writel(param->EmcOdtRead, &regs->odt_read);
- writel(param->EmcFbioCfg6, &regs->fbio_cfg6);
- writel(param->EmcCfgDigDll, &regs->cfg_dig_dll);
- writel(param->EmcCfgDigDllPeriod, &regs->cfg_dig_dll_period);
+ write32(&regs->cfg_2, param->EmcCfg2);
+ write32(&regs->cfg_pipe, param->EmcCfgPipe);
+ write32(&regs->dbg, param->EmcDbg);
+ write32(&regs->cmdq, param->EmcCmdQ);
+ write32(&regs->mc2emcq, param->EmcMc2EmcQ);
+ write32(&regs->mrs_wait_cnt, param->EmcMrsWaitCnt);
+ write32(&regs->mrs_wait_cnt2, param->EmcMrsWaitCnt2);
+ write32(&regs->fbio_cfg5, param->EmcFbioCfg5);
+ write32(&regs->rc, param->EmcRc);
+ write32(&regs->rfc, param->EmcRfc);
+ write32(&regs->rfc_slr, param->EmcRfcSlr);
+ write32(&regs->ras, param->EmcRas);
+ write32(&regs->rp, param->EmcRp);
+ write32(&regs->r2r, param->EmcR2r);
+ write32(&regs->w2w, param->EmcW2w);
+ write32(&regs->r2w, param->EmcR2w);
+ write32(&regs->w2r, param->EmcW2r);
+ write32(&regs->r2p, param->EmcR2p);
+ write32(&regs->w2p, param->EmcW2p);
+ write32(&regs->rd_rcd, param->EmcRdRcd);
+ write32(&regs->wr_rcd, param->EmcWrRcd);
+ write32(&regs->rrd, param->EmcRrd);
+ write32(&regs->rext, param->EmcRext);
+ write32(&regs->wext, param->EmcWext);
+ write32(&regs->wdv, param->EmcWdv);
+ write32(&regs->wdv_mask, param->EmcWdvMask);
+ write32(&regs->quse, param->EmcQUse);
+ write32(&regs->quse_width, param->EmcQuseWidth);
+ write32(&regs->ibdly, param->EmcIbdly);
+ write32(&regs->einput, param->EmcEInput);
+ write32(&regs->einput_duration, param->EmcEInputDuration);
+ write32(&regs->puterm_extra, param->EmcPutermExtra);
+ write32(&regs->puterm_width, param->EmcPutermWidth);
+ write32(&regs->puterm_adj, param->EmcPutermAdj);
+ write32(&regs->cdb_cntl_1, param->EmcCdbCntl1);
+ write32(&regs->cdb_cntl_2, param->EmcCdbCntl2);
+ write32(&regs->cdb_cntl_3, param->EmcCdbCntl3);
+ write32(&regs->qrst, param->EmcQRst);
+ write32(&regs->qsafe, param->EmcQSafe);
+ write32(&regs->rdv, param->EmcRdv);
+ write32(&regs->rdv_mask, param->EmcRdvMask);
+ write32(&regs->qpop, param->EmcQpop);
+ write32(&regs->ctt, param->EmcCtt);
+ write32(&regs->ctt_duration, param->EmcCttDuration);
+ write32(&regs->refresh, param->EmcRefresh);
+ write32(&regs->burst_refresh_num, param->EmcBurstRefreshNum);
+ write32(&regs->pre_refresh_req_cnt, param->EmcPreRefreshReqCnt);
+ write32(&regs->pdex2wr, param->EmcPdEx2Wr);
+ write32(&regs->pdex2rd, param->EmcPdEx2Rd);
+ write32(&regs->pchg2pden, param->EmcPChg2Pden);
+ write32(&regs->act2pden, param->EmcAct2Pden);
+ write32(&regs->ar2pden, param->EmcAr2Pden);
+ write32(&regs->rw2pden, param->EmcRw2Pden);
+ write32(&regs->txsr, param->EmcTxsr);
+ write32(&regs->txsrdll, param->EmcTxsrDll);
+ write32(&regs->tcke, param->EmcTcke);
+ write32(&regs->tckesr, param->EmcTckesr);
+ write32(&regs->tpd, param->EmcTpd);
+ write32(&regs->tfaw, param->EmcTfaw);
+ write32(&regs->trpab, param->EmcTrpab);
+ write32(&regs->tclkstable, param->EmcTClkStable);
+ write32(&regs->tclkstop, param->EmcTClkStop);
+ write32(&regs->trefbw, param->EmcTRefBw);
+ write32(&regs->odt_write, param->EmcOdtWrite);
+ write32(&regs->odt_read, param->EmcOdtRead);
+ write32(&regs->fbio_cfg6, param->EmcFbioCfg6);
+ write32(&regs->cfg_dig_dll, param->EmcCfgDigDll);
+ write32(&regs->cfg_dig_dll_period, param->EmcCfgDigDllPeriod);
/* Don't write bit 1: addr swizzle lock bit. Written at end of sequence. */
- writel(param->EmcFbioSpare & 0xfffffffd, &regs->fbio_spare);
-
- writel(param->EmcCfgRsv, &regs->cfg_rsv);
- writel(param->EmcDllXformDqs0, &regs->dll_xform_dqs0);
- writel(param->EmcDllXformDqs1, &regs->dll_xform_dqs1);
- writel(param->EmcDllXformDqs2, &regs->dll_xform_dqs2);
- writel(param->EmcDllXformDqs3, &regs->dll_xform_dqs3);
- writel(param->EmcDllXformDqs4, &regs->dll_xform_dqs4);
- writel(param->EmcDllXformDqs5, &regs->dll_xform_dqs5);
- writel(param->EmcDllXformDqs6, &regs->dll_xform_dqs6);
- writel(param->EmcDllXformDqs7, &regs->dll_xform_dqs7);
- writel(param->EmcDllXformDqs8, &regs->dll_xform_dqs8);
- writel(param->EmcDllXformDqs9, &regs->dll_xform_dqs9);
- writel(param->EmcDllXformDqs10, &regs->dll_xform_dqs10);
- writel(param->EmcDllXformDqs11, &regs->dll_xform_dqs11);
- writel(param->EmcDllXformDqs12, &regs->dll_xform_dqs12);
- writel(param->EmcDllXformDqs13, &regs->dll_xform_dqs13);
- writel(param->EmcDllXformDqs14, &regs->dll_xform_dqs14);
- writel(param->EmcDllXformDqs15, &regs->dll_xform_dqs15);
- writel(param->EmcDllXformQUse0, &regs->dll_xform_quse0);
- writel(param->EmcDllXformQUse1, &regs->dll_xform_quse1);
- writel(param->EmcDllXformQUse2, &regs->dll_xform_quse2);
- writel(param->EmcDllXformQUse3, &regs->dll_xform_quse3);
- writel(param->EmcDllXformQUse4, &regs->dll_xform_quse4);
- writel(param->EmcDllXformQUse5, &regs->dll_xform_quse5);
- writel(param->EmcDllXformQUse6, &regs->dll_xform_quse6);
- writel(param->EmcDllXformQUse7, &regs->dll_xform_quse7);
- writel(param->EmcDllXformQUse8, &regs->dll_xform_quse8);
- writel(param->EmcDllXformQUse9, &regs->dll_xform_quse9);
- writel(param->EmcDllXformQUse10, &regs->dll_xform_quse10);
- writel(param->EmcDllXformQUse11, &regs->dll_xform_quse11);
- writel(param->EmcDllXformQUse12, &regs->dll_xform_quse12);
- writel(param->EmcDllXformQUse13, &regs->dll_xform_quse13);
- writel(param->EmcDllXformQUse14, &regs->dll_xform_quse14);
- writel(param->EmcDllXformQUse15, &regs->dll_xform_quse15);
- writel(param->EmcDllXformDq0, &regs->dll_xform_dq0);
- writel(param->EmcDllXformDq1, &regs->dll_xform_dq1);
- writel(param->EmcDllXformDq2, &regs->dll_xform_dq2);
- writel(param->EmcDllXformDq3, &regs->dll_xform_dq3);
- writel(param->EmcDllXformDq4, &regs->dll_xform_dq4);
- writel(param->EmcDllXformDq5, &regs->dll_xform_dq5);
- writel(param->EmcDllXformDq6, &regs->dll_xform_dq6);
- writel(param->EmcDllXformDq7, &regs->dll_xform_dq7);
- writel(param->EmcDllXformAddr0, &regs->dll_xform_addr0);
- writel(param->EmcDllXformAddr1, &regs->dll_xform_addr1);
- writel(param->EmcDllXformAddr2, &regs->dll_xform_addr2);
- writel(param->EmcDllXformAddr3, &regs->dll_xform_addr3);
- writel(param->EmcDllXformAddr4, &regs->dll_xform_addr4);
- writel(param->EmcDllXformAddr5, &regs->dll_xform_addr5);
- writel(param->EmcAcpdControl, &regs->acpd_control);
- writel(param->EmcDsrVttgenDrv, &regs->dsr_vttgen_drv);
- writel(param->EmcTxdsrvttgen, &regs->txdsrvttgen);
- writel(param->EmcBgbiasCtl0, &regs->bgbias_ctl0);
+ write32(&regs->fbio_spare, param->EmcFbioSpare & 0xfffffffd);
+
+ write32(&regs->cfg_rsv, param->EmcCfgRsv);
+ write32(&regs->dll_xform_dqs0, param->EmcDllXformDqs0);
+ write32(&regs->dll_xform_dqs1, param->EmcDllXformDqs1);
+ write32(&regs->dll_xform_dqs2, param->EmcDllXformDqs2);
+ write32(&regs->dll_xform_dqs3, param->EmcDllXformDqs3);
+ write32(&regs->dll_xform_dqs4, param->EmcDllXformDqs4);
+ write32(&regs->dll_xform_dqs5, param->EmcDllXformDqs5);
+ write32(&regs->dll_xform_dqs6, param->EmcDllXformDqs6);
+ write32(&regs->dll_xform_dqs7, param->EmcDllXformDqs7);
+ write32(&regs->dll_xform_dqs8, param->EmcDllXformDqs8);
+ write32(&regs->dll_xform_dqs9, param->EmcDllXformDqs9);
+ write32(&regs->dll_xform_dqs10, param->EmcDllXformDqs10);
+ write32(&regs->dll_xform_dqs11, param->EmcDllXformDqs11);
+ write32(&regs->dll_xform_dqs12, param->EmcDllXformDqs12);
+ write32(&regs->dll_xform_dqs13, param->EmcDllXformDqs13);
+ write32(&regs->dll_xform_dqs14, param->EmcDllXformDqs14);
+ write32(&regs->dll_xform_dqs15, param->EmcDllXformDqs15);
+ write32(&regs->dll_xform_quse0, param->EmcDllXformQUse0);
+ write32(&regs->dll_xform_quse1, param->EmcDllXformQUse1);
+ write32(&regs->dll_xform_quse2, param->EmcDllXformQUse2);
+ write32(&regs->dll_xform_quse3, param->EmcDllXformQUse3);
+ write32(&regs->dll_xform_quse4, param->EmcDllXformQUse4);
+ write32(&regs->dll_xform_quse5, param->EmcDllXformQUse5);
+ write32(&regs->dll_xform_quse6, param->EmcDllXformQUse6);
+ write32(&regs->dll_xform_quse7, param->EmcDllXformQUse7);
+ write32(&regs->dll_xform_quse8, param->EmcDllXformQUse8);
+ write32(&regs->dll_xform_quse9, param->EmcDllXformQUse9);
+ write32(&regs->dll_xform_quse10, param->EmcDllXformQUse10);
+ write32(&regs->dll_xform_quse11, param->EmcDllXformQUse11);
+ write32(&regs->dll_xform_quse12, param->EmcDllXformQUse12);
+ write32(&regs->dll_xform_quse13, param->EmcDllXformQUse13);
+ write32(&regs->dll_xform_quse14, param->EmcDllXformQUse14);
+ write32(&regs->dll_xform_quse15, param->EmcDllXformQUse15);
+ write32(&regs->dll_xform_dq0, param->EmcDllXformDq0);
+ write32(&regs->dll_xform_dq1, param->EmcDllXformDq1);
+ write32(&regs->dll_xform_dq2, param->EmcDllXformDq2);
+ write32(&regs->dll_xform_dq3, param->EmcDllXformDq3);
+ write32(&regs->dll_xform_dq4, param->EmcDllXformDq4);
+ write32(&regs->dll_xform_dq5, param->EmcDllXformDq5);
+ write32(&regs->dll_xform_dq6, param->EmcDllXformDq6);
+ write32(&regs->dll_xform_dq7, param->EmcDllXformDq7);
+ write32(&regs->dll_xform_addr0, param->EmcDllXformAddr0);
+ write32(&regs->dll_xform_addr1, param->EmcDllXformAddr1);
+ write32(&regs->dll_xform_addr2, param->EmcDllXformAddr2);
+ write32(&regs->dll_xform_addr3, param->EmcDllXformAddr3);
+ write32(&regs->dll_xform_addr4, param->EmcDllXformAddr4);
+ write32(&regs->dll_xform_addr5, param->EmcDllXformAddr5);
+ write32(&regs->acpd_control, param->EmcAcpdControl);
+ write32(&regs->dsr_vttgen_drv, param->EmcDsrVttgenDrv);
+ write32(&regs->txdsrvttgen, param->EmcTxdsrvttgen);
+ write32(&regs->bgbias_ctl0, param->EmcBgbiasCtl0);
/*
* Set pipe bypass enable bits before sending any DRAM commands.
@@ -393,8 +396,8 @@ static void sdram_patch_bootrom(const struct sdram_params *param,
BOOT_ROM_PATCH_CONTROL_OFFSET_MASK) >>
BOOT_ROM_PATCH_CONTROL_OFFSET_SHIFT);
addr = BOOT_ROM_PATCH_CONTROL_BASE_ADDRESS + (addr << 2);
- writel(param->BootRomPatchData, (uint32_t *)addr);
- writel(1, &regs->timing_control);
+ write32((uint32_t *)addr, param->BootRomPatchData);
+ write32(&regs->timing_control, 1);
}
}
@@ -402,7 +405,7 @@ static void sdram_set_dpd3(const struct sdram_params *param,
struct tegra_pmc_regs *regs)
{
/* Program DPD request */
- writel(param->PmcIoDpd3Req, &regs->io_dpd3_req);
+ write32(&regs->io_dpd3_req, param->PmcIoDpd3Req);
udelay(param->PmcIoDpd3ReqWait);
}
@@ -410,27 +413,27 @@ static void sdram_set_dli_trims(const struct sdram_params *param,
struct tegra_emc_regs *regs)
{
/* Program DLI trims */
- writel(param->EmcDliTrimTxDqs0, &regs->dli_trim_txdqs0);
- writel(param->EmcDliTrimTxDqs1, &regs->dli_trim_txdqs1);
- writel(param->EmcDliTrimTxDqs2, &regs->dli_trim_txdqs2);
- writel(param->EmcDliTrimTxDqs3, &regs->dli_trim_txdqs3);
- writel(param->EmcDliTrimTxDqs4, &regs->dli_trim_txdqs4);
- writel(param->EmcDliTrimTxDqs5, &regs->dli_trim_txdqs5);
- writel(param->EmcDliTrimTxDqs6, &regs->dli_trim_txdqs6);
- writel(param->EmcDliTrimTxDqs7, &regs->dli_trim_txdqs7);
- writel(param->EmcDliTrimTxDqs8, &regs->dli_trim_txdqs8);
- writel(param->EmcDliTrimTxDqs9, &regs->dli_trim_txdqs9);
- writel(param->EmcDliTrimTxDqs10, &regs->dli_trim_txdqs10);
- writel(param->EmcDliTrimTxDqs11, &regs->dli_trim_txdqs11);
- writel(param->EmcDliTrimTxDqs12, &regs->dli_trim_txdqs12);
- writel(param->EmcDliTrimTxDqs13, &regs->dli_trim_txdqs13);
- writel(param->EmcDliTrimTxDqs14, &regs->dli_trim_txdqs14);
- writel(param->EmcDliTrimTxDqs15, &regs->dli_trim_txdqs15);
-
- writel(param->EmcCaTrainingTimingCntl1,
- &regs->ca_training_timing_cntl1);
- writel(param->EmcCaTrainingTimingCntl2,
- &regs->ca_training_timing_cntl2);
+ write32(&regs->dli_trim_txdqs0, param->EmcDliTrimTxDqs0);
+ write32(&regs->dli_trim_txdqs1, param->EmcDliTrimTxDqs1);
+ write32(&regs->dli_trim_txdqs2, param->EmcDliTrimTxDqs2);
+ write32(&regs->dli_trim_txdqs3, param->EmcDliTrimTxDqs3);
+ write32(&regs->dli_trim_txdqs4, param->EmcDliTrimTxDqs4);
+ write32(&regs->dli_trim_txdqs5, param->EmcDliTrimTxDqs5);
+ write32(&regs->dli_trim_txdqs6, param->EmcDliTrimTxDqs6);
+ write32(&regs->dli_trim_txdqs7, param->EmcDliTrimTxDqs7);
+ write32(&regs->dli_trim_txdqs8, param->EmcDliTrimTxDqs8);
+ write32(&regs->dli_trim_txdqs9, param->EmcDliTrimTxDqs9);
+ write32(&regs->dli_trim_txdqs10, param->EmcDliTrimTxDqs10);
+ write32(&regs->dli_trim_txdqs11, param->EmcDliTrimTxDqs11);
+ write32(&regs->dli_trim_txdqs12, param->EmcDliTrimTxDqs12);
+ write32(&regs->dli_trim_txdqs13, param->EmcDliTrimTxDqs13);
+ write32(&regs->dli_trim_txdqs14, param->EmcDliTrimTxDqs14);
+ write32(&regs->dli_trim_txdqs15, param->EmcDliTrimTxDqs15);
+
+ write32(&regs->ca_training_timing_cntl1,
+ param->EmcCaTrainingTimingCntl1);
+ write32(&regs->ca_training_timing_cntl2,
+ param->EmcCaTrainingTimingCntl2);
sdram_trigger_emc_timing_update(regs);
udelay(param->EmcTimingControlWait);
@@ -446,7 +449,7 @@ static void sdram_set_clock_enable_signal(const struct sdram_params *param,
* Assert dummy read of PIN register to ensure above write to PIN
* register went through. 200 is the recommended value by NVIDIA.
*/
- dummy |= readl(&regs->pin);
+ dummy |= read32(&regs->pin);
udelay(200 + param->EmcPinExtraWait);
/* Deassert reset */
@@ -455,7 +458,7 @@ static void sdram_set_clock_enable_signal(const struct sdram_params *param,
* Assert dummy read of PIN register to ensure above write to PIN
* register went through. 200 is the recommended value by NVIDIA.
*/
- dummy |= readl(&regs->pin);
+ dummy |= read32(&regs->pin);
udelay(500 + param->EmcPinExtraWait);
/* Enable clock enable signal */
@@ -464,7 +467,7 @@ static void sdram_set_clock_enable_signal(const struct sdram_params *param,
* Assert dummy read of PIN register to ensure above write to PIN
* register went through. 200 is the recommended value by NVIDIA.
*/
- dummy |= readl(&regs->pin);
+ dummy |= read32(&regs->pin);
udelay(param->EmcPinProgramWait);
if (!dummy) {
@@ -478,13 +481,13 @@ static void sdram_set_clock_enable_signal(const struct sdram_params *param,
EMC_NOP_NOP_CMD_MASK | EMC_NOP_NOP_DEV_SELECTN_MASK);
/* Write mode registers */
- writel(param->EmcEmrs2, &regs->emrs2);
- writel(param->EmcEmrs3, &regs->emrs3);
- writel(param->EmcEmrs, &regs->emrs);
- writel(param->EmcMrs, &regs->mrs);
+ write32(&regs->emrs2, param->EmcEmrs2);
+ write32(&regs->emrs3, param->EmcEmrs3);
+ write32(&regs->emrs, param->EmcEmrs);
+ write32(&regs->mrs, param->EmcMrs);
if (param->EmcExtraModeRegWriteEnable) {
- writel(param->EmcMrwExtra, &regs->mrs);
+ write32(&regs->mrs, param->EmcMrwExtra);
}
}
@@ -494,11 +497,11 @@ static void sdram_init_zq_calibration(const struct sdram_params *param,
if ((param->EmcZcalWarmColdBootEnables &
EMC_ZCAL_WARM_COLD_BOOT_ENABLES_COLDBOOT_MASK) == 1) {
/* Need to initialize ZCAL on coldboot. */
- writel(param->EmcZcalInitDev0, &regs->zq_cal);
+ write32(&regs->zq_cal, param->EmcZcalInitDev0);
udelay(param->EmcZcalInitWait);
if ((param->EmcDevSelect & 2) == 0) {
- writel(param->EmcZcalInitDev1, &regs->zq_cal);
+ write32(&regs->zq_cal, param->EmcZcalInitDev1);
udelay(param->EmcZcalInitWait);
}
} else {
@@ -510,9 +513,9 @@ static void sdram_set_zq_calibration(const struct sdram_params *param,
struct tegra_emc_regs *regs)
{
/* Start periodic ZQ calibration */
- writel(param->EmcZcalInterval, &regs->zcal_interval);
- writel(param->EmcZcalWaitCnt, &regs->zcal_wait_cnt);
- writel(param->EmcZcalMrwCmd, &regs->zcal_mrw_cmd);
+ write32(&regs->zcal_interval, param->EmcZcalInterval);
+ write32(&regs->zcal_wait_cnt, param->EmcZcalWaitCnt);
+ write32(&regs->zcal_mrw_cmd, param->EmcZcalMrwCmd);
}
static void sdram_set_refresh(const struct sdram_params *param,
@@ -530,15 +533,15 @@ static void sdram_set_refresh(const struct sdram_params *param,
}
/* Enable refresh */
- writel((param->EmcDevSelect | EMC_REFCTRL_REF_VALID_ENABLED),
- &regs->refctrl);
+ write32(&regs->refctrl,
+ (param->EmcDevSelect | EMC_REFCTRL_REF_VALID_ENABLED));
- writel(param->EmcDynSelfRefControl, &regs->dyn_self_ref_control);
- writel(param->EmcCfg, &regs->cfg);
- writel(param->EmcSelDpdCtrl, &regs->sel_dpd_ctrl);
+ write32(&regs->dyn_self_ref_control, param->EmcDynSelfRefControl);
+ write32(&regs->cfg, param->EmcCfg);
+ write32(&regs->sel_dpd_ctrl, param->EmcSelDpdCtrl);
/* Write addr swizzle lock bit */
- writel(param->EmcFbioSpare, &regs->fbio_spare);
+ write32(&regs->fbio_spare, param->EmcFbioSpare);
/* Re-trigger timing to latch power saving functions */
sdram_trigger_emc_timing_update(regs);
@@ -556,12 +559,13 @@ static void sdram_lock_carveouts(const struct sdram_params *param,
struct tegra_mc_regs *regs)
{
/* Lock carveouts, and emem_cfg registers */
- writel(param->McVideoProtectWriteAccess, &regs->video_protect_reg_ctrl);
- writel(MC_EMEM_CFG_ACCESS_CTRL_WRITE_ACCESS_DISABLED,
- &regs->emem_cfg_access_ctrl);
- writel(param->McSecCarveoutProtectWriteAccess,
- &regs->sec_carveout_reg_ctrl);
- writel(param->McMtsCarveoutRegCtrl, &regs->mts_carveout_reg_ctrl);
+ write32(&regs->video_protect_reg_ctrl,
+ param->McVideoProtectWriteAccess);
+ write32(&regs->emem_cfg_access_ctrl,
+ MC_EMEM_CFG_ACCESS_CTRL_WRITE_ACCESS_DISABLED);
+ write32(&regs->sec_carveout_reg_ctrl,
+ param->McSecCarveoutProtectWriteAccess);
+ write32(&regs->mts_carveout_reg_ctrl, param->McMtsCarveoutRegCtrl);
}
void sdram_init(const struct sdram_params *param)
@@ -616,7 +620,7 @@ void sdram_init(const struct sdram_params *param)
uint32_t sdram_get_ram_code(void)
{
struct tegra_pmc_regs *pmc = (struct tegra_pmc_regs*)TEGRA_PMC_BASE;
- return ((readl(&pmc->strapping_opt_a) &
+ return ((read32(&pmc->strapping_opt_a) &
PMC_STRAPPING_OPT_A_RAM_CODE_MASK) >>
PMC_STRAPPING_OPT_A_RAM_CODE_SHIFT);
}
diff --git a/src/soc/nvidia/tegra124/spi.c b/src/soc/nvidia/tegra124/spi.c
index 0584177d5e..e1d022a420 100644
--- a/src/soc/nvidia/tegra124/spi.c
+++ b/src/soc/nvidia/tegra124/spi.c
@@ -230,7 +230,7 @@ int spi_claim_bus(struct spi_slave *slave)
else
val |= SPI_CMD1_CS_SW_VAL;
- writel(val, &regs->command1);
+ write32(&regs->command1, val);
return 0;
}
@@ -246,7 +246,7 @@ void spi_release_bus(struct spi_slave *slave)
else
val &= ~SPI_CMD1_CS_SW_VAL;
- writel(val, &regs->command1);
+ write32(&regs->command1, val);
}
static void dump_fifo_status(struct tegra_spi_channel *spi)
@@ -383,12 +383,12 @@ static int tegra_spi_pio_prepare(struct tegra_spi_channel *spi,
/* BLOCK_SIZE in SPI_DMA_BLK register applies to both DMA and
* PIO transfers */
- writel(todo - 1, &spi->regs->dma_blk);
+ write32(&spi->regs->dma_blk, todo - 1);
if (dir == SPI_SEND) {
unsigned int to_fifo = bytes;
while (to_fifo) {
- writel(*p, &spi->regs->tx_fifo);
+ write32(&spi->regs->tx_fifo, *p);
p++;
to_fifo--;
}
@@ -493,11 +493,12 @@ static int tegra_spi_dma_prepare(struct tegra_spi_channel *spi,
/* ensure bytes to send will be visible to DMA controller */
dcache_clean_by_mva(spi->out_buf, bytes);
- writel((u32)&spi->regs->tx_fifo, &spi->dma_out->regs->apb_ptr);
- writel((u32)spi->out_buf, &spi->dma_out->regs->ahb_ptr);
+ write32(&spi->dma_out->regs->apb_ptr,
+ (u32)&spi->regs->tx_fifo);
+ write32(&spi->dma_out->regs->ahb_ptr, (u32)spi->out_buf);
setbits_le32(&spi->dma_out->regs->csr, APB_CSR_DIR);
setup_dma_params(spi, spi->dma_out);
- writel(wcount, &spi->dma_out->regs->wcount);
+ write32(&spi->dma_out->regs->wcount, wcount);
} else {
spi->dma_in = dma_claim();
if (!spi->dma_in)
@@ -506,15 +507,15 @@ static int tegra_spi_dma_prepare(struct tegra_spi_channel *spi,
/* avoid data collisions */
dcache_clean_invalidate_by_mva(spi->in_buf, bytes);
- writel((u32)&spi->regs->rx_fifo, &spi->dma_in->regs->apb_ptr);
- writel((u32)spi->in_buf, &spi->dma_in->regs->ahb_ptr);
+ write32(&spi->dma_in->regs->apb_ptr, (u32)&spi->regs->rx_fifo);
+ write32(&spi->dma_in->regs->ahb_ptr, (u32)spi->in_buf);
clrbits_le32(&spi->dma_in->regs->csr, APB_CSR_DIR);
setup_dma_params(spi, spi->dma_in);
- writel(wcount, &spi->dma_in->regs->wcount);
+ write32(&spi->dma_in->regs->wcount, wcount);
}
/* BLOCK_SIZE starts at n-1 */
- writel(todo - 1, &spi->regs->dma_blk);
+ write32(&spi->regs->dma_blk, todo - 1);
return todo;
}
diff --git a/src/soc/nvidia/tegra124/uart.c b/src/soc/nvidia/tegra124/uart.c
index 26aec20030..70fafee83e 100644
--- a/src/soc/nvidia/tegra124/uart.c
+++ b/src/soc/nvidia/tegra124/uart.c
@@ -56,19 +56,19 @@ static void tegra124_uart_init(struct tegra124_uart *uart_ptr)
tegra124_uart_tx_flush(uart_ptr);
// Disable interrupts.
- writeb(0, &uart_ptr->ier);
+ write8(&uart_ptr->ier, 0);
// Force DTR and RTS to high.
- writeb(UART8250_MCR_DTR | UART8250_MCR_RTS, &uart_ptr->mcr);
+ write8(&uart_ptr->mcr, UART8250_MCR_DTR | UART8250_MCR_RTS);
// Set line configuration, access divisor latches.
- writeb(UART8250_LCR_DLAB | line_config, &uart_ptr->lcr);
+ write8(&uart_ptr->lcr, UART8250_LCR_DLAB | line_config);
// Set the divisor.
- writeb(divisor & 0xff, &uart_ptr->dll);
- writeb((divisor >> 8) & 0xff, &uart_ptr->dlm);
+ write8(&uart_ptr->dll, divisor & 0xff);
+ write8(&uart_ptr->dlm, (divisor >> 8) & 0xff);
// Hide the divisor latches.
- writeb(line_config, &uart_ptr->lcr);
+ write8(&uart_ptr->lcr, line_config);
// Enable FIFOs, and clear receive and transmit.
- writeb(UART8250_FCR_FIFO_EN | UART8250_FCR_CLEAR_RCVR | UART8250_FCR_CLEAR_XMIT,
- &uart_ptr->fcr);
+ write8(&uart_ptr->fcr,
+ UART8250_FCR_FIFO_EN | UART8250_FCR_CLEAR_RCVR | UART8250_FCR_CLEAR_XMIT);
}
static unsigned char tegra124_uart_rx_byte(struct tegra124_uart *uart_ptr)
@@ -81,7 +81,7 @@ static unsigned char tegra124_uart_rx_byte(struct tegra124_uart *uart_ptr)
static void tegra124_uart_tx_byte(struct tegra124_uart *uart_ptr, unsigned char data)
{
while (!(read8(&uart_ptr->lsr) & UART8250_LSR_THRE));
- writeb(data, &uart_ptr->thr);
+ write8(&uart_ptr->thr, data);
}
static void tegra124_uart_tx_flush(struct tegra124_uart *uart_ptr)
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-29 04:51:43 +0000