kunlun/plc/halphy/hw/phy_ana.c

/****************************************************************************

Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.

This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
be copied by any method or incorporated into another program without
the express written consent of Aerospace C.Power. This Information or any portion
thereof remains the property of Aerospace C.Power. The Information contained herein
is believed to be accurate and Aerospace C.Power assumes no responsibility or
liability for its use in any way and conveys no license or title under
any patent or copyright and makes no representation or warranty that this
Information is free from patent or copyright infringement.

****************************************************************************/

#include "ada_reg.h"
#include "phy_ana.h"
#include "ahb.h"
#include "hw_reg_api.h"
#include "phy_bb.h"
#include "phy_chn.h"
#include "phy_rxtd_reg.h"
#include "phy_rx_fd_reg.h"
#include "phy_dfe_reg.h"
#include "iot_io.h"
#include "hw_phy_api.h"
#include "phy_reg.h"
#include "phy_ana.h"
#include "phy_ana_hw.h"
#include "phy_txrx_pwr.h"
#include "phy_pm.h"

#if HW_PLATFORM > HW_PLATFORM_FPGA
#include "granite_reg.h"
#endif
extern uint32_t all_mask_gain_table[];

/* ada reg clk enable */
void enable_ada(uint32_t enable)
{
#if HW_PLATFORM != HW_PLATFORM_SIMU
    if (enable) {
        ahb_ada_enable();
    } else {
        ahb_ada_disable();
    }
#else
    (void)enable;
#endif
    return;
}

/* ada rst */
void warm_rst_ada()
{
#if HW_PLATFORM != HW_PLATFORM_SIMU
    ahb_ada_reset();
#endif
    return;
}

/* ada power on enable */
void phy_ada_enable(uint32_t enable)
{
    if (enable) {
        enable = 0x1;
    }
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    /* ADA power on */
    tmp = ADA_READ_REG(CFG_ADC_CFG0_ADDR);
    REG_FIELD_SET(ADA_POWER_ON, tmp, enable);
    ADA_WRITE_REG(CFG_ADC_CFG0_ADDR, tmp);
    tmp = ADA_READ_REG(CFG_ADC_CFG0_ADDR);
#endif

    return;
}

/***************************************DAC******************************************/

/* dac buf size conf */
void phy_dac_buf_size_cfg(uint32_t size)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    /* dac buf size */
    tmp = ADA_READ_REG(CFG_DAC_CFG0_ADDR);
    REG_FIELD_SET(DAC_BUF_SIZE, tmp, size);
    ADA_WRITE_REG(CFG_DAC_CFG0_ADDR, tmp);
#else
    (void)size;
#endif

    return;
}

/* dac mux conf, 0-DA_B come from phy and DA_A come from tone, 1 reverse */
void phy_dac_mux_cfg(DA_B_PATH_CFG path)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    /* DAC mux */
    tmp = ADA_READ_REG(CFG_DAC_CFG1_ADDR);
    REG_FIELD_SET(DAC_MUX, tmp, path);
    ADA_WRITE_REG(CFG_DAC_CFG1_ADDR, tmp);
#else
    (void)path;
#endif

    return;
}

/* dac clk inv en conf */
void phy_dac_clk_inv_cfg(uint32_t enable)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    /* DAC clk inv */
    tmp = ADA_READ_REG(CFG_ADC_CFG2_ADDR);
    REG_FIELD_SET(DAC_CLK_INV, tmp, enable);
    ADA_WRITE_REG(CFG_ADC_CFG2_ADDR, tmp);
#else
    (void)enable;
#endif

    return;
}

/* dac enable conf */
void phy_dac_en_cfg(uint32_t enable)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    /* DAC en */
    tmp = ADA_READ_REG(CFG_DAC_CFG0_ADDR);
    REG_FIELD_SET(SOC_DAC_EN, tmp, enable);
    ADA_WRITE_REG(CFG_DAC_CFG0_ADDR, tmp);
#else
    (void)enable;
#endif

    return;
}

