kunlun/plc/halmac/test/tx_test_lib.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 "tx_test_lib.h"
#include "mac_sys_reg.h"
#include "hw_reg_api.h"
#include "mac_tx_hw.h"
#include "iot_errno.h"
#include "iot_io.h"
#include "mac_pdev.h"
#include "iot_bitops.h"
#include "hw_phy_init.h"
#include "hw_tonemap.h"
#include "phy_chn.h"
#include "mac_crc.h"
#include "mpdu_header.h"
#include "mac_desc_engine.h"
#include "mac_rx_hw.h"
#include "mac_cert_test.h"
#include "tx_desc_reg_api.h"
#include "rf_tx_test_lib.h"

#if (IOT_FTM_SUPPORT || CPLC_IOT_CERT_SUPPORT)

#if HW_PLATFORM >= HW_PLATFORM_FPGA

uint32_t enq_time = 0;
uint8_t close_tx_print = 0;
uint8_t mac_ping_enable = 0;

uint32_t mac_sche_set_cfg(void *vdev, hw_sched_cmd_t *cmdlist,
    uint16_t cmd_num, uint32_t bcn_pd, uint32_t start_ntb)
{
    /* disable plc schedule */
    mac_sched_enable_bp(vdev, 0);
    /* config HW scheduler alert time */
    mac_sched_set_bp_ahead_alert(vdev, MAC_BP_AHEAD_ALERT_DUR);
    /*set cmd list and cmd num*/
    mac_sched_set_bp_cmd_list(vdev, cmdlist, cmd_num);
    /*set bcn period*/
    mac_sched_set_bp_dur(vdev, bcn_pd);

    /* set plc start ntb */
    mac_sched_set_bp_start_ntb(vdev, start_ntb);
    /* start plc */
    mac_sched_trigger_bp(vdev);
    mac_sched_enable_bp(vdev, 1);
    return 0;
}

//TODO:fill mac msdu header for test
bool_t mac_fill_msdu_frame(uint32_t proto, iot_pkt_t *buf, uint16_t data_len)
{
    uint16_t msdu_len = 0;

    IOT_ASSERT(buf);
    //TODO: no mac addr case
    switch (proto)
    {
#if SUPPORT_SMART_GRID
    case PLC_PROTO_TYPE_SG:
    {
        if (iot_pkt_data_len(buf) < (data_len + SG_MAC_MSDU_CRC_LEN))
        {
            return false;
        }
        mac_header_t *sg_mac = (mac_header_t *)iot_pkt_data(buf);
        if (sg_mac->mac_exist_flag) {
            msdu_len = data_len - MAC_HDR_LEN_WITH_ADDR;
        } else {
            msdu_len = data_len - MAC_HDR_LEN_NO_ADDR;
        }
        if (sg_mac->msdu_len != msdu_len)
        {
            iot_printf("warning: msdu len not match,fix from %d to %d\r\n", \
                sg_mac->msdu_len, msdu_len);
            sg_mac->msdu_len = msdu_len;
        }
        break;
    }
#endif

#if SUPPORT_SOUTHERN_POWER_GRID
    case PLC_PROTO_TYPE_SPG:
    {
        if (iot_pkt_data_len(buf) < (data_len + SPG_MAC_MSDU_CRC_LEN))
        {
            return false;
        }
        spg_mac_header_t *spg_mac = (spg_mac_header_t *)iot_pkt_data(buf);
        if (spg_mac->mac_hdr_type) {
            /* short msdu */
            msdu_len = data_len - MAC_SHORT_HDR_LEN_SPG;
        } else {
            /* long msdu */
            msdu_len = data_len - MAC_LONG_HDR_LEN_SPG;
        }
        if (spg_mac->msdu_len != msdu_len)
        {
            iot_printf("warning: msdu len not match,fix from %d to %d\r\n", \
                spg_mac->msdu_len, msdu_len);
            spg_mac->msdu_len = msdu_len;
        }
        break;
    }
#endif

#if SUPPORT_GREEN_PHY
        case PLC_PROTO_TYPE_GP:
        {
            if (iot_pkt_data_len(buf) < (data_len + GP_MAC_MSDU_CRC_LEN))
            {
                return false;
            }
            gp_mac_header_t *gp_mac = (gp_mac_header_t *)iot_pkt_data(buf);
            msdu_len = data_len - sizeof(*gp_mac);
            if (gp_mac->mfl != msdu_len)
            {
                iot_printf("warning: msdu len not match,fix from %d to %d\r\n", \
                    gp_mac->mfl, msdu_len);
                gp_mac->mfl = msdu_len;
            }
            break;
        }
#endif

    default:
        return false;
    }
    return true;
}

