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

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 "multi_nid_sync.h"
#include "phy_bb.h"
#include "iot_errno_api.h"
#include "plc_const.h"
#include "iot_io.h"
#include "mac_sched_hw.h"
#include "plc_utils.h"
#include "mac_pdev.h"
#include "phy_multi_ppm.h"
#include "mac_vdev.h"
#include "hw_war.h"
#include "mac_cmn_hw.h"
#include "plc_protocol.h"

#if ENA_SYNC_DIFF_CCO_PPM

#define mac_multi_sync_ctxt_get(pdev_id)        \
    (((pdev_id) < MAX_PDEV_NUM) ? (&g_mac_pdev[pdev_id]->ppm_cal) : NULL)

static uint32_t mac_multi_sync_get_nid(m_ppm_cal_ctxt_t *ctxt,
    uint8_t idx)
{
    if (idx >= MAX_SYNC_CCO_CNT || ctxt == NULL) {
        IOT_ASSERT(0);
    }

    return ctxt->ppm_cal[idx].nid;
}

static void mac_multi_sync_set_nid(m_ppm_cal_ctxt_t *ctxt, uint8_t idx,
    nid_t nid)
{
    if (idx >= MAX_SYNC_CCO_CNT || ctxt == NULL) {
        IOT_ASSERT(0);
    }

    ctxt->ppm_cal[idx].nid = nid;
    return;
}

static uint32_t mac_multi_sync_get_flag(m_ppm_cal_ctxt_t *ctxt,
    uint8_t idx)
{
    (void)ctxt;
    phy_ppm_status_ctxt_t *p_ctxt =
        phy_multi_sync_get_ppm_status();
    return phy_multi_sync_get_valid_flag(p_ctxt, idx);
}

static void mac_multi_sync_ppm_rst(m_ppm_cal_ctxt_t *ctxt)
{
    ctxt->last_clear_ntb = 0;
    ctxt->phy_ppm_ctxt = phy_multi_sync_get_ppm_status();
    for (uint8_t idx = 0; idx < MAX_SYNC_CCO_CNT; idx++) {
        ctxt->ppm_cal[idx].rsv = 0;
        ctxt->ppm_cal[idx].nid = PLC_NID_INVALID;
        ctxt->ppm_cal[idx].ntb_record.last_bcn_local_ts = 0;
        ctxt->ppm_cal[idx].ntb_record.last_bcn_remote_tx_ntb = 0;
        ctxt->ppm_cal[idx].ntb_record.last_saved_ntb = 0;
        ctxt->ppm_cal[idx].ntb_record.last_bcn_local_ntb = 0;
    }
}

uint8_t IRAM_ATTR mac_multi_sync_get_ena(uint8_t pdev_id)
{
    m_ppm_cal_ctxt_t *ctxt = mac_multi_sync_ctxt_get(pdev_id);
    if (NULL == ctxt) {
        return 0;
    }

    phy_ppm_status_ctxt_t *status_ctxt =
        (phy_ppm_status_ctxt_t *)ctxt->phy_ppm_ctxt;
    IOT_ASSERT(status_ctxt);

    return status_ctxt->enable;
}

void mac_multi_sync_set_ena(uint8_t pdev_id, uint8_t enable_flag)
{
    m_ppm_cal_ctxt_t *ctxt = mac_multi_sync_ctxt_get(pdev_id);
    phy_ppm_status_ctxt_t *status_ctxt =
        (phy_ppm_status_ctxt_t*)ctxt->phy_ppm_ctxt;
    IOT_ASSERT(ctxt != NULL && status_ctxt != NULL);

    enable_flag = (enable_flag == 0) ? 0 : 1;
    if (enable_flag == mac_multi_sync_get_ena(pdev_id)) {
        return;
    }

    phy_multi_sync_set_enable(status_ctxt, enable_flag);

    if (enable_flag == 0) {
        mac_multi_sync_ppm_rst(ctxt);
        phy_multi_sync_ppm_rst(status_ctxt);
    }

    iot_printf("[M-NID]multi sync ena=%d\n", enable_flag);
}

int32_t mac_multi_sync_get_ppm(uint8_t pdev_id, nid_t nid)
{
    phy_ppm_status_ctxt_t *ctxt =
        phy_multi_sync_get_ppm_status();
    uint8_t idx = phy_multi_sync_get_record_idx(ctxt, nid);

    (void)pdev_id;
    if (idx < MAX_SYNC_CCO_CNT) {
        return phy_multi_sync_get_record_ppm(ctxt, idx);
    }

    return PLC_MAX_MAC_NTB_PPM;
}

