1 /******************************************************************************
\r
3 * Copyright (c) 2019 Intel.
\r
5 * Licensed under the Apache License, Version 2.0 (the "License");
\r
6 * you may not use this file except in compliance with the License.
\r
7 * You may obtain a copy of the License at
\r
9 * http://www.apache.org/licenses/LICENSE-2.0
\r
11 * Unless required by applicable law or agreed to in writing, software
\r
12 * distributed under the License is distributed on an "AS IS" BASIS,
\r
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
14 * See the License for the specific language governing permissions and
\r
15 * limitations under the License.
\r
17 *******************************************************************************/
\r
20 #include "common.hpp"
\r
21 #include "xran_lib_wrap.hpp"
\r
22 #include "xran_common.h"
\r
23 #include "xran_fh_o_du.h"
\r
25 #include "ethernet.h"
\r
26 #include "xran_transport.h"
\r
27 #include "xran_cp_api.h"
\r
32 const std::string module_name = "C-Plane";
\r
34 const uint8_t m_bitmask[] = { 0x00, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
\r
39 /* wrapper function for performace tests to reset mbuf */
\r
40 int xran_ut_prepare_cp(struct rte_mbuf *mbuf, struct xran_cp_gen_params *params,
\r
41 uint8_t cc_id, uint8_t ant_id, uint8_t seq_id)
\r
43 rte_pktmbuf_reset(mbuf);
\r
44 return(xran_prepare_ctrl_pkt(mbuf, params, cc_id, ant_id, seq_id));
\r
48 void cput_fh_rx_callback(void *pCallbackTag, xran_status_t status)
\r
53 void cput_fh_rx_prach_callback(void *pCallbackTag, xran_status_t status)
\r
62 class C_plane: public KernelTests
\r
65 struct xran_section_gen_info *m_pSectGenInfo = NULL;
\r
66 struct xran_section_gen_info *m_pSectResult = NULL;
\r
70 int m_maxSections = 8; /* not used */
\r
73 struct rte_mbuf *m_pTestBuffer;
\r
75 struct xran_cp_gen_params m_params;
\r
76 struct xran_recv_packet_info m_pktInfo;
\r
77 struct xran_cp_gen_params m_result;
\r
80 std::string m_dirStr;
\r
81 uint8_t m_sectionType;
\r
83 uint8_t m_ccId, m_antId;
\r
85 uint8_t m_frameId, m_subframeId, m_slotId;
\r
86 uint8_t m_symStart, m_symNum;
\r
87 uint16_t *m_prbStart = NULL, *m_prbNum = NULL;
\r
89 uint8_t m_iqWidth, m_compMethod;
\r
91 uint16_t m_reMask = 0xfff;
\r
92 uint16_t m_sectionId;
\r
93 uint8_t m_filterIndex;
\r
94 uint16_t m_timeOffset;
\r
97 uint16_t m_cpLength;
\r
100 uint16_t m_ext1_dst_len = 0;
\r
101 int8_t *m_p_ext1_dst = NULL;
\r
102 int16_t *m_p_bfw_iq_src = NULL;
\r
104 struct xran_sectionext1_info m_ext1;
\r
105 struct xran_sectionext2_info m_ext2;
\r
106 struct xran_sectionext4_info m_ext4;
\r
107 struct xran_sectionext5_info m_ext5;
\r
109 int16_t m_bfwIQ[XRAN_MAX_BFW_N*2];
\r
112 void SetUp() override
\r
116 init_test("C_Plane");
\r
118 m_numSections = get_input_parameter<int>("num_sections");
\r
119 ASSERT_FALSE(m_numSections == 0);
\r
121 m_dirStr = get_input_parameter<std::string>("direction");
\r
123 if(!m_dirStr.compare("DL")) m_dir = XRAN_DIR_DL;
\r
124 else if(!m_dirStr.compare("UL")) m_dir = XRAN_DIR_UL;
\r
125 else FAIL() << "Invalid direction!";
\r
127 m_sectionType = get_input_parameter<uint8_t>("section_type");
\r
128 m_ccId = get_input_parameter<uint8_t>("cc_id");
\r
129 m_antId = get_input_parameter<uint8_t>("ant_id");
\r
130 m_seqId = get_input_parameter<uint16_t>("seq_id");
\r
132 m_frameId = get_input_parameter<uint8_t>("frame_id");
\r
133 m_subframeId = get_input_parameter<uint8_t>("subframe_id");
\r
134 m_slotId = get_input_parameter<uint8_t>("slot_id");
\r
135 m_symStart = get_input_parameter<uint8_t>("symbol_start");
\r
136 m_compMethod = get_input_parameter<uint8_t>("comp_method");
\r
137 m_iqWidth = get_input_parameter<uint8_t>("iq_width");
\r
139 m_sectionId = get_input_parameter<uint8_t>("section_id");
\r
140 m_symNum = get_input_parameter<uint8_t>("symbol_num");
\r
141 m_beamId = get_input_parameter<uint16_t>("beam_id");
\r
143 /* reading configurations of start prb and the number of prbs */
\r
144 std::vector<int> prbstart = get_input_parameter<std::vector<int>>("prb_start");
\r
145 std::vector<int> prbnum = get_input_parameter<std::vector<int>>("prb_num");
\r
146 /* number of sections and the pair of start/number of prb shall be matched */
\r
147 ASSERT_TRUE((m_numSections == prbstart.size())
\r
148 && (m_numSections == prbnum.size())
\r
149 && (prbstart.size() == prbnum.size()));
\r
151 m_prbStart = new uint16_t [m_numSections];
\r
152 m_prbNum = new uint16_t [m_numSections];
\r
153 for(i=0; i < m_numSections; i++) {
\r
154 m_prbStart[i] = prbstart[i];
\r
155 m_prbNum[i] = prbnum[i];
\r
158 switch(m_sectionType) {
\r
159 case XRAN_CP_SECTIONTYPE_1:
\r
160 m_filterIndex = XRAN_FILTERINDEX_STANDARD;
\r
163 case XRAN_CP_SECTIONTYPE_3:
\r
164 m_filterIndex = get_input_parameter<uint8_t>("filter_index");
\r
165 m_timeOffset = get_input_parameter<uint16_t>("time_offset");
\r
166 m_fftSize = get_input_parameter<uint8_t>("fft_size");
\r
167 m_scs = get_input_parameter<uint8_t>("scs");
\r
168 m_cpLength = get_input_parameter<uint16_t>("cp_length");
\r
169 m_freqOffset = get_input_parameter<int>("freq_offset");
\r
173 FAIL() << "Invalid Section Type - " << m_sectionType << "\n";
\r
176 /* allocate and prepare required data storage */
\r
177 m_pSectGenInfo = new struct xran_section_gen_info [m_numSections];
\r
178 ASSERT_NE(m_pSectGenInfo, nullptr);
\r
179 m_params.sections = m_pSectGenInfo;
\r
181 m_pSectResult = new struct xran_section_gen_info [m_numSections];
\r
182 ASSERT_NE(m_pSectResult, nullptr);
\r
183 m_result.sections = m_pSectResult;
\r
185 m_ext1_dst_len = 9600;
\r
186 m_p_ext1_dst = new int8_t [m_ext1_dst_len];
\r
187 m_p_bfw_iq_src = new int16_t [9600/2];
\r
189 /* allocating an mbuf for packet generatrion */
\r
190 m_pTestBuffer = xran_ethdi_mbuf_alloc();
\r
192 ASSERT_FALSE(m_pTestBuffer == NULL);
\r
195 void TearDown() override
\r
199 if(m_pTestBuffer != NULL)
\r
200 rte_pktmbuf_free(m_pTestBuffer);
\r
203 delete[] m_prbStart;
\r
208 delete[] m_p_bfw_iq_src;
\r
211 delete[] m_p_ext1_dst;
\r
214 delete[] m_pSectGenInfo;
\r
216 if(m_pSectResult) {
\r
217 delete[] m_pSectResult;
\r
222 int prepare_sections(bool extflag);
\r
223 int prepare_extensions(int sect_num);
\r
224 void verify_sections(void);
\r
230 int C_plane::prepare_extensions(int sect_num)
\r
239 m_ext1.bfwNumber = 4*N; // 4 ant, 8 UEs
\r
240 m_ext1.bfwiqWidth = 16;
\r
241 m_ext1.bfwCompMeth = XRAN_BFWCOMPMETHOD_NONE;
\r
242 /* XRAN_BFWCOMPMETHOD_BLKFLOAT
\r
243 * XRAN_BFWCOMPMETHOD_BLKSCALE
\r
244 * XRAN_BFWCOMPMETHOD_ULAW
\r
245 * XRAN_BFWCOMPMETHOD_BEAMSPACE
\r
247 m_ext1.p_bfwIQ = m_bfwIQ;
\r
249 switch (m_ext1.bfwCompMeth) {
\r
250 case XRAN_BFWCOMPMETHOD_BLKFLOAT:
\r
251 m_ext1.bfwCompParam.exponent = 0xa;
\r
253 case XRAN_BFWCOMPMETHOD_BLKSCALE:
\r
254 m_ext1.bfwCompParam.blockScaler = 0xa5;
\r
256 case XRAN_BFWCOMPMETHOD_ULAW:
\r
257 m_ext1.bfwCompParam.compBitWidthShift = 0x55;
\r
258 case XRAN_BFWCOMPMETHOD_BEAMSPACE:
\r
260 m_ext1.bfwCompParam.activeBeamspaceCoeffMask[i] = 0xa0 + i;
\r
264 for(i=0; i<N*4; i++) {
\r
265 m_ext1.p_bfwIQ[i*2] = 0xcafe;
\r
266 m_ext1.p_bfwIQ[i*2+1] = 0xbeef;
\r
270 m_ext2.bfAzPtWidth = 7;
\r
271 m_ext2.bfAzPt = 0x55 & m_bitmask[m_ext2.bfAzPtWidth];
\r
272 m_ext2.bfZePtWidth = 7;
\r
273 m_ext2.bfZePt = 0xaa & m_bitmask[m_ext2.bfAzPtWidth];
\r
274 m_ext2.bfAz3ddWidth = 7;
\r
275 m_ext2.bfAz3dd = 0x5a & m_bitmask[m_ext2.bfAzPtWidth];
\r
276 m_ext2.bfZe3ddWidth = 7;
\r
277 m_ext2.bfZe3dd = 0xa5 & m_bitmask[m_ext2.bfAzPtWidth];
\r
278 m_ext2.bfAzSI = 0x2 & m_bitmask[3];
\r
279 m_ext2.bfZeSI = 0x5 & m_bitmask[3];
\r
283 m_ext4.modCompScaler = 0x5aa5;
\r
286 m_ext5.num_sets = 2;
\r
287 for(i=0; i<m_ext5.num_sets; i++) {
\r
288 m_ext5.mc[i].csf = i%2;
\r
289 m_ext5.mc[i].mcScaleReMask = 0xa5a + i;
\r
290 m_ext5.mc[i].mcScaleOffset = 0x5a5a + i;
\r
295 m_params.sections[sect_num].exData[numext].type = XRAN_CP_SECTIONEXTCMD_1;
\r
296 m_params.sections[sect_num].exData[numext].len = sizeof(m_ext1);
\r
297 m_params.sections[sect_num].exData[numext].data = &m_ext1;
\r
300 m_params.sections[sect_num].exData[numext].type = XRAN_CP_SECTIONEXTCMD_2;
\r
301 m_params.sections[sect_num].exData[numext].len = sizeof(m_ext2);
\r
302 m_params.sections[sect_num].exData[numext].data = &m_ext2;
\r
305 m_params.sections[sect_num].exData[numext].type = XRAN_CP_SECTIONEXTCMD_4;
\r
306 m_params.sections[sect_num].exData[numext].len = sizeof(m_ext4);
\r
307 m_params.sections[sect_num].exData[numext].data = &m_ext4;
\r
310 m_params.sections[sect_num].exData[numext].type = XRAN_CP_SECTIONEXTCMD_5;
\r
311 m_params.sections[sect_num].exData[numext].len = sizeof(m_ext5);
\r
312 m_params.sections[sect_num].exData[numext].data = &m_ext5;
\r
315 m_params.sections[sect_num].exDataSize = numext;
\r
320 int C_plane::prepare_sections(bool extflag)
\r
325 /* Preparing input data for packet generation */
\r
326 m_params.dir = m_dir;
\r
327 m_params.sectionType = m_sectionType;
\r
329 m_params.hdr.filterIdx = m_filterIndex;
\r
330 m_params.hdr.frameId = m_frameId;
\r
331 m_params.hdr.subframeId = m_subframeId;
\r
332 m_params.hdr.slotId = m_slotId;
\r
333 m_params.hdr.startSymId = m_symStart;
\r
334 m_params.hdr.iqWidth = XRAN_CONVERT_IQWIDTH(m_iqWidth);
\r
335 m_params.hdr.compMeth = m_compMethod;
\r
337 switch(m_sectionType) {
\r
338 case XRAN_CP_SECTIONTYPE_1:
\r
341 case XRAN_CP_SECTIONTYPE_3:
\r
342 m_params.hdr.timeOffset = m_timeOffset;
\r
343 m_params.hdr.fftSize = m_fftSize;
\r
344 m_params.hdr.scs = m_scs;
\r
345 m_params.hdr.cpLength = m_cpLength;
\r
352 for(numsec=0; numsec < m_numSections; numsec++) {
\r
353 m_params.sections[numsec].info.type = m_params.sectionType; // for database
\r
354 m_params.sections[numsec].info.startSymId = m_params.hdr.startSymId; // for database
\r
355 m_params.sections[numsec].info.iqWidth = m_params.hdr.iqWidth; // for database
\r
356 m_params.sections[numsec].info.compMeth = m_params.hdr.compMeth; // for database
\r
357 m_params.sections[numsec].info.id = m_sectionId++;
\r
358 m_params.sections[numsec].info.rb = XRAN_RBIND_EVERY;
\r
359 m_params.sections[numsec].info.symInc = XRAN_SYMBOLNUMBER_NOTINC;
\r
360 m_params.sections[numsec].info.startPrbc = m_prbStart[numsec];
\r
361 m_params.sections[numsec].info.numPrbc = m_prbNum[numsec];
\r
362 m_params.sections[numsec].info.numSymbol = m_symNum;
\r
363 m_params.sections[numsec].info.reMask = m_reMask;
\r
364 m_params.sections[numsec].info.beamId = m_beamId;
\r
365 switch(m_sectionType) {
\r
366 case XRAN_CP_SECTIONTYPE_1:
\r
369 case XRAN_CP_SECTIONTYPE_3:
\r
370 m_params.sections[numsec].info.freqOffset = m_freqOffset;
\r
377 /* section extension */
\r
378 if(/*extflag == true*/0) {
\r
379 m_params.sections[numsec].info.ef = 1;
\r
380 prepare_extensions(numsec);
\r
383 m_params.sections[numsec].info.ef = 0;
\r
384 m_params.sections[numsec].exDataSize = 0;
\r
388 m_params.numSections = numsec;
\r
394 void C_plane::verify_sections(void)
\r
398 /* Verify the result */
\r
399 EXPECT_TRUE(m_result.dir == m_params.dir);
\r
400 EXPECT_TRUE(m_result.sectionType == m_params.sectionType);
\r
402 EXPECT_TRUE(m_result.hdr.filterIdx == m_params.hdr.filterIdx);
\r
403 EXPECT_TRUE(m_result.hdr.frameId == m_params.hdr.frameId);
\r
404 EXPECT_TRUE(m_result.hdr.subframeId == m_params.hdr.subframeId);
\r
405 EXPECT_TRUE(m_result.hdr.slotId == m_params.hdr.slotId);
\r
406 EXPECT_TRUE(m_result.hdr.startSymId == m_params.hdr.startSymId);
\r
407 EXPECT_TRUE(m_result.hdr.iqWidth == m_params.hdr.iqWidth);
\r
408 EXPECT_TRUE(m_result.hdr.compMeth == m_params.hdr.compMeth);
\r
410 switch(m_sectionType) {
\r
411 case XRAN_CP_SECTIONTYPE_1:
\r
414 case XRAN_CP_SECTIONTYPE_3:
\r
415 EXPECT_TRUE(m_result.hdr.fftSize == m_params.hdr.fftSize);
\r
416 EXPECT_TRUE(m_result.hdr.scs == m_params.hdr.scs);
\r
417 EXPECT_TRUE(m_result.hdr.cpLength == m_params.hdr.cpLength);
\r
421 FAIL() << "Invalid Section Type - " << m_sectionType << "\n";
\r
424 ASSERT_TRUE(m_result.numSections == m_params.numSections);
\r
425 for(i=0; i < m_result.numSections; i++) {
\r
426 EXPECT_TRUE(m_result.sections[i].info.id == m_params.sections[i].info.id);
\r
427 EXPECT_TRUE(m_result.sections[i].info.rb == XRAN_RBIND_EVERY);
\r
428 EXPECT_TRUE(m_result.sections[i].info.symInc == XRAN_SYMBOLNUMBER_NOTINC);
\r
429 EXPECT_TRUE(m_result.sections[i].info.startPrbc == m_params.sections[i].info.startPrbc);
\r
430 EXPECT_TRUE(m_result.sections[i].info.numPrbc == m_params.sections[i].info.numPrbc);
\r
431 EXPECT_TRUE(m_result.sections[i].info.numSymbol == m_params.sections[i].info.numSymbol);
\r
432 EXPECT_TRUE(m_result.sections[i].info.reMask == m_params.sections[i].info.reMask);
\r
433 EXPECT_TRUE(m_result.sections[i].info.beamId == m_params.sections[i].info.beamId);
\r
434 EXPECT_TRUE(m_result.sections[i].info.ef == m_params.sections[i].info.ef);
\r
436 switch(m_sectionType) {
\r
437 case XRAN_CP_SECTIONTYPE_1:
\r
440 case XRAN_CP_SECTIONTYPE_3:
\r
441 EXPECT_TRUE(m_result.sections[i].info.freqOffset == m_params.sections[i].info.freqOffset);
\r
445 FAIL() << "Invalid Section Type - " << m_sectionType << "\n";
\r
448 if(m_params.sections[i].info.ef) {
\r
449 // printf("[%d] %d == %d\n",i, m_result.sections[i].exDataSize, m_params.sections[i].exDataSize);
\r
450 EXPECT_TRUE(m_result.sections[i].exDataSize == m_params.sections[i].exDataSize);
\r
452 for(j=0; j < m_params.sections[i].exDataSize; j++) {
\r
453 EXPECT_TRUE(m_result.sections[i].exData[j].type == m_params.sections[i].exData[j].type);
\r
455 switch(m_params.sections[i].exData[j].type) {
\r
456 case XRAN_CP_SECTIONEXTCMD_1:
\r
458 struct xran_sectionext1_info *ext1_params, *ext1_result;
\r
459 int iq_size, parm_size, N;
\r
461 ext1_params = (struct xran_sectionext1_info *)m_params.sections[i].exData[j].data;
\r
462 ext1_result = (struct xran_sectionext1_info *)m_result.sections[i].exData[j].data;
\r
464 EXPECT_TRUE(ext1_result->bfwiqWidth == ext1_params->bfwiqWidth);
\r
465 EXPECT_TRUE(ext1_result->bfwCompMeth == ext1_params->bfwCompMeth);
\r
467 N = ext1_params->bfwNumber;
\r
468 switch(ext1_params->bfwCompMeth) {
\r
469 case XRAN_BFWCOMPMETHOD_BLKFLOAT:
\r
470 EXPECT_TRUE(ext1_result->bfwCompParam.exponent == ext1_params->bfwCompParam.exponent);
\r
473 case XRAN_BFWCOMPMETHOD_BLKSCALE:
\r
474 EXPECT_TRUE(ext1_result->bfwCompParam.blockScaler == ext1_params->bfwCompParam.blockScaler);
\r
477 case XRAN_BFWCOMPMETHOD_ULAW:
\r
478 EXPECT_TRUE(ext1_result->bfwCompParam.compBitWidthShift == ext1_params->bfwCompParam.compBitWidthShift);
\r
481 case XRAN_BFWCOMPMETHOD_BEAMSPACE:
\r
482 parm_size = N>>3; if(N%8) parm_size++; parm_size *= 8;
\r
483 EXPECT_TRUE(std::memcmp(ext1_result->bfwCompParam.activeBeamspaceCoeffMask, ext1_params->bfwCompParam.activeBeamspaceCoeffMask, parm_size));
\r
487 /* Get the number of BF weights */
\r
488 iq_size = N*ext1_params->bfwiqWidth*2; // total in bits
\r
489 parm_size = iq_size>>3; // total in bytes (/8)
\r
490 if(iq_size%8) parm_size++; // round up
\r
491 EXPECT_TRUE(std::memcmp(ext1_result->p_bfwIQ, ext1_params->p_bfwIQ, parm_size));
\r
496 case XRAN_CP_SECTIONEXTCMD_2:
\r
498 struct xran_sectionext2_info *ext2_params, *ext2_result;
\r
500 ext2_params = (struct xran_sectionext2_info *)m_params.sections[i].exData[j].data;
\r
501 ext2_result = (struct xran_sectionext2_info *)m_result.sections[i].exData[j].data;
\r
503 if(ext2_params->bfAzPtWidth) {
\r
504 EXPECT_TRUE(ext2_result->bfAzPtWidth == ext2_params->bfAzPtWidth);
\r
505 EXPECT_TRUE(ext2_result->bfAzPt == ext2_params->bfAzPt);
\r
508 if(ext2_params->bfZePtWidth) {
\r
509 EXPECT_TRUE(ext2_result->bfZePtWidth == ext2_params->bfZePtWidth);
\r
510 EXPECT_TRUE(ext2_result->bfZePt == ext2_params->bfZePt);
\r
512 if(ext2_params->bfAz3ddWidth) {
\r
513 EXPECT_TRUE(ext2_result->bfAz3ddWidth == ext2_params->bfAz3ddWidth);
\r
514 EXPECT_TRUE(ext2_result->bfAz3dd == ext2_params->bfAz3dd);
\r
516 if(ext2_params->bfZe3ddWidth) {
\r
517 EXPECT_TRUE(ext2_result->bfZe3ddWidth == ext2_params->bfZe3ddWidth);
\r
518 EXPECT_TRUE(ext2_result->bfZe3dd == ext2_params->bfZe3dd);
\r
521 EXPECT_TRUE(ext2_result->bfAzSI == ext2_params->bfAzSI);
\r
522 EXPECT_TRUE(ext2_result->bfZeSI == ext2_params->bfZeSI);
\r
526 case XRAN_CP_SECTIONEXTCMD_4:
\r
528 struct xran_sectionext4_info *ext4_params, *ext4_result;
\r
530 ext4_params = (struct xran_sectionext4_info *)m_params.sections[i].exData[j].data;
\r
531 ext4_result = (struct xran_sectionext4_info *)m_result.sections[i].exData[j].data;
\r
533 EXPECT_TRUE(ext4_result->csf == ext4_params->csf);
\r
534 EXPECT_TRUE(ext4_result->modCompScaler == ext4_params->modCompScaler);
\r
537 case XRAN_CP_SECTIONEXTCMD_5:
\r
539 struct xran_sectionext5_info *ext5_params, *ext5_result;
\r
542 ext5_params = (struct xran_sectionext5_info *)m_params.sections[i].exData[j].data;
\r
543 ext5_result = (struct xran_sectionext5_info *)m_result.sections[i].exData[j].data;
\r
545 EXPECT_TRUE(ext5_result->num_sets == ext5_params->num_sets);
\r
546 for(idx=0; idx < ext5_params->num_sets; idx++) {
\r
547 EXPECT_TRUE(ext5_result->mc[idx].csf == ext5_params->mc[idx].csf);
\r
548 EXPECT_TRUE(ext5_result->mc[idx].mcScaleReMask == ext5_params->mc[idx].mcScaleReMask);
\r
549 EXPECT_TRUE(ext5_result->mc[idx].mcScaleOffset == ext5_params->mc[idx].mcScaleOffset);
\r
562 /***************************************************************************
\r
563 * Functional Test cases
\r
564 ***************************************************************************/
\r
566 TEST_P(C_plane, Section_Ext1)
\r
570 int16_t *ptr = NULL;
\r
572 int32_t nAntElm = 32;
\r
573 int8_t iqWidth = 16;
\r
574 int8_t compMethod = XRAN_COMPMETHOD_NONE;
\r
575 int8_t *p_ext1_dst = NULL;
\r
576 int16_t *bfw_payload = NULL;
\r
577 int32_t expected_len = (3+1)*nRbs + nAntElm*nRbs*4;
\r
579 struct xran_section_gen_info* loc_pSectGenInfo = m_params.sections;
\r
580 struct xran_sectionext1_info m_ext1;
\r
581 struct xran_cp_radioapp_section_ext1 *p_ext1;
\r
583 /* Configure section information */
\r
584 if(prepare_sections(false) < 0) {
\r
585 FAIL() << "Invalid Section configuration\n";
\r
587 ptr = m_p_bfw_iq_src;
\r
589 for (idRb =0; idRb < nRbs*nAntElm*2; idRb++){
\r
594 len = xran_cp_populate_section_ext_1(m_p_ext1_dst,
\r
602 ASSERT_TRUE(len == expected_len);
\r
604 p_ext1_dst = m_p_ext1_dst;
\r
607 p_ext1 = (struct xran_cp_radioapp_section_ext1 *)p_ext1_dst;
\r
608 bfw_payload = (int16_t*)(p_ext1+1);
\r
609 p_ext1_dst += p_ext1->extLen*XRAN_SECTIONEXT_ALIGN;
\r
611 }while(p_ext1->ef != XRAN_EF_F_LAST);
\r
613 ASSERT_TRUE(idRb == nRbs);
\r
615 /* Update section information */
\r
616 memset(&m_ext1, 0, sizeof (struct xran_sectionext1_info));
\r
617 m_ext1.bfwNumber = nAntElm;
\r
618 m_ext1.bfwiqWidth = iqWidth;
\r
619 m_ext1.bfwCompMeth = compMethod;
\r
620 m_ext1.p_bfwIQ = (int16_t*)m_p_ext1_dst;
\r
621 m_ext1.bfwIQ_sz = len;
\r
623 loc_pSectGenInfo->exData[0].type = XRAN_CP_SECTIONEXTCMD_1;
\r
624 loc_pSectGenInfo->exData[0].len = sizeof(m_ext1);
\r
625 loc_pSectGenInfo->exData[0].data = &m_ext1;
\r
627 loc_pSectGenInfo->info.ef = 1;
\r
628 loc_pSectGenInfo->exDataSize = 1;
\r
630 m_params.numSections = 1;
\r
632 /* Generating C-Plane packet */
\r
633 ASSERT_TRUE(xran_prepare_ctrl_pkt(m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId) == XRAN_STATUS_SUCCESS);
\r
635 /* Parsing generated packet */
\r
636 EXPECT_TRUE(xran_parse_cp_pkt(m_pTestBuffer, &m_result, &m_pktInfo) == XRAN_STATUS_SUCCESS);
\r
638 /* Verify the result */
\r
639 //verify_sections();
\r
642 TEST_P(C_plane, Section_Ext1_9bit)
\r
646 int16_t *ptr = NULL;
\r
648 int32_t nAntElm = 32;
\r
649 int8_t iqWidth = 9;
\r
650 int8_t compMethod = XRAN_COMPMETHOD_BLKFLOAT;
\r
651 int8_t *p_ext1_dst = NULL;
\r
652 int16_t *bfw_payload = NULL;
\r
653 int32_t expected_len = ((nAntElm/16*4*iqWidth)+1)*nRbs + /* bfwCompParam + IQ = */
\r
654 sizeof(struct xran_cp_radioapp_section_ext1)*nRbs; /* ext1 Headers */
\r
656 struct xran_section_gen_info* loc_pSectGenInfo = m_params.sections;
\r
657 struct xran_sectionext1_info m_ext1;
\r
658 struct xran_cp_radioapp_section_ext1 *p_ext1;
\r
660 /* Configure section information */
\r
661 if(prepare_sections(false) < 0) {
\r
662 FAIL() << "Invalid Section configuration\n";
\r
664 ptr = m_p_bfw_iq_src;
\r
666 for (idRb =0; idRb < nRbs*nAntElm*2; idRb++){
\r
671 len = xran_cp_populate_section_ext_1(m_p_ext1_dst,
\r
679 ASSERT_TRUE(len == expected_len);
\r
681 p_ext1_dst = m_p_ext1_dst;
\r
684 p_ext1 = (struct xran_cp_radioapp_section_ext1 *)p_ext1_dst;
\r
685 bfw_payload = (int16_t*)(p_ext1+1);
\r
686 p_ext1_dst += p_ext1->extLen*XRAN_SECTIONEXT_ALIGN;
\r
688 }while(p_ext1->ef != XRAN_EF_F_LAST);
\r
690 ASSERT_TRUE(idRb == nRbs);
\r
692 /* Update section information */
\r
693 memset(&m_ext1, 0, sizeof (struct xran_sectionext1_info));
\r
694 m_ext1.bfwNumber = nAntElm;
\r
695 m_ext1.bfwiqWidth = iqWidth;
\r
696 m_ext1.bfwCompMeth = compMethod;
\r
697 m_ext1.p_bfwIQ = (int16_t*)m_p_ext1_dst;
\r
698 m_ext1.bfwIQ_sz = len;
\r
700 loc_pSectGenInfo->exData[0].type = XRAN_CP_SECTIONEXTCMD_1;
\r
701 loc_pSectGenInfo->exData[0].len = sizeof(m_ext1);
\r
702 loc_pSectGenInfo->exData[0].data = &m_ext1;
\r
704 loc_pSectGenInfo->info.ef = 1;
\r
705 loc_pSectGenInfo->exDataSize = 1;
\r
707 m_params.numSections = 1;
\r
709 /* Generating C-Plane packet */
\r
710 ASSERT_TRUE(xran_prepare_ctrl_pkt(m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId) == XRAN_STATUS_SUCCESS);
\r
712 /* Parsing generated packet */
\r
713 EXPECT_TRUE(xran_parse_cp_pkt(m_pTestBuffer, &m_result, &m_pktInfo) == XRAN_STATUS_SUCCESS);
\r
715 /* Verify the result */
\r
716 //verify_sections();
\r
721 TEST_P(C_plane, PacketGen)
\r
726 /* Configure section information */
\r
727 if(prepare_sections(false) < 0) {
\r
728 FAIL() << "Invalid Section configuration\n";
\r
731 /* Generating C-Plane packet */
\r
732 ASSERT_TRUE(xran_prepare_ctrl_pkt(m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId) == XRAN_STATUS_SUCCESS);
\r
734 /* Parsing generated packet */
\r
735 EXPECT_TRUE(xran_parse_cp_pkt(m_pTestBuffer, &m_result, &m_pktInfo) == XRAN_STATUS_SUCCESS);
\r
737 /* Verify the result */
\r
742 TEST_P(C_plane, PacketGen_Ext)
\r
747 /* Configure section information */
\r
748 if(prepare_sections(true) < 0) {
\r
749 FAIL() << "Invalid Section configuration\n";
\r
752 /* Generating C-Plane packet */
\r
753 ASSERT_TRUE(xran_prepare_ctrl_pkt(m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId) == XRAN_STATUS_SUCCESS);
\r
755 /* Parsing generated packet */
\r
756 EXPECT_TRUE(xran_parse_cp_pkt(m_pTestBuffer, &m_result, &m_pktInfo) == XRAN_STATUS_SUCCESS);
\r
758 /* Verify the result */
\r
763 /***************************************************************************
\r
764 * Performance Test cases
\r
765 ***************************************************************************/
\r
766 TEST_P(C_plane, Perf)
\r
768 /* Configure section information */
\r
769 if(prepare_sections(false) < 0) {
\r
770 FAIL() << "Invalid Section configuration\n";
\r
773 /* using wrapper function to reset mbuf */
\r
774 performance("C", module_name,
\r
775 &xran_ut_prepare_cp, m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId);
\r
778 TEST_P(C_plane, Perf_Ext)
\r
780 /* Configure section information */
\r
781 if(prepare_sections(true) < 0) {
\r
782 FAIL() << "Invalid Section configuration\n";
\r
785 /* using wrapper function to reset mbuf */
\r
786 performance("C", module_name,
\r
787 &xran_ut_prepare_cp, m_pTestBuffer, &m_params, m_ccId, m_antId, m_seqId);
\r
791 INSTANTIATE_TEST_CASE_P(UnitTest, C_plane,
\r
792 testing::ValuesIn(get_sequence(C_plane::get_number_of_cases("C_Plane"))));
\r