iot_pkt_t *ftm_fill_mac_data(uint8_t delimier_type,
    uint16_t buf_len, uint8_t *pkt, uint16_t pkt_len)
{
    iot_pkt_t *buf;
    IOT_PKT_GET(buf, buf_len, 0, PLC_MAC_TX_MID);
    IOT_ASSERT(buf);
    if (pkt_len > buf_len) {
        iot_printf("waring drop some data, pb len:%d, data len:%d\n",
            buf_len, pkt_len);
        pkt_len = buf_len;
    }
    uint8_t *tmp = iot_pkt_put(buf, buf_len);
    switch (delimier_type){
    case FC_DELIM_BEACON:
    {
        IOT_ASSERT(pkt);
        os_mem_cpy(tmp, pkt, pkt_len);
        os_mem_set((tmp+pkt_len), 0, buf_len-pkt_len);
        break;
    }
    case FC_DELIM_SOF:
    {
        IOT_ASSERT(pkt);
        os_mem_cpy(tmp, pkt, pkt_len);
        os_mem_set((tmp+pkt_len), 0, buf_len-pkt_len);
        break;
    }
    case FC_DELIM_NNCCO:
        (void)pkt;
        (void)pkt_len;
        os_mem_set(tmp, 0x55, buf_len);
        break;
    case FC_DELIM_SOUND:
        IOT_ASSERT(pkt);
        os_mem_cpy(tmp, pkt, pkt_len);
        os_mem_set((tmp+pkt_len), 0, buf_len-pkt_len);
        break;
    default:
        iot_printf("other frame\n");
        break;
    }
    return buf;
}

