/***************************************************************************
 *
 * Copyright 2015-2019 BES.
 * All rights reserved. All unpublished rights reserved.
 *
 * No part of this work may be used or reproduced in any form or by any
 * means, or stored in a database or retrieval system, without prior written
 * permission of BES.
 *
 * Use of this work is governed by a license granted by BES.
 * This work contains confidential and proprietary information of
 * BES. which is protected by copyright, trade secret,
 * trademark and other intellectual property rights.
 *
 ****************************************************************************/
#ifdef CHIP_HAS_PSRAMUHS

#include "plat_types.h"
#include "plat_addr_map.h"
#include "hal_location.h"
#include "hal_psramuhs.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "hal_cache.h"
#include "pmu.h"
#include "psramuhsphy.h"
#include "reg_psramuhs_mc.h"

//#define PSRAMUHS_DUAL_8BIT
//#define PSRAMUHS_BURST_REFRESH
//#define PSRAMUHS_DUMMY_CYCLE
//#define PSRAMUHS_PRA_ENABLE
//#define PSRAMUHS_DUAL_SWITCH
//#define PSRAMUHS_DIG_LOOPBACK
//#define PSRAMUHS_ANA_LOOPBACK
//#define PSRAMUHS_AUTO_PRECHARGE
//#define PSRAMUHS_WRAP_ENABLE

#if defined(CHIP_BEST2001) && !defined(PSRAMUHS_DUMMY_CYCLE)
#define PSRAMUHS_DUMMY_CYCLE
#endif

#define TX_FIFO_DEPTH                       4
#define RX_FIFO_DEPTH                       4

enum CP_FSM_STATE_T {
    CP_FSM_STATE_SELF_REFRESH   = 1,
    CP_FSM_STATE_PD             = 2,
    CP_FSM_STATE_READY          = 4,
};

enum MEMIF_CMD_T {
    MEMIF_NO_CMD        = 0x00,
    MEMIF_WRITE         = 0x01,
    MEMIF_READ          = 0x02,
    MEMIF_MRS           = 0x05,
    MEMIF_MRR           = 0x06,
    MEMIF_REF           = 0x08,
    MEMIF_SREF          = 0x09,
    MEMIF_PD            = 0x10,
    MEMIF_NOP           = 0x20,
    MEMIF_RST           = 0xFF,
    MEMIF_ZQCL          = 0x85,
    MEMIF_ZQCS          = 0x45,
    MEMIF_ZQCRST        = 0x25,
    MEMIF_START_CLOCK   = 0x40,
    MEMIF_STOP_CLOCK    = 0x80,
    MEMIF_NEW_CMD       = 0x7F,
};

static struct PSRAMUHS_MC_T * const psramuhs_mc = (struct PSRAMUHS_MC_T *)PSRAMUHS_CTRL_BASE;

#ifdef FPGA
static const uint32_t psramuhs_run_clk = 26000000;
#else
#if (PSRAMUHS_SPEED != 0)
static const uint32_t psramuhs_run_clk = PSRAMUHS_SPEED*1000*1000;
#else
#error "invalid PSRAMUHS_SPEED"
#endif
#endif

static int hal_psramuhsip_mc_busy(void)
{
    return !!(psramuhs_mc->REG_404 & PSRAM_UHS_MC_BUSY);
}

static int hal_psramuhsip_wb_busy(void)
{
    return !!(psramuhs_mc->REG_404 & PSRAM_UHS_MC_WB_FILL_LEVEL_MASK);
}

int hal_psramuhsip_mc_in_sleep(void)
{
    return GET_BITFIELD(psramuhs_mc->REG_404, PSRAM_UHS_MC_CP_FSM_STATE) == CP_FSM_STATE_PD;
}

int hal_psramuhsip_rx_fifo_empty(void)
{
    return !!(psramuhs_mc->REG_404 & PSRAM_UHS_MC_MGR_RXFIFO_R_EMPTY);
}

int hal_psramuhsip_tx_fifo_full(void)
{
    return !!(psramuhs_mc->REG_404 & PSRAM_UHS_MC_MGR_TXFIFO_W_FULL);
}

uint32_t hal_psramuhsip_get_rx_fifo_len(void)
{
    return GET_BITFIELD(psramuhs_mc->REG_404, PSRAM_UHS_MC_MGR_RXFIFO_FULL_CNT);
}

uint32_t hal_psramuhsip_get_tx_fifo_free_len(void)
{
    return GET_BITFIELD(psramuhs_mc->REG_404, PSRAM_UHS_MC_MGR_TXFIFO_EMPTY_CNT);
}