/* dac mux conf */
void phy_dac_tone_mode_en_cfg(uint32_t enable)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;

    tmp = ADA_READ_REG(CFG_DAC_CFG1_ADDR);
    REG_FIELD_SET(TONE_MODE, tmp, enable);
    ADA_WRITE_REG(CFG_DAC_CFG1_ADDR, tmp);
#else
    (void)enable;
#endif

    return;
}

/* dac tone num conf */
void phy_dac_tone_num_cfg(uint32_t tone_num)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;

    tmp = ADA_READ_REG(CFG_DAC_CFG1_ADDR);
    REG_FIELD_SET(TONE_NUMBER, tmp, tone_num);
    ADA_WRITE_REG(CFG_DAC_CFG1_ADDR, tmp);
#else
    (void)tone_num;
#endif

    return;
}


/***************************************ADC******************************************/

/* adc enable conf */
void phy_adc_en_cfg(uint32_t enable)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    /* ADC en */
    tmp = ADA_READ_REG(CFG_ADC_CFG0_ADDR);
    REG_FIELD_SET(SOC_ADC_EN, tmp, enable);
    ADA_WRITE_REG(CFG_ADC_CFG0_ADDR, tmp);
#else
    (void)enable;
#endif

    return;
}

/* adc mode conf */
void phy_adc_mode_cfg(ADC_MODE_CFG mode)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    /* ADC mode select */
    if(mode == ADC_MODE_FORCE)
    {
        tmp = ADA_READ_REG(CFG_ADC_CFG2_ADDR);
        REG_FIELD_SET(ADC_FORCE_MODE, tmp, true);
        ADA_WRITE_REG(CFG_ADC_CFG2_ADDR, tmp);

        tmp = ADA_READ_REG(CFG_ADC_CFG2_ADDR);
        REG_FIELD_SET(ADC_AUTO_MODE, tmp, false);
        ADA_WRITE_REG(CFG_ADC_CFG2_ADDR, tmp);
    }
    else
    {
        tmp = ADA_READ_REG(CFG_ADC_CFG2_ADDR);
        REG_FIELD_SET(ADC_AUTO_MODE, tmp, true);
        ADA_WRITE_REG(CFG_ADC_CFG2_ADDR, tmp);

    }
#else
    (void)mode;
#endif

    return;
}

/* adc buf size conf */
void phy_adc_buf_size_cfg(uint32_t buf_size)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    /* buf size */
    tmp = ADA_READ_REG(CFG_ADC_CFG1_ADDR);
    REG_FIELD_SET(ADC_BUF_SIZE, tmp, buf_size);
    ADA_WRITE_REG(CFG_ADC_CFG1_ADDR, tmp);
#else
    (void)buf_size;
#endif

    return;
}

/* adc sample size conf */
void phy_adc_sample_size_cfg(uint32_t sample_size)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    /* sample size */
    tmp = ADA_READ_REG(CFG_ADC_CFG3_ADDR);
    REG_FIELD_SET(ADC_SAMPLE_SIZE, tmp, sample_size);
    ADA_WRITE_REG(CFG_ADC_CFG3_ADDR, tmp);
#else
    (void)sample_size;
#endif


    return;
}

/* adc threshhold conf */
void phy_adc_thrd_cfg(uint32_t thrd)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;

    tmp = ADA_READ_REG(CFG_ADC_CFG2_ADDR);
    REG_FIELD_SET(ADC_THR_VAL, tmp, thrd);
    ADA_WRITE_REG(CFG_ADC_CFG2_ADDR, tmp);
#else
    (void)thrd;
#endif

    return;
}

/* adc clk inv conf */
void phy_adc_clk_inv_cfg(uint32_t enable)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;

    tmp = ADA_READ_REG(CFG_ADC_CFG2_ADDR);
    REG_FIELD_SET(ADC_CLK_INV, tmp, enable);
    ADA_WRITE_REG(CFG_ADC_CFG2_ADDR, tmp);
#else
    (void)enable;
#endif

    return;
}

