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

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 "rx_mpdu_start.h"
#include "hw_desc.h"
#include "mpdu_header.h"
#include "rx_pb_start.h"
#include "plc_protocol.h"
#include "mac_data_api.h"
#include "phy_bb.h"
#include "iot_io.h"
#include "mac_sched_hw.h"
#include "mac_tx_hw.h"
#include "mac_hplc_ext_api.h"

uint32_t mac_get_nncco_protect_region_offset(uint32_t proto, void *fc)
{
    uint32_t ret = 0;
    switch (proto)
    {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
        ret = ((frame_control_t *)fc)->vf.nn_cco.sbandoffset;
        break;
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
        ret = ((spg_frame_control_t *)fc)->vf.nn_cco.bwth_start_shift;
        break;
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
        /* GP has no this feature */
        IOT_ASSERT(0);
        break;
#endif
    default:
        // todo
        break;
    }
    return ret;
}

uint32_t mac_get_nncco_received_nid(uint32_t proto, void *fc)
{
    uint32_t ret = 0;
    switch (proto)
    {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
        ret = ((frame_control_t *)fc)->vf.nn_cco.receive_nid;
        break;
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
        ret = ((spg_frame_control_t *)fc)->vf.nn_cco.neighbor_network;
        break;
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
        /* GP has no this feature */
        IOT_ASSERT(0);
        break;
#endif
    default:
        // todo
        break;
    }
    return ret;
}

uint32_t mac_is_unicast(uint32_t proto, void *fc, uint8_t is_rf)
{
    uint32_t ret = 0;
    (void)is_rf;
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
        if (is_rf) {
            ret = (((frame_control_t *)fc)->vf.rf_sof.dst_tei != 0xfff);
        } else {
            ret = (((frame_control_t *)fc)->vf.sof.dst_tei != 0xfff);
        }
        break;
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
        ret = (((spg_frame_control_t *)fc)->vf.sof.dst_tei != 0xfff);
        break;
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
        ret = (((hpav_frame_control *)fc)->vf_av.sof.dst_tei != 0xff);
        break;
#endif
    default:
        // todo
        IOT_ASSERT(0);
        break;
    }
    return ret;
}


uint32_t mac_get_nncco_protect_dur(uint32_t proto, void *fc)
{
    uint32_t ret = 0;
    switch (proto)
    {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
        ret = ((frame_control_t *)fc)->vf.nn_cco.duration;
        break;
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
        ret = ((spg_frame_control_t *)fc)->vf.nn_cco.conti_time;
        break;
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
        /* GP has no this feature */
        IOT_ASSERT(0);
        break;
#endif
    default:
        // todo
        break;
    }
    return ret;
}

uint8_t mac_get_nncco_self_ch_id(uint32_t proto, void *fc)
{
    uint8_t rf_channel;

#if HPLC_RF_SUPPORT
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        rf_channel =
            (uint8_t)((frame_control_t *)fc)->vf.nn_cco.self_rf_channel;
        break;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        rf_channel =
            (uint8_t)((spg_frame_control_t *)fc)->vf.nn_cco.self_rf_channel;
        break;
    }
#endif
    default:
        rf_channel = RF_CHANNEL_ID_INVALID;
        break;
    }
#else
    (void)proto;
    (void)fc;
    rf_channel = RF_CHANNEL_ID_INVALID;
#endif

    return rf_channel;
}

uint8_t mac_get_nncco_self_option(uint32_t proto, void *fc)
{
    uint8_t rf_option;

#if HPLC_RF_SUPPORT
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        rf_option = (uint8_t)((frame_control_t *)fc)->vf.nn_cco.self_rf_option;
        break;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        rf_option = ((spg_frame_control_t *)fc)->vf.nn_cco.self_rf_option;
        break;
    }
#endif
    default:
        rf_option = RF_OPTION_INVALID;
        break;
    }
#else
    (void)proto;
    (void)fc;
    rf_option = RF_OPTION_INVALID;
#endif

    return rf_option;
}

uint32_t mac_get_rx_delimiter_from_fc(uint32_t proto, void *fc)
{
    uint32_t deimiter = 0xFF;

    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
        deimiter = ((frame_control_t *)fc)->delimiter_type;
        break;
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
        deimiter = ((spg_frame_control_t *)fc)->delimiter_type;
        break;
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
        deimiter = ((hpav_frame_control *)fc)->delimiter_type;
        break;
#endif
    default:
        // todo
        break;
    }

    return deimiter;
}

uint32_t mac_get_nid_from_fc(uint32_t proto, void *fc)
{
    uint32_t nid = 0xFFFFFFFF;

    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
        nid = ((frame_control_t *)fc)->nid;
        break;
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
        nid = ((spg_frame_control_t *)fc)->snid;
        break;
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
        nid = ((hpav_frame_control *)fc)->snid;
        break;
#endif
    default:
        // todo
        break;
    }

    return nid;
}