void mpdu_tx_beacon_test(uint32_t proto, mac_queue_ctxt_t *tx_ctxt, uint8_t qid,\
       uint8_t bcast, uint8_t delimiter_type, uint32_t nid,\
       uint32_t dtei, uint32_t stei, uint8_t tmi, uint8_t ext_tmi,\
       uint8_t lid, uint8_t need_encry, tx_mpdu_end *mpdu_end,\
       uint16_t pkt_len, uint8_t *pkt, uint8_t phase, uint32_t band_sel)
{
    tx_mpdu_start *mpdu;
    tx_pb_start *pb;
    uint32_t pb_sz;
    uint32_t pb_mod;
    uint32_t rate_mode = 0;
    uint8_t pb_hdr_resv_crc_len;
    uint32_t network = (PLC_PROTO_TYPE_SPG == proto)? 1:0;
    uint8_t ppdu_mode = (PLC_PROTO_TYPE_GP == proto)? \
        HW_DESC_PPDU_MODE_AVONLY_1FCSYM:0;

    mac_desc_get(&g_mac_desc_eng,PLC_TX_MPDU_START_POOL, (void**)&mpdu);
    mac_desc_get(&g_mac_desc_eng,PLC_TX_PB_START_POOL, (void**)&pb);
    IOT_ASSERT(mpdu && pb);

    phy_get_pb_size(proto, tmi, ext_tmi, &pb_sz);
    phy_get_pb_mod(proto, tmi, ext_tmi, &pb_mod);

    /* get pb header + crc length */
    pb_hdr_resv_crc_len = mac_get_pb_hdr_resv_crc_len(FC_DELIM_BEACON, \
                                        proto);
    iot_pkt_t *test_data = \
        ftm_fill_mac_data(delimiter_type, (pb_sz - pb_hdr_resv_crc_len), \
        pkt, pkt_len);


    mac_crc_set_bcn_swcrc(proto,iot_pkt_data(test_data), pb_sz);
    mac_tx_mpdu_fill_pb_start(pb, NULL, iot_pkt_data(test_data), 0, 1, 1, proto);
    mac_crc_set_pb_swcrc(proto, pb, FC_DELIM_BEACON, pb_sz);

    mac_tx_mpdu_fill_macinfo(mpdu, qid, 1, need_encry, 0, \
            phy_get_sym_per_pb(proto, 0, tmi, ext_tmi,
            phy_get_pss_id(proto, tmi, ext_tmi)),\
            phy_get_fl_per_pb(proto, 0, tmi, ext_tmi), 0,\
            pb_hdr_resv_crc_len, 0, 1, 1, mpdu_end, pb, NULL, 0, \
            (uint32_t)(iot_pkt_data(test_data) - (uint8_t*)test_data), \
            0, 0, 0, 0, 0);
    mac_tx_mpdu_fill_phyinfo(mpdu, HW_DESC_TX_PORT_PLC, \
        128, phase, phy_def_hw_band_id_get(), \
        ppdu_mode, 0, pb_mod, rate_mode);
    mac_tx_mpdu_fill_fcinfo(mpdu, proto, \
        1, phase, delimiter_type, network, nid, 0, \
        tmi, ext_tmi, dtei, stei, lid, bcast, 0, 0, 0, 0, NULL);
    mac_crc_set_fc_swcrc(proto, mpdu);

    {
        /* get tx fc message */
        tx_fc_msg_t msg = {0};
        void *fc = mac_tx_mpdu_start_get_fc_ptr(mpdu);
        mac_get_tx_msg_from_fc(proto, delimiter_type, fc, &msg);
        iot_printf("proto = %d,""hwq = %d,"\
                   "beacon tx:tmi = %d,"\
                   "pb_num = %d\n", \
                   proto, qid, msg.tmi, 1);
    }
    /* send */
    mac_tx_hw_mpdu(tx_ctxt, qid, mpdu);
}