/* adc dmsb inv conf */
void phy_adc_dmsb_inv_cfg(uint32_t enable)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;

    tmp = ADA_READ_REG(CFG_ADC_CFG0_ADDR);
    REG_FIELD_SET(ADC_DMSB_INV, tmp, enable);
    ADA_WRITE_REG(CFG_ADC_CFG0_ADDR, tmp);
#else
    (void)enable;
#endif

    return;
}

/* adc sample done status */
bool_t phy_adc_is_sample_done()
{
    bool_t is_done = 0;

#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;

    tmp = ADA_READ_REG(CFG_ADC_CFG0_ADDR);
    //sample done;
    is_done = (tmp & ADC_SAMPLE_DONE_MASK)?1:0;
#endif

    return is_done;
}

/* adc trig en */
void phy_adc_trig_en_cfg(uint32_t enable)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;

    tmp = ADA_READ_REG(CFG_ADC_CFG0_ADDR);
    REG_FIELD_SET(ADC_TRIG, tmp, enable);
    ADA_WRITE_REG(CFG_ADC_CFG0_ADDR, tmp);
#else
    (void)enable;
#endif

    return;
}

/* adc trig addr */
uint32_t phy_adc_trig_addr_get()
{
    uint32_t trig_offset = 0;

#if HW_PLATFORM >= HW_PLATFORM_FPGA
    trig_offset = REG_FIELD_GET(ADC_TRIG_ADDR, ADA_READ_REG(CFG_ADC_STS0_ADDR));
#endif

    return trig_offset;
}

/* get ada power */
uint32_t phy_ada_get_power_on()
{
    uint32_t tmp = ADA_READ_REG(CFG_ADC_CFG0_ADDR);
    return REG_FIELD_GET(ADA_POWER_ON, tmp);
}

/*************************************************************************************/

/* DAC cfg */
void phy_ada_tx_cfg(DaTxPara_t *tp)
{
    /*clk enable*/
    enable_ada(true);
    //warm_rst_ada();

    /* DAC buf size */
    phy_dac_buf_size_cfg(tp->buf_size);

    /* DAC mux */
    phy_dac_mux_cfg(tp->path);

    /* DAC clk inv */
    phy_dac_clk_inv_cfg(tp->inv_en);

    /* dac mux conf */
    phy_dac_tone_mode_en_cfg(tp->tone_mode_en);

    /* dac tone num conf */
    phy_dac_tone_num_cfg(tp->tone_num);

    /* DAC en */
    phy_dac_en_cfg(false);//mode from phy
}

/* ADC cfg */
void phy_ada_rx_cfg(DaRxPara_t *rp)
{
    /*clk enable*/
    enable_ada(true);

    /* adc mode select */
    phy_adc_mode_cfg(rp->mode);

    /* ADC buf size conf */
    phy_adc_buf_size_cfg(rp->buf_size);

    /* ADC sample size conf */
    phy_adc_sample_size_cfg(rp->sample_size);

    /* ADC threshhold conf */
    phy_adc_thrd_cfg(rp->thrd);

    /* ADC clk inv conf */
    phy_adc_clk_inv_cfg(rp->clk_inv_en);

    /* ADC dmsb inv conf */
    phy_adc_dmsb_inv_cfg(rp->dmsb_inv_en);

    /* ADC en */
    phy_adc_en_cfg(true);

}

void phy_ana_tx_set(bool_t tx_en, bool_t dac_en)
{
#if HW_PLATFORM > HW_PLATFORM_FPGA
    uint8_t reg_id = 0;
    uint32_t wdata = 0;
    uint32_t wmask = 0;

    reg_id = CFG_ANA_TOP_REG_ADDR;
    wdata = tx_en << TOP_EN_TX_OFFSET | \
            dac_en << TOP_EN_DAC_OFFSET;
    wmask = TOP_EN_TX_MASK | TOP_EN_DAC_MASK;
    phy_ana_i2c_write(reg_id,wdata,wmask);
#else
    (void)tx_en;
    (void)dac_en;
#endif
}