void IRAM_ATTR mac_get_rx_frm_msg_from_fc(uint32_t proto,
                                    void *fc, rx_fc_msg_t *msg)
{
    uint8_t delimiter = (uint8_t)mac_get_delimi_from_fc(proto, fc);
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        /* nid share the same place for SG */
        frame_control_t *sg_fc = (frame_control_t *)fc;
        msg->nid = sg_fc->nid;
        msg->delimiter = delimiter;
        switch (delimiter) {
        case FC_DELIM_BEACON:
        {
            msg->tmi = sg_fc->vf.bcn.tmi;
            msg->fccs = sg_fc->vf.bcn.fccs;
            msg->src_tei = sg_fc->vf.bcn.src_tei;
            msg->time_stamp = sg_fc->vf.bcn.time_stamp;
            msg->phase = sg_fc->vf.bcn.phase_num;
            msg->pb_num = 1;
            msg->rf_mcs = (uint8_t)sg_fc->vf.rf_bcn.mcs;
            msg->rf_pb_sz_idx = (uint8_t)sg_fc->vf.rf_bcn.pb_sz_idx;
            msg->numsym = sg_fc->vf.bcn.sym_num;
            break;
        }
        case FC_DELIM_SOF:
        {
            msg->bcast = sg_fc->vf.sof.bcast;
            msg->src_tei = sg_fc->vf.sof.src_tei;
            msg->dst_tei = sg_fc->vf.sof.dst_tei;
            msg->tmi = sg_fc->vf.sof.tmi;
            msg->lid = sg_fc->vf.sof.lid;
            msg->retry = sg_fc->vf.sof.retry;
            msg->tmi_ext = sg_fc->vf.sof.tmi_ext;
            msg->fccs = sg_fc->vf.sof.fccs;
            msg->pb_num = (uint8_t)sg_fc->vf.sof.pb_num;
            msg->rf_mcs = (uint8_t)sg_fc->vf.rf_sof.mcs;
            msg->rf_pb_sz_idx = (uint8_t)sg_fc->vf.rf_sof.pb_sz_idx;
            msg->numsym = sg_fc->vf.sof.sym_num;
            break;
        }
        case FC_DELIM_NNCCO:
        {
            msg->pb_num = 0;
            msg->fccs = sg_fc->vf.nn_cco.fccs;
            break;
        }
        case FC_DELIM_SACK:
        {
            msg->dst_tei = sg_fc->vf.sack.dtei;
            msg->src_tei = sg_fc->vf.sack.stei;
            msg->snr_in_sack = (int8_t)sg_fc->vf.sack.snr;
            msg->bitmap_in_sack = sg_fc->vf.sack.rx_status;
            msg->load_in_sack = sg_fc->vf.sack.load;
            msg->result_in_sack = sg_fc->vf.sack.rx_result;
            msg->pb_num = (uint8_t)sg_fc->vf.sack.rx_pb;
            msg->sack_ext_deli = sg_fc->vf.sack.ext_deli;
            msg->time_stamp = sg_fc->vf.sync.time_stamp;
            msg->fccs = sg_fc->vf.sack.fccs;
            break;
        }
        case I1901_RTS_CTS:
        {
            i1901_frame_control_t *i1901_fc = (i1901_frame_control_t *)fc;
            msg->pb_num = 0;
            msg->dst_tei = i1901_fc->vf.rts_cts.dtei;
            msg->src_tei = i1901_fc->vf.rts_cts.stei;
            msg->rtsf = i1901_fc->vf.rts_cts.rtsf;
            break;
        }
        default:
            break;
        }
        break;
    }
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
    {
        hpav_frame_control *gp_fc = (hpav_frame_control *)fc;
        msg->nid = gp_fc->snid;
        switch (delimiter) {
        case DT_AV_BEACON:
        {
            msg->time_stamp = gp_fc->vf_av.bcn.bts;
            /* bcn pb size of GP has fixed 136 bytes */
            msg->tmi  = 2;
            break;
        }
        case DT_AV_SOF:
        {
            msg->src_tei = gp_fc->vf_av.sof.src_tei;
            msg->dst_tei = gp_fc->vf_av.sof.dst_tei;
            msg->tmi   = gp_fc->vf_av.sof.tmi_av;
            msg->lid   = gp_fc->vf_av.sof.lid;
            msg->fccs  = gp_fc->fccs_av.fccs_av0;
            msg->fccs |= gp_fc->fccs_av.fccs_av1 << 8;
            msg->fccs |= gp_fc->fccs_av.fccs_av2 << 16;
            msg->numsym = gp_fc->vf_av.sof.numsym;
            break;
        }
        case DT_AV_SACK:
        {
            break;
        }
        case DT_AV_RTS_CTS:
        {
            msg->src_tei = gp_fc->vf_av.rtscts.src_tei;
            msg->dst_tei = gp_fc->vf_av.rtscts.dst_tei;
            msg->lid   = gp_fc->vf_av.rtscts.lid;
            msg->rtsf = gp_fc->vf_av.rtscts.rtsf;
            break;
        }
        case DT_AV_SOUND:
        {
            msg->src_tei = gp_fc->vf_av.sound.stei;
            msg->dst_tei = gp_fc->vf_av.sound.dtei;
            msg->lid   = gp_fc->vf_av.sound.lid;
            msg->saf   = gp_fc->vf_av.sound.saf;
            break;
        }
        case DT_AV_RSOF:
        {
            break;
        }
        default:
            break;
        }
        break;
    }
#endif
#if SUPPORT_GREEN_PHY //Av SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_AV:
    {
        // TO BE DONE
        break;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        spg_frame_control_t *spg_fc = (spg_frame_control_t *)fc;
        msg->nid = spg_fc->snid;
        msg->delimiter = delimiter;
        switch (delimiter) {
        case FC_DELIM_BEACON:
        {
            uint8_t *fccs = spg_fc->vf.bcn.fccs;
            msg->tmi = spg_fc->vf.bcn.tmi;
            msg->fccs = fccs[0];
            msg->fccs |= fccs[1] << 8;
            msg->fccs |= fccs[2] << 16;
            msg->time_stamp = spg_fc->vf.bcn.time_stamp;
            msg->src_tei = spg_fc->vf.bcn.src_tei;
            msg->phase = spg_fc->vf.bcn.phase_num;
            msg->numsym = spg_fc->vf.bcn.sym_num;
            break;
        }
        case FC_DELIM_SOF:
        {
            msg->src_tei = spg_fc->vf.sof.src_tei;
            msg->dst_tei = spg_fc->vf.sof.dst_tei;
            msg->tmi = spg_fc->vf.sof.tmi;
            msg->lid = spg_fc->vf.sof.lid;
            msg->retry = spg_fc->vf.sof.retry;
            msg->tmi_ext = spg_fc->vf.sof.tmi_ext;
            msg->fccs = spg_fc->vf.sof.fccs;
            msg->pb_num = (uint8_t)spg_fc->vf.sof.pb_num;
            msg->numsym = spg_fc->vf.sof.sym_num;
            break;
        }
        case FC_DELIM_SACK:
        {
            msg->dst_tei = spg_fc->vf.sack.dtei;
            msg->bitmap_in_sack = spg_fc->vf.sack.rx_status;
            msg->result_in_sack = spg_fc->vf.sack.rx_result;
            msg->pb_num = (uint8_t)spg_fc->vf.sack.rx_pb;
            msg->sack_ext_deli = spg_fc->vf.sack.ext_deli;
            msg->time_stamp = spg_fc->vf.sync.time_stamp;
            msg->fccs = spg_fc->vf.sack.fccs;
            break;
        }
        case FC_DELIM_NNCCO:
        {
            msg->fccs = spg_fc->vf.nn_cco.fccs;
            break;
        }
        case FC_DELIM_SOUND:
        {
            break;
        }
        default:
            break;
        }
        break;
    }
#endif
    default:
        break;
    }

    return;
}

void mac_rf_get_rx_frm_msg_from_fc(uint32_t proto,
    void *fc, rx_fc_msg_t *msg)
{
    uint8_t delimiter = (uint8_t)mac_get_delimi_from_fc(proto, fc);

    msg->delimiter = delimiter;
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        /* nid share the same place for SG */
        frame_control_t *sg_fc = (frame_control_t *)fc;
        msg->nid = sg_fc->nid;
        switch (delimiter) {
        case FC_DELIM_BEACON:
        {
            msg->time_stamp = sg_fc->vf.rf_bcn.time_stamp;
            msg->src_tei = sg_fc->vf.rf_bcn.src_tei;
            msg->rf_mcs = (uint8_t)sg_fc->vf.rf_bcn.mcs;
            msg->rf_pb_sz_idx = (uint8_t)sg_fc->vf.rf_bcn.pb_sz_idx;
            msg->pb_num = 1;
            msg->fccs = sg_fc->vf.rf_bcn.fccs;
            break;
        }
        case FC_DELIM_SOF:
        {
            msg->src_tei = sg_fc->vf.rf_sof.src_tei;
            msg->dst_tei = sg_fc->vf.rf_sof.dst_tei;
            msg->lid = sg_fc->vf.rf_sof.lid;
            msg->rf_pb_sz_idx = (uint8_t)sg_fc->vf.rf_sof.pb_sz_idx;
            msg->bcast = sg_fc->vf.rf_sof.bcast;
            msg->retry = sg_fc->vf.rf_sof.retry;
            msg->rf_mcs = (uint8_t)sg_fc->vf.rf_sof.mcs;
            msg->pb_num = 1;
            msg->fccs = sg_fc->vf.rf_sof.fccs;
            break;
        }
        case FC_DELIM_SACK:
        {
            msg->result_in_sack = sg_fc->vf.rf_sack.rx_result;
            msg->src_tei = sg_fc->vf.rf_sack.stei;
            msg->dst_tei = sg_fc->vf.rf_sack.dtei;
            msg->snr_in_sack = (int8_t)sg_fc->vf.rf_sack.snr;
            msg->load_in_sack = sg_fc->vf.rf_sack.load;
            msg->sack_ext_deli = sg_fc->vf.rf_sack.ext_deli;
            msg->fccs = sg_fc->vf.rf_sack.fccs;
            break;
        }
        default:
            break;
        }
        break;
    }