void mpdu_tx_sof_test(uint32_t proto, mac_queue_ctxt_t *tx_ctxt, uint8_t qid,\
       uint8_t bcast, uint8_t delimiter_type,uint32_t nid, uint32_t dtei,\
       uint32_t stei,uint8_t tmi, uint8_t ext_tmi, uint8_t lid,\
       uint8_t pb_num,uint8_t need_ack, uint8_t need_encry,\
       uint8_t need_decrypt, uint32_t avln_idx_in_desc,\
       uint32_t key_table_idx_in_desc, uint32_t key_idx_in_desc,\
       uint8_t hw_retry_cnt, tx_mpdu_end *mpdu_end, uint16_t pkt_len, \
       uint8_t *pkt, uint8_t phase, uint32_t band_sel, \
       uint8_t rawdata_mode, uint8_t *fc_rawdata)
{
    tx_mpdu_start *mpdu;
    tx_pb_start *pb;
    uint32_t pb_sz;
    uint32_t bitmap;
    uint32_t pb_mod;
    uint32_t rate_mode = 0;
    uint32_t network = (PLC_PROTO_TYPE_SPG == proto)? 1:0;
    uint8_t ppdu_mode = (PLC_PROTO_TYPE_GP == proto)? \
        HW_DESC_PPDU_MODE_AVONLY_1FCSYM:0;

    phy_get_pb_size(proto, tmi, ext_tmi,&pb_sz);
    phy_get_pb_mod(proto, tmi, ext_tmi, &pb_mod);

    /* get header + crc length */
    uint8_t pb_hdr_resv_crc_len = mac_get_pb_hdr_resv_crc_len(delimiter_type, proto);

    iot_pkt_t *test_data = \
        ftm_fill_mac_data(delimiter_type, \
            ((pb_sz - pb_hdr_resv_crc_len) * pb_num), pkt, pkt_len);

    bitmap = 0xffffffff >> (32 - pb_num);

    if(!rawdata_mode)
    {
        mac_fill_msdu_frame(proto, test_data, pkt_len);
        mac_crc_set_msdu_swcrc(proto, test_data);
    }

    mac_desc_get(&g_mac_desc_eng,PLC_TX_MPDU_START_POOL, (void**)&mpdu);
    IOT_ASSERT(mpdu);
    mac_tx_mpdu_form_pb_list(&pb, test_data, pb_num, bitmap, pb_sz, proto);

    if(rawdata_mode)
    {
        /* if raw data mode, sw fill pb header and pb crc */
#if CPLC_IOT_CERT_SUPPORT
        fill_pb_hdr_crc_rawdata(pb, g_mt_ctxt->pb_header, g_mt_ctxt->pb_crc);
#endif
    }

    mac_tx_mpdu_fill_macinfo(mpdu, qid, pb_num, need_encry, need_ack,\
        phy_get_sym_per_pb(proto, phy_def_hw_band_id_get(), tmi, ext_tmi,
            phy_get_pss_id(proto, tmi, ext_tmi)),\
        phy_get_fl_per_pb(proto, \
            phy_def_hw_band_id_get(), tmi, ext_tmi), 0,\
        pb_hdr_resv_crc_len, hw_retry_cnt, 1, 1, mpdu_end, pb, NULL, 0, \
        (uint32_t)(iot_pkt_data(test_data) - (uint8_t*)test_data), 0, \
        avln_idx_in_desc, key_table_idx_in_desc, key_idx_in_desc, 0);
    mac_tx_mpdu_fill_phyinfo(mpdu, HW_DESC_TX_PORT_PLC, \
        128, phase, phy_def_hw_band_id_get(), \
        ppdu_mode, 0, pb_mod, rate_mode);

    uint8_t proto_org = 0;
    if(rawdata_mode)
    {
        /* if raw data mode, save original proto */
        proto_org = proto;
        proto = PLC_PROTO_TYPE_RAWDATA;
    }
    mac_tx_mpdu_fill_fcinfo(mpdu, proto, \
        pb_num, phase, delimiter_type, network, nid, 0,\
        tmi, ext_tmi, dtei, stei, lid, bcast, 0,need_encry,\
        key_table_idx_in_desc ,key_idx_in_desc, fc_rawdata);

    void *fcv = mac_tx_mpdu_start_get_fc_ptr(mpdu);

    if(rawdata_mode)
    {
        proto = proto_org;
    }
    if(!need_decrypt)
    {
        switch (proto) {
#if SUPPORT_SMART_GRID
        case PLC_PROTO_TYPE_SG:
        {
            frame_control_t *fc = \
                (frame_control_t *)fcv;
            fc->vf.sof.decrypt_mode = 0;
            break;
        }
#endif
#if SUPPORT_SOUTHERN_POWER_GRID
        case PLC_PROTO_TYPE_SPG:
        {
            spg_frame_control_t *fc = \
                (spg_frame_control_t *)fcv;
            fc->vf.sof.decrypt_mode = 0;
            break;
        }
#endif
#if SUPPORT_GREEN_PHY
        case PLC_PROTO_TYPE_GP:
        {
            hpav_frame_control *fc = (hpav_frame_control *)fcv;
            fc->vf_av.sof.eks = 0x0f;
            break;
        }
#endif
        default:
            IOT_ASSERT(0);
        }
    }

    mac_crc_set_fc_swcrc(proto, mpdu);
    if(rawdata_mode)
    {
        /* if rawdata mode, copy fcs and don't use hw fcs */
#if SUPPORT_SMART_GRID
        frame_control_t *fc = (frame_control_t *) fcv;
        frame_control_t *fc_rawdata_p = (frame_control_t *) fc_rawdata;
        fc->vf.sof.fccs = fc_rawdata_p->vf.sof.fccs;
#elif SUPPORT_SOUTHERN_POWER_GRID
        spg_frame_control_t *fc = (spg_frame_control_t*)fcv;
        spg_frame_control_t *fc_rawdata_p = (spg_frame_control_t *) fc_rawdata;
        fc->vf.sof.fccs = fc_rawdata_p->vf.sof.fccs;
#endif
    }
    if(!close_tx_print)
    {
        tx_fc_msg_t msg = {0};
        mac_get_tx_msg_from_fc(proto, delimiter_type, fcv, &msg);

        {
            iot_printf("proto = %d," \
                       "hwq = %d," \
                       "sof tx:tmi = %d," \
                       "sof tx:ext_tmi = %d," \
                       "pb_num = %d\n", \
                       proto, qid, tmi, ext_tmi, pb_num);
        }
    }
    /* send */
    mac_tx_hw_mpdu(tx_ctxt, qid, mpdu);
}