void phy_ana_rx_set(bool_t rx_en, bool_t adc_en)
{
#if HW_PLATFORM > HW_PLATFORM_FPGA
    uint8_t reg_id = 0;
    uint32_t wdata = 0;
    uint32_t wmask = 0;

    reg_id = CFG_ANA_TOP_REG_ADDR;
    wdata = rx_en << TOP_EN_RX_OFFSET | \
            adc_en << TOP_EN_ADC_OFFSET;
    wmask = TOP_EN_RX_MASK | TOP_EN_ADC_MASK;
    phy_ana_i2c_write(reg_id,wdata,wmask);
#else
    (void)rx_en;
    (void)adc_en;
#endif
}

void phy_ana_sadc_enable(bool_t enable)
{
#if HW_PLATFORM > HW_PLATFORM_FPGA
    uint8_t reg_id = 0;
    uint8_t rodata = 0;
    uint32_t rdata = 0;
    uint32_t wdata = 0;
    uint32_t wmask = 0;

    /*init granite top reg */
    reg_id = CFG_ANA_TOP_REG_ADDR;
    if(enable) {
        wdata = TOP_EN_SADC_MASK; //enable sadc
    } else{
        wdata = 0; //enable sadc
    }
    wmask = TOP_EN_SADC_MASK;
    phy_ana_i2c_write(reg_id, wdata, wmask);

    /* init granite sadc reg */
    reg_id = CFG_ANA_SADC_REG_ADDR;
    phy_ana_i2c_read(reg_id, &rdata, &rodata);
    REG_FIELD_SET(SADC_EN, rdata, enable); //monitor sadc enable
    //REG_FIELD_SET(SADC_EN_CAL, rdata, 0);//sadc dc offset calibration enables
    phy_ana_i2c_write(reg_id, rdata, ~0);
#else
    (void)enable;
#endif
}

/* bb ana tx/rx */
void phy_ana_dfe_init(void)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_TX_START_CFG_ADDR);
    REG_FIELD_SET(SW_TX_START_CFG_DATA, tmp, 0x20202);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_TX_START_CFG_ADDR, tmp);

    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_TX_START_CFG_MASK_ADDR);
    REG_FIELD_SET(SW_TX_START_CFG_DATA_MASK, tmp, 0x28303);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_TX_START_CFG_MASK_ADDR, tmp);

    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_TX_END_CFG_ADDR);
    REG_FIELD_SET(SW_TX_END_CFG_DATA, tmp, 0x0);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_TX_END_CFG_ADDR, tmp);

    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_TX_END_CFG_MASK_ADDR);
    REG_FIELD_SET(SW_TX_END_CFG_DATA_MASK, tmp, 0x28303);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_TX_END_CFG_MASK_ADDR, tmp);

    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_RX_START_CFG_ADDR);
    REG_FIELD_SET(SW_RX_START_CFG_DATA, tmp, 0x8101);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_RX_START_CFG_ADDR, tmp);

    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_RX_START_CFG_MASK_ADDR);
    REG_FIELD_SET(SW_RX_START_CFG_DATA_MASK, tmp, 0x28303);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_RX_START_CFG_MASK_ADDR, tmp);

    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_RX_END_CFG_ADDR);
    REG_FIELD_SET(SW_RX_END_CFG_DATA, tmp, 0x0);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_RX_END_CFG_ADDR, tmp);

    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_RX_END_CFG_MASK_ADDR);
    REG_FIELD_SET(SW_RX_END_CFG_DATA_MASK, tmp, 0x28303);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_RX_END_CFG_MASK_ADDR, tmp);

    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_RX_ON_CFG_MASK_ADDR);
    REG_FIELD_SET(SW_RX_ON_CFG_DATA_MASK, tmp, 0xe7ffc0ff);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_RX_ON_CFG_MASK_ADDR, tmp);
#endif
}

/* wait until i2c is idle */
static inline void phy_wait_i2c_idle(uint32_t tmp)
{
#if HW_PLATFORM > HW_PLATFORM_FPGA
    do{
        tmp = PHY_DFE_READ_REG(CFG_BB_ANA_REG_CTRL_ADDR);
    }while(REG_FIELD_GET(ANA_I2C_BUSY, tmp) || \
            REG_FIELD_GET(RX_I2C_BUSY, tmp) || \
            REG_FIELD_GET(TOP_I2C_BUSY, tmp));
#else
    (void)tmp;
#endif
}