#endif

#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        spg_frame_control_t *spg_fc = (spg_frame_control_t *)fc;
        msg->nid = spg_fc->snid;
        switch (delimiter) {
        case FC_DELIM_BEACON:
        {
            msg->time_stamp = spg_fc->vf.rf_bcn.time_stamp;
            msg->src_tei = spg_fc->vf.rf_bcn.src_tei;
            msg->rf_mcs = (uint8_t)spg_fc->vf.rf_bcn.mcs;
            msg->rf_pb_sz_idx = (uint8_t)spg_fc->vf.rf_bcn.pb_sz_idx;
            msg->pb_num = 1;
            msg->fccs = spg_fc->vf.rf_bcn.fccs[0];
            msg->fccs |= spg_fc->vf.rf_bcn.fccs[1] << 8;
            msg->fccs |= spg_fc->vf.rf_bcn.fccs[2] << 16;
            break;
        }
        case FC_DELIM_SOF:
        {
            msg->src_tei = spg_fc->vf.rf_sof.src_tei;
            msg->dst_tei = spg_fc->vf.rf_sof.dst_tei;
            msg->lid = spg_fc->vf.rf_sof.lid;
            msg->rf_pb_sz_idx = (uint8_t)spg_fc->vf.rf_sof.pb_sz_idx;
            msg->retry = spg_fc->vf.rf_sof.retry;
            msg->rf_mcs = (uint8_t)spg_fc->vf.rf_sof.mcs;
            msg->pb_num = 1;
            msg->fccs = spg_fc->vf.rf_sof.fccs;
            break;
        }
        case FC_DELIM_SACK:
        {
            msg->result_in_sack = spg_fc->vf.rf_sack.rx_result;
            msg->dst_tei = spg_fc->vf.rf_sack.dtei;
            msg->sack_ext_deli = spg_fc->vf.rf_sack.ext_deli;
            msg->fccs = spg_fc->vf.rf_sack.fccs[0];
            msg->fccs |= spg_fc->vf.rf_sack.fccs[1] << 8;
            msg->fccs |= spg_fc->vf.rf_sack.fccs[2] << 16;
            break;
        }
        default:
            break;
        }
        break;
    }
#endif
    default:
        (void)proto;
        (void)fc;
        (void)msg;
        break;
    }

    return;
}

void IRAM_ATTR mac_get_tx_msg_from_fc(uint32_t proto, uint32_t delimiter,
                                void *fc, tx_fc_msg_t *msg)
{
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        switch (delimiter) {
        case FC_DELIM_BEACON:
        {
            frame_control_t *sg_fc = (frame_control_t *)fc;
            msg->network_type = (uint8_t)sg_fc->network_type;
            msg->nid = sg_fc->nid;
            msg->tmi = (uint8_t)sg_fc->vf.bcn.tmi;
            msg->src_tei = (tei_t)sg_fc->vf.bcn.src_tei;
            msg->rf_mcs = (uint8_t)sg_fc->vf.rf_bcn.mcs;
            msg->rf_pb_sz_idx = (uint8_t)sg_fc->vf.rf_bcn.pb_sz_idx;
            break;
        }
        case FC_DELIM_SOF:
        {
            frame_control_t *sg_fc = (frame_control_t *)fc;
            msg->tmi = (uint8_t)sg_fc->vf.sof.tmi;
            msg->ext_tmi = (uint8_t)sg_fc->vf.sof.tmi_ext;
            msg->rf_mcs = (uint8_t)sg_fc->vf.rf_sof.mcs;
            msg->rf_pb_sz_idx = (uint8_t)sg_fc->vf.rf_sof.pb_sz_idx;
            break;
        }
        case FC_DELIM_NNCCO:
        {
            break;
        }
        case FC_DELIM_SOUND:
        {
            break;
        }
        default:
            break;
        }
        break;
    }
#endif

#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
    {
        switch (delimiter) {
        case DT_AV_BEACON:
        {
            hpav_frame_control *gp_fc = (hpav_frame_control *)fc;
            (void)gp_fc;
            break;
        }
        case DT_AV_SOF:
        {
            hpav_frame_control *gp_fc = (hpav_frame_control *)fc;
            msg->tmi = (uint8_t)gp_fc->vf_av.sof.tmi_av;
            break;
        }
        case DT_AV_SACK:
        {
            break;
        }
        case DT_AV_RTS_CTS:
        {
            break;
        }
        case DT_AV_SOUND:
        {
            break;
        }
        case DT_AV_RSOF:
        {
            break;
        }
        default:
            break;
        }
        break;
    }
#endif
#if SUPPORT_GREEN_PHY //Av use SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_AV:
    {
        // TO BE DONE
    }break;
#endif

#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        switch (delimiter) {
        case FC_DELIM_BEACON:
        {
            spg_frame_control_t *spg_fc = (spg_frame_control_t *)fc;
            msg->network_type = (uint8_t)spg_fc->access_ind;
            msg->nid = spg_fc->snid;
            msg->tmi = (uint8_t)spg_fc->vf.bcn.tmi;
            msg->src_tei = (tei_t)spg_fc->vf.bcn.src_tei;
            msg->bcn_period_cnt = spg_fc->vf.bcn.bcn_period_cnt;
            msg->rf_mcs = (uint8_t)spg_fc->vf.rf_bcn.mcs;
            msg->rf_pb_sz_idx = (uint8_t)spg_fc->vf.rf_bcn.pb_sz_idx;
            break;
        }
        case FC_DELIM_SOF:
        {
            spg_frame_control_t *spg_fc = (spg_frame_control_t *)fc;
            msg->tmi = (uint8_t)spg_fc->vf.sof.tmi;
            msg->ext_tmi = (uint8_t)spg_fc->vf.sof.tmi_ext;
            msg->rf_mcs = (uint8_t)spg_fc->vf.rf_sof.mcs;
            msg->rf_pb_sz_idx = (uint8_t)spg_fc->vf.rf_sof.pb_sz_idx;
            break;
        }
        case FC_DELIM_NNCCO:
        {
            break;
        }
        case FC_DELIM_SOUND:
        {
            break;
        }
        default:
            break;
        }
        break;
    }
#endif
    default:
        break;
    }

    return;
}

uint32_t IRAM_ATTR mac_get_delimi_from_fc(uint32_t proto, void *fc)
{
    uint32_t deimiter = 0xFF;

    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
#if SUPPORT_IEEE_1901
        i1901_frame_control_t *i1901_fc = (i1901_frame_control_t *)fc;
        deimiter = i1901_fc->delimiter_type;
#else
        frame_control_t *sg_fc = (frame_control_t *)fc;
        deimiter = sg_fc->delimiter_type;
#endif
        break;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        spg_frame_control_t *spg_fc = (spg_frame_control_t *)fc;
        deimiter = spg_fc->delimiter_type;
        break;
    }
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
    {
        hpav_frame_control *gp_fc = (hpav_frame_control *)fc;
        deimiter = gp_fc->delimiter_type;
        break;
    }
#endif
    default:
        // todo
        break;
    }

    return deimiter;
}