uint32_t mac_tx_mpdu_fill_ack_fcinfo(tx_mpdu_start *mpdu_start,\
    uint32_t proto, uint32_t delimter, uint32_t network, uint32_t nid,\
    uint32_t rx_result, uint32_t rx_status, \
    uint32_t stei, uint32_t dtei, uint32_t rx_pb, uint32_t snr, \
    uint32_t load, uint32_t ext_deli)
{
    IOT_ASSERT(mpdu_start);
    mpdu_start->proto_type = proto;
#if SUPPORT_SMART_GRID
    frame_control_t *fc =  (frame_control_t *)mac_tx_mpdu_start_get_fc_ptr(mpdu_start);
    fc->delimiter_type = delimter;
    fc->network_type = network;
    fc->nid = nid;
    fc->vf.sack.rx_result = rx_result;
    fc->vf.sack.rx_status = rx_status;
    fc->vf.sack.stei = stei;
    fc->vf.sack.dtei = dtei;
    fc->vf.sack.rx_pb = rx_pb;
    fc->vf.sack.resv0 = 0;
    fc->vf.sack.snr = snr;
    fc->vf.sack.load = load;
    fc->vf.sack.resv1 = 0;
    fc->vf.sack.ext_deli = ext_deli;
    fc->vf.sack.version = 0;
#else
    IOT_ASSERT(0);
#endif
    return 0;
}