void phy_ana_i2c_write(uint32_t reg_id, uint32_t wdata, uint32_t mask)
{
#if HW_PLATFORM > HW_PLATFORM_FPGA
    uint32_t tmp = 0;
    uint8_t rodata = 0;
    uint32_t rdata = 0;
    uint32_t wmask = 0;

    /* check mask valid */
    if(!mask){
        return;
    }

    /* poll idle */
    phy_wait_i2c_idle(tmp);

    /* cfg mask */
    if((reg_id == CFG_ANA_TOP_REG_ADDR) || \
        (reg_id == CFG_ANA_RX_REG_0_ADDR) || \
        (~mask == 0))
    {
        tmp = PHY_DFE_READ_REG(CFG_BB_ANA_REG_WDATA_MASK_ADDR);
        REG_FIELD_SET(SW_ANA_REG_WDATA_MASK, tmp, mask);
        PHY_DFE_WRITE_REG(CFG_BB_ANA_REG_WDATA_MASK_ADDR, tmp);

        /* cfg wdata */
        PHY_DFE_WRITE_REG(CFG_BB_ANA_REG_WDATA_ADDR, wdata);
    }
    else{
        phy_ana_i2c_read(reg_id, &rdata, &rodata);
        wmask = (rdata & (~mask)) | (wdata & mask);

        /* cfg wdata */
        PHY_DFE_WRITE_REG(CFG_BB_ANA_REG_WDATA_ADDR, wmask);
    }

    /* poll idle */
    phy_wait_i2c_idle(tmp);

    /* cfg reg id, start write */
    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_REG_CTRL_ADDR);
    REG_FIELD_SET(SW_ANA_REG_ADDR, tmp, reg_id);
    REG_FIELD_SET(SW_ANA_REG_WR, tmp, 1);
    REG_FIELD_SET(SW_ANA_REG_START, tmp, 1);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_REG_CTRL_ADDR, tmp);

    /* poll idle */
    phy_wait_i2c_idle(tmp);
#else
    (void)reg_id;
    (void)wdata;
    (void)mask;
#endif
}

void phy_ana_i2c_read(uint32_t reg_id, uint32_t *rdata, uint8_t *rodata)
{
#if HW_PLATFORM > HW_PLATFORM_FPGA
    uint32_t tmp = 0;

    /* poll idle */
    phy_wait_i2c_idle(tmp);

    /* cfg reg id, start write */
    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_REG_CTRL_ADDR);
    REG_FIELD_SET(SW_ANA_REG_ADDR, tmp, reg_id);
    REG_FIELD_SET(SW_ANA_REG_WR, tmp, 0);
    REG_FIELD_SET(SW_ANA_REG_START, tmp, 1);
    PHY_DFE_WRITE_REG(CFG_BB_ANA_REG_CTRL_ADDR, tmp);

    /* poll idle */
    phy_wait_i2c_idle(tmp);

    /* get ro-data */
    tmp = PHY_DFE_READ_REG(CFG_BB_ANA_REG_CTRL_ADDR);
    *rodata = REG_FIELD_GET(SW_ANA_REG_RO_DATA, tmp);

    /* get rdata */
    *rdata = PHY_DFE_READ_REG(CFG_BB_ANA_REG_RDATA_ADDR);
#else
    (void)reg_id;
    (void)rdata;
    (void)rodata;
#endif
}

void phy_ana_pga_gain_set(uint32_t val)
{
#if HW_PLATFORM == HW_PLATFORM_SILICON
    phy_ana_i2c_write(CFG_ANA_TX_REG_ADDR, val << TX_GPGA_OFFSET, \
        TX_GPGA_MASK);
#else
    (void)val;
#endif
}

