1027 lines
33 KiB
C
1027 lines
33 KiB
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 "chip_reg_base.h"
|
|
#include "hw_reg_api.h"
|
|
#include "hw_tonemask.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 "mpdu_frame.h"
|
|
#include "ahb_rf.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 "iot_clock.h"
|
|
#include "phy_rx_fd_reg.h"
|
|
#include "phy_txrx_pwr.h"
|
|
#include "plc_protocol.h"
|
|
#include "clk.h"
|
|
#include "iot_wdg.h"
|
|
#include "hal_rx.h"
|
|
#include "tx_entry.h"
|
|
#include "hw_phy_api.h"
|
|
#include "hw_tx.h"
|
|
#include "phy_mix.h"
|
|
#include "phy_chn.h"
|
|
|
|
uint32_t mac_tx_single_mode()
|
|
{
|
|
volatile uint32_t tx_done = 0;
|
|
uint32_t enq_time = 0, cur_time = 0;
|
|
int64_t time_span = 0;
|
|
uint32_t start_time = 0, end_time = 0;
|
|
iot_phy_sts_info_t total_sts = {0};
|
|
uint32_t rate_idx = 0;
|
|
uint32_t band_idx = 0;
|
|
|
|
#if PHY_TX_ALWAYS_EN == 1
|
|
phy_ctrl_tx_always_en(true);
|
|
#endif
|
|
|
|
start_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for cnt*/
|
|
/* beacon or sof transmit */
|
|
do {
|
|
enq_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for tx*/
|
|
/* send the beacon */
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
/* hwq config */
|
|
dt_mac_hwq0_ptr_set((uint32_t)mpdu_start);
|
|
/* multi hwq */
|
|
if (glb_cfg.hwq_num > 1) {
|
|
dt_mac_hwq1_ptr_set((uint32_t)mpdu_start);
|
|
}
|
|
dt_mac_tx_hwq0_re_trig();
|
|
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 = phy_get_tx_done_from_mpdu(mpdu_start);
|
|
} while (!tx_done \
|
|
|| ((uint64_t)time_span < bcn_period_ms * TICKS_MS));
|
|
|
|
/* tx cnt print */
|
|
end_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
time_span = end_time - start_time;
|
|
if (time_span < 0) { // wrap around
|
|
time_span = (0x100000000LL) - start_time + end_time;
|
|
}
|
|
if((uint64_t)time_span > print_tx_period_ms*TICKS_MS){
|
|
phy_sts_get(&total_sts);
|
|
iot_printf("mac tx ok:%d/4s, fc_ok:%d/4s, fc_err:%d/4s,", \
|
|
total_sts.mac_tx_ok_cnt, total_sts.fc_crc_ok_cnt, \
|
|
total_sts.fc_crc_fail_cnt);
|
|
iot_printf("pld_ok:%d/4s, pld fail:%d/4s, sync ok:%d/4s\r\n", \
|
|
total_sts.pld_crc_ok_cnt, total_sts.pld_crc_fail_cnt, \
|
|
total_sts.sync_ok_cnt);
|
|
start_time = end_time;
|
|
#if MAC_TX_TEST_ID == MAC_TX_BURN
|
|
mpdu_start->resv++;
|
|
wdg_feed_dog(1);
|
|
iot_printf("4s cnt %u, feed dog!\r\n",mpdu_start->resv);
|
|
#endif
|
|
/* band info */
|
|
for(rate_idx=0; rate_idx<MAC_BB_MAX_RATE; rate_idx++)
|
|
{
|
|
for(band_idx=0; band_idx<MAX_HW_BAND; band_idx++)
|
|
{
|
|
if(band_cnt[rate_idx][band_idx] != 0){
|
|
iot_printf("[RATE-%d][BAND-%d]:%d\r\n", \
|
|
rate_idx, band_idx, band_cnt[rate_idx][band_idx]);
|
|
band_cnt[rate_idx][band_idx] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} while (true);
|
|
|
|
return 0;
|
|
}
|
|
|
|
extern tonemap_table_entry spg_tonemap_table[];
|
|
extern tonemap_table_entry spg_ext_tonemap_table[];
|
|
extern tonemap_table_entry sg_tonemap_table[];
|
|
extern tonemap_table_entry sg_ext_tonemap_table[];
|
|
extern tonemap_table_entry gp_tonemap_table[];
|
|
uint32_t mac_tx_tmi_scan()
|
|
{
|
|
uint32_t tx_done = 0;
|
|
uint32_t enq_time = 0, cur_time = 0;
|
|
int64_t time_span = 0;
|
|
iot_phy_sts_info_t total_sts = {0};
|
|
uint32_t tmi_retry_cnt = 0;
|
|
|
|
/* pb num for each tmi */
|
|
for(uint32_t j=1; j<5; j++)
|
|
{
|
|
for(uint32_t i=0; i<MAC_EXT_TMI_MAX; i++)
|
|
{
|
|
#if (SUPPORT_SMART_GRID)
|
|
if(PHY_PROTO_TYPE_GET() == PLC_PROTO_TYPE_SG) {
|
|
if(i < 15) {
|
|
/* mask unused TMI in standard table */
|
|
if(sg_tonemap_table[i].pb_size == 0 || \
|
|
j > sg_tonemap_table[i].max_pb_num) {
|
|
continue;
|
|
}
|
|
} else {
|
|
/* mask unused TMI in ext table */
|
|
if(sg_ext_tonemap_table[i-15].pb_size == 0 || \
|
|
j > sg_ext_tonemap_table[i-15].max_pb_num) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
#if IOT_PLC_PHY_BAND_DFT == IOT_SUPPORT_TONE_100_230
|
|
/* total symb num >= 512*/
|
|
if((i == 7 && j >= 2) || (i == 8 && j >= 2) || \
|
|
(i == 3 && j >= 3) || (i == 9 && j >= 3) || \
|
|
(i == 12 && j >= 3) || (i == 0 && j == 4) || \
|
|
(i == 10 && j == 4))
|
|
continue;
|
|
#endif
|
|
} else
|
|
#endif
|
|
#if (SUPPORT_SOUTHERN_POWER_GRID)
|
|
if (PHY_PROTO_TYPE_GET() == PLC_PROTO_TYPE_SPG) {
|
|
if (i < 15) {
|
|
/* mask some unused TMI */
|
|
if (spg_tonemap_table[i].pb_size == 0 || \
|
|
j > spg_tonemap_table[i].max_pb_num) {
|
|
continue;
|
|
}
|
|
} else {
|
|
/* mask unused TMI in ext table */
|
|
if (spg_ext_tonemap_table[i-15].pb_size == 0 || \
|
|
j > spg_ext_tonemap_table[i-15].max_pb_num) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#if (SUPPORT_GREEN_PHY)
|
|
if(PHY_PROTO_TYPE_GET() == PLC_PROTO_TYPE_GP) {
|
|
/* mask some unused TMI */
|
|
if(gp_tonemap_table[i].pb_size == 0 || \
|
|
j > gp_tonemap_table[i].max_pb_num)
|
|
continue;
|
|
/* max tmi */
|
|
if(i >= GP_TMI_MAX)
|
|
continue;
|
|
}
|
|
#endif
|
|
{/* MACRO format */}
|
|
|
|
glb_cfg.tmi = i;
|
|
glb_cfg.pb_num = j;
|
|
tmi_retry_cnt = MAC_TMI_SCAN_CNT;
|
|
while(tmi_retry_cnt--)
|
|
{
|
|
enq_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for tx*/
|
|
/* send the beacon */
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
dt_mac_tx_hwq0_re_trig();
|
|
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 = phy_get_tx_done_from_mpdu(mpdu_start);
|
|
} while (!tx_done \
|
|
|| ((uint64_t)time_span < bcn_period_ms * TICKS_MS));
|
|
}
|
|
|
|
phy_sts_get(&total_sts);
|
|
iot_printf("[TMI-%d][PB-%d]:\r\nmac tx ok:%d/4s,"
|
|
" fc_ok:%d/4s, fc_err:%d/4s,", \
|
|
glb_cfg.tmi, glb_cfg.pb_num, total_sts.mac_tx_ok_cnt, \
|
|
total_sts.fc_crc_ok_cnt, total_sts.fc_crc_fail_cnt);
|
|
iot_printf("pld_ok:%d/4s, pld fail:%d/4s, sync ok:%d/4s\r\n", \
|
|
total_sts.pld_crc_ok_cnt, total_sts.pld_crc_fail_cnt, \
|
|
total_sts.sync_ok_cnt);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
uint32_t mac_tx_bcn_alert()
|
|
{
|
|
uint32_t tmp1 = 0;
|
|
|
|
/* beacon alert */
|
|
do {
|
|
/* beacon period */
|
|
RGF_MAC_WRITE_REG(CFG_BEACON_PERIOD_ADDR, 0xffff0000);//1000ms
|
|
|
|
/* beacon alert ahead */
|
|
RGF_MAC_WRITE_REG(CFG_BEACON_ADDR,1);
|
|
|
|
/* scedule */
|
|
tmp1 = RGF_HWQ_READ_REG(CFG_SCHEDULE_ADDR);
|
|
REG_FIELD_SET(CFG_SCH_EN,tmp1,1);
|
|
REG_FIELD_SET(CFG_SCH_CMD_NUM,tmp1,0);
|
|
REG_FIELD_SET(CFG_SCH_WR_TRIG,tmp1,1);
|
|
REG_FIELD_SET(CFG_SCH_SELF_RECUR_EN,tmp1,1);
|
|
REG_FIELD_SET(SCH_WR_TRIG_ENABLE,tmp1,0);
|
|
REG_FIELD_SET(SCH_CUR_NUM,tmp1,0);
|
|
RGF_HWQ_WRITE_REG(CFG_SCHEDULE_ADDR,tmp1);
|
|
|
|
while(!mac_beacon_alert_flag);
|
|
mac_beacon_alert_flag = false;
|
|
|
|
} while (true);
|
|
|
|
return 0;
|
|
}
|
|
|
|
uint32_t mac_tx_complete()
|
|
{
|
|
int64_t time_span = 0;
|
|
uint32_t start_time = 0, end_time = 0;
|
|
iot_phy_sts_info_t total_sts = {0};
|
|
uint32_t start1_time = 0, end1_time = 0;
|
|
uint32_t rate_idx = 0;
|
|
uint32_t band_idx = 0;
|
|
|
|
/* tx complete */
|
|
start1_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for print*/
|
|
do {
|
|
/* send the beacon/sof */
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
dt_mac_tx_hwq0_re_trig();
|
|
|
|
while(!mac_tx_complete_flag);
|
|
mac_tx_complete_flag = false;
|
|
|
|
start_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for tx*/
|
|
do { // wait for tx done and hwq disable
|
|
end_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
time_span = end_time - start_time;
|
|
if (time_span < 0) { // wrap around
|
|
time_span = (0x100000000LL) - start_time + end_time;
|
|
}
|
|
} while ((uint64_t)time_span < (bcn_period_ms-5) * TICKS_MS);
|
|
|
|
/* tx cnt print */
|
|
end1_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
time_span = end1_time - start1_time;
|
|
if (time_span < 0) { // wrap around
|
|
time_span = (0x100000000LL) - start1_time + end1_time;
|
|
}
|
|
if((uint64_t)time_span > print_tx_period_ms*TICKS_MS){
|
|
phy_sts_get(&total_sts);
|
|
iot_printf("mac tx ok:%d/4s, fc_ok:%d/4s, fc_err:%d/4s,", \
|
|
total_sts.mac_tx_ok_cnt, total_sts.fc_crc_ok_cnt, \
|
|
total_sts.fc_crc_fail_cnt);
|
|
iot_printf("pld_ok:%d/4s, pld fail:%d/4s, sync ok:%d/4s\r\n", \
|
|
total_sts.pld_crc_ok_cnt, total_sts.pld_crc_fail_cnt, \
|
|
total_sts.sync_ok_cnt);
|
|
start1_time = end1_time;
|
|
|
|
/* band info */
|
|
for(rate_idx=0; rate_idx<MAC_BB_MAX_RATE; rate_idx++)
|
|
{
|
|
for(band_idx=0; band_idx<MAX_HW_BAND; band_idx++)
|
|
{
|
|
if(band_cnt[rate_idx][band_idx] != 0){
|
|
iot_printf("[RATE-%d][BAND-%d]:%d\r\n", \
|
|
rate_idx, band_idx, band_cnt[rate_idx][band_idx]);
|
|
band_cnt[rate_idx][band_idx] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} while (true);
|
|
|
|
return 0;
|
|
}
|
|
|
|
uint32_t mac_tx_sched()
|
|
{
|
|
uint32_t tmp1 = 0;
|
|
uint32_t cur_time;
|
|
hw_sched_cmd_t cmd[HW_SCHED_CMD_MAX_CNT];
|
|
|
|
/* schedule: beacon ahead alert interrupt */
|
|
do {
|
|
/* send the beacon */
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
dt_mac_tx_hwq0_re_trig();
|
|
|
|
/* q0 ptr */
|
|
RGF_HWQ_WRITE_REG(CFG_Q0_PTR_ADDR,(uint32_t)(mpdu_start));
|
|
|
|
/* q0 ena */
|
|
RGF_HWQ_WRITE_REG(CFG_Q_ENA_ADDR,0x1);
|
|
|
|
#if MAC_DTEST_PLATFORM == MAC_DTEST_EDA
|
|
/* beacon period */
|
|
RGF_MAC_WRITE_REG(CFG_BEACON_PERIOD_ADDR, 0x320000);//50ms
|
|
|
|
/* beacon alert ahead */
|
|
RGF_MAC_WRITE_REG(CFG_BEACON_ADDR,5);//5ms
|
|
#define END_TIME_UNIT 10
|
|
#elif MAC_DTEST_PLATFORM == MAC_DTEST_FPGA
|
|
/* beacon period */
|
|
RGF_MAC_WRITE_REG(CFG_BEACON_PERIOD_ADDR, 0x3E80000);//1s
|
|
|
|
/* beacon alert ahead */
|
|
RGF_MAC_WRITE_REG(CFG_BEACON_ADDR,100);//100ms
|
|
#define END_TIME_UNIT 10
|
|
#endif
|
|
|
|
cmd[0].t_info.se.end_t=END_TIME_UNIT;//1ms
|
|
cmd[0].t_info.se.start_t=0x0;
|
|
cmd[0].t_info.se.r_flag=0x0;
|
|
cmd[0].t_info.se.s_flag=0x0;
|
|
cmd[0].phase=0x1;
|
|
cmd[0].nb_flag=0x0;
|
|
cmd[0].idle_bit=0x0;
|
|
cmd[0].req_int=0x0;
|
|
cmd[0].rx_rate_mode=RX_MODE_SR;
|
|
cmd[0].tx_q_en_bm=0x1;
|
|
|
|
for(uint32_t i=1;i<HW_SCHED_CMD_MAX_CNT;i++)
|
|
{
|
|
cmd[i]=cmd[i-1];
|
|
cmd[i].t_info.se.end_t=(i+1)*END_TIME_UNIT;
|
|
}
|
|
/* sch ptr */
|
|
RGF_HWQ_WRITE_REG(CFG_SCH_PTR_ADDR,(uint32_t)cmd);
|
|
|
|
cur_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR); //25M 0.04us
|
|
RGF_MAC_WRITE_REG(CFG_BCN_START_NTB_ADDR,cur_time+0x500);
|
|
|
|
/* scedule */
|
|
tmp1 = RGF_HWQ_READ_REG(CFG_SCHEDULE_ADDR);
|
|
REG_FIELD_SET(CFG_SCH_EN,tmp1,1);
|
|
REG_FIELD_SET(CFG_SCH_CMD_NUM,tmp1,100);
|
|
REG_FIELD_SET(CFG_SCH_WR_TRIG,tmp1,1);
|
|
REG_FIELD_SET(CFG_SCH_SELF_RECUR_EN,tmp1,1);
|
|
REG_FIELD_SET(SCH_WR_TRIG_ENABLE,tmp1,0);
|
|
REG_FIELD_SET(SCH_CUR_NUM,tmp1,0);
|
|
RGF_HWQ_WRITE_REG(CFG_SCHEDULE_ADDR,tmp1);
|
|
|
|
while(!mac_beacon_alert_flag);
|
|
mac_beacon_alert_flag = false;
|
|
}while(true);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void mac_tx_mix()
|
|
{
|
|
uint32_t tmp = 0;
|
|
|
|
/* mix en from mac in the future */
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_CTRL_ADDR);
|
|
REG_FIELD_SET(CFG_PHY_TX_LONG_PREAM_EN, tmp, 1);
|
|
RGF_MAC_WRITE_REG(CFG_PHY_CTRL_ADDR,tmp);
|
|
|
|
/* normal tx */
|
|
mac_tx_single_mode();
|
|
}
|
|
|
|
void mac_tx_gp_ext()
|
|
{
|
|
uint32_t tmp = 0;
|
|
uint32_t tx_done = 0;
|
|
uint32_t enq_time = 0, cur_time = 0;
|
|
int64_t time_span = 0;
|
|
iot_phy_sts_info_t total_sts = {0};
|
|
uint32_t tmi_retry_cnt = 0;
|
|
|
|
/* mix en */
|
|
phy_mix_flag_set(true);
|
|
|
|
/* mix en from mac in the future */
|
|
tmp = RGF_MAC_READ_REG(CFG_GP_CTRL_ADDR);
|
|
REG_FIELD_SET(CFG_GP_PB_SIZE_SEL, tmp, 1);
|
|
RGF_MAC_WRITE_REG(CFG_GP_CTRL_ADDR,tmp);
|
|
|
|
tmp = PHY_RX_FD_READ_REG(CFG_BB_SEND_MAC_CTRL_ADDR);
|
|
REG_FIELD_SET(SW_ALWAYS_SEND_FC, tmp, 0);
|
|
PHY_RX_FD_WRITE_REG(CFG_BB_SEND_MAC_CTRL_ADDR, tmp);
|
|
|
|
#if MAC_TMI_ID == MAC_TMI_4 || MAC_TMI_ID == 5
|
|
/* fix symbnum */
|
|
tmp = RGF_TMR_READ_REG(CFG_TX_FC_CTRL_ADDR);
|
|
REG_FIELD_SET(CFG_TX_FC_FL_BY_SW, tmp , 1);
|
|
RGF_TMR_WRITE_REG(CFG_TX_FC_CTRL_ADDR, tmp);
|
|
#endif
|
|
|
|
#if IOT_PLC_PHY_BAND_DFT == IOT_SUPPORT_TONE_80_1228
|
|
phy_rxfd_rate0_det(80,1228);
|
|
phy_rxfd_rate1_det(80,1228);
|
|
#endif
|
|
|
|
/* normal tx for single mode */
|
|
//mac_tx_single_mode();
|
|
|
|
/* pb num for each tmi */
|
|
for(uint32_t j=1; j<5; j++)
|
|
{
|
|
for(uint32_t i=4; i<MAC_EXT_TMI_2; i++)
|
|
{
|
|
if(i == 4 || i == 5)
|
|
{
|
|
/* fix symbnum */
|
|
tmp = RGF_TMR_READ_REG(CFG_TX_FC_CTRL_ADDR);
|
|
REG_FIELD_SET(CFG_TX_FC_FL_BY_SW, tmp , 1);
|
|
RGF_TMR_WRITE_REG(CFG_TX_FC_CTRL_ADDR, tmp);
|
|
}
|
|
else{
|
|
/* fix symbnum */
|
|
tmp = RGF_TMR_READ_REG(CFG_TX_FC_CTRL_ADDR);
|
|
REG_FIELD_SET(CFG_TX_FC_FL_BY_SW, tmp , 0);
|
|
RGF_TMR_WRITE_REG(CFG_TX_FC_CTRL_ADDR, tmp);
|
|
}
|
|
|
|
glb_cfg.tmi = i;
|
|
glb_cfg.pb_num = j;
|
|
tmi_retry_cnt = MAC_TMI_SCAN_CNT;
|
|
while(tmi_retry_cnt--)
|
|
{
|
|
enq_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for tx*/
|
|
/* send the beacon */
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
dt_mac_tx_hwq0_re_trig();
|
|
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 = phy_get_tx_done_from_mpdu(mpdu_start);
|
|
} while (!tx_done \
|
|
|| ((uint64_t)time_span < bcn_period_ms * TICKS_MS));
|
|
}
|
|
|
|
phy_sts_get(&total_sts);
|
|
iot_printf("[TMI-%d][PB-%d]:\r\n"
|
|
"mac tx ok:%d/4s, fc_ok:%d/4s, fc_err:%d/4s,", \
|
|
glb_cfg.tmi, glb_cfg.pb_num, total_sts.mac_tx_ok_cnt, \
|
|
total_sts.fc_crc_ok_cnt, total_sts.fc_crc_fail_cnt);
|
|
iot_printf("pld_ok:%d/4s, pld fail:%d/4s, sync ok:%d/4s\r\n", \
|
|
total_sts.pld_crc_ok_cnt, total_sts.pld_crc_fail_cnt,
|
|
total_sts.sync_ok_cnt);
|
|
}
|
|
}
|
|
}
|
|
|
|
void mac_tx_gp_tone_mask()
|
|
{
|
|
/* check protocol */
|
|
IOT_ASSERT(glb_cfg.m_type == PLC_PROTO_TYPE_GP);
|
|
|
|
const plc_tonemask_table *tonemask_tbl_ptr = \
|
|
&all_mask_tone_mask_table_gp;
|
|
|
|
/* full band */
|
|
init_band_table(&all_mask_band_table_r0_full, \
|
|
HW_FULL_BAND, \
|
|
tonemask_tbl_ptr, \
|
|
all_mask_band_table_r0_full.fc_sym_num, \
|
|
all_mask_band_table_r0_full.start_tone, \
|
|
all_mask_band_table_r0_full.end_tone);
|
|
/* low band */
|
|
init_band_table(&all_mask_band_table_r0_low, \
|
|
HW_LOW_BAND, \
|
|
tonemask_tbl_ptr, \
|
|
all_mask_band_table_r0_low.fc_sym_num, \
|
|
all_mask_band_table_r0_low.start_tone, \
|
|
all_mask_band_table_r0_low.end_tone);
|
|
/* high band */
|
|
init_band_table(&all_mask_band_table_r0_high, \
|
|
HW_HIGH_BAND, \
|
|
tonemask_tbl_ptr, \
|
|
all_mask_band_table_r0_high.fc_sym_num, \
|
|
all_mask_band_table_r0_high.start_tone, \
|
|
all_mask_band_table_r0_high.end_tone);
|
|
|
|
/* full band */
|
|
init_band_table(&all_mask_band_table_r1_full, \
|
|
HW_FULL_BAND, \
|
|
tonemask_tbl_ptr, \
|
|
all_mask_band_table_r1_full.fc_sym_num, \
|
|
all_mask_band_table_r1_full.start_tone, \
|
|
all_mask_band_table_r1_full.end_tone);
|
|
/* low band */
|
|
init_band_table(&all_mask_band_table_r1_low, \
|
|
HW_LOW_BAND, \
|
|
tonemask_tbl_ptr, \
|
|
all_mask_band_table_r1_low.fc_sym_num, \
|
|
all_mask_band_table_r1_low.start_tone, \
|
|
all_mask_band_table_r1_low.end_tone);
|
|
/* high band */
|
|
init_band_table(&all_mask_band_table_r1_high, \
|
|
HW_HIGH_BAND, \
|
|
tonemask_tbl_ptr, \
|
|
all_mask_band_table_r1_high.fc_sym_num, \
|
|
all_mask_band_table_r1_high.start_tone, \
|
|
all_mask_band_table_r1_high.end_tone);
|
|
|
|
/* cal new tone para */
|
|
phy_band_init(PLC_PROTO_TYPE_GP, IOT_SUPPORT_TONE_80_1228);
|
|
/* load new mask */
|
|
phy_tone_mask_amp_phase_tab_load(&all_mask_amp_phase_table, \
|
|
TONE_MASK_ID_GP, \
|
|
PLC_PROTO_TYPE_GP);
|
|
|
|
/* add amplitude mask to optimze mask snr */
|
|
phy_amp_mask_set(214, 214);
|
|
phy_amp_mask_set(226, 226);
|
|
phy_amp_mask_set(749, 749);
|
|
phy_amp_mask_set(735, 736);
|
|
phy_amp_mask_set(420, 421);
|
|
|
|
/* normal tx */
|
|
mac_tx_single_mode();
|
|
}
|
|
|
|
void mac_tx_band_switch()
|
|
{
|
|
/* init */
|
|
phy_reinit( \
|
|
PLC_PROTO_TYPE_SG, \
|
|
IOT_SUPPORT_TONE_80_490, \
|
|
TONE_MASK_ID_NULL, \
|
|
true);
|
|
|
|
/* delay */
|
|
for(uint32_t i = 0; i < 300; i++)
|
|
{
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
dt_mac_tx_hwq0_re_trig();
|
|
for(uint32_t j = 0; j < 50000; j++);
|
|
}
|
|
|
|
/* init */
|
|
phy_reinit( \
|
|
PLC_PROTO_TYPE_SG, \
|
|
IOT_SUPPORT_TONE_100_230, \
|
|
TONE_MASK_ID_NULL, \
|
|
true);
|
|
|
|
/* normal tx */
|
|
mac_tx_single_mode();
|
|
}
|
|
|
|
void phy_tx_td_start_test()
|
|
{
|
|
uint8_t tmi = 0;
|
|
uint32_t rate_idx = 0;
|
|
uint32_t band_idx = 0;
|
|
int64_t time_span = 0;
|
|
uint32_t enq_time = 0, cur_time = 0;
|
|
uint32_t start_time = 0, end_time = 0;
|
|
iot_phy_sts_info_t total_sts = {0};
|
|
volatile uint32_t tx_done = 0;
|
|
|
|
/* tx start */
|
|
start_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for cnt*/
|
|
/* beacon or sof transmit */
|
|
do {
|
|
glb_cfg.tmi = tmi;
|
|
enq_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for tx*/
|
|
/* send the beacon */
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
dt_mac_tx_hwq0_re_trig();
|
|
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 = phy_get_tx_done_from_mpdu(mpdu_start);
|
|
} while (!tx_done \
|
|
|| ((uint64_t)time_span < bcn_period_ms * TICKS_MS));
|
|
|
|
/* update tmi */
|
|
tmi = (tmi > 1) ? 0 : (tmi + 1);
|
|
|
|
/* tx cnt print */
|
|
end_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
time_span = end_time - start_time;
|
|
if (time_span < 0) { // wrap around
|
|
time_span = (0x100000000LL) - start_time + end_time;
|
|
}
|
|
if((uint64_t)time_span > print_tx_period_ms*TICKS_MS){
|
|
/* print sts */
|
|
phy_sts_get(&total_sts);
|
|
iot_printf("[TMI-%d]:\n", glb_cfg.tmi);
|
|
iot_printf("mac tx ok:%d/4s, fc_ok:%d/4s, fc_err:%d/4s,", \
|
|
total_sts.mac_tx_ok_cnt, total_sts.fc_crc_ok_cnt, \
|
|
total_sts.fc_crc_fail_cnt);
|
|
iot_printf("pld_ok:%d/4s, pld fail:%d/4s, sync ok:%d/4s\r\n", \
|
|
total_sts.pld_crc_ok_cnt, total_sts.pld_crc_fail_cnt, \
|
|
total_sts.sync_ok_cnt);
|
|
start_time = end_time;
|
|
/* band info */
|
|
for(rate_idx=0; rate_idx<MAC_BB_MAX_RATE; rate_idx++)
|
|
{
|
|
for(band_idx=0; band_idx<MAX_HW_BAND; band_idx++)
|
|
{
|
|
if(band_cnt[rate_idx][band_idx] != 0){
|
|
iot_printf("[RATE-%d][BAND-%d]:%d\r\n", \
|
|
rate_idx, band_idx, band_cnt[rate_idx][band_idx]);
|
|
band_cnt[rate_idx][band_idx] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} while (true);
|
|
}
|
|
|
|
/*
|
|
* 1 high power bcn and 9 -20dB low power bcn with tmi 3. pkt time span 4-10s.
|
|
* transmit tmi7 pb520 have the same tx power with the same bcn. gree low band.
|
|
*/
|
|
void phy_tx_emc_scan()
|
|
{
|
|
volatile uint32_t tx_done = 0;
|
|
/* bcn time start and end time */
|
|
uint32_t last_time = 0, cur_time = 0;
|
|
int64_t time_span = 0;
|
|
/* broadcast sof start and end time */
|
|
uint32_t start_time = 0, end_time = 0;
|
|
/* broadcast delay */
|
|
uint32_t dly_start_time = 0, dly_end_time = 0;
|
|
/* bcn time span: ms */
|
|
uint16_t bcn_time_period = 2000;
|
|
/* sof time span: ms */
|
|
uint16_t sof_time_period = 1000;
|
|
/* sts print */
|
|
iot_phy_sts_info_t total_sts = {0};
|
|
uint32_t rate_idx = 0;
|
|
uint32_t band_idx = 0;
|
|
/* bcn index */
|
|
uint8_t bcn_index = 0;
|
|
|
|
start_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for cnt*/
|
|
last_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for tx*/
|
|
dly_start_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
/* beacon or sof transmit */
|
|
do {
|
|
cur_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
time_span = cur_time - last_time;
|
|
if (time_span < 0) { // wrap around
|
|
time_span = (0x100000000LL) - last_time + cur_time;
|
|
}
|
|
if((uint64_t)time_span > bcn_time_period*TICKS_MS){
|
|
if(bcn_index < 9) {
|
|
/* -20dB power */
|
|
if(!bcn_index) {
|
|
phy_pwr_adjust_set(127);
|
|
}
|
|
bcn_index++;
|
|
} else {
|
|
bcn_index = 0;
|
|
/* full power */
|
|
phy_pwr_adjust_set(137);
|
|
}
|
|
glb_cfg.tmi = 3;
|
|
glb_cfg.p_type = FC_DELIM_BEACON;
|
|
/* send the beacon */
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
dt_mac_tx_hwq0_re_trig();
|
|
do { // wait for tx done and hwq disable
|
|
tx_done = phy_get_tx_done_from_mpdu(mpdu_start);
|
|
} while (!tx_done);
|
|
last_time = cur_time;
|
|
}
|
|
|
|
/* sof time span */
|
|
end_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
time_span = end_time - start_time;
|
|
if (time_span < 0) { // wrap around
|
|
time_span = (0x100000000LL) - start_time + end_time;
|
|
}
|
|
if((uint64_t)time_span > sof_time_period*TICKS_MS){
|
|
/* update config */
|
|
glb_cfg.tmi = 7;
|
|
glb_cfg.p_type = FC_DELIM_SOF;
|
|
glb_cfg.ack_en = 0;
|
|
/* send the sof */
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
dt_mac_tx_hwq0_re_trig();
|
|
do { // wait for tx done and hwq disable
|
|
tx_done = phy_get_tx_done_from_mpdu(mpdu_start);
|
|
} while (!tx_done);
|
|
start_time = end_time;
|
|
}
|
|
|
|
dly_end_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
time_span = dly_end_time - dly_start_time;
|
|
if (time_span < 0) { // wrap around
|
|
time_span = (0x100000000LL) - dly_start_time + dly_end_time;
|
|
}
|
|
if((uint64_t)time_span > 4000*TICKS_MS){
|
|
/* print tx cnt */
|
|
phy_sts_get(&total_sts);
|
|
iot_printf("mac tx ok:%d/4s, fc_ok:%d/4s, fc_err:%d/4s,", \
|
|
total_sts.mac_tx_ok_cnt, total_sts.fc_crc_ok_cnt, \
|
|
total_sts.fc_crc_fail_cnt);
|
|
iot_printf("pld_ok:%d/4s, pld fail:%d/4s, sync ok:%d/4s\r\n", \
|
|
total_sts.pld_crc_ok_cnt, total_sts.pld_crc_fail_cnt, \
|
|
total_sts.sync_ok_cnt);
|
|
/* band info */
|
|
for(rate_idx=0; rate_idx<MAC_BB_MAX_RATE; rate_idx++)
|
|
{
|
|
for(band_idx=0; band_idx<MAX_HW_BAND; band_idx++)
|
|
{
|
|
if(band_cnt[rate_idx][band_idx] != 0){
|
|
iot_printf("[RATE-%d][BAND-%d]:%d\r\n", \
|
|
rate_idx, band_idx, band_cnt[rate_idx][band_idx]);
|
|
band_cnt[rate_idx][band_idx] = 0;
|
|
}
|
|
}
|
|
}
|
|
dly_start_time = dly_end_time;
|
|
}
|
|
} while (true);
|
|
}
|
|
|
|
void mac_phy_rst_flow()
|
|
{
|
|
int64_t time_span = 0;
|
|
uint32_t enq_time = 0, cur_time = 0;
|
|
uint32_t start_time = 0, end_time = 0;
|
|
uint32_t rate_idx = 0, band_idx = 0;
|
|
iot_phy_sts_info_t total_sts = {0};
|
|
volatile uint32_t tx_done = 0;
|
|
|
|
/* tx start */
|
|
start_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for cnt*/
|
|
/* beacon or sof transmit */
|
|
do {
|
|
enq_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);/*for tx*/
|
|
/* send the beacon */
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
dt_mac_tx_hwq0_re_trig();
|
|
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 = phy_get_tx_done_from_mpdu(mpdu_start);
|
|
} while (!tx_done \
|
|
|| ((uint64_t)time_span < bcn_period_ms * TICKS_MS));
|
|
|
|
/* tx cnt print */
|
|
end_time = RGF_MAC_READ_REG(CFG_RD_NTB_ADDR);
|
|
time_span = end_time - start_time;
|
|
if (time_span < 0) { // wrap around
|
|
time_span = (0x100000000LL) - start_time + end_time;
|
|
}
|
|
if((uint64_t)time_span > print_tx_period_ms*TICKS_MS) {
|
|
/* update band id */
|
|
glb_cfg.band_id = !glb_cfg.band_id;
|
|
/* pre reinit */
|
|
mac_set_sw_idle_mode(1, 1);
|
|
mac_wait_phy_txrx_idle();
|
|
mac_force_phy_tx_ready(1, 1);
|
|
/* wait hwq to be idle */
|
|
mac_tx_wait_all_queue_idle(true, 30);
|
|
/* mac rst hold */
|
|
//warm_rst_mac_hold();
|
|
/* phy reinit */
|
|
phy_reinit(PLC_PROTO_TYPE_SG, glb_cfg.band_id, TONE_MASK_ID_NULL, true);
|
|
/* mac rst release */
|
|
//warm_rst_mac_release();
|
|
/* release idle mode */
|
|
mac_force_phy_tx_ready(0, 0);
|
|
/* must del ena after del force */
|
|
mac_set_sw_idle_mode(1,0);
|
|
mac_set_sw_idle_mode(0,0);
|
|
|
|
/* print sts */
|
|
phy_sts_get(&total_sts);
|
|
iot_printf("[TMI-%d]:\n", glb_cfg.tmi);
|
|
iot_printf("mac tx ok:%d/4s, fc_ok:%d/4s, fc_err:%d/4s,", \
|
|
total_sts.mac_tx_ok_cnt, total_sts.fc_crc_ok_cnt, \
|
|
total_sts.fc_crc_fail_cnt);
|
|
iot_printf("pld_ok:%d/4s, pld fail:%d/4s, sync ok:%d/4s\r\n", \
|
|
total_sts.pld_crc_ok_cnt, total_sts.pld_crc_fail_cnt, \
|
|
total_sts.sync_ok_cnt);
|
|
start_time = end_time;
|
|
/* band info */
|
|
for(rate_idx=0; rate_idx<MAC_BB_MAX_RATE; rate_idx++)
|
|
{
|
|
for(band_idx=0; band_idx<MAX_HW_BAND; band_idx++)
|
|
{
|
|
if(band_cnt[rate_idx][band_idx] != 0){
|
|
iot_printf("[RATE-%d][BAND-%d]:%d\r\n", \
|
|
rate_idx, band_idx, band_cnt[rate_idx][band_idx]);
|
|
band_cnt[rate_idx][band_idx] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} while (true);
|
|
}
|
|
|
|
void mac_tmap_test()
|
|
{
|
|
#if SUPPORT_GREEN_PHY
|
|
/* check protocol */
|
|
IOT_ASSERT(glb_cfg.m_type == PLC_PROTO_TYPE_GP);
|
|
|
|
/* update ext tmi */
|
|
glb_cfg.tmi = MAC_TMI_7;
|
|
|
|
/* tmap common config must behind burst */
|
|
phy_tmap_common_init();
|
|
/* self tmi */
|
|
phy_tmap_self_tmi_set(1);
|
|
/* mac tmap init */
|
|
mac_tmap_init();
|
|
|
|
mac_tx_single_mode();
|
|
#endif
|
|
}
|
|
|
|
void phy_gp_hybrid_mode_test()
|
|
{
|
|
#if SUPPORT_GREEN_PHY
|
|
/* check protocol */
|
|
IOT_ASSERT(glb_cfg.m_type == PLC_PROTO_TYPE_GP);
|
|
|
|
/* update standard tmi */
|
|
glb_cfg.tmi = MAC_TMI_2;
|
|
|
|
/* init gp hybrid mode */
|
|
phy_gp_hybrid_mode_init();
|
|
/* update ppdu mode */
|
|
glb_cfg.ppdu_mode = HW_DESC_PPDU_MODE_HYBRID_1FCSYM;
|
|
|
|
mac_tx_single_mode();
|
|
#endif
|
|
}
|
|
|
|
void phy_gp_burst_mode_test()
|
|
{
|
|
#if SUPPORT_GREEN_PHY
|
|
/* check protocol */
|
|
IOT_ASSERT(glb_cfg.m_type == PLC_PROTO_TYPE_GP);
|
|
|
|
/* update standard tmi */
|
|
glb_cfg.tmi = MAC_TMI_2;
|
|
|
|
/* init gp burst mode */
|
|
phy_gp_burst_init();
|
|
/* update mpdu number */
|
|
glb_cfg.mpdu_cnt = 2;
|
|
/* 20us +/- 0.5 us */
|
|
dtest_mac_bifs_set(5);
|
|
|
|
mac_tx_single_mode();
|
|
#endif
|
|
}
|
|
|
|
void phy_tx_tone_test(void)
|
|
{
|
|
phy_txrx_ovr_set(1,2);
|
|
phy_dfe_tone_cfg(true, 164,0);
|
|
phy_phase_ovr_set(PHY_PHASE_OVR_A, 1, PHY_TXRX_OVR_TX);
|
|
}
|
|
|
|
void mac_tx_start()
|
|
{
|
|
platform_tx_pre_init();
|
|
#if HW_PLATFORM > HW_PLATFORM_SIMU
|
|
#if EDA_SIMU_SUPPORT != 1
|
|
iot_print_config(true);
|
|
|
|
/* serial init */
|
|
dbg_uart_init();
|
|
iot_printf("mac_tx_test begin...\n");
|
|
#endif
|
|
#endif
|
|
|
|
/* mac tx common init interface */
|
|
tx_common_init(IOT_PLC_PHY_BAND_DFT);
|
|
|
|
/* mac rx common init interface */
|
|
rx_common_init(IOT_PLC_PHY_BAND_DFT);
|
|
|
|
#if defined(MODULE_EN)
|
|
if(glb_cfg.t_type == MAC_TX_SCHED_BCN_AHEAD_ALERT)
|
|
iot_printf("[Error]: Must debug mode...\n");
|
|
/* send the beacon/sof */
|
|
mac_tx_mpdu_test(NULL, mpdu_start);
|
|
dt_mac_tx_hwq0_re_trig();
|
|
|
|
while(!mac_tx_complete_flag);
|
|
mac_tx_complete_flag = false;
|
|
|
|
return;
|
|
#endif
|
|
|
|
#if 0
|
|
/* disable intr */
|
|
PHY_WRITE_REG(CFG_BB_INT_EN_0_ADDR, 0);
|
|
PHY_WRITE_REG(CFG_BB_INT_EN_1_ADDR, 0);
|
|
PHY_WRITE_REG(CFG_BB_INT_EN_2_ADDR, 0);
|
|
PHY_WRITE_REG(CFG_BB_INT_EN_3_ADDR, 0);
|
|
#endif
|
|
|
|
switch(MAC_TX_TEST_ID)
|
|
{
|
|
case MAC_TX_BEACON:
|
|
case MAC_TX_SOF:
|
|
mac_tx_single_mode();
|
|
break;
|
|
case MAC_TX_TMI:
|
|
phy_interrupt_init();
|
|
mac_tx_tmi_scan();
|
|
break;
|
|
case MAC_TX_INTR_BCN_ALT:
|
|
mac_tx_bcn_alert();
|
|
break;
|
|
case MAC_TX_INTR_MPDU_COMPLETE:
|
|
mac_tx_complete();
|
|
break;
|
|
case MAC_TX_SCHED_BCN_AHEAD_ALERT:
|
|
mac_tx_sched();
|
|
break;
|
|
case MAC_TX_MIX_MODE:
|
|
mac_tx_mix();
|
|
break;
|
|
case MAC_TX_GP_EXT:
|
|
mac_tx_gp_ext();
|
|
break;
|
|
case MAC_TX_GP_TONE_MASK:
|
|
mac_tx_gp_tone_mask();
|
|
break;
|
|
case MAC_TX_BURN:
|
|
mac_tx_single_mode();
|
|
break;
|
|
case MAC_TX_BAND_SWITCH:
|
|
mac_tx_band_switch();
|
|
break;
|
|
case MAC_TX_PHY_TD_START:
|
|
phy_tx_td_start_test();
|
|
break;
|
|
case MAC_TX_EMC_SCAN:
|
|
phy_tx_emc_scan();
|
|
break;
|
|
case MAC_PHY_RST_FLOW:
|
|
mac_phy_rst_flow();
|
|
break;
|
|
case MAC_SOUND_TMAP:
|
|
mac_tmap_test();
|
|
break;
|
|
case MAC_TX_GP_HYBRID:
|
|
phy_gp_hybrid_mode_test();
|
|
break;
|
|
case PHY_BURST_MODE:
|
|
phy_gp_burst_mode_test();
|
|
break;
|
|
case PHY_TX_TONE:
|
|
phy_tx_tone_test();
|
|
break;
|
|
default:
|
|
while(true);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
#if !MODULE_EN
|
|
|
|
int main(void) {
|
|
mac_tx_start();
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|