mirror of
https://github.com/AsahiLinux/u-boot
synced 2024-12-26 13:03:40 +00:00
c05ed00afb
Move this uncommon header out of the common header. Signed-off-by: Simon Glass <sjg@chromium.org>
1367 lines
39 KiB
C
1367 lines
39 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) Marvell International Ltd. and its affiliates
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <i2c.h>
|
|
#include <log.h>
|
|
#include <spl.h>
|
|
#include <asm/io.h>
|
|
#include <asm/arch/cpu.h>
|
|
#include <asm/arch/soc.h>
|
|
#include <linux/delay.h>
|
|
|
|
#include "ddr3_hw_training.h"
|
|
|
|
/*
|
|
* Debug
|
|
*/
|
|
#define DEBUG_WL_C(s, d, l) \
|
|
DEBUG_WL_S(s); DEBUG_WL_D(d, l); DEBUG_WL_S("\n")
|
|
#define DEBUG_WL_FULL_C(s, d, l) \
|
|
DEBUG_WL_FULL_S(s); DEBUG_WL_FULL_D(d, l); DEBUG_WL_FULL_S("\n")
|
|
|
|
#ifdef MV_DEBUG_WL
|
|
#define DEBUG_WL_S(s) puts(s)
|
|
#define DEBUG_WL_D(d, l) printf("%x", d)
|
|
#define DEBUG_RL_S(s) \
|
|
debug_cond(ddr3_get_log_level() >= MV_LOG_LEVEL_2, "%s", s)
|
|
#define DEBUG_RL_D(d, l) \
|
|
debug_cond(ddr3_get_log_level() >= MV_LOG_LEVEL_2, "%x", d)
|
|
#else
|
|
#define DEBUG_WL_S(s)
|
|
#define DEBUG_WL_D(d, l)
|
|
#endif
|
|
|
|
#ifdef MV_DEBUG_WL_FULL
|
|
#define DEBUG_WL_FULL_S(s) puts(s)
|
|
#define DEBUG_WL_FULL_D(d, l) printf("%x", d)
|
|
#else
|
|
#define DEBUG_WL_FULL_S(s)
|
|
#define DEBUG_WL_FULL_D(d, l)
|
|
#endif
|
|
|
|
#define WL_SUP_EXPECTED_DATA 0x21
|
|
#define WL_SUP_READ_DRAM_ENTRY 0x8
|
|
|
|
static int ddr3_write_leveling_single_cs(u32 cs, u32 freq, int ratio_2to1,
|
|
u32 *result,
|
|
MV_DRAM_INFO *dram_info);
|
|
static void ddr3_write_ctrl_pup_reg(int bc_acc, u32 pup, u32 reg_addr,
|
|
u32 data);
|
|
|
|
extern u16 odt_static[ODT_OPT][MAX_CS];
|
|
extern u16 odt_dynamic[ODT_OPT][MAX_CS];
|
|
extern u32 wl_sup_pattern[LEN_WL_SUP_PATTERN];
|
|
|
|
/*
|
|
* Name: ddr3_write_leveling_hw
|
|
* Desc: Execute Write leveling phase by HW
|
|
* Args: freq - current sequence frequency
|
|
* dram_info - main struct
|
|
* Notes:
|
|
* Returns: MV_OK if success, MV_FAIL if fail.
|
|
*/
|
|
int ddr3_write_leveling_hw(u32 freq, MV_DRAM_INFO *dram_info)
|
|
{
|
|
u32 reg, phase, delay, cs, pup;
|
|
#ifdef MV88F67XX
|
|
int dpde_flag = 0;
|
|
#endif
|
|
/* Debug message - Start Read leveling procedure */
|
|
DEBUG_WL_S("DDR3 - Write Leveling - Starting HW WL procedure\n");
|
|
|
|
#ifdef MV88F67XX
|
|
/* Dynamic pad issue (BTS669) during WL */
|
|
reg = reg_read(REG_DUNIT_CTRL_LOW_ADDR);
|
|
if (reg & (1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS)) {
|
|
dpde_flag = 1;
|
|
reg_write(REG_DUNIT_CTRL_LOW_ADDR,
|
|
reg & ~(1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS));
|
|
}
|
|
#endif
|
|
|
|
reg = 1 << REG_DRAM_TRAINING_WL_OFFS;
|
|
/* Config the retest number */
|
|
reg |= (COUNT_HW_WL << REG_DRAM_TRAINING_RETEST_OFFS);
|
|
reg |= (dram_info->cs_ena << (REG_DRAM_TRAINING_CS_OFFS));
|
|
reg_write(REG_DRAM_TRAINING_ADDR, reg); /* 0x15B0 - Training Register */
|
|
|
|
reg = reg_read(REG_DRAM_TRAINING_SHADOW_ADDR) |
|
|
(1 << REG_DRAM_TRAINING_AUTO_OFFS);
|
|
reg_write(REG_DRAM_TRAINING_SHADOW_ADDR, reg);
|
|
|
|
/* Wait */
|
|
do {
|
|
reg = reg_read(REG_DRAM_TRAINING_SHADOW_ADDR) &
|
|
(1 << REG_DRAM_TRAINING_AUTO_OFFS);
|
|
} while (reg); /* Wait for '0' */
|
|
|
|
reg = reg_read(REG_DRAM_TRAINING_ADDR);
|
|
/* Check if Successful */
|
|
if (reg & (1 << REG_DRAM_TRAINING_ERROR_OFFS)) {
|
|
/*
|
|
* Read results to arrays - Results are required for WL
|
|
* High freq Supplement and DQS Centralization
|
|
*/
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
for (pup = 0;
|
|
pup < dram_info->num_of_total_pups;
|
|
pup++) {
|
|
if (pup == dram_info->num_of_std_pups
|
|
&& dram_info->ecc_ena)
|
|
pup = ECC_PUP;
|
|
reg =
|
|
ddr3_read_pup_reg(PUP_WL_MODE, cs,
|
|
pup);
|
|
phase =
|
|
(reg >> REG_PHY_PHASE_OFFS) &
|
|
PUP_PHASE_MASK;
|
|
delay = reg & PUP_DELAY_MASK;
|
|
dram_info->wl_val[cs][pup][P] = phase;
|
|
dram_info->wl_val[cs][pup][D] = delay;
|
|
dram_info->wl_val[cs][pup][S] =
|
|
WL_HI_FREQ_STATE - 1;
|
|
reg =
|
|
ddr3_read_pup_reg(PUP_WL_MODE + 0x1,
|
|
cs, pup);
|
|
dram_info->wl_val[cs][pup][DQS] =
|
|
(reg & 0x3F);
|
|
}
|
|
|
|
#ifdef MV_DEBUG_WL
|
|
/* Debug message - Print res for cs[i]: cs,PUP,Phase,Delay */
|
|
DEBUG_WL_S("DDR3 - Write Leveling - Write Leveling Cs - ");
|
|
DEBUG_WL_D((u32) cs, 1);
|
|
DEBUG_WL_S(" Results:\n");
|
|
for (pup = 0;
|
|
pup < dram_info->num_of_total_pups;
|
|
pup++) {
|
|
if (pup == dram_info->num_of_std_pups
|
|
&& dram_info->ecc_ena)
|
|
pup = ECC_PUP;
|
|
DEBUG_WL_S("DDR3 - Write Leveling - PUP: ");
|
|
DEBUG_WL_D((u32) pup, 1);
|
|
DEBUG_WL_S(", Phase: ");
|
|
DEBUG_WL_D((u32)
|
|
dram_info->wl_val[cs][pup]
|
|
[P], 1);
|
|
DEBUG_WL_S(", Delay: ");
|
|
DEBUG_WL_D((u32)
|
|
dram_info->wl_val[cs][pup]
|
|
[D], 2);
|
|
DEBUG_WL_S("\n");
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/* Dynamic pad issue (BTS669) during WL */
|
|
#ifdef MV88F67XX
|
|
if (dpde_flag) {
|
|
reg = reg_read(REG_DUNIT_CTRL_LOW_ADDR) |
|
|
(1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS);
|
|
reg_write(REG_DUNIT_CTRL_LOW_ADDR, reg);
|
|
}
|
|
#endif
|
|
|
|
DEBUG_WL_S("DDR3 - Write Leveling - HW WL Ended Successfully\n");
|
|
|
|
return MV_OK;
|
|
} else {
|
|
DEBUG_WL_S("DDR3 - Write Leveling - HW WL Error\n");
|
|
return MV_FAIL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Name: ddr3_wl_supplement
|
|
* Desc: Write Leveling Supplement
|
|
* Args: dram_info - main struct
|
|
* Notes:
|
|
* Returns: MV_OK if success, MV_FAIL if fail.
|
|
*/
|
|
int ddr3_wl_supplement(MV_DRAM_INFO *dram_info)
|
|
{
|
|
u32 cs, cnt, pup_num, sum, phase, delay, max_pup_num, pup, sdram_offset;
|
|
u32 tmp_count, ecc, reg;
|
|
u32 ddr_width, tmp_pup, idx;
|
|
u32 sdram_pup_val, uj;
|
|
u32 one_clk_err = 0, align_err = 0, no_err = 0, err = 0, err_n = 0;
|
|
u32 sdram_data[LEN_WL_SUP_PATTERN] __aligned(32) = { 0 };
|
|
|
|
ddr_width = dram_info->ddr_width;
|
|
no_err = 0;
|
|
|
|
DEBUG_WL_S("DDR3 - Write Leveling Hi-Freq Supplement - Starting\n");
|
|
|
|
switch (ddr_width) {
|
|
/* Data error from pos-adge to pos-adge */
|
|
case 16:
|
|
one_clk_err = 4;
|
|
align_err = 4;
|
|
break;
|
|
case 32:
|
|
one_clk_err = 8;
|
|
align_err = 8;
|
|
break;
|
|
case 64:
|
|
one_clk_err = 0x10;
|
|
align_err = 0x10;
|
|
break;
|
|
default:
|
|
DEBUG_WL_S("Error - bus width!!!\n");
|
|
return MV_FAIL;
|
|
}
|
|
|
|
/* Enable SW override */
|
|
reg = reg_read(REG_DRAM_TRAINING_2_ADDR) |
|
|
(1 << REG_DRAM_TRAINING_2_SW_OVRD_OFFS);
|
|
|
|
/* [0] = 1 - Enable SW override */
|
|
/* 0x15B8 - Training SW 2 Register */
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR, reg);
|
|
DEBUG_WL_S("DDR3 - Write Leveling Hi-Freq Supplement - SW Override Enabled\n");
|
|
reg = (1 << REG_DRAM_TRAINING_AUTO_OFFS);
|
|
reg_write(REG_DRAM_TRAINING_ADDR, reg); /* 0x15B0 - Training Register */
|
|
tmp_count = 0;
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
sum = 0;
|
|
/*
|
|
* 2 iterations loop: 1)actual WL results 2) fix WL
|
|
* if needed
|
|
*/
|
|
for (cnt = 0; cnt < COUNT_WL_HI_FREQ; cnt++) {
|
|
DEBUG_WL_C("COUNT = ", cnt, 1);
|
|
for (ecc = 0; ecc < (dram_info->ecc_ena + 1);
|
|
ecc++) {
|
|
if (ecc) {
|
|
DEBUG_WL_S("ECC PUP:\n");
|
|
} else {
|
|
DEBUG_WL_S("DATA PUP:\n");
|
|
}
|
|
|
|
max_pup_num =
|
|
dram_info->num_of_std_pups * (1 -
|
|
ecc) +
|
|
ecc;
|
|
/* ECC Support - Switch ECC Mux on ecc=1 */
|
|
reg =
|
|
(reg_read(REG_DRAM_TRAINING_2_ADDR)
|
|
& ~(1 <<
|
|
REG_DRAM_TRAINING_2_ECC_MUX_OFFS));
|
|
reg |=
|
|
(dram_info->ecc_ena *
|
|
ecc <<
|
|
REG_DRAM_TRAINING_2_ECC_MUX_OFFS);
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR,
|
|
reg);
|
|
ddr3_reset_phy_read_fifo();
|
|
|
|
/* Write to memory */
|
|
sdram_offset =
|
|
tmp_count * (SDRAM_CS_SIZE + 1) +
|
|
0x200;
|
|
if (MV_OK != ddr3_dram_sram_burst((u32)
|
|
wl_sup_pattern,
|
|
sdram_offset,
|
|
LEN_WL_SUP_PATTERN))
|
|
return MV_FAIL;
|
|
|
|
/* Read from memory */
|
|
if (MV_OK !=
|
|
ddr3_dram_sram_burst(sdram_offset,
|
|
(u32)
|
|
sdram_data,
|
|
LEN_WL_SUP_PATTERN))
|
|
return MV_FAIL;
|
|
|
|
/* Print the buffer */
|
|
for (uj = 0; uj < LEN_WL_SUP_PATTERN;
|
|
uj++) {
|
|
if ((uj % 4 == 0) && (uj != 0)) {
|
|
DEBUG_WL_S("\n");
|
|
}
|
|
DEBUG_WL_D(sdram_data[uj],
|
|
8);
|
|
DEBUG_WL_S(" ");
|
|
}
|
|
|
|
/* Check pup which DQS/DATA is error */
|
|
for (pup = 0; pup < max_pup_num; pup++) {
|
|
/* ECC support - bit 8 */
|
|
pup_num = (ecc) ? ECC_PUP : pup;
|
|
if (pup < 4) { /* lower 32 bit */
|
|
tmp_pup = pup;
|
|
idx =
|
|
WL_SUP_READ_DRAM_ENTRY;
|
|
} else { /* higher 32 bit */
|
|
tmp_pup = pup - 4;
|
|
idx =
|
|
WL_SUP_READ_DRAM_ENTRY
|
|
+ 1;
|
|
}
|
|
DEBUG_WL_S("\nCS: ");
|
|
DEBUG_WL_D((u32) cs, 1);
|
|
DEBUG_WL_S(" PUP: ");
|
|
DEBUG_WL_D((u32) pup_num, 1);
|
|
DEBUG_WL_S("\n");
|
|
sdram_pup_val =
|
|
((sdram_data[idx] >>
|
|
((tmp_pup) * 8)) & 0xFF);
|
|
DEBUG_WL_C("Actual Data = ",
|
|
sdram_pup_val, 2);
|
|
DEBUG_WL_C("Expected Data = ",
|
|
(WL_SUP_EXPECTED_DATA
|
|
+ pup), 2);
|
|
/*
|
|
* ALINGHMENT: calculate
|
|
* expected data vs actual data
|
|
*/
|
|
err =
|
|
(WL_SUP_EXPECTED_DATA +
|
|
pup) - sdram_pup_val;
|
|
/*
|
|
* CLOCK LONG: calculate
|
|
* expected data vs actual data
|
|
*/
|
|
err_n =
|
|
sdram_pup_val -
|
|
(WL_SUP_EXPECTED_DATA +
|
|
pup);
|
|
DEBUG_WL_C("err = ", err, 2);
|
|
DEBUG_WL_C("err_n = ", err_n,
|
|
2);
|
|
if (err == no_err) {
|
|
/* PUP is correct - increment State */
|
|
dram_info->wl_val[cs]
|
|
[pup_num]
|
|
[S] = 1;
|
|
} else if (err_n == one_clk_err) {
|
|
/* clock is longer than DQS */
|
|
phase =
|
|
((dram_info->wl_val
|
|
[cs]
|
|
[pup_num][P] +
|
|
WL_HI_FREQ_SHIFT)
|
|
% MAX_PHASE_2TO1);
|
|
dram_info->wl_val[cs]
|
|
[pup_num]
|
|
[P] = phase;
|
|
delay =
|
|
dram_info->wl_val
|
|
[cs][pup_num]
|
|
[D];
|
|
DEBUG_WL_S("#### Clock is longer than DQS more than one clk cycle ####\n");
|
|
ddr3_write_pup_reg
|
|
(PUP_WL_MODE, cs,
|
|
pup * (1 - ecc) +
|
|
ECC_PUP * ecc,
|
|
phase, delay);
|
|
} else if (err == align_err) {
|
|
/* clock is align to DQS */
|
|
phase =
|
|
dram_info->wl_val
|
|
[cs][pup_num]
|
|
[P];
|
|
delay =
|
|
dram_info->wl_val
|
|
[cs][pup_num]
|
|
[D];
|
|
DEBUG_WL_S("#### Alignment PUPS problem ####\n");
|
|
if ((phase == 0)
|
|
|| ((phase == 1)
|
|
&& (delay <=
|
|
0x10))) {
|
|
DEBUG_WL_S("#### Warning - Possible Layout Violation (DQS is longer than CLK)####\n");
|
|
}
|
|
|
|
phase = 0x0;
|
|
delay = 0x0;
|
|
dram_info->wl_val[cs]
|
|
[pup_num]
|
|
[P] = phase;
|
|
dram_info->wl_val[cs]
|
|
[pup_num]
|
|
[D] = delay;
|
|
ddr3_write_pup_reg
|
|
(PUP_WL_MODE, cs,
|
|
pup * (1 - ecc) +
|
|
ECC_PUP * ecc,
|
|
phase, delay);
|
|
}
|
|
/* Stop condition for ECC phase */
|
|
pup = (ecc) ? max_pup_num : pup;
|
|
}
|
|
|
|
/* ECC Support - Disable ECC MUX */
|
|
reg =
|
|
(reg_read(REG_DRAM_TRAINING_2_ADDR)
|
|
& ~(1 <<
|
|
REG_DRAM_TRAINING_2_ECC_MUX_OFFS));
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR,
|
|
reg);
|
|
}
|
|
}
|
|
|
|
for (pup = 0; pup < dram_info->num_of_std_pups; pup++)
|
|
sum += dram_info->wl_val[cs][pup][S];
|
|
|
|
if (dram_info->ecc_ena)
|
|
sum += dram_info->wl_val[cs][ECC_PUP][S];
|
|
|
|
/* Checks if any pup is not locked after the change */
|
|
if (sum < (WL_HI_FREQ_STATE * (dram_info->num_of_total_pups))) {
|
|
DEBUG_WL_C("DDR3 - Write Leveling Hi-Freq Supplement - didn't work for Cs - ",
|
|
(u32) cs, 1);
|
|
return MV_FAIL;
|
|
}
|
|
tmp_count++;
|
|
}
|
|
}
|
|
|
|
dram_info->wl_max_phase = 0;
|
|
dram_info->wl_min_phase = 10;
|
|
|
|
/*
|
|
* Read results to arrays - Results are required for DQS Centralization
|
|
*/
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
for (pup = 0; pup < dram_info->num_of_total_pups; pup++) {
|
|
if (pup == dram_info->num_of_std_pups
|
|
&& dram_info->ecc_ena)
|
|
pup = ECC_PUP;
|
|
reg = ddr3_read_pup_reg(PUP_WL_MODE, cs, pup);
|
|
phase =
|
|
(reg >> REG_PHY_PHASE_OFFS) &
|
|
PUP_PHASE_MASK;
|
|
if (phase > dram_info->wl_max_phase)
|
|
dram_info->wl_max_phase = phase;
|
|
if (phase < dram_info->wl_min_phase)
|
|
dram_info->wl_min_phase = phase;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Disable SW override - Must be in a different stage */
|
|
/* [0]=0 - Enable SW override */
|
|
reg = reg_read(REG_DRAM_TRAINING_2_ADDR);
|
|
reg &= ~(1 << REG_DRAM_TRAINING_2_SW_OVRD_OFFS);
|
|
/* 0x15B8 - Training SW 2 Register */
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR, reg);
|
|
|
|
reg = reg_read(REG_DRAM_TRAINING_1_ADDR) |
|
|
(1 << REG_DRAM_TRAINING_1_TRNBPOINT_OFFS);
|
|
reg_write(REG_DRAM_TRAINING_1_ADDR, reg);
|
|
|
|
DEBUG_WL_S("DDR3 - Write Leveling Hi-Freq Supplement - Ended Successfully\n");
|
|
|
|
return MV_OK;
|
|
}
|
|
|
|
/*
|
|
* Name: ddr3_write_leveling_hw_reg_dimm
|
|
* Desc: Execute Write leveling phase by HW
|
|
* Args: freq - current sequence frequency
|
|
* dram_info - main struct
|
|
* Notes:
|
|
* Returns: MV_OK if success, MV_FAIL if fail.
|
|
*/
|
|
int ddr3_write_leveling_hw_reg_dimm(u32 freq, MV_DRAM_INFO *dram_info)
|
|
{
|
|
u32 reg, phase, delay, cs, pup, pup_num;
|
|
__maybe_unused int dpde_flag = 0;
|
|
|
|
/* Debug message - Start Read leveling procedure */
|
|
DEBUG_WL_S("DDR3 - Write Leveling - Starting HW WL procedure\n");
|
|
|
|
if (dram_info->num_cs > 2) {
|
|
DEBUG_WL_S("DDR3 - Write Leveling - HW WL Ended Successfully\n");
|
|
return MV_NO_CHANGE;
|
|
}
|
|
|
|
/* If target freq = 400 move clock start point */
|
|
/* Write to control PUP to Control Deskew Regs */
|
|
if (freq <= DDR_400) {
|
|
for (pup = 0; pup <= dram_info->num_of_total_pups; pup++) {
|
|
/* PUP_DELAY_MASK 0x1F */
|
|
/* reg = 0x0C10001F + (uj << 16); */
|
|
ddr3_write_ctrl_pup_reg(1, pup, CNTRL_PUP_DESKEW + pup,
|
|
0x1F);
|
|
}
|
|
}
|
|
|
|
#ifdef MV88F67XX
|
|
/* Dynamic pad issue (BTS669) during WL */
|
|
reg = reg_read(REG_DUNIT_CTRL_LOW_ADDR);
|
|
if (reg & (1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS)) {
|
|
dpde_flag = 1;
|
|
reg_write(REG_DUNIT_CTRL_LOW_ADDR,
|
|
reg & ~(1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS));
|
|
}
|
|
#endif
|
|
|
|
reg = (1 << REG_DRAM_TRAINING_WL_OFFS);
|
|
/* Config the retest number */
|
|
reg |= (COUNT_HW_WL << REG_DRAM_TRAINING_RETEST_OFFS);
|
|
reg |= (dram_info->cs_ena << (REG_DRAM_TRAINING_CS_OFFS));
|
|
reg_write(REG_DRAM_TRAINING_ADDR, reg); /* 0x15B0 - Training Register */
|
|
|
|
reg = reg_read(REG_DRAM_TRAINING_SHADOW_ADDR) |
|
|
(1 << REG_DRAM_TRAINING_AUTO_OFFS);
|
|
reg_write(REG_DRAM_TRAINING_SHADOW_ADDR, reg);
|
|
|
|
/* Wait */
|
|
do {
|
|
reg = reg_read(REG_DRAM_TRAINING_SHADOW_ADDR) &
|
|
(1 << REG_DRAM_TRAINING_AUTO_OFFS);
|
|
} while (reg); /* Wait for '0' */
|
|
|
|
reg = reg_read(REG_DRAM_TRAINING_ADDR);
|
|
/* Check if Successful */
|
|
if (reg & (1 << REG_DRAM_TRAINING_ERROR_OFFS)) {
|
|
/*
|
|
* Read results to arrays - Results are required for WL High
|
|
* freq Supplement and DQS Centralization
|
|
*/
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
for (pup = 0;
|
|
pup < dram_info->num_of_total_pups;
|
|
pup++) {
|
|
if (pup == dram_info->num_of_std_pups
|
|
&& dram_info->ecc_ena)
|
|
pup = ECC_BIT;
|
|
reg =
|
|
ddr3_read_pup_reg(PUP_WL_MODE, cs,
|
|
pup);
|
|
phase =
|
|
(reg >> REG_PHY_PHASE_OFFS) &
|
|
PUP_PHASE_MASK;
|
|
delay = reg & PUP_DELAY_MASK;
|
|
dram_info->wl_val[cs][pup][P] = phase;
|
|
dram_info->wl_val[cs][pup][D] = delay;
|
|
if ((phase == 1) && (delay >= 0x1D)) {
|
|
/*
|
|
* Need to do it here for
|
|
* uncorrect WL values
|
|
*/
|
|
ddr3_write_pup_reg(PUP_WL_MODE,
|
|
cs, pup, 0,
|
|
0);
|
|
dram_info->wl_val[cs][pup][P] =
|
|
0;
|
|
dram_info->wl_val[cs][pup][D] =
|
|
0;
|
|
}
|
|
dram_info->wl_val[cs][pup][S] =
|
|
WL_HI_FREQ_STATE - 1;
|
|
reg =
|
|
ddr3_read_pup_reg(PUP_WL_MODE + 0x1,
|
|
cs, pup);
|
|
dram_info->wl_val[cs][pup][DQS] =
|
|
(reg & 0x3F);
|
|
}
|
|
#ifdef MV_DEBUG_WL
|
|
/*
|
|
* Debug message - Print res for cs[i]:
|
|
* cs,PUP,Phase,Delay
|
|
*/
|
|
DEBUG_WL_S("DDR3 - Write Leveling - Write Leveling Cs - ");
|
|
DEBUG_WL_D((u32) cs, 1);
|
|
DEBUG_WL_S(" Results:\n");
|
|
for (pup = 0;
|
|
pup < dram_info->num_of_total_pups;
|
|
pup++) {
|
|
DEBUG_WL_S
|
|
("DDR3 - Write Leveling - PUP: ");
|
|
DEBUG_WL_D((u32) pup, 1);
|
|
DEBUG_WL_S(", Phase: ");
|
|
DEBUG_WL_D((u32)
|
|
dram_info->wl_val[cs][pup]
|
|
[P], 1);
|
|
DEBUG_WL_S(", Delay: ");
|
|
DEBUG_WL_D((u32)
|
|
dram_info->wl_val[cs][pup]
|
|
[D], 2);
|
|
DEBUG_WL_S("\n");
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#ifdef MV88F67XX
|
|
/* Dynamic pad issue (BTS669) during WL */
|
|
if (dpde_flag) {
|
|
reg = reg_read(REG_DUNIT_CTRL_LOW_ADDR) |
|
|
(1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS);
|
|
reg_write(REG_DUNIT_CTRL_LOW_ADDR, reg);
|
|
}
|
|
#endif
|
|
DEBUG_WL_S("DDR3 - Write Leveling - HW WL Ended Successfully\n");
|
|
|
|
/* If target freq = 400 move clock back */
|
|
/* Write to control PUP to Control Deskew Regs */
|
|
if (freq <= DDR_400) {
|
|
for (pup = 0; pup <= dram_info->num_of_total_pups;
|
|
pup++) {
|
|
ddr3_write_ctrl_pup_reg(1, pup,
|
|
CNTRL_PUP_DESKEW + pup, 0);
|
|
}
|
|
}
|
|
|
|
return MV_OK;
|
|
} else {
|
|
/* Configure Each PUP with locked leveling settings */
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
for (pup = 0;
|
|
pup < dram_info->num_of_total_pups;
|
|
pup++) {
|
|
/* ECC support - bit 8 */
|
|
pup_num = (pup == dram_info->num_of_std_pups) ?
|
|
ECC_BIT : pup;
|
|
ddr3_write_pup_reg(PUP_WL_MODE, cs,
|
|
pup_num, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
reg_write(REG_DRAM_TRAINING_ADDR, 0);
|
|
|
|
/* If target freq = 400 move clock back */
|
|
/* Write to control PUP to Control Deskew Regs */
|
|
if (freq <= DDR_400) {
|
|
for (pup = 0; pup <= dram_info->num_of_total_pups;
|
|
pup++) {
|
|
ddr3_write_ctrl_pup_reg(1, pup,
|
|
CNTRL_PUP_DESKEW + pup, 0);
|
|
}
|
|
}
|
|
|
|
DEBUG_WL_S("DDR3 - Write Leveling - HW WL Ended Successfully\n");
|
|
return MV_NO_CHANGE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Name: ddr3_write_leveling_sw
|
|
* Desc: Execute Write leveling phase by SW
|
|
* Args: freq - current sequence frequency
|
|
* dram_info - main struct
|
|
* Notes:
|
|
* Returns: MV_OK if success, MV_FAIL if fail.
|
|
*/
|
|
int ddr3_write_leveling_sw(u32 freq, int ratio_2to1, MV_DRAM_INFO *dram_info)
|
|
{
|
|
u32 reg, cs, cnt, pup, max_pup_num;
|
|
u32 res[MAX_CS];
|
|
max_pup_num = dram_info->num_of_total_pups;
|
|
__maybe_unused int dpde_flag = 0;
|
|
|
|
/* Debug message - Start Write leveling procedure */
|
|
DEBUG_WL_S("DDR3 - Write Leveling - Starting SW WL procedure\n");
|
|
|
|
#ifdef MV88F67XX
|
|
/* Dynamic pad issue (BTS669) during WL */
|
|
reg = reg_read(REG_DUNIT_CTRL_LOW_ADDR);
|
|
if (reg & (1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS)) {
|
|
dpde_flag = 1;
|
|
reg_write(REG_DUNIT_CTRL_LOW_ADDR,
|
|
reg & ~(1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS));
|
|
}
|
|
#endif
|
|
|
|
/* Set Output buffer-off to all CS and correct ODT values */
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
reg = reg_read(REG_DDR3_MR1_ADDR) &
|
|
REG_DDR3_MR1_ODT_MASK;
|
|
reg |= odt_static[dram_info->cs_ena][cs];
|
|
reg |= (1 << REG_DDR3_MR1_OUTBUF_DIS_OFFS);
|
|
|
|
/* 0x15D0 - DDR3 MR0 Register */
|
|
reg_write(REG_DDR3_MR1_ADDR, reg);
|
|
/* Issue MRS Command to current cs */
|
|
reg = REG_SDRAM_OPERATION_CMD_MR1 &
|
|
~(1 << (REG_SDRAM_OPERATION_CS_OFFS + cs));
|
|
/*
|
|
* [3-0] = 0x4 - MR1 Command, [11-8] -
|
|
* enable current cs
|
|
*/
|
|
/* 0x1418 - SDRAM Operation Register */
|
|
reg_write(REG_SDRAM_OPERATION_ADDR, reg);
|
|
|
|
udelay(MRS_DELAY);
|
|
}
|
|
}
|
|
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling - Qoff and RTT Values are set for all Cs\n");
|
|
|
|
/* Enable SW override */
|
|
reg = reg_read(REG_DRAM_TRAINING_2_ADDR) |
|
|
(1 << REG_DRAM_TRAINING_2_SW_OVRD_OFFS);
|
|
/* [0] = 1 - Enable SW override */
|
|
/* 0x15B8 - Training SW 2 Register */
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR, reg);
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling - SW Override Enabled\n");
|
|
|
|
/* Enable PHY write leveling mode */
|
|
reg = reg_read(REG_DRAM_TRAINING_2_ADDR) &
|
|
~(1 << REG_DRAM_TRAINING_2_WL_MODE_OFFS);
|
|
/* [2] = 0 - TrnWLMode - Enable */
|
|
/* 0x15B8 - Training SW 2 Register */
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR, reg);
|
|
/* Reset WL results arry */
|
|
memset(dram_info->wl_val, 0, sizeof(u32) * MAX_CS * MAX_PUP_NUM * 7);
|
|
|
|
/* Loop for each cs */
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
DEBUG_WL_FULL_C("DDR3 - Write Leveling - Starting working with Cs - ",
|
|
(u32) cs, 1);
|
|
/* Refresh X9 current cs */
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling - Refresh X9\n");
|
|
for (cnt = 0; cnt < COUNT_WL_RFRS; cnt++) {
|
|
reg =
|
|
REG_SDRAM_OPERATION_CMD_RFRS & ~(1 <<
|
|
(REG_SDRAM_OPERATION_CS_OFFS
|
|
+ cs));
|
|
/* [3-0] = 0x2 - refresh, [11-8] - enable current cs */
|
|
reg_write(REG_SDRAM_OPERATION_ADDR, reg); /* 0x1418 - SDRAM Operation Register */
|
|
|
|
do {
|
|
reg =
|
|
((reg_read
|
|
(REG_SDRAM_OPERATION_ADDR)) &
|
|
REG_SDRAM_OPERATION_CMD_RFRS_DONE);
|
|
} while (reg); /* Wait for '0' */
|
|
}
|
|
|
|
/* Configure MR1 in Cs[CsNum] - write leveling on, output buffer on */
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling - Configure MR1 for current Cs: WL-on,OB-on\n");
|
|
reg = reg_read(REG_DDR3_MR1_ADDR) &
|
|
REG_DDR3_MR1_OUTBUF_WL_MASK;
|
|
/* Set ODT Values */
|
|
reg &= REG_DDR3_MR1_ODT_MASK;
|
|
reg |= odt_static[dram_info->cs_ena][cs];
|
|
/* Enable WL MODE */
|
|
reg |= (1 << REG_DDR3_MR1_WL_ENA_OFFS);
|
|
/* [7]=1, [12]=0 - Output Buffer and write leveling enabled */
|
|
reg_write(REG_DDR3_MR1_ADDR, reg); /* 0x15D4 - DDR3 MR1 Register */
|
|
/* Issue MRS Command to current cs */
|
|
reg = REG_SDRAM_OPERATION_CMD_MR1 &
|
|
~(1 << (REG_SDRAM_OPERATION_CS_OFFS + cs));
|
|
/*
|
|
* [3-0] = 0x4 - MR1 Command, [11-8] -
|
|
* enable current cs
|
|
*/
|
|
/* 0x1418 - SDRAM Operation Register */
|
|
reg_write(REG_SDRAM_OPERATION_ADDR, reg);
|
|
|
|
udelay(MRS_DELAY);
|
|
|
|
/* Write leveling cs[cs] */
|
|
if (MV_OK !=
|
|
ddr3_write_leveling_single_cs(cs, freq, ratio_2to1,
|
|
(u32 *)(res + cs),
|
|
dram_info)) {
|
|
DEBUG_WL_FULL_C("DDR3 - Write Leveling single Cs - FAILED - Cs - ",
|
|
(u32) cs, 1);
|
|
for (pup = 0; pup < max_pup_num; pup++) {
|
|
if (((res[cs] >> pup) & 0x1) == 0) {
|
|
DEBUG_WL_C("Failed Byte : ",
|
|
pup, 1);
|
|
}
|
|
}
|
|
return MV_FAIL;
|
|
}
|
|
|
|
/* Set TrnWLDeUpd - After each CS is done */
|
|
reg = reg_read(REG_TRAINING_WL_ADDR) |
|
|
(1 << REG_TRAINING_WL_CS_DONE_OFFS);
|
|
/* 0x16AC - Training Write leveling register */
|
|
reg_write(REG_TRAINING_WL_ADDR, reg);
|
|
|
|
/*
|
|
* Debug message - Finished Write leveling cs[cs] -
|
|
* each PUP Fail/Success
|
|
*/
|
|
DEBUG_WL_FULL_C("DDR3 - Write Leveling - Finished Cs - ", (u32) cs,
|
|
1);
|
|
DEBUG_WL_FULL_C("DDR3 - Write Leveling - The Results: 1-PUP locked, 0-PUP failed -",
|
|
(u32) res[cs], 3);
|
|
|
|
/*
|
|
* Configure MR1 in cs[cs] - write leveling off (0),
|
|
* output buffer off (1)
|
|
*/
|
|
reg = reg_read(REG_DDR3_MR1_ADDR) &
|
|
REG_DDR3_MR1_OUTBUF_WL_MASK;
|
|
reg |= (1 << REG_DDR3_MR1_OUTBUF_DIS_OFFS);
|
|
/* No need to sort ODT since it is same CS */
|
|
/* 0x15D4 - DDR3 MR1 Register */
|
|
reg_write(REG_DDR3_MR1_ADDR, reg);
|
|
/* Issue MRS Command to current cs */
|
|
reg = REG_SDRAM_OPERATION_CMD_MR1 &
|
|
~(1 << (REG_SDRAM_OPERATION_CS_OFFS + cs));
|
|
/*
|
|
* [3-0] = 0x4 - MR1 Command, [11-8] -
|
|
* enable current cs
|
|
*/
|
|
/* 0x1418 - SDRAM Operation Register */
|
|
reg_write(REG_SDRAM_OPERATION_ADDR, reg);
|
|
|
|
udelay(MRS_DELAY);
|
|
}
|
|
}
|
|
|
|
/* Disable WL Mode */
|
|
/* [2]=1 - TrnWLMode - Disable */
|
|
reg = reg_read(REG_DRAM_TRAINING_2_ADDR);
|
|
reg |= (1 << REG_DRAM_TRAINING_2_WL_MODE_OFFS);
|
|
/* 0x15B8 - Training SW 2 Register */
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR, reg);
|
|
|
|
/* Disable SW override - Must be in a different stage */
|
|
/* [0]=0 - Enable SW override */
|
|
reg = reg_read(REG_DRAM_TRAINING_2_ADDR);
|
|
reg &= ~(1 << REG_DRAM_TRAINING_2_SW_OVRD_OFFS);
|
|
/* 0x15B8 - Training SW 2 Register */
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR, reg);
|
|
|
|
/* Set Output buffer-on to all CS and correct ODT values */
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
reg = reg_read(REG_DDR3_MR1_ADDR) &
|
|
REG_DDR3_MR1_ODT_MASK;
|
|
reg &= REG_DDR3_MR1_OUTBUF_WL_MASK;
|
|
reg |= odt_static[dram_info->cs_ena][cs];
|
|
|
|
/* 0x15D0 - DDR3 MR1 Register */
|
|
reg_write(REG_DDR3_MR1_ADDR, reg);
|
|
/* Issue MRS Command to current cs */
|
|
reg = REG_SDRAM_OPERATION_CMD_MR1 &
|
|
~(1 << (REG_SDRAM_OPERATION_CS_OFFS + cs));
|
|
/*
|
|
* [3-0] = 0x4 - MR1 Command, [11-8] -
|
|
* enable current cs
|
|
*/
|
|
/* 0x1418 - SDRAM Operation Register */
|
|
reg_write(REG_SDRAM_OPERATION_ADDR, reg);
|
|
|
|
udelay(MRS_DELAY);
|
|
}
|
|
}
|
|
|
|
#ifdef MV88F67XX
|
|
/* Dynamic pad issue (BTS669) during WL */
|
|
if (dpde_flag) {
|
|
reg = reg_read(REG_DUNIT_CTRL_LOW_ADDR) |
|
|
(1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS);
|
|
reg_write(REG_DUNIT_CTRL_LOW_ADDR, reg);
|
|
}
|
|
#endif
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling - Finished WL procedure for all Cs\n");
|
|
|
|
return MV_OK;
|
|
}
|
|
|
|
#if !defined(MV88F672X)
|
|
/*
|
|
* Name: ddr3_write_leveling_sw
|
|
* Desc: Execute Write leveling phase by SW
|
|
* Args: freq - current sequence frequency
|
|
* dram_info - main struct
|
|
* Notes:
|
|
* Returns: MV_OK if success, MV_FAIL if fail.
|
|
*/
|
|
int ddr3_write_leveling_sw_reg_dimm(u32 freq, int ratio_2to1,
|
|
MV_DRAM_INFO *dram_info)
|
|
{
|
|
u32 reg, cs, cnt, pup;
|
|
u32 res[MAX_CS];
|
|
__maybe_unused int dpde_flag = 0;
|
|
|
|
/* Debug message - Start Write leveling procedure */
|
|
DEBUG_WL_S("DDR3 - Write Leveling - Starting SW WL procedure\n");
|
|
|
|
#ifdef MV88F67XX
|
|
/* Dynamic pad issue (BTS669) during WL */
|
|
reg = reg_read(REG_DUNIT_CTRL_LOW_ADDR);
|
|
if (reg & (1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS)) {
|
|
dpde_flag = 1;
|
|
reg_write(REG_DUNIT_CTRL_LOW_ADDR,
|
|
reg & ~(1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS));
|
|
}
|
|
#endif
|
|
|
|
/* If target freq = 400 move clock start point */
|
|
/* Write to control PUP to Control Deskew Regs */
|
|
if (freq <= DDR_400) {
|
|
for (pup = 0; pup <= dram_info->num_of_total_pups; pup++) {
|
|
/* PUP_DELAY_MASK 0x1F */
|
|
/* reg = 0x0C10001F + (uj << 16); */
|
|
ddr3_write_ctrl_pup_reg(1, pup, CNTRL_PUP_DESKEW + pup,
|
|
0x1F);
|
|
}
|
|
}
|
|
|
|
/* Set Output buffer-off to all CS and correct ODT values */
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
reg = reg_read(REG_DDR3_MR1_ADDR) &
|
|
REG_DDR3_MR1_ODT_MASK;
|
|
reg |= odt_static[dram_info->cs_ena][cs];
|
|
reg |= (1 << REG_DDR3_MR1_OUTBUF_DIS_OFFS);
|
|
|
|
/* 0x15D0 - DDR3 MR0 Register */
|
|
reg_write(REG_DDR3_MR1_ADDR, reg);
|
|
/* Issue MRS Command to current cs */
|
|
reg = REG_SDRAM_OPERATION_CMD_MR1 &
|
|
~(1 << (REG_SDRAM_OPERATION_CS_OFFS + cs));
|
|
/*
|
|
* [3-0] = 0x4 - MR1 Command, [11-8] -
|
|
* enable current cs
|
|
*/
|
|
/* 0x1418 - SDRAM Operation Register */
|
|
reg_write(REG_SDRAM_OPERATION_ADDR, reg);
|
|
|
|
udelay(MRS_DELAY);
|
|
}
|
|
}
|
|
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling - Qoff and RTT Values are set for all Cs\n");
|
|
|
|
/* Enable SW override */
|
|
reg = reg_read(REG_DRAM_TRAINING_2_ADDR) |
|
|
(1 << REG_DRAM_TRAINING_2_SW_OVRD_OFFS);
|
|
/* [0] = 1 - Enable SW override */
|
|
/* 0x15B8 - Training SW 2 Register */
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR, reg);
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling - SW Override Enabled\n");
|
|
|
|
/* Enable PHY write leveling mode */
|
|
reg = reg_read(REG_DRAM_TRAINING_2_ADDR) &
|
|
~(1 << REG_DRAM_TRAINING_2_WL_MODE_OFFS);
|
|
/* [2] = 0 - TrnWLMode - Enable */
|
|
/* 0x15B8 - Training SW 2 Register */
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR, reg);
|
|
|
|
/* Loop for each cs */
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
DEBUG_WL_FULL_C("DDR3 - Write Leveling - Starting working with Cs - ",
|
|
(u32) cs, 1);
|
|
|
|
/* Refresh X9 current cs */
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling - Refresh X9\n");
|
|
for (cnt = 0; cnt < COUNT_WL_RFRS; cnt++) {
|
|
reg =
|
|
REG_SDRAM_OPERATION_CMD_RFRS & ~(1 <<
|
|
(REG_SDRAM_OPERATION_CS_OFFS
|
|
+ cs));
|
|
/* [3-0] = 0x2 - refresh, [11-8] - enable current cs */
|
|
reg_write(REG_SDRAM_OPERATION_ADDR, reg); /* 0x1418 - SDRAM Operation Register */
|
|
|
|
do {
|
|
reg =
|
|
((reg_read
|
|
(REG_SDRAM_OPERATION_ADDR)) &
|
|
REG_SDRAM_OPERATION_CMD_RFRS_DONE);
|
|
} while (reg); /* Wait for '0' */
|
|
}
|
|
|
|
/*
|
|
* Configure MR1 in Cs[CsNum] - write leveling on,
|
|
* output buffer on
|
|
*/
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling - Configure MR1 for current Cs: WL-on,OB-on\n");
|
|
reg = reg_read(REG_DDR3_MR1_ADDR) &
|
|
REG_DDR3_MR1_OUTBUF_WL_MASK;
|
|
/* Set ODT Values */
|
|
reg &= REG_DDR3_MR1_ODT_MASK;
|
|
reg |= odt_static[dram_info->cs_ena][cs];
|
|
/* Enable WL MODE */
|
|
reg |= (1 << REG_DDR3_MR1_WL_ENA_OFFS);
|
|
/*
|
|
* [7]=1, [12]=0 - Output Buffer and write leveling
|
|
* enabled
|
|
*/
|
|
/* 0x15D4 - DDR3 MR1 Register */
|
|
reg_write(REG_DDR3_MR1_ADDR, reg);
|
|
/* Issue MRS Command to current cs */
|
|
reg = REG_SDRAM_OPERATION_CMD_MR1 &
|
|
~(1 << (REG_SDRAM_OPERATION_CS_OFFS + cs));
|
|
/*
|
|
* [3-0] = 0x4 - MR1 Command, [11-8] -
|
|
* enable current cs
|
|
*/
|
|
/* 0x1418 - SDRAM Operation Register */
|
|
reg_write(REG_SDRAM_OPERATION_ADDR, reg);
|
|
|
|
udelay(MRS_DELAY);
|
|
|
|
/* Write leveling cs[cs] */
|
|
if (MV_OK !=
|
|
ddr3_write_leveling_single_cs(cs, freq, ratio_2to1,
|
|
(u32 *)(res + cs),
|
|
dram_info)) {
|
|
DEBUG_WL_FULL_C("DDR3 - Write Leveling single Cs - FAILED - Cs - ",
|
|
(u32) cs, 1);
|
|
return MV_FAIL;
|
|
}
|
|
|
|
/* Set TrnWLDeUpd - After each CS is done */
|
|
reg = reg_read(REG_TRAINING_WL_ADDR) |
|
|
(1 << REG_TRAINING_WL_CS_DONE_OFFS);
|
|
/* 0x16AC - Training Write leveling register */
|
|
reg_write(REG_TRAINING_WL_ADDR, reg);
|
|
|
|
/*
|
|
* Debug message - Finished Write leveling cs[cs] -
|
|
* each PUP Fail/Success
|
|
*/
|
|
DEBUG_WL_FULL_C("DDR3 - Write Leveling - Finished Cs - ", (u32) cs,
|
|
1);
|
|
DEBUG_WL_FULL_C("DDR3 - Write Leveling - The Results: 1-PUP locked, 0-PUP failed -",
|
|
(u32) res[cs], 3);
|
|
|
|
/* Configure MR1 in cs[cs] - write leveling off (0), output buffer off (1) */
|
|
reg = reg_read(REG_DDR3_MR1_ADDR) &
|
|
REG_DDR3_MR1_OUTBUF_WL_MASK;
|
|
reg |= (1 << REG_DDR3_MR1_OUTBUF_DIS_OFFS);
|
|
/* No need to sort ODT since it is same CS */
|
|
/* 0x15D4 - DDR3 MR1 Register */
|
|
reg_write(REG_DDR3_MR1_ADDR, reg);
|
|
/* Issue MRS Command to current cs */
|
|
reg = REG_SDRAM_OPERATION_CMD_MR1 &
|
|
~(1 << (REG_SDRAM_OPERATION_CS_OFFS + cs));
|
|
/*
|
|
* [3-0] = 0x4 - MR1 Command, [11-8] -
|
|
* enable current cs
|
|
*/
|
|
/* 0x1418 - SDRAM Operation Register */
|
|
reg_write(REG_SDRAM_OPERATION_ADDR, reg);
|
|
|
|
udelay(MRS_DELAY);
|
|
}
|
|
}
|
|
|
|
/* Disable WL Mode */
|
|
/* [2]=1 - TrnWLMode - Disable */
|
|
reg = reg_read(REG_DRAM_TRAINING_2_ADDR);
|
|
reg |= (1 << REG_DRAM_TRAINING_2_WL_MODE_OFFS);
|
|
/* 0x15B8 - Training SW 2 Register */
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR, reg);
|
|
|
|
/* Disable SW override - Must be in a different stage */
|
|
/* [0]=0 - Enable SW override */
|
|
reg = reg_read(REG_DRAM_TRAINING_2_ADDR);
|
|
reg &= ~(1 << REG_DRAM_TRAINING_2_SW_OVRD_OFFS);
|
|
/* 0x15B8 - Training SW 2 Register */
|
|
reg_write(REG_DRAM_TRAINING_2_ADDR, reg);
|
|
|
|
/* Set Output buffer-on to all CS and correct ODT values */
|
|
for (cs = 0; cs < MAX_CS; cs++) {
|
|
if (dram_info->cs_ena & (1 << cs)) {
|
|
reg = reg_read(REG_DDR3_MR1_ADDR) &
|
|
REG_DDR3_MR1_ODT_MASK;
|
|
reg &= REG_DDR3_MR1_OUTBUF_WL_MASK;
|
|
reg |= odt_static[dram_info->cs_ena][cs];
|
|
|
|
/* 0x15D0 - DDR3 MR1 Register */
|
|
reg_write(REG_DDR3_MR1_ADDR, reg);
|
|
/* Issue MRS Command to current cs */
|
|
reg = REG_SDRAM_OPERATION_CMD_MR1 &
|
|
~(1 << (REG_SDRAM_OPERATION_CS_OFFS + cs));
|
|
/*
|
|
* [3-0] = 0x4 - MR1 Command, [11-8] -
|
|
* enable current cs
|
|
*/
|
|
/* 0x1418 - SDRAM Operation Register */
|
|
reg_write(REG_SDRAM_OPERATION_ADDR, reg);
|
|
|
|
udelay(MRS_DELAY);
|
|
}
|
|
}
|
|
|
|
#ifdef MV88F67XX
|
|
/* Dynamic pad issue (BTS669) during WL */
|
|
if (dpde_flag) {
|
|
reg = reg_read(REG_DUNIT_CTRL_LOW_ADDR) |
|
|
(1 << REG_DUNIT_CTRL_LOW_DPDE_OFFS);
|
|
reg_write(REG_DUNIT_CTRL_LOW_ADDR, reg);
|
|
}
|
|
#endif
|
|
|
|
/* If target freq = 400 move clock back */
|
|
/* Write to control PUP to Control Deskew Regs */
|
|
if (freq <= DDR_400) {
|
|
for (pup = 0; pup <= dram_info->num_of_total_pups; pup++) {
|
|
ddr3_write_ctrl_pup_reg(1, pup, CNTRL_PUP_DESKEW + pup,
|
|
0);
|
|
}
|
|
}
|
|
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling - Finished WL procedure for all Cs\n");
|
|
return MV_OK;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Name: ddr3_write_leveling_single_cs
|
|
* Desc: Execute Write leveling for single Chip select
|
|
* Args: cs - current chip select
|
|
* freq - current sequence frequency
|
|
* result - res array
|
|
* dram_info - main struct
|
|
* Notes:
|
|
* Returns: MV_OK if success, MV_FAIL if fail.
|
|
*/
|
|
static int ddr3_write_leveling_single_cs(u32 cs, u32 freq, int ratio_2to1,
|
|
u32 *result, MV_DRAM_INFO *dram_info)
|
|
{
|
|
u32 reg, pup_num, delay, phase, phaseMax, max_pup_num, pup,
|
|
max_pup_mask;
|
|
|
|
max_pup_num = dram_info->num_of_total_pups;
|
|
*result = 0;
|
|
u32 flag[MAX_PUP_NUM] = { 0 };
|
|
|
|
DEBUG_WL_FULL_C("DDR3 - Write Leveling Single Cs - WL for Cs - ",
|
|
(u32) cs, 1);
|
|
|
|
switch (max_pup_num) {
|
|
case 2:
|
|
max_pup_mask = 0x3;
|
|
break;
|
|
case 4:
|
|
max_pup_mask = 0xf;
|
|
DEBUG_WL_C("max_pup_mask = ", max_pup_mask, 3);
|
|
break;
|
|
case 5:
|
|
max_pup_mask = 0x1f;
|
|
DEBUG_WL_C("max_pup_mask = ", max_pup_mask, 3);
|
|
break;
|
|
case 8:
|
|
max_pup_mask = 0xff;
|
|
DEBUG_WL_C("max_pup_mask = ", max_pup_mask, 3);
|
|
break;
|
|
case 9:
|
|
max_pup_mask = 0x1ff;
|
|
DEBUG_WL_C("max_pup_mask = ", max_pup_mask, 3);
|
|
break;
|
|
default:
|
|
DEBUG_WL_C("ddr3_write_leveling_single_cs wrong max_pup_num = ",
|
|
max_pup_num, 3);
|
|
return MV_FAIL;
|
|
}
|
|
|
|
/* CS ODT Override */
|
|
reg = reg_read(REG_SDRAM_ODT_CTRL_HIGH_ADDR) &
|
|
REG_SDRAM_ODT_CTRL_HIGH_OVRD_MASK;
|
|
reg |= (REG_SDRAM_ODT_CTRL_HIGH_OVRD_ENA << (2 * cs));
|
|
/* Set 0x3 - Enable ODT on the curent cs and disable on other cs */
|
|
/* 0x1498 - SDRAM ODT Control high */
|
|
reg_write(REG_SDRAM_ODT_CTRL_HIGH_ADDR, reg);
|
|
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling Single Cs - ODT Asserted for current Cs\n");
|
|
|
|
/* tWLMRD Delay */
|
|
/* Delay of minimum 40 Dram clock cycles - 20 Tclk cycles */
|
|
udelay(1);
|
|
|
|
/* [1:0] - current cs number */
|
|
reg = (reg_read(REG_TRAINING_WL_ADDR) & REG_TRAINING_WL_CS_MASK) | cs;
|
|
reg |= (1 << REG_TRAINING_WL_UPD_OFFS); /* [2] - trnWLCsUpd */
|
|
/* 0x16AC - Training Write leveling register */
|
|
reg_write(REG_TRAINING_WL_ADDR, reg);
|
|
|
|
/* Broadcast to all PUPs: Reset DQS phase, reset leveling delay */
|
|
ddr3_write_pup_reg(PUP_WL_MODE, cs, PUP_BC, 0, 0);
|
|
|
|
/* Seek Edge */
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling Single Cs - Seek Edge - Current Cs\n");
|
|
|
|
/* Drive DQS high for one cycle - All data PUPs */
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling Single Cs - Seek Edge - Driving DQS high for one cycle\n");
|
|
if (!ratio_2to1) {
|
|
reg = (reg_read(REG_TRAINING_WL_ADDR) &
|
|
REG_TRAINING_WL_RATIO_MASK) | REG_TRAINING_WL_1TO1;
|
|
} else {
|
|
reg = (reg_read(REG_TRAINING_WL_ADDR) &
|
|
REG_TRAINING_WL_RATIO_MASK) | REG_TRAINING_WL_2TO1;
|
|
}
|
|
/* 0x16AC - Training Write leveling register */
|
|
reg_write(REG_TRAINING_WL_ADDR, reg);
|
|
|
|
/* Wait tWLdelay */
|
|
do {
|
|
/* [29] - trnWLDelayExp */
|
|
reg = (reg_read(REG_TRAINING_WL_ADDR)) &
|
|
REG_TRAINING_WL_DELAYEXP_MASK;
|
|
} while (reg == 0x0); /* Wait for '1' */
|
|
|
|
/* Read WL res */
|
|
reg = (reg_read(REG_TRAINING_WL_ADDR) >> REG_TRAINING_WL_RESULTS_OFFS) &
|
|
REG_TRAINING_WL_RESULTS_MASK;
|
|
/* [28:20] - TrnWLResult */
|
|
|
|
if (!ratio_2to1) /* Different phase options for 2:1 or 1:1 modes */
|
|
phaseMax = MAX_PHASE_1TO1;
|
|
else
|
|
phaseMax = MAX_PHASE_2TO1;
|
|
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling Single Cs - Seek Edge - Shift DQS + Octet Leveling\n");
|
|
|
|
/* Shift DQS + Octet leveling */
|
|
for (phase = 0; phase < phaseMax; phase++) {
|
|
for (delay = 0; delay < MAX_DELAY; delay++) {
|
|
/* Broadcast to all PUPs: DQS phase,leveling delay */
|
|
ddr3_write_pup_reg(PUP_WL_MODE, cs, PUP_BC, phase,
|
|
delay);
|
|
|
|
udelay(1); /* Delay of 3 Tclk cycles */
|
|
|
|
DEBUG_WL_FULL_S("DDR3 - Write Leveling Single Cs - Seek Edge: Phase = ");
|
|
DEBUG_WL_FULL_D((u32) phase, 1);
|
|
DEBUG_WL_FULL_S(", Delay = ");
|
|
DEBUG_WL_FULL_D((u32) delay, 1);
|
|
DEBUG_WL_FULL_S("\n");
|
|
|
|
/* Drive DQS high for one cycle - All data PUPs */
|
|
if (!ratio_2to1) {
|
|
reg = (reg_read(REG_TRAINING_WL_ADDR) &
|
|
REG_TRAINING_WL_RATIO_MASK) |
|
|
REG_TRAINING_WL_1TO1;
|
|
} else {
|
|
reg = (reg_read(REG_TRAINING_WL_ADDR) &
|
|
REG_TRAINING_WL_RATIO_MASK) |
|
|
REG_TRAINING_WL_2TO1;
|
|
}
|
|
reg_write(REG_TRAINING_WL_ADDR, reg); /* 0x16AC */
|
|
|
|
/* Wait tWLdelay */
|
|
do {
|
|
reg = (reg_read(REG_TRAINING_WL_ADDR)) &
|
|
REG_TRAINING_WL_DELAYEXP_MASK;
|
|
} while (reg == 0x0); /* [29] Wait for '1' */
|
|
|
|
/* Read WL res */
|
|
reg = reg_read(REG_TRAINING_WL_ADDR);
|
|
reg = (reg >> REG_TRAINING_WL_RESULTS_OFFS) &
|
|
REG_TRAINING_WL_RESULTS_MASK; /* [28:20] */
|
|
|
|
DEBUG_WL_FULL_C("DDR3 - Write Leveling Single Cs - Seek Edge: Results = ",
|
|
(u32) reg, 3);
|
|
|
|
/* Update State machine */
|
|
for (pup = 0; pup < (max_pup_num); pup++) {
|
|
/* ECC support - bit 8 */
|
|
pup_num = (pup == dram_info->num_of_std_pups) ?
|
|
ECC_BIT : pup;
|
|
if (dram_info->wl_val[cs][pup][S] == 0) {
|
|
/* Update phase to PUP */
|
|
dram_info->wl_val[cs][pup][P] = phase;
|
|
/* Update delay to PUP */
|
|
dram_info->wl_val[cs][pup][D] = delay;
|
|
}
|
|
|
|
if (((reg >> pup_num) & 0x1) == 0)
|
|
flag[pup_num] = 1;
|
|
|
|
if (((reg >> pup_num) & 0x1)
|
|
&& (flag[pup_num] == 1)
|
|
&& (dram_info->wl_val[cs][pup][S] == 0)) {
|
|
/*
|
|
* If the PUP is locked now and in last
|
|
* counter states
|
|
*/
|
|
/* Go to next state */
|
|
dram_info->wl_val[cs][pup][S] = 1;
|
|
/* Set res */
|
|
*result = *result | (1 << pup_num);
|
|
}
|
|
}
|
|
|
|
/* If all locked - Break the loops - Finished */
|
|
if (*result == max_pup_mask) {
|
|
phase = phaseMax;
|
|
delay = MAX_DELAY;
|
|
DEBUG_WL_S("DDR3 - Write Leveling Single Cs - Seek Edge: All Locked\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Debug message - Print res for cs[i]: cs,PUP,Phase,Delay */
|
|
DEBUG_WL_C("DDR3 - Write Leveling - Results for CS - ", (u32) cs, 1);
|
|
for (pup = 0; pup < (max_pup_num); pup++) {
|
|
DEBUG_WL_S("DDR3 - Write Leveling - PUP: ");
|
|
DEBUG_WL_D((u32) pup, 1);
|
|
DEBUG_WL_S(", Phase: ");
|
|
DEBUG_WL_D((u32) dram_info->wl_val[cs][pup][P], 1);
|
|
DEBUG_WL_S(", Delay: ");
|
|
DEBUG_WL_D((u32) dram_info->wl_val[cs][pup][D], 2);
|
|
DEBUG_WL_S("\n");
|
|
}
|
|
|
|
/* Check if some not locked and return error */
|
|
if (*result != max_pup_mask) {
|
|
DEBUG_WL_S("DDR3 - Write Leveling - ERROR - not all PUPS were locked\n");
|
|
return MV_FAIL;
|
|
}
|
|
|
|
/* Configure Each PUP with locked leveling settings */
|
|
for (pup = 0; pup < (max_pup_num); pup++) {
|
|
/* ECC support - bit 8 */
|
|
pup_num = (pup == dram_info->num_of_std_pups) ? ECC_BIT : pup;
|
|
phase = dram_info->wl_val[cs][pup][P];
|
|
delay = dram_info->wl_val[cs][pup][D];
|
|
ddr3_write_pup_reg(PUP_WL_MODE, cs, pup_num, phase, delay);
|
|
}
|
|
|
|
/* CS ODT Override */
|
|
reg = reg_read(REG_SDRAM_ODT_CTRL_HIGH_ADDR) &
|
|
REG_SDRAM_ODT_CTRL_HIGH_OVRD_MASK;
|
|
/* 0x1498 - SDRAM ODT Control high */
|
|
reg_write(REG_SDRAM_ODT_CTRL_HIGH_ADDR, reg);
|
|
|
|
return MV_OK;
|
|
}
|
|
|
|
/*
|
|
* Perform DDR3 Control PUP Indirect Write
|
|
*/
|
|
static void ddr3_write_ctrl_pup_reg(int bc_acc, u32 pup, u32 reg_addr, u32 data)
|
|
{
|
|
u32 reg = 0;
|
|
|
|
/* Store value for write */
|
|
reg = (data & 0xFFFF);
|
|
|
|
/* Set bit 26 for control PHY access */
|
|
reg |= (1 << REG_PHY_CNTRL_OFFS);
|
|
|
|
/* Configure BC or UC access to PHYs */
|
|
if (bc_acc == 1)
|
|
reg |= (1 << REG_PHY_BC_OFFS);
|
|
else
|
|
reg |= (pup << REG_PHY_PUP_OFFS);
|
|
|
|
/* Set PHY register address to write to */
|
|
reg |= (reg_addr << REG_PHY_CS_OFFS);
|
|
|
|
reg_write(REG_PHY_REGISTRY_FILE_ACCESS_ADDR, reg); /* 0x16A0 */
|
|
reg |= REG_PHY_REGISTRY_FILE_ACCESS_OP_WR;
|
|
reg_write(REG_PHY_REGISTRY_FILE_ACCESS_ADDR, reg); /* 0x16A0 */
|
|
|
|
do {
|
|
reg = (reg_read(REG_PHY_REGISTRY_FILE_ACCESS_ADDR)) &
|
|
REG_PHY_REGISTRY_FILE_ACCESS_OP_DONE;
|
|
} while (reg); /* Wait for '0' to mark the end of the transaction */
|
|
}
|