mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-07-11 13:46:17 +09:00
83d290c56f
When U-Boot started using SPDX tags we were among the early adopters and there weren't a lot of other examples to borrow from. So we picked the area of the file that usually had a full license text and replaced it with an appropriate SPDX-License-Identifier: entry. Since then, the Linux Kernel has adopted SPDX tags and they place it as the very first line in a file (except where shebangs are used, then it's second line) and with slightly different comment styles than us. In part due to community overlap, in part due to better tag visibility and in part for other minor reasons, switch over to that style. This commit changes all instances where we have a single declared license in the tag as both the before and after are identical in tag contents. There's also a few places where I found we did not have a tag and have introduced one. Signed-off-by: Tom Rini <trini@konsulko.com>
1366 lines
39 KiB
C
1366 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 <spl.h>
|
|
#include <asm/io.h>
|
|
#include <asm/arch/cpu.h>
|
|
#include <asm/arch/soc.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 */
|
|
}
|