void hal_psramuhsip_mc_busy_wait(void)
{
    while (hal_psramuhsip_mc_busy());
}

void hal_psramuhsip_wb_busy_wait(void)
{
    while (hal_psramuhsip_wb_busy());
}

void hal_psramuhsip_flush_tx_fifo(void)
{
    hal_psramuhsip_mc_busy_wait();
    psramuhs_mc->REG_01C = PSRAM_UHS_MC_MGR_TX_FIFO_CLR;
    hal_psramuhsip_mc_busy_wait();
}

void hal_psramuhsip_flush_rx_fifo(void)
{
    hal_psramuhsip_mc_busy_wait();
    psramuhs_mc->REG_01C = PSRAM_UHS_MC_MGR_RX_FIFO_CLR;
    hal_psramuhsip_mc_busy_wait();
}

void hal_psramuhsip_flush_all_fifo(void)
{
    hal_psramuhsip_mc_busy_wait();
    psramuhs_mc->REG_01C = PSRAM_UHS_MC_MGR_TX_FIFO_CLR | PSRAM_UHS_MC_MGR_RX_FIFO_CLR;
    hal_psramuhsip_mc_busy_wait();
}

void hal_psramuhsip_xfer_addr_len(uint32_t addr, uint32_t len)
{
    psramuhs_mc->REG_008 = addr;
    psramuhs_mc->REG_00C = len;
}

void hal_psramuhsip_write_fifo(uint32_t *data, uint32_t len)
{
    for (int i = 0; i < len; i++) {
        psramuhs_mc->REG_014 = *data++;
    }
}

void hal_psramuhsip_read_fifo(uint32_t *data, uint32_t len)
{
    for (int i = 0; i < len; i++) {
        *data++ = psramuhs_mc->REG_018;
    }
}

void hal_psramuhsip_set_reg_data_mask(void)
{
#ifdef PSRAMUHS_DUAL_8BIT
    psramuhs_mc->REG_010 = 0xFFFC;
#else
    psramuhs_mc->REG_010 = 0xFFFE;
#endif
}

void hal_psramuhsip_set_mem_data_mask(void)
{
    psramuhs_mc->REG_010 = 0;
}

void hal_psramuhsip_set_reg_fifo_width(void)
{
    psramuhs_mc->REG_0B0 = 0;
}

void hal_psramuhsip_set_mem_fifo_width(void)
{
    // 128 bits if PSRAMUHS_DUAL_8BIT; 64 bits otherwise
    psramuhs_mc->REG_0B0 = PSRAM_UHS_MC_MGR_FIFO_TEST_EN;
}

void hal_psramuhsip_set_cmd(enum MEMIF_CMD_T cmd)
{
    psramuhs_mc->REG_004 = cmd;
}

POSSIBLY_UNUSED void psramuhs_read_reg(uint32_t reg, uint32_t *val)
{
    hal_psramuhsip_flush_all_fifo();
    hal_psramuhsip_xfer_addr_len(reg, 1);
    hal_psramuhsip_set_cmd(MEMIF_MRR);
    while (hal_psramuhsip_rx_fifo_empty());
    hal_psramuhsip_read_fifo(val, 1);
}

static void psramuhs_send_cmd_reg(enum MEMIF_CMD_T cmd, uint32_t reg, uint32_t val)
{
#if !defined(PSRAMUHS_DIG_LOOPBACK) && !defined(PSRAMUHS_ANA_LOOPBACK)
#ifdef PSRAMUHS_DUAL_8BIT
    val &= 0xFF;
    val |= (val << 8);
#endif
    hal_psramuhsip_flush_all_fifo();
    //hal_psramuhsip_set_reg_fifo_width();
    //hal_psramuhsip_set_reg_data_mask();
    hal_psramuhsip_write_fifo(&val, 1);
    hal_psramuhsip_xfer_addr_len(reg, 1);
    hal_psramuhsip_set_cmd(cmd);
    while (hal_psramuhsip_get_tx_fifo_free_len() != TX_FIFO_DEPTH);
    hal_psramuhsip_mc_busy_wait();
    //hal_psramuhsip_set_mem_fifo_width();
    //hal_psramuhsip_set_mem_data_mask();
#endif
}

static void psramuhs_write_reg(uint32_t reg, uint32_t val)
{
    psramuhs_send_cmd_reg(MEMIF_MRS, reg, val);
}

