1286 lines
42 KiB
C
Executable File
1286 lines
42 KiB
C
Executable File
#include "chip_reg_base.h"
|
|
#include "hw_reg_api.h"
|
|
#include "hw_tonemask.h"
|
|
#include "tx_mpdu_start.h"
|
|
#include "tx_mpdu_end.h"
|
|
#include "tx_pb_start.h"
|
|
#include "plc_utils.h"
|
|
#include "mac_reset.h"
|
|
#include "mac_hwq_reg.h"
|
|
#include "mac_sys_reg.h"
|
|
#include "mac_rx_reg.h"
|
|
#include "mac_tmr_reg.h"
|
|
#include "ada_reg.h"
|
|
#include "hw_phy_init.h"
|
|
#include "phy_ana.h"
|
|
#include "phy_reg.h"
|
|
#include "phy_bb.h"
|
|
#include "mpdu_frame.h"
|
|
#include "ahb.h"
|
|
#include "iot_irq.h"
|
|
//#include "iot_mem.h"
|
|
#include "mac_tx_main.h"
|
|
#include "intc_reg.h"
|
|
#include "apb_glb_reg.h"
|
|
#include "command_list.h"
|
|
#include "dbg_io.h"
|
|
#include "iot_config.h"
|
|
#include "iot_io.h"
|
|
|
|
#include "mac_hwq_mgr.h"
|
|
#include "iot_pkt_api.h"
|
|
#include "mac_desc_engine.h"
|
|
#include "mac_tx_hw.h"
|
|
#include "mac_rx_hw.h"
|
|
#include "os_utils.h"
|
|
|
|
#include "phy_rxtd_reg.h"
|
|
#include "mac_crc.h"
|
|
#include "mpdu_header.h"
|
|
|
|
#include "mac_avln.h"
|
|
#include "mac_key_hw.h"
|
|
#include "mac_key.h"
|
|
|
|
/* if mem fun is not ready, use global heap */
|
|
tx_mpdu_start mpdu_start;
|
|
tx_mpdu_end mpdu_end;
|
|
tx_pb_start pb_start,pb_second,pb_third,pb_last;
|
|
uint8_t pb_buf[MAC_PB_SIZE_MAX] = { 0 };
|
|
uint8_t pb_buf_second[MAC_PB_SIZE_MAX] = { 0 };
|
|
uint8_t pb_buf_third[MAC_PB_SIZE_MAX] = { 0 };
|
|
uint8_t pb_buf_last[MAC_PB_SIZE_MAX] = { 0 };
|
|
/* mac tx beacon test - with 7000 GP protocol */
|
|
#if EDA_SIMU_SUPPORT == 1
|
|
uint32_t bcn_period_ms = 6;
|
|
#else
|
|
uint32_t bcn_period_ms = 20 << 1;
|
|
#endif
|
|
iot_mac_intr_info_t mac_info;
|
|
volatile bool_t mac_beacon_alert_flag = false;
|
|
volatile bool_t mac_tx_complete_flag = false;
|
|
|
|
/* tx cfg */
|
|
iot_tx_cfg_info_t glb_cfg = {PLC_PROTO_TYPE_SG,FC_DELIM_SOF,MAC_TX_TEST_ID, \
|
|
MAC_TMI_ID,MAC_PB_NUM_ID,IOT_PLC_PHY_BAND_DFT, \
|
|
IOT_RATE_MODE_TX};
|
|
uint32_t print_tx_period_ms=4000;
|
|
//mac_msdu_t *g_msdu[MAX_MAC_TXQ_NUM] = {NULL};
|
|
uint8_t delay_time = 0;
|
|
uint32_t enq_time = 0;
|
|
uint8_t send_tput_flag =0;
|
|
uint8_t mac_ping_enable = 0;
|
|
|
|
void mac_encry_mode_init_test(uint8_t vlan_num, \
|
|
uint8_t key_tbl_num, uint8_t key_num)
|
|
{
|
|
uint8_t vlan_idx, key_tbl_idx, key_idx;
|
|
mac_avln_t *avln_ptr;
|
|
mac_key_table_t *key_tbl;
|
|
mac_key_entry *key;
|
|
|
|
mac_avln_ctxt_init(vlan_num);
|
|
for(vlan_idx = 0; vlan_idx < vlan_num; vlan_idx++)
|
|
{
|
|
mac_avln_init(vlan_idx, key_tbl_num);
|
|
avln_ptr = (g_mac_avln_ctxt.mac_avln_array + vlan_idx);
|
|
for(key_tbl_idx = 0; key_tbl_idx < key_tbl_num; key_tbl_idx++)
|
|
{
|
|
key_tbl = (avln_ptr->key_tbl + key_tbl_idx);
|
|
mac_key_tbl_init(key_tbl, key_num);
|
|
}
|
|
}
|
|
for(vlan_idx = 0; vlan_idx < vlan_num; vlan_idx++)
|
|
{
|
|
avln_ptr = (g_mac_avln_ctxt.mac_avln_array + vlan_idx);
|
|
for(key_tbl_idx = 0; key_tbl_idx < key_tbl_num; key_tbl_idx++)
|
|
{
|
|
key_tbl = (avln_ptr->key_tbl + key_tbl_idx);
|
|
for(key_idx = 0; key_idx < key_num; key_idx++)
|
|
{
|
|
key = (key_tbl->key_array + key_idx);
|
|
mac_key_set(key, 0, vlan_idx, key_tbl_idx, key_idx);
|
|
}
|
|
|
|
}
|
|
}
|
|
key = g_mac_avln_ctxt.mac_avln_array->key_tbl->key_array;
|
|
mac_key_set(key, 0x12345678, 0x23456789, 0x3456789a, 0x456789ab);
|
|
|
|
for(vlan_idx = 0; vlan_idx < vlan_num; vlan_idx++)
|
|
{
|
|
avln_ptr = (g_mac_avln_ctxt.mac_avln_array + vlan_idx);
|
|
mac_key_hw_set_avln_key_tlb(vlan_idx, avln_ptr);
|
|
}
|
|
|
|
for(vlan_idx = 0; vlan_idx < vlan_num; vlan_idx++)
|
|
{
|
|
mac_key_hw_set_avln_nid(vlan_idx, 0x1);
|
|
}
|
|
}
|
|
|
|
void ftm_msdu_init()
|
|
{
|
|
#if 0
|
|
uint8_t i;
|
|
for(i=0; i<MAX_MAC_TXQ_NUM; i++)
|
|
{
|
|
g_msdu[i] = \
|
|
os_mem_malloc(IOT_FTM_MID,sizeof(mac_msdu_t));
|
|
IOT_ASSERT(g_msdu[i]);
|
|
mac_msdu_init(g_msdu[i], 1, NULL, NULL);
|
|
}
|
|
#endif
|
|
return;
|
|
}
|
|
//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);
|
|
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);
|
|
msdu_len = data_len - sizeof(*spg_mac);
|
|
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, HEAD_SIEZ_64, PLC_MAC_TX_MID);
|
|
IOT_ASSERT(buf && ((pkt_len + HEAD_SIEZ_64) <= buf_len));
|
|
uint8_t *tmp = iot_pkt_put(buf, buf_len-HEAD_SIEZ_64);
|
|
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-HEAD_SIEZ_64);
|
|
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-HEAD_SIEZ_64);
|
|
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-HEAD_SIEZ_64);
|
|
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)
|
|
{
|
|
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);
|
|
|
|
iot_pkt_t *test_data = \
|
|
ftm_fill_mac_data(delimiter_type, MIN_DATA_SIZE, pkt, pkt_len);
|
|
|
|
phy_get_pb_size(proto, tmi, ext_tmi, &pb_sz);
|
|
phy_get_pb_mod(proto, tmi, ext_tmi, &pb_mod);
|
|
|
|
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);
|
|
|
|
/* get pb header + crc length */
|
|
pb_hdr_resv_crc_len = mac_get_pb_hdr_resv_crc_len(FC_DELIM_BEACON,
|
|
proto);
|
|
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, 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, 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};
|
|
mac_get_tx_msg_from_fc(proto, delimiter_type, &mpdu->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)
|
|
{
|
|
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;
|
|
|
|
iot_pkt_t *test_data = \
|
|
ftm_fill_mac_data(delimiter_type, MAX_DATA_SIZE, pkt, pkt_len);
|
|
|
|
phy_get_pb_size(proto, tmi,ext_tmi,&pb_sz);
|
|
phy_get_pb_mod(proto, tmi, ext_tmi, &pb_mod);
|
|
|
|
bitmap = 0xffffffff >> (32 - pb_num);
|
|
|
|
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);
|
|
|
|
/* get header + crc length */
|
|
uint8_t pb_hdr_resv_crc_len = mac_get_pb_hdr_resv_crc_len(delimiter_type, \
|
|
proto);
|
|
mac_tx_mpdu_fill_macinfo(mpdu, qid, pb_num, need_encry, 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, 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, HW_DESC_TX_PHASE_ALL, 0, ppdu_mode, 0, pb_mod, rate_mode);
|
|
mac_tx_mpdu_fill_fcinfo(mpdu, proto, \
|
|
pb_num, HW_DESC_TX_PHASE_ALL, delimiter_type, network, nid, 0,\
|
|
tmi, ext_tmi, dtei, stei, lid, bcast, 0,need_encry,\
|
|
key_table_idx_in_desc ,key_idx_in_desc, NULL);
|
|
if(!need_decrypt)
|
|
{
|
|
switch (proto) {
|
|
case PLC_PROTO_TYPE_SG:
|
|
{
|
|
frame_control_t *fc = \
|
|
(frame_control_t *)&mpdu->fc.sg_fc;
|
|
fc->vf.sof.decrypt_mode = 0;
|
|
break;
|
|
}
|
|
case PLC_PROTO_TYPE_SPG:
|
|
{
|
|
spg_frame_control_t *fc = \
|
|
(spg_frame_control_t *)&mpdu->fc.spg_fc;
|
|
fc->vf.sof.decrypt_mode = 0;
|
|
break;
|
|
}
|
|
default:
|
|
IOT_ASSERT(0);
|
|
}
|
|
}
|
|
|
|
mac_crc_set_fc_swcrc(proto, mpdu);
|
|
if(!send_tput_flag)
|
|
{
|
|
tx_fc_msg_t msg = {0};
|
|
mac_get_tx_msg_from_fc(proto, delimiter_type, &mpdu->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, pb_num);
|
|
}
|
|
}
|
|
|
|
/* send */
|
|
mac_tx_hw_mpdu(tx_ctxt, qid, mpdu);
|
|
}
|
|
void gp_mpdu_tx_rtscts_test(uint32_t proto, mac_queue_ctxt_t *tx_ctxt,\
|
|
uint8_t qid, uint8_t delimiter_type,uint32_t nid,\
|
|
uint32_t dtei, uint32_t stei,uint8_t tmi, uint8_t lid,\
|
|
uint8_t pb_num, 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 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;
|
|
|
|
iot_pkt_t *test_data = \
|
|
ftm_fill_mac_data(delimiter_type, MID_DATA_SIZE, pkt, pkt_len);
|
|
|
|
//phy_get_pb_size(proto, tmi,0,&pb_sz);
|
|
phy_get_pb_mod(proto, tmi, 0, &pb_mod);
|
|
|
|
//bitmap = 0xffffffff >> (32 - pb_num);
|
|
|
|
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);
|
|
|
|
/* get header + crc length */
|
|
uint8_t pb_hdr_resv_crc_len = mac_get_pb_hdr_resv_crc_len(delimiter_type, \
|
|
proto);
|
|
mac_tx_mpdu_fill_macinfo(mpdu, qid, pb_num, need_encry, 0,\
|
|
phy_get_sym_per_pb(proto, 0, tmi, 0,
|
|
phy_get_pss_id(proto, tmi, ext_tmi)), \
|
|
phy_get_fl_per_pb(proto, 0, tmi, 0), 0,\
|
|
pb_hdr_resv_crc_len, hw_retry_cnt, 1, 1, mpdu_end, NULL, NULL, 0, \
|
|
(uint32_t)(iot_pkt_data(test_data) - (uint8_t*)test_data), 0, 0, 0, 0, 0, 0);
|
|
|
|
/* For RTS-CTS only */
|
|
mpdu->pb_num = 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, \
|
|
pb_num, HW_DESC_TX_PHASE_ALL, delimiter_type, network, nid, 0, \
|
|
tmi, 0, dtei, stei, lid, 0, 0, 0, 0, 0, NULL);
|
|
mac_crc_set_fc_swcrc(proto, mpdu);
|
|
if(!send_tput_flag)
|
|
{
|
|
tx_fc_msg_t msg = {0};
|
|
mac_get_tx_msg_from_fc(proto, delimiter_type, &mpdu->fc, &msg);
|
|
iot_printf("GP:proto = %d," \
|
|
"hwq = %d," \
|
|
"sof tx:tmi = %d," \
|
|
"pb_num = %d\n", \
|
|
proto, qid, msg.tmi, pb_num);
|
|
}
|
|
|
|
/* send */
|
|
mac_tx_hw_mpdu(tx_ctxt, qid, mpdu);
|
|
}
|
|
|
|
void mpdu_tx_nncco_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;
|
|
|
|
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);
|
|
mac_tx_mpdu_fill_phyinfo(mpdu, HW_DESC_TX_PORT_PLC, \
|
|
128, HW_DESC_TX_PHASE_ALL, 0, 0, 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 nncco tx_done\n",qid);
|
|
|
|
/* 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;
|
|
if(proto == PLC_PROTO_TYPE_SPG)
|
|
{
|
|
iot_printf("NW do not supprot sound!");
|
|
return;
|
|
}
|
|
iot_pkt_t *test_data = \
|
|
ftm_fill_mac_data(delimiter_type, MID_DATA_SIZE, pkt, pkt_len);
|
|
|
|
phy_get_pb_size(proto, tmi, ext_tmi, &pb_sz);
|
|
phy_get_pb_mod(proto, tmi, ext_tmi, &pb_mod);
|
|
|
|
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);
|
|
|
|
uint8_t pb_hdr_resv_crc_len = mac_get_pb_hdr_resv_crc_len(delimiter_type, \
|
|
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, 0, 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};
|
|
mac_get_tx_msg_from_fc(proto, delimiter_type, &mpdu->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 gp_mpdu_tx_sound_test(uint32_t proto, mac_queue_ctxt_t *tx_ctxt, uint8_t qid,\
|
|
uint8_t delimiter_type,uint32_t nid,\
|
|
uint32_t dtei, uint32_t stei,uint8_t 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;
|
|
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;
|
|
|
|
iot_pkt_t *test_data = \
|
|
ftm_fill_mac_data(delimiter_type, MID_DATA_SIZE, pkt, pkt_len);
|
|
|
|
phy_get_pb_size(proto, tmi,0,&pb_sz);
|
|
phy_get_pb_mod(proto, tmi, 0, &pb_mod);
|
|
|
|
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);
|
|
|
|
uint8_t pb_hdr_resv_crc_len = mac_get_pb_hdr_resv_crc_len(delimiter_type, \
|
|
proto);
|
|
mac_tx_mpdu_fill_macinfo(mpdu, qid, 1, 0, 0,\
|
|
phy_get_sym_per_pb(proto, 0, tmi, 0,
|
|
phy_get_pss_id(proto, tmi, ext_tmi)), \
|
|
phy_get_fl_per_pb(proto, 0, tmi, 0), 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, network, nid, 0,\
|
|
tmi, 0, dtei, stei, lid, 0, 0, 0, 0, 0, NULL);
|
|
|
|
mac_crc_set_fc_swcrc(proto, mpdu);
|
|
|
|
{
|
|
tx_fc_msg_t msg = {0};
|
|
mac_get_tx_msg_from_fc(proto, delimiter_type, &mpdu->fc, &msg);
|
|
iot_printf("mac_type = %d," \
|
|
"hwq = %d," \
|
|
"sound tx:tmi = %d," \
|
|
"pb_num = %d\n", \
|
|
proto, qid, msg.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)
|
|
{
|
|
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;
|
|
|
|
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);
|
|
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);
|
|
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;
|
|
mpdu_tx_nncco_test(proto, tx_ctxt, qid, bcast, FC_DELIM_NNCCO, nid,\
|
|
dtei, stei, lid, need_encry, end);
|
|
break;
|
|
case FC_DELIM_SOUND:
|
|
(void)pb_num;
|
|
(void)need_decrypt;
|
|
(void)avln_idx_in_desc;
|
|
(void)key_table_idx_in_desc;
|
|
(void)key_idx_in_desc;
|
|
mpdu_tx_sound_test(proto, tx_ctxt, qid, bcast, FC_DELIM_SOUND,nid,\
|
|
dtei, stei, tmi, ext_tmi,lid, need_ack, need_encry, hw_retry_cnt, end,\
|
|
pkt_len, pkt);
|
|
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
|
|
}
|
|
|
|
/* For GP protocol only */
|
|
void gp_mpdu_send_test(mac_queue_ctxt_t *tx_ctxt, uint8_t qid,\
|
|
uint8_t delimiter_type,uint32_t snid,\
|
|
uint32_t dtei, uint32_t stei,uint8_t tmi,\
|
|
uint8_t lid,uint8_t pb_num,\
|
|
uint8_t need_encry, uint8_t need_ack, uint8_t hw_retry_cnt, \
|
|
uint16_t pkt_len, uint8_t *pkt)
|
|
{
|
|
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;
|
|
|
|
switch(delimiter_type){
|
|
case DT_AV_BEACON:
|
|
mpdu_tx_beacon_test(proto, tx_ctxt, qid, 0, DT_AV_BEACON, snid,\
|
|
dtei, stei, tmi, 0, lid, need_encry, end, pkt_len, pkt);
|
|
break;
|
|
case DT_AV_SOF:
|
|
mpdu_tx_sof_test(proto, tx_ctxt, qid, 0, DT_AV_SOF, snid,\
|
|
dtei, stei, tmi, 0, lid, pb_num, need_ack, need_encry,\
|
|
0, 0, 0, 0, hw_retry_cnt, end, pkt_len, pkt);
|
|
break;
|
|
case DT_AV_RTS_CTS:
|
|
gp_mpdu_tx_rtscts_test(proto, tx_ctxt, qid, DT_AV_RTS_CTS, snid,\
|
|
dtei, stei, tmi, lid, pb_num, need_encry,\
|
|
0, end, pkt_len, pkt);
|
|
break;
|
|
case DT_AV_SACK:
|
|
break;
|
|
case DT_AV_SOUND:
|
|
gp_mpdu_tx_sound_test(proto, tx_ctxt, qid, DT_AV_SOUND, snid,\
|
|
dtei, stei, tmi, lid, 0, need_encry, 0, end, pkt_len, pkt);
|
|
break;
|
|
default:
|
|
IOT_ASSERT(0);
|
|
}
|
|
}
|
|
|
|
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);
|
|
if(mac_ping_enable)
|
|
{
|
|
enq_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
}
|
|
do {
|
|
mac_rx_hw_mpdu(g_mac_pdev[0], 0);
|
|
} while (!end->tx_done);
|
|
mac_tx_hw_mpdu_comp(qid, 1);
|
|
return 0;
|
|
}
|
|
|
|
uint8_t loop = 0;
|
|
int32_t mac_tx_mpdu_test(void *pdev, tx_mpdu_start *mpdu) {
|
|
(void)pdev;
|
|
uint32_t tmp = 0;
|
|
uint32_t pb_size = 0;
|
|
uint32_t tmi = 0, ext_tmi = 0;
|
|
uint32_t pb_mod = 0;
|
|
uint32_t rate_mode = glb_cfg.rate_mode;
|
|
uint32_t* dbg_buf =NULL;
|
|
|
|
mpdu->desc_type = DESC_TYPE_TX_MPDU_START;
|
|
mpdu->proto_type = glb_cfg.m_type;
|
|
mpdu->tx_port = HW_DESC_TX_PORT_PLC;
|
|
mpdu->tx_phase = HW_DESC_TX_PHASE_ALL;
|
|
mpdu->tx_power = 128; // 1/8 unit db
|
|
if((glb_cfg.p_type == DT_AV_SOF)||(glb_cfg.p_type == FC_DELIM_SOF))
|
|
mpdu->need_ack = 1;
|
|
mpdu->ppdu_mode = HW_DESC_PPDU_MODE_AVONLY_1FCSYM;
|
|
mpdu->next = NULL;
|
|
|
|
/* clear the mpdu_end */
|
|
if (mpdu->tx_status) {
|
|
mpdu->tx_status->tx_done = 0;
|
|
mpdu->tx_status->tx_ok = 0;
|
|
}
|
|
|
|
/* tmi info */
|
|
tmi = glb_cfg.tmi;
|
|
if (tmi >= 15) {
|
|
/* if use ext_tmi */
|
|
tmi = 15;
|
|
ext_tmi = glb_cfg.tmi - 15;
|
|
}
|
|
|
|
if(glb_cfg.m_type == PLC_PROTO_TYPE_SG)
|
|
{
|
|
if(glb_cfg.p_type == FC_DELIM_BEACON)
|
|
{
|
|
mpdu->fc.sg_fc.delimiter_type = FC_DELIM_BEACON; /*beacon*/
|
|
mpdu->fc.sg_fc.vf.bcn.time_stamp = 0;
|
|
mpdu->fc.sg_fc.vf.bcn.src_tei = 1;
|
|
mpdu->fc.sg_fc.vf.bcn.tmi = tmi;
|
|
mpdu->fc.sg_fc.vf.bcn.sym_num = 0;
|
|
mpdu->fc.sg_fc.vf.bcn.phase_num = 0;
|
|
mpdu->fc.sg_fc.vf.bcn.pb_num = glb_cfg.pb_num;
|
|
mpdu->fc.sg_fc.vf.bcn.version = 0;
|
|
}
|
|
else if(glb_cfg.p_type == FC_DELIM_SOF)
|
|
{
|
|
mpdu->fc.sg_fc.delimiter_type = FC_DELIM_SOF; /*sof*/
|
|
mpdu->fc.sg_fc.vf.sof.src_tei = 1;
|
|
mpdu->fc.sg_fc.vf.sof.dst_tei = 2;
|
|
mpdu->fc.sg_fc.vf.sof.lid = 0;
|
|
mpdu->fc.sg_fc.vf.sof.frame_len = 0;
|
|
mpdu->fc.sg_fc.vf.sof.pb_num = glb_cfg.pb_num;
|
|
mpdu->fc.sg_fc.vf.sof.sym_num = 0;
|
|
mpdu->fc.sg_fc.vf.sof.bcast = 0;
|
|
mpdu->fc.sg_fc.vf.sof.tmi = tmi;
|
|
mpdu->fc.sg_fc.vf.sof.tmi_ext = ext_tmi;
|
|
mpdu->fc.sg_fc.vf.sof.version = 0;
|
|
|
|
// RAW DATA TESTING
|
|
//mpdu->fc.sg_fc.vf.sof.lid = loop++;
|
|
}
|
|
else if(glb_cfg.p_type == FC_DELIM_SOUND)
|
|
{
|
|
mpdu->fc.sg_fc.delimiter_type = FC_DELIM_SOUND; /*sound*/
|
|
mpdu->fc.sg_fc.vf.sof.src_tei = 1;
|
|
mpdu->fc.sg_fc.vf.sof.dst_tei = 2;
|
|
mpdu->fc.sg_fc.vf.sof.lid = 0;
|
|
mpdu->fc.sg_fc.vf.sof.frame_len = 0;
|
|
mpdu->fc.sg_fc.vf.sof.pb_num = glb_cfg.pb_num;
|
|
mpdu->fc.sg_fc.vf.sof.sym_num = 0;
|
|
mpdu->fc.sg_fc.vf.sof.bcast = 0;
|
|
mpdu->fc.sg_fc.vf.sof.tmi = tmi;
|
|
mpdu->fc.sg_fc.vf.sof.tmi_ext = ext_tmi;
|
|
mpdu->fc.sg_fc.vf.sof.version = 0;
|
|
|
|
}
|
|
mpdu->fc.sg_fc.network_type = 0;
|
|
// RAW DATA TESTING
|
|
//mpdu->fc.sg_fc.nid = 0x123456 + (loop++);
|
|
mpdu->fc.sg_fc.nid = 0x123456;
|
|
}
|
|
else if (glb_cfg.m_type == PLC_PROTO_TYPE_SPG)
|
|
{
|
|
if(glb_cfg.p_type == FC_DELIM_BEACON)
|
|
{
|
|
mpdu->fc.spg_fc.delimiter_type = FC_DELIM_BEACON; /*beacon*/
|
|
mpdu->fc.spg_fc.vf.bcn.time_stamp = 0;
|
|
mpdu->fc.spg_fc.vf.bcn.src_tei = 1;
|
|
mpdu->fc.spg_fc.vf.bcn.tmi = tmi;
|
|
mpdu->fc.spg_fc.vf.bcn.sym_num = 0;
|
|
mpdu->fc.spg_fc.vf.bcn.phase_num = 0;
|
|
mpdu->fc.spg_fc.vf.bcn.version = 0;
|
|
}
|
|
else if(glb_cfg.p_type == FC_DELIM_SOF)
|
|
{
|
|
mpdu->fc.spg_fc.delimiter_type = FC_DELIM_SOF; /*sof*/
|
|
mpdu->fc.spg_fc.vf.sof.src_tei = 1;
|
|
mpdu->fc.spg_fc.vf.sof.dst_tei = 2;
|
|
mpdu->fc.spg_fc.vf.sof.lid = 0;
|
|
mpdu->fc.spg_fc.vf.sof.frm_len = 0;
|
|
mpdu->fc.spg_fc.vf.sof.pb_num = glb_cfg.pb_num;
|
|
mpdu->fc.spg_fc.vf.sof.sym_num = 0;
|
|
mpdu->fc.spg_fc.vf.sof.tmi = tmi;
|
|
mpdu->fc.spg_fc.vf.sof.tmi_ext = ext_tmi;
|
|
mpdu->fc.spg_fc.vf.sof.version = 0;
|
|
}
|
|
mpdu->fc.spg_fc.access_ind = 1;
|
|
mpdu->fc.spg_fc.snid = 0xb;
|
|
}
|
|
else{
|
|
/* AV FC */
|
|
if(glb_cfg.p_type == DT_AV_BEACON)
|
|
{
|
|
mpdu->fc.hpav_fc.delimiter_type = DT_AV_BEACON;
|
|
}
|
|
else if(glb_cfg.p_type == DT_AV_SOF)
|
|
{
|
|
mpdu->fc.hpav_fc.delimiter_type = DT_AV_SOF;
|
|
mpdu->fc.hpav_fc.vf_av.sof.src_tei = 1;
|
|
mpdu->fc.hpav_fc.vf_av.sof.dst_tei = 2;
|
|
mpdu->fc.hpav_fc.vf_av.sof.lid = 0;
|
|
mpdu->fc.hpav_fc.vf_av.sof.eks = 0xf;
|
|
if(tmi == 0 || tmi == 1)
|
|
mpdu->fc.hpav_fc.vf_av.sof.pbsz = 0;
|
|
else if(tmi == 2)
|
|
mpdu->fc.hpav_fc.vf_av.sof.pbsz = 1;
|
|
else
|
|
IOT_ASSERT(0);
|
|
mpdu->fc.hpav_fc.vf_av.sof.numsym = 3;
|
|
mpdu->fc.hpav_fc.vf_av.sof.tmi_av = glb_cfg.tmi;
|
|
mpdu->fc.hpav_fc.vf_av.sof.fl_av = 0;
|
|
}
|
|
else if(glb_cfg.p_type == DT_AV_RTS_CTS)
|
|
{
|
|
mpdu->fc.hpav_fc.delimiter_type = DT_AV_RTS_CTS;
|
|
mpdu->fc.hpav_fc.vf_av.rtscts.src_tei = 1;
|
|
mpdu->fc.hpav_fc.vf_av.rtscts.dst_tei = 2;
|
|
mpdu->fc.hpav_fc.vf_av.rtscts.lid = 0;
|
|
mpdu->fc.hpav_fc.vf_av.rtscts.rtsf = 1;
|
|
}
|
|
else if(glb_cfg.p_type == DT_AV_SOUND)
|
|
{
|
|
mpdu->fc.hpav_fc.delimiter_type = DT_AV_SOUND;
|
|
mpdu->fc.hpav_fc.vf_av.sound.stei = 1;
|
|
mpdu->fc.hpav_fc.vf_av.sound.dtei = 2;
|
|
mpdu->fc.hpav_fc.vf_av.sound.lid = 0;
|
|
if(tmi == 0 || tmi == 1)
|
|
mpdu->fc.hpav_fc.vf_av.sound.pbsz = 0;
|
|
else if(tmi == 2)
|
|
mpdu->fc.hpav_fc.vf_av.sound.pbsz = 1;
|
|
mpdu->fc.hpav_fc.vf_av.sound.req_tm = 1;
|
|
mpdu->fc.hpav_fc.vf_av.sound.fl_av = 0;
|
|
mpdu->fc.hpav_fc.vf_av.sound.src = 0xFD;//as part of Initial Channel Estimation
|
|
}
|
|
mpdu->fc.hpav_fc.access = 1;
|
|
mpdu->fc.hpav_fc.snid = 0xb;
|
|
}
|
|
|
|
/* band info */
|
|
#ifdef IOT_SUPPORT_MULTI_RATE_HW
|
|
mpdu->sg_bandsel = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR)%3;
|
|
#else
|
|
mpdu->sg_bandsel = 0;
|
|
#endif
|
|
|
|
/* only contains the pb's size */
|
|
phy_get_pb_size(glb_cfg.m_type, tmi, ext_tmi, &pb_size);
|
|
mpdu->pb_num = glb_cfg.pb_num;
|
|
mpdu->total_bytes = pb_size*glb_cfg.pb_num;
|
|
/* start/end time, ignore in GP's case */
|
|
//mpdu->start_time = 0;
|
|
//mpdu->end_time = 0;
|
|
/* TODO: amplitude table select */
|
|
mpdu->tx_tone_amp = 0;
|
|
mpdu->tx_symbnum_ppb = phy_get_sym_per_pb(glb_cfg.m_type, mpdu->sg_bandsel,
|
|
tmi, ext_tmi, phy_get_pss_id(glb_cfg.m_type, tmi, ext_tmi));
|
|
if(mpdu->tx_symbnum_ppb*glb_cfg.pb_num >= 512){
|
|
iot_printf("[TMI-%d][PB-%d][error]:symbol size %d bigger than 512.", \
|
|
ext_tmi+tmi,glb_cfg.pb_num,mpdu->tx_symbnum_ppb*glb_cfg.pb_num);
|
|
return -1;
|
|
}
|
|
mpdu->sw_tx_fl_ppb = (uint32_t) \
|
|
phy_get_fl_per_pb(glb_cfg.m_type, mpdu->sg_bandsel, tmi, ext_tmi);
|
|
|
|
/* hw id */
|
|
mpdu->swq_id = 0;
|
|
/* hw retry cnt */
|
|
mpdu->hw_retry_cnt = 0;
|
|
|
|
/* set the crc hdr len, GP is 4 for bcn */
|
|
if(glb_cfg.m_type == PLC_PROTO_TYPE_SG)
|
|
{
|
|
if(glb_cfg.p_type == FC_DELIM_BEACON)
|
|
{
|
|
mpdu->pb_hdr_crc_len = 3;
|
|
}
|
|
else if((glb_cfg.p_type == FC_DELIM_SOF)||(glb_cfg.p_type == FC_DELIM_SOUND))
|
|
{
|
|
mpdu->pb_hdr_crc_len = 4;
|
|
}
|
|
}
|
|
else if(glb_cfg.m_type == PLC_PROTO_TYPE_SPG)
|
|
{
|
|
if(glb_cfg.p_type == FC_DELIM_BEACON)
|
|
{
|
|
mpdu->pb_hdr_crc_len = 3;
|
|
}
|
|
else if((glb_cfg.p_type == FC_DELIM_SOF)||(glb_cfg.p_type == FC_DELIM_SOUND))
|
|
{
|
|
mpdu->pb_hdr_crc_len = 7;
|
|
}
|
|
}
|
|
else{
|
|
if(glb_cfg.p_type == DT_AV_BEACON)
|
|
{
|
|
mpdu->pb_hdr_crc_len = 4;
|
|
}
|
|
else if(glb_cfg.p_type == DT_AV_SOF)
|
|
{
|
|
mpdu->pb_hdr_crc_len = 8;
|
|
}
|
|
}
|
|
|
|
/* pb modulation and rate */
|
|
phy_get_pb_mod(glb_cfg.m_type,tmi, ext_tmi, &pb_mod);
|
|
mpdu->tx_pb_modulation = pb_mod;
|
|
mpdu->tx_rate_mode = rate_mode;
|
|
|
|
#if 0
|
|
|
|
/* zliu test */
|
|
mpdu->proto_type = 4;
|
|
mpdu->fc.sg_fc.vf.sof.frame_len = 0x1c1;
|
|
mpdu->fc.sg_fc.vf.sof.pb_num =2; //0x2 is 6/30versions
|
|
//zliu RAW SPECIAL
|
|
mpdu->fc.sg_fc.vf.sof.sym_num = 0x15;//mpdu->tx_symbnum_ppb;
|
|
|
|
|
|
|
|
#endif
|
|
dbg_buf= (uint32_t*)&mpdu->fc.sg_fc.vf.sof;
|
|
iot_printf("FC:0x%04x 0x%04x 0x%04x 0x%04x\n", dbg_buf[0],dbg_buf[1],dbg_buf[2],dbg_buf[3]);
|
|
/* set hwq0's ptr list */
|
|
RGF_HWQ_WRITE_REG(CFG_HWQ0_PTR_ADDR, (uint32_t)mpdu);
|
|
/* read NTB and fill in the start and end time
|
|
* by max time span value
|
|
*/
|
|
tmp = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
RGF_HWQ_WRITE_REG(CFG_HWQ0_START_ADDR, tmp);
|
|
RGF_HWQ_WRITE_REG(CFG_HWQ0_END_ADDR, (tmp + (0xffffffff >> 1) - 1));
|
|
|
|
|
|
/* trigger send */
|
|
tmp = RGF_HWQ_READ_REG(CFG_HWQ0_ADDR);
|
|
if (REG_FIELD_GET(CFG_DBG_HWQ0_EN, tmp)) {
|
|
/* if enable then disable first */
|
|
REG_FIELD_SET(CFG_DBG_HWQ0_EN, tmp, 0); // disable hwq
|
|
RGF_HWQ_WRITE_REG(CFG_HWQ0_ADDR, tmp);
|
|
}
|
|
REG_FIELD_SET(CFG_DBG_HWQ0_EN, tmp, 1); // enable hwq
|
|
RGF_HWQ_WRITE_REG(CFG_HWQ0_ADDR, tmp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
uint32_t tx_complete_handler(uint32_t vector, iot_addrword_t data)
|
|
{
|
|
uint32_t status;
|
|
|
|
status = RGF_MAC_READ_REG(CFG_MAC_INT_STS_ADDR);
|
|
//iot_printf("intc status=0x%x\r\n",status);
|
|
|
|
if(status & (0x1 <<5)){
|
|
/* clear intr */
|
|
RGF_MAC_WRITE_REG(CFG_MAC_INT_CLR_ADDR, 0x1<<5);
|
|
RGF_HWQ_WRITE_REG(CFG_HWQ_TX_DONE_INT_CLR_ADDR,0xf);
|
|
if(!mpdu_start.tx_status->tx_done)
|
|
iot_printf("Intr complete,but tx not done!\r\n");
|
|
mpdu_start.tx_status->tx_done = 0;
|
|
mac_tx_complete_flag = true;
|
|
}
|
|
|
|
if(status & (0x1 <<0)){
|
|
/* clear intr */
|
|
RGF_MAC_WRITE_REG(CFG_MAC_INT_CLR_ADDR, 0x1<<0);
|
|
mac_beacon_alert_flag = true;
|
|
}
|
|
|
|
if(status & (0x1 <<4)){
|
|
/* clear intr */
|
|
RGF_MAC_WRITE_REG(CFG_MAC_INT_CLR_ADDR, 0x1<<4);
|
|
|
|
mac_beacon_alert_flag = true;
|
|
}
|
|
|
|
#if MODULE_EN
|
|
/* single interrupt handler */
|
|
INTC_WRITE_REG(CFG_INT_ENA0_ADDR,0x0);
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
void mac_interrupt_init()
|
|
{
|
|
uint32_t tmp = 0;
|
|
|
|
os_mem_set(&mac_info, 0x0, sizeof(iot_mac_intr_info_t));
|
|
/* intc en */
|
|
INTC_WRITE_REG(CFG_INT_ENA0_ADDR,0x21);
|
|
/* clr mac int */
|
|
RGF_MAC_WRITE_REG(CFG_MAC_INT_CLR_ADDR, 0x1<<(5));//tx complete
|
|
RGF_MAC_WRITE_REG(CFG_MAC_INT_CLR_ADDR, 0x1<<(0));//tx beacon alert
|
|
|
|
/* MPDU done intr enable */
|
|
tmp = RGF_MAC_READ_REG(CFG_INT_ENA_MASK_ADDR);
|
|
if(glb_cfg.t_type == MAC_TX_INTR_MPDU_COMPLETE)
|
|
REG_FIELD_SET(CFG_INT_ENABLE_MASK,tmp,(0x1<<5));
|
|
else if(glb_cfg.t_type == MAC_TX_INTR_BCN_ALT)
|
|
REG_FIELD_SET(CFG_INT_ENABLE_MASK,tmp,(0x1<<0));
|
|
else if(glb_cfg.t_type == MAC_TX_SCHED_BCN_AHEAD_ALERT)
|
|
REG_FIELD_SET(CFG_INT_ENABLE_MASK,tmp,(0x1<<5));
|
|
RGF_MAC_WRITE_REG(CFG_INT_ENA_MASK_ADDR, tmp);
|
|
|
|
/* pri int */
|
|
tmp = RGF_MAC_READ_REG(CFG_INT_PRI1_MASK_ADDR);
|
|
REG_FIELD_SET(CFG_INT_PRI1_MASK,tmp,(0x1<<0) | (0x1<<5));
|
|
RGF_MAC_WRITE_REG(CFG_INT_PRI1_MASK_ADDR, tmp);
|
|
|
|
/* interrupt controller */
|
|
mac_info.int_num = HAL_VECTOR_MAC_1;
|
|
mac_info.handle = iot_interrupt_create( mac_info.int_num, 0, (iot_addrword_t)&mac_info, tx_complete_handler);
|
|
iot_interrupt_attach( mac_info.handle);
|
|
|
|
iot_interrupt_unmask( mac_info.handle);
|
|
}
|
|
|
|
|
|
uint32_t mac_hw_init() {
|
|
uint32_t tmp;
|
|
|
|
/* reset mac */
|
|
mac_reset(MAC_RST_REASON_COLD);
|
|
/* reset phy */
|
|
phy_reset(PHY_RST_REASON_COLD);
|
|
/* reset mac */
|
|
mac_reset(MAC_RST_REASON_COLD);
|
|
|
|
/* init */
|
|
phy_init(PLC_PROTO_TYPE_SG, IOT_PLC_PHY_BAND_DFT, TONE_MASK_ID_NULL, true);
|
|
|
|
/* dtest mac interrupt cfg */
|
|
if(glb_cfg.t_type >= MAC_TX_INTR_BCN_ALT)
|
|
mac_interrupt_init();
|
|
|
|
/******************************************************/
|
|
/* mac related dtest param */
|
|
/* enable DCU debug mode */
|
|
tmp = RGF_HWQ_READ_REG(CFG_SCH_ADDR);
|
|
if(glb_cfg.t_type == MAC_TX_SCHED_BCN_AHEAD_ALERT)
|
|
REG_FIELD_SET(CFG_HWQ_DBG_MODE, tmp, 0); // commandlist enable
|
|
else
|
|
REG_FIELD_SET(CFG_HWQ_DBG_MODE, tmp, 1); // debug enable
|
|
RGF_HWQ_WRITE_REG(CFG_SCH_ADDR, tmp);
|
|
|
|
/* set hwq 0 's config */
|
|
/* set hwq0's type, cap */
|
|
tmp = RGF_HWQ_READ_REG(CFG_HWQ0_ADDR);
|
|
REG_FIELD_SET(CFG_DBG_HWQ0_TYPE, tmp, 0); // 0:TDMA, 1:CSMA
|
|
REG_FIELD_SET(CFG_DBG_HWQ0_CAP, tmp, 1); // CAP1 as default
|
|
RGF_HWQ_WRITE_REG(CFG_HWQ0_ADDR, tmp);
|
|
|
|
/* set beacon period */
|
|
RGF_MAC_WRITE_REG(CFG_BEACON_PERIOD_ADDR, bcn_period_ms * TICKS_MS);
|
|
|
|
/* config my nid */
|
|
tmp = RGF_MAC_READ_REG(CFG_MYNID_ADDR);
|
|
REG_FIELD_SET(CFG_MYNID, tmp, 0x123456);
|
|
RGF_MAC_WRITE_REG(CFG_MYNID_ADDR, tmp);
|
|
|
|
/* tei cfg */
|
|
RGF_MAC_WRITE_REG(CFG_MYTEI_ADDR, 1);
|
|
|
|
/* enable and trigger the HW to load it */
|
|
tmp = RGF_MAC_READ_REG(CFG_TMI_CTRL_ADDR);
|
|
REG_FIELD_SET(CFG_TONE_AMP_EN, tmp, 0);
|
|
RGF_MAC_WRITE_REG(CFG_TMI_CTRL_ADDR, tmp);
|
|
|
|
/* delete timeout for long pkt */
|
|
RGF_TMR_WRITE_REG(CFG_TX_TIMEOUT_0_ADDR,0x0);
|
|
RGF_TMR_WRITE_REG(CFG_TX_TIMEOUT_1_ADDR,0x0);
|
|
RGF_TMR_WRITE_REG(CFG_TX_TIMEOUT_2_ADDR,0x0);
|
|
RGF_TMR_WRITE_REG(CFG_PHY_TX_TIMEOUT_ADDR,0x0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* support mode : ftm, module, dtest scan */
|
|
void tx_common_init()
|
|
{
|
|
/* basic data struct init for bit ops */
|
|
iot_bitops_init();
|
|
|
|
mac_hw_init();
|
|
/* construct the desc */
|
|
#if MAC_PB_NUM_ID == 1
|
|
pb_start.next_pb = NULL;
|
|
pb_start.pb_buf_addr = (uint32_t)&pb_buf[0];
|
|
#elif MAC_PB_NUM_ID == 2
|
|
pb_start.next_pb = &pb_second;
|
|
pb_second.next_pb = NULL;
|
|
pb_start.pb_buf_addr = (uint32_t)&pb_buf[0];
|
|
pb_second.pb_buf_addr = (uint32_t)&pb_buf_second[0];
|
|
#elif MAC_PB_NUM_ID == 3
|
|
pb_start.next_pb = &pb_second;
|
|
pb_second.next_pb = &pb_third;
|
|
pb_third.next_pb = NULL;
|
|
pb_start.pb_buf_addr = (uint32_t)&pb_buf[0];
|
|
pb_second.pb_buf_addr = (uint32_t)&pb_buf_second[0];
|
|
pb_third.pb_buf_addr = (uint32_t)&pb_buf_third[0];
|
|
#elif MAC_PB_NUM_ID == 4
|
|
pb_start.next_pb = &pb_second;
|
|
pb_second.next_pb = &pb_third;
|
|
pb_third.next_pb = &pb_last;
|
|
pb_last.next_pb = NULL;
|
|
pb_start.pb_buf_addr = (uint32_t)&pb_buf[0];
|
|
pb_second.pb_buf_addr = (uint32_t)&pb_buf_second[0];
|
|
pb_third.pb_buf_addr = (uint32_t)&pb_buf_third[0];
|
|
pb_last.pb_buf_addr = (uint32_t)&pb_buf_last[0];
|
|
#endif
|
|
if((glb_cfg.p_type == DT_AV_SOF) \
|
|
||(glb_cfg.p_type == FC_DELIM_SOF) \
|
|
||(glb_cfg.p_type == FC_DELIM_SOUND))
|
|
{
|
|
sg_sof_pb_hdr_t sg_sof_pb_hdr;
|
|
|
|
sg_sof_pb_hdr.mac_frame_start = 1;
|
|
sg_sof_pb_hdr.mac_frame_end = 1;
|
|
sg_sof_pb_hdr.seq = 0;
|
|
pb_start.sof_pb_header = *((uint8_t *)&sg_sof_pb_hdr);
|
|
pb_second.sof_pb_header = *((uint8_t *)&sg_sof_pb_hdr);
|
|
pb_third.sof_pb_header = *((uint8_t *)&sg_sof_pb_hdr);
|
|
pb_last.sof_pb_header = *((uint8_t *)&sg_sof_pb_hdr);
|
|
}
|
|
|
|
mpdu_start.next = NULL;
|
|
mpdu_start.pb_list = &pb_start;
|
|
mpdu_start.tx_status = &mpdu_end;
|
|
|
|
/* fill in the beacon content */
|
|
hp_beacon_payload_fixed_header *tmp =
|
|
(hp_beacon_payload_fixed_header *)&pb_buf[0];
|
|
tmp->nid = 0x123456;
|
|
tmp->hm = 0;
|
|
tmp->stei = 1;
|
|
|
|
uint32_t i;
|
|
tmp->bmi.opad[0] = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
for (i = 1; i < sizeof(tmp->bmi.opad)/4; i++) { //init pb_buf with 4 pb
|
|
tmp->bmi.opad[i] = tmp->bmi.opad[0]+i;
|
|
}
|
|
}
|
|
|
|
/* fresh all the cfg */
|
|
void mac_glb_map(uint32_t mac_type, uint32_t pkt_type, uint32_t test_type)
|
|
{
|
|
glb_cfg.m_type = mac_type;
|
|
glb_cfg.p_type = pkt_type;
|
|
glb_cfg.t_type = test_type;
|
|
}
|
|
|
|
/* cli api */
|
|
void mac_tx_handle(uint32_t mac_type, uint32_t pkt_type, uint32_t num)
|
|
{
|
|
uint32_t tx_done = 0;
|
|
uint32_t enq_time = 0, cur_time = 0;
|
|
int64_t time_span = 0;
|
|
bool_t period_done = false;
|
|
|
|
mac_glb_map(mac_type,pkt_type,pkt_type);
|
|
tx_common_init();
|
|
|
|
do {
|
|
enq_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
|
|
mac_tx_mpdu_test(NULL, &mpdu_start);
|
|
do { // wait for tx done and hwq disable
|
|
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;
|
|
}
|
|
tx_done = mpdu_start.tx_status->tx_done;
|
|
period_done = ((uint64_t)time_span < bcn_period_ms * TICKS_MS)?0:1;
|
|
if(!tx_done && period_done){
|
|
iot_printf("[Dtest][tx][timeout] Please check again!\r\n");
|
|
return;
|
|
}
|
|
} while (!tx_done || !period_done);
|
|
|
|
if(--num == 0){
|
|
iot_printf("[Dtest][tx][done] Successfully!\r\n");
|
|
return;
|
|
}
|
|
|
|
} while (true);
|
|
}
|