void mac_multi_sync_init(uint8_t pdev_id)
{
    phy_ppm_status_ctxt_t *status_ctxt;
    m_ppm_cal_ctxt_t *ctxt = mac_multi_sync_ctxt_get(pdev_id);

    if (NULL == ctxt) {
        return;
    }
    ctxt->phy_ppm_ctxt = phy_multi_sync_get_ppm_status();
    status_ctxt = (phy_ppm_status_ctxt_t*)ctxt->phy_ppm_ctxt;
    mac_multi_sync_ppm_rst(ctxt);
    phy_multi_sync_ppm_rst(status_ctxt);
    phy_multi_sync_set_enable(status_ctxt, ENA_SYNC_DIFF_CCO_PPM);
    /* nid=0 ppm set mp ppms */
    phy_multi_sync_set_record_ppm(status_ctxt, 0,
        (-g_phy_ctxt.dep.phy_cal_ppm_in_oem) << PLC_NTB_PPM_SHIFT);
    /* set valid flag */
    phy_multi_sync_set_valid_flag(status_ctxt,
        0, RECORD_PPM_VALID);
#if HW_PLATFORM >= HW_PLATFORM_FPGA
    /* enable hw tx/rx multippm sync */
    phy_set_sw_nn_rx_ppm_en(ENA_SYNC_DIFF_CCO_PPM);
    phy_set_sw_nn_tx_ppm_en(ENA_SYNC_DIFF_CCO_PPM);
    /* if hw ppm, set hw ppm */
    phy_set_sw_nn_ppm_para(0, PLC_NID_INVALID,
        -g_phy_ctxt.dep.phy_cal_ppm_in_oem);
#endif
}

uint32_t mac_multi_ppm_record(uint8_t pdev_id, nid_t nid, nid_t my_nid,
    uint32_t rate_mode, uint32_t r_ts, uint32_t l_ts, uint32_t l_ntb,
    uint32_t min_update_period, int16_t ppm_err)
{
    m_ppm_cal_ctxt_t *cal_ctxt = mac_multi_sync_ctxt_get(pdev_id);
    phy_ppm_status_ctxt_t *status_ctxt =
        (phy_ppm_status_ctxt_t *)cal_ctxt->phy_ppm_ctxt;
    uint32_t ret = ERR_FAIL;
    uint8_t final_idx = MAX_SYNC_CCO_CNT;
    uint32_t tmp_nid;
    uint32_t valid;
    mac_ntb_record_ctxt_t tmp_record, *final_record;

    (void)rate_mode;
    if ((NULL == cal_ctxt) || (mac_multi_sync_get_ena(pdev_id) == 0)) {
        return ret;
    }

    /* find the place to insert, there's 2 conditions:
     * 1) nid already saved
     * 2) nid not saved before
     * for 1) case, we need use the original entry,
     * for 2) case, we need to find there's enough place to save new nid.
     */
    for (uint8_t idx = 1; idx < MAX_SYNC_CCO_CNT; idx++) {
        valid = mac_multi_sync_get_flag(cal_ctxt, idx);
        tmp_nid = mac_multi_sync_get_nid(cal_ctxt, idx);
        if (final_idx == MAX_SYNC_CCO_CNT && valid == RECORD_PPM_INVALID_NID) {
            final_idx = idx;
        }
        if (nid == tmp_nid) {
            final_idx = idx;
            break;
        }
    }

    if (final_idx != MAX_SYNC_CCO_CNT) {
        valid = mac_multi_sync_get_flag(cal_ctxt, final_idx);
        if (valid == RECORD_PPM_INVALID_NID) {
            mac_multi_sync_set_nid(cal_ctxt, final_idx, nid);
            phy_multi_sync_set_record_nid(status_ctxt, final_idx, nid);
            phy_multi_sync_set_valid_flag(status_ctxt, final_idx,
                RECORD_PPM_INVALID_PPM);
        }

        if (my_nid == PLC_NID_INVALID || nid != my_nid) {
            /* if this nid is not my nid, then cal ppm here */
            final_record = &cal_ctxt->ppm_cal[final_idx].ntb_record;
            if (valid == RECORD_PPM_INVALID_NID) {
                /* first update */
                ppm_err = mac_ppm_cal(final_record, r_ts, l_ts, l_ntb,
                    min_update_period);
            } else {
                os_mem_cpy(&tmp_record, final_record, sizeof(tmp_record));
                ppm_err = mac_ppm_cal(&tmp_record, r_ts, l_ts, l_ntb,
                    min_update_period);
                if (IOT_ABS(ppm_err) > PLC_SYNC_NTB_MAX_PPM) {
                    if (valid == RECORD_PPM_INVALID_PPM) {
                        /* set to pib ppm */
                        ppm_err = -phy_get_cal_ppm_in_pib() << PLC_NTB_PPM_SHIFT;
                    } else {
                        ppm_err = PLC_MAX_MAC_NTB_PPM; /* invalid ppm */
                        if ((tmp_record.last_saved_ntb
                            - final_record->last_saved_ntb)
                            > MAC_MULTI_UPDATE_TIMEOUT_NTB) {
                            os_mem_cpy(final_record, &tmp_record,
                                sizeof(tmp_record));
                        }
                    }
                } else {
                    os_mem_cpy(final_record, &tmp_record, sizeof(tmp_record));
                }
            }
        } else if (my_nid != PLC_NID_INVALID) {
            /* if nid is not my nid, then follow 168 line,
             * just save the local ntb here for aging the ppm status */
            cal_ctxt->ppm_cal[final_idx].ntb_record.last_saved_ntb = \
                mac_sched_get_ntb64(NULL);
        }

        if (ppm_err > -PLC_MAX_MAC_NTB_PPM && ppm_err < PLC_MAX_MAC_NTB_PPM) {
            /* if ppm_err is valid, save the ppm of the corresponding nid */
            phy_multi_sync_set_record_ppm(status_ctxt, final_idx, ppm_err);
            /* set valid flag */
            phy_multi_sync_set_valid_flag(status_ctxt,
                final_idx, RECORD_PPM_VALID);
            ret = ERR_OK;
        } else {
            ret = ERR_FAIL;
        }

        if (valid != RECORD_PPM_VALID) {
            iot_printf("[M-NID]nid:%x,ppm:%d,flag:%d\n", nid, ppm_err, valid);
        }
    }

    ret = phy_multi_sync_set_ppm(status_ctxt, nid);
    if (ret != ERR_OK) {
        iot_printf("ckq set multippm err, nid:0x%x\n", nid);
    }

    return ret;
}