static void psramuhs_single_cmd(enum MEMIF_CMD_T cmd)
{
#if !defined(PSRAMUHS_DIG_LOOPBACK) && !defined(PSRAMUHS_ANA_LOOPBACK)
    hal_psramuhsip_flush_all_fifo();
    hal_psramuhsip_set_cmd(cmd);
    hal_psramuhsip_mc_busy_wait();
#endif
}

static POSSIBLY_UNUSED void psramuhs_start_clock(void)
{
    psramuhs_single_cmd(MEMIF_START_CLOCK);
}

static POSSIBLY_UNUSED void psramuhs_stop_clock(void)
{
    psramuhs_single_cmd(MEMIF_STOP_CLOCK);
}

static POSSIBLY_UNUSED void psramuhs_reset(void)
{
    psramuhs_single_cmd(MEMIF_RST);
}

static POSSIBLY_UNUSED void psramuhs_zq_calib_reset(void)
{
    psramuhs_send_cmd_reg(MEMIF_ZQCRST, 7, 0);
}

static POSSIBLY_UNUSED void psramuhs_zq_calib(void)
{
    psramuhs_send_cmd_reg(MEMIF_ZQCL, 5, 0);
}

static void psramuhs_set_timing(uint32_t clk)
{
    uint32_t reg;
    uint32_t val;
    uint32_t burst_len;

    reg = 0;
    if (clk <= 200000000) {
        val = 7;
    } else if (clk <= 333000000) {
        val = 6;
    } else if (clk <= 400000000) {
        val = 5;
    } else if (clk <= 533000000) {
        val = 4;
    } else if (clk <= 667000000) {
        val = 0;
    } else if (clk <= 800000000) {
        val = 1;
    } else if (clk <= 933000000) {
        val = 2;
    } else {
        val = 3;
    }
    // Latency, drive
    val = (val << 0) | (2 << 3);
#if 0
    //refresh disable
    val |= (1 << 7);
#endif
    psramuhs_write_reg(reg, val);

    reg = 2;
#if defined(__ARM_ARCH_ISA_ARM) || defined(DSP_ENABLE)
#ifdef PSRAMUHS_DUAL_8BIT
    burst_len = 0x1;//32B
#else
    burst_len = 0x2;//64B
#endif
#else
#ifdef PSRAMUHS_DUAL_8BIT
    burst_len = 0x0;//16B
#else
    burst_len = 0x1;//32B
#endif
#endif
#ifdef PSRAMUHS_PRA_ENABLE
    // Burst len, pra enable
    val = (burst_len << 0) | (1 << 4);
#else
    // Burst len, auto-precharge
#ifdef PSRAMUHS_AUTO_PRECHARGE
    val = (burst_len << 0) | (1 << 3);
#else
    val = (burst_len << 0);
#endif
#endif
    //wrap enable
#ifdef PSRAMUHS_WRAP_ENABLE
    val |= (1 << 2);
#endif
    psramuhs_write_reg(reg, val);

    reg = 6;
    // Vref trim
    val = (8 << 0);
    psramuhs_write_reg(reg, val);
    hal_sys_timer_delay_us(5);

    psramuhs_zq_calib_reset();
    psramuhs_zq_calib();
}

void hal_psramuhs_sleep(void)
{
}

void hal_psramuhs_wakeup(void)
{
}

