fhi_lib/test/test_xran/c_plane_tests.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_lib_wrap.hpp"
  22 #include "xran_common.h"
  23 #include "xran_fh_o_du.h"
  24 #include "ethdi.h"
  25 #include "ethernet.h"
  26 #include "xran_transport.h"
  27 #include "xran_cp_api.h"
  28
  29 #include <stdint.h>
  30
  31 #define DELETE_ARRAY(x)         { if(x) { delete[] x; x = nullptr; } }
  32
  33 #define XRAN_MAX_BUFLEN_EXT11   (MAX_RX_LEN -                                           \
  34                                     (RTE_PKTMBUF_HEADROOM                               \
  35                                      + sizeof(struct xran_ecpri_hdr)                    \
  36                                      + sizeof(struct xran_cp_radioapp_common_header)    \
  37                                      + sizeof(struct xran_cp_radioapp_section1)         \
  38                                      + sizeof(union xran_cp_radioapp_section_ext6)     \
  39                                      + sizeof(union xran_cp_radioapp_section_ext10)    \
  40                                      ))
  41
  42 const std::string module_name = "C-Plane";
  43
  44 const uint8_t m_bitmask[] = { 0x00, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
  45
  46 extern "C"
  47 {
  48
  49 /* wrapper function for performace tests to reset mbuf */
  50 int xran_ut_prepare_cp(struct xran_cp_gen_params *params,
  51                         uint8_t cc_id, uint8_t ant_id, uint8_t seq_id, uint16_t start_sect_id)
  52 {
  53     int ret;
  54     struct rte_mbuf *mbuf;
  55
  56     mbuf = xran_ethdi_mbuf_alloc();
  57     if(mbuf == NULL) {
  58         printf("Failed to allocate buffer!\n");
  59         return (-1);
  60         }
  61
  62     ret = xran_prepare_ctrl_pkt(mbuf, params, cc_id, ant_id, seq_id, start_sect_id);
  63     rte_pktmbuf_free(mbuf);
  64
  65     return (ret);
  66 }
  67
  68 void cput_fh_rx_callback(void *pCallbackTag, xran_status_t status)
  69 {
  70     return;
  71 }
  72
  73 void cput_fh_rx_prach_callback(void *pCallbackTag, xran_status_t status)
  74 {
  75     rte_pause();
  76 }
  77
  78 } /* extern "C" */
  79
  80
  81
  82 class C_plane: public KernelTests
  83 {
  84 private:
  85     struct xran_section_gen_info *m_pSectGenInfo = NULL;
  86     struct xran_section_recv_info *m_pSectResult = NULL;
  87
  88     struct sectinfo {
  89         uint16_t    sectionId;
  90         uint8_t     rb;
  91         uint8_t     symInc;
  92         uint16_t    startPrbc;
  93         uint16_t    numPrbc;
  94         uint16_t    reMask;
  95         uint8_t     numSymbol;
  96         uint16_t    beamId;
  97         int         freqOffset;
  98         std::vector<uint8_t> exts;
  99         };
 100
 101     struct extcfginfo {
 102         int         type;
 103         std::string name;
 104         union {
 105             struct xran_sectionext1_info ext1;
 106             struct xran_sectionext2_info ext2;
 107             struct xran_sectionext3_info ext3;
 108             struct xran_sectionext4_info ext4;
 109             struct xran_sectionext5_info ext5;
 110             struct xran_sectionext6_info ext6;
 111             struct xran_sectionext7_info ext7;
 112             struct xran_sectionext8_info ext8;
 113             struct xran_sectionext9_info ext9;
 114             struct xran_sectionext10_info ext10;
 115             struct xran_sectionext11_info ext11;
 116             } u;
 117         };
 118
 119 protected:
 120     int m_maxSections = 8;  /*  not used */
 121     int m_numSections;
 122
 123     struct rte_mbuf *m_pTestBuffer = nullptr;
 124     struct xran_fh_config  *m_fh_cfg;
 125     struct xran_srs_config *m_srs_cfg;
 126     struct xran_device_ctx m_xran_dev_ctx;
 127
 128     struct xran_cp_gen_params m_params;
 129     struct xran_recv_packet_info m_pktInfo;
 130     struct xran_cp_recv_params m_result;
 131     struct xran_prb_elm *m_prb_ele = nullptr;
 132
 133     struct xran_sectionext1_info m_temp_ext1[XRAN_MAX_PRBS];
 134
 135     uint8_t     m_dir;
 136     std::string m_dirStr;
 137     uint8_t     m_sectionType;
 138
 139     uint8_t     m_ccId, m_antId;
 140     uint8_t     m_seqId;
 141     uint8_t     m_frameId, m_subframeId, m_slotId;
 142     uint8_t     m_symStart;
 143
 144     uint8_t     m_iqWidth, m_compMethod;
 145     uint8_t     m_filterIndex;
 146     uint16_t    m_timeOffset;
 147     uint8_t     m_fftSize;
 148     uint8_t     m_scs;
 149     uint16_t    m_cpLength;
 150
 151     uint32_t    mb_free = MBUF_FREE;
 152
 153     struct sectinfo     *m_sections;
 154     struct extcfginfo   *m_extcfgs;
 155     int                 m_nextcfgs;
 156
 157     uint16_t  m_ext1_dst_len = 0;
 158     int8_t   *m_p_ext1_dst   = nullptr;
 159     int16_t  *m_p_bfw_iq_src = nullptr;
 160
 161     struct xran_sectionext1_info m_ext1;
 162
 163     int         m_antElmTRx;
 164     struct rte_mbuf_ext_shared_info m_extSharedInfo;
 165     uint8_t     *m_pBfwIQ_ext = nullptr;
 166     int16_t     *m_pBfw_src[XRAN_MAX_SET_BFWS];
 167     int16_t     m_pBfw_rx[XRAN_MAX_SET_BFWS][MAX_RX_LEN];
 168     struct xran_ext11_bfw_info m_bfwInfo[XRAN_MAX_SET_BFWS];
 169
 170     void SetUp() override
 171     {
 172         int i, j;
 173         bool flag_skip;
 174         int ext_type;
 175         std::string ext_name;
 176
 177         init_test("C_Plane");
 178
 179         m_dirStr        = get_input_parameter<std::string>("direction");
 180
 181         memset(&m_xran_dev_ctx, 0, sizeof(struct xran_device_ctx));
 182         m_srs_cfg = &m_xran_dev_ctx.srs_cfg;
 183         m_fh_cfg  = &m_xran_dev_ctx.fh_cfg;
 184
 185         if(!m_dirStr.compare("DL")) m_dir = XRAN_DIR_DL;
 186         else if(!m_dirStr.compare("UL")) m_dir = XRAN_DIR_UL;
 187         else FAIL() << "Invalid direction!";
 188
 189         m_sectionType   = get_input_parameter<uint8_t>("section_type");
 190         m_ccId          = get_input_parameter<uint8_t>("cc_id");
 191         m_antId         = get_input_parameter<uint8_t>("ant_id");
 192         m_seqId         = get_input_parameter<uint16_t>("seq_id");
 193
 194         m_frameId       = get_input_parameter<uint8_t>("frame_id");
 195         m_subframeId    = get_input_parameter<uint8_t>("subframe_id");
 196         m_slotId        = get_input_parameter<uint8_t>("slot_id");
 197         m_symStart      = get_input_parameter<uint8_t>("symbol_start");
 198         m_compMethod    = get_input_parameter<uint8_t>("comp_method");
 199         m_iqWidth       = get_input_parameter<uint8_t>("iq_width");
 200
 201         m_xran_dev_ctx.interval_us_local = get_input_parameter<uint8_t>("interval");
 202         m_srs_cfg->eAxC_offset = XRAN_MAX_ANTENNA_NR;//m_antId + 4;
 203         m_fh_cfg->neAxc        = m_antId + 1;
 204
 205         switch(m_sectionType) {
 206             case XRAN_CP_SECTIONTYPE_1:
 207                 m_filterIndex = XRAN_FILTERINDEX_STANDARD;
 208                 break;
 209
 210             case XRAN_CP_SECTIONTYPE_3:
 211                 m_filterIndex   = get_input_parameter<uint8_t>("filter_index");
 212                 m_timeOffset    = get_input_parameter<uint16_t>("time_offset");
 213                 m_fftSize       = get_input_parameter<uint8_t>("fft_size");
 214                 m_scs           = get_input_parameter<uint8_t>("scs");
 215                 m_cpLength      = get_input_parameter<uint16_t>("cp_length");
 216                 break;
 217
 218             default:
 219                 FAIL() << "Invalid Section Type - " << m_sectionType << std::endl;
 220             }
 221
 222         m_numSections   = get_input_subsection_size("sections");
 223         ASSERT_FALSE(m_numSections == 0);
 224
 225         m_sections = new struct sectinfo [m_numSections];
 226         for(i=0; i<m_numSections; i++) {
 227             m_sections[i].sectionId = get_input_parameter<uint16_t>("sections", i, "sectionId");
 228             m_sections[i].rb        = get_input_parameter<uint16_t>("sections", i, "rb");
 229             m_sections[i].symInc    = get_input_parameter<uint16_t>("sections", i, "symInc");
 230             m_sections[i].startPrbc = get_input_parameter<uint16_t>("sections", i, "startPrbc");
 231             m_sections[i].numPrbc   = get_input_parameter<uint16_t>("sections", i, "numPrbc");
 232             m_sections[i].reMask    = get_input_parameter<uint16_t>("sections", i, "reMask");
 233             m_sections[i].numSymbol = get_input_parameter<uint16_t>("sections", i, "numSymbol");
 234             m_sections[i].beamId    = get_input_parameter<uint16_t>("sections", i, "beamId");
 235
 236             switch(m_sectionType) {
 237                 case XRAN_CP_SECTIONTYPE_3:
 238                     m_sections[i].freqOffset    = get_input_parameter<uint16_t>("sections", i, "freqOffset");
 239                     break;
 240                 }
 241
 242             m_sections[i].exts      = get_input_parameter<std::vector<uint8_t>>("sections", i, "exts");
 243             }
 244
 245         /* allocate and prepare required data storage */
 246         m_pSectGenInfo      = new struct xran_section_gen_info [m_numSections];
 247         ASSERT_NE(m_pSectGenInfo, nullptr);
 248         m_params.sections   = m_pSectGenInfo;
 249
 250         m_pSectResult       = new struct xran_section_recv_info [m_numSections];
 251         ASSERT_NE(m_pSectResult, nullptr);
 252         m_result.sections   = m_pSectResult;
 253
 254         /* reading configurations of section extension */
 255         m_nextcfgs = get_input_subsection_size("extensions");
 256         if(m_nextcfgs) {
 257             m_extcfgs = new struct extcfginfo [m_nextcfgs];
 258
 259             flag_skip = false;
 260             for(i=0; i < m_nextcfgs; i++) {
 261                 std::vector<uint16_t> beamIDs;
 262
 263                 ext_type    = get_input_parameter<int>("extensions", i, "type");
 264                 switch(ext_type) {
 265                     case XRAN_CP_SECTIONEXTCMD_1:
 266                     {
 267                         /* if section extension type 1 is present, then ignore other extensions */
 268                         if(i != 0 && m_nextcfgs != 1) {
 269                             std::cout << "### Extension 1 configuration, ignore other extensions !!\n" << std::endl;
 270                             }
 271                         flag_skip = true;
 272                         m_nextcfgs = 1;
 273                         i = 0;
 274                         m_extcfgs[i].u.ext1.bfwCompMeth = get_input_parameter<uint8_t> ("extensions", i, "bfwCompMeth");
 275                         m_extcfgs[i].u.ext1.bfwIqWidth  = get_input_parameter<uint8_t> ("extensions", i, "bfwIqWidth");
 276                         m_antElmTRx                     = get_input_parameter<uint8_t> ("extensions", i, "antelm_trx");
 277                         struct xran_device_ctx * p_xran_dev_ctx = xran_dev_get_ctx();
 278                         p_xran_dev_ctx->numSetBFWs_arr[0] = m_numSections;
 279                         break;
 280                     }
 281                     case XRAN_CP_SECTIONEXTCMD_2:
 282                         m_extcfgs[i].u.ext2.bfAzPtWidth  = get_input_parameter<uint8_t>("extensions", i, "bfAzPtWidth") & 0x7;
 283                         m_extcfgs[i].u.ext2.bfAzPt       = get_input_parameter<uint8_t>("extensions", i, "bfAzPt") & 0xf;
 284                         m_extcfgs[i].u.ext2.bfZePtWidth  = get_input_parameter<uint8_t>("extensions", i, "bfZePtWidth") & 0x7;
 285                         m_extcfgs[i].u.ext2.bfZePt       = get_input_parameter<uint8_t>("extensions", i, "bfZePt") & 0xf;
 286                         m_extcfgs[i].u.ext2.bfAz3ddWidth = get_input_parameter<uint8_t>("extensions", i, "bfAz3ddWidth") & 0x7;
 287                         m_extcfgs[i].u.ext2.bfAz3dd      = get_input_parameter<uint8_t>("extensions", i, "bfAz3dd") & 0xf;
 288                         m_extcfgs[i].u.ext2.bfZe3ddWidth = get_input_parameter<uint8_t>("extensions", i, "bfZe3ddWidth") & 0x7;
 289                         m_extcfgs[i].u.ext2.bfZe3dd      = get_input_parameter<uint8_t>("extensions", i, "bfZe3dd") & 0xf;
 290                         m_extcfgs[i].u.ext2.bfAzSI       = get_input_parameter<uint8_t>("extensions", i, "bfAzSI") & 0x7;
 291                         m_extcfgs[i].u.ext2.bfZeSI       = get_input_parameter<uint8_t>("extensions", i, "bfZeSI") & 0x7;
 292                         break;
 293
 294                     case XRAN_CP_SECTIONEXTCMD_3:
 295                         m_extcfgs[i].u.ext3.codebookIdx  = get_input_parameter<uint8_t> ("extensions", i, "codebookIdx");
 296                         m_extcfgs[i].u.ext3.layerId      = get_input_parameter<uint8_t> ("extensions", i, "layerId") & 0xf;
 297                         m_extcfgs[i].u.ext3.numLayers    = get_input_parameter<uint8_t> ("extensions", i, "numLayers") & 0xf;
 298                         m_extcfgs[i].u.ext3.txScheme     = get_input_parameter<uint8_t> ("extensions", i, "txScheme") & 0xf;
 299                         m_extcfgs[i].u.ext3.crsReMask    = get_input_parameter<uint16_t>("extensions", i, "crsReMask") & 0xfff;
 300                         m_extcfgs[i].u.ext3.crsShift     = get_input_parameter<uint8_t> ("extensions", i, "crsShift") & 0x1;
 301                         m_extcfgs[i].u.ext3.crsSymNum    = get_input_parameter<uint8_t> ("extensions", i, "crsSymNum") & 0xf;
 302                         m_extcfgs[i].u.ext3.numAntPort   = get_input_parameter<uint16_t>("extensions", i, "numAntPort");
 303                         m_extcfgs[i].u.ext3.beamIdAP1    = get_input_parameter<uint16_t>("extensions", i, "beamIdAP1");
 304                         m_extcfgs[i].u.ext3.beamIdAP2    = get_input_parameter<uint16_t>("extensions", i, "beamIdAP2");
 305                         m_extcfgs[i].u.ext3.beamIdAP3    = get_input_parameter<uint16_t>("extensions", i, "beamIdAP3");
 306                         break;
 307
 308                     case XRAN_CP_SECTIONEXTCMD_4:
 309                         m_extcfgs[i].u.ext4.csf          = get_input_parameter<uint8_t> ("extensions", i, "csf") & 0xf;
 310                         m_extcfgs[i].u.ext4.modCompScaler= get_input_parameter<uint16_t>("extensions", i, "modCompScaler") & 0x7fff;
 311                         break;
 312
 313                     case XRAN_CP_SECTIONEXTCMD_5:
 314                         {
 315                         std::vector<uint16_t> csf;
 316                         std::vector<uint16_t> mcScaleReMask;
 317                         std::vector<uint16_t> mcScaleOffset;
 318
 319                         m_extcfgs[i].u.ext5.num_sets     = get_input_parameter<uint8_t>("extensions", i, "num_sets");
 320                         if(m_extcfgs[i].u.ext5.num_sets > XRAN_MAX_MODCOMP_ADDPARMS)
 321                             FAIL() << "Invalid number of sets in extension 5!";
 322
 323                         csf = get_input_parameter<std::vector<uint16_t>>("extensions", i, "csf");
 324                         mcScaleReMask = get_input_parameter<std::vector<uint16_t>>("extensions", i, "mcScaleReMask");
 325                         mcScaleOffset = get_input_parameter<std::vector<uint16_t>>("extensions", i, "mcScaleOffset");
 326
 327                         if(csf.size() != m_extcfgs[i].u.ext5.num_sets
 328                                 || mcScaleReMask.size() != m_extcfgs[i].u.ext5.num_sets
 329                                 || mcScaleOffset.size() != m_extcfgs[i].u.ext5.num_sets)
 330                             FAIL() << "Invalid configuration in extension 5 - different size!";
 331
 332                         for(j=0; j < m_extcfgs[i].u.ext5.num_sets; j++) {
 333                             m_extcfgs[i].u.ext5.mc[j].csf           = csf[j];
 334                             m_extcfgs[i].u.ext5.mc[j].mcScaleReMask = mcScaleReMask[j];
 335                             m_extcfgs[i].u.ext5.mc[j].mcScaleOffset = mcScaleOffset[j];
 336                             }
 337                         }
 338                         break;
 339
 340                     case XRAN_CP_SECTIONEXTCMD_6:
 341                         m_extcfgs[i].u.ext6.rbgSize     = get_input_parameter<uint8_t> ("extensions", i, "rbgSize");
 342                         m_extcfgs[i].u.ext6.rbgMask     = get_input_parameter<uint32_t>("extensions", i, "rbgMask");
 343                         m_extcfgs[i].u.ext6.symbolMask  = get_input_parameter<uint16_t>("extensions", i, "symbolMask");
 344                         break;
 345
 346                     case XRAN_CP_SECTIONEXTCMD_9:
 347                     {
 348                         m_extcfgs[i].u.ext9.technology  = get_input_parameter<uint8_t> ("extensions", i, "technology");
 349                         m_xran_dev_ctx.dssPeriod = 1;
 350                     }
 351                     break;
 352                     case XRAN_CP_SECTIONEXTCMD_10:
 353                         m_extcfgs[i].u.ext10.numPortc   = get_input_parameter<uint8_t> ("extensions", i, "numPortc");
 354                         m_extcfgs[i].u.ext10.beamGrpType= get_input_parameter<uint8_t> ("extensions", i, "beamGrpType");
 355                         switch(m_extcfgs[i].u.ext10.beamGrpType) {
 356                             case XRAN_BEAMGT_COMMON:
 357                             case XRAN_BEAMGT_MATRIXIND:
 358                                 break;
 359                             case XRAN_BEAMGT_VECTORLIST:
 360                                 beamIDs = get_input_parameter<std::vector<uint16_t>>("extensions", i, "beamID");
 361                                 for(j=0; j < m_extcfgs[i].u.ext10.numPortc; j++)
 362                                     m_extcfgs[i].u.ext10.beamID[j] = beamIDs[j];
 363                                 break;
 364                             default:
 365                                 FAIL() << "Invalid Beam Group Type - " << m_extcfgs[i].u.ext10.beamGrpType << std::endl;
 366                             }
 367                         break;
 368
 369                     case XRAN_CP_SECTIONEXTCMD_11:
 370                         {
 371                         int temp;
 372                         /* if section extension type 11 is present, then ignore other extensions */
 373                         if(i != 0 && m_nextcfgs != 1) {
 374                             std::cout << "### Extension 11 configuration, ignore other extensions !!\n" << std::endl;
 375                             }
 376                         flag_skip = true;
 377                         m_nextcfgs = 1;
 378                         i = 0;
 379
 380                         m_extcfgs[i].u.ext11.RAD            = get_input_parameter<uint8_t> ("extensions", i, "RAD");
 381                         m_extcfgs[i].u.ext11.disableBFWs    = get_input_parameter<uint8_t> ("extensions", i, "disableBFWs");
 382                         m_extcfgs[i].u.ext11.numBundPrb     = get_input_parameter<uint8_t> ("extensions", i, "numBundPrb");
 383                         m_extcfgs[i].u.ext11.bfwCompMeth    = get_input_parameter<uint8_t> ("extensions", i, "bfwCompMeth");
 384                         m_extcfgs[i].u.ext11.bfwIqWidth     = get_input_parameter<uint8_t> ("extensions", i, "bfwIqWidth");
 385                         m_extcfgs[i].u.ext11.numSetBFWs     = get_input_parameter<uint8_t> ("extensions", i, "numSetBFWs");
 386                         m_antElmTRx                         = get_input_parameter<uint8_t> ("extensions", i, "antelm_trx");
 387                         beamIDs = get_input_parameter<std::vector<uint16_t>>("extensions", i, "beamID");
 388
 389                         /* Allocate buffers */
 390                         m_extcfgs[i].u.ext11.maxExtBufSize  = MAX_RX_LEN;
 391                         m_pBfwIQ_ext = (uint8_t *)xran_malloc(m_extcfgs[i].u.ext11.maxExtBufSize);
 392                         m_extcfgs[i].u.ext11.pExtBuf = m_pBfwIQ_ext;
 393
 394                         for(j = 0; j < XRAN_MAX_SET_BFWS; j++) {
 395                             m_pBfw_src[j]    = new int16_t [XRAN_MAX_BFW_N];
 396                             memset(m_pBfw_src[j], j+1, XRAN_MAX_BFW_N);
 397                             }
 398
 399                         for(j=0; j < m_extcfgs[i].u.ext11.numSetBFWs; j++) {
 400                             m_bfwInfo[j].pBFWs  = (uint8_t *)(m_pBfw_src[j]);
 401                             m_bfwInfo[j].beamId = beamIDs[j];
 402                             }
 403
 404                         /* Initialize Shared information for external buffer */
 405                         m_extSharedInfo.free_cb     = NULL;
 406                         m_extSharedInfo.fcb_opaque  = NULL;
 407                         rte_mbuf_ext_refcnt_update(&m_extSharedInfo, 0);
 408                         m_extcfgs[i].u.ext11.pExtBufShinfo  = &m_extSharedInfo;
 409
 410                         /* Check all BFWs can be fit with given buffer */
 411                         temp = xran_cp_estimate_max_set_bfws(m_antElmTRx, m_extcfgs[i].u.ext11.bfwIqWidth,
 412                                             m_extcfgs[i].u.ext11.bfwCompMeth, m_extcfgs[i].u.ext11.maxExtBufSize);
 413                         if(m_extcfgs[i].u.ext11.numSetBFWs > temp) {
 414                             FAIL() << "Too many sets of BFWs - " << m_extcfgs[i].u.ext11.numSetBFWs
 415                                     << "  (max " << temp << " for " << m_extcfgs[i].u.ext11.maxExtBufSize << std::endl;
 416                             }
 417
 418                         temp = xran_cp_prepare_ext11_bfws(m_extcfgs[i].u.ext11.numSetBFWs, m_antElmTRx,
 419                                             m_extcfgs[i].u.ext11.bfwIqWidth, m_extcfgs[i].u.ext11.bfwCompMeth,
 420                                             m_pBfwIQ_ext, XRAN_MAX_BUFLEN_EXT11, m_bfwInfo);
 421                         if(temp < 0) {
 422                             FAIL() << "Fail to prepare BFWs!" << std::endl;
 423                             };
 424                         m_extcfgs[i].u.ext11.totalBfwIQLen = temp;
 425                         }
 426                         break;
 427
 428                     default:
 429                        FAIL() << "Invalid Section Type Extension - " << ext_type << std::endl;
 430                        continue;
 431                     } /* switch(ext_type) */
 432
 433                 m_extcfgs[i].type   = ext_type;
 434                 m_extcfgs[i].name   = get_input_parameter<std::string>("extensions", i, "name");
 435
 436                 if(flag_skip)
 437                     break;
 438                 } /* for(i=0; i < m_nextcfgs; i++) */
 439             }
 440         else {
 441             m_extcfgs = nullptr;
 442             }
 443
 444         m_ext1_dst_len      = 9600;
 445         m_p_ext1_dst        = new int8_t [m_ext1_dst_len];
 446         m_p_bfw_iq_src      = new int16_t [9600/2];
 447     }
 448
 449     void TearDown() override
 450     {
 451         if(m_pTestBuffer != nullptr) {
 452             rte_pktmbuf_free(m_pTestBuffer);
 453             m_pTestBuffer = nullptr;
 454             }
 455
 456         if(m_prb_ele){
 457             xran_free(m_prb_ele);
 458             m_prb_ele = nullptr;
 459         }
 460
 461         if(m_pBfwIQ_ext){
 462             xran_free(m_pBfwIQ_ext);
 463             m_pBfwIQ_ext = nullptr;
 464             }
 465         for(int i = 0; i < XRAN_MAX_SET_BFWS; i++) {
 466             DELETE_ARRAY(m_pBfw_src[i]);
 467             }
 468
 469         DELETE_ARRAY(m_extcfgs);
 470         DELETE_ARRAY(m_sections);
 471         DELETE_ARRAY(m_p_bfw_iq_src);
 472         DELETE_ARRAY(m_p_ext1_dst);
 473         DELETE_ARRAY(m_pSectGenInfo);
 474         DELETE_ARRAY(m_pSectResult);
 475     }
 476
 477     int prepare_sections(void);
 478     int prepare_extensions(void);
 479     void verify_sections(void);
 480
 481     void test_ext1(void);
 482 };
 483
 484
 485
 486 int C_plane::prepare_extensions()
 487 {
 488     int i, j, numext, sect_num;
 489     int ext_id;
 490
 491     for(sect_num=0; sect_num < m_numSections; sect_num++) {
 492         numext = 0;
 493
 494         for(i=0; i < (int)(m_sections[sect_num].exts.size()); i++) {
 495
 496             ext_id = m_sections[sect_num].exts[i];
 497             if(ext_id >= m_nextcfgs) {
 498                 std::cout << "Invalid section extension configuration index - " << ext_id << " [max " << m_nextcfgs-1 << "]" << std::endl;
 499                 return (-1);
 500                 }
 501
 502             switch(m_extcfgs[ext_id].type) {
 503                 case XRAN_CP_SECTIONEXTCMD_1:
 504 //                    std::cout << "Skip Extension 1 !!" << std::endl;
 505                     continue;
 506                 case XRAN_CP_SECTIONEXTCMD_2:
 507                     m_params.sections[sect_num].exData[numext].len  = sizeof(m_extcfgs[ext_id].u.ext2);
 508                     m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext2;
 509                     break;
 510                 case XRAN_CP_SECTIONEXTCMD_3:
 511                     m_params.sections[sect_num].exData[numext].len  = sizeof(m_extcfgs[ext_id].u.ext3);
 512                     m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext3;
 513                     break;
 514                 case XRAN_CP_SECTIONEXTCMD_4:
 515                     m_params.sections[sect_num].exData[numext].len  = sizeof(m_extcfgs[ext_id].u.ext4);
 516                     m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext4;
 517                     break;
 518                 case XRAN_CP_SECTIONEXTCMD_5:
 519                     m_params.sections[sect_num].exData[numext].len  = sizeof(m_extcfgs[ext_id].u.ext5);
 520                     m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext5;
 521                     break;
 522                 case XRAN_CP_SECTIONEXTCMD_6:
 523                     m_params.sections[sect_num].exData[numext].len  = sizeof(m_extcfgs[ext_id].u.ext6);
 524                     m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext6;
 525                     break;
 526                 case XRAN_CP_SECTIONEXTCMD_9:
 527                     m_params.sections[sect_num].exData[numext].len  = sizeof(m_extcfgs[ext_id].u.ext9);
 528                     m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext9;
 529                     break;
 530                 case XRAN_CP_SECTIONEXTCMD_10:
 531                     m_params.sections[sect_num].exData[numext].len  = sizeof(m_extcfgs[ext_id].u.ext10);
 532                     m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext10;
 533                     break;
 534                 case XRAN_CP_SECTIONEXTCMD_11:
 535                     m_params.sections[sect_num].exData[numext].len  = sizeof(m_extcfgs[ext_id].u.ext11);
 536                     m_params.sections[sect_num].exData[numext].data = &m_extcfgs[ext_id].u.ext11;
 537
 538                     m_result.sections[sect_num].exts[numext].type   = m_extcfgs[ext_id].type;
 539                     for(j=0 ; j < XRAN_MAX_SET_BFWS; j++)
 540                         m_result.sections[sect_num].exts[numext].u.ext11.bundInfo[j].pBFWs = (uint8_t *)m_pBfw_rx[j];
 541
 542                     break;
 543                 default:
 544                     std::cout << "Invalid Section Extension Type - " << (int)m_extcfgs[ext_id].type << std::endl;
 545                     return (-1);
 546                 } /* switch(m_extcfgs[ext_id].type) */
 547
 548             m_params.sections[sect_num].exData[numext].type = m_extcfgs[ext_id].type;
 549             numext++;
 550             } /* for(i=0; i < m_sections[sect_num].exts.size(); i++) */
 551
 552         if(numext) {
 553             m_params.sections[sect_num].exDataSize  = numext;
 554             m_params.sections[sect_num].info->ef     = 1;
 555             }
 556         else {
 557             m_params.sections[sect_num].exDataSize  = 0;
 558             m_params.sections[sect_num].info->ef     = 0;
 559             }
 560         } /* for(sect_num=0; sect_num < m_numSections; sect_num++) */
 561
 562     return (0);
 563 }
 564
 565
 566 int C_plane::prepare_sections(void)
 567 {
 568   int numsec;
 569
 570
 571     /* Preparing input data for packet generation */
 572     m_params.dir                  = m_dir;
 573     m_params.sectionType          = m_sectionType;
 574
 575     m_params.hdr.filterIdx        = m_filterIndex;
 576     m_params.hdr.frameId          = m_frameId;
 577     m_params.hdr.subframeId       = m_subframeId;
 578     m_params.hdr.slotId           = m_slotId;
 579     m_params.hdr.startSymId       = m_symStart;
 580     m_params.hdr.iqWidth          = XRAN_CONVERT_IQWIDTH(m_iqWidth);
 581     m_params.hdr.compMeth         = m_compMethod;
 582
 583     switch(m_sectionType) {
 584         case XRAN_CP_SECTIONTYPE_1:
 585             break;
 586
 587         case XRAN_CP_SECTIONTYPE_3:
 588             m_params.hdr.timeOffset   = m_timeOffset;
 589             m_params.hdr.fftSize      = m_fftSize;
 590             m_params.hdr.scs          = m_scs;
 591             m_params.hdr.cpLength     = m_cpLength;
 592             break;
 593
 594         default:
 595             return (-1);
 596         }
 597
 598     for(numsec=0; numsec < m_numSections; numsec++) {
 599         m_params.sections[numsec].info = new struct xran_section_info;
 600         m_params.sections[numsec].info->type         = m_params.sectionType;
 601         m_params.sections[numsec].info->startSymId   = m_params.hdr.startSymId;
 602         m_params.sections[numsec].info->iqWidth      = m_params.hdr.iqWidth;
 603         m_params.sections[numsec].info->compMeth     = m_params.hdr.compMeth;
 604         m_params.sections[numsec].info->id           = m_sections[numsec].sectionId;
 605         m_params.sections[numsec].info->rb           = m_sections[numsec].rb;
 606         m_params.sections[numsec].info->symInc       = m_sections[numsec].symInc;
 607         m_params.sections[numsec].info->startPrbc    = m_sections[numsec].startPrbc;
 608         m_params.sections[numsec].info->numPrbc      = m_sections[numsec].numPrbc;
 609         m_params.sections[numsec].info->reMask       = m_sections[numsec].reMask;
 610         m_params.sections[numsec].info->numSymbol    = m_sections[numsec].numSymbol;
 611         m_params.sections[numsec].info->beamId       = m_sections[numsec].beamId;
 612
 613         switch(m_sectionType) {
 614             case XRAN_CP_SECTIONTYPE_1:
 615                 break;
 616
 617             case XRAN_CP_SECTIONTYPE_3:
 618                 m_params.sections[numsec].info->freqOffset   = m_sections[numsec].freqOffset;
 619                 break;
 620
 621             default:
 622                 return (-1);
 623             }
 624     }
 625
 626     m_params.numSections        = numsec;
 627
 628     return (0);
 629 }
 630
 631
 632 void C_plane::verify_sections(void)
 633 {
 634   int i,j,k;
 635
 636     /* Verify the result */
 637     EXPECT_TRUE(m_result.dir            == m_params.dir);
 638     EXPECT_TRUE(m_result.sectionType    == m_params.sectionType);
 639
 640     EXPECT_TRUE(m_result.hdr.filterIdx  == m_params.hdr.filterIdx);
 641     EXPECT_TRUE(m_result.hdr.frameId    == m_params.hdr.frameId);
 642     EXPECT_TRUE(m_result.hdr.subframeId == m_params.hdr.subframeId);
 643     EXPECT_TRUE(m_result.hdr.slotId     == m_params.hdr.slotId);
 644     EXPECT_TRUE(m_result.hdr.startSymId == m_params.hdr.startSymId);
 645     EXPECT_TRUE(m_result.hdr.iqWidth    == m_params.hdr.iqWidth);
 646     EXPECT_TRUE(m_result.hdr.compMeth   == m_params.hdr.compMeth);
 647
 648     switch(m_sectionType) {
 649         case XRAN_CP_SECTIONTYPE_1:
 650             break;
 651
 652         case XRAN_CP_SECTIONTYPE_3:
 653             EXPECT_TRUE(m_result.hdr.fftSize    == m_params.hdr.fftSize);
 654             EXPECT_TRUE(m_result.hdr.scs        == m_params.hdr.scs);
 655             EXPECT_TRUE(m_result.hdr.cpLength   == m_params.hdr.cpLength);
 656             break;
 657
 658         default:
 659             FAIL() << "Invalid Section Type - " << m_sectionType << "\n";
 660         }
 661     // printf("m_result.numSections = %d , m_params.numSections = %d\n",m_result.numSections,i,m_params.numSections);
 662     ASSERT_TRUE(m_result.numSections    == m_params.numSections);
 663     for(i=0; i < m_result.numSections; i++) {
 664         // printf("m_result.sections[%d].info.id = %d , m_params.sections[%d].info.id = %d\n",i,m_result.sections[i].info.id,i,m_params.sections[i].info.id);
 665         EXPECT_TRUE(m_result.sections[i].info.id        == m_params.sections[i].info->id);
 666         EXPECT_TRUE(m_result.sections[i].info.rb        == m_params.sections[i].info->rb);
 667         EXPECT_TRUE(m_result.sections[i].info.symInc    == m_params.sections[i].info->symInc);
 668         EXPECT_TRUE(m_result.sections[i].info.startPrbc == m_params.sections[i].info->startPrbc);
 669         if(m_params.sections[i].info->numPrbc > 255)
 670             EXPECT_TRUE(m_result.sections[i].info.numPrbc == 0);
 671         else
 672             EXPECT_TRUE(m_result.sections[i].info.numPrbc == m_params.sections[i].info->numPrbc);
 673         EXPECT_TRUE(m_result.sections[i].info.numSymbol == m_params.sections[i].info->numSymbol);
 674         EXPECT_TRUE(m_result.sections[i].info.reMask    == m_params.sections[i].info->reMask);
 675         EXPECT_TRUE(m_result.sections[i].info.beamId    == m_params.sections[i].info->beamId);
 676         EXPECT_TRUE(m_result.sections[i].info.ef        == m_params.sections[i].info->ef);
 677
 678         switch(m_sectionType) {
 679             case XRAN_CP_SECTIONTYPE_1:
 680                 break;
 681
 682             case XRAN_CP_SECTIONTYPE_3:
 683                 EXPECT_TRUE(m_result.sections[i].info.freqOffset  == m_params.sections[i].info->freqOffset);
 684                 break;
 685
 686             default:
 687                 FAIL() << "Invalid Section Type - " << m_sectionType << "\n";
 688             }
 689
 690         if(m_params.sections[i].info->ef) {
 691             //printf("[%d] %d ==  %d\n",i,  m_result.sections[i].exDataSize, m_params.sections[i].exDataSize);
 692             EXPECT_TRUE(m_result.sections[i].numExts == m_params.sections[i].exDataSize);
 693
 694             for(j=0; j < (int)m_params.sections[i].exDataSize; j++) {
 695                 EXPECT_TRUE(m_result.sections[i].exts[j].type == m_params.sections[i].exData[j].type);
 696
 697                 switch(m_params.sections[i].exData[j].type) {
 698                     case XRAN_CP_SECTIONEXTCMD_1:
 699                         {
 700                         struct xran_sectionext1_info *ext1_params, *ext1_result;
 701                         int iq_size, parm_size, N;
 702
 703                         ext1_params = (struct xran_sectionext1_info *)m_params.sections[i].exData[j].data;
 704                         ext1_result = &m_result.sections[i].exts[j].u.ext1;
 705
 706                         EXPECT_TRUE(ext1_result->bfwIqWidth  == ext1_params->bfwIqWidth);
 707                         EXPECT_TRUE(ext1_result->bfwCompMeth == ext1_params->bfwCompMeth);
 708
 709                         N = ext1_params->bfwNumber;
 710                         switch(ext1_params->bfwCompMeth) {
 711                             case XRAN_BFWCOMPMETHOD_BLKFLOAT:
 712                                 //printf("[%d, %d] %d ==  %d\n",i, j, ext1_result->bfwCompParam.exponent, ext1_params->bfwCompParam.exponent);
 713                                 EXPECT_TRUE(ext1_result->bfwCompParam.exponent == ext1_params->bfwCompParam.exponent);
 714                                 break;
 715
 716                             case XRAN_BFWCOMPMETHOD_BLKSCALE:
 717                                 EXPECT_TRUE(ext1_result->bfwCompParam.blockScaler == ext1_params->bfwCompParam.blockScaler);
 718                                 break;
 719
 720                             case XRAN_BFWCOMPMETHOD_ULAW:
 721                                 EXPECT_TRUE(ext1_result->bfwCompParam.compBitWidthShift == ext1_params->bfwCompParam.compBitWidthShift);
 722                                 break;
 723
 724                             case XRAN_BFWCOMPMETHOD_BEAMSPACE:
 725                                 parm_size = N>>3; if(N%8) parm_size++; parm_size *= 8;
 726                                 EXPECT_TRUE(std::memcmp(ext1_result->bfwCompParam.activeBeamspaceCoeffMask, ext1_params->bfwCompParam.activeBeamspaceCoeffMask, parm_size));
 727                                 break;
 728                             }
 729
 730                         /* Get the number of BF weights */
 731                         iq_size = N*ext1_params->bfwIqWidth*2;  // total in bits
 732                         parm_size = iq_size>>3;                 // total in bytes (/8)
 733                         if(iq_size%8) parm_size++;              // round up
 734                         EXPECT_FALSE(std::memcmp(ext1_result->p_bfwIQ, ext1_params->p_bfwIQ, parm_size));
 735                         }
 736                         break;
 737
 738                     case XRAN_CP_SECTIONEXTCMD_2:
 739                         {
 740                         struct xran_sectionext2_info *ext2_params, *ext2_result;
 741
 742                         ext2_params = (struct xran_sectionext2_info *)m_params.sections[i].exData[j].data;
 743                         ext2_result = &m_result.sections[i].exts[j].u.ext2;
 744
 745                         if(ext2_params->bfAzPtWidth) {
 746                             EXPECT_TRUE(ext2_result->bfAzPtWidth    == ext2_params->bfAzPtWidth);
 747                             EXPECT_TRUE(ext2_result->bfAzPt         == ext2_params->bfAzPt);
 748                             }
 749
 750                         if(ext2_params->bfZePtWidth) {
 751                             EXPECT_TRUE(ext2_result->bfZePtWidth    == ext2_params->bfZePtWidth);
 752                             EXPECT_TRUE(ext2_result->bfZePt         == ext2_params->bfZePt);
 753                             }
 754                         if(ext2_params->bfAz3ddWidth) {
 755                             EXPECT_TRUE(ext2_result->bfAz3ddWidth   == ext2_params->bfAz3ddWidth);
 756                             EXPECT_TRUE(ext2_result->bfAz3dd        == ext2_params->bfAz3dd);
 757                             }
 758                         if(ext2_params->bfZe3ddWidth) {
 759                             EXPECT_TRUE(ext2_result->bfZe3ddWidth   == ext2_params->bfZe3ddWidth);
 760                             EXPECT_TRUE(ext2_result->bfZe3dd        == ext2_params->bfZe3dd);
 761                             }
 762
 763                         EXPECT_TRUE(ext2_result->bfAzSI == ext2_params->bfAzSI);
 764                         EXPECT_TRUE(ext2_result->bfZeSI == ext2_params->bfZeSI);
 765                         }
 766                         break;
 767
 768                     case XRAN_CP_SECTIONEXTCMD_3:
 769                         {
 770                         struct xran_sectionext3_info *ext3_params, *ext3_result;
 771
 772                         ext3_params = (struct xran_sectionext3_info *)m_params.sections[i].exData[j].data;
 773                         ext3_result = &m_result.sections[i].exts[j].u.ext3;
 774
 775                         EXPECT_TRUE(ext3_result->layerId    == ext3_params->layerId);
 776                         EXPECT_TRUE(ext3_result->codebookIdx== ext3_params->codebookIdx);
 777                         EXPECT_TRUE(ext3_result->numLayers  == ext3_params->numLayers);
 778
 779                         if(ext3_params->layerId == XRAN_LAYERID_0
 780                             || ext3_params->layerId == XRAN_LAYERID_TXD) {   /* first data layer */
 781                             EXPECT_TRUE(ext3_result->txScheme   == ext3_params->txScheme);
 782                             EXPECT_TRUE(ext3_result->crsReMask  == ext3_params->crsReMask);
 783                             EXPECT_TRUE(ext3_result->crsShift   == ext3_params->crsShift);
 784                             EXPECT_TRUE(ext3_result->crsSymNum  == ext3_params->crsSymNum);
 785
 786                             EXPECT_TRUE(ext3_result->numAntPort == ext3_params->numAntPort);
 787
 788                             EXPECT_TRUE(ext3_result->beamIdAP1  == ext3_params->beamIdAP1);
 789
 790                             if(ext3_params->numAntPort == 4) {
 791                                 EXPECT_TRUE(ext3_result->beamIdAP2  == ext3_params->beamIdAP2);
 792                                 EXPECT_TRUE(ext3_result->beamIdAP3  == ext3_params->beamIdAP3);
 793                                 }
 794                             }
 795                         }
 796                         break;
 797
 798                     case XRAN_CP_SECTIONEXTCMD_4:
 799                         {
 800                         struct xran_sectionext4_info *ext4_params, *ext4_result;
 801
 802                         ext4_params = (struct xran_sectionext4_info *)m_params.sections[i].exData[j].data;
 803                         ext4_result = &m_result.sections[i].exts[j].u.ext4;
 804
 805                         EXPECT_TRUE(ext4_result->csf            == ext4_params->csf);
 806                         EXPECT_TRUE(ext4_result->modCompScaler  == ext4_params->modCompScaler);
 807                         }
 808                         break;
 809
 810                     case XRAN_CP_SECTIONEXTCMD_5:
 811                         {
 812                         struct xran_sectionext5_info *ext5_params, *ext5_result;
 813                         int idx;
 814
 815                         ext5_params = (struct xran_sectionext5_info *)m_params.sections[i].exData[j].data;
 816                         ext5_result = &m_result.sections[i].exts[j].u.ext5;
 817
 818                         EXPECT_TRUE(ext5_result->num_sets == ext5_params->num_sets);
 819                         for(idx=0; idx < ext5_params->num_sets; idx++) {
 820                             EXPECT_TRUE(ext5_result->mc[idx].csf == ext5_params->mc[idx].csf);
 821                             EXPECT_TRUE(ext5_result->mc[idx].mcScaleReMask == ext5_params->mc[idx].mcScaleReMask);
 822                             EXPECT_TRUE(ext5_result->mc[idx].mcScaleOffset == ext5_params->mc[idx].mcScaleOffset);
 823                             }
 824                         }
 825                         break;
 826                     case XRAN_CP_SECTIONEXTCMD_6:
 827                         {
 828                         struct xran_sectionext6_info *ext6_params, *ext6_result;
 829
 830                         ext6_params = (struct xran_sectionext6_info *)m_params.sections[i].exData[j].data;
 831                         ext6_result = &m_result.sections[i].exts[j].u.ext6;
 832
 833                         EXPECT_TRUE(ext6_result->rbgSize    == ext6_params->rbgSize);
 834                         EXPECT_TRUE(ext6_result->rbgMask    == ext6_params->rbgMask);
 835                         EXPECT_TRUE(ext6_result->symbolMask == ext6_params->symbolMask);
 836                         }
 837                         break;
 838                     case XRAN_CP_SECTIONEXTCMD_9:
 839                         {
 840                         struct xran_sectionext9_info *ext9_params, *ext9_result;
 841
 842                         ext9_params = (struct xran_sectionext9_info *)m_params.sections[i].exData[j].data;
 843                         ext9_result = &m_result.sections[i].exts[j].u.ext9;
 844                         EXPECT_TRUE(ext9_result->technology    == ext9_params->technology);
 845                         }
 846                         break;
 847                     case XRAN_CP_SECTIONEXTCMD_10:
 848                         {
 849                         struct xran_sectionext10_info *ext10_params, *ext10_result;
 850                         int idx;
 851
 852                         ext10_params = (struct xran_sectionext10_info *)m_params.sections[i].exData[j].data;
 853                         ext10_result = &m_result.sections[i].exts[j].u.ext10;
 854
 855                         EXPECT_TRUE(ext10_result->numPortc      == ext10_params->numPortc);
 856                         EXPECT_TRUE(ext10_result->beamGrpType   == ext10_params->beamGrpType);
 857                         if(ext10_result->beamGrpType == XRAN_BEAMGT_VECTORLIST) {
 858                             for(idx=0; idx < ext10_result->numPortc; idx++)
 859                                 EXPECT_TRUE(ext10_result->beamID[idx] == ext10_params->beamID[idx]);
 860                             }
 861                         }
 862                         break;
 863                     case XRAN_CP_SECTIONEXTCMD_11:
 864                         {
 865                         struct xran_sectionext11_info *ext11_params;
 866                         struct xran_sectionext11_recv_info *ext11_result;
 867
 868                         ext11_params = (struct xran_sectionext11_info *)m_params.sections[i].exData[j].data;
 869                         ext11_result = &m_result.sections[i].exts[j].u.ext11;
 870
 871                         EXPECT_TRUE(ext11_result->RAD           == ext11_params->RAD);
 872                         EXPECT_TRUE(ext11_result->disableBFWs   == ext11_params->disableBFWs);
 873                         EXPECT_TRUE(ext11_result->numBundPrb    == ext11_params->numBundPrb);
 874                         EXPECT_TRUE(ext11_result->bfwCompMeth   == ext11_params->bfwCompMeth);
 875                         EXPECT_TRUE(ext11_result->bfwIqWidth    == ext11_params->bfwIqWidth);
 876
 877
 878                         EXPECT_TRUE(ext11_result->numSetBFWs    == ext11_params->numSetBFWs);
 879                         for(k=0; k < ext11_result->numSetBFWs; k++) {
 880                             EXPECT_TRUE(ext11_result->bundInfo[k].beamId    == m_bfwInfo[k].beamId);
 881 #if 0
 882                             EXPECT_TRUE(ext11_result->bundInfo[k].BFWSize   == ext11_params->BFWSize);
 883
 884                             if(ext11_result->bundInfo[k].pBFWs)
 885                                 EXPECT_TRUE(memcmp(ext11_result->bundInfo[k].pBFWs,
 886                                                 ext11_params->bundInfo[k].pBFWs + ext11_params->bundInfo[k].offset + 4,
 887                                                 ext11_result->bundInfo[k].BFWSize) == 0);
 888                             switch(ext11_result->bfwCompMeth) {
 889                                 case XRAN_BFWCOMPMETHOD_NONE:
 890                                     break;
 891
 892                                 case XRAN_BFWCOMPMETHOD_BLKFLOAT:
 893                                     EXPECT_TRUE(ext11_result->bundInfo[k].bfwCompParam.exponent == ext11_params->bundInfo[k].bfwCompParam.exponent);
 894                                     break;
 895
 896                                 default:
 897                                     FAIL() << "Invalid BfComp method - %d" << ext11_result->bfwCompMeth << std::endl;
 898                                 }
 899 #endif
 900                             }
 901                         }
 902                         break;
 903                     }
 904                 }
 905             }
 906             if(m_params.sections[i].info != NULL)
 907                 delete m_params.sections[i].info;
 908         }
 909
 910     return;
 911 }
 912
 913 void C_plane::test_ext1(void)
 914 {
 915     int i = 0, idRb;
 916     int16_t *ptr = NULL;
 917     int32_t nRbs = 36;
 918     int32_t nAntElm = 64;
 919     int8_t  iqWidth = 9;
 920     int8_t  compMethod = XRAN_COMPMETHOD_BLKFLOAT;
 921     int numSections = 0;
 922     int8_t  *p_ext1_dst  = NULL;
 923     int8_t  *bfw_payload = NULL;
 924     // int32_t expected_len = ((nAntElm/16*4*iqWidth)+1)*nRbs + /* bfwCompParam + IQ = */
 925     //                         sizeof(struct xran_cp_radioapp_section_ext1)*nRbs; /* ext1 Headers */
 926
 927     int16_t  ext_len       = 9600;
 928     int16_t  ext_sec_total = 0;
 929     int8_t * ext_buf       = nullptr;
 930     int8_t * ext_buf_init  = nullptr;
 931
 932     struct xran_section_gen_info* loc_pSectGenInfo = m_params.sections;
 933     struct xran_sectionext1_info m_prep_ext1;
 934     struct xran_cp_radioapp_section_ext1 *p_ext1;
 935     struct xran_cp_radioapp_section1 *p_section1;
 936     struct rte_mbuf_ext_shared_info  share_data;
 937     struct rte_mbuf *mbuf = NULL;
 938     struct xran_sectionext1_info ext1;
 939
 940
 941     nAntElm     = m_antElmTRx;
 942     nRbs        = m_params.sections[0].info->numPrbc;
 943     iqWidth     = m_extcfgs[0].u.ext1.bfwIqWidth;
 944     compMethod  = m_extcfgs[0].u.ext1.bfwCompMeth;
 945     numSections = m_numSections;
 946
 947 #if 0
 948     switch(compMethod) {
 949         case XRAN_BFWCOMPMETHOD_NONE:
 950             // expected_len = (3+1)*nRbs + nAntElm*nRbs*4;
 951             expected_len =  sizeof(struct xran_cp_radioapp_section1)*numSections + \
 952                             sizeof(struct xran_cp_radioapp_section_ext1)*numSections + \
 953                             nAntElm*numSections*4;
 954             break;
 955         case XRAN_BFWCOMPMETHOD_BLKFLOAT:
 956             expected_len = ((nAntElm/16*iqWidth)+1)*numSections*4 + /* bfwCompParam + IQ = */
 957                             sizeof(struct xran_cp_radioapp_section1)*numSections + \
 958                             sizeof(struct xran_cp_radioapp_section_ext1)*numSections; /* ext1 Headers */
 959             break;
 960         default:
 961             FAIL() << "Unsupported Compression Method - " << compMethod << std::endl;
 962         }
 963 #endif
 964
 965     if(loc_pSectGenInfo->info->type == XRAN_CP_SECTIONTYPE_1) {
 966         ext_buf  = ext_buf_init = (int8_t*) xran_malloc(ext_len);
 967         if (ext_buf) {
 968             ptr = m_p_bfw_iq_src;
 969
 970             for (idRb =0; idRb < nRbs*nAntElm*2; idRb++){
 971                 ptr[idRb] = i;
 972                 i++;
 973                 }
 974
 975             ext_buf += (RTE_PKTMBUF_HEADROOM +
 976                        sizeof (struct xran_ecpri_hdr) +
 977                        sizeof(struct xran_cp_radioapp_common_header));
 978
 979             ext_len -= (RTE_PKTMBUF_HEADROOM +
 980                         sizeof(struct xran_ecpri_hdr) +
 981                         sizeof(struct xran_cp_radioapp_common_header));
 982
 983             m_prb_ele = (xran_prb_elm *) xran_malloc(sizeof(struct xran_prb_elm));
 984
 985             m_prb_ele->bf_weight.bfwIqWidth  = iqWidth;
 986             m_prb_ele->bf_weight.bfwCompMeth = compMethod;
 987             m_prb_ele->bf_weight.numSetBFWs  = numSections;
 988             m_prb_ele->bf_weight.nAntElmTRx  = nAntElm;
 989             ext_sec_total = xran_cp_populate_section_ext_1((int8_t *)ext_buf,
 990                                                  ext_len,
 991                                                  m_p_bfw_iq_src,
 992                                                  m_prb_ele);
 993
 994             // ASSERT_TRUE(ext_sec_total == expected_len);
 995             p_ext1_dst = ext_buf;
 996
 997             memset(&m_temp_ext1[0], 0, sizeof (struct xran_sectionext1_info)*XRAN_MAX_PRBS);
 998
 999             idRb = 0;
1000             do {
1001                 p_section1 = (struct xran_cp_radioapp_section1 *)p_ext1_dst;
1002                 p_ext1 = (struct xran_cp_radioapp_section_ext1 *)(p_section1+1);
1003                 bfw_payload = (int8_t*)(p_ext1+1);
1004                 m_pSectGenInfo[idRb].info->id = idRb;
1005
1006                 m_pSectGenInfo[idRb].exData[0].type   = XRAN_CP_SECTIONEXTCMD_1;
1007                 m_pSectGenInfo[idRb].exData[0].len    = sizeof(ext1);
1008
1009
1010                 m_pSectGenInfo[idRb].info->ef = 1;
1011                 m_pSectGenInfo[idRb].exDataSize = 1;
1012
1013                 p_ext1_dst += sizeof(struct xran_cp_radioapp_section1) /*+ sizeof(struct xran_cp_radioapp_section_ext1)*/ + p_ext1->extLen*XRAN_SECTIONEXT_ALIGN;
1014
1015                 m_temp_ext1[0].bfwNumber      = nAntElm;
1016                 m_temp_ext1[0].bfwIqWidth     = iqWidth;
1017                 m_temp_ext1[0].bfwCompMeth    = compMethod;
1018                 m_temp_ext1[0].p_bfwIQ               = (int8_t*)bfw_payload;
1019                 m_temp_ext1[0].bfwIQ_sz              = p_ext1->extLen*XRAN_SECTIONEXT_ALIGN;
1020                 if(compMethod == XRAN_BFWCOMPMETHOD_BLKFLOAT) {
1021                     m_temp_ext1[0].bfwCompParam.exponent = *bfw_payload++ & 0xF;
1022                 }
1023                 m_pSectGenInfo[idRb].exData[0].data   = &m_temp_ext1[0];
1024                 idRb++;
1025             } while(idRb < numSections); /*p_ext1->ef != XRAN_EF_F_LAST);*/
1026
1027             ASSERT_TRUE(idRb == numSections);
1028
1029             mbuf = xran_attach_cp_ext_buf(0, ext_buf_init, ext_buf, ext_sec_total, &share_data);
1030             m_params.numSections    = numSections;
1031
1032             /* Generating C-Plane packet */
1033             ASSERT_TRUE(xran_prepare_ctrl_pkt(/*m_pTestBuffer*/mbuf, &m_params, m_ccId, m_antId, m_seqId, 0) == XRAN_STATUS_SUCCESS);
1034             EXPECT_TRUE(xran_parse_cp_pkt(/*m_pTestBuffer*/mbuf, &m_result, &m_pktInfo, (void *)&m_xran_dev_ctx, &mb_free) == XRAN_STATUS_SUCCESS);
1035             }
1036         else {
1037             FAIL() << "xran_malloc failed\n";
1038             }
1039
1040         /* Verify the result */
1041         verify_sections();
1042
1043         if(ext_buf_init)
1044             xran_free(ext_buf_init);
1045         }
1046 }
1047
1048 /***************************************************************************
1049  * Functional Test cases
1050  ***************************************************************************/
1051
1052 TEST_P(C_plane, CPacketGen)
1053 {
1054     /* Configure section information */
1055     if(prepare_sections() < 0) {
1056         FAIL() << "Invalid Section configuration\n";
1057     }
1058     if(prepare_extensions() < 0) {
1059         FAIL() << "Invalid Section extension configuration\n";
1060     }
1061     if(m_nextcfgs) {
1062         if(m_extcfgs[0].type == XRAN_CP_SECTIONEXTCMD_1) {
1063             test_ext1();
1064             return;
1065         }
1066         else if(m_extcfgs[0].type == XRAN_CP_SECTIONEXTCMD_11) {
1067             /* use large buffer to linearize external buffer for parsing */
1068             m_pTestBuffer = xran_ethdi_mbuf_alloc();
1069             ASSERT_FALSE(m_pTestBuffer == nullptr);
1070
1071             if(xran_cp_attach_ext_buf(m_pTestBuffer,
1072                                 m_pBfwIQ_ext,
1073                                 m_extcfgs[0].u.ext11.maxExtBufSize,
1074                                 &m_extSharedInfo) < 0) {
1075                 rte_pktmbuf_free(m_pTestBuffer);
1076                 m_pTestBuffer = nullptr;
1077                 FAIL() << "Failed to attach external buffer !!\n";
1078             }
1079             rte_mbuf_ext_refcnt_update(&m_extSharedInfo, 0);
1080         }
1081     }
1082
1083     if(m_pTestBuffer == nullptr) {
1084         m_pTestBuffer = xran_ethdi_mbuf_alloc();
1085         ASSERT_FALSE(m_pTestBuffer == nullptr);
1086     }
1087
1088     xran_cp_init_sectiondb((void *)&m_xran_dev_ctx);
1089     /* Generating C-Plane packet */
1090     ASSERT_TRUE(xran_prepare_ctrl_pkt(m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId, 0) == XRAN_STATUS_SUCCESS);
1091
1092     /* Linearize data in the chain of mbufs to parse generated packet*/
1093     ASSERT_TRUE(rte_pktmbuf_linearize(m_pTestBuffer) == 0);
1094     /* Parsing generated packet */
1095     EXPECT_TRUE(xran_parse_cp_pkt(m_pTestBuffer, &m_result, &m_pktInfo, (void *)&m_xran_dev_ctx, &mb_free) == XRAN_STATUS_SUCCESS);
1096
1097     /* Verify the result */
1098     verify_sections();
1099 }
1100
1101 /***************************************************************************
1102  * Performance Test cases
1103  ***************************************************************************/
1104
1105 TEST_P(C_plane, Perf)
1106 {
1107     /* Configure section information */
1108     if(prepare_sections() < 0) {
1109         FAIL() << "Invalid Section configuration\n";
1110         }
1111     if(prepare_extensions() < 0) {
1112         FAIL() << "Invalid Section extension configuration\n";
1113         }
1114
1115     xran_cp_init_sectiondb((void *)&m_xran_dev_ctx);
1116     /* using wrapper function to reset mbuf */
1117     performance("C", module_name,
1118             &xran_ut_prepare_cp, &m_params, m_ccId, m_antId, m_seqId, 0);
1119 }
1120
1121
1122
1123 INSTANTIATE_TEST_CASE_P(UnitTest, C_plane,
1124         testing::ValuesIn(get_sequence(C_plane::get_number_of_cases("C_Plane"))));
1125