void mac_multi_sync_nid_timeout_clear(uint8_t pdev_id)
{
    m_ppm_cal_ctxt_t *cal_ctxt = mac_multi_sync_ctxt_get(pdev_id);
    phy_ppm_status_ctxt_t *status_ctxt =
        (phy_ppm_status_ctxt_t *)cal_ctxt->phy_ppm_ctxt;

    IOT_ASSERT(cal_ctxt != NULL && status_ctxt != NULL);
    uint64_t cur_ntb = mac_sched_get_ntb64(NULL);

    if (mac_multi_sync_get_ena(pdev_id) == 0) {
        return;
    }

    if ((int64_t)(cur_ntb - cal_ctxt->last_clear_ntb) < MAX_BCN_RX_TIMEOUT_NTB) {
        return;
    } else {
        cal_ctxt->last_clear_ntb = cur_ntb;
    }

    for (uint8_t idx = 1; idx < MAX_SYNC_CCO_CNT; idx++) {
        uint32_t cur_nid = cal_ctxt->ppm_cal[idx].nid;
        if ((cur_nid != PLC_NID_INVALID) &&
            ((int64_t)(cur_ntb - cal_ctxt->ppm_cal[idx].ntb_record.last_saved_ntb) >
            MAX_BCN_RX_TIMEOUT_NTB)) {
            iot_printf("[M-NID]aged nid:%x,ppm:%d\n",
                cal_ctxt->ppm_cal[idx].nid, status_ctxt->ppm_status[idx].ppm_err);

            cal_ctxt->ppm_cal[idx].rsv = 0;
            cal_ctxt->ppm_cal[idx].nid = PLC_NID_INVALID;
            cal_ctxt->ppm_cal[idx].ntb_record.last_bcn_local_ts = 0;
            cal_ctxt->ppm_cal[idx].ntb_record.last_bcn_remote_tx_ntb = 0;
            cal_ctxt->ppm_cal[idx].ntb_record.last_saved_ntb = 0;
            cal_ctxt->ppm_cal[idx].ntb_record.last_bcn_local_ntb = 0;

            status_ctxt->ppm_status[idx].rsv = 0;
            status_ctxt->ppm_status[idx].valid = RECORD_PPM_INVALID_NID;
            status_ctxt->ppm_status[idx].nid = PLC_NID_INVALID;
            status_ctxt->ppm_status[idx].ppm_err = 0;

            phy_set_sw_nn_ppm_para(idx, PLC_NID_INVALID, 0);
        }
    }
}

