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