void mac_beacon_rx_fc_info_get(uint8_t proto, mac_rx_info_t *rx_info,
                                    rx_fc_msg_t *msg)
{
    IOT_ASSERT(msg);

    switch(proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        frame_control_t *fc = (frame_control_t *)rx_info->fc;
        msg->nid = fc->nid;
        if (rx_info->phy.is_rf) {
            msg->time_stamp = fc->vf.rf_bcn.time_stamp;
        } else {
            msg->time_stamp = fc->vf.bcn.time_stamp;
        }

        break;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        spg_frame_control_t *fc =
            (spg_frame_control_t *)rx_info->fc;
        msg->nid = fc->snid;
        msg->time_stamp = fc->vf.bcn.time_stamp;

        break;
    }
#endif
    default:
        break;
    }
}

uint8_t mac_get_mpdu_fc_len(uint32_t proto)
{
    uint8_t mpdu_fc_len = 0;

    switch (proto) {
#if (SUPPORT_SMART_GRID || SUPPORT_SOUTHERN_POWER_GRID || SUPPORT_GREEN_PHY)
    case PLC_PROTO_TYPE_SG:
    case PLC_PROTO_TYPE_SPG:
    case PLC_PROTO_TYPE_GP:
        mpdu_fc_len = PLC_MPDU_FC_LEN;
        break;
#endif
    default:
        // todo
        break;
    }

    return mpdu_fc_len;
}

uint8_t mac_get_mpdu_fccs_len(uint32_t proto)
{
    uint8_t mpdu_fccs_len = 0;

    switch (proto) {
#if (SUPPORT_SMART_GRID || SUPPORT_SOUTHERN_POWER_GRID || SUPPORT_GREEN_PHY)
    case PLC_PROTO_TYPE_SG:
    case PLC_PROTO_TYPE_SPG:
    case PLC_PROTO_TYPE_GP:
        mpdu_fccs_len = PLC_MPDU_FCCS_LEN;
        break;
#endif
    default:
        // todo
        break;
    }

    return mpdu_fccs_len;
}

uint8_t mac_get_pb_hdr_crc_len(uint32_t delimiter, uint32_t proto)
{
    uint8_t pb_hdr_crc_len = 0;

    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
        switch (delimiter) {
        case FC_DELIM_BEACON:
#if SUPPORT_IEEE_1901
            pb_hdr_crc_len = I1901_BCN_PB_HDR_CRC_LEN;
#else
            pb_hdr_crc_len = SG_BCN_PB_HDR_CRC_LEN;
#endif
            break;
        case FC_DELIM_SOF:
#if SUPPORT_IEEE_1901
            pb_hdr_crc_len = I1901_SOF_PB_HDR_CRC_LEN;
#else
            pb_hdr_crc_len = SG_SOF_PB_HDR_CRC_LEN;
#endif
            break;
        case FC_DELIM_NNCCO:
            pb_hdr_crc_len = 0;
            break;
        case FC_DELIM_SOUND:
            pb_hdr_crc_len = SG_SOF_PB_HDR_CRC_LEN;
            break;
        default:
            pb_hdr_crc_len = 0;
            break;
        }
        break;
#endif

#if SUPPORT_GREEN_PHY
        case PLC_PROTO_TYPE_GP:
            switch (delimiter) {
            case DT_AV_BEACON:
                pb_hdr_crc_len = GP_BCN_PB_HDR_CRC_LEN;
                break;
            case DT_AV_SOF:
                pb_hdr_crc_len = GP_SOF_PB_HDR_CRC_LEN;
                break;
            case DT_AV_SACK:
            case DT_AV_RTS_CTS:
                pb_hdr_crc_len = 0;
                break;
            case DT_AV_SOUND:
                pb_hdr_crc_len = GP_SOUND_PB_HDR_CRC_LEN;
                break;
            default:
                pb_hdr_crc_len = 0;
                break;
            }
            break;
#endif
#if SUPPORT_GREEN_PHY //Av SUPPORT_GREEN_PHY
        case PLC_PROTO_TYPE_AV:
        {
            // TO BE DONE
            break;
        }
#endif

#if SUPPORT_SOUTHERN_POWER_GRID
        case PLC_PROTO_TYPE_SPG:
        {
            switch (delimiter) {
            case FC_DELIM_BEACON:
                pb_hdr_crc_len = SPG_BCN_PB_HDR_CRC_LEN;
                break;
            case FC_DELIM_SOF:
                pb_hdr_crc_len = SPG_SOF_PB_HDR_CRC_LEN;
                break;
            case FC_DELIM_NNCCO:
                pb_hdr_crc_len = 0;
                break;
            case FC_DELIM_SOUND:
                pb_hdr_crc_len = SPG_SOF_PB_HDR_CRC_LEN;
                break;
            default:
                pb_hdr_crc_len = 0;
                break;
            }
            break;
        }
#endif
        default:
            break;
    }

    return pb_hdr_crc_len;
}

uint8_t mac_get_pb_hdr_resv_crc_len(uint32_t delimiter, uint32_t proto)
{
    uint8_t pb_hdr_resv_crc_len = 0;
    switch (proto) {
#if (SUPPORT_SMART_GRID || SUPPORT_GREEN_PHY)
    case PLC_PROTO_TYPE_SG:
    case PLC_PROTO_TYPE_GP:
    case PLC_PROTO_TYPE_AV:
        pb_hdr_resv_crc_len = mac_get_pb_hdr_crc_len(delimiter, proto);
        break;
#endif

#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
        switch (delimiter) {
        case FC_DELIM_BEACON:
            pb_hdr_resv_crc_len += SPG_BCN_PB_HDR_CRC_LEN + SPG_BCN_PB_RESV_LEN;
            break;
        case FC_DELIM_SOF:
            pb_hdr_resv_crc_len = SPG_SOF_PB_HDR_CRC_LEN + SPG_SOF_PB_RESV_LEN;
            break;
        case FC_DELIM_NNCCO:
            pb_hdr_resv_crc_len = 0;
            break;
        case FC_DELIM_SOUND:
            pb_hdr_resv_crc_len = SPG_SOF_PB_HDR_CRC_LEN + SPG_SOF_PB_RESV_LEN;
            break;
        default:
            pb_hdr_resv_crc_len = 0;
            break;
        }
        break;
#endif
    default:
        break;
    }

    return pb_hdr_resv_crc_len;
}
uint8_t mac_get_pb_pld_crc_len(uint32_t delimiter, uint32_t proto)
{
    uint8_t pb_pld_crc_len = 0;
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        switch (delimiter) {
        case FC_DELIM_BEACON:
#if SUPPORT_IEEE_1901
            pb_pld_crc_len = I1901_BCN_PB_PAYLOAD_CRC_LEN;
#else
            pb_pld_crc_len = SG_BCN_PB_PAYLOAD_CRC_LEN;
#endif
            break;
        case FC_DELIM_SOF:
            pb_pld_crc_len = 0;
            break;
        case FC_DELIM_NNCCO:
            pb_pld_crc_len = 0;
            break;
        case FC_DELIM_SOUND:
            pb_pld_crc_len = 0;
            break;
        default:
            pb_pld_crc_len = 0;
            break;
        }
        break;
    }
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
    {
        switch (delimiter) {
        case DT_AV_BEACON:
            pb_pld_crc_len = 0;
            break;
        case DT_AV_SOF:
            pb_pld_crc_len = 0;
            break;
        case DT_AV_SACK:
            pb_pld_crc_len = 0;
            break;
        case DT_AV_RTS_CTS:
            pb_pld_crc_len = 0;
            break;
        case DT_AV_SOUND:
            pb_pld_crc_len = 0;
            break;
        default:
            pb_pld_crc_len = 0;
            break;
        }
        break;
    }