static void hal_psramuhs_mc_set_timing(uint32_t clk)
{
    uint32_t val1, val2;
    uint32_t val;

    if (clk <= 200000000) {
        val1 = 9;
        val2 = 5;
    } else if (clk <= 333000000) {
        val1 = 13;
        val2 = 5;
    } else if (clk <= 400000000) {
        val1 = 16;
        val2 = 6;
    } else if (clk <= 533000000) {
        val1 = 20;
        val2 = 10;
    } else if (clk <= 667000000) {
        val1 = 24;
        val2 = 12;
    } else if (clk <= 800000000) {
        val1 = 29;
        val2 = 14;
    } else if (clk <= 933000000) {
        val1 = 33;
        val2 = 16;
    } else {
        val1 = 37;
        val2 = 18;
    }
    if (clk >= 466000000)
        val2--;

    psramuhs_mc->REG_028 = PSRAM_UHS_MC_WRITE_LATENCY(val2);
    psramuhs_mc->REG_02C = PSRAM_UHS_MC_READ_LATENCY(val1);

    // tCEM_MAX <= 7.8 us when MRW2[5]==1 && MRR4[2]==0, or <= 3.9 us when MRW2[5]==0 || MRR4[2]==1
    val = (clk / 1000000) * 30 / 10 - 1;
    psramuhs_mc->REG_04C = PSRAM_UHS_MC_T_REFI(val) | PSRAM_UHS_MC_NUM_OF_BURST_RFS(0x1000);

#ifdef FPGA
    clk = 800*1000*1000;
#endif
    // tRC >= 60 ns
    val = ((clk / 1000000) * 60 + (1000 - 1)) / 1000;
    psramuhs_mc->REG_050 = PSRAM_UHS_MC_T_RC(val);
    // tRFC >= 60 ns
    val = ((clk / 1000000) * 60 + (1000 - 1)) / 1000;
    psramuhs_mc->REG_054 = PSRAM_UHS_MC_T_RFC(val);
#ifdef PSRAMUHS_AUTO_PRECHARGE

    // tCPHR >= 5 ns (auto precharge)
#if PSRAMUHS_SPEED >= 900
    val = ((clk / 1000000) * 5 + (1000 - 1)) / 1000;
#else /*PSRAMUHS_SPEED == 1000*/
    val = 20;
#endif /*PSRAMUHS_SPEED == 1000*/
    psramuhs_mc->REG_05C = PSRAM_UHS_MC_T_CPHR_AP(val);

    // tCPHW >= 30 ns (auto precharge)
#if PSRAMUHS_SPEED >= 900
    val = ((clk / 1000000) * 30 + (1000 - 1)) / 1000;
#else /*PSRAMUHS_SPEED == 1000*/
    val = 100;
#endif /*PSRAMUHS_SPEED == 1000*/
    psramuhs_mc->REG_064 = PSRAM_UHS_MC_T_CPHW_AP(val);

#else /*PSRAMUHS_AUTO_PRECHARGE*/

    // tCPHR >= 20 ns (no auto precharge)
#if PSRAMUHS_SPEED >= 900
    val = ((clk / 1000000) * 20 + (1000 - 1)) / 1000;
#else /*PSRAMUHS_SPEED == 1000*/
    val = 20;
#endif /*PSRAMUHS_SPEED == 1000*/
    psramuhs_mc->REG_058 = PSRAM_UHS_MC_T_CPHR(val);

    // tCPHW >= 30 ns (no auto precharge)
#if PSRAMUHS_SPEED >= 900
    val = ((clk / 1000000) * 30 + (1000 - 1)) / 1000;
#else /*PSRAMUHS_SPEED == 1000*/
    val = 100;
#endif /*PSRAMUHS_SPEED == 1000*/
    psramuhs_mc->REG_060 = PSRAM_UHS_MC_T_CPHW(val);

#endif /*PSRAMUHS_AUTO_PRECHARGE*/
    // tMRR >=  20ns
    val = 20;//((clk / 1000000) * 20 + (1000 - 1)) / 1000;
    psramuhs_mc->REG_068 = PSRAM_UHS_MC_T_MRR(val);
    // tMRW >= 100 ns
    val = ((clk / 1000000) * 100 + (1000 - 1)) / 1000;
    psramuhs_mc->REG_06C = PSRAM_UHS_MC_T_MRS(val);
    // tCEM >= 4 cycles
    psramuhs_mc->REG_070 = PSRAM_UHS_MC_T_CEM(4);
    // tRST >= 10 us
    val = (clk / 1000000) * 10;
    psramuhs_mc->REG_074 = PSRAM_UHS_MC_T_RST(val);
    // tSRF >= 100 ns
    val = ((clk / 1000000) + (10 - 1)) / 10;
    psramuhs_mc->REG_078 = PSRAM_UHS_MC_T_SRF(val);
    // tSRF >= 70 ns
    val = ((clk / 1000000) * 70 + (1000 - 1)) / 1000;
    psramuhs_mc->REG_07C = PSRAM_UHS_MC_T_XSR(val);
    // tHS >= 150 us
    val = (clk / 1000000) * 150;
    psramuhs_mc->REG_080 = PSRAM_UHS_MC_T_HS(val);
    // tXPHS >= 100 ns
    val = ((clk / 1000000) + (10 - 1)) / 10;
    psramuhs_mc->REG_084 = PSRAM_UHS_MC_T_XPHS(val);
    // tXHS >= 150 us
    val = (clk / 1000000) * 150;
    psramuhs_mc->REG_088 = PSRAM_UHS_MC_T_XHS(val);
    // tZQCAL >= 1 us
    val = (clk / 1000000) * 1;
    psramuhs_mc->REG_08C = PSRAM_UHS_MC_T_ZQCAL(val);
    // tZQCRST >= 1 us
    val = (clk / 1000000) * 1;
    psramuhs_mc->REG_090 = PSRAM_UHS_MC_T_ZQCRST(val);
    // NOP dummy cycles, same as tXPHS >= 100 ns
    val = ((clk / 1000000) + (10 - 1)) / 10;
    psramuhs_mc->REG_0A0 = PSRAM_UHS_MC_STOP_CLK_IN_NOP | PSRAM_UHS_MC_NOP_DMY_CYC(val);
    psramuhs_mc->REG_0A4 = PSRAM_UHS_MC_QUEUE_IDLE_CYCLE(50000);
    // tDQSCK in [2 ns, 6.5 ns], expanded time >= tDQSCK_MAX
    val = ((clk / 1000000) * 65/10 + (1000 - 1)) / 1000;
    psramuhs_mc->REG_0A8 = PSRAM_UHS_MC_T_EXPANDRD(val);
}