static uint32_t mac_ntb_convert(uint8_t pdev_id, nid_t nid,
    uint32_t *l_ntb_array, uint32_t l_ntb_len,
    uint32_t *r_ntb_array, uint32_t r_ntb_len)
{
    uint16_t ret = ERR_FAIL;
    int16_t delta_ppm = 0;
    int16_t my_ppm = 0;
    int16_t other_ppm = 0;
    uint32_t last_bcn_local_ntb = 0;
    uint32_t last_bcn_remote_tx_ntb = 0;
    uint32_t tmp_idx;
    uint32_t *tmp_ptr;
    int32_t tmp;
    int64_t delta_ntb;
    nid_t my_nid;
    mac_pdev_t *pdev = get_pdev_ptr(pdev_id);
    mac_vdev_t *vdev = pdev->vdev[PLC_DEFAULT_VDEV];
    uint64_t curr_ntb = mac_sched_get_ntb64(NULL);
    uint64_t last_bcn_local_ntb64 = 0;

    m_ppm_cal_ctxt_t *cal_ctxt = &pdev->ppm_cal;
    phy_ppm_status_ctxt_t *status_ctxt = \
        (phy_ppm_status_ctxt_t *)cal_ctxt->phy_ppm_ctxt;
    IOT_ASSERT(cal_ctxt != NULL && status_ctxt != NULL);

    vdev_get_nid(vdev, &my_nid);

    if (mac_multi_sync_get_ena(pdev_id) == 0) {
        return ret;
    }

    if (my_nid == nid) {
        return ret;
    }

    for (uint8_t idx = 1; idx < MAX_SYNC_CCO_CNT; idx++) {
        if (mac_multi_sync_get_flag(cal_ctxt, idx) != RECORD_PPM_VALID) {
            continue;
        }
         uint32_t cur_nid = status_ctxt->ppm_status[idx].nid;
         if (nid == cur_nid) {
            last_bcn_local_ntb = \
                cal_ctxt->ppm_cal[idx].ntb_record.last_bcn_local_ntb;
            last_bcn_remote_tx_ntb = \
                cal_ctxt->ppm_cal[idx].ntb_record.last_bcn_remote_tx_ntb;
            last_bcn_local_ntb64 = \
                cal_ctxt->ppm_cal[idx].ntb_record.last_saved_ntb;
            other_ppm = phy_multi_sync_get_record_ppm(status_ctxt, idx);
            if (other_ppm != PLC_MAX_MAC_NTB_PPM) {
                ret = ERR_OK;
            }
         }
         if (my_nid != PLC_NID_INVALID && my_nid == cur_nid) {
            my_ppm = phy_multi_sync_get_record_ppm(status_ctxt, idx);
         }
    }

    if (ret == ERR_OK) {
        /* if the last_bcn_local_ntb64 is far from curr_ntb, cannot be converted
         */
        if (curr_ntb - last_bcn_local_ntb64 > (UINT32_MAX / 2)) {
            ret = ERR_FAIL;
            goto out;
        }
        if (l_ntb_array != NULL) {
            delta_ppm = other_ppm - my_ppm;
            tmp_ptr = l_ntb_array;
            for (tmp_idx = 0; tmp_idx < l_ntb_len; tmp_idx++) {
                tmp = (int32_t)(*(tmp_ptr + tmp_idx) - last_bcn_local_ntb);
                delta_ntb = tmp;
                delta_ntb = (delta_ntb << (PPM_CALC_MILLION_SHIFT
                    + PLC_NTB_PPM_SHIFT)) / ((1 << (PPM_CALC_MILLION_SHIFT
                    + PLC_NTB_PPM_SHIFT)) + delta_ppm);
                *(tmp_ptr + tmp_idx) = (uint32_t)(last_bcn_remote_tx_ntb
                    + delta_ntb);
            }
        }

        if (r_ntb_array != NULL) {
            delta_ppm = my_ppm - other_ppm;
            tmp_ptr = r_ntb_array;
            for (tmp_idx = 0; tmp_idx < r_ntb_len; tmp_idx++) {
                tmp = (int32_t)(*(tmp_ptr + tmp_idx) - last_bcn_remote_tx_ntb);
                delta_ntb = tmp;
                delta_ntb = (delta_ntb << (PPM_CALC_MILLION_SHIFT
                    + PLC_NTB_PPM_SHIFT)) / ((1 << (PPM_CALC_MILLION_SHIFT
                    + PLC_NTB_PPM_SHIFT)) + delta_ppm);
                *(tmp_ptr + tmp_idx) = (uint32_t)(last_bcn_local_ntb
                    + delta_ntb);
            }
        }
    }

out:
    return ret;
}