void mpdu_tx_ack_test(uint32_t proto, mac_queue_ctxt_t *tx_ctxt,\
       uint8_t qid, tx_mpdu_end *mpdu_end, uint32_t band_sel, \
       uint8_t rawdata_mode, uint8_t *fc_rawdata, uint8_t phase,\
       uint8_t delimiter_type, uint32_t nid,
       uint32_t rx_result, uint32_t rx_status, uint32_t stei, \
       uint32_t dtei, uint32_t rx_pb, uint32_t snr, uint32_t load, \
       uint32_t ext_deli)
{
    tx_mpdu_start *mpdu;
    uint32_t network = (PLC_PROTO_TYPE_SPG == proto)? 1:0;
    uint8_t ppdu_mode = (PLC_PROTO_TYPE_GP == proto)? \
        HW_DESC_PPDU_MODE_AVONLY_1FCSYM:0;

    mac_desc_get(&g_mac_desc_eng,PLC_TX_MPDU_START_POOL, (void**)&mpdu);
    IOT_ASSERT(mpdu);

    mac_tx_mpdu_fill_macinfo(mpdu, qid, 0, 0, 0,\
        0, 0, 0, 0, 0, 1, 1, mpdu_end, NULL, NULL, 0, \
        0, 0, 0, 0, 0, 0);
    mac_tx_mpdu_fill_phyinfo(mpdu, HW_DESC_TX_PORT_PLC, \
        128, phase, phy_def_hw_band_id_get(), ppdu_mode, 0, 1, 0);

    uint8_t proto_tmp = 0;
    if(rawdata_mode)  //if mtmode goto rawdata mode
    {
        proto_tmp = proto;
        proto = PLC_PROTO_TYPE_RAWDATA;
    }
    mac_tx_mpdu_fill_ack_fcinfo(mpdu, proto, delimiter_type, network, nid,\
    rx_result, rx_status, stei, dtei, rx_pb, snr, load, ext_deli);
    if(rawdata_mode)
    {
        proto = proto_tmp;
    }

    mac_crc_set_fc_swcrc(proto, mpdu);

    {
        iot_printf("hwq = %d ack tx_done\n",qid);
    }
    /* send */
    mac_tx_hw_mpdu(tx_ctxt, qid, mpdu);

}
void mpdu_tx_nncco_or_rtscts_test(uint32_t proto, mac_queue_ctxt_t *tx_ctxt,
       uint8_t qid, uint8_t bcast, uint8_t delimiter_type,uint32_t nid,
       uint32_t dtei, uint32_t stei,uint8_t lid,uint8_t need_encry,
       tx_mpdu_end *mpdu_end)
{
    tx_mpdu_start *mpdu;
    uint32_t network = (PLC_PROTO_TYPE_SPG == proto)? 1:0;
    uint8_t ppdu_mode = (PLC_PROTO_TYPE_GP == proto)?
        HW_DESC_PPDU_MODE_AVONLY_1FCSYM:0;

    mac_desc_get(&g_mac_desc_eng,PLC_TX_MPDU_START_POOL, (void**)&mpdu);
    IOT_ASSERT(mpdu);

    mac_tx_mpdu_fill_macinfo(mpdu, qid, 0, 0, 0,
        0, 0, 0, 0, 0, 1, 1, mpdu_end, NULL, NULL, 0,
        0, 0, 0, 0, 0, 0);
    mac_tx_mpdu_fill_phyinfo(mpdu, HW_DESC_TX_PORT_PLC,
        128, HW_DESC_TX_PHASE_ALL, 0, ppdu_mode, 0, 1, 0);
    mac_tx_mpdu_fill_fcinfo(mpdu, proto,
        0, HW_DESC_TX_PHASE_ALL, delimiter_type, network, nid, 0,
        0, 0, dtei, stei, lid, bcast, 0, 0, 0, 0, NULL);
    mac_crc_set_fc_swcrc(proto, mpdu);

    iot_printf("hwq = %d deli:%d tx_done\n", qid, delimiter_type);

    /* send */
    mac_tx_hw_mpdu(tx_ctxt, qid, mpdu);
}

void mpdu_tx_sound_test(uint32_t proto, mac_queue_ctxt_t *tx_ctxt, uint8_t qid,\
       uint8_t bcast, uint8_t delimiter_type,uint32_t nid,\
       uint32_t dtei, uint32_t stei,uint8_t tmi, uint8_t ext_tmi,\
       uint8_t lid,uint8_t need_ack, uint8_t need_encry,\
       uint8_t hw_retry_cnt, tx_mpdu_end *mpdu_end,\
       uint16_t pkt_len, uint8_t *pkt)
{
    tx_mpdu_start *mpdu;
    tx_pb_start *pb;
    uint32_t pb_sz;
    uint32_t pb_mod;
    uint32_t rate_mode = 0;
    uint8_t ppdu_mode = (PLC_PROTO_TYPE_GP == proto)? \
        HW_DESC_PPDU_MODE_AVONLY_1FCSYM:0;
    if(proto == PLC_PROTO_TYPE_SPG)
    {
        iot_printf("NW do not supprot sound!");
        return;
    }

    phy_get_pb_size(proto, tmi, ext_tmi, &pb_sz);
    phy_get_pb_mod(proto, tmi, ext_tmi, &pb_mod);

    uint8_t pb_hdr_resv_crc_len = mac_get_pb_hdr_resv_crc_len(delimiter_type, proto);

    iot_pkt_t *test_data = \
        ftm_fill_mac_data(delimiter_type, (pb_sz - pb_hdr_resv_crc_len), \
        pkt, pkt_len);


    mac_desc_get(&g_mac_desc_eng,PLC_TX_PB_START_POOL, (void**)&pb);
    mac_desc_get(&g_mac_desc_eng,PLC_TX_MPDU_START_POOL, (void**)&mpdu);
    IOT_ASSERT(mpdu && pb);

    mac_tx_mpdu_fill_pb_start(pb, NULL, iot_pkt_data(test_data), 0, 1, 1, proto);

    mac_tx_mpdu_fill_macinfo(mpdu, qid, 1, 0, need_ack,\
        phy_get_sym_per_pb(proto, 0, tmi, ext_tmi,
        phy_get_pss_id(proto, tmi, ext_tmi)),\
        phy_get_fl_per_pb(proto, 0, tmi, ext_tmi), 0,\
        pb_hdr_resv_crc_len, 0, 1, 1, mpdu_end, pb, NULL, 0, \
        (uint32_t)(iot_pkt_data(test_data) - (uint8_t*)test_data), 0, 0, 0, 0, 0);

    mac_tx_mpdu_fill_phyinfo(mpdu, HW_DESC_TX_PORT_PLC, \
        128, HW_DESC_TX_PHASE_ALL, 0, ppdu_mode, 0, pb_mod, rate_mode);
    mac_tx_mpdu_fill_fcinfo(mpdu, proto, \
        1, HW_DESC_TX_PHASE_ALL, delimiter_type, 0, nid, 0,\
        tmi, ext_tmi, dtei, stei, lid, bcast, 0, 0, 0, 0, NULL);
    mac_crc_set_fc_swcrc(proto, mpdu);

    {
        tx_fc_msg_t msg = {0};
        void *fc = mac_tx_mpdu_start_get_fc_ptr(mpdu);
        mac_get_tx_msg_from_fc(proto, delimiter_type, fc, &msg);

        {
            iot_printf("proto = %d," \
                       "hwq = %d," \
                       "sof tx:tmi = %d," \
                       "sof tx:ext_tmi = %d," \
                       "pb_num = %d\n", \
                       proto, qid, msg.tmi, msg.ext_tmi, 1);
        }
    }
    /* send */
    mac_tx_hw_mpdu(tx_ctxt, qid, mpdu);
}