#endif
#if SUPPORT_GREEN_PHY //Av SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_AV:
    {
        // TO BE DONE
        break;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        switch (delimiter) {
        case FC_DELIM_BEACON:
            pb_pld_crc_len = SPG_BCN_PB_PAYLOAD_CRC_LEN;
            break;
        case FC_DELIM_SOF:
            pb_pld_crc_len = 0;
            break;
        case FC_DELIM_NNCCO:
            pb_pld_crc_len = 0;
            break;
        case FC_DELIM_SOUND:
            pb_pld_crc_len = 0;
            break;
        default:
            pb_pld_crc_len = 0;
            break;
        }
        break;
    }
#endif
    default:
        break;
    }

    return pb_pld_crc_len;
}

uint8_t mac_get_pb_crc_len(uint32_t delimiter, uint32_t proto)
{
    uint8_t pb_pb_crc_len = 0;
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        switch (delimiter) {
        case FC_DELIM_BEACON:
#if SUPPORT_IEEE_1901
            pb_pb_crc_len = I1901_BCN_PB_CRC_LEN;
#else
            pb_pb_crc_len = SG_BCN_PB_CRC_LEN;
#endif
            break;
        case FC_DELIM_SOF:
#if SUPPORT_IEEE_1901
            pb_pb_crc_len = I1901_SOF_PB_CRC_LEN;
#else
            pb_pb_crc_len = SG_SOF_PB_CRC_LEN;
#endif
            break;
        case FC_DELIM_NNCCO:
            pb_pb_crc_len = 0;
            break;
        case FC_DELIM_SOUND:
            pb_pb_crc_len = SG_SOF_PB_CRC_LEN;
            break;
        default:
            pb_pb_crc_len = 0;
            break;
        }
        break;
    }
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
    {
        switch (delimiter) {
        case DT_AV_BEACON:
            pb_pb_crc_len = GP_BCN_PB_CRC_LEN;
            break;
        case DT_AV_SOF:
            pb_pb_crc_len = GP_SOF_PB_CRC_LEN;
            break;
        case DT_AV_SACK:
        case DT_AV_RTS_CTS:
            pb_pb_crc_len = 0;
            break;
        case DT_AV_SOUND:
            pb_pb_crc_len = GP_SOUND_PB_CRC_LEN;
            break;
        default:
            pb_pb_crc_len = 0;
            break;
        }
        break;
    }
#endif
#if SUPPORT_GREEN_PHY //Av use macor of SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_AV:
    {
        // TO BE DONE
        break;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        switch (delimiter) {
        case FC_DELIM_BEACON:
            pb_pb_crc_len = SPG_BCN_PB_CRC_LEN;
            break;
        case FC_DELIM_SOF:
            pb_pb_crc_len = SPG_SOF_PB_CRC_LEN;
            break;
        case FC_DELIM_NNCCO:
            pb_pb_crc_len = 0;
            break;
        case FC_DELIM_SOUND:
            pb_pb_crc_len = SPG_SOF_PB_CRC_LEN;
            break;
        default:
            pb_pb_crc_len = 0;
            break;
        }
        break;
    }
#endif
    default:
        break;
    }

    return pb_pb_crc_len;
}
uint8_t mac_get_pb_hdr_len(uint32_t delimiter, uint32_t proto)
{
    uint8_t pb_hdr_len = 0;
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        switch (delimiter) {
        case FC_DELIM_BEACON:
            pb_hdr_len = 0;
            break;
        case FC_DELIM_SOF:
#if SUPPORT_IEEE_1901
            pb_hdr_len = I1901_SOF_PB_HDR_LEN;
#else
            pb_hdr_len = SG_SOF_PB_HDR_LEN;
#endif
            break;
        default:
            pb_hdr_len = 0;
            break;
        }
        break;
    }
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
    {
        switch (delimiter) {
        case DT_AV_BEACON:
            pb_hdr_len = 0;
            break;
        case DT_AV_SOF:
            pb_hdr_len = GP_SOF_PB_HDR_LEN;
            break;
        case DT_AV_SACK:
        case DT_AV_RTS_CTS:
            pb_hdr_len = 0;
            break;
        case DT_AV_SOUND:
            pb_hdr_len = 0;
            break;
        default:
            break;
        }
        break;
    }
#endif
#if SUPPORT_GREEN_PHY //Av use macor of SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_AV:
    {
        // TO BE DONE
        break;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        switch (delimiter) {
        case FC_DELIM_BEACON:
            pb_hdr_len = 0;
            break;
        case FC_DELIM_SOF:
            pb_hdr_len = SPG_SOF_PB_HDR_LEN;
            break;
        default:
            pb_hdr_len = 0;
            break;
        }
        break;
    }
#endif
    default:
        break;
    }

    return pb_hdr_len;
}

uint32_t mac_get_sof_pb_valid_payload_sz(uint32_t proto, uint32_t pb_size)
{
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
#if SUPPORT_IEEE_1901
        if (!((72 == pb_size) || (136 == pb_size) || (520 == pb_size))) {
            /* invalid pb size */
            return 0;
        }
#else /* SUPPORT_IEEE_1901 */
        if (!((72 == pb_size) || (136 == pb_size)
            || (264 == pb_size) || (520 == pb_size))) {
            /* invalid pb size */
            return 0;
        }
#endif /* SUPPORT_IEEE_1901 */
        break;
#endif /* SUPPORT_SMART_GRID */

#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
        if (!((136 == pb_size) || (520 == pb_size))) {
            /* invalid pb size */
            return 0;
        }
        break;
#endif /* SUPPORT_SOUTHERN_POWER_GRID */

    default:
        return 0;
    }

    return (uint32_t)(pb_size - mac_get_pb_hdr_resv_crc_len(FC_DELIM_SOF,
        proto));
}

void IRAM_ATTR mac_get_nncco_info_from_fc(void *fc, nncco_fc_info_t *nn_fc_info)
{
    IOT_ASSERT(fc);
    uint32_t proto = PHY_PROTO_TYPE_GET();
    uint8_t delimiter = (uint8_t)mac_get_delimi_from_fc(proto, fc);
    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        /* nid share the same place for SG */
        frame_control_t *sg_fc = (frame_control_t *)fc;
        nn_fc_info->nid = sg_fc->nid;
        nn_fc_info->delimiter = delimiter;
        switch (delimiter) {
        case FC_DELIM_NNCCO:
        {
            nn_fc_info->receive_nid = sg_fc->vf.nn_cco.receive_nid;
            nn_fc_info->duration = sg_fc->vf.nn_cco.duration;
            nn_fc_info->sbandoffset = sg_fc->vf.nn_cco.sbandoffset;
            nn_fc_info->self_rf_channel =
                (uint8_t)sg_fc->vf.nn_cco.self_rf_channel;
            nn_fc_info->self_rf_option =
                (uint8_t)sg_fc->vf.nn_cco.self_rf_option;
            break;
        }
        default:
            IOT_ASSERT(0);
            break;
        }
        break;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        spg_frame_control_t *spg_fc = (spg_frame_control_t *)fc;
        nn_fc_info->nid = spg_fc->snid;
        nn_fc_info->delimiter = delimiter;
        switch (delimiter) {
        case FC_DELIM_NNCCO:
        {
            /* nncco info */
            nn_fc_info->receive_nid = spg_fc->vf.nn_cco.neighbor_network;
            nn_fc_info->duration = spg_fc->vf.nn_cco.conti_time;
            nn_fc_info->bwth_end_flag = spg_fc->vf.nn_cco.bwth_end_flag;
            nn_fc_info->bwth_end_shift = spg_fc->vf.nn_cco.bwth_end_shift;
            nn_fc_info->sbandoffset = spg_fc->vf.nn_cco.bwth_start_shift;
            nn_fc_info->self_rf_channel =
                spg_fc->vf.nn_cco.self_rf_channel;
            nn_fc_info->self_rf_option =
                spg_fc->vf.nn_cco.self_rf_option;
            break;
        }
        default:
            IOT_ASSERT(0);
            break;
        }
        break;
    }