static void hal_psramuhs_mc_init(uint32_t clk)
{
    uint32_t val;
    uint32_t burst_len;
    uint32_t boundary;

    val = PSRAM_UHS_MC_CHIP_TYPE;
#ifdef PSRAMUHS_DUAL_8BIT
    val |= PSRAM_UHS_MC_CHIP_BIT;
#endif
#ifdef PSRAMUHS_DUAL_SWITCH
    val |= PSRAM_UHS_MC_CHIP_SWITCH;
#endif
#ifdef PSRAMUHS_16BIT
    val |= PSRAM_UHS_MC_CHIP_IO_X16 | PSRAM_UHS_MC_CHIP_CA_PATTERN(2);
#else
    val |= PSRAM_UHS_MC_CHIP_CA_PATTERN(1);
#endif
#if (PSRAMUHS_SIZE == 0x800000)
    val |= PSRAM_UHS_MC_CHIP_MEM_SIZE(1);
#elif (PSRAMUHS_SIZE == 0x1000000)
    val |= PSRAM_UHS_MC_CHIP_MEM_SIZE(2);
#elif (PSRAMUHS_SIZE == 0x2000000)
    val |= PSRAM_UHS_MC_CHIP_MEM_SIZE(3);
#else
    ASSERT(false, "Bad PSRAMUHS_SIZE=0x%08X", PSRAMUHS_SIZE);
#endif
    psramuhs_mc->REG_000 = val;
    psramuhs_mc->REG_024 = PSRAM_UHS_MC_STOP_CLK_IDLE | PSRAM_UHS_MC_AUTOWAKEUP_EN;
    // Burst length: 1=32 bytes (Cortex-M) or 2=64 bytes (Cortex-A), Page boundary: 2K bytes
#ifdef PSRAMUHS_WRAP_ENABLE
#if defined(__ARM_ARCH_ISA_ARM) || defined(DSP_ENABLE)
    burst_len = 0x2;//64B
#else
    burst_len = 0x1;//32B
#endif
#else
#ifdef PSRAMUHS_DUAL_8BIT
    burst_len = 0x6;// 0:16B 5;2KB 6:4KB
#else
    burst_len = 0x5;// 0:16B 5;2KB 6:4KB
#endif
#endif
#ifdef PSRAMUHS_DUAL_8BIT
    boundary = 2;
#else
    boundary = 1;
#endif
    psramuhs_mc->REG_034 = PSRAM_UHS_MC_BURST_LENGTH(burst_len) | PSRAM_UHS_MC_PAGE_BOUNDARY(boundary);

    // AXI bus width: 128 bits
    psramuhs_mc->REG_038 = PSRAM_UHS_MC_BUS_WIDTH;
    // Write buffer level with high priority: 0~15
    psramuhs_mc->REG_03C = PSRAM_UHS_MC_HIGH_PRI_LEVEL(8);
#ifdef PSRAMUHS_PRA_ENABLE
    psramuhs_mc->REG_040 = PSRAM_UHS_MC_PRA_ENABLE | PSRAM_UHS_MC_PRA_MAX_CNT(32);
#else
#ifdef PSRAMUHS_AUTO_PRECHARGE
    psramuhs_mc->REG_040 = PSRAM_UHS_MC_AUTO_PRECHARGE | PSRAM_UHS_MC_PRA_MAX_CNT(32);
#else
    psramuhs_mc->REG_040 = PSRAM_UHS_MC_PRA_MAX_CNT(32);
#endif
#endif
#ifdef PSRAMUHS_WRAP_ENABLE
    psramuhs_mc->REG_040 |= PSRAM_UHS_MC_CP_WRAP_EN;
#endif
    psramuhs_mc->REG_048 = PSRAM_UHS_MC_FRE_RATIO(2);
#ifdef PSRAMUHS_DUMMY_CYCLE
    psramuhs_mc->REG_840 |= PSRAM_UHS_MC_PHY_DUMMY_CYC_EN;
#endif
#if defined(CHIP_BEST2001)
    psramuhs_mc->REG_840 |= PSRAM_UHS_MC_PHY_IDLE_PAD_EN;
#endif
    psramuhs_mc->REG_844 = PSRAM_UHS_MC_T_WPST(2);

    hal_psramuhsip_set_reg_fifo_width();
    hal_psramuhsip_set_reg_data_mask();

    hal_psramuhs_mc_set_timing(clk);

    psramuhs_mc->REG_400 = PSRAM_UHS_MC_INIT_COMPLETE;

#ifdef PSRAMUHS_DIG_LOOPBACK
    psramuhs_mc->REG_840 |= PSRAM_UHS_MC_PHY_LOOPBACK_EN;
    psramuhs_mc->REG_044 |= PSRAM_UHS_MC_SNP_DISABLE;
#endif
#ifdef PSRAMUHS_ANA_LOOPBACK
    psramuhs_mc->REG_044 |= PSRAM_UHS_MC_SNP_DISABLE;
    psramuhs_mc->REG_0B0 |= PSRAM_UHS_MC_MGR_FIFO_TEST_EN;
    psramuhs_mc->REG_840 |= PSRAM_UHS_MC_ANA_LOOPBACK_EN;
#endif

#ifndef FPGA
#if !defined(PSRAMUHS_DIG_LOOPBACK) && !defined(PSRAMUHS_ANA_LOOPBACK)
    psramuhsphy_init_calib();
#endif
#endif

}

