fhi_lib/test/test_xran/init_sys_functional.cc

   1 /******************************************************************************
   2 *
   3 *   Copyright (c) 2020 Intel.
   4 *
   5 *   Licensed under the Apache License, Version 2.0 (the "License");
   6 *   you may not use this file except in compliance with the License.
   7 *   You may obtain a copy of the License at
   8 *
   9 *       http://www.apache.org/licenses/LICENSE-2.0
  10 *
  11 *   Unless required by applicable law or agreed to in writing, software
  12 *   distributed under the License is distributed on an "AS IS" BASIS,
  13 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 *   See the License for the specific language governing permissions and
  15 *   limitations under the License.
  16 *
  17 *******************************************************************************/
  18
  19
  20 #include "common.hpp"
  21 #include "xran_fh_o_du.h"
  22 #include "xran_cp_api.h"
  23 #include "xran_lib_wrap.hpp"
  24 #include "xran_common.h"
  25 #include "ethdi.h"
  26
  27 #include <stdint.h>
  28 #include <iostream>
  29 #include <vector>
  30 #include <string>
  31
  32
  33
  34 using namespace std;
  35 const std::string module_name = "init_sys_functional";
  36
  37 extern enum xran_if_state xran_if_current_state;
  38
  39 int32_t physide_sym_call_back(void * param, struct xran_sense_of_time *time)
  40 {
  41     rte_pause();
  42     return 0;
  43 }
  44
  45 int physide_dl_tti_call_back(void * param)
  46 {
  47     rte_pause();
  48     return 0;
  49 }
  50
  51 int physide_ul_half_slot_call_back(void * param)
  52 {
  53     rte_pause();
  54     return 0;
  55 }
  56
  57 int physide_ul_full_slot_call_back(void * param)
  58 {
  59     rte_pause();
  60     return 0;
  61 }
  62
  63 void xran_fh_rx_callback(void *pCallbackTag, xran_status_t status)
  64 {
  65     rte_pause();
  66     return;
  67 }
  68
  69 void xran_fh_bfw_callback(void *pCallbackTag, xran_status_t status)
  70 {
  71     rte_pause();
  72     return;
  73 }
  74
  75 void xran_fh_srs_callback(void *pCallbackTag, xran_status_t status)
  76 {
  77     rte_pause();
  78     return;
  79 }
  80
  81
  82 void xran_fh_rx_prach_callback(void *pCallbackTag, xran_status_t status)
  83 {
  84
  85     rte_pause();
  86 }
  87
  88 class Init_Sys_Check : public KernelTests
  89 {
  90 protected:
  91
  92     void SetUp() override
  93     {
  94         xranlib->Init(0);
  95         xranlib->Open(0, nullptr, nullptr, (void *)xran_fh_rx_callback, (void *)xran_fh_bfw_callback, (void *)xran_fh_rx_prach_callback, (void *)xran_fh_srs_callback);
  96     }
  97
  98     /* It's called after an execution of the each test case.*/
  99     void TearDown() override
 100     {
 101         xranlib->Close();
 102         xranlib->Cleanup();
 103     }
 104
 105 public:
 106
 107     BbuIoBufCtrlStruct sFrontHaulTxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
 108     BbuIoBufCtrlStruct sFrontHaulTxPrbMapBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
 109     BbuIoBufCtrlStruct sFrontHaulRxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
 110     BbuIoBufCtrlStruct sFrontHaulRxPrbMapBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
 111     BbuIoBufCtrlStruct sFHPrachRxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
 112
 113     BbuIoBufCtrlStruct sFHCpRxPrbMapBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
 114     BbuIoBufCtrlStruct sFHCpTxPrbMapBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
 115     /* buffers lists */
 116     struct xran_flat_buffer sFrontHaulTxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_NUM_OF_SYMBOL_PER_SLOT];
 117     struct xran_flat_buffer sFrontHaulTxPrbMapBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
 118     struct xran_flat_buffer sFrontHaulRxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_NUM_OF_SYMBOL_PER_SLOT];
 119     struct xran_flat_buffer sFrontHaulRxPrbMapBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
 120     struct xran_flat_buffer sFHPrachRxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_NUM_OF_SYMBOL_PER_SLOT];
 121
 122     void*    nInstanceHandle[XRAN_PORTS_NUM][XRAN_MAX_SECTOR_NR]; // instance per sector
 123     uint32_t nBufPoolIndex[XRAN_MAX_SECTOR_NR][xranLibWraper::MAX_SW_XRAN_INTERFACE_NUM];
 124     uint16_t nInstanceNum;
 125 };
 126
 127 TEST_P(Init_Sys_Check, Test_Open_Close)
 128 {
 129     struct xran_device_ctx * p_xran_dev_ctx = xran_dev_get_ctx();
 130     /* check stat of lib */
 131     ASSERT_EQ(1, p_xran_dev_ctx->enableCP);
 132     ASSERT_EQ(1, p_xran_dev_ctx->xran2phy_mem_ready);
 133 }
 134
 135 TEST_P(Init_Sys_Check, Test_xran_mm_init)
 136 {
 137     int16_t ret = 0;
 138     ret = xran_mm_init (xranlib->get_xranhandle(), (uint64_t) SW_FPGA_FH_TOTAL_BUFFER_LEN, SW_FPGA_SEGMENT_BUFFER_LEN);
 139     ASSERT_EQ(0, ret);
 140 }
 141
 142 /* this case cannot be tested since memory cannot be initialized twice */
 143 /* memory initialization is moved to the wrapper class */
 144 #if 0
 145 TEST_P(Init_Sys_Check, Test_xran_bm_init_alloc_free)
 146 {
 147     int16_t ret = 0;
 148     void *ptr;
 149     void *mb;
 150     uint32_t nSW_ToFpga_FTH_TxBufferLen   = 13168; /* 273*12*4 + 64*/
 151     int16_t k = 0;
 152
 153
 154     struct xran_buffer_list *pFthTxBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN];
 155     struct xran_buffer_list *pFthTxPrbMapBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN];
 156     struct xran_buffer_list *pFthRxBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN];
 157     struct xran_buffer_list *pFthRxPrbMapBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN];
 158     struct xran_buffer_list *pFthRxRachBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN];
 159     struct xran_buffer_list *pFthRxRachBufferDecomp[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN];
 160
 161     Init_Sys_Check::nInstanceNum = xranlib->get_num_cc();
 162
 163     for (k = 0; k < XRAN_PORTS_NUM; k++) {
 164         ret = xran_sector_get_instances (xranlib->get_xranhandle(), Init_Sys_Check::nInstanceNum, &(Init_Sys_Check::nInstanceHandle[k][0]));
 165         ASSERT_EQ(0, ret);
 166         ASSERT_EQ(1, Init_Sys_Check::nInstanceNum);
 167     }
 168
 169
 170     ret = xran_bm_init(Init_Sys_Check::nInstanceHandle[0][0],
 171                     &Init_Sys_Check::nBufPoolIndex[0][0],
 172                     XRAN_N_FE_BUF_LEN*XRAN_MAX_ANTENNA_NR*XRAN_NUM_OF_SYMBOL_PER_SLOT, nSW_ToFpga_FTH_TxBufferLen);
 173     ASSERT_EQ(0, ret);
 174
 175     ret = xran_bm_allocate_buffer(Init_Sys_Check::nInstanceHandle[0][0], Init_Sys_Check::nBufPoolIndex[0][0],&ptr, &mb);
 176     ASSERT_EQ(0, ret);
 177     ASSERT_NE(ptr, nullptr);
 178     ASSERT_NE(mb, nullptr);
 179
 180     ret = xran_bm_free_buffer(Init_Sys_Check::nInstanceHandle[0][0], ptr, mb);
 181     ASSERT_EQ(0, ret);
 182
 183
 184
 185     for(int i=0; i< xranlib->get_num_cc(); i++)
 186     {
 187         for(int j=0; j<XRAN_N_FE_BUF_LEN; j++)
 188         {
 189             for(int z = 0; z < XRAN_MAX_ANTENNA_NR; z++){
 190                 pFthTxBuffer[i][z][j]     = &(Init_Sys_Check::sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList);
 191                 pFthTxPrbMapBuffer[i][z][j]     = &(Init_Sys_Check::sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList);
 192                 pFthRxBuffer[i][z][j]     = &(Init_Sys_Check::sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList);
 193                 pFthRxPrbMapBuffer[i][z][j]     = &(Init_Sys_Check::sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList);
 194                 pFthRxRachBuffer[i][z][j] = &(Init_Sys_Check::sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList);
 195                 pFthRxRachBufferDecomp[i][z][j] = &(Init_Sys_Check::sFHPrachRxBbuIoBufCtrlDecomp[j][i][z].sBufferList);
 196             }
 197         }
 198     }
 199
 200     if(NULL != Init_Sys_Check::nInstanceHandle[0])
 201     {
 202         for (int i = 0; i < xranlib->get_num_cc(); i++)
 203         {
 204             ret = xran_5g_fronthault_config (Init_Sys_Check::nInstanceHandle[0][i],
 205                 pFthTxBuffer[i],
 206                 pFthTxPrbMapBuffer[i],
 207                 pFthRxBuffer[i],
 208                 pFthRxPrbMapBuffer[i],
 209                 xran_fh_rx_callback,  &pFthRxBuffer[i][0]);
 210
 211             ASSERT_EQ(0, ret);
 212         }
 213
 214         // add prach callback here
 215         for (int i = 0; i < xranlib->get_num_cc(); i++)
 216         {
 217             ret = xran_5g_prach_req(Init_Sys_Check::nInstanceHandle[0][i], pFthRxRachBuffer[i], pFthRxRachBufferDecomp[i],
 218                 xran_fh_rx_prach_callback,&pFthRxRachBuffer[i][0]);
 219             ASSERT_EQ(0, ret);
 220         }
 221     }
 222
 223
 224 }
 225 #endif
 226
 227 TEST_P(Init_Sys_Check, Test_xran_get_common_counters)
 228 {
 229     int16_t ret = 0;
 230     struct xran_common_counters x_counters;
 231
 232     ret = xran_get_common_counters(xranlib->get_xranhandle(), &x_counters);
 233
 234     ASSERT_EQ(0, ret);
 235     ASSERT_EQ(0, x_counters.Rx_on_time);
 236     ASSERT_EQ(0, x_counters.Rx_early);
 237     ASSERT_EQ(0, x_counters.Rx_late);
 238     ASSERT_EQ(0, x_counters.Rx_corrupt);
 239     ASSERT_EQ(0, x_counters.Rx_pkt_dupl);
 240     ASSERT_EQ(0, x_counters.Total_msgs_rcvd);
 241 }
 242
 243 TEST_P(Init_Sys_Check, Test_xran_get_slot_idx)
 244 {
 245 #define NUM_OF_SUBFRAME_PER_FRAME 10
 246     int32_t nNrOfSlotInSf = 1;
 247     int32_t nSfIdx = -1;
 248     uint32_t nFrameIdx;
 249     uint32_t nSubframeIdx;
 250     uint32_t nSlotIdx;
 251     uint64_t nSecond;
 252
 253     uint32_t nXranTime  = xran_get_slot_idx(0, &nFrameIdx, &nSubframeIdx, &nSlotIdx, &nSecond);
 254     nSfIdx = nFrameIdx*NUM_OF_SUBFRAME_PER_FRAME*nNrOfSlotInSf
 255         + nSubframeIdx*nNrOfSlotInSf
 256         + nSlotIdx;
 257
 258     ASSERT_EQ(0, nSfIdx);
 259 }
 260
 261 TEST_P(Init_Sys_Check, Test_xran_reg_physide_cb)
 262 {
 263     struct xran_device_ctx * p_xran_dev_ctx = xran_dev_get_ctx();
 264     int16_t ret = 0;
 265     ret = xran_reg_physide_cb(xranlib->get_xranhandle(), physide_dl_tti_call_back, NULL, 10, XRAN_CB_TTI);
 266     ASSERT_EQ(0,ret);
 267     ASSERT_EQ((long long)physide_dl_tti_call_back, (long long)p_xran_dev_ctx->ttiCb[XRAN_CB_TTI]);
 268     ASSERT_EQ(NULL, p_xran_dev_ctx->TtiCbParam[XRAN_CB_TTI]);
 269     ASSERT_EQ(10, p_xran_dev_ctx->SkipTti[XRAN_CB_TTI]);
 270
 271     ret = xran_reg_physide_cb(xranlib->get_xranhandle(), physide_ul_half_slot_call_back, NULL, 10, XRAN_CB_HALF_SLOT_RX);
 272     ASSERT_EQ(0,ret);
 273     ASSERT_EQ((long long)physide_ul_half_slot_call_back, (long long)p_xran_dev_ctx->ttiCb[XRAN_CB_HALF_SLOT_RX]);
 274     ASSERT_EQ((long long)NULL, (long long)p_xran_dev_ctx->TtiCbParam[XRAN_CB_HALF_SLOT_RX]);
 275     ASSERT_EQ(10, p_xran_dev_ctx->SkipTti[XRAN_CB_HALF_SLOT_RX]);
 276
 277     ret = xran_reg_physide_cb(xranlib->get_xranhandle(), physide_ul_full_slot_call_back, NULL, 10, XRAN_CB_FULL_SLOT_RX);
 278     ASSERT_EQ(0,ret);
 279     ASSERT_EQ((long long)physide_ul_full_slot_call_back,(long long) p_xran_dev_ctx->ttiCb[XRAN_CB_FULL_SLOT_RX]);
 280     ASSERT_EQ(NULL, p_xran_dev_ctx->TtiCbParam[XRAN_CB_FULL_SLOT_RX]);
 281     ASSERT_EQ(10, p_xran_dev_ctx->SkipTti[XRAN_CB_FULL_SLOT_RX]);
 282
 283 }
 284
 285 TEST_P(Init_Sys_Check, Test_xran_reg_sym_cb){
 286     int16_t ret = 0;
 287     ret = xran_reg_sym_cb(xranlib->get_xranhandle(),  physide_sym_call_back, NULL, NULL, 11, XRAN_CB_SYM_RX_WIN_END);
 288     ASSERT_EQ(0,ret);
 289 }
 290
 291 TEST_P(Init_Sys_Check, Test_xran_mm_destroy){
 292     int16_t ret = 0;
 293     ret = xran_mm_destroy(xranlib->get_xranhandle());
 294     ASSERT_EQ(0,ret);
 295 }
 296
 297 TEST_P(Init_Sys_Check, Test_xran_start_stop){
 298     int16_t ret = 0;
 299     ASSERT_EQ(XRAN_STOPPED, xran_if_current_state);
 300     ret = xranlib->Start();
 301     ASSERT_EQ(0,ret);
 302     ASSERT_EQ(XRAN_RUNNING, xran_if_current_state);
 303     ret = xranlib->Stop();
 304     ASSERT_EQ(0,ret);
 305     ASSERT_EQ(XRAN_STOPPED, xran_if_current_state);
 306 }
 307
 308 INSTANTIATE_TEST_CASE_P(UnitTest, Init_Sys_Check,
 309                         testing::ValuesIn(get_sequence(Init_Sys_Check::get_number_of_cases("init_sys_functional"))));
 310
 311
 312