uint32_t phy_ana_pga_gain_get(void)
{
#if HW_PLATFORM == HW_PLATFORM_SILICON
    uint32_t rdata;
    uint8_t rodata;

    phy_ana_i2c_read(CFG_ANA_TX_REG_ADDR, &rdata, &rodata);
    return (uint32_t)REG_FIELD_GET(TX_GPGA, rdata);
#else
    return 3;
#endif
}

void phy_ana_tx_en(bool_t en)
{
#if HW_PLATFORM == HW_PLATFORM_SILICON
    phy_ana_i2c_write(CFG_ANA_TOP_REG_ADDR, \
        (en << TOP_EN_DAC_OFFSET) | \
        (en << TOP_EN_TX_OFFSET), \
        TOP_EN_DAC_MASK | \
        TOP_EN_TX_MASK);
#else
    (void)en;
#endif
}

void phy_ana_rx_en(bool_t en)
{
#if HW_PLATFORM == HW_PLATFORM_SILICON
    phy_ana_i2c_write(CFG_ANA_TOP_REG_ADDR, \
        (en << TOP_EN_ADC_OFFSET) | \
        (en << TOP_EN_RX_OFFSET), \
        TOP_EN_ADC_MASK | \
        TOP_EN_RX_MASK);
#else
    (void)en;
#endif
}

void phy_ana_enlic_en(uint8_t val)
{
#if HW_PLATFORM == HW_PLATFORM_SILICON
    phy_ana_i2c_write(CFG_ANA_TOP_REG_ADDR, \
        (val << TOP_ENLIC_OFFSET), \
        TOP_ENLIC_MASK);
#else
    (void)val;
#endif
}

void phy_ana_filter_set(uint8_t val)
{
#if HW_PLATFORM == HW_PLATFORM_SILICON
    phy_ana_i2c_write(CFG_ANA_RX_REG_0_ADDR, \
        (val << RX_SELC_OFFSET), \
        RX_SELC_MASK);
#else
    (void)val;
#endif
}

void phy_ana_dbg_print()
{
#if HW_PLATFORM == HW_PLATFORM_SILICON
    uint8_t rodata = 0;
    uint32_t rdata = 0;

    phy_ana_i2c_read(CFG_ANA_RX_REG_0_ADDR, &rdata, &rodata);
    iot_printf("Analog rx0:0x%x, ", rdata);
    phy_ana_i2c_read(CFG_ANA_TX_REG_ADDR, &rdata, &rodata);
    iot_printf("tx6:0x%x, ", rdata);
    phy_ana_i2c_read(CFG_ANA_TOP_REG_ADDR, &rdata, &rodata);
    iot_printf("top10:0x%x\n", rdata);
#endif
}

void phy_ana_set_filter_init(uint32_t band_id)
{
#if HW_PLATFORM > HW_PLATFORM_FPGA
    uint32_t wdata = 0;
    /* bandwidth filter set if cal ok */
    uint32_t tmp = 0;
    uint32_t end_tone = 0;
    /* get end tone */
    tmp = PHY_READ_REG(CFG_BB_R0_B0_TONE_ADDR);
    end_tone = REG_FIELD_GET(SW_RATE0_BAND0_END_TONE, tmp);
    tmp = PHY_READ_REG(CFG_BB_R1_B0_TONE_ADDR);
    if (end_tone < REG_FIELD_GET(SW_RATE0_BAND0_END_TONE, tmp)) {
        end_tone = REG_FIELD_GET(SW_RATE0_BAND0_END_TONE, tmp);
    }

    /* TODO: get filter value from const table */
    if (end_tone <= 120) {
        wdata = 63;
    } else if (end_tone <= 230) {
        wdata = (g_phy_ctxt.dep.band_8m_cap_set > 0) ?
            g_phy_ctxt.dep.band_8m_cap_set : 63;
    } else if (end_tone <= 400) {
        wdata = 23; /* rx safe with 12M */
    } else if (end_tone <= 500) {
        wdata = (g_phy_ctxt.dep.band_15m_cap_set > 0) ?
            g_phy_ctxt.dep.band_15m_cap_set : 18;
    } else if (end_tone <= 743) {
        wdata = (g_phy_ctxt.dep.band_20m_cap_set > 0) ?
            g_phy_ctxt.dep.band_20m_cap_set : 14;
    } else if (end_tone <= 1256) {
        wdata = 9;  /* rx safe with 30M */
    } else {
        wdata = 7;  /* rx safe with 38M */
    }

    if (band_id == IOT_SUPPORT_TONE_MULTI_BAND021) {
        wdata = 57; /* opt 6m spur */
    }

    phy_ana_filter_set(wdata);

    iot_printf("%s bandwidth filter set value: %d.\n", \
        __FUNCTION__, wdata);
#else
    (void)band_id;
#endif
}

