rockchip: rk3399: add dram driver
add dram driver, and kernel can through sip function talk to bl31 to
do ddr frequency scaling. and ddr auto powerdown.
Change-Id: I0d0f2869aed95e336c6e23ba96a9310985c84840
diff --git a/plat/rockchip/rk3399/drivers/dram/dram.c b/plat/rockchip/rk3399/drivers/dram/dram.c
new file mode 100644
index 0000000..3b39e8b
--- /dev/null
+++ b/plat/rockchip/rk3399/drivers/dram/dram.c
@@ -0,0 +1,2556 @@
+/*
+ * Copyright (c) 2016, ARM Limited and Contributors. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of ARM nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without specific
+ * prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <debug.h>
+#include <mmio.h>
+#include <plat_private.h>
+#include "dram.h"
+#include "dram_spec_timing.h"
+#include "string.h"
+#include "soc.h"
+#include "pmu.h"
+
+#include <delay_timer.h>
+
+#define CTL_TRAINING (1)
+#define PI_TRAINING (!CTL_TRAINING)
+
+#define EN_READ_GATE_TRAINING (1)
+#define EN_CA_TRAINING (0)
+#define EN_WRITE_LEVELING (0)
+#define EN_READ_LEVELING (0)
+#define EN_WDQ_LEVELING (0)
+
+#define ENPER_CS_TRAINING_FREQ (933)
+
+struct pll_div {
+ unsigned int mhz;
+ unsigned int refdiv;
+ unsigned int fbdiv;
+ unsigned int postdiv1;
+ unsigned int postdiv2;
+ unsigned int frac;
+ unsigned int freq;
+};
+
+static const struct pll_div dpll_rates_table[] = {
+
+ /* _mhz, _refdiv, _fbdiv, _postdiv1, _postdiv2 */
+ {.mhz = 933, .refdiv = 3, .fbdiv = 350, .postdiv1 = 3, .postdiv2 = 1},
+ {.mhz = 800, .refdiv = 1, .fbdiv = 100, .postdiv1 = 3, .postdiv2 = 1},
+ {.mhz = 732, .refdiv = 1, .fbdiv = 61, .postdiv1 = 2, .postdiv2 = 1},
+ {.mhz = 666, .refdiv = 1, .fbdiv = 111, .postdiv1 = 4, .postdiv2 = 1},
+ {.mhz = 600, .refdiv = 1, .fbdiv = 50, .postdiv1 = 2, .postdiv2 = 1},
+ {.mhz = 528, .refdiv = 1, .fbdiv = 66, .postdiv1 = 3, .postdiv2 = 1},
+ {.mhz = 400, .refdiv = 1, .fbdiv = 50, .postdiv1 = 3, .postdiv2 = 1},
+ {.mhz = 300, .refdiv = 1, .fbdiv = 50, .postdiv1 = 4, .postdiv2 = 1},
+ {.mhz = 200, .refdiv = 1, .fbdiv = 50, .postdiv1 = 3, .postdiv2 = 2},
+};
+
+static struct rk3399_ddr_cic_regs *const rk3399_ddr_cic = (void *)CIC_BASE;
+static struct rk3399_ddr_pctl_regs *const rk3399_ddr_pctl[2] = {
+ (void *)DDRC0_BASE, (void *)DDRC1_BASE
+};
+
+static struct rk3399_ddr_pi_regs *const rk3399_ddr_pi[2] = {
+ (void *)DDRC0_PI_BASE, (void *)DDRC1_PI_BASE
+};
+
+static struct rk3399_ddr_publ_regs *const rk3399_ddr_publ[2] = {
+ (void *)DDRC0_PHY_BASE, (void *)DDRC1_PHY_BASE
+};
+
+struct rk3399_dram_status {
+ uint32_t current_index;
+ uint32_t index_freq[2];
+ struct timing_related_config timing_config;
+ struct drv_odt_lp_config drv_odt_lp_cfg;
+};
+
+static struct rk3399_dram_status rk3399_dram_status;
+static struct ddr_dts_config_timing dts_parameter = {
+ .available = 0
+};
+
+static struct rk3399_sdram_default_config ddr3_default_config = {
+ .bl = 8,
+ .ap = 0,
+ .dramds = 40,
+ .dramodt = 120,
+ .burst_ref_cnt = 1,
+ .zqcsi = 0
+};
+
+static struct drv_odt_lp_config ddr3_drv_odt_default_config = {
+ .ddr3_speed_bin = DDR3_DEFAULT,
+ .pd_idle = 0,
+ .sr_idle = 0,
+ .sr_mc_gate_idle = 0,
+ .srpd_lite_idle = 0,
+ .standby_idle = 0,
+
+ .ddr3_dll_dis_freq = 300,
+ .phy_dll_dis_freq = 125,
+ .odt_dis_freq = 933,
+
+ .dram_side_drv = 40,
+ .dram_side_dq_odt = 120,
+ .dram_side_ca_odt = 120,
+
+ .phy_side_ca_drv = 40,
+ .phy_side_ck_cs_drv = 40,
+ .phy_side_dq_drv = 40,
+ .phy_side_odt = 240,
+};
+
+static struct rk3399_sdram_default_config lpddr3_default_config = {
+ .bl = 8,
+ .ap = 0,
+ .dramds = 34,
+ .dramodt = 240,
+ .burst_ref_cnt = 1,
+ .zqcsi = 0
+};
+
+static struct drv_odt_lp_config lpddr3_drv_odt_default_config = {
+ .ddr3_speed_bin = DDR3_DEFAULT,
+ .pd_idle = 0,
+ .sr_idle = 0,
+ .sr_mc_gate_idle = 0,
+ .srpd_lite_idle = 0,
+ .standby_idle = 0,
+
+ .ddr3_dll_dis_freq = 300,
+ .phy_dll_dis_freq = 125,
+ .odt_dis_freq = 666,
+
+ .dram_side_drv = 40,
+ .dram_side_dq_odt = 120,
+ .dram_side_ca_odt = 120,
+
+ .phy_side_ca_drv = 40,
+ .phy_side_ck_cs_drv = 40,
+ .phy_side_dq_drv = 40,
+ .phy_side_odt = 240,
+};
+
+static struct rk3399_sdram_default_config lpddr4_default_config = {
+ .bl = 16,
+ .ap = 0,
+ .dramds = 40,
+ .dramodt = 240,
+ .caodt = 240,
+ .burst_ref_cnt = 1,
+ .zqcsi = 0
+};
+
+static struct drv_odt_lp_config lpddr4_drv_odt_default_config = {
+ .ddr3_speed_bin = DDR3_DEFAULT,
+ .pd_idle = 0,
+ .sr_idle = 0,
+ .sr_mc_gate_idle = 0,
+ .srpd_lite_idle = 0,
+ .standby_idle = 0,
+
+ .ddr3_dll_dis_freq = 300,
+ .phy_dll_dis_freq = 125,
+ .odt_dis_freq = 933,
+
+ .dram_side_drv = 60,
+ .dram_side_dq_odt = 40,
+ .dram_side_ca_odt = 40,
+
+ .phy_side_ca_drv = 40,
+ .phy_side_ck_cs_drv = 80,
+ .phy_side_dq_drv = 80,
+ .phy_side_odt = 60,
+};
+
+uint32_t dcf_code[] = {
+#include "dcf_code.inc"
+};
+
+
+#define write_32(addr, value)\
+ mmio_write_32((uintptr_t)(addr), (uint32_t)(value))
+
+#define read_32(addr) \
+ mmio_read_32((uintptr_t)(addr))
+#define clrbits_32(addr, clear)\
+ mmio_clrbits_32((uintptr_t)(addr), (uint32_t)(clear))
+#define setbits_32(addr, set)\
+ mmio_setbits_32((uintptr_t)(addr), (uint32_t)(set))
+#define clrsetbits_32(addr, clear, set)\
+ mmio_clrsetbits_32((uintptr_t)(addr), (uint32_t)(clear),\
+ (uint32_t)(set))
+
+#define DCF_START_ADDR (SRAM_BASE + 0x1400)
+#define DCF_PARAM_ADDR (SRAM_BASE + 0x1000)
+
+/* DCF_PAMET */
+#define PARAM_DRAM_FREQ (0)
+#define PARAM_DPLL_CON0 (4)
+#define PARAM_DPLL_CON1 (8)
+#define PARAM_DPLL_CON2 (0xc)
+#define PARAM_DPLL_CON3 (0x10)
+#define PARAM_DPLL_CON4 (0x14)
+#define PARAM_DPLL_CON5 (0x18)
+/* equal to fn<<4 */
+#define PARAM_FREQ_SELECT (0x1c)
+
+static unsigned int get_cs_die_capability(struct rk3399_sdram_config
+ *psdram_config, unsigned int channel,
+ unsigned int cs)
+{
+ unsigned int die;
+ unsigned int cs_cap;
+ unsigned int row[2];
+
+ row[0] = psdram_config->ch[channel].cs0_row;
+ row[1] = psdram_config->ch[channel].cs1_row;
+ die = psdram_config->ch[channel].bus_width /
+ psdram_config->ch[channel].each_die_bus_width;
+ cs_cap = (1 << (row[cs] +
+ (psdram_config->ch[channel].bank / 4 + 1) +
+ psdram_config->ch[channel].col +
+ (psdram_config->ch[channel].bus_width / 16)));
+ if (psdram_config->ch[channel].each_die_6gb_or_12gb)
+ cs_cap = cs_cap * 3 / 4;
+
+ return (cs_cap / die);
+}
+
+static void sdram_config_init(struct rk3399_sdram_config *psdram_config)
+{
+ uint32_t os_reg2_val, i;
+
+ os_reg2_val = read_32(PMUGRF_BASE + PMUGRF_OSREG(2));
+
+ for (i = 0; i < READ_CH_CNT(os_reg2_val); i++) {
+ psdram_config->ch[i].bank = 1 << READ_BK_INFO(os_reg2_val, i);
+ psdram_config->ch[i].bus_width =
+ 8 * (1 << READ_BW_INFO(os_reg2_val, i));
+ psdram_config->ch[i].col = READ_COL_INFO(os_reg2_val, i);
+ psdram_config->ch[i].cs0_row =
+ READ_CS0_ROW_INFO(os_reg2_val, i);
+ psdram_config->ch[i].cs1_row =
+ READ_CS1_ROW_INFO(os_reg2_val, i);
+ psdram_config->ch[i].cs_cnt = READ_CS_INFO(os_reg2_val, i);
+ psdram_config->ch[i].each_die_6gb_or_12gb =
+ READ_CH_ROW_INFO(os_reg2_val, i);
+ psdram_config->ch[i].each_die_bus_width =
+ 8 * (1 << READ_DIE_BW_INFO(os_reg2_val, i));
+ }
+ psdram_config->dramtype = READ_DRAMTYPE_INFO(os_reg2_val);
+ psdram_config->channal_num = READ_CH_CNT(os_reg2_val);
+}
+
+static void drv_odt_lp_cfg_init(uint32_t dram_type,
+ struct ddr_dts_config_timing *dts_timing,
+ struct drv_odt_lp_config *drv_config)
+{
+ if ((dts_timing) && (dts_timing->available)) {
+ drv_config->ddr3_speed_bin = dts_timing->ddr3_speed_bin;
+ drv_config->pd_idle = dts_timing->pd_idle;
+ drv_config->sr_idle = dts_timing->sr_idle;
+ drv_config->sr_mc_gate_idle = dts_timing->sr_mc_gate_idle;
+ drv_config->srpd_lite_idle = dts_timing->srpd_lite_idle;
+ drv_config->standby_idle = dts_timing->standby_idle;
+ drv_config->ddr3_dll_dis_freq = dts_timing->ddr3_dll_dis_freq;
+ drv_config->phy_dll_dis_freq = dts_timing->phy_dll_dis_freq;
+ }
+
+ switch (dram_type) {
+ case DDR3:
+ if ((dts_timing) && (dts_timing->available)) {
+ drv_config->odt_dis_freq =
+ dts_timing->ddr3_odt_dis_freq;
+ drv_config->dram_side_drv = dts_timing->ddr3_drv;
+ drv_config->dram_side_dq_odt = dts_timing->ddr3_odt;
+ drv_config->phy_side_ca_drv =
+ dts_timing->phy_ddr3_ca_drv;
+ drv_config->phy_side_ck_cs_drv =
+ dts_timing->phy_ddr3_ca_drv;
+ drv_config->phy_side_dq_drv =
+ dts_timing->phy_ddr3_dq_drv;
+ drv_config->phy_side_odt = dts_timing->phy_ddr3_odt;
+ } else {
+ memcpy(drv_config, &ddr3_drv_odt_default_config,
+ sizeof(struct drv_odt_lp_config));
+ }
+ break;
+ case LPDDR3:
+ if ((dts_timing) && (dts_timing->available)) {
+ drv_config->odt_dis_freq =
+ dts_timing->lpddr3_odt_dis_freq;
+ drv_config->dram_side_drv = dts_timing->lpddr3_drv;
+ drv_config->dram_side_dq_odt = dts_timing->lpddr3_odt;
+ drv_config->phy_side_ca_drv =
+ dts_timing->phy_lpddr3_ca_drv;
+ drv_config->phy_side_ck_cs_drv =
+ dts_timing->phy_lpddr3_ca_drv;
+ drv_config->phy_side_dq_drv =
+ dts_timing->phy_lpddr3_dq_drv;
+ drv_config->phy_side_odt = dts_timing->phy_lpddr3_odt;
+
+ } else {
+ memcpy(drv_config, &lpddr3_drv_odt_default_config,
+ sizeof(struct drv_odt_lp_config));
+ }
+ break;
+ case LPDDR4:
+ default:
+ if ((dts_timing) && (dts_timing->available)) {
+ drv_config->odt_dis_freq =
+ dts_timing->lpddr4_odt_dis_freq;
+ drv_config->dram_side_drv = dts_timing->lpddr4_drv;
+ drv_config->dram_side_dq_odt =
+ dts_timing->lpddr4_dq_odt;
+ drv_config->dram_side_ca_odt =
+ dts_timing->lpddr4_ca_odt;
+ drv_config->phy_side_ca_drv =
+ dts_timing->phy_lpddr4_ca_drv;
+ drv_config->phy_side_ck_cs_drv =
+ dts_timing->phy_lpddr4_ck_cs_drv;
+ drv_config->phy_side_dq_drv =
+ dts_timing->phy_lpddr4_dq_drv;
+ drv_config->phy_side_odt = dts_timing->phy_lpddr4_odt;
+ } else {
+ memcpy(drv_config, &lpddr4_drv_odt_default_config,
+ sizeof(struct drv_odt_lp_config));
+ }
+ break;
+ }
+
+ switch (drv_config->phy_side_ca_drv) {
+ case 240:
+ drv_config->phy_side_ca_drv = PHY_DRV_ODT_240;
+ break;
+ case 120:
+ drv_config->phy_side_ca_drv = PHY_DRV_ODT_120;
+ break;
+ case 80:
+ drv_config->phy_side_ca_drv = PHY_DRV_ODT_80;
+ break;
+ case 60:
+ drv_config->phy_side_ca_drv = PHY_DRV_ODT_60;
+ break;
+ case 48:
+ drv_config->phy_side_ca_drv = PHY_DRV_ODT_48;
+ break;
+ case 40:
+ drv_config->phy_side_ca_drv = PHY_DRV_ODT_40;
+ break;
+ default:
+ drv_config->phy_side_ca_drv = PHY_DRV_ODT_34_3;
+ break;
+ };
+
+ switch (drv_config->phy_side_ck_cs_drv) {
+ case 240:
+ drv_config->phy_side_ck_cs_drv = PHY_DRV_ODT_240;
+ break;
+ case 120:
+ drv_config->phy_side_ck_cs_drv = PHY_DRV_ODT_120;
+ break;
+ case 80:
+ drv_config->phy_side_ck_cs_drv = PHY_DRV_ODT_80;
+ break;
+ case 60:
+ drv_config->phy_side_ck_cs_drv = PHY_DRV_ODT_60;
+ break;
+ case 48:
+ drv_config->phy_side_ck_cs_drv = PHY_DRV_ODT_48;
+ break;
+ case 40:
+ drv_config->phy_side_ck_cs_drv = PHY_DRV_ODT_40;
+ break;
+ default:
+ drv_config->phy_side_ck_cs_drv = PHY_DRV_ODT_34_3;
+ break;
+ }
+
+ switch (drv_config->phy_side_dq_drv) {
+ case 240:
+ drv_config->phy_side_dq_drv = PHY_DRV_ODT_240;
+ break;
+ case 120:
+ drv_config->phy_side_dq_drv = PHY_DRV_ODT_120;
+ break;
+ case 80:
+ drv_config->phy_side_dq_drv = PHY_DRV_ODT_80;
+ break;
+ case 60:
+ drv_config->phy_side_dq_drv = PHY_DRV_ODT_60;
+ break;
+ case 48:
+ drv_config->phy_side_dq_drv = PHY_DRV_ODT_48;
+ break;
+ case 40:
+ drv_config->phy_side_dq_drv = PHY_DRV_ODT_40;
+ break;
+ default:
+ drv_config->phy_side_dq_drv = PHY_DRV_ODT_34_3;
+ break;
+ }
+
+ switch (drv_config->phy_side_odt) {
+ case 240:
+ drv_config->phy_side_odt = PHY_DRV_ODT_240;
+ break;
+ case 120:
+ drv_config->phy_side_odt = PHY_DRV_ODT_120;
+ break;
+ case 80:
+ drv_config->phy_side_odt = PHY_DRV_ODT_80;
+ break;
+ case 60:
+ drv_config->phy_side_odt = PHY_DRV_ODT_60;
+ break;
+ case 48:
+ drv_config->phy_side_odt = PHY_DRV_ODT_48;
+ break;
+ case 40:
+ drv_config->phy_side_odt = PHY_DRV_ODT_40;
+ break;
+ default:
+ drv_config->phy_side_odt = PHY_DRV_ODT_34_3;
+ break;
+ }
+}
+
+static void sdram_timing_cfg_init(struct timing_related_config *ptiming_config,
+ struct rk3399_sdram_config *psdram_config,
+ struct drv_odt_lp_config *drv_config)
+{
+ uint32_t i, j;
+
+ for (i = 0; i < psdram_config->channal_num; i++) {
+ ptiming_config->dram_info[i].speed_rate =
+ drv_config->ddr3_speed_bin;
+ ptiming_config->dram_info[i].cs_cnt =
+ psdram_config->ch[i].cs_cnt;
+ for (j = 0; j < psdram_config->ch[i].cs_cnt; j++) {
+ ptiming_config->dram_info[i].per_die_capability[j] =
+ get_cs_die_capability(psdram_config, i, j);
+ }
+ }
+ ptiming_config->dram_type = psdram_config->dramtype;
+ ptiming_config->ch_cnt = psdram_config->channal_num;
+ switch (psdram_config->dramtype) {
+ case DDR3:
+ ptiming_config->bl = ddr3_default_config.bl;
+ ptiming_config->ap = ddr3_default_config.ap;
+ break;
+ case LPDDR3:
+ ptiming_config->bl = lpddr3_default_config.bl;
+ ptiming_config->ap = lpddr3_default_config.ap;
+ break;
+ case LPDDR4:
+ ptiming_config->bl = lpddr4_default_config.bl;
+ ptiming_config->ap = lpddr4_default_config.ap;
+ ptiming_config->rdbi = 0;
+ ptiming_config->wdbi = 0;
+ break;
+ }
+ ptiming_config->dramds = drv_config->dram_side_drv;
+ ptiming_config->dramodt = drv_config->dram_side_dq_odt;
+ ptiming_config->caodt = drv_config->dram_side_ca_odt;
+}
+
+struct lat_adj_pair {
+ uint32_t cl;
+ uint32_t rdlat_adj;
+ uint32_t cwl;
+ uint32_t wrlat_adj;
+};
+
+const struct lat_adj_pair ddr3_lat_adj[] = {
+ {6, 5, 5, 4},
+ {8, 7, 6, 5},
+ {10, 9, 7, 6},
+ {11, 9, 8, 7},
+ {13, 0xb, 9, 8},
+ {14, 0xb, 0xa, 9}
+};
+
+const struct lat_adj_pair lpddr3_lat_adj[] = {
+ {3, 2, 1, 0},
+ {6, 5, 3, 2},
+ {8, 7, 4, 3},
+ {9, 8, 5, 4},
+ {10, 9, 6, 5},
+ {11, 9, 6, 5},
+ {12, 0xa, 6, 5},
+ {14, 0xc, 8, 7},
+ {16, 0xd, 8, 7}
+};
+
+const struct lat_adj_pair lpddr4_lat_adj[] = {
+ {6, 5, 4, 2},
+ {10, 9, 6, 4},
+ {14, 0xc, 8, 6},
+ {20, 0x11, 0xa, 8},
+ {24, 0x15, 0xc, 0xa},
+ {28, 0x18, 0xe, 0xc},
+ {32, 0x1b, 0x10, 0xe},
+ {36, 0x1e, 0x12, 0x10}
+};
+
+static uint32_t get_rdlat_adj(uint32_t dram_type, uint32_t cl)
+{
+ const struct lat_adj_pair *p;
+ uint32_t cnt;
+ uint32_t i;
+
+ if (dram_type == DDR3) {
+ p = ddr3_lat_adj;
+ cnt = ARRAY_SIZE(ddr3_lat_adj);
+ } else if (dram_type == LPDDR3) {
+ p = lpddr3_lat_adj;
+ cnt = ARRAY_SIZE(lpddr3_lat_adj);
+ } else {
+ p = lpddr4_lat_adj;
+ cnt = ARRAY_SIZE(lpddr4_lat_adj);
+ }
+
+ for (i = 0; i < cnt; i++) {
+ if (cl == p[i].cl)
+ return p[i].rdlat_adj;
+ }
+ /* fail */
+ return 0xff;
+}
+
+static uint32_t get_wrlat_adj(uint32_t dram_type, uint32_t cwl)
+{
+ const struct lat_adj_pair *p;
+ uint32_t cnt;
+ uint32_t i;
+
+ if (dram_type == DDR3) {
+ p = ddr3_lat_adj;
+ cnt = ARRAY_SIZE(ddr3_lat_adj);
+ } else if (dram_type == LPDDR3) {
+ p = lpddr3_lat_adj;
+ cnt = ARRAY_SIZE(lpddr3_lat_adj);
+ } else {
+ p = lpddr4_lat_adj;
+ cnt = ARRAY_SIZE(lpddr4_lat_adj);
+ }
+
+ for (i = 0; i < cnt; i++) {
+ if (cwl == p[i].cwl)
+ return p[i].wrlat_adj;
+ }
+ /* fail */
+ return 0xff;
+}
+
+#define PI_REGS_DIMM_SUPPORT (0)
+#define PI_ADD_LATENCY (0)
+#define PI_DOUBLEFREEK (1)
+
+#define PI_PAD_DELAY_PS_VALUE (1000)
+#define PI_IE_ENABLE_VALUE (3000)
+#define PI_TSEL_ENABLE_VALUE (700)
+
+static uint32_t get_pi_rdlat_adj(struct dram_timing_t *pdram_timing)
+{
+ /*[DLLSUBTYPE2] == "STD_DENALI_HS" */
+ uint32_t rdlat, delay_adder, ie_enable, hs_offset, tsel_adder,
+ extra_adder, tsel_enable;
+
+ ie_enable = PI_IE_ENABLE_VALUE;
+ tsel_enable = PI_TSEL_ENABLE_VALUE;
+
+ rdlat = pdram_timing->cl + PI_ADD_LATENCY;
+ delay_adder = ie_enable / (1000000 / pdram_timing->mhz);
+ if ((ie_enable % (1000000 / pdram_timing->mhz)) != 0)
+ delay_adder++;
+ hs_offset = 0;
+ tsel_adder = 0;
+ extra_adder = 0;
+ /* rdlat = rdlat - (PREAMBLE_SUPPORT & 0x1); */
+ tsel_adder = tsel_enable / (1000000 / pdram_timing->mhz);
+ if ((tsel_enable % (1000000 / pdram_timing->mhz)) != 0)
+ tsel_adder++;
+ delay_adder = delay_adder - 1;
+ if (tsel_adder > delay_adder)
+ extra_adder = tsel_adder - delay_adder;
+ else
+ extra_adder = 0;
+ if (PI_REGS_DIMM_SUPPORT && PI_DOUBLEFREEK)
+ hs_offset = 2;
+ else
+ hs_offset = 1;
+
+ if (delay_adder > (rdlat - 1 - hs_offset)) {
+ rdlat = rdlat - tsel_adder;
+ } else {
+ if ((rdlat - delay_adder) < 2)
+ rdlat = 2;
+ else
+ rdlat = rdlat - delay_adder - extra_adder;
+ }
+
+ return rdlat;
+}
+
+static uint32_t get_pi_wrlat(struct dram_timing_t *pdram_timing,
+ struct timing_related_config *timing_config)
+{
+ uint32_t tmp;
+
+ if (timing_config->dram_type == LPDDR3) {
+ tmp = pdram_timing->cl;
+ if (tmp >= 14)
+ tmp = 8;
+ else if (tmp >= 10)
+ tmp = 6;
+ else if (tmp == 9)
+ tmp = 5;
+ else if (tmp == 8)
+ tmp = 4;
+ else if (tmp == 6)
+ tmp = 3;
+ else
+ tmp = 1;
+ } else {
+ tmp = 1;
+ }
+
+ return tmp;
+}
+
+static uint32_t get_pi_wrlat_adj(struct dram_timing_t *pdram_timing,
+ struct timing_related_config *timing_config)
+{
+ return get_pi_wrlat(pdram_timing, timing_config) + PI_ADD_LATENCY - 1;
+}
+
+static uint32_t get_pi_tdfi_phy_rdlat(struct dram_timing_t *pdram_timing,
+ struct timing_related_config *timing_config)
+{
+ /* [DLLSUBTYPE2] == "STD_DENALI_HS" */
+ uint32_t cas_lat, delay_adder, ie_enable, hs_offset, ie_delay_adder;
+ uint32_t mem_delay_ps, round_trip_ps;
+ uint32_t phy_internal_delay, lpddr_adder, dfi_adder, rdlat_delay;
+
+ ie_enable = PI_IE_ENABLE_VALUE;
+
+ delay_adder = ie_enable / (1000000 / pdram_timing->mhz);
+ if ((ie_enable % (1000000 / pdram_timing->mhz)) != 0)
+ delay_adder++;
+ delay_adder = delay_adder - 1;
+ if (PI_REGS_DIMM_SUPPORT && PI_DOUBLEFREEK)
+ hs_offset = 2;
+ else
+ hs_offset = 1;
+
+ cas_lat = pdram_timing->cl + PI_ADD_LATENCY;
+
+ if (delay_adder > (cas_lat - 1 - hs_offset)) {
+ ie_delay_adder = 0;
+ } else {
+ ie_delay_adder = ie_enable / (1000000 / pdram_timing->mhz);
+ if ((ie_enable % (1000000 / pdram_timing->mhz)) != 0)
+ ie_delay_adder++;
+ }
+
+ if (timing_config->dram_type == DDR3) {
+ mem_delay_ps = 0;
+ } else if (timing_config->dram_type == LPDDR4) {
+ mem_delay_ps = 3600;
+ } else if (timing_config->dram_type == LPDDR3) {
+ mem_delay_ps = 5500;
+ } else {
+ printf("get_pi_tdfi_phy_rdlat:dramtype unsupport\n");
+ return 0;
+ }
+ round_trip_ps = 1100 + 500 + mem_delay_ps + 500 + 600;
+ delay_adder = round_trip_ps / (1000000 / pdram_timing->mhz);
+ if ((round_trip_ps % (1000000 / pdram_timing->mhz)) != 0)
+ delay_adder++;
+
+ phy_internal_delay = 5 + 2 + 4;
+ lpddr_adder = mem_delay_ps / (1000000 / pdram_timing->mhz);
+ if ((mem_delay_ps % (1000000 / pdram_timing->mhz)) != 0)
+ lpddr_adder++;
+ dfi_adder = 0;
+ phy_internal_delay = phy_internal_delay + 2;
+ rdlat_delay = delay_adder + phy_internal_delay +
+ ie_delay_adder + lpddr_adder + dfi_adder;
+
+ rdlat_delay = rdlat_delay + 2;
+ return rdlat_delay;
+}
+
+static uint32_t get_pi_todtoff_min(struct dram_timing_t *pdram_timing,
+ struct timing_related_config *timing_config)
+{
+ uint32_t tmp, todtoff_min_ps;
+
+ if (timing_config->dram_type == LPDDR3)
+ todtoff_min_ps = 2500;
+ else if (timing_config->dram_type == LPDDR4)
+ todtoff_min_ps = 1500;
+ else
+ todtoff_min_ps = 0;
+ /* todtoff_min */
+ tmp = todtoff_min_ps / (1000000 / pdram_timing->mhz);
+ if ((todtoff_min_ps % (1000000 / pdram_timing->mhz)) != 0)
+ tmp++;
+ return tmp;
+}
+
+static uint32_t get_pi_todtoff_max(struct dram_timing_t *pdram_timing,
+ struct timing_related_config *timing_config)
+{
+ uint32_t tmp, todtoff_max_ps;
+
+ if ((timing_config->dram_type == LPDDR4)
+ || (timing_config->dram_type == LPDDR3))
+ todtoff_max_ps = 3500;
+ else
+ todtoff_max_ps = 0;
+
+ /* todtoff_max */
+ tmp = todtoff_max_ps / (1000000 / pdram_timing->mhz);
+ if ((todtoff_max_ps % (1000000 / pdram_timing->mhz)) != 0)
+ tmp++;
+ return tmp;
+}
+
+static void gen_rk3399_ctl_params_f0(struct timing_related_config
+ *timing_config,
+ struct dram_timing_t *pdram_timing)
+{
+ uint32_t i;
+ uint32_t tmp, tmp1;
+
+ for (i = 0; i < timing_config->ch_cnt; i++) {
+ if (timing_config->dram_type == DDR3) {
+ tmp = ((700000 + 10) * timing_config->freq +
+ 999) / 1000;
+ tmp += pdram_timing->txsnr + (pdram_timing->tmrd * 3) +
+ pdram_timing->tmod + pdram_timing->tzqinit;
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[5], tmp);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[22],
+ 0xffff, pdram_timing->tdllk);
+
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[32],
+ (pdram_timing->tmod << 8) |
+ pdram_timing->tmrd);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[59],
+ 0xffff << 16,
+ (pdram_timing->txsr -
+ pdram_timing->trcd) << 16);
+ } else if (timing_config->dram_type == LPDDR4) {
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[5],
+ pdram_timing->tinit1 + pdram_timing->tinit3);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[32],
+ (pdram_timing->tmrd << 8) |
+ pdram_timing->tmrd);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[59],
+ 0xffff << 16, pdram_timing->txsr << 16);
+ } else {
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[5],
+ pdram_timing->tinit1);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[7],
+ pdram_timing->tinit4);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[32],
+ (pdram_timing->tmrd << 8) |
+ pdram_timing->tmrd);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[59],
+ 0xffff << 16, pdram_timing->txsr << 16);
+ }
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[6],
+ pdram_timing->tinit3);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[8],
+ pdram_timing->tinit5);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[23], (0x7f << 16),
+ ((pdram_timing->cl * 2) << 16));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[23], (0x1f << 24),
+ (pdram_timing->cwl << 24));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[24], 0x3f,
+ pdram_timing->al);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[26], 0xffff << 16,
+ (pdram_timing->trc << 24) |
+ (pdram_timing->trrd << 16));
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[27],
+ (pdram_timing->tfaw << 24) |
+ (pdram_timing->trppb << 16) |
+ (pdram_timing->twtr << 8) | pdram_timing->tras_min);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[31], 0xff << 24,
+ max(4, pdram_timing->trtp) << 24);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[33],
+ (pdram_timing->tcke << 24) | pdram_timing->tras_max);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[34], 0xff,
+ max(1, pdram_timing->tckesr));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[39],
+ (0x3f << 16) | (0xff << 8),
+ (pdram_timing->twr << 16) |
+ (pdram_timing->trcd << 8));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[42], 0x1f << 16,
+ pdram_timing->tmrz << 16);
+ tmp = pdram_timing->tdal ? pdram_timing->tdal :
+ (pdram_timing->twr + pdram_timing->trp);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[44], 0xff, tmp);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[45], 0xff,
+ pdram_timing->trp);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[48],
+ ((pdram_timing->trefi - 8) << 16) |
+ pdram_timing->trfc);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[52], 0xffff,
+ pdram_timing->txp);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[53], 0xffff << 16,
+ pdram_timing->txpdll << 16);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[55], 0xf << 24,
+ pdram_timing->tcscke << 24);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[55], 0xff,
+ pdram_timing->tmrri);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[56],
+ (pdram_timing->tzqcke << 24) |
+ (pdram_timing->tmrwckel << 16) |
+ (pdram_timing->tckehcs << 8) | pdram_timing->tckelcs);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[60], 0xffff,
+ pdram_timing->txsnr);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[62], 0xffff << 16,
+ (pdram_timing->tckehcmd << 24) |
+ (pdram_timing->tckelcmd << 16));
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[63],
+ (pdram_timing->tckelpd << 24) |
+ (pdram_timing->tescke << 16) |
+ (pdram_timing->tsr << 8) | pdram_timing->tckckel);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[64], 0xfff,
+ (pdram_timing->tcmdcke << 8) |
+ pdram_timing->tcsckeh);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[92],
+ (0xffff << 8),
+ (pdram_timing->tcksrx << 16) |
+ (pdram_timing->tcksre << 8));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[108], (0x1 << 24),
+ (timing_config->dllbp << 24));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[122],
+ (0x3FF << 16),
+ (pdram_timing->tvrcg_enable << 16));
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[123],
+ (pdram_timing->tfc_long << 16) |
+ pdram_timing->tvrcg_disable);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[124],
+ (pdram_timing->tvref_long << 16) |
+ (pdram_timing->tckfspx << 8) |
+ pdram_timing->tckfspe);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[133],
+ (pdram_timing->mr[1] << 16) | pdram_timing->mr[0]);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[134], 0xffff,
+ pdram_timing->mr[2]);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[138], 0xffff,
+ pdram_timing->mr[3]);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[139], 0xff << 24,
+ pdram_timing->mr11 << 24);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[147],
+ (pdram_timing->mr[1] << 16) | pdram_timing->mr[0]);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[148], 0xffff,
+ pdram_timing->mr[2]);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[152], 0xffff,
+ pdram_timing->mr[3]);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[153], 0xff << 24,
+ pdram_timing->mr11 << 24);
+ if (timing_config->dram_type == LPDDR4) {
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[140],
+ 0xffff << 16, pdram_timing->mr12 << 16);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[142],
+ 0xffff << 16, pdram_timing->mr14 << 16);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[145],
+ 0xffff << 16, pdram_timing->mr22 << 16);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[154],
+ 0xffff << 16, pdram_timing->mr12 << 16);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[156],
+ 0xffff << 16, pdram_timing->mr14 << 16);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[159],
+ 0xffff << 16, pdram_timing->mr22 << 16);
+ }
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[179], 0xfff << 8,
+ pdram_timing->tzqinit << 8);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[180],
+ (pdram_timing->tzqcs << 16) |
+ (pdram_timing->tzqinit / 2));
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[181],
+ (pdram_timing->tzqlat << 16) | pdram_timing->tzqcal);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[212], 0xff << 8,
+ pdram_timing->todton << 8);
+
+ if (timing_config->odt) {
+ setbits_32(&rk3399_ddr_pctl[i]->denali_ctl[213],
+ 1 << 16);
+ if (timing_config->freq < 400)
+ tmp = 4 << 24;
+ else
+ tmp = 8 << 24;
+ } else {
+ clrbits_32(&rk3399_ddr_pctl[i]->denali_ctl[213],
+ 1 << 16);
+ tmp = 2 << 24;
+ }
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[216],
+ 0x1f << 24, tmp);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[221],
+ (0x3 << 16) | (0xf << 8),
+ (pdram_timing->tdqsck << 16) |
+ (pdram_timing->tdqsck_max << 8));
+ tmp =
+ (get_wrlat_adj(timing_config->dram_type, pdram_timing->cwl)
+ << 8) | get_rdlat_adj(timing_config->dram_type,
+ pdram_timing->cl);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[284], 0xffff,
+ tmp);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[82], 0xffff << 16,
+ (4 * pdram_timing->trefi) << 16);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[83], 0xffff,
+ (2 * pdram_timing->trefi) & 0xffff);
+
+ if ((timing_config->dram_type == LPDDR3) ||
+ (timing_config->dram_type == LPDDR4)) {
+ tmp = get_pi_wrlat(pdram_timing, timing_config);
+ tmp1 = get_pi_todtoff_max(pdram_timing, timing_config);
+ tmp = (tmp > tmp1) ? (tmp - tmp1) : 0;
+ } else {
+ tmp = 0;
+ }
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[214], 0x3f << 16,
+ (tmp & 0x3f) << 16);
+
+ if ((timing_config->dram_type == LPDDR3) ||
+ (timing_config->dram_type == LPDDR4)) {
+ /* min_rl_preamble= cl+TDQSCK_MIN-1 */
+ tmp = pdram_timing->cl +
+ get_pi_todtoff_min(pdram_timing, timing_config) - 1;
+ /* todtoff_max */
+ tmp1 = get_pi_todtoff_max(pdram_timing, timing_config);
+ tmp = (tmp > tmp1) ? (tmp - tmp1) : 0;
+ } else {
+ tmp = pdram_timing->cl - pdram_timing->cwl;
+ }
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[215], 0x3f << 8,
+ (tmp & 0x3f) << 8);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[275], 0xff << 16,
+ (get_pi_tdfi_phy_rdlat
+ (pdram_timing, timing_config)
+ & 0xff) << 16);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[277], 0xffff,
+ (2 * pdram_timing->trefi) & 0xffff);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[282], 0xffff,
+ (2 * pdram_timing->trefi) & 0xffff);
+
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[283],
+ 20 * pdram_timing->trefi);
+
+ /* CTL_308 TDFI_CALVL_CAPTURE_F0:RW:16:10 */
+ tmp1 = 20000 / (1000000 / pdram_timing->mhz) + 1;
+ if ((20000 % (1000000 / pdram_timing->mhz)) != 0)
+ tmp1++;
+ tmp = (tmp1 >> 1) + (tmp1 % 2) + 5;
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[308], 0x3ff << 16,
+ tmp << 16);
+
+ /* CTL_308 TDFI_CALVL_CC_F0:RW:0:10 */
+ tmp = tmp + 18;
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[308], 0x3ff,
+ tmp);
+
+ /* CTL_314 TDFI_WRCSLAT_F0:RW:8:8 */
+ tmp1 = get_pi_wrlat_adj(pdram_timing, timing_config);
+ if (timing_config->freq <= ENPER_CS_TRAINING_FREQ) {
+ if (tmp1 < 5) {
+ if (tmp1 == 0)
+ tmp = 0;
+ else
+ tmp = tmp1 - 1;
+ } else {
+ tmp = tmp1 - 5;
+ }
+ } else {
+ tmp = tmp1 - 2;
+ }
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[314], 0xff << 8,
+ tmp << 8);
+
+ /* CTL_314 TDFI_RDCSLAT_F0:RW:0:8 */
+ if ((timing_config->freq <= ENPER_CS_TRAINING_FREQ) &&
+ (pdram_timing->cl >= 5))
+ tmp = pdram_timing->cl - 5;
+ else
+ tmp = pdram_timing->cl - 2;
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[314], 0xff,
+ tmp);
+ }
+}
+
+static void gen_rk3399_ctl_params_f1(struct timing_related_config
+ *timing_config,
+ struct dram_timing_t *pdram_timing)
+{
+ uint32_t i;
+ uint32_t tmp, tmp1;
+
+ for (i = 0; i < timing_config->ch_cnt; i++) {
+ if (timing_config->dram_type == DDR3) {
+ tmp =
+ ((700000 + 10) * timing_config->freq +
+ 999) / 1000;
+ tmp +=
+ pdram_timing->txsnr + (pdram_timing->tmrd * 3) +
+ pdram_timing->tmod + pdram_timing->tzqinit;
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[9], tmp);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[22],
+ 0xffff << 16, pdram_timing->tdllk << 16);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[34],
+ 0xffffff00,
+ (pdram_timing->tmod << 24) |
+ (pdram_timing->tmrd << 16) |
+ (pdram_timing->trtp << 8));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[60],
+ 0xffff << 16,
+ (pdram_timing->txsr -
+ pdram_timing->trcd) << 16);
+ } else if (timing_config->dram_type == LPDDR4) {
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[9],
+ pdram_timing->tinit1 + pdram_timing->tinit3);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[34],
+ 0xffffff00,
+ (pdram_timing->tmrd << 24) |
+ (pdram_timing->tmrd << 16) |
+ (pdram_timing->trtp << 8));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[60],
+ 0xffff << 16, pdram_timing->txsr << 16);
+ } else {
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[9],
+ pdram_timing->tinit1);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[11],
+ pdram_timing->tinit4);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[34],
+ 0xffffff00,
+ (pdram_timing->tmrd << 24) |
+ (pdram_timing->tmrd << 16) |
+ (pdram_timing->trtp << 8));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[60],
+ 0xffff << 16, pdram_timing->txsr << 16);
+ }
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[10],
+ pdram_timing->tinit3);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[12],
+ pdram_timing->tinit5);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[24], (0x7f << 8),
+ ((pdram_timing->cl * 2) << 8));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[24], (0x1f << 16),
+ (pdram_timing->cwl << 16));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[24], 0x3f << 24,
+ pdram_timing->al << 24);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[28], 0xffffff00,
+ (pdram_timing->tras_min << 24) |
+ (pdram_timing->trc << 16) |
+ (pdram_timing->trrd << 8));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[29], 0xffffff,
+ (pdram_timing->tfaw << 16) |
+ (pdram_timing->trppb << 8) | pdram_timing->twtr);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[35],
+ (pdram_timing->tcke << 24) | pdram_timing->tras_max);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[36], 0xff,
+ max(1, pdram_timing->tckesr));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[39],
+ (0xff << 24), (pdram_timing->trcd << 24));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[40],
+ 0x3f, pdram_timing->twr);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[42], 0x1f << 24,
+ pdram_timing->tmrz << 24);
+ tmp = pdram_timing->tdal ? pdram_timing->tdal :
+ (pdram_timing->twr + pdram_timing->trp);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[44], 0xff << 8,
+ tmp << 8);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[45], 0xff << 8,
+ pdram_timing->trp << 8);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[49],
+ ((pdram_timing->trefi - 8) << 16) |
+ pdram_timing->trfc);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[52], 0xffff << 16,
+ pdram_timing->txp << 16);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[54], 0xffff,
+ pdram_timing->txpdll);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[55], 0xff << 8,
+ pdram_timing->tmrri << 8);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[57],
+ (pdram_timing->tmrwckel << 24) |
+ (pdram_timing->tckehcs << 16) |
+ (pdram_timing->tckelcs << 8) | pdram_timing->tcscke);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[58], 0xf,
+ pdram_timing->tzqcke);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[61], 0xffff,
+ pdram_timing->txsnr);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[64], 0xffff << 16,
+ (pdram_timing->tckehcmd << 24) |
+ (pdram_timing->tckelcmd << 16));
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[65],
+ (pdram_timing->tckelpd << 24) |
+ (pdram_timing->tescke << 16) |
+ (pdram_timing->tsr << 8) | pdram_timing->tckckel);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[66], 0xfff,
+ (pdram_timing->tcmdcke << 8) |
+ pdram_timing->tcsckeh);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[92], (0xff << 24),
+ (pdram_timing->tcksre << 24));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[93], 0xff,
+ pdram_timing->tcksrx);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[108], (0x1 << 25),
+ (timing_config->dllbp << 25));
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[125],
+ (pdram_timing->tvrcg_disable << 16) |
+ pdram_timing->tvrcg_enable);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[126],
+ (pdram_timing->tckfspx << 24) |
+ (pdram_timing->tckfspe << 16) |
+ pdram_timing->tfc_long);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[127], 0xffff,
+ pdram_timing->tvref_long);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[134],
+ 0xffff << 16, pdram_timing->mr[0] << 16);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[135],
+ (pdram_timing->mr[2] << 16) | pdram_timing->mr[1]);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[138],
+ 0xffff << 16, pdram_timing->mr[3] << 16);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[140], 0xff,
+ pdram_timing->mr11);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[148],
+ 0xffff << 16, pdram_timing->mr[0] << 16);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[149],
+ (pdram_timing->mr[2] << 16) | pdram_timing->mr[1]);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[152],
+ 0xffff << 16, pdram_timing->mr[3] << 16);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[154], 0xff,
+ pdram_timing->mr11);
+ if (timing_config->dram_type == LPDDR4) {
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[141],
+ 0xffff, pdram_timing->mr12);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[143],
+ 0xffff, pdram_timing->mr14);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[146],
+ 0xffff, pdram_timing->mr22);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[155],
+ 0xffff, pdram_timing->mr12);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[157],
+ 0xffff, pdram_timing->mr14);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[160],
+ 0xffff, pdram_timing->mr22);
+ }
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[182],
+ ((pdram_timing->tzqinit / 2) << 16) |
+ pdram_timing->tzqinit);
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[183],
+ (pdram_timing->tzqcal << 16) | pdram_timing->tzqcs);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[184], 0x3f,
+ pdram_timing->tzqlat);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[188], 0xfff,
+ pdram_timing->tzqreset);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[212], 0xff << 16,
+ pdram_timing->todton << 16);
+
+ if (timing_config->odt) {
+ setbits_32(&rk3399_ddr_pctl[i]->denali_ctl[213],
+ (1 << 24));
+ if (timing_config->freq < 400)
+ tmp = 4 << 24;
+ else
+ tmp = 8 << 24;
+ } else {
+ clrbits_32(&rk3399_ddr_pctl[i]->denali_ctl[213],
+ (1 << 24));
+ tmp = 2 << 24;
+ }
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[217], 0x1f << 24,
+ tmp);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[221], 0xf << 24,
+ (pdram_timing->tdqsck_max << 24));
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[222], 0x3,
+ pdram_timing->tdqsck);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[291], 0xffff,
+ (get_wrlat_adj(timing_config->dram_type,
+ pdram_timing->cwl) << 8) |
+ get_rdlat_adj(timing_config->dram_type,
+ pdram_timing->cl));
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[84], 0xffff,
+ (4 * pdram_timing->trefi) & 0xffff);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[84], 0xffff << 16,
+ ((2 * pdram_timing->trefi) & 0xffff) << 16);
+
+ if ((timing_config->dram_type == LPDDR3) ||
+ (timing_config->dram_type == LPDDR4)) {
+ tmp = get_pi_wrlat(pdram_timing, timing_config);
+ tmp1 = get_pi_todtoff_max(pdram_timing, timing_config);
+ tmp = (tmp > tmp1) ? (tmp - tmp1) : 0;
+ } else {
+ tmp = 0;
+ }
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[214], 0x3f << 24,
+ (tmp & 0x3f) << 24);
+
+ if ((timing_config->dram_type == LPDDR3) ||
+ (timing_config->dram_type == LPDDR4)) {
+ /* min_rl_preamble= cl+TDQSCK_MIN-1 */
+ tmp = pdram_timing->cl +
+ get_pi_todtoff_min(pdram_timing, timing_config) - 1;
+ /* todtoff_max */
+ tmp1 = get_pi_todtoff_max(pdram_timing, timing_config);
+ tmp = (tmp > tmp1) ? (tmp - tmp1) : 0;
+ } else {
+ tmp = pdram_timing->cl - pdram_timing->cwl;
+ }
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[215], 0x3f << 16,
+ (tmp & 0x3f) << 16);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[275], 0xff << 24,
+ (get_pi_tdfi_phy_rdlat
+ (pdram_timing, timing_config)
+ & 0xff) << 24);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[284],
+ 0xffff << 16,
+ ((2 * pdram_timing->trefi) & 0xffff) << 16);
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[289], 0xffff,
+ (2 * pdram_timing->trefi) & 0xffff);
+
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[290],
+ 20 * pdram_timing->trefi);
+
+ /* CTL_309 TDFI_CALVL_CAPTURE_F1:RW:16:10 */
+ tmp1 = 20000 / (1000000 / pdram_timing->mhz) + 1;
+ if ((20000 % (1000000 / pdram_timing->mhz)) != 0)
+ tmp1++;
+ tmp = (tmp1 >> 1) + (tmp1 % 2) + 5;
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[309], 0x3ff << 16,
+ tmp << 16);
+
+ /* CTL_309 TDFI_CALVL_CC_F1:RW:0:10 */
+ tmp = tmp + 18;
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[309], 0x3ff,
+ tmp);
+
+ /* CTL_314 TDFI_WRCSLAT_F1:RW:24:8 */
+ tmp1 = get_pi_wrlat_adj(pdram_timing, timing_config);
+ if (timing_config->freq <= ENPER_CS_TRAINING_FREQ) {
+ if (tmp1 < 5) {
+ if (tmp1 == 0)
+ tmp = 0;
+ else
+ tmp = tmp1 - 1;
+ } else {
+ tmp = tmp1 - 5;
+ }
+ } else {
+ tmp = tmp1 - 2;
+ }
+
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[314], 0xff << 24,
+ tmp << 24);
+
+ /* CTL_314 TDFI_RDCSLAT_F1:RW:16:8 */
+ if ((timing_config->freq <= ENPER_CS_TRAINING_FREQ) &&
+ (pdram_timing->cl >= 5))
+ tmp = pdram_timing->cl - 5;
+ else
+ tmp = pdram_timing->cl - 2;
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[314], 0xff << 16,
+ tmp << 16);
+ }
+}
+
+static void gen_rk3399_ctl_params(struct timing_related_config *timing_config,
+ struct dram_timing_t *pdram_timing,
+ uint32_t fn)
+{
+ if (fn == 0)
+ gen_rk3399_ctl_params_f0(timing_config, pdram_timing);
+ else
+ gen_rk3399_ctl_params_f1(timing_config, pdram_timing);
+
+#if CTL_TRAINING
+ uint32_t i, tmp0, tmp1;
+
+ tmp0 = tmp1 = 0;
+#if EN_READ_GATE_TRAINING
+ tmp1 = 1;
+#endif
+
+#if EN_CA_TRAINING
+ tmp0 |= (1 << 8);
+#endif
+
+#if EN_WRITE_LEVELING
+ tmp0 |= (1 << 16);
+#endif
+
+#if EN_READ_LEVELING
+ tmp0 |= (1 << 24);
+#endif
+ for (i = 0; i < timing_config->ch_cnt; i++) {
+ if (tmp0 | tmp1)
+ setbits_32(&rk3399_ddr_pctl[i]->denali_ctl[305],
+ 1 << 16);
+ if (tmp0)
+ setbits_32(&rk3399_ddr_pctl[i]->denali_ctl[70], tmp0);
+ if (tmp1)
+ setbits_32(&rk3399_ddr_pctl[i]->denali_ctl[71], tmp1);
+ }
+#endif
+}
+
+static void gen_rk3399_pi_params_f0(struct timing_related_config *timing_config,
+ struct dram_timing_t *pdram_timing)
+{
+ uint32_t tmp, tmp1, tmp2;
+ uint32_t i;
+
+ for (i = 0; i < timing_config->ch_cnt; i++) {
+ /* PI_02 PI_TDFI_PHYMSTR_MAX_F0:RW:0:32 */
+ tmp = 4 * pdram_timing->trefi;
+ write_32(&rk3399_ddr_pi[i]->denali_pi[2], tmp);
+ /* PI_03 PI_TDFI_PHYMSTR_RESP_F0:RW:0:16 */
+ tmp = 2 * pdram_timing->trefi;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[3], 0xffff, tmp);
+ /* PI_07 PI_TDFI_PHYUPD_RESP_F0:RW:16:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[7], 0xffff << 16,
+ tmp << 16);
+
+ /* PI_42 PI_TDELAY_RDWR_2_BUS_IDLE_F0:RW:0:8 */
+ if (timing_config->dram_type == LPDDR4)
+ tmp = 2;
+ else
+ tmp = 0;
+ tmp = (pdram_timing->bl / 2) + 4 +
+ (get_pi_rdlat_adj(pdram_timing) - 2) + tmp +
+ get_pi_tdfi_phy_rdlat(pdram_timing, timing_config);
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[42], 0xff, tmp);
+ /* PI_43 PI_WRLAT_F0:RW:0:5 */
+ if (timing_config->dram_type == LPDDR3) {
+ tmp = get_pi_wrlat(pdram_timing, timing_config);
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[43], 0x1f,
+ tmp);
+ }
+ /* PI_43 PI_ADDITIVE_LAT_F0:RW:8:6 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[43], 0x3f << 8,
+ PI_ADD_LATENCY << 8);
+
+ /* PI_43 PI_CASLAT_LIN_F0:RW:16:7 */
+ tmp = pdram_timing->cl * 2;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[43], 0x7f << 16,
+ tmp << 16);
+ /* PI_46 PI_TREF_F0:RW:16:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[46], 0xffff << 16,
+ pdram_timing->trefi << 16);
+ /* PI_46 PI_TRFC_F0:RW:0:10 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[46], 0x3ff,
+ pdram_timing->trfc);
+ /* PI_66 PI_TODTL_2CMD_F0:RW:24:8 */
+ if (timing_config->dram_type == LPDDR3) {
+ tmp = get_pi_todtoff_max(pdram_timing, timing_config);
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[66],
+ 0xff << 24, tmp << 24);
+ }
+ /* PI_72 PI_WR_TO_ODTH_F0:RW:16:6 */
+ if ((timing_config->dram_type == LPDDR3) ||
+ (timing_config->dram_type == LPDDR4)) {
+ tmp1 = get_pi_wrlat(pdram_timing, timing_config);
+ tmp2 = get_pi_todtoff_max(pdram_timing, timing_config);
+ if (tmp1 > tmp2)
+ tmp = tmp1 - tmp2;
+ else
+ tmp = 0;
+ } else if (timing_config->dram_type == DDR3) {
+ tmp = 0;
+ }
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[72], 0x3f << 16,
+ tmp << 16);
+ /* PI_73 PI_RD_TO_ODTH_F0:RW:8:6 */
+ if ((timing_config->dram_type == LPDDR3) ||
+ (timing_config->dram_type == LPDDR4)) {
+ /* min_rl_preamble= cl+TDQSCK_MIN-1 */
+ tmp1 = pdram_timing->cl +
+ get_pi_todtoff_min(pdram_timing, timing_config) - 1;
+ /* todtoff_max */
+ tmp2 = get_pi_todtoff_max(pdram_timing, timing_config);
+ if (tmp1 > tmp2)
+ tmp = tmp1 - tmp2;
+ else
+ tmp = 0;
+ } else if (timing_config->dram_type == DDR3) {
+ tmp = pdram_timing->cl - pdram_timing->cwl;
+ }
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[73], 0x3f << 8,
+ tmp << 8);
+ /* PI_89 PI_RDLAT_ADJ_F0:RW:16:8 */
+ tmp = get_pi_rdlat_adj(pdram_timing);
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[89], 0xff << 16,
+ tmp << 16);
+ /* PI_90 PI_WRLAT_ADJ_F0:RW:16:8 */
+ tmp = get_pi_wrlat_adj(pdram_timing, timing_config);
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[90], 0xff << 16,
+ tmp << 16);
+ /* PI_91 PI_TDFI_WRCSLAT_F0:RW:16:8 */
+ tmp1 = tmp;
+ if (tmp1 < 5) {
+ if (tmp1 == 0)
+ tmp = 0;
+ else
+ tmp = tmp1 - 1;
+ } else {
+ tmp = tmp1 - 5;
+ }
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[91], 0xff << 16,
+ tmp << 16);
+ /* PI_95 PI_TDFI_CALVL_CAPTURE_F0:RW:16:10 */
+ tmp1 = 20000 / (1000000 / pdram_timing->mhz) + 1;
+ if ((20000 % (1000000 / pdram_timing->mhz)) != 0)
+ tmp1++;
+ tmp = (tmp1 >> 1) + (tmp1 % 2) + 5;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[95], 0x3ff << 16,
+ tmp << 16);
+ /* PI_95 PI_TDFI_CALVL_CC_F0:RW:0:10 */
+ tmp = tmp + 18;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[95], 0x3ff, tmp);
+ /* PI_102 PI_TMRZ_F0:RW:8:5 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[102], 0x1f << 8,
+ pdram_timing->tmrz << 8);
+ /* PI_111 PI_TDFI_CALVL_STROBE_F0:RW:8:4 */
+ tmp1 = 2 * 1000 / (1000000 / pdram_timing->mhz);
+ if ((2 * 1000 % (1000000 / pdram_timing->mhz)) != 0)
+ tmp1++;
+ /* pi_tdfi_calvl_strobe=tds_train+5 */
+ tmp = tmp1 + 5;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[111], 0xf << 8,
+ tmp << 8);
+ /* PI_116 PI_TCKEHDQS_F0:RW:16:6 */
+ tmp = 10000 / (1000000 / pdram_timing->mhz);
+ if ((10000 % (1000000 / pdram_timing->mhz)) != 0)
+ tmp++;
+ if (pdram_timing->mhz <= 100)
+ tmp = tmp + 1;
+ else
+ tmp = tmp + 8;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[116], 0x3f << 16,
+ tmp << 16);
+ /* PI_125 PI_MR1_DATA_F0_0:RW+:8:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[125], 0xffff << 8,
+ pdram_timing->mr[1] << 8);
+ /* PI_133 PI_MR1_DATA_F0_1:RW+:0:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[133], 0xffff,
+ pdram_timing->mr[1]);
+ /* PI_140 PI_MR1_DATA_F0_2:RW+:16:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[140], 0xffff << 16,
+ pdram_timing->mr[1] << 16);
+ /* PI_148 PI_MR1_DATA_F0_3:RW+:0:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[148], 0xffff,
+ pdram_timing->mr[1]);
+ /* PI_126 PI_MR2_DATA_F0_0:RW+:0:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[126], 0xffff,
+ pdram_timing->mr[2]);
+ /* PI_133 PI_MR2_DATA_F0_1:RW+:16:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[133], 0xffff << 16,
+ pdram_timing->mr[2] << 16);
+ /* PI_141 PI_MR2_DATA_F0_2:RW+:0:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[141], 0xffff,
+ pdram_timing->mr[2]);
+ /* PI_148 PI_MR2_DATA_F0_3:RW+:16:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[148], 0xffff << 16,
+ pdram_timing->mr[2] << 16);
+ /* PI_156 PI_TFC_F0:RW:0:10 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[156], 0x3ff,
+ pdram_timing->trfc);
+ /* PI_158 PI_TWR_F0:RW:24:6 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[158], 0x3f << 24,
+ pdram_timing->twr << 24);
+ /* PI_158 PI_TWTR_F0:RW:16:6 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[158], 0x3f << 16,
+ pdram_timing->twtr << 16);
+ /* PI_158 PI_TRCD_F0:RW:8:8 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[158], 0xff << 8,
+ pdram_timing->trcd << 8);
+ /* PI_158 PI_TRP_F0:RW:0:8 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[158], 0xff,
+ pdram_timing->trp);
+ /* PI_157 PI_TRTP_F0:RW:24:8 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[157], 0xff << 24,
+ pdram_timing->trtp << 24);
+ /* PI_159 PI_TRAS_MIN_F0:RW:24:8 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[159], 0xff << 24,
+ pdram_timing->tras_min << 24);
+ /* PI_159 PI_TRAS_MAX_F0:RW:0:17 */
+ tmp = pdram_timing->tras_max * 99 / 100;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[159], 0x1ffff, tmp);
+ /* PI_160 PI_TMRD_F0:RW:16:6 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[160], 0x3f << 16,
+ pdram_timing->tmrd << 16);
+ /*PI_160 PI_TDQSCK_MAX_F0:RW:0:4 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[160], 0xf,
+ pdram_timing->tdqsck_max);
+ /* PI_187 PI_TDFI_CTRLUPD_MAX_F0:RW:8:16 */
+ tmp = 2 * pdram_timing->trefi;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[187], 0xffff << 8,
+ tmp << 8);
+ /* PI_188 PI_TDFI_CTRLUPD_INTERVAL_F0:RW:0:32 */
+ tmp = 20 * pdram_timing->trefi;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[188], 0xffffffff,
+ tmp);
+ }
+}
+
+static void gen_rk3399_pi_params_f1(struct timing_related_config *timing_config,
+ struct dram_timing_t *pdram_timing)
+{
+ uint32_t tmp, tmp1, tmp2;
+ uint32_t i;
+
+ for (i = 0; i < timing_config->ch_cnt; i++) {
+ /* PI_04 PI_TDFI_PHYMSTR_MAX_F1:RW:0:32 */
+ tmp = 4 * pdram_timing->trefi;
+ write_32(&rk3399_ddr_pi[i]->denali_pi[4], tmp);
+ /* PI_05 PI_TDFI_PHYMSTR_RESP_F1:RW:0:16 */
+ tmp = 2 * pdram_timing->trefi;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[5], 0xffff, tmp);
+ /* PI_12 PI_TDFI_PHYUPD_RESP_F1:RW:0:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[12], 0xffff, tmp);
+
+ /* PI_42 PI_TDELAY_RDWR_2_BUS_IDLE_F1:RW:8:8 */
+ if (timing_config->dram_type == LPDDR4)
+ tmp = 2;
+ else
+ tmp = 0;
+ tmp = (pdram_timing->bl / 2) + 4 +
+ (get_pi_rdlat_adj(pdram_timing) - 2) + tmp +
+ get_pi_tdfi_phy_rdlat(pdram_timing, timing_config);
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[42], 0xff << 8,
+ tmp << 8);
+ /* PI_43 PI_WRLAT_F1:RW:24:5 */
+ if (timing_config->dram_type == LPDDR3) {
+ tmp = get_pi_wrlat(pdram_timing, timing_config);
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[43],
+ 0x1f << 24, tmp << 24);
+ }
+ /* PI_44 PI_ADDITIVE_LAT_F1:RW:0:6 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[44], 0x3f,
+ PI_ADD_LATENCY);
+ /* PI_44 PI_CASLAT_LIN_F1:RW:8:7:=0x18 */
+ tmp = pdram_timing->cl * 2;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[44], 0x7f << 8,
+ tmp << 8);
+ /* PI_47 PI_TREF_F1:RW:16:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[47], 0xffff << 16,
+ pdram_timing->trefi << 16);
+ /* PI_47 PI_TRFC_F1:RW:0:10 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[47], 0x3ff,
+ pdram_timing->trfc);
+ /* PI_67 PI_TODTL_2CMD_F1:RW:8:8 */
+ if (timing_config->dram_type == LPDDR3) {
+ tmp = get_pi_todtoff_max(pdram_timing, timing_config);
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[67],
+ 0xff << 8, tmp << 8);
+ }
+ /* PI_72 PI_WR_TO_ODTH_F1:RW:24:6 */
+ if ((timing_config->dram_type == LPDDR3)
+ || (timing_config->dram_type == LPDDR4)) {
+ tmp1 = get_pi_wrlat(pdram_timing, timing_config);
+ tmp2 = get_pi_todtoff_max(pdram_timing, timing_config);
+ if (tmp1 > tmp2)
+ tmp = tmp1 - tmp2;
+ else
+ tmp = 0;
+ } else if (timing_config->dram_type == DDR3) {
+ tmp = 0;
+ }
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[72], 0x3f << 24,
+ tmp << 24);
+ /* PI_73 PI_RD_TO_ODTH_F1:RW:16:6 */
+ if ((timing_config->dram_type == LPDDR3)
+ || (timing_config->dram_type == LPDDR4)) {
+ /* min_rl_preamble= cl+TDQSCK_MIN-1 */
+ tmp1 =
+ pdram_timing->cl + get_pi_todtoff_min(pdram_timing,
+ timing_config)
+ - 1;
+ /* todtoff_max */
+ tmp2 = get_pi_todtoff_max(pdram_timing, timing_config);
+ if (tmp1 > tmp2)
+ tmp = tmp1 - tmp2;
+ else
+ tmp = 0;
+ } else if (timing_config->dram_type == DDR3) {
+ tmp = pdram_timing->cl - pdram_timing->cwl;
+ }
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[73], 0x3f << 16,
+ tmp << 16);
+ /*P I_89 PI_RDLAT_ADJ_F1:RW:24:8 */
+ tmp = get_pi_rdlat_adj(pdram_timing);
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[89], 0xff << 24,
+ tmp << 24);
+ /* PI_90 PI_WRLAT_ADJ_F1:RW:24:8 */
+ tmp = get_pi_wrlat_adj(pdram_timing, timing_config);
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[90], 0xff << 24,
+ tmp << 24);
+ /* PI_91 PI_TDFI_WRCSLAT_F1:RW:24:8 */
+ tmp1 = tmp;
+ if (tmp1 < 5) {
+ if (tmp1 == 0)
+ tmp = 0;
+ else
+ tmp = tmp1 - 1;
+ } else {
+ tmp = tmp1 - 5;
+ }
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[91], 0xff << 24,
+ tmp << 24);
+ /*PI_96 PI_TDFI_CALVL_CAPTURE_F1:RW:16:10 */
+ /* tadr=20ns */
+ tmp1 = 20000 / (1000000 / pdram_timing->mhz) + 1;
+ if ((20000 % (1000000 / pdram_timing->mhz)) != 0)
+ tmp1++;
+ tmp = (tmp1 >> 1) + (tmp1 % 2) + 5;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[96], 0x3ff << 16,
+ tmp << 16);
+ /* PI_96 PI_TDFI_CALVL_CC_F1:RW:0:10 */
+ tmp = tmp + 18;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[96], 0x3ff, tmp);
+ /*PI_103 PI_TMRZ_F1:RW:0:5 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[103], 0x1f,
+ pdram_timing->tmrz);
+ /*PI_111 PI_TDFI_CALVL_STROBE_F1:RW:16:4 */
+ /* tds_train=ceil(2/ns) */
+ tmp1 = 2 * 1000 / (1000000 / pdram_timing->mhz);
+ if ((2 * 1000 % (1000000 / pdram_timing->mhz)) != 0)
+ tmp1++;
+ /* pi_tdfi_calvl_strobe=tds_train+5 */
+ tmp = tmp1 + 5;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[111], 0xf << 16,
+ tmp << 16);
+ /* PI_116 PI_TCKEHDQS_F1:RW:24:6 */
+ tmp = 10000 / (1000000 / pdram_timing->mhz);
+ if ((10000 % (1000000 / pdram_timing->mhz)) != 0)
+ tmp++;
+ if (pdram_timing->mhz <= 100)
+ tmp = tmp + 1;
+ else
+ tmp = tmp + 8;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[116], 0x3f << 24,
+ tmp << 24);
+ /* PI_128 PI_MR1_DATA_F1_0:RW+:0:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[128], 0xffff,
+ pdram_timing->mr[1]);
+ /* PI_135 PI_MR1_DATA_F1_1:RW+:8:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[135], 0xffff << 8,
+ pdram_timing->mr[1] << 8);
+ /* PI_143 PI_MR1_DATA_F1_2:RW+:0:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[143], 0xffff,
+ pdram_timing->mr[1]);
+ /* PI_150 PI_MR1_DATA_F1_3:RW+:8:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[150], 0xffff << 8,
+ pdram_timing->mr[1] << 8);
+ /* PI_128 PI_MR2_DATA_F1_0:RW+:16:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[128], 0xffff << 16,
+ pdram_timing->mr[2] << 16);
+ /* PI_136 PI_MR2_DATA_F1_1:RW+:0:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[136], 0xffff,
+ pdram_timing->mr[2]);
+ /* PI_143 PI_MR2_DATA_F1_2:RW+:16:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[143], 0xffff << 16,
+ pdram_timing->mr[2] << 16);
+ /* PI_151 PI_MR2_DATA_F1_3:RW+:0:16 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[151], 0xffff,
+ pdram_timing->mr[2]);
+ /* PI_156 PI_TFC_F1:RW:16:10 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[156], 0x3ff << 16,
+ pdram_timing->trfc << 16);
+ /* PI_162 PI_TWR_F1:RW:8:6 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[162], 0x3f << 8,
+ pdram_timing->twr << 8);
+ /* PI_162 PI_TWTR_F1:RW:0:6 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[162], 0x3f,
+ pdram_timing->twtr);
+ /* PI_161 PI_TRCD_F1:RW:24:8 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[161], 0xff << 24,
+ pdram_timing->trcd << 24);
+ /* PI_161 PI_TRP_F1:RW:16:8 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[161], 0xff << 16,
+ pdram_timing->trp << 16);
+ /* PI_161 PI_TRTP_F1:RW:8:8 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[161], 0xff << 8,
+ pdram_timing->trtp << 8);
+ /* PI_163 PI_TRAS_MIN_F1:RW:24:8 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[163], 0xff << 24,
+ pdram_timing->tras_min << 24);
+ /* PI_163 PI_TRAS_MAX_F1:RW:0:17 */
+ tmp = pdram_timing->tras_max * 99 / 100;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[163], 0x1ffff, tmp);
+ /* PI_164 PI_TMRD_F1:RW:16:6 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[164], 0x3f << 16,
+ pdram_timing->tmrd << 16);
+ /* PI_164 PI_TDQSCK_MAX_F1:RW:0:4 */
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[164], 0xf,
+ pdram_timing->tdqsck_max);
+ /* PI_189 PI_TDFI_CTRLUPD_MAX_F1:RW:0:16 */
+ tmp = 2 * pdram_timing->trefi;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[189], 0xffff, tmp);
+ /* PI_190 PI_TDFI_CTRLUPD_INTERVAL_F1:RW:0:32 */
+ tmp = 20 * pdram_timing->trefi;
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[190], 0xffffffff,
+ tmp);
+ }
+}
+
+static void gen_rk3399_pi_params(struct timing_related_config *timing_config,
+ struct dram_timing_t *pdram_timing,
+ uint32_t fn)
+{
+ if (fn == 0)
+ gen_rk3399_pi_params_f0(timing_config, pdram_timing);
+ else
+ gen_rk3399_pi_params_f1(timing_config, pdram_timing);
+
+#if PI_TRAINING
+ uint32_t i;
+
+ for (i = 0; i < timing_config->ch_cnt; i++) {
+#if EN_READ_GATE_TRAINING
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[80], 3 << 24,
+ 2 << 24);
+#endif
+
+#if EN_CA_TRAINING
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[100], 3 << 8,
+ 2 << 8);
+#endif
+
+#if EN_WRITE_LEVELING
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[60], 3 << 8,
+ 2 << 8);
+#endif
+
+#if EN_READ_LEVELING
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[80], 3 << 16,
+ 2 << 16);
+#endif
+
+#if EN_WDQ_LEVELING
+ clrsetbits_32(&rk3399_ddr_pi[i]->denali_pi[124], 3 << 16,
+ 2 << 16);
+#endif
+ }
+#endif
+}
+
+static void gen_rk3399_set_odt(uint32_t odt_en)
+{
+ uint32_t drv_odt_val;
+ uint32_t i;
+
+ for (i = 0; i < rk3399_dram_status.timing_config.ch_cnt; i++) {
+ drv_odt_val = (odt_en | (0 << 1) | (0 << 2)) << 16;
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[5],
+ 0x7 << 16, drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[133],
+ 0x7 << 16, drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[261],
+ 0x7 << 16, drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[389],
+ 0x7 << 16, drv_odt_val);
+ drv_odt_val = (odt_en | (0 << 1) | (0 << 2)) << 24;
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[6],
+ 0x7 << 24, drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[134],
+ 0x7 << 24, drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[262],
+ 0x7 << 24, drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[390],
+ 0x7 << 24, drv_odt_val);
+ }
+}
+
+static void gen_rk3399_set_ds_odt(struct timing_related_config *timing_config,
+ struct drv_odt_lp_config *drv_config)
+{
+ uint32_t i, drv_odt_val;
+
+ for (i = 0; i < timing_config->ch_cnt; i++) {
+ if (timing_config->dram_type == LPDDR4)
+ drv_odt_val = drv_config->phy_side_odt |
+ (PHY_DRV_ODT_Hi_Z << 4) |
+ (drv_config->phy_side_dq_drv << 8) |
+ (drv_config->phy_side_dq_drv << 12);
+ else if (timing_config->dram_type == LPDDR3)
+ drv_odt_val = PHY_DRV_ODT_Hi_Z |
+ (drv_config->phy_side_odt << 4) |
+ (drv_config->phy_side_dq_drv << 8) |
+ (drv_config->phy_side_dq_drv << 12);
+ else
+ drv_odt_val = drv_config->phy_side_odt |
+ (drv_config->phy_side_odt << 4) |
+ (drv_config->phy_side_dq_drv << 8) |
+ (drv_config->phy_side_dq_drv << 12);
+
+ /* DQ drv odt set */
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[6], 0xffffff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[134], 0xffffff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[262], 0xffffff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[390], 0xffffff,
+ drv_odt_val);
+ /* DQS drv odt set */
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[7], 0xffffff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[135], 0xffffff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[263], 0xffffff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[391], 0xffffff,
+ drv_odt_val);
+
+ gen_rk3399_set_odt(timing_config->odt);
+
+ /* CA drv set */
+ drv_odt_val = drv_config->phy_side_ca_drv |
+ (drv_config->phy_side_ca_drv << 4);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[544], 0xff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[672], 0xff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[800], 0xff,
+ drv_odt_val);
+
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[928], 0xff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[937], 0xff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[935], 0xff,
+ drv_odt_val);
+
+ drv_odt_val = drv_config->phy_side_ck_cs_drv |
+ (drv_config->phy_side_ck_cs_drv << 4);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[929], 0xff,
+ drv_odt_val);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[939], 0xff,
+ drv_odt_val);
+ }
+}
+
+static void gen_rk3399_phy_params(struct timing_related_config *timing_config,
+ struct drv_odt_lp_config *drv_config,
+ struct dram_timing_t *pdram_timing,
+ uint32_t fn)
+{
+ uint32_t tmp, i, div, j;
+ uint32_t mem_delay_ps, pad_delay_ps, total_delay_ps, delay_frac_ps;
+ uint32_t trpre_min_ps, gate_delay_ps, gate_delay_frac_ps;
+ uint32_t ie_enable, tsel_enable, cas_lat, rddata_en_ie_dly, tsel_adder;
+ uint32_t extra_adder, delta, hs_offset;
+
+ for (i = 0; i < timing_config->ch_cnt; i++) {
+
+ pad_delay_ps = PI_PAD_DELAY_PS_VALUE;
+ ie_enable = PI_IE_ENABLE_VALUE;
+ tsel_enable = PI_TSEL_ENABLE_VALUE;
+
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[896],
+ (0x3 << 8) | 1, fn << 8);
+
+ /* PHY_LOW_FREQ_SEL */
+ /* DENALI_PHY_913 1bit offset_0 */
+ if (timing_config->freq > 400)
+ clrbits_32(&rk3399_ddr_publ[i]->denali_phy[913], 1);
+ else
+ setbits_32(&rk3399_ddr_publ[i]->denali_phy[913], 1);
+
+ /* PHY_RPTR_UPDATE_x */
+ /* DENALI_PHY_87/215/343/471 4bit offset_16 */
+ tmp = 2500 / (1000000 / pdram_timing->mhz) + 3;
+ if ((2500 % (1000000 / pdram_timing->mhz)) != 0)
+ tmp++;
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[87], 0xf << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[215], 0xf << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[343], 0xf << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[471], 0xf << 16,
+ tmp << 16);
+
+ /* PHY_PLL_CTRL */
+ /* DENALI_PHY_911 13bits offset_0 */
+ /* PHY_LP4_BOOT_PLL_CTRL */
+ /* DENALI_PHY_919 13bits offset_0 */
+ if (pdram_timing->mhz <= 150)
+ tmp = 3;
+ else if (pdram_timing->mhz <= 300)
+ tmp = 2;
+ else if (pdram_timing->mhz <= 600)
+ tmp = 1;
+ else
+ tmp = 0;
+ tmp = (1 << 12) | (tmp << 9) | (2 << 7) | (1 << 1);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[911], 0x1fff,
+ tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[919], 0x1fff,
+ tmp);
+
+ /* PHY_PLL_CTRL_CA */
+ /* DENALI_PHY_911 13bits offset_16 */
+ /* PHY_LP4_BOOT_PLL_CTRL_CA */
+ /* DENALI_PHY_919 13bits offset_16 */
+ if (pdram_timing->mhz <= 150)
+ tmp = 3;
+ else if (pdram_timing->mhz <= 300)
+ tmp = 2;
+ else if (pdram_timing->mhz <= 600)
+ tmp = 1;
+ else
+ tmp = 0;
+ tmp = (tmp << 9) | (2 << 7) | (1 << 5) | (1 << 1);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[911],
+ 0x1fff << 16, tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[919],
+ 0x1fff << 16, tmp << 16);
+
+ /* PHY_TCKSRE_WAIT */
+ /* DENALI_PHY_922 4bits offset_24 */
+ if (pdram_timing->mhz <= 400)
+ tmp = 1;
+ else if (pdram_timing->mhz <= 800)
+ tmp = 3;
+ else if (pdram_timing->mhz <= 1000)
+ tmp = 4;
+ else
+ tmp = 5;
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[922], 0xf << 24,
+ tmp << 24);
+ /* PHY_CAL_CLK_SELECT_0:RW8:3 */
+ div = pdram_timing->mhz / (2 * 20);
+ for (j = 2, tmp = 1; j <= 128; j <<= 1, tmp++) {
+ if (div < j)
+ break;
+ }
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[947], 0x7 << 8,
+ tmp << 8);
+ setbits_32(&rk3399_ddr_publ[i]->denali_phy[927], (1 << 22));
+
+ if (timing_config->dram_type == DDR3) {
+ mem_delay_ps = 0;
+ trpre_min_ps = 1000;
+ } else if (timing_config->dram_type == LPDDR4) {
+ mem_delay_ps = 1500;
+ trpre_min_ps = 900;
+ } else if (timing_config->dram_type == LPDDR3) {
+ mem_delay_ps = 2500;
+ trpre_min_ps = 900;
+ } else {
+ ERROR("gen_rk3399_phy_params:dramtype unsupport\n");
+ return;
+ }
+ total_delay_ps = mem_delay_ps + pad_delay_ps;
+ delay_frac_ps =
+ 1000 * total_delay_ps / (1000000 / pdram_timing->mhz);
+ gate_delay_ps = delay_frac_ps + 1000 - (trpre_min_ps / 2);
+ gate_delay_frac_ps =
+ gate_delay_ps - gate_delay_ps / 1000 * 1000;
+ tmp = gate_delay_frac_ps * 0x200 / 1000;
+ /* PHY_RDDQS_GATE_BYPASS_SLAVE_DELAY */
+ /* DENALI_PHY_2/130/258/386 10bits offset_0 */
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[2], 0x2ff, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[130], 0x2ff, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[258], 0x2ff, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[386], 0x2ff, tmp);
+ /* PHY_RDDQS_GATE_SLAVE_DELAY */
+ /* DENALI_PHY_77/205/333/461 10bits offset_16 */
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[77], 0x2ff << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[205], 0x2ff << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[333], 0x2ff << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[461], 0x2ff << 16,
+ tmp << 16);
+
+ tmp = gate_delay_ps / 1000;
+ /* PHY_LP4_BOOT_RDDQS_LATENCY_ADJUST */
+ /* DENALI_PHY_10/138/266/394 4bit offset_0 */
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[10], 0xf, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[138], 0xf, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[266], 0xf, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[394], 0xf, tmp);
+ /* PHY_RDDQS_LATENCY_ADJUST */
+ /* DENALI_PHY_78/206/334/462 4bits offset_0 */
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[78], 0xf, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[206], 0xf, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[334], 0xf, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[462], 0xf, tmp);
+ /* PHY_GTLVL_LAT_ADJ_START */
+ /* DENALI_PHY_80/208/336/464 4bits offset_16 */
+ tmp = delay_frac_ps / 1000;
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[80], 0xf << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[208], 0xf << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[336], 0xf << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[464], 0xf << 16,
+ tmp << 16);
+
+ cas_lat = pdram_timing->cl + PI_ADD_LATENCY;
+ rddata_en_ie_dly = ie_enable / (1000000 / pdram_timing->mhz);
+ if ((ie_enable % (1000000 / pdram_timing->mhz)) != 0)
+ rddata_en_ie_dly++;
+ rddata_en_ie_dly = rddata_en_ie_dly - 1;
+ tsel_adder = tsel_enable / (1000000 / pdram_timing->mhz);
+ if ((tsel_enable % (1000000 / pdram_timing->mhz)) != 0)
+ tsel_adder++;
+ if (rddata_en_ie_dly > tsel_adder)
+ extra_adder = rddata_en_ie_dly - tsel_adder;
+ else
+ extra_adder = 0;
+ delta = cas_lat - rddata_en_ie_dly;
+ if (PI_REGS_DIMM_SUPPORT && PI_DOUBLEFREEK)
+ hs_offset = 2;
+ else
+ hs_offset = 1;
+ if (rddata_en_ie_dly > (cas_lat - 1 - hs_offset)) {
+ tmp = 0;
+ } else {
+ if ((delta == 2) || (delta == 1))
+ tmp = rddata_en_ie_dly - 0 - extra_adder;
+ else
+ tmp = extra_adder;
+ }
+ /* PHY_LP4_BOOT_RDDATA_EN_TSEL_DLY */
+ /* DENALI_PHY_9/137/265/393 4bit offset_16 */
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[9], 0xf << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[137], 0xf << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[265], 0xf << 16,
+ tmp << 16);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[393], 0xf << 16,
+ tmp << 16);
+ /* PHY_RDDATA_EN_TSEL_DLY */
+ /* DENALI_PHY_86/214/342/470 4bit offset_0 */
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[86], 0xf, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[214], 0xf, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[342], 0xf, tmp);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[470], 0xf, tmp);
+
+ if (tsel_adder > rddata_en_ie_dly)
+ extra_adder = tsel_adder - rddata_en_ie_dly;
+ else
+ extra_adder = 0;
+ if (rddata_en_ie_dly > (cas_lat - 1 - hs_offset))
+ tmp = tsel_adder;
+ else
+ tmp = rddata_en_ie_dly - 0 + extra_adder;
+ /* PHY_LP4_BOOT_RDDATA_EN_DLY */
+ /* DENALI_PHY_9/137/265/393 4bit offset_8 */
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[9], 0xf << 8,
+ tmp << 8);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[137], 0xf << 8,
+ tmp << 8);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[265], 0xf << 8,
+ tmp << 8);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[393], 0xf << 8,
+ tmp << 8);
+ /* PHY_RDDATA_EN_DLY */
+ /* DENALI_PHY_85/213/341/469 4bit offset_24 */
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[85], 0xf << 24,
+ tmp << 24);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[213], 0xf << 24,
+ tmp << 24);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[341], 0xf << 24,
+ tmp << 24);
+ clrsetbits_32(&rk3399_ddr_publ[i]->denali_phy[469], 0xf << 24,
+ tmp << 24);
+
+ if (pdram_timing->mhz <= ENPER_CS_TRAINING_FREQ) {
+
+ /*
+ * Note:Per-CS Training is not compatible at speeds
+ * under 533 MHz. If the PHY is running at a speed
+ * less than 533MHz, all phy_per_cs_training_en_X
+ * parameters must be cleared to 0.
+ */
+
+ /*DENALI_PHY_84/212/340/468 1bit offset_16 */
+ clrbits_32(&rk3399_ddr_publ[i]->denali_phy[84],
+ 0x1 << 16);
+ clrbits_32(&rk3399_ddr_publ[i]->denali_phy[212],
+ 0x1 << 16);
+ clrbits_32(&rk3399_ddr_publ[i]->denali_phy[340],
+ 0x1 << 16);
+ clrbits_32(&rk3399_ddr_publ[i]->denali_phy[468],
+ 0x1 << 16);
+ } else {
+ setbits_32(&rk3399_ddr_publ[i]->denali_phy[84],
+ 0x1 << 16);
+ setbits_32(&rk3399_ddr_publ[i]->denali_phy[212],
+ 0x1 << 16);
+ setbits_32(&rk3399_ddr_publ[i]->denali_phy[340],
+ 0x1 << 16);
+ setbits_32(&rk3399_ddr_publ[i]->denali_phy[468],
+ 0x1 << 16);
+ }
+ }
+}
+
+static int to_get_clk_index(unsigned int mhz)
+{
+ int pll_cnt, i;
+
+ pll_cnt = sizeof(dpll_rates_table) / sizeof(struct pll_div);
+
+ /* Assumming rate_table is in descending order */
+ for (i = 0; i < pll_cnt; i++) {
+ if (mhz >= dpll_rates_table[i].mhz)
+ break;
+ }
+
+ return i;
+}
+
+uint32_t rkclk_prepare_pll_timing(unsigned int mhz)
+{
+ unsigned int refdiv, postdiv1, fbdiv, postdiv2;
+ int index;
+
+ index = to_get_clk_index(mhz);
+ refdiv = dpll_rates_table[index].refdiv;
+ fbdiv = dpll_rates_table[index].fbdiv;
+ postdiv1 = dpll_rates_table[index].postdiv1;
+ postdiv2 = dpll_rates_table[index].postdiv2;
+ write_32(DCF_PARAM_ADDR + PARAM_DPLL_CON0, FBDIV(fbdiv));
+ write_32(DCF_PARAM_ADDR + PARAM_DPLL_CON1, POSTDIV2(postdiv2) |
+ POSTDIV1(postdiv1) | REFDIV(refdiv));
+ return (24 * fbdiv) / refdiv / postdiv1 / postdiv2;
+}
+
+uint64_t ddr_get_rate(void)
+{
+ uint32_t refdiv, postdiv1, fbdiv, postdiv2;
+
+ refdiv = mmio_read_32(CRU_BASE + CRU_PLL_CON(DPLL_ID, 1)) & 0x3f;
+ fbdiv = mmio_read_32(CRU_BASE + CRU_PLL_CON(DPLL_ID, 0)) & 0xfff;
+ postdiv1 =
+ (mmio_read_32(CRU_BASE + CRU_PLL_CON(DPLL_ID, 1)) >> 8) & 0x7;
+ postdiv2 =
+ (mmio_read_32(CRU_BASE + CRU_PLL_CON(DPLL_ID, 1)) >> 12) & 0x7;
+
+ return (24 / refdiv * fbdiv / postdiv1 / postdiv2) * 1000 * 1000;
+}
+
+/*
+ * return: bit12: channel 1, external self-refresh
+ * bit11: channel 1, stdby_mode
+ * bit10: channel 1, self-refresh with controller and memory clock gate
+ * bit9: channel 1, self-refresh
+ * bit8: channel 1, power-down
+ *
+ * bit4: channel 1, external self-refresh
+ * bit3: channel 0, stdby_mode
+ * bit2: channel 0, self-refresh with controller and memory clock gate
+ * bit1: channel 0, self-refresh
+ * bit0: channel 0, power-down
+ */
+uint32_t exit_low_power(void)
+{
+ struct rk3399_ddr_pctl_regs *ddr_pctl_regs;
+ uint32_t low_power = 0;
+ uint32_t channel_mask;
+ uint32_t channel;
+ uint32_t tmp;
+
+ channel_mask = (read_32(PMUGRF_BASE + PMUGRF_OSREG(2)) >> 28) & 0x3;
+ for (channel = 0; channel < 2; channel++) {
+ ddr_pctl_regs = rk3399_ddr_pctl[channel];
+ if (!(channel_mask & (1 << channel)))
+ continue;
+
+ /* exit stdby mode */
+ low_power |=
+ ((read_32(&rk3399_ddr_cic->cic_ctrl1) >>
+ channel) & 0x1) << (3 + 8 * channel);
+ write_32(&rk3399_ddr_cic->cic_ctrl1,
+ (1 << (channel + 16)) | (0 << channel));
+ /* exit external self-refresh */
+ tmp = channel ? 12 : 8;
+ low_power |= ((read_32(PMU_BASE + PMU_SFT_CON) >> tmp) & 0x1)
+ << (4 + 8 * channel);
+ clrbits_32(PMU_BASE + PMU_SFT_CON, 1 << tmp);
+ while (!(read_32(PMU_BASE + PMU_DDR_SREF_ST) &
+ (1 << channel)))
+ ;
+ /* exit auto low-power */
+ low_power |= (read_32(&ddr_pctl_regs->denali_ctl[101]) &
+ 0xf) << (8 * channel);
+ clrbits_32(&ddr_pctl_regs->denali_ctl[101], 0xf);
+ /* lp_cmd to exit */
+ if (((read_32(&ddr_pctl_regs->denali_ctl[100]) >> 24) &
+ 0x7f) != 0x40) {
+ while (read_32(&ddr_pctl_regs->denali_ctl[200]) & 0x1)
+ ;
+ clrsetbits_32(&ddr_pctl_regs->denali_ctl[93],
+ 0xff << 24, 0x69 << 24);
+ while (((read_32(&ddr_pctl_regs->denali_ctl[100]) >>
+ 24) & 0x7f) != 0x40)
+ ;
+ }
+ }
+ return low_power;
+}
+
+void resume_low_power(uint32_t low_power)
+{
+ struct rk3399_ddr_pctl_regs *ddr_pctl_regs;
+ uint32_t channel_mask;
+ uint32_t channel;
+ uint32_t tmp;
+ uint32_t val;
+
+ channel_mask = (read_32(PMUGRF_BASE + PMUGRF_OSREG(2)) >> 28) & 0x3;
+ for (channel = 0; channel < 2; channel++) {
+ ddr_pctl_regs = rk3399_ddr_pctl[channel];
+ if (!(channel_mask & (1 << channel)))
+ continue;
+
+ /* resume external self-refresh */
+ tmp = channel ? 12 : 8;
+ val = (low_power >> (4 + 8 * channel)) & 0x1;
+ setbits_32(PMU_BASE + PMU_SFT_CON, val << tmp);
+ /* resume auto low-power */
+ val = (low_power >> (8 * channel)) & 0xf;
+ setbits_32(&ddr_pctl_regs->denali_ctl[101], val);
+ /* resume stdby mode */
+ val = (low_power >> (3 + 8 * channel)) & 0x1;
+ write_32(&rk3399_ddr_cic->cic_ctrl1,
+ (1 << (channel + 16)) | (val << channel));
+ }
+}
+
+static void wait_dcf_done(void)
+{
+ while ((read_32(DCF_BASE + DCF_DCF_ISR) & (DCF_DONE)) == 0)
+ continue;
+}
+
+void clr_dcf_irq(void)
+{
+ /* clear dcf irq status */
+ mmio_write_32(DCF_BASE + DCF_DCF_ISR, DCF_TIMEOUT | DCF_ERR | DCF_DONE);
+}
+
+static void enable_dcf(uint32_t dcf_addr)
+{
+ /* config DCF start addr */
+ write_32(DCF_BASE + DCF_DCF_ADDR, dcf_addr);
+ /* wait dcf done */
+ while (read_32(DCF_BASE + DCF_DCF_CTRL) & 1)
+ continue;
+ /* clear dcf irq status */
+ write_32(DCF_BASE + DCF_DCF_ISR, DCF_TIMEOUT | DCF_ERR | DCF_DONE);
+ /* DCF start */
+ setbits_32(DCF_BASE + DCF_DCF_CTRL, DCF_START);
+}
+
+void dcf_code_init(void)
+{
+ memcpy((void *)DCF_START_ADDR, (void *)dcf_code, sizeof(dcf_code));
+ /* set dcf master secure */
+ write_32(SGRF_BASE + 0xe01c, ((0x3 << 0) << 16) | (0 << 0));
+ write_32(DCF_BASE + DCF_DCF_TOSET, 0x80000000);
+}
+
+static void dcf_start(uint32_t freq, uint32_t index)
+{
+ write_32(CRU_BASE + CRU_SOFTRST_CON(10), (0x1 << (1 + 16)) | (1 << 1));
+ write_32(CRU_BASE + CRU_SOFTRST_CON(11), (0x1 << (0 + 16)) | (1 << 0));
+ write_32(DCF_PARAM_ADDR + PARAM_FREQ_SELECT, index << 4);
+
+ write_32(DCF_PARAM_ADDR + PARAM_DRAM_FREQ, freq);
+
+ rkclk_prepare_pll_timing(freq);
+ udelay(10);
+ write_32(CRU_BASE + CRU_SOFTRST_CON(10), (0x1 << (1 + 16)) | (0 << 1));
+ write_32(CRU_BASE + CRU_SOFTRST_CON(11), (0x1 << (0 + 16)) | (0 << 0));
+ udelay(10);
+ enable_dcf(DCF_START_ADDR);
+}
+
+static void dram_low_power_config(struct drv_odt_lp_config *lp_config)
+{
+ uint32_t tmp, tmp1, i;
+ uint32_t ch_cnt = rk3399_dram_status.timing_config.ch_cnt;
+ uint32_t dram_type = rk3399_dram_status.timing_config.dram_type;
+
+ if (dram_type == LPDDR4)
+ tmp = (lp_config->srpd_lite_idle << 16) |
+ lp_config->pd_idle;
+ else
+ tmp = lp_config->pd_idle;
+
+ if (dram_type == DDR3)
+ tmp1 = (2 << 16) | (0x7 << 8) | 7;
+ else
+ tmp1 = (3 << 16) | (0x7 << 8) | 7;
+
+ for (i = 0; i < ch_cnt; i++) {
+ write_32(&rk3399_ddr_pctl[i]->denali_ctl[102], tmp);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[103], 0xffff,
+ (lp_config->sr_mc_gate_idle << 8) |
+ lp_config->sr_idle);
+ clrsetbits_32(&rk3399_ddr_pctl[i]->denali_ctl[101],
+ 0x70f0f, tmp1);
+ }
+
+ /* standby idle */
+ write_32(&rk3399_ddr_cic->cic_idle_th, lp_config->standby_idle);
+ write_32(&rk3399_ddr_cic->cic_cg_wait_th, 0x640008);
+
+ if (ch_cnt == 2) {
+ write_32(GRF_BASE + GRF_DDRC1_CON1,
+ (((0x1<<4) | (0x1<<5) | (0x1<<6) | (0x1<<7)) << 16) |
+ ((0x1<<4) | (0x0<<5) | (0x1<<6) | (0x1<<7)));
+ if (lp_config->standby_idle)
+ tmp = 0x002a002a;
+ else
+ tmp = 0;
+ write_32(&rk3399_ddr_cic->cic_ctrl1, tmp);
+ }
+
+ write_32(GRF_BASE + GRF_DDRC0_CON1,
+ (((0x1<<4) | (0x1<<5) | (0x1<<6) | (0x1<<7)) << 16) |
+ ((0x1<<4) | (0x0<<5) | (0x1<<6) | (0x1<<7)));
+ if (lp_config->standby_idle)
+ tmp = 0x00150015;
+ else
+ tmp = 0;
+ write_32(&rk3399_ddr_cic->cic_ctrl1, tmp);
+}
+
+
+static void dram_related_init(struct ddr_dts_config_timing *dts_timing)
+{
+ uint32_t trefi0, trefi1;
+ uint32_t i;
+ struct rk3399_sdram_config sdram_config;
+
+ dcf_code_init();
+
+ /* get sdram config for os reg */
+ sdram_config_init(&sdram_config);
+ drv_odt_lp_cfg_init(sdram_config.dramtype, dts_timing,
+ &rk3399_dram_status.drv_odt_lp_cfg);
+ sdram_timing_cfg_init(&rk3399_dram_status.timing_config,
+ &sdram_config,
+ &rk3399_dram_status.drv_odt_lp_cfg);
+
+ trefi0 = ((read_32(&rk3399_ddr_pctl[0]->denali_ctl[48]) >>
+ 16) & 0xffff) + 8;
+ trefi1 = ((read_32(&rk3399_ddr_pctl[0]->denali_ctl[49]) >>
+ 16) & 0xffff) + 8;
+
+ rk3399_dram_status.index_freq[0] = trefi0 * 10 / 39;
+ rk3399_dram_status.index_freq[1] = trefi1 * 10 / 39;
+ rk3399_dram_status.current_index =
+ (read_32(&rk3399_ddr_pctl[0]->denali_ctl[111])
+ >> 16) & 0x3;
+ if (rk3399_dram_status.timing_config.dram_type == DDR3) {
+ rk3399_dram_status.index_freq[0] /= 2;
+ rk3399_dram_status.index_freq[1] /= 2;
+ }
+ rk3399_dram_status.index_freq[(rk3399_dram_status.current_index + 1)
+ & 0x1] = 0;
+
+ /* disable all training by ctl and pi */
+ for (i = 0; i < rk3399_dram_status.timing_config.ch_cnt; i++) {
+ clrbits_32(&rk3399_ddr_pctl[i]->denali_ctl[70], (1 << 24) |
+ (1 << 16) | (1 << 8) | 1);
+ clrbits_32(&rk3399_ddr_pctl[i]->denali_ctl[71], 1);
+
+ clrbits_32(&rk3399_ddr_pi[i]->denali_pi[60], 0x3 << 8);
+ clrbits_32(&rk3399_ddr_pi[i]->denali_pi[80], (0x3 << 24) |
+ (0x3 << 16));
+ clrbits_32(&rk3399_ddr_pi[i]->denali_pi[100], 0x3 << 8);
+ clrbits_32(&rk3399_ddr_pi[i]->denali_pi[124], 0x3 << 16);
+ }
+
+ /* init drv odt */
+ if (rk3399_dram_status.index_freq[rk3399_dram_status.current_index] <
+ rk3399_dram_status.drv_odt_lp_cfg.odt_dis_freq)
+ rk3399_dram_status.timing_config.odt = 0;
+ else
+ rk3399_dram_status.timing_config.odt = 1;
+ gen_rk3399_set_ds_odt(&rk3399_dram_status.timing_config,
+ &rk3399_dram_status.drv_odt_lp_cfg);
+ dram_low_power_config(&rk3399_dram_status.drv_odt_lp_cfg);
+}
+
+static uint32_t prepare_ddr_timing(uint32_t mhz)
+{
+ uint32_t index;
+ struct dram_timing_t dram_timing;
+
+ rk3399_dram_status.timing_config.freq = mhz;
+
+ if (mhz < rk3399_dram_status.drv_odt_lp_cfg.ddr3_dll_dis_freq)
+ rk3399_dram_status.timing_config.dllbp = 1;
+ else
+ rk3399_dram_status.timing_config.dllbp = 0;
+ if (mhz < rk3399_dram_status.drv_odt_lp_cfg.odt_dis_freq) {
+ rk3399_dram_status.timing_config.odt = 0;
+ } else {
+ rk3399_dram_status.timing_config.odt = 1;
+ gen_rk3399_set_odt(1);
+ }
+
+ index = (rk3399_dram_status.current_index + 1) & 0x1;
+ if (rk3399_dram_status.index_freq[index] == mhz)
+ goto out;
+
+ /*
+ * checking if having available gate traiing timing for
+ * target freq.
+ */
+ dram_get_parameter(&rk3399_dram_status.timing_config, &dram_timing);
+
+ gen_rk3399_ctl_params(&rk3399_dram_status.timing_config,
+ &dram_timing, index);
+ gen_rk3399_pi_params(&rk3399_dram_status.timing_config,
+ &dram_timing, index);
+ gen_rk3399_phy_params(&rk3399_dram_status.timing_config,
+ &rk3399_dram_status.drv_odt_lp_cfg,
+ &dram_timing, index);
+ rk3399_dram_status.index_freq[index] = mhz;
+
+
+out:
+ return index;
+}
+
+void print_dram_status_info(void)
+{
+ uint32_t *p;
+ uint32_t i;
+
+ p = (uint32_t *) &rk3399_dram_status.timing_config;
+ INFO("rk3399_dram_status.timing_config:\n");
+ for (i = 0; i < sizeof(struct timing_related_config) / 4; i++)
+ tf_printf("%u\n", p[i]);
+ p = (uint32_t *) &rk3399_dram_status.drv_odt_lp_cfg;
+ INFO("rk3399_dram_status.drv_odt_lp_cfg:\n");
+ for (i = 0; i < sizeof(struct drv_odt_lp_config) / 4; i++)
+ tf_printf("%u\n", p[i]);
+}
+
+uint64_t ddr_set_rate(uint64_t hz)
+{
+ uint32_t low_power, index;
+ uint32_t mhz = hz / (1000 * 1000);
+
+ if (mhz ==
+ rk3399_dram_status.index_freq[rk3399_dram_status.current_index])
+ goto out;
+
+ low_power = exit_low_power();
+ index = prepare_ddr_timing(mhz);
+ if (index > 1) {
+ /* set timing error, quit */
+ mhz = 0;
+ goto out;
+ }
+
+ dcf_start(mhz, index);
+ wait_dcf_done();
+ if (rk3399_dram_status.timing_config.odt == 0)
+ gen_rk3399_set_odt(0);
+
+ rk3399_dram_status.current_index = index;
+ resume_low_power(low_power);
+out:
+ return mhz;
+}
+
+uint64_t ddr_round_rate(uint64_t hz)
+{
+ int index;
+ uint32_t mhz = hz / (1000 * 1000);
+
+ index = to_get_clk_index(mhz);
+
+ return dpll_rates_table[index].mhz * 1000 * 1000;
+}
+
+uint64_t dts_timing_receive(uint64_t timing, uint64_t index)
+{
+ uint32_t *p = (uint32_t *) &dts_parameter;
+ static uint32_t receive_nums;
+
+ if (index < (sizeof(dts_parameter) / sizeof(uint32_t) - 1)) {
+ p[index] = (uint32_t)timing;
+ receive_nums++;
+ } else {
+ dts_parameter.available = 0;
+ return -1;
+ }
+
+ /* receive all parameter */
+ if (receive_nums == (sizeof(dts_parameter) / sizeof(uint32_t) - 1)) {
+ dts_parameter.available = 1;
+ receive_nums = 0;
+ }
+
+ return index;
+}
+
+void ddr_init(void)
+{
+ dram_related_init(&dts_parameter);
+}