#endif
    default:
        break;
    }
    (void)proto;
    (void)delimiter;
    return;
}

/* judge receive nid whether is mynid */
uint32_t mac_nncco_nid_compare(uint32_t nid_in_nncco, uint32_t nid_to_check)
{
    uint32_t proto = PHY_PROTO_TYPE_GET();
    if (PLC_PROTO_TYPE_SG == proto) {
        if (nid_in_nncco == nid_to_check) {
            return 1;
        }
    }
    else if (PLC_PROTO_TYPE_SPG  == proto) {
        if (nid_in_nncco & (1 << (nid_to_check - 1))) {
            return 1;
        }
    }
    return 0;
}

uint32_t mac_debug_nncco_info(void *fc, uint32_t ntb)
{
    uint32_t proto = PHY_PROTO_TYPE_GET();
#if HW_PLATFORM == HW_PLATFORM_SIMU

    nncco_fc_info_t nn_fc_info = { 0 };
    mac_get_nncco_sw_info_from_fc(fc, &nn_fc_info);

    if (PLC_PROTO_TYPE_SG == proto) {
        iot_printf("%s proto:%d, nid %lu dur %lu start_ntb %lu, nn nid %lu, "
            "local ntb %lu\n", __FUNCTION__, proto, nn_fc_info.nid,
            (uint32_t)nn_fc_info.sw_duration,
            nn_fc_info.start_ntb_l32,
            (uint32_t)nn_fc_info.sw_receive_nid, ntb);
    }
    else if (PLC_PROTO_TYPE_SPG == proto) {
        iot_printf("%s proto:%d, nid %lu, dur:%lu, start_ntb:%lu, "
            "last_ntb_offset:%lu, rece nid %lu, local ntb %lu\n",
            __FUNCTION__, proto, nn_fc_info.nid,
            (uint32_t)nn_fc_info.sw_duration,
            nn_fc_info.start_ntb_l32,
            nn_fc_info.last_offset,
            (uint32_t)nn_fc_info.sw_receive_nid, ntb);
    }
#else /* HW_PLATFORM == HW_PLATFORM_SIMU */

    nncco_fc_info_t nn_fc_info = { 0 };
    mac_get_nncco_info_from_fc(fc, &nn_fc_info);

#if SUPPORT_SMART_GRID
    if (PLC_PROTO_TYPE_SG == proto) {
        iot_printf("nncco p:%d, n:%lu, d:%lu, ef:%d, es:%d,"
            " so:%lu, nbm:%lu, ln:%lu\n",
            proto, nn_fc_info.nid,
            nn_fc_info.duration,
            nn_fc_info.sbandoffset,
            nn_fc_info.receive_nid, ntb);
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    if (PLC_PROTO_TYPE_SPG == proto) {
        iot_printf("nncco p:%d, n:%lu, d40:%lu, ef:%d, lo4:%lu, "
            "nsto4:%lu, nbm:%lu, ln %lu\n",
            proto, nn_fc_info.nid,
            nn_fc_info.duration,
            nn_fc_info.bwth_end_flag,
            nn_fc_info.bwth_end_shift,
            nn_fc_info.sbandoffset,
            nn_fc_info.receive_nid, ntb);
    }
#endif

#endif /* HW_PLATFORM == HW_PLATFORM_SIMU */
    (void)proto;
    return 0;
}

void IRAM_ATTR mac_set_bcn_st(void *fc, uint32_t ntb)
{
#if HW_PLATFORM != HW_PLATFORM_SIMU
    IOT_ASSERT(fc);
    uint32_t proto = PHY_PROTO_TYPE_GET();
#if SUPPORT_SMART_GRID
    frame_control_t *cur_fc_sg;
    if (PLC_PROTO_TYPE_SG == proto) {
        cur_fc_sg = (frame_control_t *)fc;
        cur_fc_sg->vf.bcn.time_stamp = ntb;
    }
#endif

#if SUPPORT_SOUTHERN_POWER_GRID
    spg_frame_control_t *cur_fc_spg;
    if (PLC_PROTO_TYPE_SPG  == proto) {
        cur_fc_spg = (spg_frame_control_t *)fc;
        cur_fc_spg->vf.bcn.time_stamp = ntb;
    }
#endif
    (void)proto;
#else
    (void)fc;
    (void)ntb;
#endif
    return;
}

void IRAM_ATTR mac_set_sync_st(void *fc, uint32_t ntb)
{
#if HW_PLATFORM != HW_PLATFORM_SIMU
    IOT_ASSERT(fc);
    uint32_t proto = PHY_PROTO_TYPE_GET();
#if SUPPORT_SMART_GRID
    if (PLC_PROTO_TYPE_SG == proto) {
        frame_control_t *cur_fc_sg = (frame_control_t *)fc;
        if (cur_fc_sg->vf.sync.ext_type == SACK_EXT_TYPE_SYNC) {
            cur_fc_sg->vf.sync.time_stamp = ntb;
        }
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    if (PLC_PROTO_TYPE_SPG == proto) {
        spg_frame_control_t *cur_fc_spg = (spg_frame_control_t *)fc;
        if (cur_fc_spg->vf.sync.ext_type == SACK_EXT_TYPE_SYNC) {
            cur_fc_spg->vf.sync.time_stamp = ntb;
        }
    }
#endif
#else
    (void)fc;
    (void)ntb;
#endif
    return;
}

uint32_t mac_get_sof_frame_len(uint32_t proto, void *fc)
{
    (void)fc;
    switch(proto)
    {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        frame_control_t *sg_fc = fc;
        return sg_fc->vf.sof.frame_len;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        spg_frame_control_t *spg_fc = fc;
        return spg_fc->vf.sof.frm_len;
    }
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_AV:
    case PLC_PROTO_TYPE_GP:
    {
        hpav_frame_control *av_fc = fc;
        return av_fc->vf_av.sof.fl_av;
    }
#endif
    default:
        IOT_ASSERT(0);
        return ERR_FAIL;
    }
}

uint32_t mac_get_sof_pbnum(uint32_t proto, void *fc)
{
    (void)fc;
    switch(proto)
    {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        frame_control_t *sg_fc = fc;
        return sg_fc->vf.sof.pb_num;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        spg_frame_control_t *spg_fc = fc;
        return spg_fc->vf.sof.pb_num;
    }
#endif
    default:
        IOT_ASSERT(0);
        return ERR_FAIL;
    }
}

