29 #include <rte_branch_prediction.h> 49 static const uint8_t bitmask[] = { 0x00, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
68 int ctx, dir, cc,
ant;
74 sectiondb[ctx][dir][cc][ant].
cur_index = 0;
95 uint8_t dir, uint8_t cc_id, uint8_t ruport_id, uint8_t ctx_id)
101 print_err(
"Invalid Context id - %d", ctx_id);
106 print_err(
"Invalid direction - %d", dir);
116 print_err(
"Invalid eAxC id - %d", ruport_id);
120 ptr = §iondb[ctx_id][dir][cc_id][ruport_id];
127 if(unlikely(ptr == NULL))
131 print_err(
"Index is out of range - %d", index);
135 return(&(ptr->
list[index]));
161 uint8_t dir, uint8_t cc_id, uint8_t ruport_id, uint8_t ctx_id,
168 ptr = xran_get_section_db(pHandle, dir, cc_id, ruport_id, ctx_id);
169 if(unlikely(ptr == NULL)) {
174 print_err(
"No more space to add section information!");
178 list = xran_get_section_info(ptr, ptr->
cur_index);
188 uint8_t cc_id, uint8_t ruport_id, uint8_t ctx_id,
192 uint8_t dir, num_sections;
200 ptr = xran_get_section_db(pHandle, dir, cc_id, ruport_id, ctx_id);
201 if(unlikely(ptr == NULL)) {
206 print_err(
"No more space to add section information!");
210 list = xran_get_section_info(ptr, ptr->
cur_index);
212 for(i=0; i<num_sections; i++) {
243 uint8_t dir, uint8_t cc_id, uint8_t ruport_id,
244 uint8_t ctx_id, uint16_t section_id)
246 int index, num_index;
250 ptr = xran_get_section_db(pHandle, dir, cc_id, ruport_id, ctx_id);
251 if(unlikely(ptr == NULL))
259 for(index=0; index < num_index; index++) {
260 if(ptr->
list[index].
id == section_id) {
261 return (xran_get_section_info(ptr, index));
265 print_dbg(
"No section ID in the list - %d", section_id);
292 uint8_t dir, uint8_t cc_id, uint8_t ruport_id,
293 uint8_t ctx_id, uint32_t *next)
299 ptr = xran_get_section_db(pHandle, dir, cc_id, ruport_id, ctx_id);
300 if(unlikely(ptr == NULL))
306 return (xran_get_section_info(ptr, index));
309 print_dbg(
"No more sections in the list");
340 ptr = xran_get_section_db(pHandle, dir, cc_id, ruport_id, ctx_id);
341 if(unlikely(ptr == NULL))
370 ptr = xran_get_section_db(pHandle, dir, cc_id, ruport_id, ctx_id);
371 if(unlikely(ptr == NULL)) {
388 uint16_t ext1_dst_len,
389 int16_t *p_bfw_iq_src,
391 uint16_t bfwNumPerRb,
397 uint8_t *p_bfw_content = NULL;
398 int32_t parm_size = 0;
399 int32_t bfw_iq_bits = 0;
400 int32_t total_len = 0;
401 int32_t comp_len = 0;
404 int16_t cur_ext_len = 0;
405 int8_t *p_ext1_dst_cur = NULL;
413 print_dbg(
"%s comp %d\n", __FUNCTION__, bfwCompMeth);
414 print_dbg(
"bfwNumPerRb %d bfwiqWidth %d\n", bfwNumPerRb, bfwiqWidth);
417 p_ext1_dst_cur = p_ext1_dst;
422 for (idxRb = 0; idxRb < rbNum; idxRb++) {
423 print_dbg(
"%s RB %d\n", __FUNCTION__, idxRb);
425 if(total_len >= ext1_dst_len){
438 cur_ext_len += parm_size;
444 p_ext1->
ef = ext_flag;
448 switch(bfwCompMeth) {
450 p_bfw_content = (uint8_t *)(p_ext1+1);
451 if(p_bfw_content == NULL) {
452 print_err(
"Fail to allocate the space for section extension 1");
455 bfp_com_req.
data_in = (int16_t*)p_bfw_iq_src;
456 bfp_com_req.
len = bfwNumPerRb*4;
465 rte_panic(
"XRAN_BFWCOMPMETHOD_BLKSCALE");
469 rte_panic(
"XRAN_BFWCOMPMETHOD_BLKSCALE");
473 rte_panic(
"XRAN_BFWCOMPMETHOD_BLKSCALE");
478 p_bfw_content = (uint8_t *)(p_ext1+1);
483 if(p_bfw_content == NULL) {
484 print_err(
"Fail to allocate the space for section extension 1");
488 bfw_iq_bits = bfwNumPerRb* bfwiqWidth * 2;
490 parm_size += bfw_iq_bits>>3;
494 print_dbg(
"copy BF W %p -> %p size %d \n", p_bfw_iq_src, p_bfw_content, parm_size);
496 rte_memcpy(p_bfw_content, p_bfw_iq_src, parm_size);
498 bfp_com_rsp.
data_out = (int8_t*)p_bfw_content;
500 comp_len = bfp_com_rsp.
len;
508 p_bfw_content = (uint8_t *)(p_bfw_content + parm_size);
510 cur_ext_len += parm_size;
514 p_bfw_content = (uint8_t *)(p_bfw_content + parm_size);
515 rte_memcpy(p_bfw_content, zeropad, parm_size);
516 cur_ext_len += parm_size;
517 print_dbg(
"zeropad %d cur_ext_len %d\n", parm_size, cur_ext_len);
521 rte_panic(
"ext1 should be aligned on 4-bytes boundary");
527 p_ext1_dst_cur += cur_ext_len;
528 p_bfw_iq_src = p_bfw_iq_src + bfwNumPerRb*2;
530 total_len += cur_ext_len;
541 #define CPLEN_TS (30720000) 555 static int xran_copy_sectionext_1(
struct rte_mbuf *mbuf,
559 int8_t *p_dst = (int8_t *)rte_pktmbuf_append(mbuf, params->
bfwIQ_sz);
561 print_err(
"Fail to allocate the space for section extension 1 [%d]", params->
bfwIQ_sz);
577 static int xran_prepare_sectionext_1(
struct rte_mbuf *mbuf,
582 int parm_size, iq_size;
587 print_dbg(
"%s %d\n", __FUNCTION__, last_flag);
592 print_err(
"Fail to allocate the space for section extension 1 [%d]", parm_size);
596 total_len += parm_size;
599 ext1->
ef = last_flag;
606 data = (uint8_t *)rte_pktmbuf_append(mbuf, parm_size);
608 print_err(
"Fail to allocate the space for section extension 1 [%d]", parm_size);
611 total_len += parm_size;
617 data = (uint8_t *)rte_pktmbuf_append(mbuf, parm_size);
619 print_err(
"Fail to allocate the space for section extension 1 [%d]", parm_size);
622 total_len += parm_size;
628 data = (uint8_t *)rte_pktmbuf_append(mbuf, parm_size);
630 print_err(
"Fail to allocate the space for section extension 1 [%d]", parm_size);
633 total_len += parm_size;
641 data = (uint8_t *)rte_pktmbuf_append(mbuf, parm_size);
643 print_err(
"Fail to allocate the space for section extension 1 [%d]", parm_size);
647 total_len += parm_size;
659 parm_size = iq_size>>3;
663 data = (uint8_t *)rte_pktmbuf_append(mbuf, parm_size);
665 print_err(
"Fail to allocate the space for section extension 1 BF W iq_size: [%d]", parm_size);
668 rte_memcpy(data, params->
p_bfwIQ, parm_size);
670 total_len += parm_size;
674 data = (uint8_t *)rte_pktmbuf_append(mbuf, parm_size);
676 print_err(
"Fail to allocate the space for section extension 1 [%d]", parm_size);
679 rte_memcpy(data, zeropad, parm_size);
680 total_len += parm_size;
688 static int xran_prepare_sectionext_2(
struct rte_mbuf *mbuf,
695 uint32_t val, shift_val;
696 int val_size, pad_size;
704 print_err(
"Fail to allocate the space for section extension 2");
707 total_len += parm_size;
710 ext2->
ef = last_flag;
752 val = val << shift_val;
753 val = rte_cpu_to_be_32(val);
756 val_size = 4 - (shift_val/8);
757 parm_size = val_size + 1;
760 total_len += parm_size;
764 parm_size += pad_size;
765 total_len += pad_size;
768 data = (uint8_t *)rte_pktmbuf_append(mbuf, parm_size);
770 print_err(
"Fail to allocate the space for section extension 2");
774 rte_memcpy(data, &val, val_size);
778 rte_memcpy(data, zeropad, pad_size);
781 *(uint32_t *)ext2 = rte_cpu_to_be_32(*(uint32_t *)ext2);
786 static int xran_prepare_sectionext_4(
struct rte_mbuf *mbuf,
800 print_err(
"Fail to allocate the space for section extension 4");
804 total_len += parm_size;
807 ext4->
ef = last_flag;
809 ext4->
csf = params->
csf?1:0;
812 *(uint32_t *)ext4 = rte_cpu_to_be_32(*(uint32_t*)ext4);
818 static int xran_prepare_sectionext_5(
struct rte_mbuf *mbuf,
830 print_err(
"Exceeds maximum number of parameters(%d). Skipping.", params->
num_sets);
835 + (sizeof(struct xran_cp_radioapp_section_ext5)*params->
num_sets)/2
842 total_len += padding;
846 if(ext_hdr == NULL) {
847 print_err(
"Fail to allocate the space for section extension 5");
852 ext_hdr->
ef = last_flag;
855 *(uint16_t *)ext_hdr = rte_cpu_to_be_16(*((uint16_t *)ext_hdr));
857 data = (uint8_t *)(ext_hdr + 1);
859 while(i < params->num_sets) {
868 *((uint64_t *)&ext5) = rte_cpu_to_be_64(*((uint64_t *)&ext5));
869 rte_memcpy(data, &ext5,
sizeof(
struct xran_cp_radioapp_section_ext5));
870 data +=
sizeof(
struct xran_cp_radioapp_section_ext5);
880 *((uint64_t *)&ext5) = rte_cpu_to_be_64(*((uint64_t *)&ext5));
881 rte_memcpy(data, &ext5,
sizeof(
struct xran_cp_radioapp_section_ext5)/2);
882 data +=
sizeof(
struct xran_cp_radioapp_section_ext5)/2;
890 rte_memcpy(data, zeropad, padding);
926 print_err(
"Invalid parameter - extension data %d is NULL", i);
931 last_flag = (params->
exDataSize == (i+1))?0:1;
935 ext_size = xran_copy_sectionext_1(mbuf, params->
exData[i].
data, last_flag);
939 ext_size = xran_prepare_sectionext_2(mbuf, params->
exData[i].
data, last_flag);
942 ext_size = xran_prepare_sectionext_4(mbuf, params->
exData[i].
data, last_flag);
945 ext_size = xran_prepare_sectionext_5(mbuf, params->
exData[i].
data, last_flag);
977 static int xran_prepare_section0(
981 #if (XRAN_STRICT_PARM_CHECK) 996 section->
hdr.
u.
s0.reserved = 0;
999 *((uint64_t *)section) = rte_cpu_to_be_64(*((uint64_t *)section));
1013 static int xran_prepare_section0_hdr(
1039 static int xran_prepare_section1(
1043 #if (XRAN_STRICT_PARM_CHECK) 1063 *((uint64_t *)section) = rte_cpu_to_be_64(*((uint64_t *)section));
1077 static int xran_prepare_section1_hdr(
1100 static int xran_prepare_section3(
1104 #if (XRAN_STRICT_PARM_CHECK) 1127 *((uint64_t *)section) = rte_cpu_to_be_64(*((uint64_t *)section));
1141 static int xran_prepare_section3_hdr(
1171 int i, ret, ext_flag;
1175 int (*xran_prepare_section_func)(
void *section,
void *params);
1182 xran_prepare_section_func = (int (*)(
void *,
void *))xran_prepare_section0;
1187 xran_prepare_section_func = (int (*)(
void *,
void *))xran_prepare_section1;
1192 xran_prepare_section_func = (int (*)(
void *,
void *))xran_prepare_section3;
1200 xran_prepare_section_func = NULL;
1205 if(unlikely(xran_prepare_section_func == NULL)) {
1211 section = rte_pktmbuf_append(mbuf, section_size);
1212 if(section == NULL) {
1213 print_err(
"Fail to allocate the space for section[%d]!", i);
1217 ret = xran_prepare_section_func((
void *)section,
1220 print_err(
"%s %d\n", __FUNCTION__, ret);
1223 totalen += section_size;
1249 static inline int xran_prepare_radioapp_common_header(
1254 #if (XRAN_STRICT_PARM_CHECK) 1280 *((uint32_t *)apphdr) = rte_cpu_to_be_32(*((uint32_t *)apphdr));
1302 int (*xran_prepare_radioapp_section_hdr_func)(
void *
hdr,
void *params);
1305 #if (XRAN_STRICT_PARM_CHECK) 1314 xran_prepare_radioapp_section_hdr_func = (int (*)(
void *,
void*))xran_prepare_section0_hdr;
1319 xran_prepare_radioapp_section_hdr_func = (int (*)(
void *,
void*))xran_prepare_section1_hdr;
1324 xran_prepare_radioapp_section_hdr_func = (int (*)(
void *,
void*))xran_prepare_section3_hdr;
1333 xran_prepare_radioapp_section_hdr_func = NULL;
1339 if(unlikely(apphdr == NULL)) {
1340 print_err(
"Fail to reserve the space for radio application header!");
1344 ret = xran_prepare_radioapp_common_header(apphdr, params);
1345 if(unlikely(ret < 0)) {
1349 if(likely(xran_prepare_radioapp_section_hdr_func)) {
1350 totalen += xran_prepare_radioapp_section_hdr_func(apphdr, params);
1353 print_err(
"xran_prepare_radioapp_section_hdr_func is NULL!");
1383 uint8_t CC_ID, uint8_t Ant_ID,
1387 uint32_t payloadlen;
1395 print_err(
"%s %d\n", __FUNCTION__, ret);
1402 print_err(
"%s %d\n", __FUNCTION__, ret);
1423 int parm_size, iq_size;
1432 data = (uint8_t *)ext;
1464 parm_size = N>>3;
if(N%8) parm_size++; parm_size *= 8;
1478 parm_size = iq_size>>3;
1479 if(iq_size%8) parm_size++;
1482 extinfo->
p_bfwIQ = (int16_t*)data;
1490 if(len != total_len) {
1510 data = (uint8_t *)ext;
1511 *(uint32_t *)ext2 = rte_cpu_to_be_32(*(uint32_t *)ext2);
1534 val = rte_cpu_to_be_32(*(uint32_t *)data);
1535 val >>= (32 - val_size);
1555 parm_size = val_size/8;
1556 if(val_size%8) parm_size += 1;
1561 extinfo->
bfAzSI = (*data >> 3) & 0x07;
1562 extinfo->
bfZeSI = *data & 0x07;
1571 if(len != total_len) {
1572 print_err(
"The size of extension 2 is not correct! [%d:%d]", len, total_len);
1589 *(uint32_t *)ext4 = rte_cpu_to_be_32(*(uint32_t *)ext4);
1595 extinfo->
csf = ext4->
csf;
1599 if(len != total_len) {
1600 print_err(
"The size of extension 4 is not correct! [%d:%d]", len, total_len);
1619 *(uint16_t *)ext_hdr = rte_cpu_to_be_16(*(uint16_t *)ext_hdr);
1627 print_err(
"Exceeds maximum number of parameters - %d", parm_size);
1632 data = (uint8_t *)(ext_hdr + 1);
1635 while(i < parm_size) {
1637 *((uint64_t *)&ext5) = rte_cpu_to_be_64(*((uint64_t *)data));
1662 print_err(
"Maximum total number %d is not correct!", i);
1672 int total_len, len, numext;
1679 ptr = (uint8_t *)ext;
1687 flag_last = (*ptr & 0x80);
1689 ext_type = *ptr & 0x7f;
1713 print_err(
"Extension %d is not supported!", ext_type);
1718 ptr += len; total_len += len;
1760 if(ret < 0 && ecpri_hdr == NULL)
1764 apphdr = (
void *)rte_pktmbuf_adj(mbuf,
sizeof(
struct xran_ecpri_hdr));
1765 if(apphdr == NULL) {
1766 print_err(
"Invalid packet - radio app hedaer!");
1770 *((uint32_t *)apphdr) = rte_cpu_to_be_32(*((uint32_t *)apphdr));
1773 print_err(
"Invalid Payload version - %d", apphdr->payloadVer);
1777 result->
dir = apphdr->dataDirection;
1787 printf(
"[CP%5d] eAxC[%d:%d:%02d:%02d] %s seq[%03d-%03d-%d] sec[%d-%d] frame[%3d-%2d-%2d] sym%02d\n",
1791 result->
dir?
"DL":
"UL",
1799 switch(apphdr->sectionType) {
1814 if(section == NULL) {
1815 print_err(
"Invalid packet 0 - radio app hedaer!");
1819 *((uint64_t *)section) = rte_be_to_cpu_64(*((uint64_t *)section));
1832 if(section == NULL) {
1833 print_err(
"Invalid packet 0 - number of section [%d:%d]!",
1854 if(section == NULL) {
1855 print_err(
"Invalid packet 1 - radio app hedaer!");
1860 *((uint64_t *)section) = rte_be_to_cpu_64(*((uint64_t *)section));
1873 section = (
void *)rte_pktmbuf_adj(mbuf,
1875 if(section == NULL) {
1876 print_err(
"Invalid packet 1 - number of section [%d:%d]!",
1887 section = (
void *)rte_pktmbuf_adj(mbuf, extlen);
1888 if(section == NULL) {
1889 print_err(
"Invalid packet 1 - section extension [%d]!", i);
1915 if(section == NULL) {
1916 print_err(
"Invalid packet 3 - radio app hedaer!");
1921 *((uint64_t *)section) = rte_be_to_cpu_64(*((uint64_t *)section));
1935 if(section->reserved) {
1936 print_err(
"Invalid packet 3 - section[%d:%d]", i, section->reserved);
1941 if(section == NULL) {
1942 print_err(
"Invalid packet 3 - number of section [%d:%d]!",
1953 section = (
void *)rte_pktmbuf_adj(mbuf, extlen);
1954 if(section == NULL) {
1955 print_err(
"Invalid packet 3 - section extension [%d]!", i);
1971 print_err(
"Non-supported Section Type - %d", apphdr->sectionType);
1975 printf(
"[CP-%s] [%3d:%2d:%2d] section%d[%d] startSym=%d filterIdx=%X IQwidth=%d CompMeth=%d\n",
1976 result->
dir?
"DL":
"UL",
1984 printf(
" || %3d:%04X| rb=%d symInc=%d numSym=%d startPrbc=%02d numPrbc=%d reMask=%03X beamId=%04X freqOffset=%d ef=%d\n",
1996 printf(
" || %2d : type=%d len=%d\n",
2003 printf(
" || bfwNumber=%d bfwiqWidth=%d bfwCompMeth=%d\n",
2011 printf(
" || AzPt=%02x(%d) ZePt=%02x(%d) Az3dd=%02x(%d) Ze3dd=%02x(%d) AzSI=%02x ZeSI=%02x\n",
2023 printf(
" || csf=%d modCompScaler=%d\n",
2031 printf(
" || num_sets=%d\n", ext5->
num_sets);
2032 for(
int k=0; k<ext5->
num_sets; k++) {
2033 printf(
" || %d - csf=%d mcScaleReMask=%04x mcScaleOffset=%04x\n",
2043 printf(
"Invalid section extension type!\n");
struct xran_section_info * xran_cp_find_section_info(void *pHandle, uint8_t dir, uint8_t cc_id, uint8_t ruport_id, uint8_t ctx_id, uint16_t section_id)
Find a section information of C-Plane from dabase by given information.
#define XRAN_MAX_ANT_ARRAY_ELM_NR
int xran_cp_init_sectiondb(void *pHandle)
Initialize section database. Allocate required memory space to store section information. Each eAxC allocates dedicated storage and the entry size is the maximum number of sections. Total entry size : number of CC * number of antenna * max number of sections * 2(direction)
uint8_t compBitWidthShift
#define XRAN_STATUS_SUCCESS
struct xran_sectionext4_info m_ext4[XRAN_MAX_NUM_EXTENSIONS]
#define print_dbg(fmt, args...)
#define XRAN_EF_F_ANOTHER_ONE
int xran_parse_section_ext2(void *ext, struct xran_sectionext2_info *extinfo)
end write files for IQ samples for ant
uint8_t activeBeamspaceCoeffMask[XRAN_MAX_BFW_N]
int xran_cp_add_multisection_info(void *pHandle, uint8_t cc_id, uint8_t ruport_id, uint8_t ctx_id, struct xran_cp_gen_params *gen_info)
int32_t xran_get_freqoffset(int32_t freqOffset, int32_t scs)
int xran_build_ecpri_hdr(struct rte_mbuf *mbuf, uint8_t CC_ID, uint8_t Ant_ID, uint8_t seq_id, struct xran_ecpri_hdr **ecpri_hdr)
Build ECPRI header and returns added length.
struct xran_sectionext5_info::@1 mc[XRAN_MAX_MODCOMP_ADDPARMS]
int xran_cp_add_section_info(void *pHandle, uint8_t dir, uint8_t cc_id, uint8_t ruport_id, uint8_t ctx_id, struct xran_section_info *info)
Add a section information of C-Plane to dabase.
struct xran_section_info info
struct xran_section_info * xran_cp_iterate_section_info(void *pHandle, uint8_t dir, uint8_t cc_id, uint8_t ruport_id, uint8_t ctx_id, uint32_t *next)
Iterate each section information of C-Plane from the database of eAxC by given information.
External API for compading with the use BFP algorithm.
#define XRAN_CONVERT_NUMPRBC(x)
#define XRAN_MAX_SECTIONDB_CTX
#define XRAN_MAX_ANTENNA_NR
int xran_parse_section_ext4(void *ext, struct xran_sectionext4_info *extinfo)
struct xran_sectionext2_info m_ext2[XRAN_MAX_NUM_EXTENSIONS]
struct xran_sectionext1_info m_ext1[XRAN_MAX_NUM_EXTENSIONS]
#define print_err(fmt, args...)
int xran_parse_ecpri_hdr(struct rte_mbuf *mbuf, struct xran_ecpri_hdr **ecpri_hdr, struct xran_recv_packet_info *pkt_info)
Parse ECPRI header.
#define XRAN_SECTIONEXT_ALIGN
int xranlib_compress_avx512_bfw(const struct xranlib_compress_request *request, struct xranlib_compress_response *response)
struct xran_section_info list[XRAN_MAX_NUM_SECTIONS]
int32_t xran_cp_getsize_section_info(void *pHandle, uint8_t dir, uint8_t cc_id, uint8_t ruport_id, uint8_t ctx_id)
Get the size of stored entries for the database of eAxC by given information.
Request structure containing pointer to data and its length.
int xran_parse_cp_pkt(struct rte_mbuf *mbuf, struct xran_cp_gen_params *result, struct xran_recv_packet_info *pkt_info)
Parse a C-Plane packet (for RU emulation) Transport layer fragmentation is not supported.
struct xran_cp_radioapp_section_header hdr
uint16_t xran_get_cplength(int CP_length)
int xran_append_control_section(struct rte_mbuf *mbuf, struct xran_cp_gen_params *params)
add sections to C-Plane packet Section type 1 and 3 are supported.
uint8_t xran_get_conf_num_bfweights(void *pHandle)
Get the configuration of the total number of beamforming weights on RU.
int xran_parse_section_ext5(void *ext, struct xran_sectionext5_info *extinfo)
int xran_append_section_extensions(struct rte_mbuf *mbuf, struct xran_section_gen_info *params)
add section extension to C-Plane packet
int xran_cp_reset_section_info(void *pHandle, uint8_t dir, uint8_t cc_id, uint8_t ruport_id, uint8_t ctx_id)
Reset a database of eAxC by given information.
struct xran_cp_header_params hdr
Modules provide debug prints and utility functions.
struct xran_ecpri_cmn_hdr cmnhdr
#define XRAN_MAX_NUM_EXTENSIONS
XRAN layer common functionality for both lls-CU and RU as well as C-plane and U-plane.
#define XRAN_COMPONENT_CARRIERS_MAX
#define XRAN_MAX_NUM_SECTIONS
struct xran_cp_radioapp_section_header hdr
union xran_sectionext1_info::@0 bfwCompParam
Response structure containing pointer to data and its length.
int xran_parse_section_extension(struct rte_mbuf *mbuf, void *ext, struct xran_section_gen_info *section)
struct xran_cp_radioapp_section_header hdr
int xran_append_radioapp_header(struct rte_mbuf *mbuf, struct xran_cp_gen_params *params)
add a radio application header in a C-Plane packet
int xran_parse_section_ext1(void *ext, struct xran_sectionext1_info *extinfo)
#define XRAN_STATUS_INVALID_PARAM
#define XRAN_CONVERT_BFWIQWIDTH(x)
int xran_dump_sectiondb(void)
int xran_cp_free_sectiondb(void *pHandle)
Release and free section database.
#define XRAN_MAX_MODCOMP_ADDPARMS
#define XRAN_SYMBOLNUMBER_MAX
struct xran_section_gen_info * sections
struct xran_section_gen_info::@2 exData[XRAN_MAX_NUM_EXTENSIONS]
struct xran_sectionext5_info m_ext5[XRAN_MAX_NUM_EXTENSIONS]
int xran_prepare_ctrl_pkt(struct rte_mbuf *mbuf, struct xran_cp_gen_params *params, uint8_t CC_ID, uint8_t Ant_ID, uint8_t seq_id)
Create a C-Plane packet Transport layer fragmentation is not supported.
struct xran_cp_radioapp_section_header hdr
#define XRAN_STATUS_RESOURCE
This file provides the definitions for Control Plane Messages APIs.
#define XRAN_STATUS_INVALID_PACKET
struct xran_eaxc_info eaxc
This file provides the definitions for Transport layer (eCPRI) API.
int32_t xran_cp_populate_section_ext_1(int8_t *p_ext1_dst, uint16_t ext1_dst_len, int16_t *p_bfw_iq_src, uint16_t rbNum, uint16_t bfwNumPerRb, uint8_t bfwiqWidth, uint8_t bfwCompMeth)