void phy_ana_init(uint32_t band_id)
{
#if HW_PLATFORM == HW_PLATFORM_FPGA

    DaTxPara_t tp = {0};
    DaRxPara_t rp = {0};

    /* ada soft reset */
    warm_rst_ada();
    /* turn ada on */
    phy_ada_enable(true);

    /* DAC cfg */
    tp.buf_size = 100;
    tp.inv_en = true;
    tp.path = DA_B_PATH_TONE;
    phy_ada_tx_cfg(&tp);
    /* ADC cfg */
    rp.buf_size = MAC_RX_BUF_SIZE;
    rp.sample_size = MAC_RX_SAMPLE_SIZE;
    rp.mode = ADC_MODE_FORCE;
    rp.thrd = 500;
    rp.clk_inv_en = false;
    rp.dmsb_inv_en = true;
    phy_ada_rx_cfg(&rp);
    (void)band_id;

#elif HW_PLATFORM > HW_PLATFORM_FPGA

    /* config default RX ON regsiter */
    phy_agc_gain_adj_dis(0xE7FFC0FF);

    /* ana filter init */
    phy_ana_set_filter_init(band_id);

    /* fix tx gain */
#if (IOT_DTEST_ONLY_SUPPORT == 0)
    uint32_t tx_pwr_enable = 0;
    tx_pwr_enable = phy_get_pwr_ctl_en();
    if (g_phy_ctxt.indep.tx_pwr_psd_fix_db || tx_pwr_enable) {
        phy_ana_i2c_write(CFG_ANA_TX_REG_ADDR, \
            3 << TX_GPGA_OFFSET, \
            TX_GPGA_MASK);
    } else {
        phy_ana_i2c_write(CFG_ANA_TX_REG_ADDR, \
            g_phy_ctxt.indep.tx_pga << TX_GPGA_OFFSET, \
            TX_GPGA_MASK);
        iot_printf("tx pga:%d\n", g_phy_ctxt.indep.tx_pga);
    }
#else
    phy_ana_i2c_write(CFG_ANA_TX_REG_ADDR, \
        3 << TX_GPGA_OFFSET, \
        TX_GPGA_MASK);
#endif

    /* en adc and rx, disable dac and tx */
    phy_ana_i2c_write(CFG_ANA_TOP_REG_ADDR, \
        (1 << TOP_EN_ADC_OFFSET) | \
        (1 << TOP_ENLIC_OFFSET) | \
        (1 << TOP_EN_RX_OFFSET), \
        TOP_EN_DAC_MASK | \
        TOP_EN_ADC_MASK | \
        TOP_ENLIC_MASK | \
        TOP_EN_TX_MASK | \
        TOP_EN_RX_MASK);

    /* enable sadc */
    phy_ana_sadc_enable(1);

    /* 1:select the sadc data; 0:select adc 16-downsampling data  */
    phy_adc_mon_sel_set(true);
    phy_bias_init_lic_io();

#else
    (void)band_id;
#endif
}