uint32_t mac_mask_input_nid(uint32_t nid)
{
    /* TODO: sometimes, cvg not clear the higher part of nid
    * so we need to clean the higher part, remove the
    * following if cvg clean the higher part
    */
    uint32_t proto = PHY_PROTO_TYPE_GET();
    if (proto == PLC_PROTO_TYPE_SG) {
        /* 24 bit for SG */
        nid &= 0xffffff;
    }
    else if (proto == PLC_PROTO_TYPE_SPG) {
        /* 4 bit for SPG */
        nid &= 0xf;
    }
    else {
        IOT_ASSERT(0);
    }
    return nid;

}

uint32_t mac_get_bcn_st(uint32_t proto, void *fc)
{
    uint32_t st = 0x0;

    switch (proto) {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
        st = ((frame_control_t *)fc)->vf.bcn.time_stamp;
        break;
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
        st = ((spg_frame_control_t *)fc)->vf.bcn.time_stamp;
        break;
#endif
#if SUPPORT_GREEN_PHY
    case PLC_PROTO_TYPE_GP:
        st = ((hpav_frame_control *)fc)->vf_av.bcn.bts;
        break;
#endif
    default:
        // todo
        break;
    }

    return st;
}

uint32_t mac_get_fc_dtei(uint32_t proto, void *fc)
{
    (void)fc;
    switch(proto)
    {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        frame_control_t *sg_fc = fc;
        return sg_fc->vf.sof.dst_tei;
    }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        spg_frame_control_t *spg_fc = fc;
        return spg_fc->vf.sof.dst_tei;
    }
#endif
    default:
        IOT_ASSERT(0);
        return ERR_FAIL;
    }
}

uint32_t mac_get_unicast_sack_ts(void)
{
#if ENA_WAR_244
    return g_phy_cpu_share_ctxt.tx_unicast_sack_ts;
#else
    //TODO: add get sack ts code
    return 0;
#endif
}

void mac_fc_i1901_to_sg(uint32_t proto, void *fc)
{
#if (SUPPORT_SMART_GRID && SUPPORT_IEEE_1901)
    uint32_t tmi, tmi_ext;
    i1901_frame_control_t *fc_1901 = (i1901_frame_control_t *)fc;
    frame_control_t sg_fc = {0};

    if (PLC_PROTO_TYPE_SG != proto) {
        iot_printf("1901 to sg proto error %d\n", proto);
        return;
    }

    sg_fc.delimiter_type = fc_1901->delimiter_type;
    sg_fc.network_type = fc_1901->network_type;
    sg_fc.nid = fc_1901->nid;

    switch (fc_1901->delimiter_type) {
    case FC_DELIM_BEACON:
        phy_tmi_i1901_to_sg(fc_1901->vf.bcn.tmi, !I1901_IS_EXT_TMI_MODE,
            &tmi, &tmi_ext);
        sg_fc.vf.bcn.time_stamp = fc_1901->vf.bcn.time_stamp;
        sg_fc.vf.bcn.src_tei = fc_1901->vf.bcn.stei;
        sg_fc.vf.bcn.tmi = (uint16_t)tmi;
        sg_fc.vf.bcn.sym_num = fc_1901->vf.bcn.pss;
        sg_fc.vf.bcn.phase_num = fc_1901->vf.bcn.phase_num;
        sg_fc.vf.bcn.version = fc_1901->vf.bcn.version;
        sg_fc.vf.bcn.fccs = fc_1901->vf.bcn.fccs;
        break;

    case FC_DELIM_SOF:
        phy_tmi_i1901_to_sg(fc_1901->vf.sof.tmi, fc_1901->vf.sof.tmi_ext,
            &tmi, &tmi_ext);
        sg_fc.vf.sof.src_tei = fc_1901->vf.sof.stei;
        sg_fc.vf.sof.dst_tei = fc_1901->vf.sof.dtei;
        sg_fc.vf.sof.lid = fc_1901->vf.sof.lid;
        sg_fc.vf.sof.frame_len = fc_1901->vf.sof.frame_len;
        sg_fc.vf.sof.pb_num = fc_1901->vf.sof.pb_num;
        sg_fc.vf.sof.sym_num = fc_1901->vf.sof.pss;
        sg_fc.vf.sof.bcast = fc_1901->vf.sof.bcast;
        sg_fc.vf.sof.retry = fc_1901->vf.sof.retry;
        /* ieee1901: 0x00 cco managed NEKS, 0x03 MPDU unencryed */
        sg_fc.vf.sof.encry = !fc_1901->vf.sof.encry;
        sg_fc.vf.sof.tmi = (uint16_t)tmi;
        sg_fc.vf.sof.tmi_ext = tmi_ext;
        sg_fc.vf.sof.version = fc_1901->vf.sof.version;
        sg_fc.vf.sof.fccs = fc_1901->vf.sof.fccs;
        break;

    case FC_DELIM_SACK:
        if (fc_1901->vf.sack.rx_pb) {
            sg_fc.vf.sack.rx_result = !(((1 << fc_1901->vf.sack.rx_pb) - 1)
                & fc_1901->vf.sack.result);
        }
        sg_fc.vf.sack.rx_status = fc_1901->vf.sack.result;
        sg_fc.vf.sack.stei = fc_1901->vf.sack.stei;
        sg_fc.vf.sack.dtei = fc_1901->vf.sack.dtei;
        sg_fc.vf.sack.rx_pb = fc_1901->vf.sack.rx_pb;
        sg_fc.vf.sack.snr = fc_1901->vf.sack.snr;
        sg_fc.vf.sack.load = fc_1901->vf.sack.load;
        sg_fc.vf.sack.ext_deli = fc_1901->vf.sack.ext_deli;
        sg_fc.vf.sack.version = fc_1901->vf.sack.version;
        sg_fc.vf.sack.fccs = fc_1901->vf.sack.fccs;
        break;

    case FC_DELIM_NNCCO:
#if (HW_PLATFORM >= HW_PLATFORM_FPGA)
        /* sg unit: 1ms, ieee1901 unit: 40ms */
        sg_fc.vf.nn_cco.duration = fc_1901->vf.nn_cco.duration * 40;
        /* sg and ieee1901 unit: 1ms */
        sg_fc.vf.nn_cco.sbandoffset = fc_1901->vf.nn_cco.sbandoffset;
        sg_fc.vf.nn_cco.receive_nid = fc_1901->vf.nn_cco.receive_nid;
        sg_fc.vf.nn_cco.self_rf_channel = RF_CHANNEL_ID_INVALID;
        sg_fc.vf.nn_cco.self_rf_option = RF_OPTION_INVALID;
        sg_fc.vf.nn_cco.version = fc_1901->vf.nn_cco.version;
        sg_fc.vf.nn_cco.fccs = fc_1901->vf.nn_cco.fccs;
        break;
#else
        return;
#endif

    case I1901_RTS_CTS:
    default:
        return;
    }

    os_mem_cpy(fc_1901, &sg_fc, sizeof(sg_fc));
#else
    (void)proto;
    (void)fc;
#endif
}