uint32_t mac_myntb_to_other_ntb(uint8_t pdev_id, nid_t nid, uint32_t *array,
    uint32_t len)
{
    uint32_t ret = ERR_FAIL;

    if (mac_multi_sync_get_ena(pdev_id) == 0) {
        return ret;
    }
    ret = mac_ntb_convert(pdev_id, nid, array, len, NULL, 0);

    return ret;
}

uint32_t mac_other_ntb_to_myntb(uint8_t pdev_id, nid_t nid, uint32_t *array,
    uint32_t len)
{
    uint32_t ret = ERR_FAIL;

    if (mac_multi_sync_get_ena(pdev_id) == 0) {
        return ret;
    }
    ret = mac_ntb_convert(pdev_id, nid, NULL, 0, array, len);

    return ret;
}

void mac_multi_sync_apply_new_ppm_step(uint8_t pdev_id, nid_t nid,
    int8_t ppm_step)
{
    phy_ppm_status_ctxt_t *ppm_sts_ctxt = NULL;
    uint32_t ppm_sync_valid = 0;
    int16_t ppm_oem;
    uint8_t idx;

    (void)pdev_id;

    if (nid != PLC_DBG_PKT_MODE_NID) {
        return;
    }
    ppm_sts_ctxt = phy_multi_sync_get_ppm_status();
    idx = phy_multi_sync_get_record_idx(ppm_sts_ctxt, nid);
    ppm_sync_valid = phy_multi_sync_get_valid_flag(ppm_sts_ctxt, idx);
    ppm_oem = phy_get_cal_ppm_in_pib();
    if (ppm_sync_valid == RECORD_PPM_VALID) {
        phy_multi_sync_set_record_ppm(ppm_sts_ctxt, idx,
            (-ppm_oem + ppm_step) << PLC_NTB_PPM_SHIFT);
        phy_multi_sync_set_ppm(ppm_sts_ctxt, nid);
#if ENA_SW_SYNC_PPM_WAR || ENA_HW_SYNC_PPM_WAR
        g_phy_ctxt.dep.phy_ppm_init = (ppm_oem - ppm_step) << PLC_REG_PPM_SHIFT;
            g_phy_cpu_share_ctxt.phy_ppm_init = g_phy_ctxt.dep.phy_ppm_init;
#endif
    }
}

#endif

uint8_t mac_multi_sync_get_ppm_tbl(pdevid_t pdev_id, plc_ppm_status_t *ppm_tbl)
{
    uint8_t vaild_nid_cnt = 0;
    if (!mac_multi_sync_get_ena(pdev_id)) {
        BUILD_BUG_ON(PLC_MAX_NEIGHBOR_NETWORK >= 2);
        uint32_t self_nid = mac_get_hw_nid();
        if (self_nid != PLC_NID_INVALID) {
            ppm_tbl[vaild_nid_cnt].nid = 0;
            ppm_tbl[vaild_nid_cnt].ppm_err = phy_txppm_get();
            vaild_nid_cnt++;
            ppm_tbl[vaild_nid_cnt].nid = self_nid;
            ppm_tbl[vaild_nid_cnt].ppm_err = phy_txppm_get();
            vaild_nid_cnt++;
        } else {
            ppm_tbl[vaild_nid_cnt].nid = 0;
            ppm_tbl[vaild_nid_cnt].ppm_err =  -phy_get_cal_ppm_in_pib();
            vaild_nid_cnt++;
        }
        return vaild_nid_cnt;
    }

    phy_ppm_status_ctxt_t *ctxt =
        phy_multi_sync_get_ppm_status();

    for (uint8_t idx = 0; idx < MAX_SYNC_CCO_CNT &&
        vaild_nid_cnt < PLC_MAX_NEIGHBOR_NETWORK; idx++) {
        if (!phy_multi_sync_get_valid_flag(ctxt, idx)) {
            continue;
        }
        ppm_tbl[vaild_nid_cnt].nid = phy_multi_sync_get_record_nid(ctxt, idx);
        ppm_tbl[vaild_nid_cnt].ppm_err =
            phy_multi_sync_get_record_ppm(ctxt, idx) >> PLC_NTB_PPM_SHIFT;
        vaild_nid_cnt++;
    }
    (void)pdev_id;
    (void)ctxt;
    return vaild_nid_cnt;
}