void phy_sadc_pt_init()
{
#if HW_PLATFORM > HW_PLATFORM_FPGA
    uint32_t reg_id = 0;
    uint8_t rodata = 0;
    uint32_t rdata = 0;
    uint32_t wdata = 0;
    uint32_t wmask = 0;
    /*init granite top reg */
    reg_id = CFG_ANA_TOP_REG_ADDR;
    wdata = TOP_EN_SADC_MASK;
    wmask = TOP_EN_SADC_MASK | TOP_ATB2PAD_EN_MASK | TOP_EN_ADC_MASK | TOP_EN_RX_MASK;
    phy_ana_i2c_write(reg_id, wdata, wmask);

    /* init granite sadc reg */
    reg_id = CFG_ANA_SADC_REG_ADDR;
    phy_ana_i2c_read(reg_id, &rdata, &rodata);
    REG_FIELD_SET(SADC_EN_CAL, rdata, 0);
    REG_FIELD_SET(SADC_EN, rdata, 1);               //sadc_en = 1
    REG_FIELD_SET(SADC_SEL_SCL_MUX, rdata, 0);      //SADC_SEL_SCL_MUX = 0
    REG_FIELD_SET(SADC_METER2PAD_EN_OVR, rdata, 0); //set 0000
    REG_FIELD_SET(SADC_F_H, rdata, 4);              //set 100
    REG_FIELD_SET(SADC_CFG_DLY, rdata, 4);          //set 100
    REG_FIELD_SET(SADC_SAMPLE_SEL, rdata, 0);       //set 0
    REG_FIELD_SET(SADC_TIMER_DLY, rdata, 14);       //sadc_timer_dly[3:0] = 1110
    phy_ana_i2c_write(reg_id, rdata, ~0);

    /* init granite bias reg 2*/
    reg_id = CFG_ANA_BIAS_REG_2_ADDR;
    phy_ana_i2c_read(reg_id, &rdata, &rodata);
    REG_FIELD_SET(BIAS_EN_ICAL, rdata, 0);     //en_ical=1
    REG_FIELD_SET(BIAS_SEL_IC_TEST, rdata, 0); //sel_ic_test[7:0] = 0000_0000
    // REG_FIELD_SET(BIAS_CAL, rdata, 16);        //cal[4:0] = 1_0000
    REG_FIELD_SET(BIAS_TRIM_ADCREF, rdata, 3);
    REG_FIELD_SET(BIAS_TRIM_DCDC, rdata, 3);
    REG_FIELD_SET(BIAS_TEST_VBG, rdata, 0); //BIAS_TEST_VBG
    phy_ana_i2c_write(reg_id, rdata, ~0);

    /* init granite ADC reg */
    reg_id = CFG_ANA_ADC_REG_ADDR;
    phy_ana_i2c_read(reg_id, &rdata, &rodata);
    REG_FIELD_SET(ADC_ATB_SEL, rdata, 0);
    phy_ana_i2c_write(reg_id, rdata, ~0);
#endif
}

/* get the gain table */
void phy_pgf_bq_pga_gain_get(uint16_t gain_idx, \
    volatile uint8_t *pgf, \
    volatile uint8_t *bq, \
    volatile uint8_t *pga, \
    volatile uint8_t *lna, \
    volatile uint8_t *byphpf, \
    volatile uint8_t *enord2, \
    volatile uint8_t *bq_qvalue)
{
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    uint32_t tmp = 0;

    IOT_ASSERT(gain_idx < 170);

    tmp = all_mask_gain_table[gain_idx];
    *pgf = (tmp & RX_GPGF_MASK) >> RX_GPGF_OFFSET;
    *bq = (tmp & RX_GBQ_MASK) >> RX_GBQ_OFFSET;
    *pga = (tmp & RX_GPGA_MASK) >> RX_GPGA_OFFSET;
    *lna = (tmp & PHY_GAIN_GLNA_MASK) >> PHY_GAIN_GLNA_OFFSET;
    *byphpf = (tmp & PHY_GAIN_BYPHPF_MASK) >> PHY_GAIN_BYPHPF_OFFSET;
    *enord2 = (tmp & PHY_GAIN_HPF_ENORD2_MASK) >> PHY_GAIN_HPF_ENORD2_OFFSET;

    (void)bq_qvalue;
#else
    (void)gain_idx;
    (void)pgf;
    (void)bq;
    (void)pga;
    (void)lna;
    (void)byphpf;
    (void)enord2;
    (void)bq_qvalue;
#endif
}