void mac_fc_sg_to_i1901(uint32_t proto, void *fc)
{
#if (SUPPORT_SMART_GRID && SUPPORT_IEEE_1901)
    uint32_t tmi, tmi_ext;
    frame_control_t *sg_fc = (frame_control_t *)fc;
    i1901_frame_control_t fc_1901 = {0};

    if (PLC_PROTO_TYPE_SG != proto) {
        iot_printf("sg to 1901 proto error %d\n", proto);
        return;
    }

    fc_1901.delimiter_type = sg_fc->delimiter_type;
    fc_1901.network_type = sg_fc->network_type;
    fc_1901.nid = sg_fc->nid;

    switch (sg_fc->delimiter_type) {
    case FC_DELIM_BEACON:
        phy_tmi_sg_to_i1901(sg_fc->vf.bcn.tmi, !I1901_IS_EXT_TMI_MODE,
            &tmi, &tmi_ext);
        fc_1901.vf.bcn.time_stamp = sg_fc->vf.bcn.time_stamp;
        fc_1901.vf.bcn.stei = sg_fc->vf.bcn.src_tei;
        fc_1901.vf.bcn.tmi = (uint16_t)tmi;
        fc_1901.vf.bcn.pss = (uint16_t)phy_get_pss_id(proto, tmi, tmi_ext);
        fc_1901.vf.bcn.phase_num = sg_fc->vf.bcn.phase_num;
        fc_1901.vf.bcn.version = sg_fc->vf.bcn.version;
        fc_1901.vf.bcn.fccs = sg_fc->vf.bcn.fccs;
        break;

    case FC_DELIM_SOF:
        phy_tmi_sg_to_i1901(sg_fc->vf.sof.tmi, sg_fc->vf.sof.tmi_ext,
            &tmi, &tmi_ext);
        fc_1901.vf.sof.stei = sg_fc->vf.sof.src_tei;
        fc_1901.vf.sof.dtei = sg_fc->vf.sof.dst_tei;
        fc_1901.vf.sof.lid = sg_fc->vf.sof.lid;
        fc_1901.vf.sof.frame_len = sg_fc->vf.sof.frame_len;
        fc_1901.vf.sof.pb_num = sg_fc->vf.sof.pb_num;

        fc_1901.vf.sof.pss = (uint16_t)phy_get_pss_id(proto, tmi, tmi_ext);
        fc_1901.vf.sof.bcast = sg_fc->vf.sof.bcast;
        fc_1901.vf.sof.retry = sg_fc->vf.sof.retry;

        /* ieee1901: 0x00 cco managed NEKS, 0x03 MPDU unencryed */
        fc_1901.vf.sof.encry = sg_fc->vf.sof.encry ? 0x00 : 0x03;
        fc_1901.vf.sof.tmi = (uint16_t)tmi;
        fc_1901.vf.sof.tmi_ext = (uint16_t)tmi_ext;
        fc_1901.vf.sof.version = sg_fc->vf.sof.version;
        fc_1901.vf.sof.fccs = sg_fc->vf.sof.fccs;
        break;

    case FC_DELIM_SACK:
        fc_1901.vf.sack.result = sg_fc->vf.sack.rx_status;
        fc_1901.vf.sack.stei = sg_fc->vf.sack.stei;
        fc_1901.vf.sack.dtei = sg_fc->vf.sack.dtei;
        fc_1901.vf.sack.rx_pb = sg_fc->vf.sack.rx_pb;
        fc_1901.vf.sack.snr = sg_fc->vf.sack.snr;
        fc_1901.vf.sack.load = sg_fc->vf.sack.load;
        fc_1901.vf.sack.ext_deli = sg_fc->vf.sack.ext_deli;
        fc_1901.vf.sack.version = sg_fc->vf.sack.version;
        fc_1901.vf.sack.fccs = sg_fc->vf.sack.fccs;
        break;

    case FC_DELIM_NNCCO:
#if (HW_PLATFORM >= HW_PLATFORM_FPGA)
        /* sg unit: 1ms, ieee1901 unit: 40ms */
        fc_1901.vf.nn_cco.duration = sg_fc->vf.nn_cco.duration / 40;

        /* sg and ieee1901 unit: 1ms */
        fc_1901.vf.nn_cco.sbandoffset = sg_fc->vf.nn_cco.sbandoffset;
        fc_1901.vf.nn_cco.receive_nid = sg_fc->vf.nn_cco.receive_nid;
        fc_1901.vf.nn_cco.version = sg_fc->vf.nn_cco.version;
        fc_1901.vf.nn_cco.fccs = sg_fc->vf.nn_cco.fccs;
        break;
#else
        return;
#endif

    case I1901_RTS_CTS:
    default:
        return;
    }

    os_mem_cpy(sg_fc, &fc_1901, sizeof(fc_1901));
#else
    (void)proto;
    (void)fc;
#endif
}

#if (ENA_HW_SYNC_PPM_WAR || ENA_SW_SYNC_PPM_WAR)

int32_t IRAM_ATTR mac_get_clear_dbg_pkt_ppm_step(void *fc)
{
    int32_t ppm_step = 0;
    uint32_t proto = PHY_PROTO_TYPE_GET();
    uint32_t dbg_pkt_version = 0;

    if (phy_get_g_mt_mode_sel()) {
        return 0;
    }

#if SUPPORT_SMART_GRID
    if (proto == PLC_PROTO_TYPE_SG) {
        frame_control_t *sg_fc = (frame_control_t*)fc;
        if (FC_DELIM_BEACON == sg_fc->delimiter_type) {
            dbg_pkt_version = sg_fc->vf.bcn.version;
            ppm_step = (int8_t)sg_fc->vf.bcn.fccs;
            sg_fc->vf.bcn.fccs = 0;
            sg_fc->vf.bcn.version = SG_STANDARD_VERSION;
        } else if (FC_DELIM_SOF == sg_fc->delimiter_type) {
            dbg_pkt_version = sg_fc->vf.sof.version;
            ppm_step = (int8_t)sg_fc->vf.sof.fccs;
            sg_fc->vf.sof.fccs = 0;
            sg_fc->vf.sof.version = SG_STANDARD_VERSION;
        }
    } else
#endif /* SUPPORT_SMART_GRID */
#if SUPPORT_SOUTHERN_POWER_GRID
    if (proto == PLC_PROTO_TYPE_SPG) {
        spg_frame_control_t *spg_fc = (spg_frame_control_t*)fc;
        if (FC_DELIM_BEACON == spg_fc->delimiter_type) {
            dbg_pkt_version = spg_fc->vf.bcn.version;
            ppm_step = (int8_t)spg_fc->vf.bcn.fccs[0];
            spg_fc->vf.bcn.fccs[0] = 0;
            spg_fc->vf.bcn.version = SPG_STANDARD_VERSION;
        } else if (FC_DELIM_SOF == spg_fc->delimiter_type) {
            dbg_pkt_version = spg_fc->vf.bcn.version;
            ppm_step = (int8_t)spg_fc->vf.sof.fccs;
            spg_fc->vf.sof.fccs = 0;
            spg_fc->vf.sof.version = SPG_STANDARD_VERSION;
        }
    }
#endif /* SUPPORT_SOUTHERN_POWER_GRID */
    {
        (void)fc;
        (void)proto;
    }

    return (int32_t)((dbg_pkt_version == DBG_PKT_VERSION) ? ppm_step : 0);
}

void IRAM_ATTR mac_modify_dbg_pkt_tx_ppm(int32_t step)
{
    phy_ppm_status_ctxt_t *ppm_sts_ctxt = &g_phy_cpu_share_ctxt.ppm_status;
    BUILD_BUG_ON(PLC_NTB_PPM_SHIFT >= 4);
    ppm_sts_ctxt->ppm_status[0].ppm_err =
        (int16_t)((-g_phy_cpu_share_ctxt.phy_ppm_init << (PLC_NTB_PPM_SHIFT
        - PLC_REG_PPM_SHIFT)) + (step << PLC_NTB_PPM_SHIFT));
}

#endif /* (ENA_HW_SYNC_PPM_WAR || ENA_SW_SYNC_PPM_WAR) */