void mpdu_send_test(mac_queue_ctxt_t *tx_ctxt, uint8_t qid,
       uint8_t bcast, uint8_t delimiter_type,uint32_t nid,
       uint32_t dtei, uint32_t stei,uint8_t tmi, uint8_t ext_tmi,
       uint8_t lid, uint8_t pb_num, uint8_t need_ack,
       uint8_t need_encry, uint8_t need_decrypt,
       uint32_t avln_idx_in_desc, uint32_t key_table_idx_in_desc,
       uint32_t key_idx_in_desc,
       uint8_t hw_retry_cnt, uint16_t pkt_len, uint8_t *pkt, uint8_t phase,
       uint32_t band_sel, uint8_t rawdata_mode, uint8_t *fc_rawdata)
{
    tx_mpdu_end *end;
    /* mac protocol */
    uint32_t proto = PHY_PROTO_TYPE_GET();

    mac_desc_get(&g_mac_desc_eng, PLC_TX_MPDU_END_POOL, (void**)&end);
    IOT_ASSERT(end);
    end->tx_done = 0;
    end->tx_ok = 0;
    (proto != PLC_PROTO_TYPE_GP)? (bcast = bcast):
        (bcast = 0);

    switch(delimiter_type){
    case FC_DELIM_BEACON:
    {
        (void)pb_num;
        (void)need_ack;
        (void)need_decrypt;
        (void)hw_retry_cnt;
        (void)avln_idx_in_desc;
        (void)key_table_idx_in_desc;
        (void)key_idx_in_desc;
        mpdu_tx_beacon_test(proto,tx_ctxt, qid, bcast, FC_DELIM_BEACON, nid,
            dtei,  stei, tmi, ext_tmi,lid, need_encry, end, pkt_len, pkt, phase,
            band_sel);
        break;
    }
    case FC_DELIM_SOF:
    {
        mpdu_tx_sof_test(proto, tx_ctxt, qid, bcast, FC_DELIM_SOF, nid,
            dtei, stei, tmi, ext_tmi,lid, pb_num, need_ack, need_encry,
            need_decrypt, avln_idx_in_desc, key_table_idx_in_desc,
            key_idx_in_desc, hw_retry_cnt, end, pkt_len, pkt, phase,
            band_sel, rawdata_mode, fc_rawdata);
        break;
    }
    case FC_DELIM_SACK:
    {
        mpdu_tx_ack_test(proto, tx_ctxt, qid, end, band_sel,
            rawdata_mode, fc_rawdata, phase, FC_DELIM_SACK, nid,
            0, 1, 1, 0xfff, 1, 0xff, 0, 0);
        break;
    }
    case FC_DELIM_NNCCO:
    {
        (void)tmi;
        (void)ext_tmi;
        (void)pb_num;
        (void)need_ack;
        (void)need_decrypt;
        (void)hw_retry_cnt;
        (void)avln_idx_in_desc;
        (void)key_table_idx_in_desc;
        (void)key_idx_in_desc;
        (void)pkt;
        (void)pkt_len;
        (void)band_sel;
        mpdu_tx_nncco_or_rtscts_test(proto, tx_ctxt, qid, bcast,
            FC_DELIM_NNCCO, nid, dtei, stei, lid, need_encry, end);
        break;
    }
    case I1901_RTS_CTS:
    {
        (void)pb_num;
        (void)need_encry;
        (void)need_decrypt;
        (void)avln_idx_in_desc;
        (void)key_table_idx_in_desc;
        (void)key_idx_in_desc;
        mpdu_tx_nncco_or_rtscts_test(proto, tx_ctxt, qid, bcast,
            I1901_RTS_CTS, nid, dtei, stei, lid, need_encry, end);
        break;
    }
    default:
        IOT_ASSERT(0);
    }
#if 0
    uint32_t enq_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
    uint32_t cur_time, time_span;
#define NTB_MS_TICK 25000 // 0.04us * 25 = 1us, 1us * 1000 = 1ms
#define TX_TIMEOUT_TICK (NTB_MS_TICK << 5) // 32 ms

    mac_rx_ring_ctxt_t *ring_ctxt = &g_mac_pdev[0]->ring_hdl;
    do {
        cur_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
        time_span = cur_time - enq_time;
        if (time_span < 0) { // wrap around
             time_span = (0x100000000LL) - enq_time + cur_time;
        }
        if (time_span > TX_TIMEOUT_TICK) {
            iot_printf("tx timeout: %dms > %dms\n", \
                time_span / NTB_MS_TICK, \
                TX_TIMEOUT_TICK / NTB_MS_TICK);
            IOT_ASSERT(0);
        }
        for(uint8_t i=0;i<MAX_PLC_RX_RING_NUM;i++){
            if(ring_ctxt->ring[i].enabled){
                mac_rx_hw_mpdu(g_mac_pdev[0], i);
            }
        }
    } while (!end->tx_done);
    mac_tx_hw_mpdu_comp(qid);
#endif
}