void hal_psramuhs_mc_entry_auto_lp()
{
    psramuhs_mc->REG_024 |= PSRAM_UHS_MC_ENTRY_SLEEP_IDLE | PSRAM_UHS_MC_ENTRY_SELF_REFRESH_IDLE;
}

void hal_psramuhs_snoop_enable()
{
    psramuhs_mc->REG_044 &= ~PSRAM_UHS_MC_SNP_DISABLE;
}
void hal_psramuhs_snoop_disable()
{
    psramuhs_mc->REG_044 |= PSRAM_UHS_MC_SNP_DISABLE;
}
void hal_psramuhs_refresh_enable()
{
#ifdef PSRAMUHS_BURST_REFRESH
    psramuhs_mc->REG_020 = PSRAM_UHS_MC_REFRESH_MODE | PSRAM_UHS_MC_BURST_REFRESH_EN;
#else
    psramuhs_mc->REG_020 = PSRAM_UHS_MC_REFRESH_MODE;
#endif
}
void hal_psramuhs_init(void)
{
#if PSRAMUHS_ENABLE
#error "must set MPU befor 2001 eco"
#endif

    hal_cache_wrap_enable(HAL_CACHE_ID_I_CACHE);
    hal_cache_wrap_enable(HAL_CACHE_ID_D_CACHE);

    hal_cmu_ddr_clock_enable();
    hal_cmu_clock_enable(HAL_CMU_MOD_O_PSRAMUHS);
    hal_cmu_clock_enable(HAL_CMU_MOD_H_PSRAMUHS);
    hal_cmu_reset_clear(HAL_CMU_MOD_O_PSRAMUHS);
    hal_cmu_reset_clear(HAL_CMU_MOD_H_PSRAMUHS);

#ifndef FPGA
    psramuhsphy_open(psramuhs_run_clk);
#endif
    hal_psramuhs_mc_init(psramuhs_run_clk);
    psramuhs_start_clock();
    hal_sys_timer_delay_us(3);
    psramuhs_reset();
    psramuhs_stop_clock();
    psramuhs_set_timing(psramuhs_run_clk);
    hal_psramuhs_refresh_enable();
#ifndef FPGA
#if !defined(PSRAMUHS_DIG_LOOPBACK) && !defined(PSRAMUHS_ANA_LOOPBACK)
    hal_psramuhs_snoop_disable();
    psramuhsphy_calib(psramuhs_run_clk);
    hal_psramuhs_snoop_enable();
#endif
#endif
    //hal_psramuhs_mc_entry_auto_lp();
}

#endif