| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * Copyright (C) Marvell International Ltd. and its affiliates |
| */ |
| |
| #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 */ |
| } |