/* used for ping under ftm mode,
 * TODO: to be removed later
 */
uint32_t test_send_sof(mac_queue_ctxt_t *tx_ctxt,
    uint32_t stei, uint32_t dtei, uint32_t nid,\
    uint8_t tmi, uint8_t ext_tmi,\
    uint8_t pb_num, uint8_t *pkt,uint8_t need_ack)
{
    /* mac protocol */
    uint32_t proto = PHY_PROTO_TYPE_GET();
    tx_mpdu_end *end;
    mac_desc_get(&g_mac_desc_eng, PLC_TX_MPDU_END_POOL, (void**)&end);
    IOT_ASSERT(end);
    end->tx_done = 0;
    end->tx_ok = 0;
    uint8_t qid = 0;
    mpdu_tx_sof_test(proto,tx_ctxt, qid, 0, FC_DELIM_SOF, nid,\
        dtei, stei, tmi, ext_tmi,0, pb_num, need_ack, 0, 0,\
        0, 0, 0, 0, end,100, pkt, 0, 0, 0, NULL);
    if(mac_ping_enable)
    {
        enq_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
    }
    do {
        mac_rx_hw_mpdu_internal(g_mac_pdev[0], 0, 1000);
    } while (!end->tx_done);
    mac_tx_hw_mpdu_comp(qid, 1);
    return 0;
}
#endif
#endif