src/cu_stub/cu_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   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 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "OCTET_STRING.h"
  22 #include "BIT_STRING.h"
  23 #include "odu_common_codec.h"
  24 #include "cu_stub_sctp.h"
  25 #include "cu_f1ap_msg_hdl.h"
  26 /*header files needed for Ue Context Setup */
  27 #include<ProtocolIE-Field.h>
  28 #include "ProtocolExtensionField.h"
  29 #include "F1AP-PDU.h"
  30 #include "ProtocolExtensionContainer.h"
  31 #include "CellGroupConfigRrc.h"
  32 #include "MAC-CellGroupConfig.h"
  33 #include "SchedulingRequestConfig.h"
  34 #include "SchedulingRequestToAddMod.h"
  35 #include "BSR-Config.h"
  36 #include "TAG-Config.h"
  37 #include "TAG.h"
  38 #include "PHR-Config.h"
  39 #include "RLC-Config.h"
  40 #include "UL-AM-RLC.h"
  41 #include "DL-AM-RLC.h"
  42 #include "LogicalChannelConfig.h"
  43 #include "RLC-BearerConfig.h"
  44 #include "PhysicalCellGroupConfig.h"
  45 #include "SpCellConfig.h"
  46 #include "ServingCellConfig.h"
  47 #include "ControlResourceSet.h"
  48 #include "SearchSpace.h"
  49 #include "PDCCH-Config.h"
  50 #include "PDSCH-TimeDomainResourceAllocation.h"
  51 #include "PDSCH-TimeDomainResourceAllocationList.h"
  52 #include "DMRS-DownlinkConfig.h"
  53 #include "PDSCH-Config.h"
  54 #include "BWP-DownlinkDedicated.h"
  55 #include "PUSCH-TimeDomainResourceAllocation.h"
  56 #include "PUSCH-TimeDomainResourceAllocationList.h"
  57 #include "DMRS-UplinkConfig.h"
  58 #include "PUSCH-Config.h"
  59 #include "SRS-ResourceId.h"
  60 #include "SRS-Resource.h"
  61 #include "SRS-ResourceSet.h"
  62 #include "SRS-Config.h"
  63 #include "BWP-UplinkDedicated.h"
  64 #include "PUSCH-ServingCellConfig.h"
  65 #include "UplinkConfig.h"
  66 #include "PDSCH-ServingCellConfig.h"
  67
  68 /* MACRO for CUtoDURRCInformation */
  69 #define CELL_GRP_ID 1
  70 #define FREQ_DOM_RSRC_SIZE 6
  71 #define CORESET0_END_PRB   48
  72 #define CORESET1_NUM_PRB   24
  73 #define PDCCH_CTRL_RSRC_SET_ONE_ID  1
  74 #define PDCCH_CTRL_RSRC_SET_ONE_DURATION 2  /* Duration for control resource set id i */
  75 #define PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY 1   /* Precoded granularity */
  76 #define PDCCH_SRCH_SPC_TWO_ID 2
  77 #define NR_PCI 1
  78 #define SCRAMBLING_ID  NR_PCI
  79 #define DMRS_ADDITIONAL_POS  0          /* DMRS Additional poistion */
  80 #define PDCCH_SYMBOL_WITHIN_SLOT 128     /* Symbol within Slot Value */
  81 #define PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE 7   /* Num of candidate at aggregation level 1 */
  82 #define PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE 7   /* Num of candidate at aggregation level 2 */
  83 #define PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE 4   /* Num of candidate at aggregation level 4 */
  84 #define PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE 2   /* Num of candidate at aggregation level 8 */
  85 #define PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE 1  /* Num of candidate at aggregation level 16 */
  86 #define PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT  0  /* format 0-0 and 1-0 */
  87 #define PDCCH_SERACH_SPACE_DCI_FORMAT 0
  88
  89 /* MACRO Ddefine for PDSCH Configuration */
  90 #define PDSCH_K0  0
  91 #define PDSCH_RES_ALLOC_TYPE       1          /* Resource allocation type */
  92 #define PDSCH_MAX_CODEWORD_SCH_BY_DCI 0       /* Max num of codewords scheduled by DCI */
  93 #define PDSCH_RBG_SIZE   0                    /* 0: config1 */
  94 #define PDSCH_NUM_HARQ_PROC 5
  95 #define PDSCH_MAPPING_TYPE_A 0
  96 #define PDSCH_MAPPING_TYPE_B 1
  97
  98 /* MACRO Define for PUSCH Configuration */
  99 #define PUSCH_K2  3
 100
 101 #define PUSCH_MSG3_DELTA_PREAMBLE 0
 102 #define PUSCH_P0_NOMINAL_WITH_GRANT -70
 103 #define PUSCH_TRANSFORM_PRECODER    1      /* 1: Disabled */
 104 #define PUSCH_MAX_MIMO_LAYERS       1
 105 #define PUSCH_PROCESS_TYPE2_ENABLED false
 106 #define PUSCH_MAPPING_TYPE_A        0
 107 #define PUSCH_MAPPING_TYPE_B        1
 108
 109 /* MACRO defines for SRC config */
 110 #define SRS_RSRC_ID  1
 111 #define SRS_RSET_ID  1
 112 #define SRS_COMB_OFFSET_N2   0
 113 #define SRS_CYCLIC_SHIFT_N2  0
 114 #define SRS_FREQ_DOM_POS     0
 115 #define SRS_FREQ_DOM_SHIFT   0
 116 #define C_SRS 0
 117 #define B_SRS 0
 118 #define B_HOP 0
 119 #define SRS_SEQ_ID 0
 120 #define APERIODIC_SRS_RESRC_TRIGGER 1
 121
 122 /* Macro definitions for DUtoCuRrcContainer */
 123 #define CELL_GRP_ID 1
 124 #define SCH_REQ_ID  0
 125 #define SR_PROHIBIT_TMR 5
 126 #define SR_TRANS_MAX 2
 127 #define PERIODIC_BSR_TMR 2
 128 #define RETX_BSR_TMR     5
 129 #define SR_DELAY_TMR     6
 130 #define TAG_ID 0
 131 #define TIME_ALIGNMENT_TMR 7
 132 #define PHR_PERIODIC_TMR 7
 133 #define PHR_PROHIBHIT_TMR 0
 134 #define PHR_PWR_FACTOR_CHANGE 3
 135 #define PHR_MODE_OTHER_CG 0
 136 #define RLC_LCID 1
 137 #define SRB_ID_1 1
 138 #define SN_FIELD_LEN 0
 139 #define T_POLL_RETRANSMIT 8
 140 #define POLL_PDU 0
 141 #define POLL_BYTE 43
 142 #define MAX_RETX_THRESHOLD 5
 143 #define T_REASSEMBLY 8
 144 #define T_STATUS_PROHIBHIT 7
 145 #define MAC_LC_PRIORITY 1
 146 #define PRIORTISIED_BIT_RATE 15
 147 #define BUCKET_SIZE_DURATION 5
 148 #define LC_GRP 0
 149 #define P_NR_FR1 0
 150 #define PDSCH_HARQ_ACK_CODEBOOK 1
 151 #define SERV_CELL_IDX 0
 152 #define RLM_SYNC_OUT_SYNC_THRESHOLD 0
 153 #define ACTIVE_DL_BWP_ID 0
 154 #define ACTIVE_UL_BWP_ID 0
 155 #define SCRAMBLING_ID  NR_PCI
 156 #define DMRS_ADDITIONAL_POS  0          /* DMRS Additional poistion */
 157 #define RES_ALLOC_TYPE       1          /* Resource allocation type */
 158
 159 /*******************************************************************
 160 *
 161 * @brief Sends F1 msg over SCTP
 162 *
 163 * @details
 164 *
 165 *    Function : SendF1APMsg
 166 *
 167 *    Functionality: Sends F1 msg over SCTP
 168 *
 169 * @params[in] Region region
 170 *             Pool pool
 171 * @return ROK     - success
 172 *         RFAILED - failure
 173 *
 174 * ****************************************************************/
 175 S16 SendF1APMsg(Region region, Pool pool)
 176 {
 177    Buffer *mBuf = NULLP;
 178
 179    if(ODU_GET_MSG_BUF(region, pool, &mBuf) == ROK)
 180    {
 181       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
 182       {
 183          ODU_PRINT_MSG(mBuf, 0,0);
 184
 185          if(sctpSend(mBuf) != ROK)
 186          {
 187             DU_LOG("\nF1AP : SCTP Send failed");
 188             ODU_PUT_MSG_BUF(mBuf);
 189             return RFAILED;
 190          }
 191       }
 192       else
 193       {
 194          DU_LOG("\nF1AP : ODU_ADD_POST_MSG_MULT failed");
 195          ODU_PUT_MSG_BUF(mBuf);
 196          return RFAILED;
 197       }
 198       ODU_PUT_MSG_BUF(mBuf);
 199    }
 200    else
 201    {
 202       DU_LOG("\nF1AP : Failed to allocate memory");
 203       return RFAILED;
 204    }
 205
 206    return ROK;
 207 } /* SendF1APMsg */
 208
 209 /*******************************************************************
 210  *
 211  * @brief Builds NRCell ID
 212  *
 213  * @details
 214  *
 215  *    Function : BuildNrCellId
 216  *
 217  *    Functionality: Building the NR Cell ID
 218  *
 219  * @params[in] BIT_STRING_t *nrcell
 220  * @return ROK     - success
 221  *         RFAILED - failure
 222  *
 223  * ****************************************************************/
 224
 225 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 226 {
 227    U8 tmp;
 228    for (tmp = 0 ; tmp < nrcell->size-1; tmp++)
 229    {
 230       nrcell->buf[tmp] = 0;
 231    }
 232    nrcell->buf[4]   = 16;
 233    nrcell->bits_unused = 4;
 234    nrcell->size = 5 * sizeof(uint8_t);
 235    return ROK;
 236 }
 237
 238 /********************************************************************
 239  *
 240  * @brief Builds and sends the F1SetupResponse
 241  *
 242  * @details
 243  *
 244  *    Function : BuildAndSendF1SetupRsp
 245  *
 246  *    Functionality: Constructs the F1SetupResponse message and sends
 247  *                   it back to the DU through SCTP.
 248  *
 249  * @params[in] void **buf,Buffer to which encoded pattern is written into
 250  * @params[in] int *size,size of buffer
 251  *
 252  * @return ROK     - success
 253  *         RFAILED - failure
 254  *
 255  * ****************************************************************/
 256 S16 BuildAndSendF1SetupRsp()
 257 {
 258    U8    idx,ieIdx;
 259    U8    elementCnt,cellCnt;
 260    F1AP_PDU_t         *f1apMsg = NULL;
 261    F1SetupResponse_t  *f1SetupRsp;
 262    GNB_CU_Name_t      *cuName;
 263    Cells_to_be_Activated_List_t *cellToActivate;
 264    RRC_Version_t      *rrcVer;
 265    asn_enc_rval_t     encRetVal;
 266    DU_LOG("\nF1AP : Building F1 Setup Response\n");
 267
 268    /* Allocate the memory for F1SetupRequest_t */
 269    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 270    if(f1apMsg == NULLP)
 271    {
 272       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 273       return RFAILED;
 274    }
 275    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 276
 277    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 278    if(f1apMsg->choice.successfulOutcome == NULLP)
 279    {
 280       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 281       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 282       return RFAILED;
 283    }
 284
 285    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_F1Setup;
 286    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 287    f1apMsg->choice.successfulOutcome->value.present = \
 288                                                       SuccessfulOutcome__value_PR_F1SetupResponse;
 289    f1SetupRsp = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
 290
 291    elementCnt = 4;
 292    f1SetupRsp->protocolIEs.list.count = elementCnt;
 293    f1SetupRsp->protocolIEs.list.size = elementCnt*sizeof(F1SetupResponseIEs_t *);
 294
 295    CU_ALLOC(f1SetupRsp->protocolIEs.list.array, \
 296          elementCnt * sizeof(F1SetupResponseIEs_t *));
 297    if(f1SetupRsp->protocolIEs.list.array == NULLP)
 298    {
 299       DU_LOG("\nF1AP : Memory allocation for F1ResponseIEs failed");
 300       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 301       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 302       return RFAILED;
 303    }
 304
 305    for(idx=0; idx<elementCnt; idx++)
 306    {
 307       CU_ALLOC(f1SetupRsp->protocolIEs.list.array[idx], \
 308             sizeof(F1SetupResponseIEs_t));
 309       if(f1SetupRsp->protocolIEs.list.array[idx] == NULLP)
 310       {
 311          CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 312                elementCnt * sizeof(F1SetupResponseIEs_t *));
 313          CU_FREE(f1apMsg->choice.successfulOutcome, \
 314                sizeof(SuccessfulOutcome_t));
 315          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 316          return RFAILED;
 317       }
 318    }
 319
 320    /*TransactionID*/
 321    idx = 0;
 322    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 323    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 324    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 325                                                             F1SetupResponseIEs__value_PR_TransactionID;
 326    f1SetupRsp->protocolIEs.list.array[idx]->value.choice.TransactionID =\
 327                                                                         TRANS_ID;
 328
 329    /*CU Name*/
 330    idx++;
 331    f1SetupRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_gNB_CU_Name;
 332    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 333    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 334                                                             F1SetupResponseIEs__value_PR_GNB_CU_Name;
 335    cuName = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_Name;
 336    cuName->size = sizeof(cuCfgParams.cuName);
 337
 338    CU_ALLOC(cuName->buf, sizeof(cuName->size));
 339    if(cuName->buf == NULLP)
 340    {
 341       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 342       {
 343          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 344                sizeof(F1SetupResponseIEs_t));
 345       }
 346       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 347             elementCnt * sizeof(F1SetupResponseIEs_t *));
 348       CU_FREE(f1apMsg->choice.successfulOutcome,\
 349             sizeof(SuccessfulOutcome_t));
 350       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 351       return RFAILED;
 352    }
 353    strcpy((char*)cuName->buf, (char*)cuCfgParams.cuName);
 354
 355    /*Cells to be activated list*/
 356    idx++;
 357    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 358                                                  ProtocolIE_ID_id_Cells_to_be_Activated_List ;
 359    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 360    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 361                                                             F1SetupResponseIEs__value_PR_Cells_to_be_Activated_List;
 362    cellToActivate = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.\
 363                     Cells_to_be_Activated_List;
 364    cellCnt=1;
 365    cellToActivate->list.count = cellCnt;
 366    cellToActivate->list.size = \
 367                                cellCnt*sizeof(struct Cells_to_be_Activated_List_ItemIEs  *);
 368    CU_ALLOC(cellToActivate->list.array,\
 369          sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 370    if(cellToActivate->list.array == NULLP)
 371    {
 372       CU_FREE(cuName->buf, sizeof(cuName->size));
 373       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 374       {
 375          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx],\
 376                sizeof(F1SetupResponseIEs_t));
 377       }
 378       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 379             elementCnt * sizeof(F1SetupResponseIEs_t *));
 380       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 381       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 382       return RFAILED;
 383    }
 384    for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 385    {
 386       CU_ALLOC(cellToActivate->list.array[ieIdx],sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 387       if(cellToActivate->list.array[ieIdx] == NULLP)
 388       {
 389          CU_FREE(cellToActivate->list.array,\
 390                sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 391          CU_FREE(cuName->buf, sizeof(cuName->size));
 392          for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 393          {
 394             CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 395                   sizeof(F1SetupResponseIEs_t));
 396          }
 397          CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 398                elementCnt * sizeof(F1SetupResponseIEs_t *));
 399          CU_FREE(f1apMsg->choice.successfulOutcome, \
 400                sizeof(SuccessfulOutcome_t));
 401          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 402          return RFAILED;
 403       }
 404    }
 405    cellToActivate->list.array[0]->id = \
 406                                        ProtocolIE_ID_id_Cells_to_be_Activated_List_Item;
 407    cellToActivate->list.array[0]->criticality = Criticality_ignore;
 408    cellToActivate->list.array[0]->value.present = \
 409                                                   Cells_to_be_Activated_List_ItemIEs__value_PR_Cells_to_be_Activated_List_Item;
 410    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 411       nRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
 412    CU_ALLOC(cellToActivate->list.array[0]->\
 413          value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 414          3*sizeof(uint8_t));
 415    if(cellToActivate->list.array[0]->value.choice.\
 416          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf == NULLP)
 417    {
 418
 419       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 420       {
 421          CU_FREE(cellToActivate->list.array[ieIdx],\
 422                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 423       }
 424
 425       CU_FREE(cellToActivate->list.array,\
 426             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 427       CU_FREE(cuName->buf, sizeof(cuName->size));
 428       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 429       {
 430          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 431                sizeof(F1SetupResponseIEs_t));
 432       }
 433       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 434             elementCnt * sizeof(F1SetupResponseIEs_t *));
 435       CU_FREE(f1apMsg->choice.successfulOutcome, \
 436             sizeof(SuccessfulOutcome_t));
 437       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 438       return RFAILED;
 439    }
 440    buildPlmnId(cuCfgParams.plmn , cellToActivate->list.array[0]->value.choice.\
 441          Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf);
 442    cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
 443       nRCGI.nRCellIdentity.size = 5;
 444    CU_ALLOC(cellToActivate->list.array[0]->value.choice.\
 445          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf,\
 446          5*sizeof(uint8_t));
 447    if(cellToActivate->list.array[0]->value.choice.\
 448          Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf == NULLP)
 449    {
 450       CU_FREE(cellToActivate->list.array[0]->\
 451             value.choice.Cells_to_be_Activated_List_Item.nRCGI.pLMN_Identity.buf,\
 452             3*sizeof(uint8_t));
 453       for(ieIdx=0; ieIdx<cellCnt; ieIdx++)
 454       {
 455          CU_FREE(cellToActivate->list.array[ieIdx],\
 456                sizeof(struct Cells_to_be_Activated_List_ItemIEs ));
 457       }
 458
 459       CU_FREE(cellToActivate->list.array,\
 460             sizeof(struct Cells_to_be_Activated_List_ItemIEs  *));
 461       CU_FREE(cuName->buf, sizeof(cuName->size));
 462       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 463       {
 464          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 465                sizeof(F1SetupResponseIEs_t));
 466       }
 467       CU_FREE(f1SetupRsp->protocolIEs.list.array, \
 468             elementCnt * sizeof(F1SetupResponseIEs_t *));
 469       CU_FREE(f1apMsg->choice.successfulOutcome, \
 470             sizeof(SuccessfulOutcome_t));
 471       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 472       return RFAILED;
 473    }
 474    BuildNrCellId(&(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity));
 475    /* RRC Version */
 476    idx++;
 477    f1SetupRsp->protocolIEs.list.array[idx]->id = \
 478                                                  ProtocolIE_ID_id_GNB_CU_RRC_Version;
 479    f1SetupRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 480    f1SetupRsp->protocolIEs.list.array[idx]->value.present = \
 481                                                             F1SetupResponseIEs__value_PR_RRC_Version;
 482    rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
 483    rrcVer->latest_RRC_Version.size = RRC_SIZE;
 484
 485    CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 486    if(rrcVer->latest_RRC_Version.buf == NULLP)
 487    {
 488       CU_FREE(cuName->buf, sizeof(cuName->size));
 489       for(ieIdx=0; ieIdx<elementCnt; idx++)
 490       {
 491          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 492                sizeof(F1SetupResponseIEs_t));
 493       }
 494       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 495             elementCnt * sizeof(F1SetupResponseIEs_t *));
 496       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 497       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 498       return RFAILED;
 499    }
 500
 501    /* Need to check RRC Version */
 502    rrcVer->latest_RRC_Version.buf[0] = cuCfgParams.rrcVersion.rrcVer;
 503    rrcVer->latest_RRC_Version.bits_unused = 5; //TODO: pick from cuCfgParam. If not present, add it
 504    CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 505    if(rrcVer->iE_Extensions == NULLP)
 506    {
 507       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 508       CU_FREE(cuName->buf, sizeof(cuName->size));
 509       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 510       {
 511          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 512                sizeof(F1SetupResponseIEs_t));
 513       }
 514       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 515             elementCnt * sizeof(F1SetupResponseIEs_t *));
 516       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 517       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 518       return RFAILED;
 519    }
 520    rrcVer->iE_Extensions->list.count = 1;
 521    rrcVer->iE_Extensions->list.size = sizeof(struct RRC_Version_ExtIEs *);
 522    CU_ALLOC(rrcVer->iE_Extensions->list.array,\
 523          sizeof(struct RRC_Version_ExtIEs *));
 524    if(rrcVer->iE_Extensions->list.array == NULLP)
 525    {
 526       CU_FREE(rrcVer->iE_Extensions,\
 527             sizeof(ProtocolExtensionContainer_4624P81_t));
 528       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 529       CU_FREE(cuName->buf, sizeof(cuName->size));
 530       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 531       {
 532          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 533                sizeof(F1SetupResponseIEs_t));
 534       }
 535       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 536             elementCnt * sizeof(F1SetupResponseIEs_t *));
 537       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 538       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 539       return RFAILED;
 540    }
 541    CU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 542          sizeof(struct RRC_Version_ExtIEs));
 543    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 544    {
 545       CU_FREE(rrcVer->iE_Extensions->list.array,\
 546             sizeof(struct RRC_Version_ExtIEs *));
 547       CU_FREE(rrcVer->iE_Extensions,\
 548             sizeof(ProtocolExtensionContainer_4624P81_t));
 549       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 550       CU_FREE(cuName->buf, sizeof(cuName->size));
 551       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 552       {
 553          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 554                sizeof(F1SetupResponseIEs_t));
 555       }
 556       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 557             elementCnt * sizeof(F1SetupResponseIEs_t *));
 558       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 559       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 560       return RFAILED;
 561    }
 562    rrcVer->iE_Extensions->list.array[0]->id = \
 563                                               ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
 564    rrcVer->iE_Extensions->list.array[0]->criticality = Criticality_reject;
 565    rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
 566                                                                   RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
 567    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 568       Latest_RRC_Version_Enhanced.size = 3*sizeof(U8);
 569    CU_ALLOC(rrcVer->iE_Extensions->list.\
 570          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
 571          3*sizeof(U8));
 572    if(rrcVer->iE_Extensions->list.\
 573          array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
 574    {
 575       CU_FREE(rrcVer->iE_Extensions->list.array[0],\
 576             sizeof(struct RRC_Version_ExtIEs));
 577       CU_FREE(rrcVer->iE_Extensions->list.array,\
 578             sizeof(struct RRC_Version_ExtIEs *));
 579       CU_FREE(rrcVer->iE_Extensions,\
 580             sizeof(ProtocolExtensionContainer_4624P81_t));
 581       CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 582       CU_FREE(cuName->buf, sizeof(cuName->size));
 583       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
 584       {
 585          CU_FREE(f1SetupRsp->protocolIEs.list.array[ieIdx], \
 586                sizeof(F1SetupResponseIEs_t));
 587       }
 588       CU_FREE(f1SetupRsp->protocolIEs.list.array,\
 589             elementCnt * sizeof(F1SetupResponseIEs_t *));
 590       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 591       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 592       return RFAILED;
 593    }
 594    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 595       Latest_RRC_Version_Enhanced.buf[0] = 0;
 596    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 597       Latest_RRC_Version_Enhanced.buf[1] = 5;
 598    rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
 599       Latest_RRC_Version_Enhanced.buf[2] = 15;
 600
 601    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 602
 603    /* Encode the F1SetupRequest type as UPER */
 604    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 605    encBufSize = 0;
 606    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 607
 608    /* Clean up */
 609    CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
 610    CU_FREE(cuName->buf, sizeof(cuName->size));
 611    for(idx=0; idx<elementCnt; idx++)
 612    {
 613       CU_FREE(f1SetupRsp->protocolIEs.list.array[idx], sizeof(F1SetupResponseIEs_t));
 614    }
 615    CU_FREE(f1SetupRsp->protocolIEs.list.array, elementCnt * sizeof(F1SetupResponseIEs_t *));
 616    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 617    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 618
 619    /* Check encode results */
 620    if(encRetVal.encoded == ENCODE_FAIL)
 621    {
 622       DU_LOG("\nF1AP : Could not encode F1SetupResponse structure (at %s)\n",\
 623             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 624       return RFAILED;
 625    }
 626    else
 627    {
 628       DU_LOG("\nF1AP : Created APER encoded buffer for F1SetupResponse\n");
 629       for(int i=0; i< encBufSize; i++)
 630       {
 631          printf("%x",encBuf[i]);
 632       }
 633    }
 634
 635    /* Sending msg */
 636    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 637    {
 638       DU_LOG("\nF1AP : Sending F1 Setup Response failed");
 639       return RFAILED;
 640    }
 641
 642    return ROK;
 643 }/* End of BuildAndSendF1SetupRsp */
 644
 645 /*******************************************************************
 646  *
 647  * @brief Builds and sends the DUUpdateAcknowledge
 648  *
 649  * @details
 650  *
 651  *    Function : BuildAndSendDUUpdateAck
 652  *
 653  *    Functionality: Constructs the DU Update Acknowledge message and sends
 654  *                   it to the DU through SCTP.
 655  *
 656  * @params[in] void **buf,Buffer to which encoded pattern is written into
 657  * @params[in] int *size,size of buffer
 658  *
 659  * @return ROK     - success
 660  *         RFAILED - failure
 661  *
 662  * ****************************************************************/
 663
 664 S16 BuildAndSendDUUpdateAck()
 665 {
 666    U8   idx;
 667    U8   elementCnt;
 668    F1AP_PDU_t *f1apMsg = NULL;
 669    GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
 670    asn_enc_rval_t enRetVal; /* Encoder return value */
 671
 672    DU_LOG("\nF1AP : Building GNB-DU Config Update Ack\n");
 673
 674    /* Allocate the memory for F1SetupRequest_t */
 675    CU_ALLOC(f1apMsg, (Size)sizeof(F1AP_PDU_t));
 676    if(f1apMsg == NULLP)
 677    {
 678       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 679       return RFAILED;
 680    }
 681
 682    f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
 683
 684    CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 685    if(f1apMsg->choice.successfulOutcome == NULLP)
 686    {
 687       DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
 688       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 689       return RFAILED;
 690    }
 691
 692    f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_gNBDUConfigurationUpdate;
 693    f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
 694    f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge;
 695    gNBDuCfgAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
 696
 697    elementCnt = 1;
 698    gNBDuCfgAck->protocolIEs.list.count = elementCnt;
 699    gNBDuCfgAck->protocolIEs.list.size = elementCnt*sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t);
 700
 701    /* Initialize the F1Setup members */
 702    CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 703    if(gNBDuCfgAck->protocolIEs.list.array == NULLP)
 704    {
 705       DU_LOG("\nF1AP : Memory allocation for DuUpdateAcknowledgeIEs failed");
 706       CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 707       CU_FREE(f1apMsg,(Size)sizeof(F1AP_PDU_t));
 708       return RFAILED;
 709    }
 710
 711    for(idx=0; idx<elementCnt; idx++)
 712    {
 713       CU_ALLOC(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 714       if(gNBDuCfgAck->protocolIEs.list.array[idx] == NULLP)
 715       {
 716          CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 717          CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 718          CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 719          return RFAILED;
 720       }
 721    }
 722
 723    /*TransactionID*/
 724    idx = 0;
 725    gNBDuCfgAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID ;
 726    gNBDuCfgAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 727    gNBDuCfgAck->protocolIEs.list.array[idx]->value.present = GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID;
 728    gNBDuCfgAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
 729
 730    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 731
 732    /* Encode the F1SetupRequest type as UPER */
 733    memset(encBuf, 0, ENC_BUF_MAX_LEN);
 734    encBufSize = 0;
 735    enRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
 736
 737    /* Clean up */
 738    for(idx=0; idx<elementCnt; idx++)
 739    {
 740       CU_FREE(gNBDuCfgAck->protocolIEs.list.array[idx], sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t));
 741    }
 742    CU_FREE(gNBDuCfgAck->protocolIEs.list.array, elementCnt * sizeof(GNBDUConfigurationUpdateAcknowledgeIEs_t *));
 743    CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
 744    CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 745
 746    /* Checking encode results */
 747    if(enRetVal.encoded == ENCODE_FAIL)
 748    {
 749       DU_LOG("\nF1AP : Could not encode DUConfigUpdateAcknowledge structure (at %s)",enRetVal.failed_type ? enRetVal.failed_type->name : "unknown");
 750       return RFAILED;
 751    }
 752    else
 753    {
 754       DU_LOG("\nF1AP : Created APER encoded buffer for DuConfigUpdateAcknowledge\n");
 755       for(int i=0; i< encBufSize; i++)
 756       {
 757          printf("%x",encBuf[i]);
 758       }
 759    }
 760
 761    /* Sending msg */
 762    if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 763    {
 764       DU_LOG("\nF1AP : Sending GNB-DU Config Update Ack failed");
 765       return RFAILED;
 766    }
 767
 768    return ROK;
 769
 770 }/* End of BuildAndSendDUUpdateAck*/
 771 /*******************************************************************
 772 *
 773 * @brief deallocating the memory of  F1reset msg
 774 *
 775 * @details
 776 *
 777 *    Function : FreeF1ResetReq
 778 *
 779 *    Functionality :
 780 *         - freeing memory of F1reset request msg
 781 *
 782 * @params[in]
 783 * @return void
 784 *
 785 *
 786 * ****************************************************************/
 787 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
 788 {
 789     uint8_t idx = 0;
 790     Reset_t *f1ResetMsg = NULLP;
 791
 792     if(f1apMsg)
 793     {
 794        if(f1apMsg->choice.initiatingMessage)
 795        {
 796           f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 797           if(f1ResetMsg->protocolIEs.list.array)
 798           {
 799              for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
 800              {
 801                  if(f1ResetMsg->protocolIEs.list.array[idx])
 802                  {
 803                     CU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 804                  }
 805              }
 806              CU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 807           }
 808           CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 809        }
 810        CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
 811     }
 812 }
 813 /*******************************************************************
 814 *
 815 * @brief build ansld ans send f1reset msg
 816 *
 817 * @details
 818 *
 819 *    Function : BuildAndSendF1ResetReq
 820 *
 821 *    Functionality: build and send f1reset msg
 822 *
 823 * @return ROK     - success
 824 *         RFAILED - failure
 825 *
 826 * ****************************************************************/
 827 uint8_t BuildAndSendF1ResetReq()
 828 {
 829     uint8_t          elementCnt=0;
 830     uint8_t          idx=0;
 831     uint8_t          ret= RFAILED;
 832     Reset_t          *f1ResetMsg = NULLP;
 833     F1AP_PDU_t       *f1apMsg = NULLP;
 834     asn_enc_rval_t   encRetVal;
 835     DU_LOG("\nF1AP : Building F1 Reset request \n");
 836     do
 837     {
 838        CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
 839        if(f1apMsg == NULLP)
 840        {
 841           DU_LOG("\nF1AP : Memory allocation for the BuildAndSendF1ResetReq's F1AP-PDU failed");
 842           break;
 843        }
 844        f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
 845        CU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
 846        if(f1apMsg->choice.initiatingMessage == NULLP)
 847        {
 848           DU_LOG("\nF1AP : Memory allocation for BuildAndSendF1ResetReq failed");
 849           break;
 850        }
 851        f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
 852        f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
 853        f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
 854
 855        f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
 856
 857        elementCnt = 3;
 858        f1ResetMsg->protocolIEs.list.count = elementCnt;
 859        f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
 860
 861        /* Initialize the F1Reset members */
 862        CU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
 863        if(f1ResetMsg->protocolIEs.list.array == NULLP)
 864        {
 865           DU_LOG("\nF1AP : Memory allocation failed for BuildAndSendF1ResetReq");
 866           break;
 867        }
 868        for(idx=0; idx<elementCnt; idx++)
 869        {
 870            CU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
 871            if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
 872            {
 873               DU_LOG("\nF1AP : Memory allocation failed for BuildAndSendF1ResetReq msg array");
 874               break;
 875            }
 876        }
 877
 878        /*TransactionID*/
 879        idx=0;
 880        f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
 881        f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 882        f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
 883        f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
 884
 885        /*Cause*/
 886        idx++;
 887        f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
 888        f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
 889        f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
 890        f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
 891        f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
 892
 893        /*Reset Type*/
 894        idx++;
 895        f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
 896        f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
 897        f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
 898        f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
 899        f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
 900
 901        xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
 902
 903        /* Encode the F1SetupRequest type as APER */
 904        memset(encBuf, 0, ENC_BUF_MAX_LEN);
 905        encBufSize = 0;
 906        encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
 907                    encBuf);
 908
 909        /* Encode results */
 910        if(encRetVal.encoded == ENCODE_FAIL)
 911        {
 912           DU_LOG("\nF1AP : Could not encode F1Reset structure (at %s)\n",\
 913                       encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
 914           break;
 915        }
 916        else
 917        {
 918           DU_LOG("\nF1AP : Created APER encoded buffer for F1Reset\n");
 919           for(idx=0; idx< encBufSize; idx++)
 920           {
 921              printf("%x",encBuf[idx]);
 922           }
 923        }
 924
 925        if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
 926        {
 927           DU_LOG("\nF1AP : Sending F1 Reset request failed");
 928           break;
 929        }
 930
 931        ret = ROK;
 932        break;
 933     }while(true);
 934
 935     FreeF1ResetReq(f1apMsg);
 936     return ret;
 937  }
 938
 939 /*******************************************************************
 940  *
 941  * @brief Fills Radio Bearer Config
 942  *
 943  * @details
 944  *
 945  *    Function : fillSrbCfg
 946  *
 947  *    Functionality: Fills Radio Bearer Config
 948  *
 949  * @params[in] SRB_ToAddModList *
 950  *
 951  * @return ROK     - success
 952  *         RFAILED - failure
 953  *
 954  * ****************************************************************/
 955 uint8_t fillSrbCfg(uint8_t srbId, SRB_ToAddModList_t *bearerCfg)
 956 {
 957    uint8_t elementCnt;
 958    uint8_t idx, ieId;
 959    if(bearerCfg != NULLP)
 960    {
 961       elementCnt = 1;
 962       bearerCfg->list.count = elementCnt;
 963       bearerCfg->list.size =\
 964            elementCnt * sizeof(SRB_ToAddMod_t *);
 965       CU_ALLOC(bearerCfg->list.array, bearerCfg->list.size);
 966       if(bearerCfg->list.array != NULLP)
 967       {
 968          for(idx = 0; idx < elementCnt; idx++)
 969          {
 970             CU_ALLOC(bearerCfg->list.array[idx], sizeof(SRB_ToAddMod_t));
 971             if(bearerCfg->list.array[idx] == NULLP)
 972             {
 973                for(ieId = 0; ieId < idx; ieId++)
 974                {
 975                   CU_FREE(bearerCfg->list.array[ieId], sizeof(SRB_ToAddMod_t));
 976                }
 977                CU_FREE(bearerCfg->list.array, bearerCfg->list.size);
 978                return RFAILED;
 979             }
 980          }
 981       }
 982       else
 983       {
 984          return RFAILED;
 985       }
 986       idx = 0;
 987       bearerCfg->list.array[idx]->srb_Identity = srbId;
 988    }
 989    return ROK;
 990 }
 991
 992 /*******************************************************************
 993  *
 994  * @brief Fills Master CellGroup Info
 995  *
 996  * @details
 997  *
 998  *    Function : fillMasterCellGroup
 999  *
1000  *    Functionality: Fills Master Cell Group IE
1001  *
1002  * @params[in] RRCSetup_IEs_t *
1003  *
1004  * @return ROK     - success
1005  *         RFAILED - failure
1006  *
1007  * ****************************************************************/
1008
1009 uint8_t fillMasterCellGroup(OCTET_STRING_t *masterCellGroup)
1010 {
1011    uint8_t ret = ROK;
1012    masterCellGroup->buf = NULLP;
1013    if(f1apMsgDb.duToCuContainer.buf)
1014    {
1015       masterCellGroup->size = f1apMsgDb.duToCuContainer.size;
1016       CU_ALLOC(masterCellGroup->buf, masterCellGroup->size);
1017       if(masterCellGroup->buf != NULLP)
1018       {
1019          memcpy(masterCellGroup->buf, f1apMsgDb.duToCuContainer.buf,\
1020                masterCellGroup->size);
1021       }
1022       else
1023       {
1024          ret = RFAILED;
1025       }
1026    }
1027    else
1028    {
1029       ret =  RFAILED;
1030    }
1031    return ret;
1032 }
1033
1034 /*******************************************************************
1035  *
1036  * @brief Fills RRC setup IE
1037  *
1038  * @details
1039  *
1040  *    Function : fillRRCSetupIE
1041  *
1042  *    Functionality: Fills RRC Setup IE
1043  *
1044  * @params[in] RRCSetup_IEs_t *
1045  *
1046  * @return ROK     - success
1047  *         RFAILED - failure
1048  *
1049  * ****************************************************************/
1050
1051 uint8_t fillRRCSetupIE(RRCSetup_IEs_t *rrcSetupIE)
1052 {
1053    uint8_t ret = ROK;
1054    if(rrcSetupIE)
1055    {
1056       CU_ALLOC(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1057       if(rrcSetupIE->radioBearerConfig.srb_ToAddModList != NULLP)
1058       {
1059          ret = fillSrbCfg(SRB1, rrcSetupIE->radioBearerConfig.srb_ToAddModList);
1060       }
1061       if(ret == ROK)
1062       {
1063          ret = fillMasterCellGroup(&rrcSetupIE->masterCellGroup);
1064       }
1065       else
1066       {
1067          CU_FREE(rrcSetupIE->radioBearerConfig.srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1068          ret = RFAILED;
1069       }
1070    }
1071    return ret;
1072 }
1073 /*******************************************************************
1074  *
1075  * @brief Fills DL DCCCH Message required for DLRRCMessageTransfer
1076  *
1077  * @details
1078  *
1079  *    Function : fillDlCcchRrcMsg
1080  *
1081  *    Functionality: Fills DL DCCCH Message required for
1082  *                   DLRRCMessageTransfer
1083  *
1084  * @params[in] RRCContainer_t *rrcContainer
1085  *
1086  * @return ROK     - success
1087  *         RFAILED - failure
1088  *
1089  * ****************************************************************/
1090
1091 uint8_t fillDlCcchRrcMsg(RRCContainer_t *rrcContainer)
1092 {
1093    uint8_t ret = ROK;
1094    uint16_t idx2;
1095    DL_CCCH_Message_t dl_CCCH_Msg;
1096    asn_enc_rval_t        encRetVal;
1097
1098    if(rrcContainer != NULLP)
1099    {
1100       dl_CCCH_Msg.message.present = DL_CCCH_MessageType_PR_c1;
1101
1102       CU_ALLOC(dl_CCCH_Msg.message.choice.c1 , sizeof(DL_CCCH_MessageType_t));
1103       if(dl_CCCH_Msg.message.choice.c1 != NULLP)
1104       {
1105          dl_CCCH_Msg.message.choice.c1->present = DL_CCCH_MessageType__c1_PR_rrcSetup;
1106          CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup, sizeof(RRCSetup_t));
1107          if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup != NULLP)
1108          {
1109             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier = 0;
1110             dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->criticalExtensions.\
1111                present = RRCSetup__criticalExtensions_PR_rrcSetup;
1112             /* Fill RRC Setup IE */
1113             CU_ALLOC(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
1114                   criticalExtensions.choice.rrcSetup, sizeof(RRCSetup_IEs_t));
1115             if(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
1116                   criticalExtensions.choice.rrcSetup != NULLP)
1117             {
1118                ret = fillRRCSetupIE(dl_CCCH_Msg.message.choice.c1->choice.rrcSetup->\
1119                      criticalExtensions.choice.rrcSetup);
1120
1121                if(ret == ROK)
1122                {
1123                   /* encode DL-CCCH message into RRC Container */
1124                   xer_fprint(stdout, &asn_DEF_DL_CCCH_MessageType, &dl_CCCH_Msg);
1125                   memset(encBuf, 0, ENC_BUF_MAX_LEN);
1126                   encBufSize = 0;
1127                   encRetVal = aper_encode(&asn_DEF_DL_CCCH_MessageType, 0, &dl_CCCH_Msg, PrepFinalEncBuf, encBuf);
1128                   /* Encode results */
1129                   if(encRetVal.encoded == ENCODE_FAIL)
1130                   {
1131                      DU_LOG( "\n F1AP : Could not encode RRCContainer for DL-CCCH Msg(at %s)\n",\
1132                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1133                      return RFAILED;
1134                   }
1135                   else
1136                   {
1137                      DU_LOG("\n F1AP : Created APER encoded buffer for RRCContainer for DL-CCCH Msg\n");
1138                      for(int i = 0; i< encBufSize; i++)
1139                      {
1140                         printf("%x",encBuf[i]);
1141                      }
1142                      rrcContainer->size = encBufSize;
1143                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1144                      if(rrcContainer->buf != NULLP)
1145                      {
1146                         memset(rrcContainer->buf, 0, encBufSize);
1147                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1148                         {
1149                            rrcContainer->buf[idx2] =    encBuf[idx2];
1150                         }
1151                      }
1152                   }
1153                }
1154                else
1155                {
1156                   ret = RFAILED;
1157                }
1158             }
1159             else
1160             {
1161                DU_LOG("\nF1AP: Memory Alloc failed for RRC Setup Msg at fillDlCcchRrcMsg()");
1162                ret = RFAILED;
1163             }
1164          }
1165          else
1166          {
1167             DU_LOG("\nF1AP: Memory Alloc failed for RRC Msg at fillDlCcchRrcMsg()");
1168             ret = RFAILED;
1169          }
1170       }
1171       else
1172       {
1173          DU_LOG("\nF1AP: Memory Alloc failed for DL Ccch Msg choice at fillDlCcchRrcMsg()");
1174          ret = RFAILED;
1175       }
1176    }
1177    else
1178    {
1179       DU_LOG("\nF1AP: RRC Container is NULLP at fillDlCcchRrcMsg()");
1180       ret = RFAILED;
1181    }
1182 }
1183
1184 uint8_t fillQosFlowsToAdd(struct SDAP_Config__mappedQoS_FlowsToAdd *qosFlow)
1185 {
1186    uint8_t idx, ied, elementCnt;
1187
1188    elementCnt = 1;
1189    qosFlow->list.count = elementCnt;
1190    qosFlow->list.size  = elementCnt * sizeof(QFI_t *);
1191    CU_ALLOC(qosFlow->list.array, qosFlow->list.size);
1192    if(qosFlow->list.array != NULLP)
1193    {
1194       for(idx = 0; idx < elementCnt; idx++)
1195       {
1196          CU_ALLOC(qosFlow->list.array[idx], sizeof(QFI_t));
1197          if(qosFlow->list.array[idx] == NULLP)
1198          {
1199             for(ied = 0; ied < idx; ied++)
1200             {
1201                CU_FREE(qosFlow->list.array[idx], sizeof(QFI_t));
1202             }
1203             CU_FREE(qosFlow->list.array, qosFlow->list.size);
1204             return RFAILED;
1205          }
1206       }
1207    }
1208    idx = 0;
1209    *qosFlow->list.array[idx] = 9;
1210    return ROK;
1211 }
1212
1213 /*******************************************************************
1214  *
1215  * @brief Fills CN Assoc for Drb to Add/Mod List
1216  *
1217  * @details
1218  *
1219  *    Function : fillCnAssoc
1220  *
1221  *    Functionality: Fills CN Assoc for Drb to Add/Mod List
1222  *
1223  * @params[in] struct DRB_ToAddMod__cnAssociation *
1224  *
1225  * @return ROK     - success
1226  *         RFAILED - failure
1227  *
1228  * ****************************************************************/
1229
1230 uint8_t fillCnAssoc(struct DRB_ToAddMod__cnAssociation *cnAssoc)
1231 {
1232    uint8_t ret = ROK;
1233
1234    cnAssoc->present = DRB_ToAddMod__cnAssociation_PR_sdap_Config;
1235    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_eps_BearerIdentity)
1236    {
1237       cnAssoc->choice.eps_BearerIdentity = 5;
1238    }
1239    if(cnAssoc->present == DRB_ToAddMod__cnAssociation_PR_sdap_Config)
1240    {
1241       CU_ALLOC(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1242       if(cnAssoc->choice.sdap_Config)
1243       {
1244          cnAssoc->choice.sdap_Config->pdu_Session = 5;
1245          cnAssoc->choice.sdap_Config->sdap_HeaderDL = 0;
1246          cnAssoc->choice.sdap_Config->sdap_HeaderUL = 0;
1247          cnAssoc->choice.sdap_Config->defaultDRB = true;
1248          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd = NULLP;
1249          cnAssoc->choice.sdap_Config->mappedQoS_FlowsToRelease = NULLP;
1250          CU_ALLOC(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd, \
1251             sizeof(struct SDAP_Config__mappedQoS_FlowsToAdd));
1252          if(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd)
1253          {
1254             ret = fillQosFlowsToAdd(cnAssoc->choice.sdap_Config->mappedQoS_FlowsToAdd);
1255          }
1256          else
1257          {
1258             DU_LOG("\nF1AP: Memory alloc failed at mappedQoS_FlowsToAdd in fillCnAssoc()");
1259             CU_FREE(cnAssoc->choice.sdap_Config, sizeof(SDAP_Config_t));
1260             ret = RFAILED;
1261          }
1262       }
1263       else
1264       {
1265          DU_LOG("\nF1AP: Mem alloc failed at fillCnAssoc()");
1266          ret = RFAILED;
1267       }
1268    }
1269    return ret;
1270 }
1271
1272 /*******************************************************************
1273  *
1274  * @brief Fills Radio Bearer Config for Drb
1275  *
1276  * @details
1277  *
1278  *    Function : fillDrbCfg
1279  *
1280  *    Functionality: Fills Radio Bearer Config for Drb
1281  *
1282  * @params[in] drbId, DRB_ToAddModList *
1283  *
1284  * @return ROK     - success
1285  *         RFAILED - failure
1286  *
1287  * ****************************************************************/
1288 uint8_t fillDrbCfg(uint8_t drbId, DRB_ToAddModList_t *drbCfg)
1289 {
1290    uint8_t idx, ied, ret, elementCnt;
1291
1292    ret = ROK;
1293    if(drbCfg != NULLP)
1294    {
1295       elementCnt = 1;
1296       drbCfg->list.count = elementCnt;
1297       drbCfg->list.size =\
1298            elementCnt * sizeof(DRB_ToAddMod_t *);
1299       CU_ALLOC(drbCfg->list.array, drbCfg->list.size);
1300       if(drbCfg->list.array != NULLP)
1301       {
1302          for(idx = 0; idx < elementCnt; idx++)
1303          {
1304             CU_ALLOC(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1305             if(drbCfg->list.array[idx] == NULLP)
1306             {
1307                for(ied = 0; ied < idx; ied++)
1308                {
1309                   CU_FREE(drbCfg->list.array[idx], sizeof(DRB_ToAddMod_t));
1310                }
1311                CU_FREE(drbCfg->list.array, drbCfg->list.size);
1312                return RFAILED;
1313             }
1314          }
1315       }
1316       else
1317       {
1318          return RFAILED;
1319       }
1320       idx = 0;
1321       /* CN ASSOCIATION */
1322       CU_ALLOC(drbCfg->list.array[idx]->cnAssociation, sizeof(struct DRB_ToAddMod__cnAssociation));
1323       if(drbCfg->list.array[idx]->cnAssociation)
1324       {
1325          ret = fillCnAssoc(drbCfg->list.array[idx]->cnAssociation);
1326       }
1327       /* DRB */
1328       drbCfg->list.array[idx]->drb_Identity = drbId;
1329    }
1330    return ret;
1331 }
1332
1333 /*******************************************************************
1334  *
1335  * @brief Fills RRC Reconfig Message required for DLRRCMessageTransfer
1336  *
1337  * @details
1338  *
1339  *    Function : fillRrcReconfigIE
1340  *
1341  *    Functionality: Fills RRC Reconfig Message required for
1342  *                   DLRRCMessageTransfer
1343  *
1344  * @params[in] RRCReconfiguration_IEs_t* rrcReconfig
1345  *
1346  * @return ROK     - success
1347  *         RFAILED - failure
1348  *
1349  * ****************************************************************/
1350
1351 uint8_t fillRrcReconfigIE(RRCReconfiguration_IEs_t *rrcReconfigMsg)
1352 {
1353    uint8_t ret = ROK;
1354    CU_ALLOC(rrcReconfigMsg->radioBearerConfig, sizeof(RadioBearerConfig_t));
1355    if(rrcReconfigMsg->radioBearerConfig)
1356    {
1357       CU_ALLOC(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1358       if(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList != NULLP)
1359       {
1360          ret = fillSrbCfg(SRB2, rrcReconfigMsg->radioBearerConfig->srb_ToAddModList);
1361
1362       }
1363       if(ret == ROK)
1364       {
1365          CU_ALLOC(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1366          if(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList != NULLP)
1367          {
1368             ret = fillDrbCfg(DRB1, rrcReconfigMsg->radioBearerConfig->drb_ToAddModList);
1369             if(ret == RFAILED)
1370             {
1371                DU_LOG("\n F1AP: Failed to fill DrbCfg at fillRrcReconfigIE()");
1372                CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1373                CU_FREE(rrcReconfigMsg->radioBearerConfig->drb_ToAddModList, sizeof(DRB_ToAddModList_t));
1374             }
1375          }
1376       }
1377       else
1378       {
1379          DU_LOG("\n F1AP: memory Alloc failed at fillRrcReconfigIE()");
1380          CU_FREE(rrcReconfigMsg->radioBearerConfig->srb_ToAddModList, sizeof(SRB_ToAddModList_t));
1381       }
1382    }
1383
1384    return ret;
1385 }
1386 /*******************************************************************
1387  *
1388  * @brief Fills DL DCCH Message required for DLRRCMessageTransfer
1389  *
1390  * @details
1391  *
1392  *    Function : fillDlDcchRrcMsg
1393  *
1394  *    Functionality: Fills DL DCCH Message required for
1395  *                   DLRRCMessageTransfer
1396  *
1397  * @params[in] RRCContainer_t *rrcContainer
1398  *
1399  * @return ROK     - success
1400  *         RFAILED - failure
1401  *
1402  * ****************************************************************/
1403
1404 uint8_t fillDlDcchRrcMsg(RRCContainer_t *rrcContainer)
1405 {
1406    uint8_t ret = ROK;
1407    uint16_t idx2;
1408    DL_DCCH_Message_t dl_DCCH_Msg;
1409    memset(&dl_DCCH_Msg, 0, sizeof(DL_DCCH_Message_t));
1410    asn_enc_rval_t        encRetVal;
1411
1412    if(rrcContainer != NULLP)
1413    {
1414       dl_DCCH_Msg.message.present = DL_DCCH_MessageType_PR_c1;
1415
1416       CU_ALLOC(dl_DCCH_Msg.message.choice.c1 , sizeof(DL_DCCH_MessageType_t));
1417       if(dl_DCCH_Msg.message.choice.c1 != NULLP)
1418       {
1419          dl_DCCH_Msg.message.choice.c1->present = DL_DCCH_MessageType__c1_PR_rrcReconfiguration;
1420          CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration, sizeof(RRCReconfiguration_t));
1421          if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration != NULLP)
1422          {
1423             dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->rrc_TransactionIdentifier = 0;
1424             dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->criticalExtensions.\
1425                present = RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration;
1426             /* Fill RRC Reconfig IE */
1427             CU_ALLOC(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
1428                   criticalExtensions.choice.rrcReconfiguration, sizeof(RRCReconfiguration_IEs_t));
1429             if(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
1430                   criticalExtensions.choice.rrcReconfiguration != NULLP)
1431             {
1432                ret = fillRrcReconfigIE(dl_DCCH_Msg.message.choice.c1->choice.rrcReconfiguration->\
1433                      criticalExtensions.choice.rrcReconfiguration);
1434
1435                if(ret == ROK)
1436                {
1437                   /* encode DL-DCCH message into RRC Container */
1438                   xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
1439                   cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
1440                   encBufSize = 0;
1441                   encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
1442                   /* Encode results */
1443                   if(encRetVal.encoded == ENCODE_FAIL)
1444                   {
1445                      DU_LOG( "\n F1AP : Could not encode RRCContainer for DL-DCCH Msg (at %s)\n",\
1446                            encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1447                      return RFAILED;
1448                   }
1449                   else
1450                   {
1451                      DU_LOG("\n F1AP : Created APER encoded buffer for RRCContainer for DL-DCCH Msg\n");
1452                      for(int i = 0; i< encBufSize; i++)
1453                      {
1454                         printf("%x",encBuf[i]);
1455                      }
1456                      rrcContainer->size = encBufSize;
1457                      CU_ALLOC(rrcContainer->buf, rrcContainer->size);
1458                      if(rrcContainer->buf != NULLP)
1459                      {
1460                         memset(rrcContainer->buf, 0, encBufSize);
1461                         for(idx2 = 0; idx2 < encBufSize; idx2++)
1462                         {
1463                            rrcContainer->buf[idx2] =    encBuf[idx2];
1464                         }
1465                      }
1466                   }
1467                }
1468                else
1469                {
1470                   DU_LOG("\nF1AP: Failed to fill RrcReconfig IE at fillDlDcchRrcMsg()");
1471                }
1472             }
1473             else
1474             {
1475                DU_LOG("\nF1AP: Memory Alloc failed for RRC Reconfig at fillDlDcchRrcMsg()");
1476                ret = RFAILED;
1477             }
1478          }
1479          else
1480          {
1481             DU_LOG("\nF1AP: Memory Alloc failed for RRC Msg at fillDlDcchRrcMsg()");
1482             ret = RFAILED;
1483          }
1484       }
1485       else
1486       {
1487          DU_LOG("\nF1AP: Memory Alloc failed for DL Dcch Msg choice at fillDlDcchRrcMsg()");
1488          ret = RFAILED;
1489       }
1490    }
1491    else
1492    {
1493       DU_LOG("\nF1AP: RRC Container is NULLP at fillDlDcchRrcMsg()");
1494       ret = RFAILED;
1495    }
1496    return ret;
1497 }
1498
1499 /*******************************************************************
1500  *
1501  * @brief Builds RRC Container IE required for DLRRCMessageTransfer
1502  *
1503  * @details
1504  *
1505  *    Function : BuildDLRRCContainer
1506  *
1507  *    Functionality: Builds RRC Container IE required for
1508  *                   DLRRCMessageTransfer
1509  *
1510  * @params[in]
1511  *
1512  * @return ROK     - success
1513  *         RFAILED - failure
1514  *
1515  * ****************************************************************/
1516
1517 uint8_t BuildDLRRCContainer(uint8_t rrcMsgType, RRCContainer_t *rrcContainer)
1518 {
1519    uint8_t ret = ROK;
1520
1521    if(rrcMsgType == RRC_SETUP)
1522    {
1523       ret = fillDlCcchRrcMsg(rrcContainer);
1524       if(ret == RFAILED)
1525          DU_LOG("\n F1AP: Failed to fill DL-CCCH Msg at BuildDLRRCContainer()");
1526    }
1527    else if(rrcMsgType == RRC_RECONFIG)
1528    {
1529       ret = fillDlDcchRrcMsg(rrcContainer);
1530       if(ret == RFAILED)
1531          DU_LOG("\n F1AP: Failed at fill DL-DCCH Msg at BuildDLRRCContainer()");
1532    }
1533    return ret;
1534 }
1535
1536 /*******************************************************************
1537  *
1538  * @brief Builds and sends the DLRRCMessageTransfer
1539  *
1540  * @details
1541  *
1542  *    Function : BuildAndSendDLRRCMessageTransfer
1543  *
1544  *    Functionality: Constructs the DL RRC Message Transfer and sends
1545  *                   it to the CU through SCTP.
1546  *
1547  * @params[in]
1548  *
1549  * @return ROK     - success
1550  *         RFAILED - failure
1551  *
1552  * ****************************************************************/
1553 uint8_t BuildAndSendDLRRCMessageTransfer(uint8_t rrcMsgType)
1554 {
1555    uint8_t   elementCnt = 0;
1556    uint8_t  ieId;
1557    uint8_t  idx;
1558    F1AP_PDU_t  *f1apMsg = NULLP;
1559    DLRRCMessageTransfer_t  *dlRRCMsg = NULLP;
1560    asn_enc_rval_t   encRetVal;        /* Encoder return value */
1561
1562    DU_LOG("\n F1AP : Building DL RRC Message Transfer Message\n");
1563
1564    CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1565    if(f1apMsg == NULLP)
1566    {
1567       DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
1568       return RFAILED;
1569    }
1570
1571    f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1572    CU_ALLOC(f1apMsg->choice.initiatingMessage,
1573          sizeof(InitiatingMessage_t));
1574    if(f1apMsg->choice.initiatingMessage == NULLP)
1575    {
1576       DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
1577       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1578       return RFAILED;
1579    }
1580
1581    f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_DLRRCMessageTransfer;
1582    f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
1583    f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_DLRRCMessageTransfer;
1584    dlRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
1585
1586    elementCnt = 4;
1587    dlRRCMsg->protocolIEs.list.count = elementCnt;
1588    dlRRCMsg->protocolIEs.list.size = elementCnt * sizeof(DLRRCMessageTransferIEs_t *);
1589
1590    /* Initialize the F1Setup members */
1591    CU_ALLOC(dlRRCMsg->protocolIEs.list.array, dlRRCMsg->protocolIEs.list.size);
1592    if(dlRRCMsg->protocolIEs.list.array == NULLP)
1593    {
1594       DU_LOG(" F1AP : Memory allocation for DL RRC MessageTransferIEs failed");
1595       CU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1596       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1597       return RFAILED;
1598    }
1599
1600    for(idx=0; idx<elementCnt; idx++)
1601    {
1602       CU_ALLOC(dlRRCMsg->protocolIEs.list.array[idx], sizeof(DLRRCMessageTransferIEs_t));
1603       if(dlRRCMsg->protocolIEs.list.array[idx] == NULLP)
1604       {
1605          for(ieId=0; ieId<idx; ieId++)
1606          {
1607             CU_FREE(dlRRCMsg->protocolIEs.list.array[ieId],\
1608                   sizeof(DLRRCMessageTransferIEs_t));
1609          }
1610          CU_FREE(dlRRCMsg->protocolIEs.list.array,\
1611                dlRRCMsg->protocolIEs.list.size);
1612          CU_FREE(f1apMsg->choice.initiatingMessage,\
1613                sizeof(InitiatingMessage_t));
1614          CU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
1615          return RFAILED;
1616       }
1617    }
1618
1619    /* GNB CU UE F1AP ID */
1620    idx = 0;
1621    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
1622    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1623    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1624                                                           DLRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
1625    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
1626
1627    /* GNB DU UE F1AP ID */
1628    idx++;
1629    dlRRCMsg->protocolIEs.list.array[idx]->id  = \
1630                                                 ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
1631    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1632    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1633                                                           DLRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
1634    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
1635
1636    /* SRBID */
1637    idx++;
1638    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_SRBID;
1639    dlRRCMsg->protocolIEs.list.array[idx]->criticality  =   Criticality_reject;
1640    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1641                                                           DLRRCMessageTransferIEs__value_PR_SRBID;
1642    dlRRCMsg->protocolIEs.list.array[idx]->value.choice.SRBID = SRB1;
1643
1644    /* RRCContainer */
1645    idx++;
1646    dlRRCMsg->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_RRCContainer;
1647    dlRRCMsg->protocolIEs.list.array[idx]->criticality   = Criticality_reject;
1648    dlRRCMsg->protocolIEs.list.array[idx]->value.present = \
1649                                                           DLRRCMessageTransferIEs__value_PR_RRCContainer;
1650    BuildDLRRCContainer(rrcMsgType, &dlRRCMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer);
1651
1652    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1653
1654    /* Encode the F1SetupRequest type as APER */
1655    memset(encBuf, 0, ENC_BUF_MAX_LEN);
1656    encBufSize = 0;
1657    encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1658          encBuf);
1659    /* Encode results */
1660    if(encRetVal.encoded == ENCODE_FAIL)
1661    {
1662       DU_LOG( "\n F1AP : Could not encode DL RRC Message Transfer structure (at %s)\n",\
1663             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1664       return RFAILED;
1665    }
1666    else
1667    {
1668       DU_LOG("\n F1AP : Created APER encoded buffer for DL RRC Message transfer\n");
1669       for(int i=0; i< encBufSize; i++)
1670       {
1671          printf("%x",encBuf[i]);
1672       }
1673    }
1674
1675    /* Sending  msg  */
1676    if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)  !=  ROK)
1677    {
1678       DU_LOG("\n F1AP : Sending  DL RRC Message Transfer Failed");
1679       return RFAILED;
1680    }
1681
1682    return ROK;
1683 }/* End of BuildAndSendDLRRCMessageTransfer */
1684
1685 /*******************************************************************
1686  *
1687  * @brief Function to set the Dl RRC Msg Type
1688  *
1689  * @details
1690  *
1691  *    Function : setDlRRCMsgType
1692  *
1693  *    Functionality: Constructs the UE Setup Response and sends
1694  *                   it to the DU through SCTP.
1695  *
1696  * @params[in]
1697  *
1698  * @return ROK     - success
1699  *         RFAILED - failure
1700  *
1701  * ****************************************************************/
1702
1703 uint8_t setDlRRCMsgType()
1704 {
1705    uint8_t rrcMsgType = 0;
1706    switch(f1apMsgDb.dlRrcMsgCount)
1707    {
1708       case RRC_SETUP:
1709         rrcMsgType = RRC_SETUP;
1710         break;
1711       case RRC_SECURITY_MODE_COMMAND:
1712         rrcMsgType = RRC_SECURITY_MODE_COMMAND;
1713         break;
1714       case RRC_RECONFIG:
1715         rrcMsgType = RRC_RECONFIG;
1716         break;
1717       default:
1718         break;
1719    }
1720    return rrcMsgType;
1721 }
1722
1723 /*******************************************************************
1724  *
1725  * @brief Function to build Initial UL RRC Message
1726  *
1727  * @details
1728  *
1729  *    Function : procInitULRRCMsg
1730  *
1731  *    Functionality: Function to build Initial UL RRC Message
1732  *
1733  * @params[in]
1734  *
1735  * @return ROK     - success
1736  *         RFAILED - failure
1737  *
1738  * ****************************************************************/
1739
1740 uint8_t procInitULRRCMsg(F1AP_PDU_t *f1apMsg)
1741 {
1742    uint8_t idx, rrcMsgType;
1743    uint8_t ret =ROK;
1744    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
1745    DU_LOG("\n filling the required values in DB in procInitULRRCMsg");
1746
1747    initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
1748
1749    for(idx=0; idx < initULRRCMsg->protocolIEs.list.count; idx++)
1750    {
1751       switch(initULRRCMsg->protocolIEs.list.array[idx]->id)
1752       {
1753          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
1754             break;
1755          case ProtocolIE_ID_id_NRCGI:
1756             break;
1757          case ProtocolIE_ID_id_C_RNTI:
1758             break;
1759          case ProtocolIE_ID_id_RRCContainer:
1760             break;
1761          case ProtocolIE_ID_id_DUtoCURRCContainer:
1762             {
1763                if((initULRRCMsg->protocolIEs.list.array[idx]->value.choice\
1764                         .DUtoCURRCContainer.size > 0) && (initULRRCMsg->protocolIEs\
1765                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf != NULLP))
1766                {
1767                   DU_LOG("\n Received Du to Cu RRC Container ");
1768                   f1apMsgDb.duToCuContainer.size = initULRRCMsg->protocolIEs\
1769                                                    .list.array[idx]->value.choice.DUtoCURRCContainer.size;
1770                   CU_ALLOC(f1apMsgDb.duToCuContainer.buf, \
1771                         f1apMsgDb.duToCuContainer.size);
1772                   if(f1apMsgDb.duToCuContainer.buf != NULLP)
1773                   {
1774                      memcpy(f1apMsgDb.duToCuContainer.buf, initULRRCMsg->protocolIEs\
1775                            .list.array[idx]->value.choice.DUtoCURRCContainer.buf, f1apMsgDb\
1776                            .duToCuContainer.size);
1777                   }
1778                }
1779                else
1780                {
1781                   DU_LOG("\n Failed to receive Du to Cu RRC Container ");
1782                   ret = RFAILED;
1783                }
1784                break;
1785             }
1786          default:
1787             DU_LOG("\n Invalid Event %ld", initULRRCMsg->protocolIEs.list.array[idx]->id);
1788             break;
1789       }
1790    }
1791    if(ret == ROK)
1792    {
1793       f1apMsgDb.dlRrcMsgCount++;
1794       rrcMsgType = setDlRRCMsgType();
1795       ret = BuildAndSendDLRRCMessageTransfer(rrcMsgType);
1796    }
1797    return ret;
1798 }
1799
1800 /*******************************************************************
1801  *
1802  * @brief Builds Nrcgi
1803  *
1804  * @details
1805  *
1806  *    Function : BuildNrcgi
1807  *
1808  *    Functionality: Building the PLMN ID and NR Cell id
1809  *
1810  * @params[in] NRCGI_t *nrcgi
1811  * @return ROK     - success
1812  *         RFAILED - failure
1813  *
1814  * ****************************************************************/
1815 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
1816 {
1817    uint8_t ret;
1818    uint8_t unused = 4;
1819    uint8_t byteSize = 5;
1820    uint8_t val = 16;
1821    /* Allocate Buffer Memory */
1822    nrcgi->pLMN_Identity.size = 3 * sizeof(uint8_t);
1823    CU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
1824    if(nrcgi->pLMN_Identity.buf == NULLP)
1825    {
1826       return RFAILED;
1827    }
1828    ret = buildPlmnId(cuCfgParams.plmn , nrcgi->pLMN_Identity.buf);
1829
1830    if(ret != ROK)
1831    {
1832       return RFAILED;
1833    }
1834    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
1835    CU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
1836    if(nrcgi->nRCellIdentity.buf == NULLP)
1837    {
1838       return RFAILED;
1839    }
1840    ret = fillBitString(&nrcgi->nRCellIdentity, unused, byteSize, val);
1841    if(ret != ROK)
1842    {
1843       return RFAILED;
1844    }
1845    return ROK;
1846 }
1847 /*******************************************************************
1848  *
1849  * @brief Builds Special cell list for UE Setup Request
1850  *
1851  * @details
1852  *
1853  *    Function : BuildSplCellList
1854  *
1855  *    Functionality: Constructs the Special Cell list for UESetReq
1856  *
1857  * @params[in] SCell_ToBeSetup_List_t *spCellLst
1858  *
1859  * @return ROK     - success
1860  *         RFAILED - failure
1861  *
1862  * ****************************************************************/
1863 uint8_t BuildSplCellList(SCell_ToBeSetup_List_t *spCellLst)
1864 {
1865    uint8_t  cellCnt;
1866    uint8_t  idx;
1867    uint8_t  ret;
1868    cellCnt = 1;
1869    spCellLst->list.count = cellCnt;
1870    spCellLst->list.size = cellCnt * sizeof(SCell_ToBeSetup_ItemIEs_t *);
1871    CU_ALLOC(spCellLst->list.array,spCellLst->list.size);
1872    if(spCellLst->list.array == NULLP)
1873    {
1874       return RFAILED;
1875    }
1876    for(idx=0; idx<cellCnt; idx++)
1877    {
1878       CU_ALLOC(spCellLst->list.array[idx],sizeof(SCell_ToBeSetup_ItemIEs_t));
1879       if(spCellLst->list.array[idx] == NULLP)
1880       {
1881          return RFAILED;
1882       }
1883    }
1884    idx = 0;
1885    spCellLst->list.array[idx]->id = ProtocolIE_ID_id_SCell_ToBeSetup_Item;
1886    spCellLst->list.array[idx]->criticality = Criticality_ignore;
1887    spCellLst->list.array[idx]->value.present =\
1888                                               SCell_ToBeSetup_ItemIEs__value_PR_SCell_ToBeSetup_Item;
1889    /* Special Cell ID -NRCGI */
1890    ret = BuildNrcgi(&spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
1891    if(ret != ROK)
1892    {
1893       return RFAILED;
1894    }
1895    /*Special Cell Index*/
1896    spCellLst->list.array[idx]->value.choice.SCell_ToBeSetup_Item.sCellIndex = 1;
1897    return ROK;
1898 }/* End of BuildSplCellList*/
1899
1900 /*******************************************************************
1901  *
1902  * @brief Builds SRBS to be setup
1903  *
1904  * @details
1905  *
1906  *    Function : BuildSRBSetup
1907  *
1908  *    Functionality: Constructs the SRB's for UESetReq
1909  *
1910  * @params[in] SRBs_ToBeSetup_List_t *srbSet
1911  *
1912  * @return ROK     - success
1913  *         RFAILED - failure
1914  *
1915  * ****************************************************************/
1916 uint8_t BuildSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
1917 {
1918    uint8_t idx;
1919    uint8_t srbCnt;
1920    srbCnt = 1;
1921    srbSet->list.count = srbCnt;
1922    srbSet->list.size = srbCnt*sizeof(SRBs_ToBeSetup_ItemIEs_t *);
1923    CU_ALLOC(srbSet->list.array,srbSet->list.size);
1924    if(srbSet->list.array == NULLP)
1925    {
1926       return RFAILED;
1927    }
1928    for(idx=0; idx<srbCnt; idx++)
1929    {
1930       CU_ALLOC(srbSet->list.array[idx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
1931       if(srbSet->list.array[idx] == NULLP)
1932       {
1933          return RFAILED;
1934       }
1935    }
1936    idx = 0;
1937    srbSet->list.array[idx]->id = ProtocolIE_ID_id_SRBs_ToBeSetup_Item;
1938    srbSet->list.array[idx]->criticality = Criticality_ignore;
1939    srbSet->list.array[idx]->value.present = \
1940       SRBs_ToBeSetup_ItemIEs__value_PR_SRBs_ToBeSetup_Item;
1941    srbSet->list.array[idx]->value.choice.SRBs_ToBeSetup_Item.sRBID = 2;
1942    return ROK;
1943 }/* End of BuildSRBSetup*/
1944
1945 /*******************************************************************
1946  *
1947  * @brief Builds QOS Info for DRB Setum Item
1948  *
1949  * @details
1950  *
1951  *    Function : BuildQOSInfo
1952  *
1953  *    Functionality: Constructs the QOS Info for DRB Setup Item
1954  *
1955  * @params[in] QoSInformation_t *qosinfo
1956  *
1957  * @return ROK     - success
1958  *         RFAILED - failure
1959  *
1960  * ****************************************************************/
1961 uint8_t BuildQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
1962 {
1963    /* NonDynamic5QIDescriptor */
1964    drbQos->qoS_Characteristics.present = QoS_Characteristics_PR_non_Dynamic_5QI;
1965    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
1966    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI == NULLP)
1967    {
1968       return RFAILED;
1969    }
1970    /*FiveQI*/
1971    drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI = 0;
1972    /*AveragingWindow*/
1973    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
1974          sizeof(AveragingWindow_t));
1975    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow == \
1976          NULLP)
1977    {
1978       return RFAILED;
1979    }
1980    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow) = 0;
1981    /*MaxDataBurstVolume*/
1982    CU_ALLOC(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
1983          sizeof(MaxDataBurstVolume_t));
1984    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume == \
1985          NULLP)
1986    {
1987       return RFAILED;
1988    }
1989    *(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume) = 0;
1990
1991    /*nRGRAN Allocation Retention Priority*/
1992    drbQos->nGRANallocationRetentionPriority.priorityLevel = PriorityLevel_highest;
1993    drbQos->nGRANallocationRetentionPriority.pre_emptionCapability = Pre_emptionCapability_may_trigger_pre_emption;
1994    drbQos->nGRANallocationRetentionPriority.pre_emptionVulnerability = Pre_emptionVulnerability_not_pre_emptable;
1995
1996    /* TO DO: GBR_QoSFlowInformation */
1997    return ROK;
1998 }/*End of BuildQOSInfo*/
1999
2000 /*******************************************************************
2001  *
2002  * @brief Builds SNSSAI
2003  *
2004  * @details
2005  *
2006  *    Function : BuildSNSSAI
2007  *
2008  *    Functionality: Constructs the SNSSAI For DRB list
2009  *
2010  * @params[in] SNSSAI_t *snssai
2011  *
2012  * @return ROK     - success
2013  *         RFAILED - failure
2014  *
2015  * ****************************************************************/
2016 uint8_t BuildSNSSAI(SNSSAI_t *snssai)
2017 {
2018    /*SNSSAI*/
2019    /*ssT*/
2020    snssai->sST.size = sizeof(uint8_t);
2021    CU_ALLOC(snssai->sST.buf,snssai->sST.size);
2022    if(snssai->sST.buf == NULLP)
2023    {
2024       return RFAILED;
2025    }
2026    snssai->sST.buf[0] = 3;
2027    /*sD*/
2028    CU_ALLOC(snssai->sD,sizeof(OCTET_STRING_t));
2029    if(snssai->sD == NULLP)
2030    {
2031       return RFAILED;
2032    }
2033    snssai->sD->size = 3*sizeof(uint8_t);
2034    CU_ALLOC(snssai->sD->buf,snssai->sD->size);
2035    if(snssai->sD->buf == NULLP)
2036    {
2037       return RFAILED;
2038    }
2039    snssai->sD->buf[0] = 3;
2040    snssai->sD->buf[1] = 6;
2041    snssai->sD->buf[2] = 9;
2042    return ROK;
2043 }/*End of BuildSNSSAI*/
2044
2045 /*******************************************************************
2046  *
2047  * @brief Builds the flow map.
2048  *
2049  * @details
2050  *
2051  *    Function : BuildFlowsMap
2052  *
2053  *    Functionality: Constructs the flowmap For DRB list
2054  *
2055  * @params[in] Flows_Mapped_To_DRB_List_t *flowMap
2056  *
2057  * @return ROK     - success
2058  *         RFAILED - failure
2059  *
2060  * ****************************************************************/
2061 uint8_t BuildFlowsMap(Flows_Mapped_To_DRB_List_t *flowMap)
2062 {
2063    uint8_t  ret;
2064    uint8_t  idx;
2065    uint8_t  flowCnt;
2066    flowCnt = 1;
2067    flowMap->list.count = flowCnt;
2068    flowMap->list.size = flowCnt * sizeof(Flows_Mapped_To_DRB_Item_t *);
2069    CU_ALLOC(flowMap->list.array,flowMap->list.size);
2070    if(flowMap->list.array == NULLP)
2071    {
2072       return RFAILED;
2073    }
2074    for(idx=0; idx<flowCnt; idx++)
2075    {
2076       CU_ALLOC(flowMap->list.array[idx],sizeof(Flows_Mapped_To_DRB_Item_t));
2077       if(flowMap->list.array[idx] == NULLP)
2078       {
2079          return RFAILED;
2080       }
2081    }
2082    idx = 0;
2083    flowMap->list.array[idx]->qoSFlowIdentifier = 0;
2084    ret = BuildQOSInfo(&flowMap->list.array[idx]->qoSFlowLevelQoSParameters);
2085    if(ret != ROK)
2086    {
2087       return RFAILED;
2088    }
2089    return ROK;
2090 }/*End of BuildFlowsMap*/
2091
2092 /*******************************************************************
2093  *
2094  * @brief Builds the Uplink Tunnel Info
2095  *
2096  * @details
2097  *
2098  *    Function : BuildULTnlInfo
2099  *
2100  *    Functionality: Constructs the UL TnlInfo For DRB list
2101  *
2102  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2103  *
2104  * @return ROK     - success
2105  *         RFAILED - failure
2106  *
2107  * ****************************************************************/
2108 uint8_t BuildULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2109 {
2110    uint8_t idx;
2111    uint8_t ulCnt;
2112    ulCnt = 1;
2113    ulInfo->list.count = ulCnt;
2114    ulInfo->list.size = ulCnt * sizeof(ULUPTNLInformation_ToBeSetup_Item_t *);
2115    CU_ALLOC(ulInfo->list.array,ulInfo->list.size);
2116    if(ulInfo->list.array == NULLP)
2117    {
2118       return RFAILED;
2119    }
2120    for(idx=0; idx<ulCnt; idx++)
2121    {
2122       CU_ALLOC(ulInfo->list.array[idx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2123       if(ulInfo->list.array[idx] == NULLP)
2124       {
2125          return RFAILED;
2126       }
2127    }
2128    idx = 0;
2129    ulInfo->list.array[idx]->uLUPTNLInformation.present = \
2130                                                          UPTransportLayerInformation_PR_gTPTunnel;
2131    /*GTP TUNNEL*/
2132    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel,\
2133          sizeof(GTPTunnel_t));
2134    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel == NULLP)
2135    {
2136       return RFAILED;
2137    }
2138    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2139       transportLayerAddress.size        = 4*sizeof(uint8_t);
2140    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2141          transportLayerAddress.buf,ulInfo->list.array[idx]->\
2142          uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2143    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2144          transportLayerAddress.buf == NULLP)
2145    {
2146       return RFAILED;
2147    }
2148    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2149       transportLayerAddress.buf[0] = 4;
2150    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2151       transportLayerAddress.buf[1] = 4;
2152    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2153       transportLayerAddress.buf[2] = 4;
2154    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2155       transportLayerAddress.buf[3] = 5;
2156    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2157       transportLayerAddress.bits_unused = 0;
2158    /*GTP TEID*/
2159    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size\
2160       = 4 * sizeof(uint8_t);
2161    CU_ALLOC(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2162          gTP_TEID.buf,ulInfo->list.array[idx]->uLUPTNLInformation.choice.\
2163          gTPTunnel->gTP_TEID.size);
2164    if(ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2165          == NULLP)
2166    {
2167       return RFAILED;
2168    }
2169    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2170       gTP_TEID.buf[0] = 11;
2171    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2172       gTP_TEID.buf[1] = 0;
2173    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2174       gTP_TEID.buf[2] = 0;
2175    ulInfo->list.array[idx]->uLUPTNLInformation.choice.gTPTunnel->\
2176       gTP_TEID.buf[3] = 1;
2177
2178    return ROK;
2179 }/*End of BuildULTnlInfo*/
2180
2181 /*******************************************************************
2182  *
2183  * @brief Builds DRBS to be setup
2184  *
2185  * @details
2186  *
2187  *    Function : BuildDRBSetup
2188  *
2189  *    Functionality: Constructs the DRB's for UESetReq
2190  *
2191  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2192  *
2193  * @return ROK     - success
2194  *         RFAILED - failure
2195  *
2196  * ****************************************************************/
2197 uint8_t BuildDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2198 {
2199    uint8_t BuildQOSInforet;
2200    uint8_t BuildSNSSAIret;
2201    uint8_t BuildFlowsMapret;
2202    uint8_t BuildULTnlInforet;
2203    uint8_t idx;
2204    uint8_t drbCnt;
2205    DRBs_ToBeSetup_Item_t *drbSetItem;
2206    drbCnt = 1;
2207    drbSet->list.count = drbCnt;
2208    drbSet->list.size = drbCnt*sizeof(DRBs_ToBeSetup_ItemIEs_t *);
2209    CU_ALLOC(drbSet->list.array,drbSet->list.size);
2210    if(drbSet->list.array == NULLP)
2211    {
2212       return RFAILED;
2213    }
2214    for(idx=0; idx<drbCnt; idx++)
2215    {
2216       CU_ALLOC(drbSet->list.array[idx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2217       if(drbSet->list.array[idx] == NULLP)
2218       {
2219          return RFAILED;
2220       }
2221    }
2222    idx = 0;
2223    drbSet->list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_Item;
2224    drbSet->list.array[idx]->criticality = Criticality_ignore;
2225    drbSet->list.array[idx]->value.present = \
2226                                             DRBs_ToBeSetup_ItemIEs__value_PR_DRBs_ToBeSetup_Item;
2227    drbSetItem = &drbSet->list.array[idx]->value.choice.DRBs_ToBeSetup_Item;
2228    /*dRBID*/
2229    drbSetItem->dRBID = 1;
2230    /*qoSInformation*/
2231    drbSetItem->qoSInformation.present = QoSInformation_PR_choice_extension;
2232    CU_ALLOC(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2233    if(drbSetItem->qoSInformation.choice.choice_extension == NULLP)
2234    {
2235       return RFAILED;
2236    }
2237    drbSetItem->qoSInformation.choice.choice_extension->id = \
2238                                                             ProtocolIE_ID_id_DRB_Information;
2239    drbSetItem->qoSInformation.choice.choice_extension->criticality = \
2240                                                                      Criticality_ignore;
2241    drbSetItem->qoSInformation.choice.choice_extension->value.present = \
2242                                                                        QoSInformation_ExtIEs__value_PR_DRB_Information;
2243   BuildQOSInforet =  BuildQOSInfo(&drbSetItem->qoSInformation.choice.\
2244          choice_extension->value.choice.DRB_Information.dRB_QoS);
2245    if(BuildQOSInforet != ROK)
2246    {
2247       return RFAILED;
2248    }
2249    /*SNSSAI*/
2250    BuildSNSSAIret = BuildSNSSAI(&drbSetItem->qoSInformation.choice.\
2251          choice_extension->value.choice.DRB_Information.sNSSAI);
2252    if(BuildSNSSAIret != ROK)
2253    {
2254       return RFAILED;
2255    }
2256    /*Flows mapped to DRB List*/
2257    BuildFlowsMapret = BuildFlowsMap(&drbSetItem->qoSInformation.choice.\
2258          choice_extension->value.choice.DRB_Information.flows_Mapped_To_DRB_List);
2259    if(BuildFlowsMapret != ROK)
2260    {
2261       return RFAILED;
2262    }
2263    /*ULUPTNLInformation To Be Setup List*/
2264    BuildULTnlInforet = BuildULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2265    if(BuildULTnlInforet != ROK)
2266    {
2267       return RFAILED;
2268    }
2269    /*RLCMode*/
2270    drbSetItem->rLCMode = RLCMode_rlc_um_bidirectional;
2271
2272    /*UL Configuration*/
2273    CU_ALLOC(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
2274    if(drbSetItem->uLConfiguration == NULLP)
2275    {
2276       return RFAILED;
2277    }
2278    drbSetItem->uLConfiguration->uLUEConfiguration = ULUEConfiguration_no_data;
2279    return ROK;
2280 }/* End of BuildDRBSetup*/
2281
2282 /*******************************************************************
2283  *
2284  * @brief Deallocating memory of function BuildAndSendUESetReq
2285  *
2286  * @details
2287  *
2288  *    Function : FreeNrcgi
2289  *
2290  *    Functionality: Deallocating memory for function BuildNrcgi
2291  *
2292  * @params[in] NRCGI_t *nrcgi
2293  *
2294  * @return void
2295  *
2296  *******************************************************************/
2297 void FreeNrcgi(NRCGI_t *nrcgi)
2298 {
2299    if(nrcgi->pLMN_Identity.buf != NULLP)
2300    {
2301       if(nrcgi->nRCellIdentity.buf != NULLP)
2302       {
2303          CU_FREE(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
2304       }
2305       CU_FREE(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
2306    }
2307 }
2308 /*******************************************************************
2309  *
2310  * @brief  Deallocating memory of function BuildAndSendUESetReq
2311  *
2312  * @details
2313  *
2314  *    Function : FreeSplCellList
2315  *
2316  *    Functionality: Deallocating memory for function BuildSplCellList
2317  *
2318  * @params[in] SCell_ToBeSetup_List_t *spCellLst
2319  *
2320  * @return void
2321  *
2322  *
2323  * *****************************************************************/
2324 void FreeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
2325 {
2326    uint8_t  cellidx;
2327    if(spCellLst->list.array != NULLP)
2328    {
2329       for(cellidx=0; cellidx<spCellLst->list.count; cellidx++)
2330       {
2331          if(cellidx==0&&spCellLst->list.array[cellidx]!=NULLP)
2332          {
2333             FreeNrcgi(&spCellLst->list.array[cellidx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
2334          }
2335          if(spCellLst->list.array[cellidx]!=NULLP)
2336          {
2337             CU_FREE(spCellLst->list.array[cellidx],sizeof(SCell_ToBeSetup_ItemIEs_t));
2338          }
2339       }
2340       CU_FREE(spCellLst->list.array,spCellLst->list.size);
2341    }
2342 }
2343 /*******************************************************************
2344  *
2345  * @brief Deallocating memory of function BuildAndSendUESetReq
2346  *
2347  * @details
2348  *
2349  *    Function : FreeSRBSetup
2350  *
2351  *    Functionality: Deallocating memory for function BuildSRBSetup
2352  *
2353  * @params[in] SRBs_ToBeSetup_List_t *srbSet
2354  *
2355  * @return void
2356  *
2357  *
2358  * ******************************************************************/
2359 void FreeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
2360 {
2361    uint8_t srbidx;
2362    if(srbSet->list.array != NULLP)
2363    {
2364       for(srbidx=0; srbidx<srbSet->list.count; srbidx++)
2365       {
2366          if(srbSet->list.array[srbidx]!=NULLP)
2367          {
2368             CU_FREE(srbSet->list.array[srbidx],sizeof(SRBs_ToBeSetup_ItemIEs_t));
2369          }
2370       }
2371       CU_FREE(srbSet->list.array,srbSet->list.size);
2372    }
2373 }
2374 /*******************************************************************
2375  *
2376  * @brief Deallocating memory of function BuildAndSendUESetReq
2377  *
2378  * @details
2379  *
2380  *    Function : FreeQOSInfo
2381  *
2382  *    Functionality:  Deallocating memory for function BuildQOSInfo
2383  *
2384  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
2385  *
2386  * @return void
2387  *
2388  * ****************************************************************/
2389 void FreeQOSInfo(QoSFlowLevelQoSParameters_t *drbQos)
2390 {
2391    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
2392    {
2393       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2394       {
2395          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2396          {
2397             CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2398                   sizeof(MaxDataBurstVolume_t));
2399          }
2400          CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,\
2401                sizeof(AveragingWindow_t));
2402       }
2403       CU_FREE(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI,\
2404             sizeof(NonDynamic5QIDescriptor_t));
2405    }
2406 }
2407 /*******************************************************************
2408  *
2409  * @brief Deallocating memory of function BuildAndSendUESetReq
2410  *
2411  * @details
2412  *
2413  *    Function : FreeULTnlInfo
2414  *
2415  *    Functionality:  Deallocating memory for function BuildULTnlInfo
2416  *
2417  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
2418  *
2419  * @return void
2420  *
2421
2422  * ****************************************************************/
2423 void FreeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
2424 {
2425    uint8_t ulidx=0;
2426    if(ulInfo->list.array != NULLP)
2427    {
2428       for(ulidx=0; ulidx<ulInfo->list.count; ulidx++)
2429       {
2430          if(ulidx==0&&ulInfo->list.array[ulidx]!=NULLP)
2431          {
2432             if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
2433             {
2434                if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2435                      transportLayerAddress.buf != NULLP)
2436                {
2437                   if(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
2438                         !=NULLP)
2439                   {
2440                      CU_ALLOC(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2441                            gTP_TEID.buf,ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.\
2442                            gTPTunnel->gTP_TEID.size);
2443                   }
2444                   CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel->\
2445                         transportLayerAddress.buf,ulInfo->list.array[ulidx]->\
2446                         uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
2447                }
2448                CU_FREE(ulInfo->list.array[ulidx]->uLUPTNLInformation.choice.gTPTunnel,\
2449                      sizeof(GTPTunnel_t));
2450             }
2451          }
2452          if(ulInfo->list.array[ulidx]!=NULLP)
2453          {
2454             CU_FREE(ulInfo->list.array[ulidx],sizeof(ULUPTNLInformation_ToBeSetup_Item_t));
2455          }
2456       }
2457       CU_FREE(ulInfo->list.array,ulInfo->list.size);
2458    }
2459 }
2460 /*******************************************************************
2461  *
2462  * @brief Deallocating memory for BuildAndSendUESetReq
2463  *
2464  * @details
2465  *
2466  *    Function : FreeDRBSetup
2467  *
2468  *    Functionality:  Deallocating memory for BuildDRBSetup
2469  *
2470  * @params[in] DRBs_ToBeSetup_List_t *drbSet
2471  *
2472  * @return void
2473  *
2474  * ****************************************************************/
2475 void FreeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
2476 {
2477    DRBs_ToBeSetup_Item_t *drbSetItem;
2478    uint8_t  flowidx;
2479    uint8_t  drbidx;
2480    if(drbSet->list.array == NULLP)
2481    {
2482       for(drbidx=0; drbidx<drbSet->list.count; drbidx++)
2483       {
2484          if(drbidx==0&&drbSet->list.array[drbidx] != NULLP)
2485          {
2486             drbSetItem =&drbSet->list.array[drbidx]->value.choice.DRBs_ToBeSetup_Item;
2487             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
2488             {
2489                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2490                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
2491                {
2492                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2493                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2494                   {
2495                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2496                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2497                      {
2498                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
2499                         {
2500                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
2501                            {
2502                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf!=NULLP)
2503                               {
2504                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2505                                        flows_Mapped_To_DRB_List.list.array != NULLP)
2506                                  {
2507                                     for(flowidx=0;flowidx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2508                                           flows_Mapped_To_DRB_List.list.count; flowidx++)
2509                                     {
2510                                        if(flowidx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2511                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2512                                        {
2513                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2514                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2515                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
2516                                           {
2517                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2518                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2519                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
2520                                              {
2521                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2522                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2523                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
2524                                                 {
2525                                                    FreeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
2526                                                    CU_FREE(drbSetItem->uLConfiguration,sizeof(ULConfiguration_t));
2527
2528                                                    CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2529                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2530                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,\
2531                                                          sizeof(MaxDataBurstVolume_t));
2532                                                 }
2533                                                 CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2534                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2535                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2536                                              }
2537                                              CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2538                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]->qoSFlowLevelQoSParameters.\
2539                                                    qoS_Characteristics.choice.non_Dynamic_5QI,sizeof(NonDynamic5QIDescriptor_t));
2540                                           }
2541                                        }
2542                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2543                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx]!=NULLP)
2544                                        {
2545                                           CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
2546                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowidx],sizeof(Flows_Mapped_To_DRB_Item_t));
2547                                        }
2548                                     }
2549                                     CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
2550                                           flows_Mapped_To_DRB_List.list.array,drbSetItem->qoSInformation.choice.choice_extension->value.\
2551                                           choice.DRB_Information.flows_Mapped_To_DRB_List.list.size);
2552                                  }
2553                                  CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->buf,\
2554                                        drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->size);
2555                               }
2556                               CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD,\
2557                                     sizeof(OCTET_STRING_t));
2558                            }
2559                            CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf,\
2560                                  drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.size);
2561                         }
2562                         CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2563                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume,sizeof(MaxDataBurstVolume_t));
2564                      }
2565                      CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2566                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow,sizeof(AveragingWindow_t));
2567                   }
2568                   CU_FREE(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
2569                         qoS_Characteristics.choice.non_Dynamic_5QI, sizeof(NonDynamic5QIDescriptor_t));
2570                }
2571                CU_FREE(drbSetItem->qoSInformation.choice.choice_extension,sizeof(QoSInformation_ExtIEs_t));
2572             }
2573          }
2574          if(drbSet->list.array[drbidx]!=NULLP)
2575          {
2576             CU_FREE(drbSet->list.array[drbidx],sizeof(DRBs_ToBeSetup_ItemIEs_t));
2577          }
2578       }
2579       CU_FREE(drbSet->list.array,drbSet->list.size);
2580    }
2581 }
2582
2583
2584 /*******************************************************************
2585  *
2586  * @brief Free the UE Setup Request
2587  *
2588  * @details
2589  *
2590  *    Function : FreeUeContextSetupReq
2591  *
2592  *    Functionality: Deallocate the memory of BuildUESetReq
2593  *
2594  * @params[in]  F1AP_PDU_t  *f1apMsg
2595  *
2596  * @return void
2597  *
2598  *
2599  * ****************************************************************/
2600 void FreeUeContextSetupReq(F1AP_PDU_t  *f1apMsg)
2601 {
2602    uint8_t idx, ieId;
2603    UEContextSetupRequest_t  *ueSetReq = NULLP;
2604
2605    if(f1apMsg != NULLP)
2606    {
2607       if(f1apMsg->choice.initiatingMessage != NULLP)
2608       {
2609          ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
2610          if(ueSetReq->protocolIEs.list.array != NULLP)
2611          {
2612             for(idx = 0; idx < ueSetReq->protocolIEs.list.count; idx++)
2613             {
2614                if(ueSetReq->protocolIEs.list.array[idx])
2615                {
2616                   switch(ueSetReq->protocolIEs.list.array[idx]->id)
2617                   {
2618                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
2619                         break;
2620                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
2621                         break;
2622                      case ProtocolIE_ID_id_SpCell_ID:
2623                         FreeNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
2624                         break;
2625                      case ProtocolIE_ID_id_ServCellIndex:
2626                         break;
2627                      case ProtocolIE_ID_id_SpCellULConfigured:
2628                         break;
2629                      case ProtocolIE_ID_id_CUtoDURRCInformation:
2630                         FreeCuToDuInfo(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation);
2631                         break;
2632                      case ProtocolIE_ID_id_SCell_ToBeSetup_List:
2633                         FreeSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
2634                         break;
2635                      case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
2636                         FreeSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
2637                         break;
2638                      case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
2639                         FreeDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
2640                         break;
2641                      case ProtocolIE_ID_id_RRCContainer:
2642                         if(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf != NULLP)
2643                         {
2644                           CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
2645                           ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
2646                         }
2647                         break;
2648                      default:
2649                         printf("\nF1AP: Invalid event type %ld", ueSetReq->protocolIEs.list.array[idx]->id);
2650                   }
2651                }
2652                break;
2653             }
2654             for(ieId=0; ieId<idx; ieId++)
2655             {
2656                if(ueSetReq->protocolIEs.list.array[ieId] != NULLP)
2657                {
2658                   CU_FREE(ueSetReq->protocolIEs.list.array[ieId],sizeof(UEContextSetupRequestIEs_t));
2659                }
2660             }
2661             CU_FREE(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
2662          }
2663          CU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2664       }
2665       CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
2666    }
2667 }
2668
2669 /**Filling cell group info **/
2670 /*******************************************************************
2671  *
2672  * @brief Build Control resource set to add/modify list
2673  *
2674  * @details
2675  *
2676  *    Function : BuildControlRSetToAddModList
2677  *
2678  *    Functionality: Build Control resource set to add/modify list
2679  *
2680  * @params[in]
2681  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2682  *
2683  * @return ROK     - success
2684  *         RFAILED - failure
2685  *
2686  * ****************************************************************/
2687 uint8_t BuildControlRSetToAddModList
2688 (
2689 struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
2690 )
2691 {
2692    uint8_t idx;
2693    uint8_t elementCnt;
2694    uint8_t numBytes, bitsUnused;
2695    struct ControlResourceSet *controlRSet;
2696    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
2697    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
2698
2699    elementCnt = 1;
2700    controlRSetList->list.count = elementCnt;
2701    controlRSetList->list.size = \
2702        elementCnt * sizeof(struct ControlResourceSet *);
2703
2704    controlRSetList->list.array = NULLP;
2705    CU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
2706    if(!controlRSetList->list.array)
2707    {
2708       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2709       return RFAILED;
2710    }
2711
2712    for(idx = 0; idx < elementCnt; idx++)
2713    {
2714       controlRSetList->list.array[idx] = NULLP;
2715       CU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
2716       if(!controlRSetList->list.array[idx])
2717       {
2718          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2719          return RFAILED;
2720       }
2721    }
2722
2723    idx=0;
2724    controlRSet = controlRSetList->list.array[idx];
2725    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
2726
2727    /* Values harcoded according to our design:
2728     * size 6 bytes
2729     * 3 LSBs unsued
2730     * Bit string stored ff0000000000
2731     */
2732    numBytes = 6;
2733    bitsUnused = 3;
2734    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
2735    controlRSet->frequencyDomainResources.buf = NULLP;
2736         CU_ALLOC(controlRSet->frequencyDomainResources.buf, \
2737            controlRSet->frequencyDomainResources.size);
2738         if(!controlRSet->frequencyDomainResources.buf)
2739         {
2740            DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2741                 return RFAILED;
2742    }
2743
2744    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
2745    coreset0EndPrb = CORESET0_END_PRB;
2746    coreset1StartPrb = coreset0EndPrb + 6;
2747    coreset1NumPrb = CORESET1_NUM_PRB;
2748    /* calculate the PRBs */
2749    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
2750    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
2751    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
2752
2753    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
2754    controlRSet->cce_REG_MappingType.present = \
2755       ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
2756
2757    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
2758    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
2759         controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
2760         controlRSet->tci_PresentInDCI = NULLP;
2761 #if 0
2762    uint8_t tciStateIdx;
2763
2764    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
2765       sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
2766    if(!controlRset->tci_StatesPDCCH_ToAddList)
2767    {
2768       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2769       return RFAILED;
2770    }
2771
2772    elementCnt = 1;
2773    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
2774    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
2775    CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
2776       controlRset->tci_StatesPDCCH_ToAddList->list.size)
2777    if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
2778    {
2779       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2780       return RFAILED;
2781    }
2782
2783    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
2784    {
2785       CU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
2786       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
2787       {
2788          DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2789          return RFAILED;
2790       }
2791    }
2792
2793    tciStateIdx = 0;
2794    /* TODO */
2795    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
2796
2797    CU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
2798    if(!controlRset->tci_PresentInDCI)
2799    {
2800       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2801       return RFAILED;
2802    }
2803    /* TODO */
2804    *(controlRset->tci_PresentInDCI);
2805 #endif
2806
2807    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
2808    CU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
2809    if(!controlRSet->pdcch_DMRS_ScramblingID)
2810    {
2811       DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
2812       return RFAILED;
2813    }
2814    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
2815
2816    return ROK;
2817 } /* End BuildControlRSetToAddModList */
2818
2819 /*******************************************************************
2820  *
2821  * @brief Build search space to add/modify list
2822  *
2823  * @details
2824  *
2825  *    Function : BuildSearchSpcToAddModList
2826  *
2827  *    Functionality: Build search space to add/modify list
2828  *
2829  * @params[in]
2830  * @return ROK     - success
2831  *         RFAILED - failure
2832  *
2833  * ****************************************************************/
2834 uint8_t BuildSearchSpcToAddModList
2835 (
2836 struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
2837 )
2838 {
2839    uint8_t idx;
2840         uint8_t numBytes;
2841         uint8_t byteIdx;
2842         uint8_t bitsUnused;
2843    uint8_t elementCnt;
2844    struct SearchSpace *searchSpc;
2845
2846    elementCnt = 1;
2847    searchSpcList->list.count = elementCnt;
2848    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
2849
2850         searchSpcList->list.array = NULLP;
2851    CU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
2852    if(!searchSpcList->list.array)
2853    {
2854       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2855       return RFAILED;
2856    }
2857
2858    for(idx = 0; idx < elementCnt; idx++)
2859    {
2860            searchSpcList->list.array[idx] = NULLP;
2861       CU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
2862       if(!searchSpcList->list.array[idx])
2863       {
2864          DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2865          return RFAILED;
2866       }
2867    }
2868
2869    idx = 0;
2870    searchSpc = searchSpcList->list.array[idx];
2871
2872    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
2873
2874    searchSpc->controlResourceSetId = NULLP;
2875    CU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
2876    if(!searchSpc->controlResourceSetId)
2877    {
2878       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2879       return RFAILED;
2880    }
2881    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
2882
2883    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
2884    CU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
2885       sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
2886    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
2887         {
2888            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2889                 return RFAILED;
2890         }
2891    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
2892            SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
2893
2894    searchSpc->duration = NULLP;
2895    searchSpc->monitoringSymbolsWithinSlot = NULLP;
2896         CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
2897         if(!searchSpc->monitoringSymbolsWithinSlot)
2898         {
2899            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2900                 return RFAILED;
2901         }
2902
2903         /* Values taken from reference logs :
2904          * size 2 bytes
2905          * 2 LSBs unsued
2906          * Bit string stores 8000
2907          */
2908    numBytes = 2;
2909         bitsUnused = 2;
2910
2911    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
2912         searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
2913         CU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
2914            searchSpc->monitoringSymbolsWithinSlot->size);
2915         if(!searchSpc->monitoringSymbolsWithinSlot->buf)
2916         {
2917            DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2918                 return RFAILED;
2919         }
2920
2921         byteIdx = 0;
2922         searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
2923          PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
2924         searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
2925         searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
2926
2927    searchSpc->nrofCandidates = NULLP;
2928    CU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
2929    if(!searchSpc->nrofCandidates)
2930    {
2931       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2932       return RFAILED;
2933    }
2934
2935    searchSpc->nrofCandidates->aggregationLevel1 = \
2936            PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
2937    searchSpc->nrofCandidates->aggregationLevel2 = \
2938            PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
2939    searchSpc->nrofCandidates->aggregationLevel4 = \
2940            PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
2941    searchSpc->nrofCandidates->aggregationLevel8 = \
2942            PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
2943    searchSpc->nrofCandidates->aggregationLevel16 = \
2944            PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
2945
2946    searchSpc->searchSpaceType = NULLP;
2947    CU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
2948    if(!searchSpc->searchSpaceType)
2949    {
2950       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2951       return RFAILED;
2952    }
2953
2954    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
2955
2956    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
2957    CU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
2958       sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
2959    if(!searchSpc->searchSpaceType->choice.ue_Specific)
2960    {
2961       DU_LOG("\nF1AP : Memory allocation failed in BuildSearchSpcToAddModList");
2962       return RFAILED;
2963    }
2964    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
2965            PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
2966
2967    return ROK;
2968 }/* End BuildSearchSpcToAddModList */
2969
2970 /*******************************************************************
2971  *
2972  * @brief Builds BWP DL dedicated PDCCH config
2973  *
2974  * @details
2975  *
2976  *    Function : BuildBWPDlDedPdcchCfg
2977  *
2978  *    Functionality: Builds BWP DL dedicated PDCCH config
2979  *
2980  * @params[in] struct PDCCH_Config *pdcchCfg
2981  *
2982  * @return ROK     - success
2983  *         RFAILED - failure
2984  *
2985  * ****************************************************************/
2986 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
2987 {
2988    pdcchCfg->controlResourceSetToAddModList = NULLP;
2989    CU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
2990       sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
2991    if(!pdcchCfg->controlResourceSetToAddModList)
2992    {
2993       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
2994       return RFAILED;
2995    }
2996
2997         if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
2998         {
2999            return RFAILED;
3000         }
3001
3002    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3003
3004    pdcchCfg->searchSpacesToAddModList = NULLP;
3005         CU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3006            sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3007         if(!pdcchCfg->searchSpacesToAddModList)
3008         {
3009            DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3010                 return RFAILED;
3011         }
3012
3013         if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3014         {
3015            return RFAILED;
3016         }
3017
3018    pdcchCfg->searchSpacesToReleaseList = NULLP;
3019         pdcchCfg->downlinkPreemption = NULLP;
3020         pdcchCfg->tpc_PUSCH = NULLP;
3021         pdcchCfg->tpc_PUCCH = NULLP;
3022         pdcchCfg->tpc_SRS = NULLP;
3023
3024    return ROK;
3025 }
3026
3027 /*******************************************************************
3028  *
3029  * @brief Builds DMRS DL PDSCH Mapping type A
3030  *
3031  * @details
3032  *
3033  *    Function : BuildDMRSDLPdschMapTypeA
3034  *
3035  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3036  *
3037  * @params[in]
3038  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3039  * @return ROK     - success
3040  *         RFAILED - failure
3041  *
3042  * ****************************************************************/
3043 uint8_t BuildDMRSDLPdschMapTypeA
3044 (
3045 struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3046 )
3047 {
3048    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3049         dmrsDlCfg->choice.setup = NULLP;
3050    CU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3051    if(!dmrsDlCfg->choice.setup)
3052    {
3053       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3054       return RFAILED;
3055    }
3056
3057         dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3058         dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3059    CU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3060    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3061    {
3062       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3063       return RFAILED;
3064    }
3065    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3066
3067         dmrsDlCfg->choice.setup->maxLength = NULLP;
3068         dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3069         dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3070         dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3071
3072    return ROK;
3073 }
3074
3075 /*******************************************************************
3076  *
3077  * @brief Builds TCI states to add/modify list
3078  *
3079  * @details
3080  *
3081  *    Function : BuildTCIStatesToAddModList
3082  *
3083  *    Functionality:Builds TCI states to add/modify list
3084  *
3085  * @params[in]
3086  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3087  *
3088  * @return ROK     - success
3089  *         RFAILED - failure
3090  *
3091  * ****************************************************************/
3092 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3093 {
3094    return ROK;
3095 }
3096
3097 /*******************************************************************
3098  *
3099  * @brief Builds PDSCH time domain allocation list
3100  *
3101  * @details
3102  *
3103  *    Function : BuildPdschTimeDomAllocList
3104  *
3105  *    Functionality: Builds PDSCH time domain allocation list
3106  *
3107  * @params[in]
3108  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3109  *
3110  * @return ROK     - success
3111  *         RFAILED - failure
3112  *
3113  * ****************************************************************/
3114 uint8_t BuildPdschTimeDomAllocList
3115 (
3116 struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3117 )
3118 {
3119    uint8_t idx;
3120    uint8_t elementCnt;
3121         struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3122
3123    timeDomAllocList->present = \
3124            PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3125
3126    timeDomAllocList->choice.setup = NULLP;
3127    CU_ALLOC(timeDomAllocList->choice.setup, \
3128            sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3129    if(!timeDomAllocList->choice.setup)
3130         {
3131            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3132                 return RFAILED;
3133         }
3134
3135         elementCnt = 1;
3136         timeDomAllocList->choice.setup->list.count = elementCnt;
3137         timeDomAllocList->choice.setup->list.size = \
3138            elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3139
3140         timeDomAllocList->choice.setup->list.array = NULLP;
3141         CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3142            timeDomAllocList->choice.setup->list.size);
3143         if(!timeDomAllocList->choice.setup->list.array)
3144         {
3145            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3146                 return RFAILED;
3147         }
3148
3149         for(idx = 0; idx < elementCnt; idx++)
3150         {
3151            timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3152            CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3153                    sizeof(struct PDSCH_TimeDomainResourceAllocation));
3154                 if(!timeDomAllocList->choice.setup->list.array[idx])
3155                 {
3156                    DU_LOG("\nF1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3157                         return RFAILED;
3158                 }
3159         }
3160
3161         idx = 0;
3162         timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3163
3164    timeDomAlloc->k0 = NULLP;
3165    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3166    timeDomAlloc->startSymbolAndLength = 53;
3167
3168    return ROK;
3169 }
3170
3171 /*******************************************************************
3172  *
3173  * @brief Builds PDSCH PRB Bundling type
3174  *
3175  * @details
3176  *
3177  *    Function : BuildPdschPrbBundlingType
3178  *
3179  *    Functionality: Builds PDSCH PRB Bundling type
3180  *
3181  * @params[in]
3182  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3183  *
3184  * @return ROK     - success
3185  *         RFAILED - failure
3186  *
3187  * ****************************************************************/
3188 uint8_t BuildPdschPrbBundlingType
3189 (
3190 struct PDSCH_Config__prb_BundlingType *prbBndlType
3191 )
3192 {
3193    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3194
3195    prbBndlType->choice.staticBundling = NULLP;
3196         CU_ALLOC(prbBndlType->choice.staticBundling, \
3197            sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3198         if(!prbBndlType->choice.staticBundling)
3199         {
3200            DU_LOG("\nF1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3201                 return RFAILED;
3202         }
3203         prbBndlType->choice.staticBundling->bundleSize = NULLP;
3204
3205    return ROK;
3206 }
3207
3208 /*******************************************************************
3209  *
3210  * @brief Builds BWP DL dedicated PDSCH config
3211  *
3212  * @details
3213  *
3214  *    Function : BuildBWPDlDedPdschCfg
3215  *
3216  *    Functionality: Builds BWP DL dedicated PDSCH config
3217  *
3218  * @params[in] struct PDSCH_Config *pdschCfg
3219  *
3220  * @return ROK     - success
3221  *         RFAILED - failure
3222  *
3223  * ****************************************************************/
3224 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3225 {
3226    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3227
3228    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3229    CU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3230       sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3231    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3232    {
3233       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3234       return RFAILED;
3235    }
3236
3237    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3238    {
3239       return RFAILED;
3240    }
3241
3242    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3243    pdschCfg->tci_StatesToAddModList = NULLP;
3244    pdschCfg->tci_StatesToReleaseList = NULLP;
3245         pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3246 #if 0
3247    CU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3248    if(!pdschCfg->tci_StatesToAddModList)
3249    {
3250       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3251       return RFAILED;
3252    }
3253    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3254    {
3255       return RFAILED;
3256    }
3257 #endif
3258
3259         pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3260
3261    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3262         CU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3263            sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3264    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3265         {
3266       DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3267                 return RFAILED;
3268         }
3269         if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3270         {
3271            return RFAILED;
3272         }
3273    pdschCfg->pdsch_AggregationFactor = NULLP;
3274         pdschCfg->rateMatchPatternToAddModList = NULLP;
3275         pdschCfg->rateMatchPatternToReleaseList = NULLP;
3276         pdschCfg->rateMatchPatternGroup1 = NULLP;
3277         pdschCfg->rateMatchPatternGroup2 = NULLP;
3278         pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3279         pdschCfg->mcs_Table = NULLP;
3280
3281         pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3282         CU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3283         if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3284         {
3285            DU_LOG("\nF1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3286                 return RFAILED;
3287         }
3288         *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3289
3290         if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3291         {
3292            return RFAILED;
3293         }
3294
3295         pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3296         pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3297         pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3298         pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3299         pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3300         pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3301    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3302
3303    return ROK;
3304 }
3305
3306 /*******************************************************************
3307  *
3308  * @brief Builds intitial DL BWP
3309  * @details
3310  *
3311  *    Function : BuildInitialDlBWP
3312  *
3313  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3314  *
3315  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3316  *
3317  * @return ROK     - success
3318  *         RFAILED - failure
3319  *
3320  * ****************************************************************/
3321 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3322 {
3323    dlBwp->pdcch_Config = NULLP;
3324    CU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3325         if(!dlBwp->pdcch_Config)
3326         {
3327            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3328       return RFAILED;
3329         }
3330         dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3331
3332    dlBwp->pdcch_Config->choice.setup = NULLP;
3333         CU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3334    if(!dlBwp->pdcch_Config->choice.setup)
3335    {
3336            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3337                 return RFAILED;
3338         }
3339    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3340         {
3341            return RFAILED;
3342         }
3343
3344    dlBwp->pdsch_Config = NULLP;
3345         CU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3346         if(!dlBwp->pdsch_Config)
3347         {
3348            DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3349                 return RFAILED;
3350         }
3351         dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3352
3353    dlBwp->pdsch_Config->choice.setup = NULLP;
3354    CU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3355    if(!dlBwp->pdsch_Config->choice.setup)
3356    {
3357       DU_LOG("\nF1AP : Memory Allocation failure in BuildInitialDlBWP");
3358                 return RFAILED;
3359         }
3360
3361    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3362         {
3363            return RFAILED;
3364         }
3365
3366    dlBwp->sps_Config = NULLP;
3367    dlBwp->radioLinkMonitoringConfig = NULLP;
3368    return ROK;
3369 }
3370
3371 /*******************************************************************
3372  *
3373  * @brief Builds DMRS UL Pusch Mapping type A
3374  *
3375  * @details
3376  *
3377  *    Function : BuildDMRSULPuschMapTypeA
3378  *
3379  *    Functionality: Builds DMRS UL Pusch Mapping type A
3380  *
3381  * @params[in]
3382  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3383  * @return ROK     - success
3384  *         RFAILED - failure
3385  *
3386  * ****************************************************************/
3387 uint8_t BuildDMRSULPuschMapTypeA
3388 (
3389 struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
3390 )
3391 {
3392    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
3393    dmrsUlCfg->choice.setup= NULLP;
3394    CU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
3395    if(!dmrsUlCfg->choice.setup)
3396    {
3397       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3398       return RFAILED;
3399    }
3400
3401    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
3402         dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3403    CU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3404    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
3405    {
3406       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3407       return RFAILED;
3408    }
3409    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3410
3411         dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
3412         dmrsUlCfg->choice.setup->maxLength = NULLP;
3413    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
3414    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
3415       sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
3416    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
3417    {
3418       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3419       return RFAILED;
3420    }
3421
3422    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
3423    CU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
3424       sizeof(long));
3425    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
3426    {
3427       DU_LOG("\nF1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
3428       return RFAILED;
3429    }
3430    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
3431
3432         dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
3433         dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
3434    return ROK;
3435 }
3436
3437 /*******************************************************************
3438  *
3439  * @brief Build PUSCH time domain allocation list
3440  *
3441  * @details
3442  *
3443  *    Function : BuildPuschTimeDomAllocList
3444  *
3445  *    Functionality: Build PUSCH time domain allocation list
3446  *
3447  * @params[in]
3448  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3449  *
3450  * @return ROK     - success
3451  *         RFAILED - failure
3452  *
3453  * ****************************************************************/
3454 uint8_t BuildPuschTimeDomAllocList
3455 (
3456 struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
3457 )
3458 {
3459    uint8_t idx;
3460    uint8_t elementCnt;
3461    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
3462
3463    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
3464    timeDomAllocList->choice.setup = NULLP;
3465    CU_ALLOC(timeDomAllocList->choice.setup, \
3466       sizeof(struct PUSCH_TimeDomainResourceAllocationList));
3467    if(!timeDomAllocList->choice.setup)
3468    {
3469       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3470       return RFAILED;
3471    }
3472
3473    elementCnt = 1;
3474    timeDomAllocList->choice.setup->list.count = elementCnt;
3475    timeDomAllocList->choice.setup->list.size = \
3476       elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
3477         timeDomAllocList->choice.setup->list.array = NULLP;
3478    CU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3479       timeDomAllocList->choice.setup->list.size);
3480    if(!timeDomAllocList->choice.setup->list.array)
3481    {
3482       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3483       return RFAILED;
3484    }
3485
3486    for(idx = 0; idx < elementCnt; idx++)
3487    {
3488            timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3489       CU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
3490          sizeof(PUSCH_TimeDomainResourceAllocation_t));
3491       if(!timeDomAllocList->choice.setup->list.array[idx])
3492       {
3493          DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3494          return RFAILED;
3495       }
3496    }
3497
3498    idx = 0;
3499    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3500    CU_ALLOC(timeDomAlloc->k2, sizeof(long));
3501    if(!timeDomAlloc->k2)
3502    {
3503       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
3504       return RFAILED;
3505    }
3506    *(timeDomAlloc->k2) = PUSCH_K2;
3507    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
3508    timeDomAlloc->startSymbolAndLength = 27;
3509    return ROK;
3510 }
3511
3512 /*******************************************************************
3513  *
3514  * @brief Builds BWP UL dedicated PUSCH Config
3515  *
3516  * @details
3517  *
3518  *    Function : BuildBWPUlDedPuschCfg
3519  *
3520  *    Functionality:
3521  *      Builds BWP UL dedicated PUSCH Config
3522  *
3523  * @params[in] : PUSCH_Config_t *puschCfg
3524  *
3525  * @return ROK     - success
3526  *         RFAILED - failure
3527  *
3528  * ****************************************************************/
3529 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
3530 {
3531    puschCfg->dataScramblingIdentityPUSCH = NULLP;
3532    CU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
3533    if(!puschCfg->dataScramblingIdentityPUSCH)
3534    {
3535       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3536       return RFAILED;
3537    }
3538    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
3539
3540    puschCfg->txConfig = NULLP;
3541         puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
3542    CU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
3543       sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
3544    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
3545    {
3546       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3547       return RFAILED;
3548    }
3549
3550    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
3551    {
3552       return RFAILED;
3553    }
3554
3555    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
3556         puschCfg->pusch_PowerControl = NULLP;
3557         puschCfg->frequencyHopping = NULLP;
3558         puschCfg->frequencyHoppingOffsetLists = NULLP;
3559    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
3560
3561    puschCfg->pusch_TimeDomainAllocationList = NULLP;
3562    CU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
3563       sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
3564    if(!puschCfg->pusch_TimeDomainAllocationList)
3565    {
3566       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3567       return RFAILED;
3568    }
3569
3570    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
3571    {
3572       return RFAILED;
3573    }
3574
3575    puschCfg->pusch_AggregationFactor = NULLP;
3576         puschCfg->mcs_Table = NULLP;
3577         puschCfg->mcs_TableTransformPrecoder = NULLP;
3578    puschCfg->transformPrecoder = NULLP;
3579    CU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
3580    if(!puschCfg->transformPrecoder)
3581    {
3582       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedPuschCfg");
3583       return RFAILED;
3584    }
3585    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
3586
3587         puschCfg->codebookSubset = NULLP;
3588         puschCfg->maxRank = NULLP;
3589         puschCfg->rbg_Size = NULLP;
3590         puschCfg->uci_OnPUSCH = NULLP;
3591         puschCfg->tp_pi2BPSK = NULLP;
3592
3593    return ROK;
3594 }
3595
3596 /*******************************************************************
3597  *
3598  * @brief Fills SRS resource to add/modify list
3599  *
3600  * @details
3601  *
3602  *    Function : BuildSrsRsrcAddModList
3603  *
3604  *    Functionality: Fills SRS resource to add/modify list
3605  *
3606  * @params[in]
3607  * @return ROK     - success
3608  *         RFAILED - failure
3609  *
3610  * ****************************************************************/
3611 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
3612 {
3613    uint8_t   elementCnt;
3614    uint8_t   rsrcIdx;
3615
3616    elementCnt = 1;
3617    resourceList->list.count = elementCnt;
3618    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
3619    resourceList->list.array = NULLP;
3620    CU_ALLOC(resourceList->list.array, resourceList->list.size);
3621    if(!resourceList->list.array)
3622    {
3623       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3624       return RFAILED;
3625    }
3626
3627    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
3628    {
3629       CU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
3630       if(!resourceList->list.array[rsrcIdx])
3631       {
3632          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3633          return RFAILED;
3634       }
3635    }
3636
3637    rsrcIdx = 0;
3638    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
3639    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
3640    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
3641
3642    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
3643    CU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
3644       sizeof(struct SRS_Resource__transmissionComb__n2));
3645    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
3646    {
3647       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3648       return RFAILED;
3649    }
3650    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
3651            = SRS_COMB_OFFSET_N2;
3652    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
3653            = SRS_CYCLIC_SHIFT_N2;
3654
3655    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
3656            0;
3657    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
3658       SRS_Resource__resourceMapping__nrofSymbols_n1;
3659    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
3660       SRS_Resource__resourceMapping__repetitionFactor_n1;
3661
3662    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
3663    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
3664    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
3665    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
3666    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
3667    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
3668       SRS_Resource__groupOrSequenceHopping_neither;
3669
3670    /* Setting resource type to aperiodic for intergration purposes */
3671    resourceList->list.array[rsrcIdx]->resourceType.present = \
3672            SRS_Resource__resourceType_PR_aperiodic;
3673    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
3674    CU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
3675       sizeof(struct SRS_Resource__resourceType__aperiodic));
3676    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
3677    {
3678       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcAddModList");
3679       return RFAILED;
3680    }
3681    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
3682
3683    return ROK;
3684 }
3685
3686 /*******************************************************************
3687  *
3688  * @brief Build SRS resource set Add/mod list
3689  *
3690  * @details
3691  *
3692  *    Function : BuildSrsRsrcSetAddModList
3693  *
3694  *    Functionality: Build SRS resource set Add/mod list
3695  *
3696  * @params[in]
3697  * @return ROK     - success
3698  *         RFAILED - failure
3699  *
3700  * ****************************************************************/
3701 uint8_t BuildSrsRsrcSetAddModList
3702 (
3703 struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
3704 )
3705 {
3706    uint8_t  elementCnt;
3707    uint8_t  rSetIdx;
3708         uint8_t  rsrcIdx;
3709         struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
3710
3711    elementCnt = 1;
3712    rsrcSetList->list.count = elementCnt;
3713    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
3714    rsrcSetList->list.array = NULLP;
3715    CU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
3716    if(!rsrcSetList->list.array)
3717    {
3718       DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3719       return RFAILED;
3720    }
3721
3722    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
3723    {
3724       CU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
3725       if(!rsrcSetList->list.array[rSetIdx])
3726       {
3727          DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3728          return RFAILED;
3729       }
3730    }
3731
3732    rSetIdx = 0;
3733    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
3734
3735         /* Fill Resource Id list in resource set */
3736         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
3737         CU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
3738            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
3739         if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
3740         {
3741            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3742                 return RFAILED;
3743         }
3744
3745         elementCnt = 1;
3746         rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
3747         rsrcIdList->list.count = elementCnt;
3748         rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
3749         rsrcIdList->list.array = NULLP;
3750         CU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
3751         if(!rsrcIdList->list.array)
3752         {
3753            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3754                 return RFAILED;
3755         }
3756
3757         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
3758         {
3759            CU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
3760                 if(!rsrcIdList->list.array[rsrcIdx])
3761                 {
3762                    DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3763                         return RFAILED;
3764                 }
3765         }
3766
3767         rsrcIdx = 0;
3768         *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
3769
3770         /* Fill resource type */
3771    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
3772       SRS_ResourceSet__resourceType_PR_aperiodic;
3773
3774    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
3775    CU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
3776       sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
3777    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
3778    {
3779            DU_LOG("\nF1AP: Memory allocation failed in BuildSrsRsrcSetAddModList");
3780                 return RFAILED;
3781         }
3782    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
3783            = APERIODIC_SRS_RESRC_TRIGGER;
3784
3785         /* TODO : Fill values for below IEs as expected by Viavi */
3786         rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
3787    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
3788
3789
3790    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
3791         rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
3792         rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
3793         rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
3794         rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
3795
3796    return ROK;
3797 }
3798
3799 /*******************************************************************
3800  *
3801  * @brief Builds BWP UL dedicated SRS Config
3802  *
3803  * @details
3804  *
3805  *    Function : BuildBWPUlDedSrsCfg
3806  *
3807  *    Functionality: Builds BWP UL dedicated SRS Config
3808  *
3809  * @params[in] SRS Config
3810  * @return ROK     - success
3811  *         RFAILED - failure
3812  *
3813  * ****************************************************************/
3814 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
3815 {
3816    srsCfg->srs_ResourceSetToReleaseList = NULLP;
3817    srsCfg->srs_ResourceSetToAddModList = NULLP;
3818    CU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
3819       sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
3820    if(!srsCfg->srs_ResourceSetToAddModList)
3821    {
3822       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3823       return RFAILED;
3824    }
3825    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
3826    {
3827       return RFAILED;
3828    }
3829
3830    srsCfg->srs_ResourceToReleaseList = NULLP;
3831
3832    /* Resource to Add/Modify list */
3833    srsCfg->srs_ResourceToAddModList = NULLP;
3834    CU_ALLOC(srsCfg->srs_ResourceToAddModList, \
3835       sizeof(struct SRS_Config__srs_ResourceToAddModList));
3836    if(!srsCfg->srs_ResourceToAddModList)
3837    {
3838       DU_LOG("\nF1AP: Memory allocation failed in BuildBWPUlDedSrsCfg");
3839       return RFAILED;
3840    }
3841
3842    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
3843    {
3844       return RFAILED;
3845    }
3846
3847    srsCfg->tpc_Accumulation = NULLP;
3848
3849    return ROK;
3850 }
3851
3852 /*******************************************************************
3853  *
3854  * @brief Builds inital UL BWP
3855  *
3856  * @details
3857  *
3858  *    Function : BuildInitialUlBWP
3859  *
3860  *    Functionality: Builds initial UL BWP
3861  *
3862  * @params[in] BWP_UplinkDedicated_t *ulBwp
3863  * @return ROK     - success
3864  *         RFAILED - failure
3865  *
3866  * ****************************************************************/
3867 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
3868 {
3869    ulBwp->pucch_Config = NULLP;
3870
3871    /* Fill BWP UL dedicated PUSCH config */
3872         ulBwp->pusch_Config = NULLP;
3873    CU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
3874    if(!ulBwp->pusch_Config)
3875    {
3876       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3877       return RFAILED;
3878    }
3879
3880    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
3881    ulBwp->pusch_Config->choice.setup = NULLP;
3882    CU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
3883    if(!ulBwp->pusch_Config->choice.setup)
3884    {
3885       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3886       return RFAILED;
3887    }
3888
3889    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
3890    {
3891       return RFAILED;
3892    }
3893
3894         ulBwp->configuredGrantConfig = NULLP;
3895
3896    /* Fill BPW UL dedicated SRS config */
3897         ulBwp->srs_Config = NULLP;
3898    CU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
3899    if(!ulBwp->srs_Config)
3900    {
3901       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3902       return RFAILED;
3903    }
3904
3905    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
3906    ulBwp->srs_Config->choice.setup = NULLP;
3907    CU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
3908    if(!ulBwp->srs_Config->choice.setup)
3909    {
3910       DU_LOG("\nF1AP : Memory allocation failed in BuildInitialUlBWP");
3911       return RFAILED;
3912    }
3913
3914    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
3915    {
3916       return RFAILED;
3917    }
3918
3919         ulBwp->beamFailureRecoveryConfig = NULLP;
3920
3921    return ROK;
3922 }
3923
3924 /*******************************************************************
3925 *
3926 * @brief Builds Pusch Serving cell Config
3927 *
3928 * @details
3929 *
3930 *    Function : BuildPuschSrvCellCfg
3931 *
3932 *    Functionality: Builds Pusch Serving cell Config
3933 *
3934 * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
3935 *
3936 * @return ROK     - success
3937 *         RFAILED - failure
3938 *
3939 * ****************************************************************/
3940 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
3941 {
3942    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
3943    puschCfg->choice.setup = NULLP;
3944    CU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
3945    if(!puschCfg->choice.setup)
3946    {
3947       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3948       return RFAILED;
3949    }
3950
3951    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
3952         puschCfg->choice.setup->rateMatching = NULLP;
3953         puschCfg->choice.setup->xOverhead = NULLP;
3954    puschCfg->choice.setup->ext1 = NULLP;
3955    CU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
3956    if(!puschCfg->choice.setup->ext1)
3957    {
3958       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3959       return RFAILED;
3960    }
3961
3962    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
3963    CU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
3964    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
3965    {
3966       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3967       return RFAILED;
3968    }
3969    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
3970
3971    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
3972    CU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
3973    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
3974    {
3975       DU_LOG("\nF1AP : Memory allocation failed in BuildPuschSrvCellCfg");
3976       return RFAILED;
3977    }
3978    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
3979    return ROK;
3980 }
3981
3982 /*******************************************************************
3983  *
3984  * @brief Builds UL config
3985  * @details
3986  *
3987  *    Function : BuildUlCfg
3988  *
3989  *    Functionality: Builds UL config in spCellCfgDed
3990  *
3991  * @params[in] UplinkConfig_t *ulCfg
3992  *
3993  * @return ROK     - success
3994  *         RFAILED - failure
3995  *
3996  * ****************************************************************/
3997 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
3998 {
3999    ulCfg->initialUplinkBWP = NULLP;
4000    CU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4001         if(!ulCfg->initialUplinkBWP)
4002         {
4003            DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
4004                 return RFAILED;
4005         }
4006
4007    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4008         {
4009            return RFAILED;
4010         }
4011
4012    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4013         ulCfg->uplinkBWP_ToAddModList = NULLP;
4014         ulCfg->firstActiveUplinkBWP_Id = NULLP;
4015    CU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4016    if(!ulCfg->firstActiveUplinkBWP_Id)
4017    {
4018       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
4019       return RFAILED;
4020    }
4021    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4022
4023    ulCfg->pusch_ServingCellConfig = NULLP;
4024    CU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4025       sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4026    if(!ulCfg->pusch_ServingCellConfig)
4027    {
4028       DU_LOG("\nF1AP : Memory Allocation failed in BuildUlCfg");
4029       return RFAILED;
4030    }
4031
4032    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4033    {
4034       return RFAILED;
4035    }
4036
4037         ulCfg->carrierSwitching = NULLP;
4038         ulCfg->ext1 = NULLP;
4039         return ROK;
4040 }
4041
4042 /*******************************************************************
4043  *
4044  * @brief Builds PDSCH serving cell config
4045  * @details
4046  *
4047  *    Function : BuildPdschSrvCellCfg
4048  *
4049  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4050  *
4051  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4052  *
4053  * @return ROK     - success
4054  *         RFAILED - failure
4055  *
4056  * ****************************************************************/
4057 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4058 {
4059    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4060    pdschCfg->choice.setup = NULLP;
4061    CU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4062    if(!pdschCfg->choice.setup)
4063    {
4064       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4065       return RFAILED;
4066    }
4067
4068    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4069         pdschCfg->choice.setup->xOverhead = NULLP;
4070    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4071    CU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4072    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4073    {
4074       DU_LOG("\nF1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4075       return RFAILED;
4076    }
4077    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4078         pdschCfg->choice.setup->pucch_Cell = NULLP;
4079         pdschCfg->choice.setup->ext1 = NULLP;
4080
4081    return ROK;
4082 }
4083
4084 /*******************************************************************
4085  *
4086  * @brief Builds CSI Meas config
4087  * @details
4088  *
4089  *    Function : BuildCsiMeasCfg
4090  *
4091  *    Functionality: Builds CSI Meas config in spCellCfgDed
4092  *
4093  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4094  *
4095  * @return ROK     - success
4096  *         RFAILED - failure
4097  *
4098  * ****************************************************************/
4099 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4100 {
4101
4102    return ROK;
4103 }
4104
4105 /*******************************************************************
4106  *
4107  * @brief Builds Spcell config dedicated
4108  * @details
4109  *
4110  *    Function : BuildSpCellCfgDed
4111  *
4112  *    Functionality: Builds sp cell config dedicated in spCellCfg
4113  *
4114  * @params[in] ServingCellConfig_t srvCellCfg
4115  *
4116  * @return ROK     - success
4117  *         RFAILED - failure
4118  *
4119  * ****************************************************************/
4120 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4121 {
4122    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4123
4124    srvCellCfg->initialDownlinkBWP = NULLP;
4125    CU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4126         if(!srvCellCfg->initialDownlinkBWP)
4127         {
4128                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4129                 return RFAILED;
4130         }
4131
4132    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4133         {
4134                 DU_LOG("\nF1AP : BuildInitialDlBWP failed");
4135                 return RFAILED;
4136         }
4137    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4138         srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4139
4140    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4141         CU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4142         if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4143         {
4144                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4145                 return RFAILED;
4146         }
4147         *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4148
4149         srvCellCfg->bwp_InactivityTimer = NULLP;
4150
4151    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4152         CU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4153         if(!srvCellCfg->defaultDownlinkBWP_Id)
4154         {
4155                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4156                 return RFAILED;
4157         }
4158         *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4159
4160    srvCellCfg->uplinkConfig = NULLP;
4161    CU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4162         if(!srvCellCfg->uplinkConfig)
4163         {
4164                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4165                 return RFAILED;
4166         }
4167
4168    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4169         {
4170                 DU_LOG("\nF1AP : BuildUlCfg failed");
4171                 return RFAILED;
4172         }
4173         srvCellCfg->supplementaryUplink = NULLP;
4174         srvCellCfg->pdcch_ServingCellConfig = NULLP;
4175
4176    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4177         CU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct     ServingCellConfig__pdsch_ServingCellConfig));
4178         if(!srvCellCfg->pdsch_ServingCellConfig)
4179         {
4180                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4181                 return RFAILED;
4182         }
4183
4184    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4185         {
4186                 DU_LOG("\nF1AP : BuildPdschSrvCellCfg failed");
4187                 return RFAILED;
4188         }
4189
4190    srvCellCfg->csi_MeasConfig = NULLP;
4191 #if 0
4192         CU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct      ServingCellConfig__csi_MeasConfig))
4193         if(!srvCellCfg->csi_MeasConfig)
4194         {
4195                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfgDed");
4196                 return RFAILED;
4197         }
4198
4199    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4200         {
4201                 DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4202                 return RFAILED;
4203         }
4204 #endif
4205    srvCellCfg->sCellDeactivationTimer = NULLP;
4206         srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4207         srvCellCfg->tag_Id = TAG_ID;
4208    srvCellCfg->dummy = NULLP;
4209    srvCellCfg->pathlossReferenceLinking = NULLP;
4210    srvCellCfg->servingCellMO = NULLP;
4211    srvCellCfg->ext1 = NULLP;
4212
4213         return ROK;
4214 }
4215 /*******************************************************************
4216  *
4217  * @brief Builds Spcell config
4218  *
4219  * @details
4220  *
4221  *    Function : BuildSpCellCfg
4222  *
4223  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4224  *
4225  * @params[in] SpCellConfig_t spCellCfg
4226  *
4227  * @return ROK     - success
4228  *         RFAILED - failure
4229  *
4230  * ****************************************************************/
4231 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4232 {
4233
4234    spCellCfg->servCellIndex = NULLP;
4235         CU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4236         if(!spCellCfg->servCellIndex)
4237         {
4238                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4239                 return RFAILED;
4240         }
4241    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4242
4243    spCellCfg->reconfigurationWithSync = NULLP;
4244         spCellCfg->rlf_TimersAndConstants = NULLP;
4245    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4246         CU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4247         if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4248         {
4249                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4250                 return RFAILED;
4251         }
4252    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4253
4254    spCellCfg->spCellConfigDedicated = NULLP;
4255    CU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4256         if(!spCellCfg->spCellConfigDedicated)
4257         {
4258                 DU_LOG("\nF1AP : Memory allocation failure in BuildSpCellCfg");
4259                 return RFAILED;
4260         }
4261    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4262         {
4263                 DU_LOG("\nF1AP : BuildSpCellCfgDed failed");
4264                 return RFAILED;
4265         }
4266         return ROK;
4267 }
4268 /*******************************************************************
4269 *
4270 * @brief Builds Phy cell group config
4271 *
4272 * @details
4273 *
4274 *    Function : BuildPhyCellGrpCfg
4275 *
4276 *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4277 *
4278 * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4279 *
4280 * @return ROK     - success
4281 *         RFAILED - failure
4282 *
4283 * ****************************************************************/
4284 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4285 {
4286    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4287         phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4288
4289    phyCellGrpCfg->p_NR_FR1 = NULLP;
4290         CU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4291         if(!phyCellGrpCfg->p_NR_FR1)
4292         {
4293                 DU_LOG("\nF1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4294                 return RFAILED;
4295         }
4296    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4297         phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4298         phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4299         phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4300         phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4301         phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4302         phyCellGrpCfg->cs_RNTI = NULLP;
4303         phyCellGrpCfg->ext1 = NULLP;
4304         phyCellGrpCfg->ext2 = NULLP;
4305
4306         return ROK;
4307 }
4308
4309 /*******************************************************************
4310 *
4311 * @brief Builds tag config
4312 *
4313 * @details
4314 *
4315 *    Function : BuildTagConfig
4316 *
4317 *    Functionality: Builds tag config in MacCellGroupConfig
4318 *
4319 * @params[in] TAG_Config *tag_Config
4320 *
4321 * @return ROK     - success
4322 *         RFAILED - failure
4323 *
4324 * ****************************************************************/
4325 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
4326 {
4327         struct TAG_Config__tag_ToAddModList *tagList;
4328    uint8_t                     idx, elementCnt;
4329
4330    tagConfig->tag_ToReleaseList = NULLP;
4331    tagConfig->tag_ToAddModList = NULLP;
4332    CU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
4333         if(!tagConfig->tag_ToAddModList)
4334         {
4335                 DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
4336                 return RFAILED;
4337         }
4338
4339         elementCnt = 1; //ODU_VALUE_ONE;
4340         tagList = tagConfig->tag_ToAddModList;
4341         tagList->list.count = elementCnt;
4342         tagList->list.size  =  elementCnt * sizeof(struct TAG *);
4343
4344    tagList->list.array = NULLP;
4345         CU_ALLOC(tagList->list.array, tagList->list.size);
4346         if(!tagList->list.array)
4347         {
4348                 DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
4349                 return RFAILED;
4350         }
4351
4352         for(idx=0; idx<tagList->list.count; idx++)
4353         {
4354            tagList->list.array[idx] = NULLP;
4355                 CU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
4356                 if(!tagList->list.array[idx])
4357                 {
4358                         DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
4359                         return RFAILED;
4360                 }
4361         }
4362
4363         idx = 0;
4364         tagList->list.array[idx]->tag_Id = TAG_ID;
4365         tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
4366
4367    return ROK;
4368 }
4369
4370 /*******************************************************************
4371 *
4372 * @brief Builds PHR Config
4373 *
4374 * @details
4375 *
4376 *    Function : BuildPhrConfig
4377 *
4378 *    Functionality: Builds phrConfig in MacCellGroupConfig
4379 *
4380 * @params[in] PHR Config *
4381 *
4382 * @return ROK     - success
4383 *         RFAILED - failure
4384 *
4385 * ****************************************************************/
4386 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
4387 {
4388
4389    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
4390         phrConfig->choice.setup = NULLP;
4391         CU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
4392         if(!phrConfig->choice.setup)
4393         {
4394                 DU_LOG("\nF1AP : Memory allocation failure in BuildPhrConfig");
4395                 return RFAILED;
4396         }
4397
4398         phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
4399         phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
4400    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
4401         phrConfig->choice.setup->multiplePHR              = false;
4402         phrConfig->choice.setup->dummy                    = false;
4403         phrConfig->choice.setup->phr_Type2OtherCell       = false;
4404         phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
4405
4406         return ROK;
4407 }
4408
4409 /*******************************************************************
4410 *
4411 * @brief Builds BSR Config
4412 *
4413 * @details
4414 *
4415 *    Function : BuildBsrConfig
4416 *
4417 *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
4418 *
4419 * @params[in] BSR_Config *bsrConfig
4420 *
4421 * @return ROK     - success
4422 *         RFAILED - failure
4423 *
4424 * ****************************************************************/
4425 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
4426 {
4427    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
4428         bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
4429         bsrConfig->logicalChannelSR_DelayTimer = NULLP;
4430
4431    return ROK;
4432 }
4433
4434 /*******************************************************************
4435 *
4436 * @brief Builds scheduling request config
4437 *
4438 * @details
4439 *
4440 *    Function : BuildSchedulingReqConfig
4441 *
4442 *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
4443 *
4444 * @params[in] SchedulingRequestConfig *schedulingRequestConfig
4445 *
4446 * @return ROK     - success
4447 *         RFAILED - failure
4448 *
4449 * ****************************************************************/
4450 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
4451 {
4452         struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
4453    uint8_t                     idx, elementCnt;
4454
4455    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
4456         CU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
4457                         sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
4458         if(!schedulingRequestConfig->schedulingRequestToAddModList)
4459         {
4460                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
4461                 return RFAILED;
4462         }
4463
4464         elementCnt = 1; //ODU_VALUE_ONE;
4465         schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
4466         schReqList->list.count = elementCnt;
4467    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
4468
4469    schReqList->list.array = NULLP;
4470    CU_ALLOC(schReqList->list.array, schReqList->list.size);
4471         if(!schReqList->list.array)
4472         {
4473                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
4474                 return RFAILED;
4475         }
4476
4477    for(idx=0;idx<schReqList->list.count; idx++)
4478         {
4479            schReqList->list.array[idx] = NULLP;
4480                 CU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
4481                 if(!schReqList->list.array[idx])
4482                 {
4483                         DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
4484                         return RFAILED;
4485                 }
4486         }
4487
4488         idx = 0;
4489         schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
4490
4491    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
4492         CU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
4493         if(!schReqList->list.array[idx]->sr_ProhibitTimer)
4494         {
4495                 DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
4496                 return RFAILED;
4497         }
4498    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
4499         schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
4500         schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
4501
4502         return ROK;
4503 }
4504 /*******************************************************************
4505 *
4506 * @brief Builds Mac cell group config
4507 *
4508 * @details
4509 *
4510 *    Function : BuildMacCellGrpCfg
4511 *
4512 *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4513 *
4514 * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4515 *
4516 * @return ROK     - success
4517 *         RFAILED - failure
4518 *
4519 * ****************************************************************/
4520 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4521 {
4522    macCellGrpCfg->drx_Config = NULLP;
4523    macCellGrpCfg->schedulingRequestConfig = NULLP;
4524         CU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4525         if(!macCellGrpCfg->schedulingRequestConfig)
4526         {
4527                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4528                 return RFAILED;
4529         }
4530
4531         if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4532         {
4533            DU_LOG("\nF1AP : BuildSchedulingReqConfig failed");
4534                 return RFAILED;
4535         }
4536
4537    macCellGrpCfg->bsr_Config = NULLP;
4538    CU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4539         if(!macCellGrpCfg->bsr_Config)
4540         {
4541                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4542                 return RFAILED;
4543         }
4544
4545    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4546         {
4547       DU_LOG("\nF1AP : BuildBsrConfig failed");
4548            return RFAILED;
4549         }
4550
4551    macCellGrpCfg->tag_Config = NULLP;
4552    CU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4553         if(!macCellGrpCfg->tag_Config)
4554         {
4555                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4556                 return RFAILED;
4557         }
4558
4559    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4560         {
4561            DU_LOG("\nF1AP : BuildTagConfig failed");
4562            return RFAILED;
4563    }
4564
4565    macCellGrpCfg->phr_Config = NULLP;
4566    CU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
4567         if(!macCellGrpCfg->phr_Config)
4568         {
4569                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacCellGrpCfg");
4570                 return RFAILED;
4571         }
4572
4573    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
4574         {
4575            DU_LOG("\nF1AP : BuildPhrConfig failed");
4576            return RFAILED;
4577    }
4578
4579    macCellGrpCfg->skipUplinkTxDynamic = false;
4580         macCellGrpCfg->ext1 = NULLP;
4581
4582         return ROK;
4583 }
4584  /*******************************************************************
4585  *
4586  * @brief Frees memeory allocated for SearchSpcToAddModList
4587  *
4588  * @details
4589  *
4590  *    Function : FreeSearchSpcToAddModList
4591  *
4592  *    Functionality: Deallocating memory of SearchSpcToAddModList
4593  *
4594  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
4595  *
4596  * @return void
4597  *
4598  4221 * ****************************************************************/
4599 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
4600 {
4601     uint8_t idx1=0;
4602     uint8_t idx2=0;
4603     struct  SearchSpace *searchSpc=NULLP;
4604
4605     if(searchSpcList->list.array)
4606          {
4607             if(searchSpcList->list.array[idx2])
4608             {
4609           searchSpc = searchSpcList->list.array[idx2];
4610                if(searchSpc->controlResourceSetId)
4611                {
4612                   if(searchSpc->monitoringSlotPeriodicityAndOffset)
4613                   {
4614                      if(searchSpc->monitoringSymbolsWithinSlot)
4615                      {
4616                         if(searchSpc->monitoringSymbolsWithinSlot->buf)
4617                         {
4618                            if(searchSpc->nrofCandidates)
4619                            {
4620                               if(searchSpc->searchSpaceType)
4621                               {
4622                                  CU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
4623                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
4624                                  CU_FREE(searchSpc->searchSpaceType, sizeof(struct
4625                                                                          SearchSpace__searchSpaceType));
4626                               }
4627                               CU_FREE(searchSpc->nrofCandidates,
4628                               sizeof(struct SearchSpace__nrofCandidates));
4629                            }
4630                            CU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
4631                            searchSpc->monitoringSymbolsWithinSlot->size);
4632                         }
4633                         CU_FREE(searchSpc->monitoringSymbolsWithinSlot,
4634                         sizeof(BIT_STRING_t));
4635                      }
4636                      CU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
4637                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
4638                   }
4639                   CU_FREE(searchSpc->controlResourceSetId,
4640                   sizeof(ControlResourceSetId_t));
4641                      }
4642                   }
4643                   for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
4644              {
4645                  CU_FREE(searchSpcList->list.array[idx1],
4646                                 sizeof(struct SearchSpace));
4647                   }
4648                   CU_FREE(searchSpcList->list.array,searchSpcList->list.size);
4649          }
4650 }
4651  /*******************************************************************
4652  *
4653  * @brief Frees memory allocated for PdschTimeDomAllocList
4654  *
4655  * @details
4656  *
4657  *    Function : FreePdschTimeDomAllocList
4658  *
4659  *    Functionality: Deallocating memory of PdschTimeDomAllocList
4660  *
4661  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4662  *
4663  * @return void
4664  *
4665  4221 * ****************************************************************/
4666 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4667 {
4668    uint8_t idx1=0;
4669
4670         if(timeDomAllocList->choice.setup)
4671    {
4672       if(timeDomAllocList->choice.setup->list.array)
4673       {
4674           for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
4675           {
4676              CU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
4677              sizeof(struct PDSCH_TimeDomainResourceAllocation));
4678           }
4679           CU_FREE(timeDomAllocList->choice.setup->list.array, \
4680           timeDomAllocList->choice.setup->list.size);
4681       }
4682       CU_FREE(timeDomAllocList->choice.setup,\
4683       sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4684    }
4685 }
4686  /*******************************************************************
4687  *
4688  * @brief Frees memory allocated for PuschTimeDomAllocList
4689  *
4690  *@details
4691  *
4692  *    Function : FreePuschTimeDomAllocList
4693  *
4694  *    Functionality: Deallocating memory of PuschTimeDomAllocList
4695  *
4696  * @params[in] PUSCH_Config_t *puschCfg
4697  *
4698  * @return void
4699  *
4700  ***********************************************************************/
4701 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
4702 {
4703     uint8_t idx1=0;
4704          uint8_t idx2=0;
4705     struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
4706
4707     if(puschCfg->pusch_TimeDomainAllocationList)
4708     {
4709        timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
4710        if(timeDomAllocList_t->choice.setup)
4711        {
4712           if(timeDomAllocList_t->choice.setup->list.array)
4713           {
4714              CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
4715              for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
4716              {
4717                 CU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
4718                                     sizeof(PUSCH_TimeDomainResourceAllocation_t));
4719                                  }
4720                                  CU_FREE(timeDomAllocList_t->choice.setup->list.array, \
4721              timeDomAllocList_t->choice.setup->list.size);
4722           }
4723           CU_FREE(timeDomAllocList_t->choice.setup, \
4724                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4725        }
4726                  CU_FREE(puschCfg->transformPrecoder, sizeof(long));
4727        CU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
4728                  sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4729     }
4730
4731 }
4732  /*******************************************************************
4733  *
4734  * @brief Frees memory allocated for InitialUlBWP
4735  *
4736  * @details
4737  *
4738  *    Function : FreeInitialUlBWP
4739  *
4740  *    Functionality: Deallocating memory of InitialUlBWP
4741  *
4742  * @params[in] BWP_UplinkDedicated_t *ulBwp
4743  *
4744  * @return void
4745  *
4746  * ****************************************************************/
4747 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4748 {
4749     uint8_t  rSetIdx, rsrcIdx;
4750     SRS_Config_t   *srsCfg = NULLP;
4751     PUSCH_Config_t *puschCfg = NULLP;
4752     struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
4753          struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
4754          struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
4755          struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
4756
4757          if(ulBwp->pusch_Config)
4758     {
4759        if(ulBwp->pusch_Config->choice.setup)
4760        {
4761           puschCfg=ulBwp->pusch_Config->choice.setup;
4762           if(puschCfg->dataScramblingIdentityPUSCH)
4763           {
4764              if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4765              {
4766                 FreePuschTimeDomAllocList(puschCfg);
4767                 dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
4768                                          if(dmrsUlCfg->choice.setup)
4769                 {
4770                    if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4771                    {
4772                       if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4773                       {
4774                          CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4775                                                                  sizeof(long));
4776                                                                  CU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
4777                          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4778                                                          }
4779                                                          CU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
4780                                                          sizeof(long));
4781                                                  }
4782                                                  CU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
4783                 }
4784                                          CU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4785                                          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4786                                  }
4787              CU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4788           }
4789           CU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4790             }
4791                  CU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4792
4793                  /* Free SRS-Config */
4794                  if(ulBwp->srs_Config)
4795                  {
4796                     if(ulBwp->srs_Config->choice.setup)
4797                          {
4798                             srsCfg = ulBwp->srs_Config->choice.setup;
4799
4800                                  /* Free Resource Set to add/mod list */
4801                             if(srsCfg->srs_ResourceSetToAddModList)
4802                                  {
4803                                     rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
4804                                          if(rsrcSetList->list.array)
4805                                          {
4806                                             rSetIdx = 0;
4807
4808                                                  /* Free SRS resource Id list in this SRS resource set */
4809                                                  if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4810                                                  {
4811                                                     rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4812
4813                                                     if(rsrcIdList->list.array)
4814                                                          {
4815                                                             for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4816                                                                  {
4817                                                                     CU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4818                                                             }
4819                                                             CU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
4820                                                          }
4821                                                     CU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4822                                                             sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4823                                                  }
4824
4825                                                  /* Free resource type info for this SRS resource set */
4826                                                  CU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4827                                                     sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4828
4829                                                  /* Free memory for each resource set */
4830                                             for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4831                                                  {
4832                                                     CU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4833                                                  }
4834                                             CU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
4835                                          }
4836                                     CU_FREE(srsCfg->srs_ResourceSetToAddModList, \
4837                                             sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4838                                  }
4839
4840                                  /* Free resource to add/modd list */
4841                                  if(srsCfg->srs_ResourceToAddModList)
4842                                  {
4843                                     resourceList = srsCfg->srs_ResourceToAddModList;
4844                                          if(resourceList->list.array)
4845                                          {
4846                                             rsrcIdx = 0;
4847                                                  CU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
4848                                                     sizeof(struct SRS_Resource__transmissionComb__n2));
4849                                             CU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
4850                                                     sizeof(struct SRS_Resource__resourceType__aperiodic));
4851
4852                                             for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4853                                                  {
4854                                                     CU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4855                    }
4856                                             CU_FREE(resourceList->list.array, resourceList->list.size);
4857                                          }
4858                                     CU_FREE(srsCfg->srs_ResourceToAddModList, \
4859                                             sizeof(struct SRS_Config__srs_ResourceToAddModList));
4860                                  }
4861
4862                             CU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4863                          }
4864                     CU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4865        }
4866          }
4867 }
4868  /*******************************************************************
4869  *
4870  * @brief Frees memory allocated for initialUplinkBWP
4871  *
4872  * @details
4873  *
4874  *    Function : FreeinitialUplinkBWP
4875  *
4876  *    Functionality: Deallocating memory of initialUplinkBWP
4877  *
4878  * @params[in] UplinkConfig_t *ulCfg
4879  *
4880  * @return void
4881  *
4882  *
4883  * ****************************************************************/
4884 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
4885 {
4886    BWP_UplinkDedicated_t *ulBwp=NULLP;
4887    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
4888
4889         if(ulCfg->initialUplinkBWP)
4890         {
4891            ulBwp=ulCfg->initialUplinkBWP;
4892            if(ulCfg->firstActiveUplinkBWP_Id)
4893            {
4894               if(ulCfg->pusch_ServingCellConfig)
4895               {
4896                  puschCfg=ulCfg->pusch_ServingCellConfig;
4897                  if(puschCfg->choice.setup)
4898                  {
4899                     if(puschCfg->choice.setup->ext1)
4900                     {
4901                         CU_FREE(puschCfg->choice.setup->ext1->\
4902                                                  processingType2Enabled,sizeof(BOOLEAN_t));
4903                         CU_FREE(puschCfg->choice.setup->ext1->\
4904                                                  maxMIMO_Layers,sizeof(long));
4905                                                  CU_FREE(puschCfg->choice.setup->ext1, \
4906                                                  sizeof(struct PUSCH_ServingCellConfig__ext1));
4907                                         }
4908                     CU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4909                  }
4910                  CU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4911               }
4912               CU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4913            }
4914            FreeInitialUlBWP(ulBwp);
4915            CU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4916         }
4917 }
4918  /*******************************************************************
4919  *
4920  * @brief Frees emmory allocated for BWPDlDedPdschCfg
4921  *
4922  * @details
4923  *
4924  *    Function : FreeBWPDlDedPdschCfg
4925  *
4926  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
4927  *
4928  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4929  *
4930  * @return void
4931  *
4932  *
4933  * ****************************************************************/
4934 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
4935 {
4936    struct PDSCH_Config *pdschCfg=NULLP;
4937         struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
4938    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
4939    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
4940
4941         if(dlBwp->pdsch_Config->choice.setup)
4942    {
4943       pdschCfg=dlBwp->pdsch_Config->choice.setup;
4944       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4945       {
4946           if(pdschCfg->pdsch_TimeDomainAllocationList)
4947           {
4948              timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
4949              if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
4950              {
4951                 prbBndlType=&pdschCfg->prb_BundlingType;
4952                 CU_FREE(prbBndlType->choice.staticBundling,\
4953                 sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4954                 CU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4955              }
4956              FreePdschTimeDomAllocList(timeDomAllocList);
4957              CU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
4958              sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4959           }
4960           dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
4961           if(dmrsDlCfg->choice.setup)
4962           {
4963              CU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
4964              sizeof(long));
4965              CU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
4966           }
4967           CU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4968           sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4969        }
4970        CU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4971     }
4972 }
4973  /*******************************************************************
4974  *
4975  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
4976  *
4977  * @details
4978  *
4979  *    Function : FreeBWPDlDedPdcchCfg
4980  *
4981  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
4982  *
4983  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4984  *
4985  * @return void
4986  *
4987  *
4988  * ****************************************************************/
4989 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
4990 {
4991    uint8_t idx1=0;
4992         uint8_t idx2=0;
4993         struct PDCCH_Config *pdcchCfg=NULLP;
4994    struct ControlResourceSet *controlRSet=NULLP;
4995         struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
4996
4997         if(dlBwp->pdcch_Config->choice.setup)
4998    {
4999       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5000       if(pdcchCfg->controlResourceSetToAddModList)
5001       {
5002          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5003          if(controlRSetList->list.array)
5004          {
5005             controlRSet = controlRSetList->list.array[idx2];
5006             if(controlRSet)
5007             {
5008                if(controlRSet->frequencyDomainResources.buf)
5009                {
5010                   if(controlRSet->pdcch_DMRS_ScramblingID)
5011                   {
5012                      if(pdcchCfg->searchSpacesToAddModList)
5013                      {
5014                          FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5015                          CU_FREE(pdcchCfg->searchSpacesToAddModList, \
5016                          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5017                      }
5018                      CU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5019                   }
5020                                                 CU_FREE(controlRSet->frequencyDomainResources.buf, \
5021                                                 controlRSet->frequencyDomainResources.size);
5022                                         }
5023                                 }
5024             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5025             {
5026                CU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5027             }
5028                                 CU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5029                         }
5030                         CU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5031                         sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5032                 }
5033                 CU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5034         }
5035 }
5036 /*******************************************************************
5037 *
5038 * @brief Builds RLC Config
5039 *
5040 * @details
5041 *
5042 *    Function : BuildRlcConfig
5043 *
5044 *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
5045 *
5046 * @params[in] RLC_Config *rlcConfig
5047 *
5048 * @return ROK     - success
5049 *         RFAILED - failure
5050 *
5051 * ****************************************************************/
5052 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
5053 {
5054
5055    rlcConfig->present = RLC_Config_PR_am;
5056
5057    rlcConfig->choice.am = NULLP;
5058    CU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5059         if(!rlcConfig->choice.am)
5060         {
5061                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
5062                 return RFAILED;
5063         }
5064
5065    /* UL */
5066         rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
5067    CU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5068         if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
5069         {
5070                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
5071                 return RFAILED;
5072         }
5073    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
5074         rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
5075         rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
5076         rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
5077         rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
5078
5079    /* DL */
5080    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
5081    CU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5082         if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
5083         {
5084                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
5085                 return RFAILED;
5086         }
5087         *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
5088    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
5089         rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
5090
5091    return ROK;
5092 }
5093
5094 /*******************************************************************
5095 *
5096 * @brief Builds MAC LC Config
5097 *
5098 * @details
5099 *
5100 *    Function : BuildMacLCConfig
5101 *
5102 *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
5103 *
5104 * @params[in] struct LogicalChannelConfig macLcConfig
5105 *
5106 * @return ROK     - success
5107 *         RFAILED - failure
5108 *
5109 * ****************************************************************/
5110 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
5111 {
5112
5113    macLcConfig->ul_SpecificParameters = NULLP;
5114    CU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5115         if(!macLcConfig->ul_SpecificParameters)
5116         {
5117                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
5118                 return RFAILED;
5119         }
5120
5121    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
5122         macLcConfig->ul_SpecificParameters->prioritisedBitRate =        PRIORTISIED_BIT_RATE;
5123         macLcConfig->ul_SpecificParameters->bucketSizeDuration =        BUCKET_SIZE_DURATION;
5124    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
5125         macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
5126         macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
5127    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
5128
5129    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
5130    CU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
5131    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
5132         {
5133                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
5134                 return RFAILED;
5135         }
5136    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
5137
5138    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
5139         CU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,       sizeof(SchedulingRequestId_t));
5140         if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
5141         {
5142                 DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
5143                 return RFAILED;
5144         }
5145    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
5146
5147         macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
5148         macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
5149         macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
5150
5151    return ROK;
5152 }
5153 /*******************************************************************
5154 *
5155 * @brief Builds RLC Bearer to Add/Mod list
5156 *
5157 * @details
5158 *
5159 *    Function :BuildRlcBearerToAddModList
5160 *
5161 *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
5162 *
5163 * @params[in] rlc_BearerToAddModList
5164 *
5165 * @return ROK     - success
5166 *         RFAILED - failure
5167 *
5168 * ****************************************************************/
5169 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
5170 {
5171    uint8_t                     idx, elementCnt;
5172
5173    elementCnt = 1;
5174    rlcBearerList->list.count = elementCnt;
5175         rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
5176
5177    rlcBearerList->list.array = NULLP;
5178         CU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
5179         if(!rlcBearerList->list.array)
5180         {
5181                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5182                 return RFAILED;
5183         }
5184
5185    for(idx=0; idx<rlcBearerList->list.count; idx++)
5186         {
5187            rlcBearerList->list.array[idx] = NULLP;
5188                 CU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5189                 if(!rlcBearerList->list.array[idx])
5190                 {
5191                         DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5192                         return RFAILED;
5193                 }
5194         }
5195
5196    idx = 0;
5197         rlcBearerList->list.array[idx]->logicalChannelIdentity = RLC_LCID;
5198
5199         CU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5200         if(!rlcBearerList->list.array[idx]->servedRadioBearer)
5201         {
5202                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5203                 return RFAILED;
5204         }
5205
5206         rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
5207    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB_ID_1;
5208
5209    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
5210    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
5211    CU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
5212         if(!rlcBearerList->list.array[idx]->rlc_Config)
5213         {
5214                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5215                 return RFAILED;
5216         }
5217
5218    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
5219         {
5220                 DU_LOG("\nF1AP : BuildRlcConfig failed");
5221                 return RFAILED;
5222         }
5223
5224    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
5225    CU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5226         if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
5227         {
5228                 DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
5229                 return RFAILED;
5230         }
5231
5232         if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
5233         {
5234                 DU_LOG("\nF1AP : BuildMacLCConfig failed");
5235                 return RFAILED;
5236         }
5237
5238         return ROK;
5239 }
5240
5241 /*******************************************************************
5242  *
5243  * @brief Free memory allocated for CellGroupConfig
5244  *
5245  * @details
5246  *
5247  *    Function : FreeMemCellGrpCfg
5248  *
5249  *    Functionality: Deallocating memory of CellGroupConfig
5250  *
5251  * @params[in] pointer to CellGroupConfigRrc_t
5252  *
5253  * @return ROK     - success
5254  *         RFAILED - failure
5255  *
5256  ******************************************************************/
5257 uint8_t FreeMemCellGrpCfg(CellGroupConfigRrc_t *cellGrpCfg)
5258 {
5259    uint8_t idx=0;
5260    SpCellConfig_t *spCellCfg=NULLP;
5261    ServingCellConfig_t *srvCellCfg=NULLP;
5262    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5263    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5264    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5265    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5266    struct RLC_Config *rlcConfig=NULLP;
5267    struct LogicalChannelConfig *macLcConfig=NULLP;
5268    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5269    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5270    struct TAG_Config *tagConfig=NULLP;
5271    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5272    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5273    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5274
5275    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5276    if(rlcBearerList)
5277    {
5278       if(rlcBearerList->list.array)
5279       {
5280          for(idx=0; idx<rlcBearerList->list.count; idx++)
5281          {
5282             if(rlcBearerList->list.array[idx])
5283             {
5284                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5285                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5286                if(rlcConfig)
5287                {
5288                   if(rlcConfig->choice.am)
5289                   {
5290                      CU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5291                      CU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5292                      CU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5293                   }
5294                   CU_FREE(rlcConfig, sizeof(struct RLC_Config));
5295                }
5296                CU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5297                if(macLcConfig)
5298                {
5299                   if(macLcConfig->ul_SpecificParameters)
5300                   {
5301                      CU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5302                      CU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5303                      CU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5304                   }
5305                   CU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5306                }
5307                CU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5308             }
5309          }
5310          CU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5311       }
5312       CU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5313    }
5314
5315    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5316    if(macCellGrpCfg)
5317    {
5318       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5319       if(schedulingRequestConfig)
5320       {
5321          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5322          if(schReqList)
5323          {
5324             if(schReqList->list.array)
5325             {
5326                for(idx=0;idx<schReqList->list.count; idx++)
5327                {
5328                   if(schReqList->list.array[idx])
5329                   {
5330                      CU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5331                      CU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5332                   }
5333                }
5334                CU_FREE(schReqList->list.array, schReqList->list.size);
5335             }
5336             CU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5337                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5338             CU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5339       }
5340       if(macCellGrpCfg->bsr_Config)
5341       {
5342          CU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5343       }
5344       tagConfig = macCellGrpCfg->tag_Config;
5345       if(tagConfig)
5346       {
5347          tagList = tagConfig->tag_ToAddModList;
5348          if(tagList)
5349          {
5350             if(tagList->list.array)
5351             {
5352                for(idx=0; idx<tagList->list.count; idx++)
5353                {
5354                   CU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5355                }
5356                CU_FREE(tagList->list.array, tagList->list.size);
5357             }
5358             CU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5359          }
5360          CU_FREE(tagConfig, sizeof(struct TAG_Config));
5361       }
5362
5363       phrConfig = macCellGrpCfg->phr_Config;
5364       if(phrConfig)
5365       {
5366          CU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5367          CU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5368       }
5369
5370       CU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5371    }
5372
5373    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5374    if(phyCellGrpCfg)
5375    {
5376       CU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5377       CU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5378    }
5379
5380    spCellCfg = cellGrpCfg->spCellConfig;
5381    if(spCellCfg)
5382    {
5383       if(spCellCfg->servCellIndex)
5384       {
5385          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5386          {
5387             if(spCellCfg->spCellConfigDedicated)
5388             {
5389                srvCellCfg = spCellCfg->spCellConfigDedicated;
5390                if(srvCellCfg->initialDownlinkBWP)
5391                {
5392                   dlBwp = srvCellCfg->initialDownlinkBWP;
5393                   if(srvCellCfg->firstActiveDownlinkBWP_Id)
5394                   {
5395                      if(srvCellCfg->defaultDownlinkBWP_Id)
5396                      {
5397                         if(srvCellCfg->uplinkConfig)
5398                         {
5399                            if(srvCellCfg->pdsch_ServingCellConfig)
5400                            {
5401                               pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5402                               if(pdschCfg->choice.setup)
5403                               {
5404                                  CU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5405                                  CU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5406                               }
5407                               CU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5408                                        ServingCellConfig__pdsch_ServingCellConfig));
5409                            }
5410                            FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5411                            CU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5412                         }
5413                         CU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5414                      }
5415                      CU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5416                   }
5417                   if(dlBwp->pdcch_Config)
5418                   {
5419                      if(dlBwp->pdsch_Config)
5420                      {
5421                         FreeBWPDlDedPdschCfg(dlBwp);
5422                         CU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5423                      }
5424                      FreeBWPDlDedPdcchCfg(dlBwp);
5425                      CU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5426                   }
5427                   CU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5428                }
5429                CU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5430             }
5431             CU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5432          }
5433          CU_FREE(spCellCfg->servCellIndex, sizeof(long));
5434       }
5435       CU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5436    }
5437    return ROK;
5438 }
5439
5440 /*******************************************************************
5441  *
5442  * @brief Fills CellGroupConfig
5443  *
5444  * @details
5445  *
5446  *    Function : fillCellGrpCfg
5447  *
5448  *    Functionality: Fills CellGroupConfig
5449  *
5450  * @params[in] pointer to CellGroupConfigRrc_t
5451  *
5452  * @return ROK     - success
5453  *         RFAILED - failure
5454  *
5455  ******************************************************************/
5456
5457 uint8_t fillCellGrpCfg(CellGroupConfig_t *cellGrp)
5458 {
5459    uint8_t               ret = RFAILED;
5460    CellGroupConfigRrc_t  cellGrpCfg;
5461    asn_enc_rval_t        encRetVal;
5462
5463    while(true)
5464    {
5465       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5466
5467       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5468       CU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5469       if(!cellGrpCfg.rlc_BearerToAddModList)
5470       {
5471          DU_LOG("\nF1AP : Memory allocation failure in CellGrpConfig");
5472          break;
5473       }
5474       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5475       {
5476          DU_LOG("\nF1AP : fillCellGrpCfg failed");
5477          break;
5478       }
5479
5480       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5481       cellGrpCfg.mac_CellGroupConfig = NULLP;
5482       CU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5483       if(!cellGrpCfg.mac_CellGroupConfig)
5484       {
5485          DU_LOG("\nF1AP : Memory allocation failure in fillCellGrpCfg");
5486          break;
5487       }
5488       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5489       {
5490          DU_LOG("\nF1AP : BuildMacCellGrpCfg failed");
5491          break;
5492       }
5493
5494
5495       cellGrpCfg.physicalCellGroupConfig = NULLP;
5496       CU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5497       if(!cellGrpCfg.physicalCellGroupConfig)
5498       {
5499          DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5500          break;
5501       }
5502       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5503       {
5504          DU_LOG("\nF1AP : BuildPhyCellGrpCfg failed");
5505          break;
5506       }
5507
5508       cellGrpCfg.spCellConfig = NULLP;
5509       CU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5510       if(!cellGrpCfg.spCellConfig)
5511       {
5512          DU_LOG("\nF1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5513          break;
5514       }
5515       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5516       {
5517          DU_LOG("\nF1AP : BuildSpCellCfg failed");
5518          break;
5519       }
5520
5521       cellGrpCfg.sCellToAddModList = NULLP;
5522       cellGrpCfg.sCellToReleaseList = NULLP;
5523       cellGrpCfg.ext1 = NULLP;
5524
5525       /* encode cellGrpCfg into duToCuRrcContainer */
5526       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5527       cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
5528       encBufSize = 0;
5529       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5530       /* Encode results */
5531       if(encRetVal.encoded == ENCODE_FAIL)
5532       {
5533          DU_LOG( "\n F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5534                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5535          break;
5536       }
5537       else
5538       {
5539          DU_LOG("\n F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5540          for(int i=0; i< encBufSize; i++)
5541          {
5542             printf("%x",encBuf[i]);
5543          }
5544       }
5545
5546       cellGrp->size = encBufSize;
5547       CU_ALLOC(cellGrp->buf, cellGrp->size);
5548       if(!cellGrp->buf)
5549       {
5550          DU_LOG("\nF1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5551          break;
5552       }
5553       memcpy(cellGrp->buf, encBuf, cellGrp->size);
5554       ret = ROK;
5555       break;
5556    }
5557    FreeMemCellGrpCfg(&cellGrpCfg);
5558    return ROK;
5559 }
5560
5561 /*******************************************************************
5562  *
5563  * @brief Fills CuToDuContainer
5564  *
5565  * @details
5566  *
5567  *    Function : fillCuToDuContainer
5568  *
5569  *    Functionality: Fills CuToDuContainer
5570  *
5571  * @params[in] pointer to CUtoDURRCInformation_t
5572  *
5573  * @return ROK     - success
5574  *         RFAILED - failure
5575  *
5576  ******************************************************************/
5577
5578 uint8_t fillCuToDuContainer(CUtoDURRCInformation_t *rrcMsg)
5579 {
5580    uint8_t elementCnt = 0;
5581    uint8_t ret = ROK;
5582    uint8_t idx, idx2, rrcBufLen;
5583
5584    elementCnt = 1;
5585    CU_ALLOC(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
5586    if(rrcMsg->iE_Extensions)
5587    {
5588       rrcMsg->iE_Extensions->list.count = elementCnt;
5589       rrcMsg->iE_Extensions->list.size = elementCnt * sizeof(CUtoDURRCInformation_ExtIEs_t);
5590
5591       /* Initialize the CUtoDURRCInformation_ExtIEs */
5592       CU_ALLOC(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
5593
5594       if(rrcMsg->iE_Extensions->list.array == NULLP)
5595       {
5596          DU_LOG(" F1AP : Memory allocation for CUtoDURRCInformation_ExtIEs failed");
5597          ret = RFAILED;
5598       }
5599
5600       for(idx=0; idx<elementCnt; idx++)
5601       {
5602          CU_ALLOC(rrcMsg->iE_Extensions->list.array[idx], sizeof(CUtoDURRCInformation_ExtIEs_t));
5603          if(rrcMsg->iE_Extensions->list.array[idx] == NULLP)
5604          {
5605             ret = RFAILED;
5606          }
5607       }
5608       idx = 0;
5609       /* Filling CellGroupConfig_t IE */
5610       rrcMsg->iE_Extensions->list.array[idx]->id = ProtocolIE_ID_id_CellGroupConfig;
5611       rrcMsg->iE_Extensions->list.array[idx]->criticality = Criticality_ignore;
5612       rrcMsg->iE_Extensions->list.array[idx]->extensionValue.present  =\
5613       CUtoDURRCInformation_ExtIEs__extensionValue_PR_CellGroupConfig;
5614       ret = fillCellGrpCfg(&rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig);
5615    }
5616    return ret;
5617 }
5618
5619 /*******************************************************************
5620  *
5621  * @brief Free CuToDuContainer
5622  *
5623  * @details
5624  *
5625  *    Function : FreeCuToDuInfo
5626  *
5627  *    Functionality: Free CuToDuContainer
5628  *
5629  * @params[in] pointer to CUtoDURRCInformation_t
5630  *
5631  * @return ROK     - success
5632  *         RFAILED - failure
5633  *
5634  ******************************************************************/
5635
5636 void FreeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
5637 {
5638    uint8_t idx, idx2;
5639
5640    if(rrcMsg->iE_Extensions)
5641    {
5642       if(rrcMsg->iE_Extensions->list.array)
5643       {
5644          for(idx= 0; idx < rrcMsg->iE_Extensions->list.count; idx++)
5645          {
5646             if(rrcMsg->iE_Extensions->list.array[idx])
5647             {
5648                switch(rrcMsg->iE_Extensions->list.array[idx]->id)
5649                {
5650                   case ProtocolIE_ID_id_CellGroupConfig:
5651                      if(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
5652                      {
5653                         CU_FREE(rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.buf,\
5654                         rrcMsg->iE_Extensions->list.array[idx]->extensionValue.choice.CellGroupConfig.size);
5655
5656                      }
5657                   break;
5658                   default:
5659                      DU_LOG("\nF1AP:Invalid Event type %ld at FreeCuToDuInfo()", \
5660                         rrcMsg->iE_Extensions->list.array[idx]->id);
5661                      break;
5662                }
5663             }
5664             break;
5665          }
5666          for(idx2 = 0; idx2 < idx; idx2++)
5667          {
5668             CU_FREE(rrcMsg->iE_Extensions->list.array[idx2], sizeof(CUtoDURRCInformation_ExtIEs_t));
5669          }
5670          CU_FREE(rrcMsg->iE_Extensions->list.array, rrcMsg->iE_Extensions->list.size);
5671
5672       }
5673
5674       CU_FREE(rrcMsg->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P16_t));
5675    }
5676 }
5677 /*******************************************************************
5678  *
5679  * @brief Builds and sends the UE Setup Request
5680  *
5681  * @details
5682  *
5683  *    Function : BuildAndSendUeContextSetupReq
5684  *
5685  *    Functionality: Constructs the UE Setup Request and sends
5686  *                   it to the CU through SCTP.
5687  *
5688  * @params[in]
5689  *
5690  * @return ROK     - success
5691  *         RFAILED - failure
5692  *
5693  * ****************************************************************/
5694 uint8_t BuildAndSendUeContextSetupReq(uint8_t cuUeF1apId, uint8_t duUeF1apId, \
5695    uint16_t rrcContLen, uint8_t *rrcContainer)
5696 {
5697    uint8_t   Nrcgiret;
5698    uint8_t   SplCellListret;
5699    uint8_t   SrbSetupret;
5700    uint8_t   elementCnt;
5701    uint8_t   idx;
5702    uint8_t   idx1;
5703    F1AP_PDU_t           *f1apMsg = NULLP;
5704    UEContextSetupRequest_t *ueSetReq = NULLP;
5705    asn_enc_rval_t encRetVal;        /* Encoder return value */
5706    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5707    uint8_t ret= RFAILED;
5708    uint8_t ret1;
5709    while(true)
5710    {
5711       DU_LOG("\n F1AP : Building UE Context Setup Request\n");
5712
5713       CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5714       if(f1apMsg == NULLP)
5715       {
5716          DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
5717          break;
5718       }
5719
5720       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5721       CU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5722       if(f1apMsg->choice.initiatingMessage == NULLP)
5723       {
5724          DU_LOG(" F1AP : Memory allocation for  F1AP-PDU failed");
5725          break;
5726       }
5727
5728       f1apMsg->choice.initiatingMessage->procedureCode = \
5729          ProcedureCode_id_UEContextSetup;
5730       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
5731       f1apMsg->choice.initiatingMessage->value.present = \
5732          InitiatingMessage__value_PR_UEContextSetupRequest;
5733       ueSetReq =
5734          &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
5735
5736       elementCnt = 11;
5737       ueSetReq->protocolIEs.list.count = elementCnt;
5738       ueSetReq->protocolIEs.list.size = \
5739                                         elementCnt * sizeof(UEContextSetupRequestIEs_t *);
5740
5741       /* Initialize the UESetup members */
5742       CU_ALLOC(ueSetReq->protocolIEs.list.array,ueSetReq->protocolIEs.list.size);
5743
5744       if(ueSetReq->protocolIEs.list.array == NULLP)
5745       {
5746          DU_LOG(" F1AP : Memory allocation for UE Context SetupRequest failed");
5747          break;
5748       }
5749
5750       for(idx1=0; idx1<elementCnt; idx1++)
5751       {
5752          CU_ALLOC(ueSetReq->protocolIEs.list.array[idx1],sizeof(UEContextSetupRequestIEs_t));
5753          if(ueSetReq->protocolIEs.list.array[idx1] == NULLP)
5754          {
5755             break;
5756          }
5757       }
5758
5759       idx = 0;
5760
5761       /*GNB CU UE F1AP ID*/
5762       ueSetReq->protocolIEs.list.array[idx]->id = \
5763                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
5764       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5765       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5766                                                              UEContextSetupRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
5767       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = cuUeF1apId;
5768
5769       /*GNB DU UE F1AP ID*/
5770       idx++;
5771       ueSetReq->protocolIEs.list.array[idx]->id = \
5772                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5773       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
5774       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5775                                                              UEContextSetupRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
5776       ueSetReq->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = duUeF1apId;
5777
5778       /*Special Cell ID*/
5779       idx++;
5780       ueSetReq->protocolIEs.list.array[idx]->id = \
5781                                                   ProtocolIE_ID_id_SpCell_ID;
5782       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5783       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5784                                                              UEContextSetupRequestIEs__value_PR_NRCGI;
5785       Nrcgiret = BuildNrcgi(&ueSetReq->protocolIEs.list.array[idx]->value.choice.NRCGI);
5786       if(Nrcgiret != ROK)
5787       {
5788          break;
5789       }
5790
5791       /*Served Cell Index*/
5792       idx++;
5793       ueSetReq->protocolIEs.list.array[idx]->id = \
5794                                                   ProtocolIE_ID_id_ServCellIndex;
5795       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5796       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5797                                                              UEContextSetupRequestIEs__value_PR_ServCellIndex;
5798       ueSetReq->protocolIEs.list.array[idx]->value.choice.ServCellIndex = \
5799                                                                           CELL_INDEX;
5800
5801       /*CellULConfigured*/
5802       idx++;
5803       ueSetReq->protocolIEs.list.array[idx]->id = \
5804                                                   ProtocolIE_ID_id_SpCellULConfigured;
5805       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
5806       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5807                                                              UEContextSetupRequestIEs__value_PR_CellULConfigured;
5808       ueSetReq->protocolIEs.list.array[idx]->value.choice.CellULConfigured = \
5809                                                                              CellULConfigured_none;
5810
5811       /*CUtoDURRCContainer*/
5812       idx++;
5813       ueSetReq->protocolIEs.list.array[idx]->id = \
5814                                                   ProtocolIE_ID_id_CUtoDURRCInformation;
5815       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5816       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5817                                                              UEContextSetupRequestIEs__value_PR_CUtoDURRCInformation;
5818       if(fillCuToDuContainer(&ueSetReq->protocolIEs.list.array[idx]->value.choice.CUtoDURRCInformation))
5819       {
5820          break;
5821       }
5822
5823       /*Special Cells to be SetupList*/
5824       idx++;
5825       ueSetReq->protocolIEs.list.array[idx]->id = \
5826                                                   ProtocolIE_ID_id_SCell_ToBeSetup_List;
5827       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_ignore;
5828       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5829                                                              UEContextSetupRequestIEs__value_PR_SCell_ToBeSetup_List;
5830       SplCellListret = BuildSplCellList(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SCell_ToBeSetup_List);
5831       if(SplCellListret != ROK)
5832       {
5833          break;
5834       }
5835       /*SRBs To Be Setup List*/
5836       idx++;
5837       ueSetReq->protocolIEs.list.array[idx]->id = \
5838                                                   ProtocolIE_ID_id_SRBs_ToBeSetup_List;
5839       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5840       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5841                                                              UEContextSetupRequestIEs__value_PR_SRBs_ToBeSetup_List;
5842       SrbSetupret =     BuildSRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.SRBs_ToBeSetup_List);
5843       if(SrbSetupret != ROK)
5844       {
5845          break;
5846       }
5847       /*DRBs to Be Setup List*/
5848       idx++;
5849       ueSetReq->protocolIEs.list.array[idx]->id = \
5850                                                   ProtocolIE_ID_id_DRBs_ToBeSetup_List;
5851       ueSetReq->protocolIEs.list.array[idx]->criticality        =       Criticality_reject;
5852       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5853                                                              UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
5854       ret1 = BuildDRBSetup(&ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
5855       if(ret1 != ROK)
5856       {
5857          break;
5858       }
5859
5860       /* RRC Container */
5861       idx++;
5862       ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_RRCContainer;
5863       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
5864       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5865          UEContextSetupRequestIEs__value_PR_RRCContainer;
5866       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size = rrcContLen;
5867       CU_ALLOC(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,
5868           ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
5869       if(!ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf)
5870       {
5871          DU_LOG(" F1AP : Memory allocation for BuildAndSendUeContextSetupReq failed");
5872          break;
5873       }
5874       memcpy(ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf, \
5875          rrcContainer, ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
5876
5877       /* RRC delivery status request */
5878       idx++;
5879       ueSetReq->protocolIEs.list.array[idx]->id = \
5880          ProtocolIE_ID_id_RRCDeliveryStatusRequest;
5881       ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
5882       ueSetReq->protocolIEs.list.array[idx]->value.present = \
5883          UEContextSetupRequestIEs__value_PR_RRCDeliveryStatusRequest;
5884       ueSetReq->protocolIEs.list.array[idx]->value.choice.RRCDeliveryStatusRequest = \
5885          RRCDeliveryStatusRequest_true;
5886
5887       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
5888
5889       /* Encode the F1SetupRequest type as APER */
5890       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5891       encBufSize = 0;
5892       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
5893             encBuf);
5894       /* Encode results */
5895       if(encRetVal.encoded == ENCODE_FAIL)
5896       {
5897          DU_LOG( "\n F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
5898                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5899          break;
5900       }
5901       else
5902       {
5903          DU_LOG("\n F1AP : Created APER encoded buffer for UE Context Setup Request\n");
5904          for(int i=0; i< encBufSize; i++)
5905          {
5906             printf("%x",encBuf[i]);
5907          }
5908       }
5909
5910       /* Sending  msg  */
5911       if(SendF1APMsg(CU_APP_MEM_REG,CU_POOL)    !=      ROK)
5912       {
5913          DU_LOG("\n F1AP : Sending UE Context Setup Request Failed");
5914          break;
5915       }
5916       ret = ROK;
5917       break;
5918    }
5919    FreeUeContextSetupReq(f1apMsg);
5920
5921    return ret;
5922 }/* End of BuildAndSendUeContextSetupReq*/
5923
5924 /****************************************************************
5925  * @brief Function to process Ul Rrc Msg received from DU
5926  *
5927  * @details
5928  *
5929  *    Function : procUlRrcMsg
5930  *
5931  *    Functionality:
5932  *         - Function to process Ul Rrc Msg received from DU
5933  *
5934  * @params[in]
5935  * @return ROK     - success
5936  *         RFAILED - failure
5937  *
5938  * ****************************************************************/
5939
5940 uint8_t procUlRrcMsg(F1AP_PDU_t *f1apMsg)
5941 {
5942    uint8_t idx, ret, srbId, rrcMsgType;
5943    uint8_t cuUeF1apId, duUeF1apId;
5944    uint8_t *rrcContainer = NULLP;
5945    uint16_t rrcContLen;
5946    ULRRCMessageTransfer_t *ulRrcMsg = NULLP;
5947
5948    ret = ROK;
5949    ulRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
5950
5951    for(idx=0; idx < ulRrcMsg->protocolIEs.list.count; idx++)
5952    {
5953       switch(ulRrcMsg->protocolIEs.list.array[idx]->id)
5954       {
5955          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
5956             {
5957                cuUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
5958                break;
5959             }
5960          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
5961             {
5962                duUeF1apId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
5963                break;
5964             }
5965          case ProtocolIE_ID_id_SRBID:
5966             srbId = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
5967             break;
5968          case ProtocolIE_ID_id_RRCContainer:
5969             {
5970                rrcContLen = ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
5971                CU_ALLOC(rrcContainer, rrcContLen)
5972                if(!rrcContainer)
5973                {
5974                   DU_LOG("\nCU_STUB: Failed to allocated memory in procUlRrcMsg");
5975                   return RFAILED;
5976                }
5977                memcpy(rrcContainer, ulRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
5978                      rrcContLen);
5979                break;
5980             }
5981
5982          default:
5983             DU_LOG("\n Invalid Event %ld", ulRrcMsg->protocolIEs.list.array[idx]->id);
5984             break;
5985       }
5986    }
5987    if(srbId == 1)
5988    {
5989       f1apMsgDb.dlRrcMsgCount++;
5990       rrcMsgType = setDlRRCMsgType();
5991       if(rrcMsgType == RRC_SECURITY_MODE_COMMAND)
5992       {
5993          ret = BuildAndSendUeContextSetupReq(cuUeF1apId, duUeF1apId, rrcContLen, rrcContainer);
5994       }
5995       if(rrcMsgType == RRC_RECONFIG)
5996       {
5997          ret = BuildAndSendDLRRCMessageTransfer(rrcMsgType);
5998       }
5999    }
6000    return ret;
6001 }
6002
6003 /****************************************************************
6004  * @brief Build And Send F1ResetAck
6005  *
6006  * @details
6007  *
6008  *    Function : FreeF1ResetAck
6009  *
6010  *    Functionality:
6011  *         - Build And Send  F1ResetRSP
6012  *
6013  *  @params[in]
6014  * @return ROK     - success
6015  *         RFAILED - failure
6016  *
6017  * ****************************************************************/
6018 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
6019 {
6020     uint8_t idx;
6021     ResetAcknowledge_t *f1ResetAck;
6022
6023     if(f1apMsg)
6024     {
6025        if(f1apMsg->choice.successfulOutcome)
6026        {
6027           f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
6028
6029           if(f1ResetAck->protocolIEs.list.array)
6030           {
6031              for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
6032              {
6033                 if(f1ResetAck->protocolIEs.list.array[idx])
6034                 {
6035                    CU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
6036                 }
6037              }
6038              CU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
6039           }
6040           CU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
6041        }
6042        CU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6043     }
6044 }
6045
6046 /****************************************************************
6047 * @brief Build And Send F1ResetAck
6048 *
6049 * @details
6050 *
6051 *    Function : BuildAndSendF1ResetAck
6052 *
6053 *    Functionality:
6054 *         - Build And Send  F1ResetRSP
6055 *
6056 *  @params[in]
6057 * @return ROK     - success
6058 *         RFAILED - failure
6059 *
6060 * ****************************************************************/
6061
6062 uint8_t BuildAndSendF1ResetAck()
6063 {
6064    uint8_t                idx = 0;
6065    uint8_t                elementCnt = 0;
6066    uint8_t                ret = RFAILED;
6067    F1AP_PDU_t             *f1apMsg = NULL;
6068    ResetAcknowledge_t     *f1ResetAck = NULLP;
6069    asn_enc_rval_t         encRetVal;
6070    DU_LOG("\nF1AP : Building F1 Reset Acknowledgment \n");
6071
6072    do{
6073         /* Allocate the memory for F1ResetRequest_t */
6074         CU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6075         if(f1apMsg == NULLP)
6076         {
6077            DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
6078            break;
6079         }
6080
6081         f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
6082
6083         CU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
6084         if(f1apMsg->choice.successfulOutcome == NULLP)
6085         {
6086            DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
6087            break;
6088         }
6089
6090         f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_Reset;
6091         f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
6092         f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
6093         f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
6094
6095         elementCnt = 1;
6096
6097         f1ResetAck->protocolIEs.list.count = elementCnt;
6098         f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
6099
6100         CU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
6101         if(f1ResetAck->protocolIEs.list.array == NULLP)
6102         {
6103            DU_LOG("\nF1AP : Memory allocation for F1ResetAckIEs failed");
6104            break;
6105         }
6106
6107         for(idx=0; idx<elementCnt; idx++)
6108         {
6109            CU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
6110            if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
6111            {
6112               break;
6113            }
6114         }
6115         /*TransactionID*/
6116         idx = 0;
6117         f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
6118         f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
6119         f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
6120         f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
6121
6122         xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6123
6124         /* Encode the F1SetupRequest type as UPER */
6125         memset(encBuf, 0, ENC_BUF_MAX_LEN);
6126         encBufSize = 0;
6127         encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6128
6129         /* Check encode results */
6130         if(encRetVal.encoded == ENCODE_FAIL)
6131         {
6132            DU_LOG("\nF1AP : Could not encode F1ResetAck structure (at %s)\n",\
6133                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6134            break;
6135         }
6136         else
6137         {
6138            DU_LOG("\nF1AP : Created APER encoded buffer for F1ResetAck \n");
6139            for(int i=0; i< encBufSize; i++)
6140            {
6141               printf("%x",encBuf[i]);
6142            }
6143         }
6144         /* Sending msg */
6145         if(SendF1APMsg(CU_APP_MEM_REG, CU_POOL) != ROK)
6146         {
6147            DU_LOG("\nF1AP : Sending F1 Reset Response failed");
6148            break;
6149         }
6150
6151         ret = ROK;
6152         break;
6153    }while(true);
6154
6155    FreeF1ResetAck(f1apMsg);
6156    return ret;
6157 }
6158
6159 /*******************************************************************
6160  *
6161  * @brief Handles received F1AP message and sends back response
6162  *
6163  * @details
6164  *
6165  *    Function : F1APMsgHdlr
6166  *
6167  *    Functionality:
6168  *         - Decodes received F1AP control message
6169  *         - Prepares response message, encodes and sends to SCTP
6170  *
6171  * @params[in]
6172  * @return ROK     - success
6173  *         RFAILED - failure
6174  *
6175  * ****************************************************************/
6176 void F1APMsgHdlr(Buffer *mBuf)
6177 {
6178    int i;
6179    char *recvBuf;
6180    MsgLen copyCnt;
6181    MsgLen recvBufLen;
6182    F1AP_PDU_t *f1apMsg = NULLP;
6183    asn_dec_rval_t rval; /* Decoder return value */
6184    F1AP_PDU_t f1apasnmsg ;
6185
6186    DU_LOG("\nF1AP : Received F1AP message buffer");
6187    ODU_PRINT_MSG(mBuf, 0,0);
6188
6189    /* Copy mBuf into char array to decode it */
6190    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
6191    CU_ALLOC(recvBuf, (Size)recvBufLen);
6192
6193    if(recvBuf == NULLP)
6194    {
6195       DU_LOG("\nF1AP : Memory allocation failed");
6196       return;
6197    }
6198    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
6199    {
6200       DU_LOG("\nF1AP : Failed while copying %d", copyCnt);
6201       return;
6202    }
6203
6204    printf("\nF1AP : Received flat buffer to be decoded : ");
6205    for(i=0; i< recvBufLen; i++)
6206    {
6207       printf("%x",recvBuf[i]);
6208    }
6209
6210    /* Decoding flat buffer into F1AP messsage */
6211    f1apMsg = &f1apasnmsg;
6212    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
6213
6214    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
6215    CU_FREE(recvBuf, (Size)recvBufLen);
6216
6217    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
6218    {
6219       DU_LOG("\nF1AP : ASN decode failed");
6220       return;
6221    }
6222    printf("\n");
6223    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6224
6225    switch(f1apMsg->present)
6226    {
6227       case F1AP_PDU_PR_initiatingMessage:
6228       {
6229          switch(f1apMsg->choice.initiatingMessage->value.present)
6230          {
6231             case InitiatingMessage__value_PR_Reset:
6232             {
6233                 DU_LOG("\nF1AP : F1 reset request received ");
6234                 BuildAndSendF1ResetAck();
6235                 break;
6236             }
6237
6238             case InitiatingMessage__value_PR_F1SetupRequest:
6239             {
6240                DU_LOG("\nF1AP : F1 setup request received");
6241                BuildAndSendF1SetupRsp();
6242                break;
6243             }
6244
6245             case InitiatingMessage__value_PR_GNBDUConfigurationUpdate:
6246             {
6247                DU_LOG("\nF1AP : GNB-DU config update received");
6248                BuildAndSendDUUpdateAck();
6249                DU_LOG("\nF1AP : Sending F1 reset request");
6250                BuildAndSendF1ResetReq();
6251                break;
6252             }
6253             case InitiatingMessage__value_PR_InitialULRRCMessageTransfer:
6254             {
6255                DU_LOG("\nF1AP : Received InitialULRRCMessageTransfer");
6256                procInitULRRCMsg(f1apMsg);
6257                break;
6258             }
6259             case InitiatingMessage__value_PR_ULRRCMessageTransfer:
6260             {
6261                DU_LOG("\nF1AP : Received ULRRCMessageTransfer");
6262                procUlRrcMsg(f1apMsg);
6263                break;
6264             }
6265
6266             case InitiatingMessage__value_PR_RRCDeliveryReport:
6267             {
6268                DU_LOG("\nF1AP : Received RRC delivery report");
6269                 break;
6270             }
6271             default:
6272             {
6273                DU_LOG("\nF1AP : Invalid type of intiating message [%d]",f1apMsg->choice.initiatingMessage->value.present);
6274                return;
6275             }
6276          }/* End of switch(initiatingMessage) */
6277          break;
6278       }
6279
6280       case F1AP_PDU_PR_successfulOutcome:
6281       {
6282          switch(f1apMsg->choice.successfulOutcome->value.present)
6283          {
6284             case SuccessfulOutcome__value_PR_ResetAcknowledge:
6285             {
6286                DU_LOG("\nF1Reset Acknowledgement is received successfully ");
6287                break;
6288             }
6289             case SuccessfulOutcome__value_PR_UEContextSetupResponse:
6290             {
6291                DU_LOG("\nF1AP : UE ContextSetupResponse received");
6292                break;
6293             }
6294             default:
6295             {
6296                DU_LOG("\nF1AP : Invalid type of successful outcome message [%d]",\
6297                   f1apMsg->choice.successfulOutcome->value.present);
6298                return;
6299             }
6300          }/* End of switch(successfulOutcome) */
6301          break;
6302       }
6303       default:
6304          {
6305             DU_LOG("\nF1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
6306             return;
6307          }
6308    }/* End of switch(f1apMsg->present) */
6309
6310 } /* End of F1APMsgHdlr */
6311
6312 /**********************************************************************
6313   End of file
6314  **********************************************************************/