src/du_app/du_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 "ckw.h"
  22 #include "ckw.x"
  23 #include "kwu.h"
  24 #include "kwu.x"
  25 #include "lkw.h"
  26 #include "lrg.h"
  27 #include "legtp.h"
  28 #include "lkw.x"
  29 #include "lrg.x"
  30 #include "F1AP-PDU.h"
  31 #include "InitiatingMessage.h"
  32 #include "SuccessfulOutcome.h"
  33 #include "du_app_mac_inf.h"
  34 #include "du_cfg.h"
  35 #include "du_app_rlc_inf.h"
  36 #include "du_mgr_main.h"
  37 #include "du_mgr.h"
  38 #include "du_utils.h"
  39 #include "du_ue_mgr.h"
  40 #include "RAT-Type.h"
  41 #include "NRFreqInfo.h"
  42 #include "NRCGI.h"
  43 #include "TDD-Info.h"
  44 #include "NR-Mode-Info.h"
  45 #include "ServedPLMNs-List.h"
  46 #include "GNB-DU-Served-Cells-List.h"
  47 #include "Served-Cell-Information.h"
  48 #include "ProtocolExtensionContainer.h"
  49 #include "RRC-Version.h"
  50 #include "FDD-Info.h"
  51 #include "FreqBandNrItem.h"
  52 #include "ServedPLMNs-Item.h"
  53 #include "GNB-DU-Served-Cells-Item.h"
  54 #include "SliceSupportItem.h"
  55 #include "FeatureSetUplinkPerCC.h"
  56 #include "SliceSupportItem.h"
  57 #include "Served-Cells-To-Modify-Item.h"
  58 #include "Served-Cells-To-Delete-List.h"
  59 #include "Served-Cells-To-Delete-Item.h"
  60 #include "QoSInformation.h"
  61 #include "ULUPTNLInformation-ToBeSetup-List.h"
  62 #include "DRB-Information.h"
  63 #include "DRBs-ToBeSetup-Item.h"
  64 #include "DRBs-ToBeSetupMod-Item.h"
  65 #include "DRBs-ToBeModified-Item.h"
  66 #include "CUtoDURRCInformation.h"
  67 #include "SCell-ToBeSetup-List.h"
  68 #include "SRBs-ToBeSetup-List.h"
  69 #include "DRBs-ToBeSetup-List.h"
  70 #include "SRBs-ToBeSetup-Item.h"
  71 #include "DRBs-ToBeModified-List.h"
  72 #include "RRCContainer.h"
  73 #include "UE-CapabilityRAT-ContainerList.h"
  74 #include "DRBs-Setup-List.h"
  75 #include "CellGroupConfig.h"
  76 #include "ResetAll.h"
  77 #include "ResetType.h"
  78 #include "Cells-to-be-Activated-List.h"
  79 #include "GNB-CU-Name.h"
  80 #include "SRBs-SetupMod-List.h"
  81 #include "DRBs-SetupMod-List.h"
  82 #include "DRBs-ToBeSetupMod-List.h"
  83 #include "PagingCell-Item.h"
  84 #include "PagingCell-list.h"
  85 #include "QoS-Characteristics.h"
  86 #include "ULUPTNLInformation-ToBeSetup-Item.h"
  87 #include "Flows-Mapped-To-DRB-Item.h"
  88 #include "NonDynamic5QIDescriptor.h"
  89 #include "Dynamic5QIDescriptor.h"
  90 #include "FeatureSetDownlinkPerCC.h"
  91 #include "FeatureSets.h"
  92 #include "UE-NR-Capability.h"
  93 #include "UE-CapabilityRAT-Container.h"
  94 #include "UE-CapabilityRAT-ContainerListRRC.h"
  95 #include "GNB-DU-System-Information.h"
  96 #include "CellGroupConfigRrc.h"
  97 #include "MAC-CellGroupConfig.h"
  98 #include "SchedulingRequestConfig.h"
  99 #include "SchedulingRequestToAddMod.h"
 100 #include "BSR-Config.h"
 101 #include "TAG-Config.h"
 102 #include "TAG.h"
 103 #include "PHR-Config.h"
 104 #include "RLC-Config.h"
 105 #include "UL-AM-RLC.h"
 106 #include "DL-AM-RLC.h"
 107 #include "LogicalChannelConfig.h"
 108 #include "RLC-BearerConfig.h"
 109 #include "PhysicalCellGroupConfig.h"
 110 #include "SpCellConfig.h"
 111 #include "TDD-UL-DL-ConfigDedicated.h"
 112 #include "ServingCellConfig.h"
 113 #include "ControlResourceSet.h"
 114 #include "SearchSpace.h"
 115 #include "PDCCH-Config.h"
 116 #include "PDSCH-TimeDomainResourceAllocation.h"
 117 #include "PDSCH-TimeDomainResourceAllocationList.h"
 118 #include "PDSCH-CodeBlockGroupTransmission.h"
 119 #include "PDSCH-ServingCellConfig.h"
 120 #include "DMRS-DownlinkConfig.h"
 121 #include "PDSCH-Config.h"
 122 #include "BWP-DownlinkDedicated.h"
 123 #include "BWP-Downlink.h"
 124 #include "PUSCH-TimeDomainResourceAllocation.h"
 125 #include "PUSCH-TimeDomainResourceAllocationList.h"
 126 #include "DMRS-UplinkConfig.h"
 127 #include "PUSCH-Config.h"
 128 #include "SRS-ResourceId.h"
 129 #include "SRS-Resource.h"
 130 #include "SRS-ResourceSet.h"
 131 #include "SRS-Config.h"
 132 #include "BWP-UplinkDedicated.h"
 133 #include "PUSCH-ServingCellConfig.h"
 134 #include "UplinkConfig.h"
 135 #include "DUtoCURRCContainer.h"
 136 #include "GBR-QoSFlowInformation.h"
 137 #include "QoSFlowLevelQoSParameters.h"
 138 #include "PUCCH-Config.h"
 139 #include "PUCCH-ResourceSet.h"
 140 #include "PUCCH-Resource.h"
 141 #include "PUCCH-PowerControl.h"
 142 #include "P0-PUCCH.h"
 143 #include "PUCCH-PathlossReferenceRS.h"
 144 #include "PUCCH-format0.h"
 145 #include "PUCCH-format1.h"
 146 #include "PUCCH-format2.h"
 147 #include "PUCCH-format3.h"
 148 #include "PUCCH-format4.h"
 149 #include "PUCCH-FormatConfig.h"
 150 #include "SchedulingRequestResourceConfig.h"
 151 #include<ProtocolIE-Field.h>
 152 #include "ProtocolExtensionField.h"
 153 #include "odu_common_codec.h"
 154 #include "du_mgr.h"
 155 #include "du_cell_mgr.h"
 156 #include "du_f1ap_msg_hdl.h"
 157 #include "DRBs-Setup-Item.h"
 158 #include "DLUPTNLInformation-ToBeSetup-List.h"
 159 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 160 #include "UPTransportLayerInformation.h"
 161 #include "GTPTunnel.h"
 162 #include "SupportedSULFreqBandItem.h"
 163 #include "du_e2ap_msg_hdl.h"
 164 #include "du_f1ap_conversions.h"
 165 #include "CNUEPagingIdentity.h"
 166 #include "PCCH-Config.h"
 167 #include "SCS-SpecificCarrier.h"
 168 #include "FrequencyInfoDL.h"
 169 #include "DownlinkConfigCommon.h"
 170 #include "FrequencyInfoUL.h"
 171 #include "UplinkConfigCommon.h"
 172 #include "TDD-UL-DL-ConfigCommon.h"
 173 #include "RACH-ConfigDedicated.h"
 174 #include "CFRA-SSB-Resource.h"
 175 #include "BWP-UplinkCommon.h"
 176 #include "ReconfigurationWithSync.h"
 177 #include "du_sys_info_hdl.h"
 178 #include "DRX-ConfigRrc.h"
 179
 180 #ifdef O1_ENABLE
 181 #include "CmInterface.h"
 182 extern StartupConfig g_cfg;
 183 #endif
 184
 185 DuCfgParams duCfgParam;
 186
 187 /******************************************************************
 188  *
 189  * @brief Function to fetch lcId based on DRB Id
 190  *
 191  * @details
 192  *
 193  *    Function : fetchLcId
 194  *
 195  *    @params[in] drbId
 196  *
 197  *    Functionality: Function to fetch lcId based on DRB Id
 198  *
 199  * Returns: lcId - SUCCESS
 200  *          RFAILED - FAILURE
 201  *****************************************************************/
 202
 203 uint8_t fetchLcId(uint8_t drbId)
 204 {
 205    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 206
 207    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 208    {
 209       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 210       {
 211          if(duCb.actvCellLst[cellIdx] != NULLP)
 212          {
 213             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.numLcs;
 214             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 215             {
 216                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbId == drbId && \
 217                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbType == RB_TYPE_DRB)
 218                {
 219                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].lcId;
 220                   return lcId;
 221                }
 222             }
 223          }
 224       }
 225    }
 226    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 227    return RFAILED;
 228 }
 229
 230 /*******************************************************************
 231 *
 232 * @brief Adding F1AP pdu to reserved pdu list
 233 *
 234 * @details
 235 *
 236 *    Function : addToReservedF1apPduList
 237 *
 238 *    Functionality: Adding F1AP pdu to reserved pdu list.
 239 *     These pdu are awaiting aknowledgment from CU
 240 *
 241 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 242 *
 243 * @return ROK - success
 244 *         RFAILED - failure
 245 *
 246 * ****************************************************************/
 247 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 248 {
 249    CmLList         *node = NULLP;
 250    ReservedF1apPduInfo *pduInfo = NULLP;
 251    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 252    if(pduInfo)
 253    {
 254       DU_ALLOC(node, sizeof(CmLList));
 255       if(node)
 256       {
 257          pduInfo->transId = transId;
 258          pduInfo->f1apMsg = (void*) f1apPdu;
 259
 260          node->node = (PTR)pduInfo;
 261          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 262       }
 263    }
 264 }
 265
 266 /*******************************************************************
 267 *
 268 * @brief searching for F1AP pdu from ReservedF1apPduList
 269 *
 270 * @details
 271 *
 272 *    Function : searchFromReservedF1apPduList
 273 *
 274 *    Functionality: searching for F1AP pdu information
 275 *
 276 * @params[in] uint8_t transId
 277 *
 278 * @return pointer to F1AP_PDU_t
 279 *
 280 * ****************************************************************/
 281
 282 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 283 {
 284    CmLList         *node;
 285    ReservedF1apPduInfo *f1apPdu;
 286    if(duCb.reservedF1apPduList.count)
 287    {
 288       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 289       while(node)
 290       {
 291          f1apPdu = (ReservedF1apPduInfo*)node->node;
 292          if(f1apPdu->transId == transId)
 293          {
 294             return node;
 295          }
 296          node = node->next;
 297       }
 298    }
 299    return NULL;
 300 }
 301
 302 /*******************************************************************
 303 *
 304 * @brief deleting F1AP pdu information from ReservedF1apPduList
 305 *
 306 * @details
 307 *
 308 *    Function : deleteFromReservedF1apPduList
 309 *
 310 *    Functionality: deleting pdu information from ReservedF1apPduList
 311 *
 312 * @params[in] CmLList *node
 313 *
 314 * @return void
 315 *
 316 * ****************************************************************/
 317
 318 void deleteFromReservedF1apPduList(CmLList *node)
 319 {
 320    ReservedF1apPduInfo *f1apPdu;
 321
 322    if(node != NULL)
 323    {
 324       f1apPdu = (ReservedF1apPduInfo *)node->node;
 325       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 326       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 327       DU_FREE(node, sizeof(CmLList));
 328       node = NULL;
 329    }
 330 }
 331
 332 /*******************************************************************
 333  *
 334  * @brief Builds Uplink Info for NR
 335  *
 336  * @details
 337  *
 338  *    Function : BuildULNRInfo
 339  *
 340  *    Functionality: Building NR Uplink Info
 341  *
 342  * @params[in] NRFreqInfo_t *ulnrfreq
 343  * @return ROK     - success
 344  *         RFAILED - failure
 345  *
 346  * ****************************************************************/
 347 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 348 {
 349    uint8_t idx=0;
 350    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 351                        fdd.ulNrFreqInfo.nrArfcn;
 352    ulnrfreq->freqBandListNr.list.count = 1;
 353    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 354    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 355    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 356    {
 357       return RFAILED;
 358    }
 359    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 360    {
 361       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 362       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 363       {
 364          return RFAILED;
 365       }
 366    }
 367    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 368                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 369                                                                  freqBand[0].nrFreqBand;
 370    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 371    return ROK;
 372 }
 373 /*******************************************************************
 374  *
 375  * @brief Builds Downlink NR Info
 376  *
 377  * @details
 378  *
 379  *    Function : BuildDLNRInfo
 380  *
 381  *    Functionality: Building Downlink NR Info
 382  *
 383  * @params[in] NRFreqInfo_t *dlnrfreq
 384  * @return ROK     - success
 385  *         RFAILED - failure
 386  *
 387  * ****************************************************************/
 388 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 389 {
 390    uint8_t idx=0;
 391    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 392                        fdd.dlNrFreqInfo.nrArfcn;
 393    dlnrfreq->freqBandListNr.list.count = 1;
 394    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 395    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 396    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 397    {
 398       return RFAILED;
 399    }
 400    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 401    {
 402       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 403       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 404       {
 405          return RFAILED;
 406       }
 407    }
 408    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 409                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 410                                                                  freqBand[0].nrFreqBand;
 411    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 412
 413    return ROK;
 414 }
 415
 416 /*******************************************************************
 417  *
 418  * @brief Builds Nrcgi
 419  *
 420  * @details
 421  *
 422  *    Function : BuildNrcgi
 423  *
 424  *    Functionality: Building the PLMN ID and NR Cell id
 425  *
 426  * @params[in] NRCGI_t *nrcgi
 427  * @return ROK     - success
 428  *         RFAILED - failure
 429  *
 430  * ****************************************************************/
 431 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 432 {
 433    uint8_t ret;
 434    uint8_t byteSize = 5;
 435    /* Allocate Buffer Memory */
 436    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 437    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 438    if(nrcgi->pLMN_Identity.buf == NULLP)
 439    {
 440       return RFAILED;
 441    }
 442    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 443          nrcgi->pLMN_Identity.buf); // Building PLMN function
 444    if(ret != ROK)
 445    {
 446       return RFAILED;
 447    }
 448    /*nrCellIdentity*/
 449    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 450    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 451    if(nrcgi->nRCellIdentity.buf == NULLP)
 452    {
 453       return RFAILED;
 454    }
 455    fillBitString(&nrcgi->nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
 456
 457    return ROK;
 458 }
 459 /*******************************************************************
 460  *
 461  * @brief Builds FiveGStac
 462  *
 463  * @details
 464  *
 465  *    Function : BuildFiveGSTac
 466  *
 467  *    Functionality: Building the FiveGSTac
 468  *
 469  * @params[in] OCTET_STRING_t *fivegsTac
 470  * @return ROK     - success
 471  *         RFAILED - failure
 472  *
 473  * ****************************************************************/
 474 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 475 {
 476    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 477    if(servcell->fiveGS_TAC == NULLP)
 478    {
 479       return RFAILED;
 480    }
 481    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 482    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 483          sizeof(servcell->fiveGS_TAC->size));
 484    if(servcell->fiveGS_TAC->buf == NULLP)
 485    {
 486       return RFAILED;
 487    }
 488    servcell->fiveGS_TAC->buf[0] = 0;
 489    servcell->fiveGS_TAC->buf[1] = 0;
 490    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 491    return ROK;
 492 }
 493
 494 /*******************************************************************
 495  *
 496  * @brief fill nr frequency information
 497  *
 498  * @details
 499  *
 500  *    Function : fillNrTddInfo
 501  *
 502  *    Functionality: fill nr frequency information
 503  *
 504  * @params[in] NRFreqInfo_t freqInfo
 505  * @return ROK     - success
 506  *         RFAILED - failure
 507  *
 508  * ****************************************************************/
 509 uint8_t fillNrTddInfo(TDD_Info_t *tddInfo)
 510 {
 511    uint8_t elementCnt = 1, freqBandListIdx = 0, supportedBandIdx = 0;
 512    NRFreqInfo_t *freqInfo = NULLP;
 513
 514    if(tddInfo == NULLP)
 515    {
 516       DU_LOG("\nERROR  --> DU APP : Null pointer received at fillNrTddInfo");
 517       return RFAILED;
 518    }
 519
 520    freqInfo = &tddInfo->nRFreqInfo;
 521    freqInfo->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn;
 522
 523    freqInfo->freqBandListNr.list.count = elementCnt;
 524    freqInfo->freqBandListNr.list.size = freqInfo->freqBandListNr.list.count  * sizeof(FreqBandNrItem_t *);
 525    DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
 526    if(!freqInfo->freqBandListNr.list.array)
 527    {
 528       DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 529       return RFAILED;
 530    }
 531
 532    for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
 533    {
 534       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
 535       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
 536       {
 537          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 538          return RFAILED;
 539       }
 540
 541       freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
 542       f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
 543       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
 544       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
 545       supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
 546
 547       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
 548             freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
 549       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
 550       {
 551          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 552          return RFAILED;
 553       }
 554
 555       for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
 556       {
 557          DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
 558                sizeof(SupportedSULFreqBandItem_t));
 559          if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
 560          {
 561             DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 562             return RFAILED;
 563          }
 564
 565          freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx]->freqBandIndicatorNr =\
 566          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.freqBand[0].sulBand[0];
 567       }
 568    }
 569
 570    tddInfo->transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs;
 571    tddInfo->transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb;
 572
 573    return ROK;
 574 }
 575
 576 /*******************************************************************
 577  *
 578  * @brief Builds NR Mode
 579  *
 580  * @details
 581  *
 582  *    Function : BuildNrMode
 583  *
 584  *    Functionality: Building the NR Mode
 585  *
 586  * @params[in] NR_Mode_Info_t *fdd
 587  * @return ROK     - success
 588  *         RFAILED - failure
 589  *
 590  * ****************************************************************/
 591 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 592 {
 593    uint8_t BuildDLNRInforet=0;
 594    uint8_t BuildULNRInforet=0;
 595
 596 #ifdef NR_TDD
 597    mode->present = NR_Mode_Info_PR_tDD;
 598 #else
 599    mode->present = NR_Mode_Info_PR_fDD;
 600 #endif
 601
 602    if(mode->present == NR_Mode_Info_PR_fDD)
 603    {
 604       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 605       if(mode->choice.fDD == NULLP)
 606       {
 607          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 608          return RFAILED;
 609       }
 610       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 611       if(BuildULNRInforet != ROK)
 612       {
 613          DU_LOG("\nERROR  --> Failed to build UlNrFreqInfo");
 614          return RFAILED;
 615       }
 616       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 617       if(BuildDLNRInforet != ROK)
 618       {
 619          DU_LOG("\nERROR  --> Failed to build DlNrFreqInfo");
 620          return RFAILED;
 621       }
 622       mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 623                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 624                                                           f1Mode.mode.fdd.ulTxBw.nrScs;
 625       mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 626                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 627                                                           f1Mode.mode.fdd.ulTxBw.nrb;
 628       mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 629                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 630                                                           f1Mode.mode.fdd.dlTxBw.nrScs;
 631       mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 632                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 633                                                           f1Mode.mode.fdd.dlTxBw.nrb;
 634    }
 635    else if(mode->present == NR_Mode_Info_PR_tDD)
 636    {
 637       DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
 638       if(mode->choice.tDD == NULLP)
 639       {
 640          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 641          return RFAILED;
 642       }
 643
 644       if(fillNrTddInfo(mode->choice.tDD) != ROK)
 645       {
 646          DU_LOG("\nERROR  --> Failed to fill Nr TDD information");
 647          return RFAILED;
 648       }
 649
 650    }
 651
 652    return ROK;
 653 }
 654 /*******************************************************************
 655  *
 656  * @brief Builds IE Extensions for Served PLMNs
 657  *
 658  * @details
 659  *
 660  *    Function : BuildExtensions
 661  *
 662  *    Functionality: Building the IE Extensions
 663  *
 664  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 665  * @return ROK     - success
 666  *         RFAILED - failure
 667  *
 668  * ****************************************************************/
 669 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 670 {
 671    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 672    uint8_t elementCnt=0, extensionCnt=0;
 673
 674    extensionCnt=IE_EXTENSION_LIST_COUNT;
 675    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 676    if((*ieExtend) == NULLP)
 677    {
 678       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 679       return RFAILED;
 680    }
 681    (*ieExtend)->list.count = extensionCnt;
 682    (*ieExtend)->list.size = \
 683                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 684    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 685    if((*ieExtend)->list.array == NULLP)
 686    {
 687       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 688       return RFAILED;
 689    }
 690    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 691    {
 692       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 693             sizeof(ServedPLMNs_ItemExtIEs_t));
 694       if((*ieExtend)->list.array[plmnidx] == NULLP)
 695       {
 696          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 697          return RFAILED;
 698       }
 699    }
 700
 701    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 702    idx = 0;
 703    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 704    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 705    (*ieExtend)->list.array[idx]->extensionValue.present = \
 706    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 707    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 708       list.count = elementCnt;
 709    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 710       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 711       list.count * sizeof(SliceSupportItem_t *);
 712
 713    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 714          list.array, elementCnt * sizeof(SliceSupportItem_t *));
 715    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 716          list.array == NULLP)
 717    {
 718       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 719       return RFAILED;
 720    }
 721
 722    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
 723    {
 724       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 725             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
 726       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 727             list.array[sliceLstIdx] == NULLP)
 728       {
 729          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 730          return RFAILED;
 731       }
 732       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 733          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
 734       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 735             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 736             extensionValue.choice.SliceSupportList.\
 737             list.array[sliceLstIdx]->sNSSAI.sST.size);
 738       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 739             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
 740       {
 741          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 742          return RFAILED;
 743       }
 744       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 745          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
 746          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
 747
 748       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 749             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 750       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 751             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
 752       {
 753          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 754          return RFAILED;
 755       }
 756       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 757          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
 758       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 759             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
 760             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 761       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 762             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
 763       {
 764          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 765          return RFAILED;
 766       }
 767       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 768       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
 769       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
 770       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 771    }
 772    return ROK;
 773 }
 774 /*******************************************************************
 775  *
 776  * @brief Builds Served PLMN
 777  *
 778  * @details
 779  *
 780  *    Function : BuildServedPlmn
 781  *
 782  *    Functionality: Building the Served PLMN
 783  *
 784  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 785  * @return ROK     - success
 786  *         RFAILED - failure
 787  *
 788  * ****************************************************************/
 789 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 790 {
 791    uint8_t  plmnidx;
 792    uint8_t  servPlmnCnt=1;
 793    uint8_t buildPlmnIdret=0;
 794    uint8_t BuildExtensionsret=0;
 795    srvplmn->list.count = servPlmnCnt;
 796    srvplmn->list.size = \
 797                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 798    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 799    if(srvplmn->list.array == NULLP)
 800    {
 801       return RFAILED;
 802    }
 803    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 804    {
 805       DU_ALLOC(srvplmn->list.array[plmnidx],\
 806             sizeof(ServedPLMNs_Item_t));
 807       if(srvplmn->list.array[plmnidx] == NULLP)
 808       {
 809          return RFAILED;
 810       }
 811    }
 812    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 813    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 814    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 815          srvplmn->list.array[0]->pLMN_Identity.buf);
 816    if(buildPlmnIdret!= ROK)
 817    {
 818       return RFAILED;
 819    }
 820    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 821    if(BuildExtensionsret!= ROK)
 822    {
 823       return RFAILED;
 824    }
 825    return ROK;
 826 }
 827 /*******************************************************************
 828  *
 829  * @brief Builds Served Cell List
 830  *
 831  * @details
 832  *
 833  *    Function : BuildServedCellList
 834  *
 835  *    Functionality: Building Served Cell List
 836  *
 837  * @params[in] PLMNID plmn
 838  * @return ROK     - success
 839  *         RFAILED - failure
 840  *
 841  * ****************************************************************/
 842
 843 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 844 {
 845    uint8_t  BuildNrcgiret=0;
 846    uint8_t  BuildFiveGSTacret=0;
 847    uint8_t  BuildServedPlmnret=0;
 848    uint8_t  BuildNrModeret=0;
 849    uint8_t  idx;
 850    uint8_t  plmnidx;
 851    uint8_t  plmnCnt=1;
 852    GNB_DU_Served_Cells_Item_t *srvCellItem;
 853    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 854    duServedCell->list.count = plmnCnt;
 855
 856    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
 857    if(duServedCell->list.array == NULLP)
 858    {
 859       return RFAILED;
 860    }
 861    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 862    {
 863       DU_ALLOC(duServedCell->list.array[plmnidx],\
 864             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 865       if(duServedCell->list.array[plmnidx] == NULLP)
 866       {
 867          return RFAILED;
 868       }
 869    }
 870    idx = 0;
 871    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 872    duServedCell->list.array[idx]->criticality = Criticality_reject;
 873    duServedCell->list.array[idx]->value.present = \
 874                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 875    srvCellItem = \
 876                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 877    /*nRCGI*/
 878    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 879    if(BuildNrcgiret != ROK)
 880    {
 881       return RFAILED;
 882    }
 883    /*nRPCI*/
 884    srvCellItem->served_Cell_Information.nRPCI = \
 885                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 886
 887    /*fiveGS_TAC*/
 888    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 889    if(BuildFiveGSTacret != ROK)
 890    {
 891       return RFAILED;
 892    }
 893    /*Served PLMNs*/
 894    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 895    if(BuildServedPlmnret !=ROK)
 896    {
 897       return RFAILED;
 898    }
 899    /*nR Mode Info with FDD*/
 900    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 901    if(BuildNrModeret != ROK)
 902    {
 903       return RFAILED;
 904    }
 905    /*Measurement timing Config*/
 906    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 907       size = sizeof(uint8_t);
 908    DU_ALLOC(srvCellItem->served_Cell_Information.\
 909          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 910    if(srvCellItem->served_Cell_Information.\
 911          measurementTimingConfiguration.buf == NULLP)
 912    {
 913       return RFAILED;
 914    }
 915    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 916                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 917
 918    /* GNB DU System Information */
 919    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 920          sizeof(GNB_DU_System_Information_t));
 921    if(!srvCellItem->gNB_DU_System_Information)
 922    {
 923       return RFAILED;
 924    }
 925    /* MIB */
 926    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
 927    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 928          srvCellItem->gNB_DU_System_Information->mIB_message.size);
 929    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 930    {
 931       return RFAILED;
 932    }
 933    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
 934                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
 935
 936    /* SIB1 */
 937    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 938                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 939
 940    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 941          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 942    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 943    {
 944       return RFAILED;
 945    }
 946    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 947    {
 948       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 949                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 950    }
 951    return ROK;
 952 }
 953 /*******************************************************************
 954  *
 955  * @brief Builds RRC Version
 956  *
 957  * @details
 958  *
 959  *    Function : BuildRrcVer
 960  *
 961  *    Functionality: Building RRC Version
 962  *
 963  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 964  * @return ROK     - success
 965  *         RFAILED - failure
 966  *
 967  * ****************************************************************/
 968 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
 969 {
 970    uint8_t rrcExt;
 971    uint8_t rrcLatest;
 972    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
 973    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
 974    if(rrcVer->latest_RRC_Version.buf == NULLP)
 975    {
 976       return RFAILED;
 977    }
 978    rrcVer->latest_RRC_Version.buf[0] = 0;
 979    rrcVer->latest_RRC_Version.bits_unused = 5;
 980    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 981    if(rrcVer->iE_Extensions == NULLP)
 982    {
 983       return RFAILED;
 984    }
 985    rrcVer->iE_Extensions->list.count = 1;
 986    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
 987    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
 988    if(rrcVer->iE_Extensions->list.array == NULLP)
 989    {
 990       return RFAILED;
 991    }
 992    rrcExt = 0;
 993    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 994          sizeof(RRC_Version_ExtIEs_t));
 995    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 996    {
 997       return RFAILED;
 998    }
 999    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1000                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1001    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1002    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1003                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1004    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1005       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1006    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1007          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1008          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1009    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1010          .Latest_RRC_Version_Enhanced.buf == NULLP)
1011    {
1012       return RFAILED;
1013    }
1014    rrcLatest = 0;
1015    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1016       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1017    rrcLatest++;
1018    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1019       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1020    rrcLatest++;
1021    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1022       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1023    return ROK;
1024 }
1025 /*******************************************************************
1026  *
1027  * @brief Sends F1 msg over SCTP
1028  *
1029  * @details
1030  *
1031  *    Function : sendF1APMsg
1032  *
1033  *    Functionality: Sends F1 msg over SCTP
1034  *
1035  * @params[in] Region region
1036  *             Pool pool
1037  * @return ROK     - success
1038  *         RFAILED - failure
1039  *
1040  * ****************************************************************/
1041 uint8_t sendF1APMsg()
1042 {
1043    Buffer *mBuf = NULLP;
1044
1045    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1046    {
1047       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1048       {
1049             ODU_PRINT_MSG(mBuf, 0,0);
1050
1051             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1052             {
1053                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1054                ODU_PUT_MSG_BUF(mBuf);
1055                return RFAILED;
1056             }
1057       }
1058       else
1059       {
1060          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1061          ODU_PUT_MSG_BUF(mBuf);
1062          return RFAILED;
1063       }
1064       ODU_PUT_MSG_BUF(mBuf);
1065    }
1066    else
1067    {
1068       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1069       return RFAILED;
1070    }
1071    return ROK;
1072 } /* sendF1APMsg */
1073
1074 /*******************************************************************
1075  *
1076  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1077  *
1078  * @details
1079  *
1080  *    Function :  FreeRrcVer
1081  *
1082  *    Functionality: deallocating the memory of function BuildRrcVer
1083  *
1084  * @params[in] RRC_Version_t *rrcVer
1085  *
1086  * @return void
1087  *
1088  *****************************************************************/
1089 void FreeRrcVer(RRC_Version_t *rrcVer)
1090 {
1091    if(rrcVer->latest_RRC_Version.buf != NULLP)
1092    {
1093       if(rrcVer->iE_Extensions != NULLP)
1094       {
1095          if(rrcVer->iE_Extensions->list.array != NULLP)
1096          {
1097             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1098             {
1099                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1100                      != NULLP)
1101                {
1102                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1103                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1104                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1105                }
1106                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1107             }
1108             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1109          }
1110          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1111       }
1112       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1113    }
1114 }
1115
1116 /*******************************************************************
1117  *
1118  * @brief Deallocating memory of TDD NrFreqInfo
1119  *
1120  * @details
1121  *
1122  *    Function : freeTddNrFreqInfo
1123  *
1124  *    Functionality: freeTddNrFreqInfo
1125  *
1126  * @params[in]  F1AP_PDU_t *f1apDuCfg
1127  *
1128  * @return ROK     - void
1129  *
1130  * ****************************************************************/
1131 void freeTddNrFreqInfo(NRFreqInfo_t *freqInfo)
1132 {
1133    uint8_t freqBandListIdx = 0, supportedBandIdx = 0;
1134
1135    if(freqInfo->freqBandListNr.list.array)
1136    {
1137       for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
1138       {
1139          if(freqInfo->freqBandListNr.list.array[freqBandListIdx])
1140          {
1141             if(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
1142             {
1143                for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
1144                {
1145                   DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1146                         sizeof(SupportedSULFreqBandItem_t));
1147                }
1148                DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
1149                      freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
1150
1151             }
1152             DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
1153          }
1154       }
1155       DU_FREE(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
1156    }
1157 }
1158
1159 /*******************************************************************
1160  *
1161  * @brief Deallocating memory allocated for Nr fdd frequencey mode
1162  *
1163  * @details
1164  *
1165  *    Function : freeFddNrFreqInfo
1166  *
1167  *    Functionality:Free memory allocated for Nr fdd frequencey mode
1168  *
1169  * @params[in]
1170  *
1171  * @return ROK     - void
1172  *
1173  * ****************************************************************/
1174 void freeFddNrFreqInfo(FDD_Info_t *fDD)
1175 {
1176    uint8_t arrIdx =0;
1177
1178    if(fDD != NULLP)
1179    {
1180       if(fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1181       {
1182          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1183                array[arrIdx], sizeof(FreqBandNrItem_t));
1184          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1185                fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1186       }
1187
1188       if(fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1189       {
1190          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.\
1191                array[arrIdx], sizeof(FreqBandNrItem_t));
1192          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1193                fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1194       }
1195       DU_FREE(fDD,sizeof(FDD_Info_t));
1196    }
1197 }
1198
1199 /*******************************************************************
1200  *
1201  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1202  *
1203  * @details
1204  *
1205  *    Function :  FreeServedCellList
1206  *
1207  *    Functionality:  deallocating the memory of function BuildServedCellList
1208
1209  *
1210  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1211  *
1212  * @return void
1213  *
1214  * ****************************************************************/
1215 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1216 {
1217    uint8_t   plmnCnt=MAX_PLMN;
1218    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1219    uint8_t  plmnIdx=0, sliceIdx=0;
1220    GNB_DU_Served_Cells_Item_t *srvCellItem;
1221    ServedPLMNs_Item_t  *servedPlmnItem;
1222    SliceSupportItem_t  *sliceSupportItem;
1223
1224    if(duServedCell->list.array!=NULLP)
1225    {
1226       if(duServedCell->list.array[0]!=NULLP)
1227       {
1228          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1229
1230          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1231                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1232          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1233                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1234
1235          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1236          {
1237             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1238                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1239             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1240          }
1241
1242          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1243          {
1244             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1245             {
1246                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1247                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1248
1249                if(servedPlmnItem->iE_Extensions != NULLP)
1250                {
1251                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1252                   {
1253                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1254                      {
1255                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1256                               SliceSupportList.list.array != NULLP)
1257                         {
1258                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1259                                  extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1260                            {
1261                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1262                                     SliceSupportList.list.array[sliceIdx] != NULLP)
1263                               {
1264                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1265                                                     extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1266
1267                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1268
1269                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1270                                  {
1271                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1272                                           sliceSupportItem->sNSSAI.sD->size);
1273                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1274                                  }
1275
1276                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1277                                        choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1278                               }
1279                            }
1280                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1281                                  SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1282                                  extensionValue.choice.SliceSupportList.list.size);
1283                         }
1284                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1285                               sizeof(ServedPLMNs_ItemExtIEs_t));
1286                      }
1287                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1288                            extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1289                   }
1290                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1291                }
1292                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1293                      sizeof(ServedPLMNs_Item_t));
1294             }
1295             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1296                   sizeof(ServedPLMNs_Item_t *));
1297          }
1298
1299          if(srvCellItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1300          {
1301             freeFddNrFreqInfo(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1302          }
1303          else
1304          {
1305             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD != NULLP)
1306             {
1307                freeTddNrFreqInfo(&srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1308                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1309             }
1310          }
1311
1312          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1313                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1314
1315          if(srvCellItem->gNB_DU_System_Information != NULLP)
1316          {
1317             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1318             {
1319                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1320                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1321             }
1322
1323             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1324             {
1325                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1326                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1327             }
1328
1329             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1330          }
1331
1332          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1333       }
1334       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1335    }
1336 }
1337
1338 /*******************************************************************
1339  *
1340  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1341  *
1342  * @details
1343  *
1344  *    Function :  FreeF1SetupReq
1345  *
1346  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1347  *
1348  * @params[in] F1AP_PDU_t *f1apMsg
1349  *
1350  * @return void
1351  *
1352  * ****************************************************************/
1353 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1354 {
1355    uint8_t ieIdx, ieIdx2;
1356    F1SetupRequest_t *f1SetupReq=NULLP;
1357
1358    if(f1apMsg != NULLP)
1359    {
1360       if(f1apMsg->choice.initiatingMessage != NULLP)
1361       {
1362          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1363          if(f1SetupReq->protocolIEs.list.array != NULLP)
1364          {
1365             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1366             {
1367                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1368                {
1369                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1370                   {
1371                      case ProtocolIE_ID_id_TransactionID:
1372                         break;
1373                      case ProtocolIE_ID_id_gNB_DU_ID:
1374                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1375                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1376                         break;
1377                      case ProtocolIE_ID_id_gNB_DU_Name:
1378                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1379                               strlen((char *)duCfgParam.duName));
1380                         break;
1381                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1382                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1383                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1384                         break;
1385                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1386                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1387                         break;
1388                      default:
1389                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1390                         break;
1391                   }
1392                }
1393             }
1394             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1395             {
1396                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1397             }
1398             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1399                   f1SetupReq->protocolIEs.list.size);
1400          }
1401          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1402       }
1403       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1404    }
1405 }
1406 /*******************************************************************
1407  *
1408  * @brief Builds and Send the F1SetupRequest
1409  *
1410  * @details
1411  *
1412  *    Function : BuildAndSendF1SetupReq
1413  *
1414  * Functionality:Fills the F1SetupRequest
1415  *
1416  * @return ROK     - success
1417  *         RFAILED - failure
1418  *
1419  ******************************************************************/
1420 uint8_t BuildAndSendF1SetupReq()
1421 {
1422    uint8_t   ret, ieIdx, elementCnt;
1423    F1AP_PDU_t                 *f1apMsg = NULLP;
1424    F1SetupRequest_t           *f1SetupReq=NULLP;
1425    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1426    RRC_Version_t              *rrcVer=NULLP;
1427    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1428    ret= RFAILED;
1429
1430    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1431    do
1432    {
1433       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1434       if(f1apMsg == NULLP)
1435       {
1436          break;
1437       }
1438       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1439       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1440       if(f1apMsg->choice.initiatingMessage == NULLP)
1441       {
1442          break;
1443       }
1444       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1445       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1446       f1apMsg->choice.initiatingMessage->value.present = \
1447                                                          InitiatingMessage__value_PR_F1SetupRequest;
1448
1449       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1450
1451       elementCnt = 4;
1452
1453       f1SetupReq->protocolIEs.list.count = elementCnt;
1454       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1455
1456       /* Initialize the F1Setup members */
1457       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1458       if(f1SetupReq->protocolIEs.list.array == NULLP)
1459       {
1460          break;
1461       }
1462       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1463       {
1464          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1465                sizeof(F1SetupRequestIEs_t));
1466          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1467          {
1468             break;
1469          }
1470       }
1471
1472       ieIdx = 0;
1473       /*TransactionID*/
1474       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1475       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1476       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1477                                                                 F1SetupRequestIEs__value_PR_TransactionID;
1478       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1479                                                                               TRANS_ID;
1480
1481       /*DU ID*/
1482       ieIdx++;
1483       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1484       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1485       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1486                                                                  F1SetupRequestIEs__value_PR_GNB_DU_ID;
1487       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1488                                                                               sizeof(uint8_t);
1489
1490       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1491             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1492       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1493             NULLP)
1494       {
1495          break;
1496       }
1497
1498       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1499                                                                                 duCfgParam.duId;
1500 #if 0
1501       /* DU name IE is of type printableString_t which wireshark is unable to decode.
1502        * However this string is decoded successfully on online decoders.
1503        * Since this is an optional IE and the value received in it are not
1504        * used as of now, eliminating this IE for now to avoid wireshark error.
1505        */
1506       /*DU Name*/
1507       if(duCfgParam.duName != NULL)
1508       {
1509          ieIdx++;
1510          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1511          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1512          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1513          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size = strlen((char *)duCfgParam.duName);
1514          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf, \
1515                f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size);
1516          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf == NULLP)
1517          {
1518             break;
1519          }
1520          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,
1521                (char*)&duCfgParam.duName);
1522       }
1523 #endif
1524
1525       /*Served Cell list */
1526       ieIdx++;
1527       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1528                                                       ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1529       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1530       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1531                                                                  F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1532       duServedCell = &f1SetupReq->protocolIEs.list.\
1533                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1534       if(BuildServedCellList(duServedCell))
1535       {
1536          break;
1537       }
1538
1539
1540       /*RRC Version*/
1541       ieIdx++;
1542       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1543                                                       ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1544       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1545       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1546                                                                  F1SetupRequestIEs__value_PR_RRC_Version;
1547       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1548       if(BuildRrcVer(rrcVer))
1549       {
1550          break;
1551       }
1552
1553       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1554
1555       /* Encode the F1SetupRequest type as APER */
1556       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1557       encBufSize = 0;
1558       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1559             encBuf);
1560
1561       /* Encode results */
1562       if(encRetVal.encoded == ENCODE_FAIL)
1563       {
1564          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1565                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1566          break;
1567       }
1568       else
1569       {
1570          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1571 #ifdef DEBUG_ASN_PRINT
1572          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1573          {
1574             printf("%x",encBuf[ieIdx]);
1575          }
1576 #endif
1577
1578          duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize;
1579          DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize);
1580          if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
1581          {
1582             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the encoding of f1setup req");
1583             return RFAILED;
1584          }
1585          memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
1586       }
1587
1588       /* Sending msg */
1589       if(sendF1APMsg() != ROK)
1590       {
1591          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1592          break;
1593       }
1594
1595       ret=ROK;
1596       break;
1597    }while(true);
1598
1599    FreeF1SetupReq(f1apMsg);
1600
1601    return ret;
1602 }/* End of BuildAndSendF1SetupReq */
1603
1604 /*******************************************************************
1605  *
1606  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1607  *
1608  * @details
1609  *
1610  *    Function : freeCellsToModifyItem
1611  *
1612  *    Functionality: Deallocating memory of variables allocated in
1613  *                    BuildAndSendDUConfigUpdate function
1614  *
1615  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1616  *
1617  * @return ROK     - void
1618  *
1619  * ****************************************************************/
1620
1621 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1622 {
1623    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1624    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1625    SliceSupportItem_t *sliceSupportItem = NULLP;
1626
1627    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1628    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1629
1630    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1631            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1632    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1633          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1634
1635    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1636    {
1637       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1638       {
1639          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1640
1641          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1642
1643          if(servedPlmnItem->iE_Extensions != NULLP)
1644          {
1645             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1646             {
1647                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1648                {
1649                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1650                         list.array != NULLP)
1651                   {
1652                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1653                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1654                      {
1655                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1656                               list.array[sliceLstIdx] != NULLP)
1657                         {
1658
1659                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1660                                               SliceSupportList.list.array[sliceLstIdx];
1661
1662                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1663                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1664                            {
1665                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1666                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1667                            }
1668                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1669                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1670                         }
1671                      }
1672                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1673                            choice.SliceSupportList.list.array,\
1674                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1675                            extensionValue.choice.SliceSupportList.list.size);
1676                   }
1677                }
1678                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1679                {
1680                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1681                }
1682                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1683             }
1684             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1685          }
1686       }
1687       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1688       {
1689          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1690       }
1691       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1692          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1693    }
1694
1695    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1696    {
1697       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1698    }
1699    else
1700    {
1701       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
1702       {
1703          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1704          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1705       }
1706    }
1707    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1708       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1709 }
1710
1711 /*******************************************************************
1712  *
1713  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1714  *
1715  * @details
1716  *
1717  *    Function : FreeDUConfigUpdate
1718  *
1719  *    Functionality: Deallocating memory of variables allocated in
1720  *                    BuildAndSendDUConfigUpdate function
1721  *
1722  * @params[in]  F1AP_PDU_t *f1apDuCfg
1723  *
1724  * @return ROK     - void
1725  *
1726  * ****************************************************************/
1727 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1728 {
1729    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1730    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1731    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1732    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1733    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1734    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1735
1736    if(f1apDuCfg != NULLP)
1737    {
1738       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1739       {
1740          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1741                        value.choice.GNBDUConfigurationUpdate;
1742          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1743          {
1744             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1745             {
1746                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1747                {
1748                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1749                   {
1750                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1751                         {
1752                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1753                                            value.choice.Served_Cells_To_Modify_List;
1754                            if(cellsToModify->list.array != NULLP)
1755                            {
1756                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1757                               {
1758                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1759                                  {
1760                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1761                                           Served_Cells_To_Modify_Item);
1762                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1763                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1764                                  }
1765                               }
1766                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1767                            }
1768                            break;
1769                         }
1770                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1771                         {
1772                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1773                                            value.choice.Served_Cells_To_Delete_List;
1774                            if(cellsToDelete->list.array != NULLP)
1775                            {
1776                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1777                               {
1778                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1779                                  {
1780                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1781                                           cellsToDelete->list.array[cellDeleteIdx]);
1782                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1783                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1784                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1785                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1786                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1787                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1788                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1789                                  }
1790                               }
1791                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1792                            }
1793
1794                            break;
1795                         }
1796                      case ProtocolIE_ID_id_gNB_DU_ID:
1797                         {
1798                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1799                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1800                            break;
1801                         }
1802                   }
1803                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1804                         sizeof(GNBDUConfigurationUpdateIEs_t));
1805                }
1806             }
1807             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1808          }
1809          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1810       }
1811       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1812    }
1813 }
1814
1815 /*******************************************************************
1816  *
1817  * @brief Fills Served Plmns required in ServCellInfo IE
1818  *
1819  * @details
1820  *
1821  *    Function : fillServedPlmns
1822  *
1823  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1824  *
1825  * @params[in] Pointer to ServedPLMNs_List_t *
1826  *
1827  * @return ROK     - success
1828  *         RFAILED - failure
1829  *
1830  *****************************************************************/
1831
1832 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1833 {
1834    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
1835
1836    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
1837    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
1838          array[arrayIdx]->pLMN_Identity.size);
1839    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
1840    {
1841       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1842       return RFAILED;
1843    }
1844    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
1845          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
1846    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1847    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
1848    {
1849       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1850       return RFAILED;
1851    }
1852
1853    ieListCnt=1;
1854    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
1855    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1856    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
1857          iE_Extensions->list.size);
1858    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
1859    {
1860       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1861       return RFAILED;
1862    }
1863    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
1864    {
1865       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
1866             sizeof(ServedPLMNs_ItemExtIEs_t));
1867       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
1868       {
1869          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1870          return RFAILED;
1871       }
1872    }
1873
1874    ieIdx = 0;
1875    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1876    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
1877    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
1878    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
1879    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1880    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1881       list.count = elementCnt;
1882    servedPlmn->list.array[arrayIdx]->\
1883       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1884       list.size = elementCnt * sizeof(SliceSupportItem_t *);
1885    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1886          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1887          list.array,servedPlmn->list.array[arrayIdx]->\
1888          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
1889    if(servedPlmn->list.array[arrayIdx]->\
1890          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1891          list.array == NULLP)
1892    {
1893       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1894       return RFAILED;
1895    }
1896
1897    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
1898    {
1899       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1900       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1901       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
1902       if(servedPlmn->list.array[arrayIdx]->\
1903       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1904       list.array[sliceLstIdx] == NULLP)
1905       {
1906          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1907          return RFAILED;
1908       }
1909
1910       servedPlmn->list.array[arrayIdx]->\
1911       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1912       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1913       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1914       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1915       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
1916       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
1917       sNSSAI.sST.size);
1918
1919       if(servedPlmn->list.array[arrayIdx]->\
1920       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1921       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1922       {
1923          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1924          return RFAILED;
1925       }
1926       servedPlmn->list.array[arrayIdx]->\
1927       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1928       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1929       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1930
1931       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1932       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1933       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1934       if(servedPlmn->list.array[arrayIdx]->\
1935       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1936       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1937       {
1938          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1939          return RFAILED;
1940       }
1941       servedPlmn->list.array[arrayIdx]->\
1942       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1943       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1944       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1945       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1946       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
1947       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1948       list.array[sliceLstIdx]->sNSSAI.sD->size);
1949       if(servedPlmn->list.array[arrayIdx]->\
1950       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1951       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1952       {
1953          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1954          return RFAILED;
1955       }
1956       memcpy(servedPlmn->list.array[arrayIdx]->\
1957       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1958       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1959       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
1960       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1961       list.array[sliceLstIdx]->sNSSAI.sD->size);
1962    }
1963    return ROK;
1964 }
1965
1966 /*******************************************************************
1967  *
1968  * @brief Fills Nr Fdd Info required in ServCellInfo IE
1969  *
1970  * @details
1971  *
1972  *    Function : fillNrFddInfo
1973  *
1974  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
1975  *
1976  * @params[in] FDD_Info_t *fDD
1977  *
1978  * @return ROK     - success
1979  *         RFAILED - failure
1980  *
1981  *****************************************************************/
1982
1983 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
1984 {
1985    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1986       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1987    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
1988    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1989    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1990          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1991    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1992    {
1993       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1994       return RFAILED;
1995    }
1996
1997    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
1998       sizeof(FreqBandNrItem_t));
1999    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2000    {
2001       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2002       return RFAILED;
2003    }
2004
2005    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2006       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2007       freqBand[0].nrFreqBand;
2008    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2009    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2010       dlNrFreqInfo.nrArfcn;
2011    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2012    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2013    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2014    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2015    {
2016       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2017       return RFAILED;
2018    }
2019
2020    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
2021    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2022    {
2023       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2024       return RFAILED;
2025    }
2026
2027    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2028       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2029       freqBand[0].nrFreqBand;
2030    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2031
2032    /*Transmission Bandwidth*/
2033    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2034       f1Mode.mode.fdd.ulTxBw.nrScs;
2035    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2036       f1Mode.mode.fdd.ulTxBw.nrb;
2037    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2038       f1Mode.mode.fdd.dlTxBw.nrScs;
2039    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2040       f1Mode.mode.fdd.dlTxBw.nrb;
2041
2042    return ROK;
2043 }
2044
2045 /*******************************************************************
2046  *
2047  * @brief Fills ServCellInfo IE
2048  *
2049  * @details
2050  *
2051  *    Function : fillServedCellInfo
2052  *
2053  *    Functionality: Fills ServCellInfo
2054  *
2055  * @params[in] Pointer to Served_Cell_Information_t *
2056  *
2057  * @return ROK     - success
2058  *         RFAILED - failure
2059  *
2060  *****************************************************************/
2061
2062 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2063 {
2064    uint8_t ieIdx, ieListCnt;
2065
2066    /*nRCGI*/
2067    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2068    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2069          srvCellInfo->nRCGI.pLMN_Identity.size);
2070    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2071    {
2072       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2073       return RFAILED;
2074    }
2075    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2076          srvCellInfo->nRCGI.pLMN_Identity.buf);
2077    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2078    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2079          srvCellInfo->nRCGI.nRCellIdentity.size);
2080    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2081    {
2082       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2083       return RFAILED;
2084    }
2085
2086    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2087    /*nRPCI*/
2088    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2089
2090    /*servedPLMNs*/
2091    ieListCnt = 1;
2092    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2093    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2094    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2095    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2096    {
2097       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2098       return RFAILED;
2099    }
2100    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2101    {
2102       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2103       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2104       {
2105          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2106          return RFAILED;
2107       }
2108    }
2109    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2110    {
2111       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2112       return RFAILED;
2113    }
2114
2115 #ifndef NR_TDD
2116    /*nR Mode Info with FDD*/
2117    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2118    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2119    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2120    {
2121       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2122       return RFAILED;
2123    }
2124    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2125    {
2126        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2127       return RFAILED;
2128    }
2129 #else
2130    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2131    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2132    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2133    {
2134       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2135       return RFAILED;
2136    }
2137    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2138    {
2139       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2140       return RFAILED;
2141    }
2142 #endif
2143
2144    /*Measurement timing Config*/
2145    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2146    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2147          buf,srvCellInfo->measurementTimingConfiguration.size);
2148    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2149    {
2150       return RFAILED;
2151    }
2152    srvCellInfo->measurementTimingConfiguration.\
2153          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2154
2155    return ROK;
2156 }
2157
2158 /*******************************************************************
2159  *
2160  * @brief Fills ServCellToModItem IE
2161  *
2162  * @details
2163  *
2164  *    Function : fillServCellToModItem
2165  *
2166  *    Functionality: Fills ServCellToModItem IE
2167  *
2168  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2169  *
2170  * @return ROK     - success
2171  *         RFAILED - failure
2172  *
2173  *****************************************************************/
2174
2175 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2176 {
2177    /*pLMN_Identity*/
2178    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2179    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2180    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2181    {
2182       return RFAILED;
2183    }
2184    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2185          modifyItem->oldNRCGI.pLMN_Identity.buf);
2186
2187    /*nRCellIdentity*/
2188    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2189    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2190          modifyItem->oldNRCGI.nRCellIdentity.size);
2191    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2192    {
2193       return RFAILED;
2194    }
2195    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2196
2197    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2198       return RFAILED;
2199    else
2200       return ROK;
2201 }
2202
2203 /*******************************************************************
2204  *
2205  * @brief Builds ServCellToModList
2206  *
2207  * @details
2208  *
2209  *    Function : buildServCellToModList
2210  *
2211  *    Functionality: Builds the serv cell to Mod List
2212  *
2213  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2214  *
2215  * @return ROK     - success
2216  *         RFAILED - failure
2217  *
2218  *****************************************************************/
2219
2220 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2221 {
2222    uint8_t ieListCnt, ieIdx;
2223    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2224
2225    ieListCnt = 1;
2226    cellsToModify->list.count = ieListCnt;
2227    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2228    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2229    if(cellsToModify->list.array == NULLP)
2230    {
2231       return RFAILED;
2232    }
2233    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2234    {
2235       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2236       if(cellsToModify->list.array[ieIdx] == NULLP)
2237       {
2238          return RFAILED;
2239       }
2240    }
2241    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2242    cellsToModify->list.array[0]->criticality = Criticality_reject;
2243    cellsToModify->list.array[0]->value.present =\
2244       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2245    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2246
2247    if(fillServCellToModItem(modifyItem))
2248       return RFAILED;
2249    else
2250       return ROK;
2251 }
2252 /*******************************************************************
2253  *
2254  * @brief filling the DeleteItemList
2255  *
2256  * @details
2257  *
2258  *    Function : fillCellToDeleteItem
2259  *
2260  *    Functionality: Filling the DeleteItemIe
2261  *
2262  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2263  *
2264  * @return ROK     - success
2265  *         RFAILED - failure
2266  *
2267  *****************************************************************/
2268 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2269 {
2270    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2271
2272    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2273    deleteItemIe->criticality = Criticality_reject;
2274    deleteItemIe->value.present =\
2275    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2276    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2277
2278    /*pLMN_Identity*/
2279    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2280    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2281    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2282    {
2283       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2284       return RFAILED;
2285    }
2286    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2287          deleteItem->oldNRCGI.pLMN_Identity.buf);
2288
2289    /*nRCellIdentity*/
2290    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2291    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2292          deleteItem->oldNRCGI.nRCellIdentity.size);
2293    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2294    {
2295       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2296       return RFAILED;
2297    }
2298    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2299    return ROK;
2300 }
2301 /*******************************************************************
2302  *
2303  * @brief Builds ServCellToDeleteList
2304  *
2305  * @details
2306  *
2307  *    Function : buildServCellToDeleteList
2308  *
2309  *    Functionality: Builds the serv cell to delete List
2310  *
2311  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2312  *
2313  * @return ROK     - success
2314  *         RFAILED - failure
2315  *
2316  *****************************************************************/
2317
2318 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2319 {
2320    uint8_t ieListCnt, arrIdx;
2321
2322    ieListCnt = 1;
2323    cellsToDelete->list.count = ieListCnt;
2324    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2325
2326    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2327    if(cellsToDelete->list.array == NULLP)
2328    {
2329       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2330       return RFAILED;
2331    }
2332
2333    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2334    {
2335       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2336       if(cellsToDelete->list.array[arrIdx] == NULLP)
2337       {
2338          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2339          return RFAILED;
2340       }
2341    }
2342
2343    arrIdx=0;
2344    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2345    {
2346       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2347       return RFAILED;
2348    }
2349    return ROK;
2350 }
2351
2352 /*******************************************************************
2353  *
2354  * @brief Builds and sends the DUConfigUpdate
2355  *
2356  * @details
2357  *
2358  *    Function : BuildAndSendDUConfigUpdate
2359  *
2360  *    Functionality: Constructs the DU Update message and sends
2361  *                   it to the CU through SCTP.
2362  *
2363  * @params[in] void **buf,Buffer to which encoded pattern is written into
2364  * @params[in] int *size,size of buffer
2365  *
2366  * @return ROK     - success
2367  *         RFAILED - failure
2368  *
2369  * ****************************************************************/
2370 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2371 {
2372    uint8_t ret =0, ieIdx=0, elementCnt=0;
2373    bool memAlloctionFailure = false;
2374    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2375    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2376    asn_enc_rval_t encRetVal;     /* Encoder return value */
2377
2378    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2379    ret= RFAILED;
2380
2381    while(true)
2382    {
2383       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2384       /* Allocate the memory for F1DuCfg */
2385       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2386       if(f1apDuCfg == NULLP)
2387       {
2388          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2389          break;
2390       }
2391
2392       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2393       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2394       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2395       {
2396          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2397          break;
2398       }
2399
2400       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2401                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2402       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2403       f1apDuCfg->choice.initiatingMessage->value.present = \
2404                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2405       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2406                     choice.GNBDUConfigurationUpdate;
2407       elementCnt = 3;
2408       duCfgUpdate->protocolIEs.list.count = elementCnt;
2409       duCfgUpdate->protocolIEs.list.size = \
2410                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2411
2412       /* Initialize the F1Setup members */
2413       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2414       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2415       {
2416          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2417          break;
2418       }
2419       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2420       {
2421          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2422          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2423          {
2424             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2425             memAlloctionFailure = true;
2426             break;
2427          }
2428       }
2429
2430       if(memAlloctionFailure == true)
2431       {
2432          break;
2433       }
2434       /*TransactionID*/
2435       ieIdx = 0;
2436       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2437       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2438       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2439       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2440       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2441
2442       ieIdx++;
2443       if(servCellAction == SERV_CELL_TO_MODIFY)
2444       {
2445          /*Served Cell to Modify */
2446          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2447          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2448          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2449          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2450          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2451          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2452                   Served_Cells_To_Modify_List))
2453          {
2454             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2455             break;
2456          }
2457       }
2458       else
2459       {
2460          /*Served Cell to Delete */
2461          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2462          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2463          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2464          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2465          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2466          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2467          Served_Cells_To_Delete_List)!=ROK)
2468          {
2469             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2470             break;
2471          }
2472
2473       }
2474       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2475       /*GNB DU ID */
2476       ieIdx++;
2477       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2478       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2479       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2480       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2481       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2482       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2483             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2484       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2485       {
2486          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2487          break;
2488       }
2489       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2490
2491       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2492
2493       /* Encode the DU Config Update type as APER */
2494       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2495       encBufSize = 0;
2496       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2497
2498       /* Checking encode results */
2499       if(encRetVal.encoded == ENCODE_FAIL)
2500       {
2501          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2502                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2503          break;
2504       }
2505       else
2506       {
2507          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2508 #ifdef DEBUG_ASN_PRINT
2509          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2510          {
2511             printf("%x",encBuf[ieIdx]);
2512          }
2513 #endif
2514       }
2515       /* Sending msg */
2516       if(sendF1APMsg() != ROK)
2517       {
2518          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2519          break;
2520       }
2521
2522       ret = ROK;
2523       break;
2524    }
2525
2526    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2527    return ret;
2528 }
2529
2530
2531 /*******************************************************************
2532  *
2533  * @brief free the ULRRCMessageTransfer
2534  *
2535  * @details
2536  *
2537  *    Function : FreeULRRCMessageTransfer
2538  *
2539  *    Functionality: Deallocating the memory of variable allocated in
2540  *                      FreeULRRCMessageTransfer
2541  *
2542  * @params[in]
2543  *
2544  * @return ROK     - void
2545  *
2546  ******************************************************************/
2547 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2548 {
2549    uint8_t idx1;
2550    ULRRCMessageTransfer_t  *ulRRCMsg;
2551
2552    if(f1apMsg != NULLP)
2553    {
2554       if(f1apMsg->choice.initiatingMessage != NULLP)
2555       {
2556          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2557          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2558          {
2559             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2560             {
2561                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2562                {
2563                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2564                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2565                   {
2566                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2567                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2568                   }
2569                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2570                }
2571             }
2572             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2573          }
2574          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2575       }
2576       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2577    }
2578 }
2579 /*******************************************************************
2580  *
2581  * @brief Builds and sends the ULRRCMessageTransfer
2582  *
2583  * @details
2584  *
2585  *    Function : BuildAndSendULRRCMessageTransfer
2586  *
2587  *    Functionality: Constructs the UL RRC Message Transfer and sends
2588  *                   it to the CU through SCTP.
2589  *
2590  * @params[in]
2591  *
2592  * @return ROK     - success
2593  *         RFAILED - failure
2594  *
2595  * ****************************************************************/
2596 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  *ueCb, uint8_t lcId, \
2597       uint16_t msgLen, uint8_t *rrcMsg)
2598 {
2599    uint8_t                 elementCnt=0, idx1=0, idx=0;
2600    uint8_t                 ret = RFAILED;
2601    F1AP_PDU_t              *f1apMsg = NULLP;
2602    ULRRCMessageTransfer_t  *ulRRCMsg = NULLP;
2603    asn_enc_rval_t          encRetVal;        /* Encoder return value */
2604
2605    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2606
2607    while(true)
2608    {
2609       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2610
2611       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2612       if(f1apMsg == NULLP)
2613       {
2614          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2615          break;
2616       }
2617       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2618       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2619       if(f1apMsg->choice.initiatingMessage == NULLP)
2620       {
2621          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2622          break;
2623       }
2624       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2625       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2626       f1apMsg->choice.initiatingMessage->value.present = \
2627                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2628       ulRRCMsg =
2629          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2630       elementCnt = 4;
2631       ulRRCMsg->protocolIEs.list.count = elementCnt;
2632       ulRRCMsg->protocolIEs.list.size = \
2633                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2634
2635       /* Initialize the F1Setup members */
2636       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2637       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2638       {
2639          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2640          break;
2641       }
2642       for(idx=0; idx<elementCnt; idx++)
2643       {
2644          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2645          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2646          {
2647             break;
2648          }
2649       }
2650
2651       idx1 = 0;
2652
2653       /*GNB CU UE F1AP ID*/
2654       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2655       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2656       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2657                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2658       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
2659
2660       /*GNB DU UE F1AP ID*/
2661       idx1++;
2662       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2663       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2664       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2665                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2666       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
2667
2668       /*SRBID*/
2669       idx1++;
2670       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2671       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2672       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2673                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2674       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2675
2676       /*RRCContainer*/
2677       idx1++;
2678       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2679       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2680       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2681                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2682       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2683       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2684             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2685       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2686       {
2687          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2688          break;
2689       }
2690       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2691       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2692             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2693
2694       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2695
2696       /* Encode the F1SetupRequest type as APER */
2697       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2698       encBufSize = 0;
2699       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2700             encBuf);
2701       /* Encode results */
2702       if(encRetVal.encoded == ENCODE_FAIL)
2703       {
2704          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2705                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2706          break;
2707       }
2708       else
2709       {
2710          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2711 #ifdef DEBUG_ASN_PRINT
2712          for(int i=0; i< encBufSize; i++)
2713          {
2714             printf("%x",encBuf[i]);
2715          }
2716 #endif
2717       }
2718
2719       /* Sending  msg  */
2720       if(sendF1APMsg()  !=      ROK)
2721       {
2722          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2723          break;
2724       }
2725       ret = ROK;
2726       break;
2727    }
2728    FreeULRRCMessageTransfer(f1apMsg);
2729
2730    return ret;
2731 }/* End of BuildAndSendULRRCMessageTransfer*/
2732
2733 /*******************************************************************
2734  *
2735  * @brief Builds tag config
2736  *
2737  * @details
2738  *
2739  *    Function : BuildTagConfig
2740  *
2741  *    Functionality: Builds tag config in MacCellGroupConfig
2742  *
2743  * @params[in] TAG_Config *tag_Config
2744  *
2745  * @return ROK     - success
2746  *         RFAILED - failure
2747  *
2748  * ****************************************************************/
2749 uint8_t BuildTagConfig(DuUeCb *ueCb, struct TAG_Config *tagConfig)
2750 {
2751    struct TAG_Config__tag_ToAddModList *tagList;
2752    uint8_t                     idx, elementCnt;
2753
2754    tagConfig->tag_ToReleaseList = NULLP;
2755    tagConfig->tag_ToAddModList = NULLP;
2756    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2757    if(!tagConfig->tag_ToAddModList)
2758    {
2759       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2760       return RFAILED;
2761    }
2762
2763    if(ueCb == NULLP)
2764       elementCnt = ODU_VALUE_ONE;
2765    else
2766       elementCnt = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModListCount;
2767
2768    tagList = tagConfig->tag_ToAddModList;
2769    tagList->list.count = elementCnt;
2770    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2771
2772    tagList->list.array = NULLP;
2773    DU_ALLOC(tagList->list.array, tagList->list.size);
2774    if(!tagList->list.array)
2775    {
2776       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2777       return RFAILED;
2778    }
2779
2780    for(idx=0; idx<tagList->list.count; idx++)
2781    {
2782       tagList->list.array[idx] = NULLP;
2783       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2784       if(!tagList->list.array[idx])
2785       {
2786          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2787          return RFAILED;
2788       }
2789    }
2790
2791    if(ueCb == NULLP)
2792    {
2793       idx = 0;
2794       tagList->list.array[idx]->tag_Id = TAG_ID;
2795       tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2796    }
2797    else
2798    {
2799       for(idx=0; idx<tagList->list.count; idx++)
2800       {
2801          tagList->list.array[idx]->tag_Id = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].tagId;
2802          tagList->list.array[idx]->timeAlignmentTimer = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].timeAlignTimer;
2803       }
2804    }
2805
2806    return ROK;
2807 }
2808
2809 /*******************************************************************
2810  *
2811  * @brief Builds PHR Config
2812  *
2813  * @details
2814  *
2815  *    Function : BuildPhrConfig
2816  *
2817  *    Functionality: Builds phrConfig in MacCellGroupConfig
2818  *
2819  * @params[in] PHR Config *
2820  *
2821  * @return ROK     - success
2822  *         RFAILED - failure
2823  *
2824  * ****************************************************************/
2825 uint8_t BuildPhrConfig(DuUeCb *ueCb, struct MAC_CellGroupConfig__phr_Config *phrConfig)
2826 {
2827
2828    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2829    phrConfig->choice.setup = NULLP;
2830    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2831    if(!phrConfig->choice.setup)
2832    {
2833       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2834       return RFAILED;
2835    }
2836
2837    if(ueCb == NULLP)
2838    {
2839       phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2840       phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2841       phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2842       phrConfig->choice.setup->multiplePHR              = false;
2843       phrConfig->choice.setup->dummy                    = false;
2844       phrConfig->choice.setup->phr_Type2OtherCell       = false;
2845       phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2846    }
2847    else
2848    {
2849       phrConfig->choice.setup->phr_PeriodicTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.periodicTimer;
2850       phrConfig->choice.setup->phr_ProhibitTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.prohibitTimer;
2851       phrConfig->choice.setup->phr_Tx_PowerFactorChange = ueCb->macUeCfg.macCellGrpCfg.phrCfg.txPowerFactor;
2852       phrConfig->choice.setup->multiplePHR              = ueCb->macUeCfg.macCellGrpCfg.phrCfg.multiplePHR;
2853       phrConfig->choice.setup->dummy                    = ueCb->macUeCfg.macCellGrpCfg.phrCfg.dummy;
2854       phrConfig->choice.setup->phr_Type2OtherCell       = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrType2OtherCell;
2855       phrConfig->choice.setup->phr_ModeOtherCG          = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrOtherCG;
2856    }
2857
2858    return ROK;
2859 }
2860
2861 /*******************************************************************
2862  *
2863  * @brief Builds BSR Config
2864  *
2865  * @details
2866  *
2867  *    Function : BuildBsrConfig
2868  *
2869  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2870  *
2871  * @params[in] BSR_Config *bsrConfig
2872  *
2873  * @return ROK     - success
2874  *         RFAILED - failure
2875  *
2876  * ****************************************************************/
2877 uint8_t BuildBsrConfig(DuUeCb *ueCb, struct BSR_Config *bsrConfig)
2878 {
2879    if(ueCb == NULLP)
2880    {
2881       bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2882       bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2883       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2884    }
2885    else
2886    {
2887       bsrConfig->periodicBSR_Timer = convertBsrPeriodicTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.periodicTimer);
2888       bsrConfig->retxBSR_Timer     = convertBsrRetxTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.retxTimer);
2889
2890       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2891       DU_ALLOC(bsrConfig->logicalChannelSR_DelayTimer, sizeof(long));
2892       if(bsrConfig->logicalChannelSR_DelayTimer == NULLP)
2893       {
2894          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildBsrConfig");
2895          return RFAILED;
2896       }
2897       *(bsrConfig->logicalChannelSR_DelayTimer) = convertLcSrDelayTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.srDelayTimer);
2898    }
2899
2900    return ROK;
2901 }
2902
2903 /*******************************************************************
2904  *
2905  * @brief Builds scheduling request config
2906  *
2907  * @details
2908  *
2909  *    Function : BuildSchedulingReqConfig
2910  *
2911  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2912  *
2913  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2914  *
2915  * @return ROK     - success
2916  *         RFAILED - failure
2917  *
2918  * ****************************************************************/
2919 uint8_t BuildSchedulingReqConfig(DuUeCb *ueCb, struct SchedulingRequestConfig *schedulingRequestConfig)
2920 {
2921    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2922    uint8_t                     idx, elementCnt;
2923
2924    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2925    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2926          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2927    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2928    {
2929       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2930       return RFAILED;
2931    }
2932
2933    if(ueCb == NULLP)
2934       elementCnt = ODU_VALUE_ONE;
2935    else
2936       elementCnt = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModListCount;
2937
2938    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2939    schReqList->list.count = elementCnt;
2940    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2941
2942    schReqList->list.array = NULLP;
2943    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2944    if(!schReqList->list.array)
2945    {
2946       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2947       return RFAILED;
2948    }
2949
2950    for(idx=0; idx<schReqList->list.count; idx++)
2951    {
2952       schReqList->list.array[idx] = NULLP;
2953       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2954       if(!schReqList->list.array[idx])
2955       {
2956          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2957          return RFAILED;
2958       }
2959    }
2960
2961    if(ueCb == NULLP)
2962    {
2963       idx = 0;
2964       schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2965
2966       schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2967       DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2968       if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2969       {
2970          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2971          return RFAILED;
2972       }
2973       *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2974       schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2975    }
2976    else
2977    {
2978       for(idx=0; idx<schReqList->list.count; idx++)
2979       {
2980          schReqList->list.array[idx]->schedulingRequestId = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].schedReqId;
2981
2982          schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2983          DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2984          if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2985          {
2986             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2987             return RFAILED;
2988          }
2989          *(schReqList->list.array[idx]->sr_ProhibitTimer) = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srProhibitTmr;
2990          schReqList->list.array[idx]->sr_TransMax = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srTransMax;
2991       }
2992    }
2993
2994    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2995
2996    return ROK;
2997 }
2998
2999 /*******************************************************************
3000  *
3001  * @brief Builds RLC Configuration for AM mode
3002  *
3003  * @details
3004  *
3005  *    Function : BuildRlcConfigAm
3006  *
3007  *    Functionality:
3008  *       Builds AM mode RLC Config in BuildRlcBearerToAddModList
3009  *
3010  * @params[in] AmBearerCfg *amCfg
3011  *             RLC_Config_t  *rlcConfig
3012  *
3013  * @return ROK     - success
3014  *         RFAILED - failure
3015  *
3016  * ****************************************************************/
3017 uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig)
3018 {
3019    rlcConfig->choice.am = NULLP;
3020    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3021    if(!rlcConfig->choice.am)
3022    {
3023       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3024       return RFAILED;
3025    }
3026
3027    /* Fill AM UL configuration */
3028    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3029    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3030    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3031    {
3032       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3033       return RFAILED;
3034    }
3035
3036    /* Fill default AM UL configuration if input pointer to DU database is NULL */
3037    if(amCfg == NULLP)
3038    {
3039       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3040       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3041       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3042       rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3043       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3044    }
3045    else
3046    {
3047       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->dlAmCfg.snLenDl);
3048       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = covertPollRetxTmrValueToEnum(amCfg->dlAmCfg.pollRetxTmr);
3049       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = covertPollPduValueToEnum(amCfg->dlAmCfg.pollPdu);
3050       rlcConfig->choice.am->ul_AM_RLC.pollByte          = covertPollByteValueToEnum(amCfg->dlAmCfg.pollByte);
3051       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = covertMaxRetxValueToEnum(amCfg->dlAmCfg.maxRetxTh);
3052    }
3053
3054    /* Fill AM DL configuraion */
3055    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3056    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3057    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3058    {
3059       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3060       return RFAILED;
3061    }
3062
3063    /* Fill default AM DL configuration if input pointer to DU database is NULL */
3064    if(amCfg == NULLP)
3065    {
3066       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3067       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3068       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3069    }
3070    else /* Fill AM configuration from DU database */
3071    {
3072       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->ulAmCfg.snLenUl);
3073       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = convertReasmblTmrValueToEnum(amCfg->ulAmCfg.reAssemTmr);
3074       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = convertProhibitTmrValueToEnum(amCfg->ulAmCfg.statProhTmr);
3075    }
3076    return ROK;
3077 }
3078
3079 /*******************************************************************
3080  *
3081  * @brief Builds RLC Config for UM Bidirection
3082  *
3083  * @details
3084  *
3085  *    Function : BuildRlcConfig UmBiDir
3086  *
3087  *    Functionality:
3088  *       Builds RLC Config for UM Bidirection in BuildRlcBearerToAddModList
3089  *
3090  * @params[in] UmBiDirBearerCfg *umBiDirCfg
3091  *             RLC_Config_t *rlcConfig
3092  *
3093  * @return ROK     - success
3094  *         RFAILED - failure
3095  *
3096  * ****************************************************************/
3097 uint8_t BuildRlcConfigUmBiDir(UmBiDirBearerCfg *umBiDirCfg, struct RLC_Config *rlcConfig)
3098 {
3099    rlcConfig->choice.um_Bi_Directional = NULLP;
3100    DU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
3101    if(rlcConfig->choice.um_Bi_Directional == NULLP)
3102    {
3103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3104       return RFAILED;
3105    }
3106
3107    /* Fill UM Bidirectional UL configuration */
3108    rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
3109    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3110    if(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength == NULLP)
3111    {
3112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3113       return RFAILED;
3114    }
3115
3116    if(umBiDirCfg != NULLP)
3117    {
3118       *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->dlUmCfg.snLenDlUm);
3119    }
3120
3121    /* Fill UM Bidirectional DL configuration */
3122    rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
3123    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3124    if(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength == NULLP)
3125    {
3126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3127       return RFAILED;
3128    }
3129
3130    if(umBiDirCfg != NULLP)
3131    {
3132       *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->ulUmCfg.snLenUlUm);
3133       rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umBiDirCfg->ulUmCfg.reAssemTmr);
3134    }
3135
3136    return ROK;
3137 }
3138
3139 /*******************************************************************
3140  *
3141  * @brief Builds RLC Config for UM Uni directional UL
3142  *
3143  * @details
3144  *
3145  *    Function : BuildRlcConfigUmUniDirUl
3146  *
3147  *    Functionality:
3148  *       Builds RLC Config for UM Unidirection UL in BuildRlcBearerToAddModList
3149  *
3150  * @params[in] UmUniDirDlBearerCfg *umUniDirDlCfg
3151  *             RLC_Config_t *rlcConfig
3152  *
3153  * @return ROK     - success
3154  *         RFAILED - failure
3155  *
3156  * ****************************************************************/
3157 uint8_t BuildRlcConfigUmUniDirUl(UmUniDirDlBearerCfg *umUniDirDlCfg, RLC_Config_t *rlcConfig)
3158 {
3159    rlcConfig->choice.um_Uni_Directional_UL = NULLP;
3160    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
3161    if(rlcConfig->choice.um_Uni_Directional_UL == NULLP)
3162    {
3163       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3164       return RFAILED;
3165    }
3166
3167    rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength = NULLP;
3168    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3169    if(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength == NULLP)
3170    {
3171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3172       return RFAILED;
3173    }
3174
3175    if(umUniDirDlCfg != NULLP)
3176    {
3177       *(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirDlCfg->dlUmCfg.snLenDlUm);
3178    }
3179
3180    return ROK;
3181 }
3182
3183 /*******************************************************************
3184  *
3185  * @brief Builds RLC Config for UM Uni directional DL
3186  *
3187  * @details
3188  *
3189  *    Function : BuildRlcConfigUmUniDirDl
3190  *
3191  *    Functionality:
3192  *       Builds RLC Config for UM Unidirection DL in BuildRlcBearerToAddModList
3193  *
3194  * @params[in] UmUniDirUlBearerCfg *umUniDirUlCfg
3195  *             RLC_Config_t *rlcConfig
3196  *
3197  * @return ROK     - success
3198  *         RFAILED - failure
3199  *
3200  * ****************************************************************/
3201 uint8_t BuildRlcConfigUmUniDirDl(UmUniDirUlBearerCfg *umUniDirUlCfg, RLC_Config_t *rlcConfig)
3202 {
3203    rlcConfig->choice.um_Uni_Directional_DL = NULLP;
3204    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
3205    if(rlcConfig->choice.um_Uni_Directional_DL == NULLP)
3206    {
3207       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3208       return RFAILED;
3209    }
3210
3211    rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength = NULLP;
3212    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3213    if(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength == NULLP)
3214    {
3215       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3216       return RFAILED;
3217    }
3218
3219    if(umUniDirUlCfg != NULLP)
3220    {
3221       *(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirUlCfg->ulUmCfg.snLenUlUm);
3222       rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umUniDirUlCfg->ulUmCfg.reAssemTmr);
3223    }
3224
3225    return ROK;
3226 }
3227
3228 /*******************************************************************
3229  *
3230  * @brief Builds RLC Config
3231  *
3232  * @details
3233  *
3234  *    Function : BuildRlcConfig
3235  *
3236  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3237  *
3238  * @params[in] RLC_Config_t *rlcConfig
3239  *
3240  * @return ROK     - success
3241  *         RFAILED - failure
3242  *
3243  * ****************************************************************/
3244 uint8_t BuildRlcConfig(RlcBearerCfg *rbCfg, struct RLC_Config *rlcConfig)
3245 {
3246
3247    /* Fill default values if rbCfg is NULL */
3248    if(rbCfg == NULLP)
3249    {
3250       rlcConfig->present = RLC_Config_PR_am;
3251       BuildRlcConfigAm(NULLP, rlcConfig);
3252    }
3253    /* If RbCfg is present, fill RLC configurations from DU Database */
3254    else
3255    {
3256       rlcConfig->present = covertRlcModeFromIntEnumToRrcEnum(rbCfg->rlcMode);
3257       switch(rlcConfig->present)
3258       {
3259          case RLC_Config_PR_am:
3260             BuildRlcConfigAm(rbCfg->u.amCfg, rlcConfig);
3261             break;
3262          case RLC_Config_PR_um_Bi_Directional:
3263             BuildRlcConfigUmBiDir(rbCfg->u.umBiDirCfg, rlcConfig);
3264             break;
3265          case RLC_Config_PR_um_Uni_Directional_UL:
3266             BuildRlcConfigUmUniDirUl(rbCfg->u.umUniDirDlCfg, rlcConfig);
3267             break;
3268          case RLC_Config_PR_um_Uni_Directional_DL:
3269             BuildRlcConfigUmUniDirDl(rbCfg->u.umUniDirUlCfg, rlcConfig);
3270             break;
3271          case RLC_Config_PR_NOTHING:
3272          default:
3273             break;
3274       }
3275    }
3276
3277    return ROK;
3278 }
3279
3280 /*******************************************************************
3281  *
3282  * @brief Builds MAC LC Config
3283  *
3284  * @details
3285  *
3286  *    Function : BuildMacLCConfig
3287  *
3288  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3289  *
3290  * @params[in] struct LogicalChannelConfig macLcConfig
3291  *
3292  * @return ROK     - success
3293  *         RFAILED - failure
3294  *
3295  * ****************************************************************/
3296 uint8_t BuildMacLCConfig(LcCfg *lcCfgDb, struct LogicalChannelConfig *macLcConfig)
3297 {
3298    macLcConfig->ul_SpecificParameters = NULLP;
3299    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3300    if(!macLcConfig->ul_SpecificParameters)
3301    {
3302       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3303       return RFAILED;
3304    }
3305
3306    if(lcCfgDb == NULLP)
3307    {
3308       macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3309       macLcConfig->ul_SpecificParameters->prioritisedBitRate =  PRIORTISIED_BIT_RATE;
3310       macLcConfig->ul_SpecificParameters->bucketSizeDuration =  BUCKET_SIZE_DURATION;
3311    }
3312    else
3313    {
3314       macLcConfig->ul_SpecificParameters->priority = lcCfgDb->ulLcCfg.priority;
3315       macLcConfig->ul_SpecificParameters->prioritisedBitRate = lcCfgDb->ulLcCfg.pbr;
3316       macLcConfig->ul_SpecificParameters->bucketSizeDuration = lcCfgDb->ulLcCfg.bsd;
3317    }
3318
3319    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3320    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3321    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3322    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3323
3324    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3325    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3326    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3327    {
3328       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3329       return RFAILED;
3330    }
3331
3332    if(lcCfgDb == NULLP)
3333       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3334    else
3335       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = lcCfgDb->ulLcCfg.lcGroup;
3336
3337    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3338    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3339    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3340    {
3341       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3342       return RFAILED;
3343    }
3344
3345    if(lcCfgDb == NULLP)
3346       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3347    else
3348       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = lcCfgDb->ulLcCfg.schReqId;
3349
3350    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3351    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3352    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3353
3354    return ROK;
3355 }
3356
3357 /*******************************************************************
3358  *
3359  * @brief Builds RLC Bearer to Add/Mod list
3360  *
3361  * @details
3362  *
3363  *    Function :BuildRlcBearerToAddModList
3364  *
3365  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3366  *
3367  * @params[in] rlc_BearerToAddModList
3368  *
3369  * @return ROK     - success
3370  *         RFAILED - failure
3371  *
3372  * ****************************************************************/
3373 uint8_t BuildRlcBearerToAddModList(DuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3374 {
3375    uint8_t  idx = 0, lcIdx=0, macLcIdx = 0, elementCnt = 0;
3376
3377    if(ueCb == NULLP)
3378       elementCnt = 1;
3379    else if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
3380       elementCnt = ueCb->rlcUeCfg.numLcs;
3381    else
3382    {
3383       for(lcIdx = 0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3384       {
3385          if(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == false)
3386             elementCnt++;
3387       }
3388    }
3389    rlcBearerList->list.count = elementCnt;
3390    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3391
3392    rlcBearerList->list.array = NULLP;
3393    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3394    if(!rlcBearerList->list.array)
3395    {
3396       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3397       return RFAILED;
3398    }
3399
3400    for(idx=0; idx<rlcBearerList->list.count; idx++)
3401    {
3402       rlcBearerList->list.array[idx] = NULLP;
3403       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3404       if(!rlcBearerList->list.array[idx])
3405       {
3406          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3407          return RFAILED;
3408       }
3409    }
3410
3411    if(ueCb == NULLP)
3412    {
3413       idx=0;
3414       rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3415       DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3416       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3417       {
3418          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3419          return RFAILED;
3420       }
3421       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3422       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB1_LCID;
3423       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3424
3425       /* Fill RLC related Configurations for this Radio Bearer */
3426       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3427       DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3428       if(!rlcBearerList->list.array[idx]->rlc_Config)
3429       {
3430          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3431          return RFAILED;
3432       }
3433       if(BuildRlcConfig(NULLP, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3434       {
3435          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3436          return RFAILED;
3437       }
3438
3439       /* Fill MAC related configurations for this Radio Bearer */
3440       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3441       DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3442       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3443       {
3444          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3445          return RFAILED;
3446       }
3447       if(BuildMacLCConfig(NULLP, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3448       {
3449          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3450          return RFAILED;
3451       }
3452    }
3453    else
3454    {
3455       idx=0;
3456       for(lcIdx=0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3457       {
3458          if((ueCb->f1UeDb->actionType != UE_CTXT_CFG_QUERY) && (ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == true))
3459             continue;
3460
3461          /* Fill Logical channel identity */
3462          rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId;
3463
3464          /* Fill Radio Bearer Id and type (DRB/SRB) for this logical channel */
3465          DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3466          if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3467          {
3468             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3469             return RFAILED;
3470          }
3471          rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3472                                                                       covertRbTypeFromIntEnumToRrcEnum(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbType);
3473          switch(rlcBearerList->list.array[idx]->servedRadioBearer->present)
3474          {
3475             case RLC_BearerConfig__servedRadioBearer_PR_srb_Identity:
3476                rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3477                break;
3478             case RLC_BearerConfig__servedRadioBearer_PR_drb_Identity:
3479                rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3480                break;
3481             case RLC_BearerConfig__servedRadioBearer_PR_NOTHING:
3482             default:
3483                break;
3484          }
3485          ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent = true;
3486
3487          rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3488
3489          /* Fill RLC related Configurations for this Radio Bearer */
3490          rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3491          DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3492          if(!rlcBearerList->list.array[idx]->rlc_Config)
3493          {
3494             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3495             return RFAILED;
3496          }
3497          if(BuildRlcConfig(&ueCb->rlcUeCfg.rlcLcCfg[lcIdx], rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3498          {
3499             DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3500             return RFAILED;
3501          }
3502
3503          /* Fill MAC related configurations for this Radio Bearer */
3504          rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3505          DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3506          if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3507          {
3508             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3509             return RFAILED;
3510          }
3511          for(macLcIdx = 0; macLcIdx < ueCb->macUeCfg.numLcs; macLcIdx++)
3512          {
3513             if(ueCb->macUeCfg.lcCfgList[macLcIdx].lcId == ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId)
3514             {
3515                if(BuildMacLCConfig(&ueCb->macUeCfg.lcCfgList[macLcIdx], rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3516                {
3517                   DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3518                   return RFAILED;
3519                }
3520                break;
3521             }
3522          }
3523
3524          idx++;
3525       }
3526    }
3527    return ROK;
3528 }
3529
3530 /*******************************************************************
3531  *
3532  * @brief Build Control resource set to add/modify list
3533  *
3534  * @details
3535  *
3536  *    Function : BuildControlRSetToAddModList
3537  *
3538  *    Functionality: Build Control resource set to add/modify list
3539  *
3540  * @params[in]
3541  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3542  *
3543  * @return ROK     - success
3544  *         RFAILED - failure
3545  *
3546  * ****************************************************************/
3547 uint8_t BuildControlRSetToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList)
3548 {
3549    uint8_t idx;
3550    uint8_t elementCnt;
3551    uint8_t numBytes, bitsUnused;
3552    struct ControlResourceSet *controlRSet;
3553    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3554    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3555
3556    if(pdcchCfg == NULLP)
3557       elementCnt = 1;
3558    else
3559       elementCnt = pdcchCfg->numCRsetToAddMod;
3560
3561    controlRSetList->list.count = elementCnt;
3562    controlRSetList->list.size = elementCnt * sizeof(struct ControlResourceSet *);
3563
3564    controlRSetList->list.array = NULLP;
3565    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3566    if(!controlRSetList->list.array)
3567    {
3568       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3569       return RFAILED;
3570    }
3571
3572    for(idx = 0; idx < elementCnt; idx++)
3573    {
3574       controlRSetList->list.array[idx] = NULLP;
3575       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3576       if(!controlRSetList->list.array[idx])
3577       {
3578          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3579          return RFAILED;
3580       }
3581    }
3582
3583    for(idx = 0; idx < elementCnt; idx++)
3584    {
3585       controlRSet = controlRSetList->list.array[idx];
3586
3587       if(pdcchCfg == NULLP)
3588          controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3589       else
3590          controlRSet->controlResourceSetId = pdcchCfg->cRSetToAddModList[idx].cRSetId;
3591
3592       /* size 6 bytes
3593        * 3 LSBs unsued
3594        * Bit string stored ff0000000000
3595        */
3596       numBytes = 6;
3597       bitsUnused = 3;
3598       controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3599
3600       controlRSet->frequencyDomainResources.buf = NULLP;
3601       DU_ALLOC(controlRSet->frequencyDomainResources.buf, controlRSet->frequencyDomainResources.size);
3602       if(!controlRSet->frequencyDomainResources.buf)
3603       {
3604          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3605          return RFAILED;
3606       }
3607
3608       memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3609
3610       if(pdcchCfg == NULLP)
3611       {
3612          coreset0EndPrb = CORESET0_END_PRB;
3613          coreset1StartPrb = coreset0EndPrb + 6;
3614          coreset1NumPrb = CORESET1_NUM_PRB;
3615          /* calculate the PRBs */
3616          fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3617          memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3618          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3619
3620          controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3621          controlRSet->cce_REG_MappingType.present = ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3622          controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3623       }
3624       else
3625       {
3626          memcpy(controlRSet->frequencyDomainResources.buf, pdcchCfg->cRSetToAddModList[idx].freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
3627          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3628          controlRSet->duration = pdcchCfg->cRSetToAddModList[idx].duration;
3629          controlRSet->cce_REG_MappingType.present = pdcchCfg->cRSetToAddModList[idx].cceRegMappingType;
3630          controlRSet->precoderGranularity = pdcchCfg->cRSetToAddModList[idx].precoderGranularity;
3631       }
3632       controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3633       controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3634       controlRSet->tci_PresentInDCI = NULLP;
3635
3636 #if 0
3637       uint8_t tciStateIdx;
3638
3639       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3640             sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3641       if(!controlRset->tci_StatesPDCCH_ToAddList)
3642       {
3643          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3644          return RFAILED;
3645       }
3646
3647       elementCnt = 1;
3648       controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3649       controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3650       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3651             controlRset->tci_StatesPDCCH_ToAddList->list.size)
3652          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3653          {
3654             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3655             return RFAILED;
3656          }
3657
3658       for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3659       {
3660          DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3661          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3662          {
3663             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3664             return RFAILED;
3665          }
3666       }
3667
3668       tciStateIdx = 0;
3669       /* TODO */
3670       *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3671
3672       DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3673       if(!controlRset->tci_PresentInDCI)
3674       {
3675          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3676          return RFAILED;
3677       }
3678       /* TODO */
3679       *(controlRset->tci_PresentInDCI);
3680 #endif
3681
3682       controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3683       DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3684       if(!controlRSet->pdcch_DMRS_ScramblingID)
3685       {
3686          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3687          return RFAILED;
3688       }
3689       if(pdcchCfg == NULLP)
3690          *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3691       else
3692          *(controlRSet->pdcch_DMRS_ScramblingID) = pdcchCfg->cRSetToAddModList[idx].dmrsScramblingId;
3693    }
3694    return ROK;
3695 } /* End BuildControlRSetToAddModList */
3696
3697 /*******************************************************************
3698  *
3699  * @brief Build search space to add/modify list
3700  *
3701  * @details
3702  *
3703  *    Function : BuildSearchSpcToAddModList
3704  *
3705  *    Functionality: Build search space to add/modify list
3706  *
3707  * @params[in]
3708  * @return ROK     - success
3709  *         RFAILED - failure
3710  *
3711  * ****************************************************************/
3712 uint8_t BuildSearchSpcToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
3713 {
3714    uint8_t idx;
3715    uint8_t numBytes;
3716    uint8_t byteIdx;
3717    uint8_t bitsUnused;
3718    uint8_t elementCnt;
3719    struct SearchSpace *searchSpc;
3720
3721    if(pdcchCfg == NULLP)
3722       elementCnt = 1;
3723    else
3724       elementCnt = pdcchCfg->numSearchSpcToAddMod;
3725
3726    searchSpcList->list.count = elementCnt;
3727    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3728
3729    searchSpcList->list.array = NULLP;
3730    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3731    if(!searchSpcList->list.array)
3732    {
3733       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3734       return RFAILED;
3735    }
3736
3737    for(idx = 0; idx < elementCnt; idx++)
3738    {
3739       searchSpcList->list.array[idx] = NULLP;
3740       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3741       if(!searchSpcList->list.array[idx])
3742       {
3743          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3744          return RFAILED;
3745       }
3746    }
3747
3748    for(idx = 0; idx < elementCnt; idx++)
3749    {
3750       searchSpc = searchSpcList->list.array[idx];
3751
3752       if(pdcchCfg == NULLP)
3753          searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3754       else
3755          searchSpc->searchSpaceId = pdcchCfg->searchSpcToAddModList[idx].searchSpaceId;
3756
3757       searchSpc->controlResourceSetId = NULLP;
3758       DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3759       if(!searchSpc->controlResourceSetId)
3760       {
3761          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3762          return RFAILED;
3763       }
3764       if(pdcchCfg == NULLP)
3765          *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3766       else
3767          *(searchSpc->controlResourceSetId) = pdcchCfg->searchSpcToAddModList[idx].cRSetId;
3768
3769       searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3770       DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3771       if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3772       {
3773          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3774          return RFAILED;
3775       }
3776       if(pdcchCfg == NULLP)
3777          searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3778       else
3779          searchSpc->monitoringSlotPeriodicityAndOffset->present = pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset;
3780
3781       searchSpc->duration = NULLP;
3782       searchSpc->monitoringSymbolsWithinSlot = NULLP;
3783       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3784       if(!searchSpc->monitoringSymbolsWithinSlot)
3785       {
3786          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3787          return RFAILED;
3788       }
3789
3790       /* Values taken from reference logs :
3791        * size 2 bytes
3792        * 2 LSBs unsued
3793        * Bit string stores 8000
3794        */
3795       numBytes = 2;
3796       bitsUnused = 2;
3797       searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3798       searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3799       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
3800       if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3801       {
3802          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3803          return RFAILED;
3804       }
3805       if(pdcchCfg == NULLP)
3806       {
3807          byteIdx = 0;
3808          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3809          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3810       }
3811       else
3812          memcpy(searchSpc->monitoringSymbolsWithinSlot->buf, pdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot, numBytes);
3813       searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3814
3815       searchSpc->nrofCandidates = NULLP;
3816       DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3817       if(!searchSpc->nrofCandidates)
3818       {
3819          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3820          return RFAILED;
3821       }
3822
3823       if(pdcchCfg == NULLP)
3824       {
3825          searchSpc->nrofCandidates->aggregationLevel1 = PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3826          searchSpc->nrofCandidates->aggregationLevel2 = PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3827          searchSpc->nrofCandidates->aggregationLevel4 = PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3828          searchSpc->nrofCandidates->aggregationLevel8 = PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3829          searchSpc->nrofCandidates->aggregationLevel16 = PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3830       }
3831       else
3832       {
3833          searchSpc->nrofCandidates->aggregationLevel1 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1;
3834          searchSpc->nrofCandidates->aggregationLevel2 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2;
3835          searchSpc->nrofCandidates->aggregationLevel4 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4;
3836          searchSpc->nrofCandidates->aggregationLevel8 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8;
3837          searchSpc->nrofCandidates->aggregationLevel16 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16;
3838       }
3839
3840       searchSpc->searchSpaceType = NULLP;
3841       DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3842       if(!searchSpc->searchSpaceType)
3843       {
3844          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3845          return RFAILED;
3846       }
3847       if(pdcchCfg == NULLP)
3848          searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3849       else
3850          searchSpc->searchSpaceType->present = pdcchCfg->searchSpcToAddModList[idx].searchSpaceType;
3851
3852       searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3853       DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3854       if(!searchSpc->searchSpaceType->choice.ue_Specific)
3855       {
3856          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3857          return RFAILED;
3858       }
3859       if(pdcchCfg == NULLP)
3860          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3861       else
3862          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = pdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat;
3863    }
3864    return ROK;
3865 }/* End BuildSearchSpcToAddModList */
3866
3867 /*******************************************************************
3868  *
3869  * @brief Builds BWP DL dedicated PDCCH config
3870  *
3871  * @details
3872  *
3873  *    Function : BuildBWPDlDedPdcchCfg
3874  *
3875  *    Functionality: Builds BWP DL dedicated PDCCH config
3876  *
3877  * @params[in] struct PDCCH_Config *pdcchCfg
3878  *
3879  * @return ROK     - success
3880  *         RFAILED - failure
3881  *
3882  * ****************************************************************/
3883 uint8_t BuildBWPDlDedPdcchCfg(PdcchConfig *pdcchCfgDb, struct PDCCH_Config *pdcchCfg)
3884 {
3885    pdcchCfg->controlResourceSetToAddModList = NULLP;
3886    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3887    if(!pdcchCfg->controlResourceSetToAddModList)
3888    {
3889       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3890       return RFAILED;
3891    }
3892
3893    if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
3894    {
3895       DU_LOG("\nERROR  --> F1AP : Failed in BuildControlRSetToAddModList()");
3896       return RFAILED;
3897    }
3898
3899    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3900
3901    pdcchCfg->searchSpacesToAddModList = NULLP;
3902    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3903    if(!pdcchCfg->searchSpacesToAddModList)
3904    {
3905       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3906       return RFAILED;
3907    }
3908
3909    if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
3910    {
3911       DU_LOG("\nERROR  --> F1AP : Failed in BuildSearchSpcToAddModList()");
3912       return RFAILED;
3913    }
3914
3915    pdcchCfg->searchSpacesToReleaseList = NULLP;
3916    pdcchCfg->downlinkPreemption = NULLP;
3917    pdcchCfg->tpc_PUSCH = NULLP;
3918    pdcchCfg->tpc_PUCCH = NULLP;
3919    pdcchCfg->tpc_SRS = NULLP;
3920
3921    return ROK;
3922 }
3923
3924 /*******************************************************************
3925  *
3926  * @brief Builds DMRS DL PDSCH Mapping type A
3927  *
3928  * @details
3929  *
3930  *    Function : BuildDMRSDLPdschMapTypeA
3931  *
3932  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3933  *
3934  * @params[in]
3935  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3936  * @return ROK     - success
3937  *         RFAILED - failure
3938  *
3939  * ****************************************************************/
3940 uint8_t BuildDMRSDLPdschMapTypeA(PdschConfig *pdschCfg, struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg)
3941 {
3942    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3943    dmrsDlCfg->choice.setup = NULLP;
3944    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3945    if(!dmrsDlCfg->choice.setup)
3946    {
3947       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3948       return RFAILED;
3949    }
3950
3951    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3952    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3953    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3954    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3955    {
3956       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3957       return RFAILED;
3958    }
3959    if(pdschCfg == NULLP)
3960       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3961    else
3962       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = pdschCfg->dmrsDlCfgForPdschMapTypeA.addPos;
3963
3964    dmrsDlCfg->choice.setup->maxLength = NULLP;
3965    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3966    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3967    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3968
3969    return ROK;
3970 }
3971
3972 /*******************************************************************
3973  *
3974  * @brief Builds TCI states to add/modify list
3975  *
3976  * @details
3977  *
3978  *    Function : BuildTCIStatesToAddModList
3979  *
3980  *    Functionality:Builds TCI states to add/modify list
3981  *
3982  * @params[in]
3983  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3984  *
3985  * @return ROK     - success
3986  *         RFAILED - failure
3987  *
3988  * ****************************************************************/
3989 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3990 {
3991    return ROK;
3992 }
3993
3994 /*******************************************************************
3995  *
3996  * @brief Builds PDSCH time domain allocation list
3997  *
3998  * @details
3999  *
4000  *    Function : BuildPdschTimeDomAllocList
4001  *
4002  *    Functionality: Builds PDSCH time domain allocation list
4003  *
4004  * @params[in]
4005  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4006  *
4007  * @return ROK     - success
4008  *         RFAILED - failure
4009  *
4010  * ****************************************************************/
4011 uint8_t BuildPdschTimeDomAllocList(PdschConfig *pdschCfg, struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4012 {
4013    uint8_t idx;
4014    uint8_t elementCnt;
4015    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
4016
4017    timeDomAllocList->present = PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
4018
4019    timeDomAllocList->choice.setup = NULLP;
4020    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4021    if(!timeDomAllocList->choice.setup)
4022    {
4023       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4024       return RFAILED;
4025    }
4026
4027 if(pdschCfg == NULLP)
4028    elementCnt = 2;
4029 else
4030 elementCnt = pdschCfg->numTimeDomRsrcAlloc;
4031    timeDomAllocList->choice.setup->list.count = elementCnt;
4032    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
4033
4034    timeDomAllocList->choice.setup->list.array = NULLP;
4035    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4036    if(!timeDomAllocList->choice.setup->list.array)
4037    {
4038       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4039       return RFAILED;
4040    }
4041
4042    for(idx = 0; idx < elementCnt; idx++)
4043    {
4044       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4045       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
4046             sizeof(struct PDSCH_TimeDomainResourceAllocation));
4047       if(!timeDomAllocList->choice.setup->list.array[idx])
4048       {
4049          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4050          return RFAILED;
4051       }
4052    }
4053
4054    if(pdschCfg == NULLP)
4055    {
4056       idx = 0;
4057       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4058       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4059       if(!timeDomAlloc->k0)
4060       {
4061          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4062          return RFAILED;
4063       }
4064       *(timeDomAlloc->k0) = 0;
4065       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4066       timeDomAlloc->startSymbolAndLength = \
4067                                            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4068
4069       idx++;
4070       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4071       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4072       if(!timeDomAlloc->k0)
4073       {
4074          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4075          return RFAILED;
4076       }
4077       *(timeDomAlloc->k0) = 1;
4078       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4079       timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4080    }
4081    else
4082    {
4083       for(idx = 0; idx < elementCnt; idx++)
4084       {
4085          timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4086          DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4087          if(!timeDomAlloc->k0)
4088          {
4089             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4090             return RFAILED;
4091          }
4092          if(pdschCfg->timeDomRsrcAllociList[idx].k0)
4093             *(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
4094          timeDomAlloc->mappingType = pdschCfg->timeDomRsrcAllociList[idx].mappingType;
4095          timeDomAlloc->startSymbolAndLength = pdschCfg->timeDomRsrcAllociList[idx].startSymbolAndLength;
4096       }
4097    }
4098
4099    return ROK;
4100 }
4101
4102 /*******************************************************************
4103  *
4104  * @brief Builds PDSCH PRB Bundling type
4105  *
4106  * @details
4107  *
4108  *    Function : BuildPdschPrbBundlingType
4109  *
4110  *    Functionality: Builds PDSCH PRB Bundling type
4111  *
4112  * @params[in]
4113  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4114  *
4115  * @return ROK     - success
4116  *         RFAILED - failure
4117  *
4118  * ****************************************************************/
4119 uint8_t BuildPdschPrbBundlingType(PdschConfig *pdschCfg, struct PDSCH_Config__prb_BundlingType *prbBndlType)
4120 {
4121    if(pdschCfg == NULLP)
4122       prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4123    else
4124       prbBndlType->present = pdschCfg->bundlingType;
4125
4126    prbBndlType->choice.staticBundling = NULLP;
4127    DU_ALLOC(prbBndlType->choice.staticBundling, \
4128          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4129    if(!prbBndlType->choice.staticBundling)
4130    {
4131       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4132       return RFAILED;
4133    }
4134    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4135
4136    return ROK;
4137 }
4138
4139 /*******************************************************************
4140  *
4141  * @brief Builds BWP DL dedicated PDSCH config
4142  *
4143  * @details
4144  *
4145  *    Function : BuildBWPDlDedPdschCfg
4146  *
4147  *    Functionality: Builds BWP DL dedicated PDSCH config
4148  *
4149  * @params[in] struct PDSCH_Config *pdschCfg
4150  *
4151  * @return ROK     - success
4152  *         RFAILED - failure
4153  *
4154  * ****************************************************************/
4155 uint8_t BuildBWPDlDedPdschCfg(PdschConfig *pdschCfgDb, struct PDSCH_Config *pdschCfg)
4156 {
4157    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4158
4159    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4160    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4161    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4162    {
4163       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4164       return RFAILED;
4165    }
4166
4167    if(BuildDMRSDLPdschMapTypeA(pdschCfgDb, pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4168    {
4169       return RFAILED;
4170    }
4171
4172    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4173    pdschCfg->tci_StatesToAddModList = NULLP;
4174    pdschCfg->tci_StatesToReleaseList = NULLP;
4175    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4176 #if 0
4177    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4178    if(!pdschCfg->tci_StatesToAddModList)
4179    {
4180       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4181       return RFAILED;
4182    }
4183    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4184    {
4185       return RFAILED;
4186    }
4187 #endif
4188
4189 if(pdschCfgDb == NULLP)
4190    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4191 else
4192 pdschCfg->resourceAllocation = pdschCfgDb->resourceAllocType;
4193
4194    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4195    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4196    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4197    {
4198       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4199       return RFAILED;
4200    }
4201    if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4202    {
4203       return RFAILED;
4204    }
4205
4206    pdschCfg->pdsch_AggregationFactor = NULLP;
4207    pdschCfg->rateMatchPatternToAddModList = NULLP;
4208    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4209    pdschCfg->rateMatchPatternGroup1 = NULLP;
4210    pdschCfg->rateMatchPatternGroup2 = NULLP;
4211    if(pdschCfgDb == NULLP)
4212       pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4213    else
4214       pdschCfg->rbg_Size = pdschCfgDb->rbgSize;
4215    pdschCfg->mcs_Table = NULLP;
4216
4217    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4218    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4219    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4220    {
4221       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4222       return RFAILED;
4223    }
4224    if(pdschCfgDb == NULLP)
4225       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4226    else
4227       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = pdschCfgDb->numCodeWordsSchByDci;
4228
4229    if(BuildPdschPrbBundlingType(pdschCfgDb, &pdschCfg->prb_BundlingType) != ROK)
4230    {
4231       return RFAILED;
4232    }
4233
4234    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4235    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4236    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4237    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4238    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4239    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4240    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4241
4242    return ROK;
4243 }
4244
4245 /*******************************************************************
4246  *
4247  * @brief Builds intitial DL BWP
4248  * @details
4249  *
4250  *    Function : BuildInitialDlBWP
4251  *
4252  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4253  *
4254  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4255  *
4256  * @return ROK     - success
4257  *         RFAILED - failure
4258  *
4259  * ****************************************************************/
4260 uint8_t BuildInitialDlBWP(InitialDlBwp *initiDlBwp, BWP_DownlinkDedicated_t *dlBwp)
4261 {
4262    PdcchConfig *pdcchCfg = NULLP;
4263    PdschConfig *pdschCfg = NULLP;
4264
4265    if(initiDlBwp)
4266    {
4267       if(initiDlBwp->pdcchPresent)
4268          pdcchCfg = &initiDlBwp->pdcchCfg;
4269       if(initiDlBwp->pdschPresent)
4270          pdschCfg = &initiDlBwp->pdschCfg;
4271    }
4272
4273    dlBwp->pdcch_Config = NULLP;
4274    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4275    if(!dlBwp->pdcch_Config)
4276    {
4277       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4278       return RFAILED;
4279    }
4280    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4281
4282    dlBwp->pdcch_Config->choice.setup = NULLP;
4283    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4284    if(!dlBwp->pdcch_Config->choice.setup)
4285    {
4286       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4287       return RFAILED;
4288    }
4289    if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
4290    {
4291       return RFAILED;
4292    }
4293
4294    dlBwp->pdsch_Config = NULLP;
4295    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4296    if(!dlBwp->pdsch_Config)
4297    {
4298       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4299       return RFAILED;
4300    }
4301    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4302
4303    dlBwp->pdsch_Config->choice.setup = NULLP;
4304    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4305    if(!dlBwp->pdsch_Config->choice.setup)
4306    {
4307       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4308       return RFAILED;
4309    }
4310
4311    if(BuildBWPDlDedPdschCfg(pdschCfg, dlBwp->pdsch_Config->choice.setup) != ROK)
4312    {
4313       return RFAILED;
4314    }
4315
4316    dlBwp->sps_Config = NULLP;
4317    dlBwp->radioLinkMonitoringConfig = NULLP;
4318    return ROK;
4319 }
4320
4321 /*******************************************************************
4322  *
4323  * @brief Builds DMRS UL Pusch Mapping type A
4324  *
4325  * @details
4326  *
4327  *    Function : BuildDMRSULPuschMapTypeA
4328  *
4329  *    Functionality: Builds DMRS UL Pusch Mapping type A
4330  *
4331  * @params[in]
4332  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4333  * @return ROK     - success
4334  *         RFAILED - failure
4335  *
4336  * ****************************************************************/
4337 uint8_t BuildDMRSULPuschMapTypeA(DmrsUlCfg *ulDmrsCfgDb, struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg)
4338 {
4339    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4340    dmrsUlCfg->choice.setup= NULLP;
4341    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4342    if(!dmrsUlCfg->choice.setup)
4343    {
4344       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4345       return RFAILED;
4346    }
4347
4348    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4349    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4350    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4351    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4352    {
4353       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4354       return RFAILED;
4355    }
4356    if(ulDmrsCfgDb == NULLP)
4357       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4358    else
4359       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = ulDmrsCfgDb->addPos;
4360
4361    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4362    dmrsUlCfg->choice.setup->maxLength = NULLP;
4363    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4364    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4365    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4366    {
4367       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4368       return RFAILED;
4369    }
4370
4371    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4372    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4373          sizeof(long));
4374    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4375    {
4376       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4377       return RFAILED;
4378    }
4379    if(ulDmrsCfgDb == NULLP)
4380       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4381    else
4382       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = ulDmrsCfgDb->transPrecodDisabled.scramblingId0;
4383
4384    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4385    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4386    return ROK;
4387 }
4388
4389 /*******************************************************************
4390  *
4391  * @brief Build PUSCH time domain allocation list
4392  *
4393  * @details
4394  *
4395  *    Function : BuildPuschTimeDomAllocList
4396  *
4397  *    Functionality: Build PUSCH time domain allocation list
4398  *
4399  * @params[in]
4400  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4401  *
4402  * @return ROK     - success
4403  *         RFAILED - failure
4404  *
4405  * ****************************************************************/
4406 uint8_t BuildPuschTimeDomAllocList(PuschCfg *puschCfgDb, struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList)
4407 {
4408    uint8_t idx;
4409    uint8_t elementCnt;
4410    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4411
4412    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4413    timeDomAllocList->choice.setup = NULLP;
4414    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4415    if(!timeDomAllocList->choice.setup)
4416    {
4417       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4418       return RFAILED;
4419    }
4420
4421    if(puschCfgDb == NULLP)
4422       elementCnt = 2;
4423    else
4424       elementCnt = puschCfgDb->numTimeDomRsrcAlloc;
4425
4426    timeDomAllocList->choice.setup->list.count = elementCnt;
4427    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4428    timeDomAllocList->choice.setup->list.array = NULLP;
4429    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4430    if(!timeDomAllocList->choice.setup->list.array)
4431    {
4432       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4433       return RFAILED;
4434    }
4435
4436    for(idx = 0; idx < elementCnt; idx++)
4437    {
4438       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4439       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
4440       if(!timeDomAllocList->choice.setup->list.array[idx])
4441       {
4442          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4443          return RFAILED;
4444       }
4445    }
4446
4447    for(idx = 0; idx < elementCnt; idx++)
4448    {
4449       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4450       DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4451       if(!timeDomAlloc->k2)
4452       {
4453          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4454          return RFAILED;
4455       }
4456       if(puschCfgDb == NULLP)
4457       {
4458          if(idx == 0)
4459             *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4460          else if(idx == 1)
4461             *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4462
4463          timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4464          timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4465       }
4466       else
4467       {
4468          *(timeDomAlloc->k2) = puschCfgDb->timeDomRsrcAllocList[idx].k2;
4469          timeDomAlloc->mappingType = puschCfgDb->timeDomRsrcAllocList[idx].mappingType;
4470          timeDomAlloc->startSymbolAndLength = puschCfgDb->timeDomRsrcAllocList[idx].startSymbolAndLength;
4471       }
4472    }
4473
4474    return ROK;
4475 }
4476
4477 /*******************************************************************
4478  *
4479  * @brief Builds BWP UL dedicated PUSCH Config
4480  *
4481  * @details
4482  *
4483  *    Function : BuildBWPUlDedPuschCfg
4484  *
4485  *    Functionality:
4486  *      Builds BWP UL dedicated PUSCH Config
4487  *
4488  * @params[in] : PUSCH_Config_t *puschCfg
4489  *
4490  * @return ROK     - success
4491  *         RFAILED - failure
4492  *
4493  * ****************************************************************/
4494 uint8_t BuildBWPUlDedPuschCfg(PuschCfg *puschCfgDb, PUSCH_Config_t *puschCfg)
4495 {
4496    DmrsUlCfg *ulDmrsCfg = NULLP;
4497
4498    if(puschCfgDb)
4499       ulDmrsCfg = &puschCfgDb->dmrsUlCfgForPuschMapTypeA;
4500
4501    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4502    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4503    if(!puschCfg->dataScramblingIdentityPUSCH)
4504    {
4505       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4506       return RFAILED;
4507    }
4508    if(puschCfgDb == NULLP)
4509       *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4510    else
4511       *(puschCfg->dataScramblingIdentityPUSCH) = puschCfgDb->dataScramblingId;
4512
4513    puschCfg->txConfig = NULLP;
4514    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4515    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4516    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4517    {
4518       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4519       return RFAILED;
4520    }
4521
4522    if(BuildDMRSULPuschMapTypeA(ulDmrsCfg, puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4523    {
4524       return RFAILED;
4525    }
4526
4527    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4528    puschCfg->pusch_PowerControl = NULLP;
4529    puschCfg->frequencyHopping = NULLP;
4530    puschCfg->frequencyHoppingOffsetLists = NULLP;
4531
4532    if(puschCfgDb == NULLP)
4533       puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4534    else
4535       puschCfg->resourceAllocation = puschCfgDb->resourceAllocType;
4536
4537    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4538    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4539    if(!puschCfg->pusch_TimeDomainAllocationList)
4540    {
4541       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4542       return RFAILED;
4543    }
4544
4545    if(BuildPuschTimeDomAllocList(puschCfgDb, puschCfg->pusch_TimeDomainAllocationList) != ROK)
4546    {
4547       return RFAILED;
4548    }
4549
4550    puschCfg->pusch_AggregationFactor = NULLP;
4551    puschCfg->mcs_Table = NULLP;
4552    puschCfg->mcs_TableTransformPrecoder = NULLP;
4553    puschCfg->transformPrecoder = NULLP;
4554    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4555    if(!puschCfg->transformPrecoder)
4556    {
4557       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4558       return RFAILED;
4559    }
4560    if(puschCfgDb == NULLP)
4561       *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4562    else
4563       *(puschCfg->transformPrecoder) = puschCfgDb->transformPrecoder;
4564
4565    puschCfg->codebookSubset = NULLP;
4566    puschCfg->maxRank = NULLP;
4567    puschCfg->rbg_Size = NULLP;
4568    puschCfg->uci_OnPUSCH = NULLP;
4569    puschCfg->tp_pi2BPSK = NULLP;
4570
4571    return ROK;
4572 }
4573
4574 /*******************************************************************
4575  *
4576  * @brief Builds PUCCH resource set add/modify list
4577  *
4578  * @details
4579  *
4580  *    Function : BuildPucchRsrcSetAddModList
4581  *
4582  *    Functionality:
4583  *      Builds PUCCH resource set add/modify list
4584  *
4585  * @params[in] : PucchResrcSetCfg *rsrcSetCfgDb
4586  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4587  *
4588  * @return ROK     - success
4589  *         RFAILED - failure
4590  *
4591  * ****************************************************************/
4592 uint8_t BuildPucchRsrcSetAddModList(PucchResrcSetCfg *rsrcSetCfgDb, \
4593    struct PUCCH_Config__resourceSetToAddModList *resourceSetToAddModList)
4594 {
4595    uint8_t elementCnt = 0, rsrcSetIdx = 0, rsrcIdx = 0;
4596    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4597
4598    if(rsrcSetCfgDb == NULLP)
4599       elementCnt = 1;
4600    else
4601       elementCnt = rsrcSetCfgDb->resrcSetToAddModListCount;
4602
4603    resourceSetToAddModList->list.count = elementCnt;
4604    resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4605    DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
4606    if(resourceSetToAddModList->list.array == NULLP)
4607    {
4608       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4609       return RFAILED;
4610    }
4611    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4612    {
4613       DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4614       if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4615       {
4616          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4617          return RFAILED;
4618       }
4619    }
4620
4621    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4622    {
4623       rsrcSet = resourceSetToAddModList->list.array[rsrcSetIdx];
4624
4625       /* Resource set Id */
4626       if(rsrcSetCfgDb == NULLP)
4627          rsrcSet->pucch_ResourceSetId = 1;
4628       else
4629          rsrcSet->pucch_ResourceSetId = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcSetId;
4630
4631       /* Resource list of a resource set */
4632       if(rsrcSetCfgDb == NULLP)
4633          elementCnt = 1;
4634       else
4635          elementCnt = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcListCount;
4636       rsrcSet->resourceList.list.count = elementCnt;
4637       rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4638       DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4639       if(rsrcSet->resourceList.list.array == NULLP)
4640       {
4641          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4642          return RFAILED;
4643       }
4644
4645       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4646       {
4647          DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4648          if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4649          {
4650             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4651             return RFAILED;
4652          }
4653       }
4654       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4655       {
4656          if(rsrcSetCfgDb == NULLP)
4657             *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4658          else
4659             *(rsrcSet->resourceList.list.array[rsrcIdx]) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcList[rsrcIdx];
4660       }
4661
4662       /* Max payload size (minus 1) in a Resource set */
4663       rsrcSet->maxPayloadMinus1 = NULLP;
4664       if(rsrcSetCfgDb && rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize)
4665       {
4666          DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
4667          if(rsrcSet->maxPayloadMinus1 == NULLP)
4668          {
4669             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4670             return RFAILED;
4671          }
4672          *(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
4673       }
4674    }
4675    return ROK;
4676 }
4677
4678 /*******************************************************************
4679  *
4680  * @brief Builds PUCCH resource add/modify list
4681  *
4682  * @details
4683  *
4684  *    Function : BuildPucchRsrcAdddModList
4685  *
4686  *    Functionality:
4687  *      Builds PUCCH resource add/modify list
4688  *
4689  * @params[in] : PucchResrcCfg *rsrcSetCfgDb
4690  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4691  *
4692  * @return ROK     - success
4693  *         RFAILED - failure
4694  *
4695  * ****************************************************************/
4696 uint8_t BuildPucchRsrcAddModList(PucchResrcCfg *rsrcCfgDb, struct PUCCH_Config__resourceToAddModList  *resourceToAddModList)
4697 {
4698    uint8_t elementCnt = 0, rsrcIdx = 0;
4699    PUCCH_Resource_t *rsrc = NULLP;
4700
4701    if(rsrcCfgDb == NULLP)
4702       elementCnt = 1;
4703    else
4704       elementCnt = rsrcCfgDb->resrcToAddModListCount;
4705    resourceToAddModList->list.count = elementCnt;
4706    resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4707    DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
4708    if(resourceToAddModList->list.array == NULLP)
4709    {
4710       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4711       return RFAILED;
4712    }
4713    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4714    {
4715       DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4716       if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
4717       {
4718          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4719          return RFAILED;
4720       }
4721    }
4722
4723    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4724    {
4725       rsrc = resourceToAddModList->list.array[rsrcIdx];
4726
4727       if(rsrcCfgDb == NULLP)
4728       {
4729          rsrc->pucch_ResourceId = 1;
4730          rsrc->startingPRB = 0;
4731          rsrc->format.present = PUCCH_Resource__format_PR_format1;
4732          DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4733          if(rsrc->format.choice.format1 == NULLP)
4734          {
4735             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4736             return RFAILED;
4737          }
4738          rsrc->format.choice.format1->initialCyclicShift = 0;
4739          rsrc->format.choice.format1->nrofSymbols = 4;
4740          rsrc->format.choice.format1->startingSymbolIndex = 0;
4741          rsrc->format.choice.format1->timeDomainOCC = 0;
4742       }
4743       else
4744       {
4745          rsrc->pucch_ResourceId = rsrcCfgDb->resrcToAddModList[rsrcIdx].resrcId;
4746          rsrc->startingPRB = rsrcCfgDb->resrcToAddModList[rsrcIdx].startPrb;
4747          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop)
4748          {
4749             DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
4750             if(rsrc->intraSlotFrequencyHopping == NULLP)
4751             {
4752                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4753                return RFAILED;
4754             }
4755             *(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
4756          }
4757          else
4758             rsrc->intraSlotFrequencyHopping = NULLP;
4759
4760          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop)
4761          {
4762             DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
4763             if(rsrc->secondHopPRB == NULLP)
4764             {
4765                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4766                return RFAILED;
4767             }
4768             *(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
4769          }
4770          else
4771             rsrc->secondHopPRB = NULLP;
4772          rsrc->format.present = covertPucchFormatIntEnumToRrcEnum(rsrcCfgDb->resrcToAddModList[rsrcIdx].pucchFormat);
4773
4774          switch(rsrc->format.present)
4775          {
4776             case PUCCH_Resource__format_PR_NOTHING:
4777                break;
4778             case PUCCH_Resource__format_PR_format0:
4779                {
4780                   DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
4781                   if(rsrc->format.choice.format0 == NULLP)
4782                   {
4783                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4784                      return RFAILED;
4785                   }
4786                   rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
4787                   rsrc->format.choice.format0->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->numSymbols;
4788                   rsrc->format.choice.format0->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->startSymbolIdx;
4789                   break;
4790                }
4791
4792             case PUCCH_Resource__format_PR_format1:
4793                {
4794                   DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4795                   if(rsrc->format.choice.format1 == NULLP)
4796                   {
4797                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4798                      return RFAILED;
4799                   }
4800                   rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
4801                   rsrc->format.choice.format1->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->numSymbols;
4802                   rsrc->format.choice.format1->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->startSymbolIdx;
4803                   rsrc->format.choice.format1->timeDomainOCC = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->timeDomOCC;
4804                   break;
4805                }
4806
4807             case PUCCH_Resource__format_PR_format2:
4808                {
4809                   DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
4810                   if(rsrc->format.choice.format2 == NULLP)
4811                   {
4812                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4813                      return RFAILED;
4814                   }
4815                   rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
4816                   rsrc->format.choice.format2->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numSymbols;
4817                   rsrc->format.choice.format2->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->startSymbolIdx;
4818                   break;
4819                }
4820
4821             case PUCCH_Resource__format_PR_format3:
4822                {
4823                   DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
4824                   if(rsrc->format.choice.format3 == NULLP)
4825                   {
4826                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4827                      return RFAILED;
4828                   }
4829                   rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
4830                   rsrc->format.choice.format3->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numSymbols;
4831                   rsrc->format.choice.format3->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->startSymbolIdx;
4832                   break;
4833                }
4834
4835             case PUCCH_Resource__format_PR_format4:
4836                {
4837                   DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
4838                   if(rsrc->format.choice.format4 == NULLP)
4839                   {
4840                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4841                      return RFAILED;
4842                   }
4843                   rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
4844                   rsrc->format.choice.format4->occ_Length = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occLen;
4845                   rsrc->format.choice.format4->occ_Index = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occIdx;
4846                   rsrc->format.choice.format4->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->startSymbolIdx;
4847                   break;
4848                }
4849          }
4850       }
4851    }
4852    return ROK;
4853 }
4854
4855 /*******************************************************************
4856  *
4857  * @brief Builds PUCCH format  config
4858  *
4859  * @details
4860  *
4861  *    Function : BuildPucchFormat
4862  *
4863  *    Functionality: Builds PUCCH format  config
4864  *
4865  * @params[in] : PucchFormatCfg *formatDb
4866  *               PUCCH_FormatConfig_t *format
4867  *
4868  * @return ROK     - success
4869  *         RFAILED - failure
4870  *
4871  * ****************************************************************/
4872 uint8_t BuildPucchFormat(PucchFormatCfg *formatDb, PUCCH_FormatConfig_t *format)
4873 {
4874    /* Inter Slot Fequency hopping */
4875    format->interslotFrequencyHopping = NULLP;
4876    if((formatDb != NULLP) && (formatDb->interSlotFreqHop == true))
4877    {
4878       DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
4879       if(format->interslotFrequencyHopping)
4880       {
4881          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4882          return RFAILED;
4883       }
4884       *(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
4885    }
4886
4887    /* Additional DMRS */
4888    format->additionalDMRS = NULLP;
4889    if((formatDb != NULLP) && (formatDb->addDmrs == true))
4890    {
4891       DU_ALLOC(format->additionalDMRS, sizeof(long));
4892       if(format->additionalDMRS)
4893       {
4894          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4895          return RFAILED;
4896       }
4897       *(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
4898    }
4899
4900     /* Maximum code rate */
4901    format->maxCodeRate = NULLP;
4902    if((formatDb != NULLP) && (formatDb->maxCodeRate != 0))
4903    {
4904       DU_ALLOC(format->maxCodeRate, sizeof(long));
4905       if(format->maxCodeRate)
4906       {
4907          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4908          return RFAILED;
4909       }
4910       *(format->maxCodeRate) = formatDb->maxCodeRate;
4911    }
4912
4913    /* Number of slots */
4914    format->nrofSlots = NULLP;
4915    if((formatDb == NULLP) || ((formatDb != NULLP) && (formatDb->numSlots != 0)))
4916    {
4917       DU_ALLOC(format->nrofSlots, sizeof(long));
4918       if(format->nrofSlots == NULLP)
4919       {
4920          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4921          return RFAILED;
4922       }
4923       if(formatDb == NULLP)
4924          *(format->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4925       else
4926          *(format->nrofSlots) = formatDb->numSlots;
4927    }
4928
4929    /* Pi2BPSK*/
4930    format->pi2BPSK = NULLP;
4931    if((formatDb != NULLP) && (formatDb->pi2BPSK == true))
4932    {
4933       DU_ALLOC(format->pi2BPSK, sizeof(long));
4934       if(format->pi2BPSK)
4935       {
4936          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4937          return RFAILED;
4938       }
4939       *(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
4940    }
4941
4942    /* Simultaneous HARQ ACK and CSI */
4943    format->simultaneousHARQ_ACK_CSI = NULLP;
4944    if((formatDb != NULLP) && (formatDb->harqAckCSI == true))
4945    {
4946       DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
4947       if(format->simultaneousHARQ_ACK_CSI)
4948       {
4949          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4950          return RFAILED;
4951       }
4952       *(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
4953    }
4954
4955    return ROK;
4956 }
4957
4958
4959 /*******************************************************************
4960  *
4961  * @brief Builds PUCCH scheduling request list
4962  *
4963  * @details
4964  *
4965  *    Function : BuildPucchSchReqAddModList
4966  *
4967  *    Functionality:
4968  *      Builds PUCCH scheduling request list
4969  *
4970  * @params[in] : PucchSchedReqCfg *schReqDb
4971  *               struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList
4972  *
4973  * @return ROK     - success
4974  *         RFAILED - failure
4975  *
4976  * ****************************************************************/
4977 uint8_t BuildPucchSchReqAddModList(PucchSchedReqCfg *schReqDb, \
4978    struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList)
4979 {
4980    uint8_t elementCnt = 0, schReqIdx = 0;
4981    SchedulingRequestResourceConfig_t *schReqRsrc;
4982
4983    elementCnt = schReqDb->schedAddModListCount;
4984    schReqRsrcToAddModList->list.count = elementCnt;
4985    schReqRsrcToAddModList->list.size = elementCnt *sizeof(struct SchedulingRequestResourceConfig *);
4986
4987    schReqRsrcToAddModList->list.array = NULLP;
4988    DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
4989    if(schReqRsrcToAddModList->list.array == NULLP)
4990    {
4991       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4992       return RFAILED;
4993    }
4994
4995    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4996    {
4997       DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
4998       if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
4999       {
5000          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5001          return RFAILED;
5002       }
5003    }
5004
5005    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
5006    {
5007       schReqRsrc = schReqRsrcToAddModList->list.array[schReqIdx];
5008       schReqRsrc->schedulingRequestResourceId = schReqDb->schedAddModList[schReqIdx].resrcId;
5009       schReqRsrc->schedulingRequestID = schReqDb->schedAddModList[schReqIdx].requestId;
5010
5011       if(schReqDb->schedAddModList[schReqIdx].periodicity)
5012       {
5013          schReqRsrc->periodicityAndOffset = NULLP;
5014          DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
5015          if(schReqRsrc->periodicityAndOffset == NULLP)
5016          {
5017             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5018             return RFAILED;
5019          }
5020
5021          schReqRsrc->periodicityAndOffset->present = schReqDb->schedAddModList[schReqIdx].periodicity;
5022          switch(schReqRsrc->periodicityAndOffset->present)
5023          {
5024             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_NOTHING:
5025                break;
5026             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
5027                schReqRsrc->periodicityAndOffset->choice.sym2 = schReqDb->schedAddModList[schReqIdx].offset;
5028                break;
5029             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
5030                schReqRsrc->periodicityAndOffset->choice.sym6or7 = schReqDb->schedAddModList[schReqIdx].offset;
5031                break;
5032             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
5033                schReqRsrc->periodicityAndOffset->choice.sl1 = schReqDb->schedAddModList[schReqIdx].offset;
5034                break;
5035             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
5036                schReqRsrc->periodicityAndOffset->choice.sl2 = schReqDb->schedAddModList[schReqIdx].offset;
5037                break;
5038             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
5039                schReqRsrc->periodicityAndOffset->choice.sl4 = schReqDb->schedAddModList[schReqIdx].offset;
5040                break;
5041             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
5042                schReqRsrc->periodicityAndOffset->choice.sl5 = schReqDb->schedAddModList[schReqIdx].offset;
5043                break;
5044             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
5045                schReqRsrc->periodicityAndOffset->choice.sl8 = schReqDb->schedAddModList[schReqIdx].offset;
5046                break;
5047             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
5048                schReqRsrc->periodicityAndOffset->choice.sl10 = schReqDb->schedAddModList[schReqIdx].offset;
5049                break;
5050             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
5051                schReqRsrc->periodicityAndOffset->choice.sl16 = schReqDb->schedAddModList[schReqIdx].offset;
5052                break;
5053             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
5054                schReqRsrc->periodicityAndOffset->choice.sl20 = schReqDb->schedAddModList[schReqIdx].offset;
5055                break;
5056             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
5057                schReqRsrc->periodicityAndOffset->choice.sl40 = schReqDb->schedAddModList[schReqIdx].offset;
5058                break;
5059             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
5060                schReqRsrc->periodicityAndOffset->choice.sl80 = schReqDb->schedAddModList[schReqIdx].offset;
5061                break;
5062             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
5063                schReqRsrc->periodicityAndOffset->choice.sl160 = schReqDb->schedAddModList[schReqIdx].offset;
5064                break;
5065             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
5066                schReqRsrc->periodicityAndOffset->choice.sl320 = schReqDb->schedAddModList[schReqIdx].offset;
5067                break;
5068             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
5069                schReqRsrc->periodicityAndOffset->choice.sl640 = schReqDb->schedAddModList[schReqIdx].offset;
5070                break;
5071          }
5072       }
5073
5074       if(schReqDb->schedAddModList[schReqIdx].resrc)
5075       {
5076          schReqRsrc->resource = NULLP;
5077          DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
5078          if(schReqRsrc->resource == NULLP)
5079          {
5080             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5081             return RFAILED;
5082          }
5083          *(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
5084
5085       }
5086    }
5087    return ROK;
5088 }
5089
5090 /*******************************************************************
5091  *
5092  * @brief Builds PUCCH multi csi resource list
5093  *
5094  * @details
5095  *
5096  *    Function : BuildPucchMultiCsiRsrcList
5097  *
5098  *    Functionality:
5099  *      Builds PUCCH multi csi resource list
5100  *
5101  * @params[in] : PucchMultiCsiCfg *multiCsiDb
5102  *               struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList
5103  *
5104  * @return ROK     - success
5105  *         RFAILED - failure
5106  *
5107  * ****************************************************************/
5108 uint8_t BuildPucchMultiCsiRsrcList(PucchMultiCsiCfg *multiCsiDb, struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList)
5109 {
5110    uint8_t elementCnt = 0, rsrcIdx = 0;
5111
5112    elementCnt = multiCsiDb->multiCsiResrcListCount;
5113    multiCsiRsrcList->list.count = elementCnt;
5114    multiCsiRsrcList->list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
5115    multiCsiRsrcList->list.array = NULLP;
5116    DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
5117    if(multiCsiRsrcList->list.array == NULLP)
5118    {
5119       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5120       return RFAILED;
5121    }
5122
5123    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5124    {
5125       DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5126       if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
5127       {
5128          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5129          return RFAILED;
5130       }
5131    }
5132
5133    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5134    {
5135       *(multiCsiRsrcList->list.array[rsrcIdx]) = multiCsiDb->multiCsiResrcList[rsrcIdx];
5136    }
5137    return ROK;
5138 }
5139
5140 /*******************************************************************
5141  *
5142  * @brief Builds DL data -to- Ul Ack list
5143  *
5144  * @details
5145  *
5146  *    Function : BuildDlDataToUlAckList
5147  *
5148  *    Functionality: Builds DL data -to- Ul Ack list
5149  *
5150  * @params[in] : PucchDlDataToUlAck *dlDataToUlAckDb
5151  *               struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList
5152  *
5153  * @return ROK     - success
5154  *         RFAILED - failure
5155  *
5156  * ****************************************************************/
5157 uint8_t BuildDlDataToUlAckList(PucchDlDataToUlAck *dlDataToUlAckDb, struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList)
5158 {
5159    uint8_t elementCnt = 0, arrIdx = 0;
5160
5161    if(dlDataToUlAckDb == NULLP)
5162       elementCnt = 2;
5163    else
5164       elementCnt = dlDataToUlAckDb->dlDataToUlAckListCount;
5165
5166    dlDataToUlACKList->list.count = elementCnt;
5167    dlDataToUlACKList->list.size = elementCnt * sizeof(long *);
5168    DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
5169    if(dlDataToUlACKList->list.array == NULLP)
5170    {
5171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5172       return RFAILED;
5173    }
5174
5175    for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5176    {
5177       DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
5178       if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
5179       {
5180          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5181          return RFAILED;
5182       }
5183    }
5184
5185    if(dlDataToUlAckDb == NULLP)
5186    {
5187       arrIdx = 0;
5188       *(dlDataToUlACKList->list.array[arrIdx++]) = 1;
5189       *(dlDataToUlACKList->list.array[arrIdx]) = 2;
5190    }
5191    else
5192    {
5193       for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5194       {
5195          *(dlDataToUlACKList->list.array[arrIdx]) = dlDataToUlAckDb->dlDataToUlAckList[arrIdx];
5196       }
5197    }
5198    return ROK;
5199 }
5200
5201 /*******************************************************************
5202  *
5203  * @brief Builds BWP UL dedicated PUCCH Config
5204  *
5205  * @details
5206  *
5207  *    Function : BuildBWPUlDedPucchCfg
5208  *
5209  *    Functionality:
5210  *      Builds BWP UL dedicated PUCCH Config
5211  *
5212  * @params[in] : PUCCH_Config_t *pucchCfg
5213  *
5214  * @return ROK     - success
5215  *         RFAILED - failure
5216  *
5217  * ****************************************************************/
5218 uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg)
5219 {
5220    PucchResrcSetCfg *rsrcSetCfgDb = NULLP;
5221    PucchResrcCfg *rsrcCfgDb = NULLP;
5222    PucchFormatCfg *format1Db = NULLP;
5223    PucchFormatCfg *format2Db = NULLP;
5224    PucchFormatCfg *format3Db = NULLP;
5225    PucchFormatCfg *format4Db = NULLP;
5226    PucchSchedReqCfg *schReqDb = NULLP;
5227    PucchMultiCsiCfg  *multiCsiDb = NULLP;
5228    PucchDlDataToUlAck *dlDataToUlAckDb = NULLP;
5229
5230    if(pucchCfgDb)
5231    {
5232       rsrcSetCfgDb = pucchCfgDb->resrcSet;
5233       rsrcCfgDb = pucchCfgDb->resrc;
5234       format1Db = pucchCfgDb->format1;
5235       format2Db = pucchCfgDb->format2;
5236       format3Db = pucchCfgDb->format3;
5237       format4Db = pucchCfgDb->format4;
5238       schReqDb = pucchCfgDb->schedReq;
5239       multiCsiDb = pucchCfgDb->multiCsiCfg;
5240       dlDataToUlAckDb = pucchCfgDb->dlDataToUlAck;
5241    }
5242
5243    /* RESOURCE SET */
5244    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5245    if(pucchCfg->resourceSetToAddModList == NULL)
5246    {
5247       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5248       return RFAILED;
5249    }
5250
5251    if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
5252    {
5253       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5254       return RFAILED;
5255    }
5256
5257    /* PUCCH RESOURCE */
5258    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5259    if(pucchCfg->resourceToAddModList == NULLP)
5260    {
5261       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5262       return RFAILED;
5263    }
5264
5265    if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
5266    {
5267       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5268       return RFAILED;
5269    }
5270
5271    /* PUCCH Format 1 */
5272    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5273    if(pucchCfg->format1 == NULLP)
5274    {
5275       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5276       return RFAILED;
5277    }
5278
5279    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
5280    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5281    if(pucchCfg->format1->choice.setup == NULLP)
5282    {
5283       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5284       return RFAILED;
5285    }
5286
5287    if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
5288    {
5289       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5290       return RFAILED;
5291    }
5292
5293    /* PUCCH Format 2 */
5294    if(format2Db)
5295    {
5296       DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
5297       if(pucchCfg->format2 == NULLP)
5298       {
5299          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5300          return RFAILED;
5301       }
5302
5303       pucchCfg->format2->present = PUCCH_Config__format2_PR_setup;
5304       DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
5305       if(pucchCfg->format2->choice.setup == NULLP)
5306       {
5307          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5308          return RFAILED;
5309       }
5310
5311       if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
5312       {
5313          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5314          return RFAILED;
5315       }
5316    }
5317
5318    /* PUCCH Format 3 */
5319    if(format3Db)
5320    {
5321       DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
5322       if(pucchCfg->format3 == NULLP)
5323       {
5324          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5325          return RFAILED;
5326       }
5327
5328       pucchCfg->format3->present = PUCCH_Config__format3_PR_setup;
5329       DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
5330       if(pucchCfg->format3->choice.setup == NULLP)
5331       {
5332          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5333          return RFAILED;
5334       }
5335
5336       if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
5337       {
5338          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5339          return RFAILED;
5340       }
5341    }
5342
5343    /* PUCCH Format 4 */
5344    if(format4Db)
5345    {
5346       DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
5347       if(pucchCfg->format4 == NULLP)
5348       {
5349          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5350          return RFAILED;
5351       }
5352
5353       pucchCfg->format4->present = PUCCH_Config__format4_PR_setup;
5354       DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
5355       if(pucchCfg->format4->choice.setup == NULLP)
5356       {
5357          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5358          return RFAILED;
5359       }
5360
5361       if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
5362       {
5363          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5364          return RFAILED;
5365       }
5366    }
5367
5368    /* Scheduling Request */
5369    if(schReqDb && (schReqDb->schedAddModListCount != 0))
5370    {
5371       pucchCfg->schedulingRequestResourceToAddModList = NULLP;
5372       DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
5373       if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
5374       {
5375          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5376          return RFAILED;
5377       }
5378
5379       if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
5380       {
5381          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5382          return RFAILED;
5383       }
5384    }
5385
5386    /* Multi CSI */
5387    if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
5388    {
5389       pucchCfg->multi_CSI_PUCCH_ResourceList = NULLP;
5390       DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
5391       if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
5392       {
5393          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5394          return RFAILED;
5395       }
5396
5397       if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
5398       {
5399          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5400          return RFAILED;
5401       }
5402    }
5403
5404    /* DL DATA TO UL ACK */
5405    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5406    if(pucchCfg->dl_DataToUL_ACK == NULLP)
5407    {
5408       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5409       return RFAILED;
5410    }
5411
5412    if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
5413    {
5414       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5415       return RFAILED;
5416    }
5417
5418    /* TODO : spatial relation info add/mod list and power control*/
5419
5420    return ROK;
5421 }
5422
5423 /*******************************************************************
5424  *
5425  * @brief Fills SRS resource to add/modify list
5426  *
5427  * @details
5428  *
5429  *    Function : BuildSrsRsrcAddModList
5430  *
5431  *    Functionality: Fills SRS resource to add/modify list
5432  *
5433  * @params[in]
5434  * @return ROK     - success
5435  *         RFAILED - failure
5436  *
5437  * ****************************************************************/
5438 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
5439 {
5440    uint8_t   elementCnt;
5441    uint8_t   rsrcIdx;
5442
5443    elementCnt = 1;
5444    resourceList->list.count = elementCnt;
5445    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
5446    resourceList->list.array = NULLP;
5447    DU_ALLOC(resourceList->list.array, resourceList->list.size);
5448    if(!resourceList->list.array)
5449    {
5450       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5451       return RFAILED;
5452    }
5453
5454    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5455    {
5456       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5457       if(!resourceList->list.array[rsrcIdx])
5458       {
5459          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5460          return RFAILED;
5461       }
5462    }
5463
5464    rsrcIdx = 0;
5465    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
5466    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
5467    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
5468
5469    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
5470    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
5471          sizeof(struct SRS_Resource__transmissionComb__n2));
5472    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
5473    {
5474       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5475       return RFAILED;
5476    }
5477    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
5478       = SRS_COMB_OFFSET_N2;
5479    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
5480       = SRS_CYCLIC_SHIFT_N2;
5481
5482    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
5483                                                                       PUSCH_START_SYMBOL;
5484    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
5485                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
5486    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
5487                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
5488
5489    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
5490    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
5491    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
5492    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
5493    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
5494    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
5495                                                                SRS_Resource__groupOrSequenceHopping_neither;
5496
5497    /* Setting resource type to aperiodic for intergration purposes */
5498    resourceList->list.array[rsrcIdx]->resourceType.present = \
5499                                                              SRS_Resource__resourceType_PR_aperiodic;
5500    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
5501    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
5502          sizeof(struct SRS_Resource__resourceType__aperiodic));
5503    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
5504    {
5505       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5506       return RFAILED;
5507    }
5508
5509    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
5510
5511    return ROK;
5512 }
5513
5514 /*******************************************************************
5515  *
5516  * @brief Build SRS resource set Add/mod list
5517  *
5518  * @details
5519  *
5520  *    Function : BuildSrsRsrcSetAddModList
5521  *
5522  *    Functionality: Build SRS resource set Add/mod list
5523  *
5524  * @params[in]
5525  * @return ROK     - success
5526  *         RFAILED - failure
5527  *
5528  * ****************************************************************/
5529    uint8_t BuildSrsRsrcSetAddModList
5530 (
5531  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
5532  )
5533 {
5534    uint8_t  elementCnt;
5535    uint8_t  rSetIdx;
5536    uint8_t  rsrcIdx;
5537    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
5538
5539    elementCnt = 1;
5540    rsrcSetList->list.count = elementCnt;
5541    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
5542    rsrcSetList->list.array = NULLP;
5543    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
5544    if(!rsrcSetList->list.array)
5545    {
5546       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5547       return RFAILED;
5548    }
5549
5550    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5551    {
5552       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5553       if(!rsrcSetList->list.array[rSetIdx])
5554       {
5555          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5556          return RFAILED;
5557       }
5558    }
5559
5560    rSetIdx = 0;
5561    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
5562
5563    /* Fill Resource Id list in resource set */
5564    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
5565    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5566          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5567    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5568    {
5569       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5570       return RFAILED;
5571    }
5572
5573    elementCnt = 1;
5574    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5575    rsrcIdList->list.count = elementCnt;
5576    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
5577    rsrcIdList->list.array = NULLP;
5578    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
5579    if(!rsrcIdList->list.array)
5580    {
5581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5582       return RFAILED;
5583    }
5584
5585    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5586    {
5587       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5588       if(!rsrcIdList->list.array[rsrcIdx])
5589       {
5590          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5591          return RFAILED;
5592       }
5593    }
5594
5595    rsrcIdx = 0;
5596    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
5597
5598    /* Fill resource type */
5599    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
5600                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
5601
5602    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
5603    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5604          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5605    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
5606    {
5607       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5608       return RFAILED;
5609    }
5610    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
5611       = APERIODIC_SRS_RESRC_TRIGGER;
5612
5613    /* TODO : Fill values for below IEs as expected by Viavi */
5614    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
5615    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
5616
5617
5618    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
5619    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
5620    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
5621    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
5622    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
5623
5624    return ROK;
5625 }
5626
5627 /*******************************************************************
5628  *
5629  * @brief Builds BWP UL dedicated SRS Config
5630  *
5631  * @details
5632  *
5633  *    Function : BuildBWPUlDedSrsCfg
5634  *
5635  *    Functionality: Builds BWP UL dedicated SRS Config
5636  *
5637  * @params[in] SRS Config
5638  * @return ROK     - success
5639  *         RFAILED - failure
5640  *
5641  * ****************************************************************/
5642 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
5643 {
5644    srsCfg->srs_ResourceSetToReleaseList = NULLP;
5645    srsCfg->srs_ResourceSetToAddModList = NULLP;
5646    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
5647          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5648    if(!srsCfg->srs_ResourceSetToAddModList)
5649    {
5650       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5651       return RFAILED;
5652    }
5653    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
5654    {
5655       return RFAILED;
5656    }
5657
5658    srsCfg->srs_ResourceToReleaseList = NULLP;
5659
5660    /* Resource to Add/Modify list */
5661    srsCfg->srs_ResourceToAddModList = NULLP;
5662    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
5663          sizeof(struct SRS_Config__srs_ResourceToAddModList));
5664    if(!srsCfg->srs_ResourceToAddModList)
5665    {
5666       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5667       return RFAILED;
5668    }
5669
5670    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
5671    {
5672       return RFAILED;
5673    }
5674    srsCfg->tpc_Accumulation = NULLP;
5675
5676    return ROK;
5677 }
5678
5679
5680
5681 /*******************************************************************
5682  *
5683  * @brief Builds Pusch Serving cell Config
5684  *
5685  * @details
5686  *
5687  *    Function : BuildPuschSrvCellCfg
5688  *
5689  *    Functionality: Builds Pusch Serving cell Config
5690  *
5691  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
5692  *
5693  * @return ROK     - success
5694  *         RFAILED - failure
5695  *
5696  * ****************************************************************/
5697 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
5698 {
5699    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
5700    puschCfg->choice.setup = NULLP;
5701    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5702    if(!puschCfg->choice.setup)
5703    {
5704       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5705       return RFAILED;
5706    }
5707
5708    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5709    puschCfg->choice.setup->rateMatching = NULLP;
5710    puschCfg->choice.setup->xOverhead = NULLP;
5711    puschCfg->choice.setup->ext1 = NULLP;
5712
5713    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
5714    if(!puschCfg->choice.setup->ext1)
5715    {
5716       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5717       return RFAILED;
5718    }
5719
5720    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
5721    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5722    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
5723    {
5724       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5725       return RFAILED;
5726    }
5727    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5728
5729    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5730    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5731    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5732    {
5733       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5734       return RFAILED;
5735    }
5736    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5737
5738    return ROK;
5739 }
5740
5741 /*******************************************************************
5742  *
5743  * @brief Builds inital UL BWP
5744  *
5745  * @details
5746  *
5747  *    Function : BuildInitialUlBWP
5748  *
5749  *    Functionality: Builds initial UL BWP
5750  *
5751  * @params[in] BWP_UplinkDedicated_t *ulBwp
5752  * @return ROK     - success
5753  *         RFAILED - failure
5754  *
5755  * ****************************************************************/
5756 uint8_t BuildInitialUlBWP(InitialUlBwp *initUlBwp, BWP_UplinkDedicated_t *ulBwp)
5757 {
5758    PucchCfg *pucchCfg = NULLP;
5759    PuschCfg *puschCfg = NULLP;
5760
5761    if(initUlBwp)
5762    {
5763       if(initUlBwp->pucchPresent)
5764          pucchCfg = &initUlBwp->pucchCfg;
5765       if(initUlBwp->puschPresent)
5766          puschCfg = &initUlBwp->puschCfg;
5767    }
5768
5769    ulBwp->pucch_Config = NULLP;
5770    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5771    if(!ulBwp->pucch_Config)
5772    {
5773       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5774       return RFAILED;
5775    }
5776
5777    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
5778    ulBwp->pucch_Config->choice.setup = NULLP;
5779    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5780    if(!ulBwp->pucch_Config->choice.setup)
5781    {
5782       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5783       return RFAILED;
5784    }
5785
5786    if(BuildBWPUlDedPucchCfg(pucchCfg, ulBwp->pucch_Config->choice.setup) != ROK)
5787    {
5788       return RFAILED;
5789    }
5790
5791    /* Fill BWP UL dedicated PUSCH config */
5792    ulBwp->pusch_Config = NULLP;
5793    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5794    if(!ulBwp->pusch_Config)
5795    {
5796       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5797       return RFAILED;
5798    }
5799
5800    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
5801    ulBwp->pusch_Config->choice.setup = NULLP;
5802    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5803    if(!ulBwp->pusch_Config->choice.setup)
5804    {
5805       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5806       return RFAILED;
5807    }
5808
5809    if(BuildBWPUlDedPuschCfg(puschCfg, ulBwp->pusch_Config->choice.setup) != ROK)
5810    {
5811       return RFAILED;
5812    }
5813
5814    ulBwp->configuredGrantConfig = NULLP;
5815
5816    /* Fill BPW UL dedicated SRS config */
5817    ulBwp->srs_Config = NULLP;
5818    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5819    if(!ulBwp->srs_Config)
5820    {
5821       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5822       return RFAILED;
5823    }
5824
5825    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
5826    ulBwp->srs_Config->choice.setup = NULLP;
5827    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5828    if(!ulBwp->srs_Config->choice.setup)
5829    {
5830       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5831       return RFAILED;
5832    }
5833
5834    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
5835    {
5836       return RFAILED;
5837    }
5838
5839    ulBwp->beamFailureRecoveryConfig = NULLP;
5840
5841    return ROK;
5842 }
5843
5844 /*******************************************************************
5845  *
5846  * @brief Builds UL config
5847  * @details
5848  *
5849  *    Function : BuildUlCfg
5850  *
5851  *    Functionality: Builds UL config in spCellCfgDed
5852  *
5853  * @params[in] UplinkConfig_t *ulCfg
5854  *
5855  * @return ROK     - success
5856  *         RFAILED - failure
5857  *
5858  * ****************************************************************/
5859 uint8_t BuildUlCfg(ServCellCfgInfo *servCellCfg, UplinkConfig_t *ulCfg)
5860 {
5861    InitialUlBwp *initUlBwp = NULLP;
5862
5863    if(servCellCfg)
5864    {
5865       initUlBwp = &servCellCfg->initUlBwp;
5866    }
5867
5868    ulCfg->initialUplinkBWP = NULLP;
5869    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5870    if(!ulCfg->initialUplinkBWP)
5871    {
5872       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5873       return RFAILED;
5874    }
5875
5876    if(BuildInitialUlBWP(initUlBwp, ulCfg->initialUplinkBWP) != ROK)
5877    {
5878       return RFAILED;
5879    }
5880
5881    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5882    ulCfg->uplinkBWP_ToAddModList = NULLP;
5883    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5884    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5885    if(!ulCfg->firstActiveUplinkBWP_Id)
5886    {
5887       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5888       return RFAILED;
5889    }
5890    if(servCellCfg == NULLP)
5891       *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5892    else
5893       *(ulCfg->firstActiveUplinkBWP_Id) = servCellCfg->firstActvUlBwpId;
5894
5895    ulCfg->pusch_ServingCellConfig = NULLP;
5896    DU_ALLOC(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5897    if(!ulCfg->pusch_ServingCellConfig)
5898    {
5899       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5900       return RFAILED;
5901    }
5902
5903    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5904    {
5905       return RFAILED;
5906    }
5907
5908    ulCfg->carrierSwitching = NULLP;
5909    ulCfg->ext1 = NULLP;
5910    return ROK;
5911 }
5912
5913 /*******************************************************************
5914  *
5915  * @brief Builds PDSCH serving cell config
5916  * @details
5917  *
5918  *    Function : BuildPdschSrvCellCfg
5919  *
5920  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5921  *
5922  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5923  *
5924  * @return ROK     - success
5925  *         RFAILED - failure
5926  *
5927  * ****************************************************************/
5928 uint8_t BuildPdschSrvCellCfg(PdschServCellCfg *pdschServCellDb, struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5929 {
5930    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5931    pdschCfg->choice.setup = NULLP;
5932    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5933    if(!pdschCfg->choice.setup)
5934    {
5935       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5936       return RFAILED;
5937    }
5938
5939    /* Code Block Group Transmission */
5940    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5941    if(pdschServCellDb && (pdschServCellDb->maxCodeBlkGrpPerTb || pdschServCellDb->codeBlkGrpFlushInd))
5942    {
5943       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission, sizeof(struct PDSCH_ServingCellConfig__codeBlockGroupTransmission));
5944       if(pdschCfg->choice.setup->codeBlockGroupTransmission == NULLP)
5945       {
5946          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5947          return RFAILED;
5948       }
5949
5950       pdschCfg->choice.setup->codeBlockGroupTransmission->present = PDSCH_ServingCellConfig__codeBlockGroupTransmission_PR_setup;
5951       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup = NULLP;
5952       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup, sizeof(struct PDSCH_CodeBlockGroupTransmission ));
5953       if(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup == NULLP)
5954       {
5955          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5956          return RFAILED;
5957       }
5958
5959       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock = \
5960          *(pdschServCellDb->maxCodeBlkGrpPerTb);
5961       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator = \
5962          *(pdschServCellDb->codeBlkGrpFlushInd);
5963    }
5964
5965    /* xOverhead */
5966    pdschCfg->choice.setup->xOverhead = NULLP;
5967    if(pdschServCellDb && pdschServCellDb->xOverhead)
5968    {
5969       DU_ALLOC(pdschCfg->choice.setup->xOverhead, sizeof(long));
5970       if(pdschCfg->choice.setup->xOverhead == NULLP)
5971       {
5972          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5973          return RFAILED;
5974       }
5975       *(pdschCfg->choice.setup->xOverhead) = *(pdschServCellDb->xOverhead);
5976    }
5977
5978    /* Number of HARQ processes */
5979    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5980    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5981    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5982    {
5983       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5984       return RFAILED;
5985    }
5986
5987    if(pdschServCellDb == NULLP)
5988    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = PDSCH_NUM_HARQ_PROC;
5989    else
5990    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = pdschServCellDb->numHarqProcForPdsch;
5991
5992    pdschCfg->choice.setup->pucch_Cell = NULLP;
5993
5994    /* Extension */
5995    pdschCfg->choice.setup->ext1 = NULLP;
5996    if(pdschServCellDb && pdschServCellDb->maxMimoLayers)
5997    {
5998       DU_ALLOC(pdschCfg->choice.setup->ext1, sizeof(struct PDSCH_ServingCellConfig__ext1));
5999       if(pdschCfg->choice.setup->ext1 == NULLP)
6000       {
6001          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6002          return RFAILED;
6003       }
6004
6005       DU_ALLOC(pdschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
6006       if(pdschCfg->choice.setup->ext1->maxMIMO_Layers == NULLP)
6007       {
6008          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6009          return RFAILED;
6010       }
6011       *(pdschCfg->choice.setup->ext1->maxMIMO_Layers) = *(pdschServCellDb->maxMimoLayers);
6012    }
6013
6014    return ROK;
6015 }
6016
6017 /*******************************************************************
6018  *
6019  * @brief Builds CSI Meas config
6020  * @details
6021  *
6022  *    Function : BuildCsiMeasCfg
6023  *
6024  *    Functionality: Builds CSI Meas config in spCellCfgDed
6025  *
6026  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
6027  *
6028  * @return ROK     - success
6029  *         RFAILED - failure
6030  *
6031  * ****************************************************************/
6032 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
6033 {
6034
6035    return ROK;
6036 }
6037
6038 /*******************************************************************
6039  *
6040  * @brief Builds DL BWP to add/modify list
6041  * @details
6042  *
6043  *    Function : BuildDlBwpToAddModList
6044  *
6045  *    Functionality: Builds DL BWP to add/modify list
6046  *
6047  * @params[in] ServCellCfgInfo *servCellCfg,
6048  *             struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList
6049  *
6050  * @return ROK     - success
6051  *         RFAILED - failure
6052  *
6053  * ****************************************************************/
6054 uint8_t BuildDlBwpToAddModList(ServCellCfgInfo *servCellCfg, struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList)
6055 {
6056    uint8_t elementCnt, idx;
6057
6058    elementCnt = servCellCfg->numDlBwpToAdd;
6059    dlBwpAddModList->list.count = elementCnt;
6060    dlBwpAddModList->list.size = elementCnt * sizeof(struct BWP_Downlink *);
6061    dlBwpAddModList->list.array = NULLP;
6062    DU_ALLOC(dlBwpAddModList->list.array, dlBwpAddModList->list.size);
6063    if(dlBwpAddModList->list.array == NULLP)
6064    {
6065       DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6066       return RFAILED;
6067    }
6068
6069    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6070    {
6071       DU_ALLOC(dlBwpAddModList->list.array[idx], sizeof(BWP_Downlink_t));
6072       if(dlBwpAddModList->list.array[idx] == NULLP)
6073       {
6074          DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6075          return RFAILED;
6076       }
6077    }
6078
6079    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6080    {
6081       dlBwpAddModList->list.array[idx]->bwp_Id = servCellCfg->DlBwpToAddList[idx].bwpId;
6082       dlBwpAddModList->list.array[idx]->bwp_Common = NULLP;
6083       dlBwpAddModList->list.array[idx]->bwp_Dedicated = NULLP;
6084    }
6085    return ROK;
6086 }
6087
6088 /*******************************************************************
6089  *
6090  * @brief Builds Spcell config dedicated
6091  * @details
6092  *
6093  *    Function : BuildSpCellCfgDed
6094  *
6095  *    Functionality: Builds sp cell config dedicated in spCellCfg
6096  *
6097  * @params[in] ServingCellConfig_t srvCellCfg
6098  *
6099  * @return ROK     - success
6100  *         RFAILED - failure
6101  *
6102  * ****************************************************************/
6103 uint8_t BuildSpCellCfgDed(DuUeCb *ueCb, ServingCellConfig_t *srvCellCfg)
6104 {
6105    ServCellCfgInfo *servCellCfg = NULLP;
6106    InitialDlBwp *initDlBwp = NULLP;
6107    PdschServCellCfg *pdschServCellDb = NULLP;
6108
6109    if(ueCb)
6110    {
6111       servCellCfg = &ueCb->macUeCfg.spCellCfg.servCellCfg;
6112       initDlBwp = &servCellCfg->initDlBwp;
6113       pdschServCellDb = &servCellCfg->pdschServCellCfg;
6114    }
6115
6116    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
6117
6118    srvCellCfg->initialDownlinkBWP = NULLP;
6119    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6120    if(!srvCellCfg->initialDownlinkBWP)
6121    {
6122       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6123       return RFAILED;
6124    }
6125
6126    if(BuildInitialDlBWP(initDlBwp, srvCellCfg->initialDownlinkBWP) != ROK)
6127    {
6128       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6129       return RFAILED;
6130    }
6131
6132    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
6133
6134    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
6135    if(ueCb && ueCb->macUeCfg.spCellCfg.servCellCfg.numDlBwpToAdd)
6136    {
6137       DU_ALLOC(srvCellCfg->downlinkBWP_ToAddModList, sizeof(struct ServingCellConfig__downlinkBWP_ToAddModList));
6138       if(srvCellCfg->downlinkBWP_ToAddModList == NULLP)
6139       {
6140          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6141          return RFAILED;
6142       }
6143
6144       if(BuildDlBwpToAddModList(&ueCb->macUeCfg.spCellCfg.servCellCfg, srvCellCfg->downlinkBWP_ToAddModList) != ROK)
6145       {
6146          DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6147          return RFAILED;
6148       }
6149    }
6150
6151    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
6152    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6153    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
6154    {
6155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6156       return RFAILED;
6157    }
6158    if(ueCb == NULLP)
6159       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6160    else
6161       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.firstActvDlBwpId;
6162
6163    srvCellCfg->bwp_InactivityTimer = NULLP;
6164
6165    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
6166    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6167    if(!srvCellCfg->defaultDownlinkBWP_Id)
6168    {
6169       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6170       return RFAILED;
6171    }
6172    if(ueCb == NULLP)
6173       *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6174    else
6175       *(srvCellCfg->defaultDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.defaultDlBwpId;
6176
6177    srvCellCfg->uplinkConfig = NULLP;
6178    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6179    if(!srvCellCfg->uplinkConfig)
6180    {
6181       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6182       return RFAILED;
6183    }
6184
6185    if(BuildUlCfg(servCellCfg, srvCellCfg->uplinkConfig) != ROK)
6186    {
6187       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
6188       return RFAILED;
6189    }
6190    srvCellCfg->supplementaryUplink = NULLP;
6191    srvCellCfg->pdcch_ServingCellConfig = NULLP;
6192
6193    srvCellCfg->pdsch_ServingCellConfig = NULLP;
6194    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
6195    if(!srvCellCfg->pdsch_ServingCellConfig)
6196    {
6197       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6198       return RFAILED;
6199    }
6200
6201    if(BuildPdschSrvCellCfg(pdschServCellDb, srvCellCfg->pdsch_ServingCellConfig) != ROK)
6202    {
6203       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
6204       return RFAILED;
6205    }
6206
6207    srvCellCfg->csi_MeasConfig = NULLP;
6208 #if 0
6209    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
6210       if(!srvCellCfg->csi_MeasConfig)
6211       {
6212          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6213          return RFAILED;
6214       }
6215
6216    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
6217    {
6218       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
6219       return RFAILED;
6220    }
6221 #endif
6222    srvCellCfg->sCellDeactivationTimer = NULLP;
6223    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
6224    srvCellCfg->tag_Id = TAG_ID;
6225    srvCellCfg->dummy = NULLP;
6226    srvCellCfg->pathlossReferenceLinking = NULLP;
6227    srvCellCfg->servingCellMO = NULLP;
6228    srvCellCfg->ext1 = NULLP;
6229
6230    return ROK;
6231 }
6232
6233 /*******************************************************************
6234  *
6235  * @brief Fills SCS specific carrier list in DL frequency info
6236  *
6237  * @details
6238  *
6239  *    Function : BuildScsSpecificCarrierListDl
6240  *
6241  *    Functionality: Fills SCS specific carrier list in DL frequency info
6242  *
6243  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
6244  *
6245  * @return ROK     - success
6246  *         RFAILED - failure
6247  *
6248  * ****************************************************************/
6249 uint8_t BuildScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
6250 {
6251    uint8_t elementCnt = 0, listIdx = 0;
6252    ScsSpecCarrier duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.dlScsCarrier;
6253
6254    elementCnt = ODU_VALUE_ONE;
6255    scsCarrierList->list.count = elementCnt;
6256    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6257
6258    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6259    if(!scsCarrierList->list.array)
6260    {
6261       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for scs carrier list array \
6262          in BuildScsSpecificCarrierListDl()");
6263       return RFAILED;
6264    }
6265
6266    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6267    {
6268       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6269       if(!scsCarrierList->list.array[listIdx])
6270       {
6271          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SCS Specific Carrier list array \
6272             element in BuildScsSpecificCarrierListDl()");
6273          return RFAILED;
6274       }
6275    }
6276
6277    listIdx = 0;
6278    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6279    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6280    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6281
6282    return ROK;
6283 }
6284
6285 /*******************************************************************
6286  *
6287  * @brief Fills DL frequency info in DL config common
6288  *
6289  * @details
6290  *
6291  *    Function : BuildFreqInfoDl
6292  *
6293  *    Functionality: Fills DL frequency info in DL config common
6294  *
6295  * @params[in] Pointer to DownlinkConfigCommon_t
6296  *
6297  * @return ROK     - success
6298  *         RFAILED - failure
6299  *
6300  * ****************************************************************/
6301 uint8_t BuildFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
6302 {
6303    uint8_t freqBandIdx = 0, elementCnt = 0;
6304    DlCfgCommon  dlCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg;
6305
6306    /* TODO : Fill SSB Absolute Frequency */
6307    /*
6308       DU_ALLOC(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
6309       if(!frequencyInfoDL->absoluteFrequencySSB)
6310       {
6311       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB Absolute Frequency in BuildFreqInfoDl()");
6312       return RFAILED;
6313       }
6314       frequencyInfoDL->absoluteFrequencySSB = ?;
6315       */
6316
6317    /* NR Multi Frequency Band List */
6318    elementCnt = ODU_VALUE_ONE;
6319    frequencyInfoDL->frequencyBandList.list.count = elementCnt;
6320    frequencyInfoDL->frequencyBandList.list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6321
6322    DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
6323    if(!frequencyInfoDL->frequencyBandList.list.array)
6324    {
6325       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for Frequency Band List array in BuildFreqInfoDl()");
6326       return RFAILED;
6327    }
6328
6329    for(freqBandIdx = 0; freqBandIdx < elementCnt; freqBandIdx++)
6330    {
6331       DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
6332       if(!frequencyInfoDL->frequencyBandList.list.array[freqBandIdx])
6333       {
6334          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoDl()");
6335          return RFAILED;
6336       }
6337    }
6338
6339    freqBandIdx = 0;
6340    *(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx]) = dlCfg.freqBandInd;
6341
6342    /* TODO : Absolute Frequency to Point A */
6343    //frequencyInfoDL->absoluteFrequencyPointA
6344
6345    /* Subcarrier Spacing specifc carrier List */
6346    if((BuildScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList)) != ROK)
6347    {
6348       DU_LOG("\nERROR  -->  DU APP : Failed to fill SCS specific carrier list DL in BuildFreqInfoDl()");
6349       return RFAILED;
6350    }
6351
6352    return ROK;
6353
6354 }
6355
6356 /*******************************************************************
6357  *
6358  * @brief Fills DL config common in Serving cell config common
6359  *
6360  * @details
6361  *
6362  *    Function : BuildDlConfigCommon
6363  *
6364  *    Functionality: Fills DL config common in Serving cell config common
6365  *
6366  * @params[in] Pointer to DownlinkConfigCommon_t
6367  *
6368  * @return ROK     - success
6369  *         RFAILED - failure
6370  *
6371  * ****************************************************************/
6372 uint8_t BuildDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
6373 {
6374    /* DL Frequency Info */
6375    DU_ALLOC(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
6376    if(!dlCfgCommon->frequencyInfoDL)
6377    {
6378       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL frequency info in BuildDlConfigCommon()");
6379       return RFAILED;
6380    }
6381    if((BuildFreqInfoDl(dlCfgCommon->frequencyInfoDL))!= ROK)
6382    {
6383       DU_LOG("\nERROR  --> DU APP : Failed to fill DL frequency info in BuildDlConfigCommon()");
6384       return RFAILED;
6385    }
6386
6387    /* DL BWP config common */
6388    DU_ALLOC(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
6389    if(!dlCfgCommon->initialDownlinkBWP)
6390    {
6391       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL BWP config common in BuildDlConfigCommon()");
6392       return RFAILED;
6393    }
6394    if((BuildBwpDlCommon(dlCfgCommon->initialDownlinkBWP)) != ROK)
6395    {
6396       DU_LOG("\nERROR  --> DU APP : Failed to fill DL DWP config common in BuildDlConfigCommon()");
6397       return RFAILED;
6398    }
6399
6400    return ROK;
6401 }
6402
6403 /*******************************************************************
6404  *
6405  * @brief Fills SCS specific carrier list in UL frequency Info
6406  *
6407  * @details
6408  *
6409  *    Function : BuildScsSpecificCarrierListUl
6410  *
6411  *    Functionality: Fills SCS specific carrier list in UL frequency Info
6412  *
6413  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
6414  *
6415  * @return ROK     - success
6416  *         RFAILED - failure
6417  *
6418  * ****************************************************************/
6419 uint8_t BuildScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
6420 {
6421    uint8_t elementCnt = 0, listIdx = 0;
6422    ScsSpecCarrier   duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.ulScsCarrier;
6423
6424    elementCnt = ODU_VALUE_ONE;
6425    scsCarrierList->list.count = elementCnt;
6426    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6427
6428    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6429    if(!scsCarrierList->list.array)
6430    {
6431       DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6432       return RFAILED;
6433    }
6434
6435    for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
6436    {
6437       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6438       if(!scsCarrierList->list.array[listIdx])
6439       {
6440          DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6441          return RFAILED;
6442       }
6443    }
6444    listIdx = 0;
6445    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6446    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6447    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6448
6449    return ROK;
6450 }
6451
6452 /*******************************************************************
6453  *
6454  * @brief Fills frequency info in UL config common
6455  *
6456  * @details
6457  *
6458  *    Function : BuildFreqInfoUl
6459  *
6460  *    Functionality: Fills frequency info in UL config common
6461  *
6462  * @params[in] Pointer to FrequencyInfoUL_t
6463  *
6464  * @return ROK     - success
6465  *         RFAILED - failure
6466  *
6467  * ****************************************************************/
6468 uint8_t BuildFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
6469 {
6470    uint8_t elementCnt = 0, listIdx= 0;
6471    UlCfgCommon  ulCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg;
6472
6473    /* NR Multi Frequency Band List */
6474    DU_ALLOC(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
6475    if(!frequencyInfoUL->frequencyBandList)
6476    {
6477       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band list in BuildFreqInfoUl()");
6478       return RFAILED;
6479    }
6480
6481    elementCnt = ODU_VALUE_ONE;
6482    frequencyInfoUL->frequencyBandList->list.count = elementCnt;
6483    frequencyInfoUL->frequencyBandList->list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6484
6485    DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
6486    if(!frequencyInfoUL->frequencyBandList->list.array)
6487    {
6488       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array in BuildFreqInfoUl()");
6489       return RFAILED;
6490    }
6491
6492    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6493    {
6494       DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
6495       if(!frequencyInfoUL->frequencyBandList->list.array[listIdx])
6496       {
6497          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoUl()");
6498          return RFAILED;
6499       }
6500    }
6501
6502    listIdx = 0;
6503    *(frequencyInfoUL->frequencyBandList->list.array[listIdx]) = ulCfg.freqBandInd;
6504
6505    /* TODO : Fill Absolute frequency point A */
6506    /*
6507       DU_ALLOC(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
6508       if(!frequencyInfoUL->absoluteFrequencyPointA)
6509       {
6510       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for absolute frequency point A in BuildFreqInfoUl()");
6511       return RFAILED;
6512       }
6513     *(frequencyInfoUL->absoluteFrequencyPointA) = ?;
6514     */
6515
6516    /* Subcarrier Spacing specifc carrier */
6517    if((BuildScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList)) != ROK)
6518    {
6519       DU_LOG("\nERROR  --> DU APP : Failed to fill SCS Specific Carrier list UL in BuildFreqInfoUl()");
6520       return RFAILED;
6521    }
6522
6523    /* P-MAX */
6524    DU_ALLOC(frequencyInfoUL->p_Max, sizeof(P_Max_t));
6525    if(!frequencyInfoUL->p_Max)
6526    {
6527       DU_LOG("\nERROR  -->  DU APP : UL Frequency Infoo  memory allocation failure");
6528       return RFAILED;
6529    }
6530    *frequencyInfoUL->p_Max = ulCfg.pMax;
6531
6532    return ROK;
6533 }
6534
6535 /*******************************************************************
6536  *
6537  * @brief Fills UL config common in Serving cell config common
6538  *
6539  * @details
6540  *
6541  *    Function : BuildUlConfigCommon
6542  *
6543  *    Functionality: Fills UL config common in Serving cell config common
6544  *
6545  * @params[in] Pointer to UplinkConfigCommon_t
6546  *
6547  * @return ROK     - success
6548  *         RFAILED - failure
6549  *
6550  * ****************************************************************/
6551 uint8_t BuildUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
6552 {
6553    /* UL Frequency Info */
6554    DU_ALLOC(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
6555    if(!ulCfgCommon->frequencyInfoUL)
6556    {
6557       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for UL frequency info in BuildUlConfigCommon()");
6558       return RFAILED;
6559    }
6560
6561    if((BuildFreqInfoUl(ulCfgCommon->frequencyInfoUL)) != ROK)
6562    {
6563       DU_LOG("\nERROR  -->  DU APP : Failed to fill frequency info UL in BuildUlConfigCommon()");
6564       return RFAILED;
6565    }
6566
6567    /* UL BWP common */
6568    DU_ALLOC(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
6569    if(!ulCfgCommon->initialUplinkBWP)
6570    {
6571       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for initial UL BWP in BuildUlConfigCommon()");
6572       return RFAILED;
6573    }
6574
6575    if((BuildBwpUlCommon(ulCfgCommon->initialUplinkBWP)) != ROK)
6576    {
6577       DU_LOG("\nERROR  -->  DU APP : Failed to fill BWP UL common in BuildUlConfigCommon()");
6578       return RFAILED;
6579    }
6580
6581    /* Time Alignment timer */
6582    ulCfgCommon->dummy = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.timeAlignTimerComm;
6583
6584    return ROK;
6585 }
6586
6587 /*******************************************************************
6588  *
6589  * @brief Fills SSB position in burst in SP cell config common
6590  *
6591  * @details
6592  *
6593  *    Function : BuildSsbPosInBurst
6594  *
6595  *    Functionality:
6596  *       Fills SSB position in burst in SP cell config common
6597  *
6598  * @params[in] Pointer to struct ServingCellConfigCommon__ssb_PositionsInBurst
6599  *
6600  * @return ROK     - success
6601  *         RFAILED - failure
6602  *
6603  * ****************************************************************/
6604 uint8_t BuildSsbPosInBurst(struct ServingCellConfigCommon__ssb_PositionsInBurst *ssbPosInBurst)
6605 {
6606    uint8_t bitStringSizeInBytes = 0;
6607
6608    ssbPosInBurst->present = ServingCellConfigCommon__ssb_PositionsInBurst_PR_mediumBitmap;
6609
6610    /* As per spec 38.331,in the definition of ServingCellConfigCommon */
6611    bitStringSizeInBytes = 1;
6612    ssbPosInBurst->choice.mediumBitmap.size = bitStringSizeInBytes * sizeof(uint8_t);
6613
6614    DU_ALLOC(ssbPosInBurst->choice.mediumBitmap.buf, ssbPosInBurst->choice.mediumBitmap.size);
6615    if(!ssbPosInBurst->choice.mediumBitmap.buf)
6616    {
6617       DU_LOG("\nERROR  -->  DU APP : Memory Allocation failed for medium bit map buffer in BuildSsbPosInBurst()");
6618       return RFAILED;
6619    }
6620
6621    if((fillBitString(&ssbPosInBurst->choice.mediumBitmap, 0, bitStringSizeInBytes, \
6622                duCfgParam.sib1Params.srvCellCfgCommSib.ssbPosInBurst)) != ROK)
6623    {
6624       DU_LOG("\nERROR  -->  DU APP : Failed to fill medium bit map in BuildSsbPosInBurst()");
6625       return RFAILED;
6626    }
6627
6628    return ROK;
6629 }
6630
6631 /*******************************************************************
6632  *
6633  * @brief Fills SP cell config common in Reconfig with Sync
6634  *
6635  * @details
6636  *
6637  *    Function : BuildSpCellConfigCommon
6638  *
6639  *    Functionality: Fills SP cell config common in Reconfig with Sync
6640  *
6641  * @params[in] Pointer to ServingCellConfigCommon_t
6642  *
6643  * @return ROK     - success
6644  *         RFAILED - failure
6645  *
6646  * ****************************************************************/
6647 uint8_t BuildSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
6648 {
6649    /* Physical Cell Identity */
6650    DU_ALLOC(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
6651    if(!spCellConfigCommon->physCellId)
6652    {
6653       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for physical cell id in BuildSpCellConfigCommon()");
6654       return RFAILED;
6655    }
6656    *(spCellConfigCommon->physCellId) = NR_PCI;
6657
6658    /* Downlink Config Common */
6659    DU_ALLOC(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
6660    if(!spCellConfigCommon->downlinkConfigCommon)
6661    {
6662       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for DL Config Common in BuildSpCellConfigCommon()");
6663       return RFAILED;
6664    }
6665    if((BuildDlConfigCommon(spCellConfigCommon->downlinkConfigCommon)) != ROK)
6666    {
6667       DU_LOG("\nERROR  -->  DU APP : Failed to fill DL config commin in BuildSpCellConfigCommon()");
6668       return RFAILED;
6669    }
6670
6671    /* Uplinlink Config Common */
6672    DU_ALLOC(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
6673    if(!spCellConfigCommon->uplinkConfigCommon)
6674    {
6675       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for UL Config Common in BuildSpCellConfigCommon()");
6676       return RFAILED;
6677    }
6678    if((BuildUlConfigCommon(spCellConfigCommon->uplinkConfigCommon)) != ROK)
6679    {
6680       DU_LOG("\nERROR  -->  DU APP : Failed to fill UL config commin in BuildSpCellConfigCommon()");
6681       return RFAILED;
6682    }
6683
6684    /* Timing Advance offset */
6685    DU_ALLOC(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
6686    if(!spCellConfigCommon->n_TimingAdvanceOffset)
6687    {
6688       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for Timing Advance Offset in BuildSpCellConfigCommon()");
6689       return RFAILED;
6690    }
6691    *(spCellConfigCommon->n_TimingAdvanceOffset) = ServingCellConfigCommon__n_TimingAdvanceOffset_n0;
6692
6693    /* SSB Position In Burst */
6694    DU_ALLOC(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
6695    if(!spCellConfigCommon->ssb_PositionsInBurst)
6696    {
6697       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Position In Burst in BuildSpCellConfigCommon()");
6698       return RFAILED;
6699    }
6700    if((BuildSsbPosInBurst(spCellConfigCommon->ssb_PositionsInBurst)) != ROK)
6701    {
6702       DU_LOG("\nERROR  -->  DU APP : Failed to fill SSB Position In Burst in BuildSpCellConfigCommon()");
6703       return RFAILED;
6704    }
6705
6706    /* SSB Periodicity in Serving cell */
6707    DU_ALLOC(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
6708    if(!spCellConfigCommon->ssb_periodicityServingCell)
6709    {
6710       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Periodicity serving cell in \
6711          BuildSpCellConfigCommon()");
6712       return RFAILED;
6713    }
6714    *(spCellConfigCommon->ssb_periodicityServingCell) = \
6715       convertSsbPeriodicityValueToEnum(duCfgParam.sib1Params.srvCellCfgCommSib.ssbPrdServingCell);
6716
6717    /* DMRS Type A position */
6718    spCellConfigCommon->dmrs_TypeA_Position = convertDmrsTypeAPosValueToEnum(duCfgParam.macCellCfg.dmrsTypeAPos);
6719
6720    /* SSB subcarrier spacing */
6721    DU_ALLOC(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
6722    if(!spCellConfigCommon->ssbSubcarrierSpacing)
6723    {
6724       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for sub-carrier spacing in BuildSpCellConfigCommon()");
6725       return RFAILED;
6726    }
6727    *(spCellConfigCommon->ssbSubcarrierSpacing) = duCfgParam.sib1Params.srvCellCfgCommSib.scs;
6728
6729    /* TDD UL-DL configuration common */
6730    DU_ALLOC(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
6731    if(!spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)
6732    {
6733       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for TDD UL-DL config common in BuildSpCellConfigCommon()");
6734       return RFAILED;
6735    }
6736    if((BuildTddUlDlCfgComm(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)) != ROK)
6737    {
6738       DU_LOG("\nERROR  -->  DU APP : Failed to fill TDD UL-DL config common in BuildSpCellConfigCommon()");
6739       return RFAILED;
6740    }
6741
6742    /* SS PBCH Block Power */
6743    spCellConfigCommon->ss_PBCH_BlockPower = duCfgParam.sib1Params.srvCellCfgCommSib.ssPbchBlockPwr;
6744
6745    return ROK;
6746 }
6747
6748 /*******************************************************************
6749  *
6750  * @brief Fills dedicated RACH configuration in Reconfiguration with sync
6751  *
6752  * @details
6753  *
6754  *    Function : BuildRecfgWithSync
6755  *
6756  *    Functionality:
6757  *       Fills dedicated RACH configuration in Reconfiguration with sync
6758  *
6759  * @params[in] DU UE CB
6760  *             Pointer to Rach config dedicated struct
6761  *
6762  * @return ROK     - success
6763  *         RFAILED - failure
6764  *
6765  * ****************************************************************/
6766 uint8_t BuildRachConfigDedicated(DuUeCb *ueCb, struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
6767 {
6768    uint8_t elementCnt = 0, listIdx = 0;
6769    CFRA_t *cfra = NULLP;
6770    struct CFRA__resources__ssb *ssbResource = NULLP;
6771    RachCfgCommon duRachCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.rachCfg;
6772
6773    rachCfgDed->present = ReconfigurationWithSync__rach_ConfigDedicated_PR_uplink;
6774
6775    /* Uplink */
6776    DU_ALLOC(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
6777    if(!rachCfgDed->choice.uplink)
6778    {
6779       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for RACH uplink configuration in BuildRachConfigDedicated()");
6780       return RFAILED;
6781    }
6782
6783    /* CFRA : Contention free Random Access */
6784    DU_ALLOC(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
6785    if(!rachCfgDed->choice.uplink->cfra)
6786    {
6787       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA in BuildRachConfigDedicated()");
6788       return RFAILED;
6789    }
6790    cfra = rachCfgDed->choice.uplink->cfra;
6791
6792    /* CFRA occassions */
6793    DU_ALLOC(cfra->occasions, sizeof(struct CFRA__occasions));
6794    if(!cfra->occasions)
6795    {
6796       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA occassion in BuildRachConfigDedicated()");
6797       return RFAILED;
6798    }
6799
6800    /* CFRA occassions : RACH generic configuration */
6801    cfra->occasions->rach_ConfigGeneric.prach_ConfigurationIndex = duRachCfg.prachCfgIdx;
6802    cfra->occasions->rach_ConfigGeneric.msg1_FDM = duRachCfg.msg1Fdm;
6803    cfra->occasions->rach_ConfigGeneric.msg1_FrequencyStart = duRachCfg.msg1FreqStart;
6804    cfra->occasions->rach_ConfigGeneric.zeroCorrelationZoneConfig = duRachCfg.zeroCorrZoneCfg;
6805    cfra->occasions->rach_ConfigGeneric.preambleReceivedTargetPower = duRachCfg.preambleRcvdTgtPwr;
6806    cfra->occasions->rach_ConfigGeneric.preambleTransMax = duRachCfg.preambleTransMax;
6807    cfra->occasions->rach_ConfigGeneric.powerRampingStep = duRachCfg.pwrRampingStep;
6808    cfra->occasions->rach_ConfigGeneric.ra_ResponseWindow = duRachCfg.raRspWindow;
6809
6810    /* CFRA occassions : SSB per RACH occasion */
6811    DU_ALLOC(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
6812    if(!cfra->occasions->ssb_perRACH_Occasion)
6813    {
6814       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB per RACH occassion in BuildRachConfigDedicated()");
6815       return RFAILED;
6816    }
6817    *(cfra->occasions->ssb_perRACH_Occasion) = convertCFRASsbPerRachOccasionValueToEnum(duCfgParam.macCellCfg.prachCfg.ssbPerRach);
6818
6819    /* CFRA resource */
6820    cfra->resources.present = CFRA__resources_PR_ssb;
6821
6822    /* CFRA resource : SSB */
6823    DU_ALLOC(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
6824    if(!cfra->resources.choice.ssb)
6825    {
6826       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA resource - SSB in BuildRachConfigDedicated()");
6827       return RFAILED;
6828    }
6829    ssbResource = cfra->resources.choice.ssb;
6830
6831    /* CFRA SSB resource list */
6832    elementCnt = ueCb->cfraResource.numSsb;
6833    ssbResource->ssb_ResourceList.list.count = elementCnt;
6834    ssbResource->ssb_ResourceList.list.size = elementCnt * sizeof(CFRA_SSB_Resource_t *);
6835
6836    DU_ALLOC(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
6837    if(!ssbResource->ssb_ResourceList.list.array)
6838    {
6839       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list in BuildRachConfigDedicated()");
6840       return RFAILED;
6841    }
6842
6843    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6844    {
6845       DU_ALLOC(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
6846       if(!ssbResource->ssb_ResourceList.list.array[listIdx])
6847       {
6848          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list element in BuildRachConfigDedicated()");
6849          return RFAILED;
6850       }
6851       ssbResource->ssb_ResourceList.list.array[listIdx]->ssb = ueCb->cfraResource.ssbResource[listIdx].ssbIdx;
6852       ssbResource->ssb_ResourceList.list.array[listIdx]->ra_PreambleIndex = ueCb->cfraResource.ssbResource[listIdx].raPreambleIdx;
6853    }
6854
6855    return ROK;
6856 }
6857
6858 /*******************************************************************
6859  *
6860  * @brief Fills reconfiguration with sync in SP cell config
6861  *
6862  * @details
6863  *
6864  *    Function : BuildRecfgWithSync
6865  *
6866  *    Functionality: Fills reconfiguration with sync in SP cell config
6867  *
6868  * @params[in] DU UE CB
6869  *             Pointer to ReconfigurationWithSync_t
6870  *
6871  * @return ROK     - success
6872  *         RFAILED - failure
6873  *
6874  * ****************************************************************/
6875 uint8_t BuildRecfgWithSync(DuUeCb *ueCb, ReconfigurationWithSync_t *recfgWithSync)
6876 {
6877    /* SP Cell Config Common */
6878    DU_ALLOC(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
6879    if(!recfgWithSync->spCellConfigCommon)
6880    {
6881       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for spCellConfigCommon in BuildRecfgWithSync()");
6882       return RFAILED;
6883    }
6884
6885    if((BuildSpCellConfigCommon(recfgWithSync->spCellConfigCommon)) != ROK)
6886    {
6887       DU_LOG("\nERROR  -->  DU APP : Failed to build SpCellConfigCommon in BuildRecfgWithSync()");
6888       return RFAILED;
6889    }
6890
6891    /* New UE Identity */
6892    recfgWithSync->newUE_Identity = ueCb->crnti;
6893
6894    /* T304 timer */
6895    recfgWithSync->t304 = ReconfigurationWithSync__t304_ms1000;
6896
6897    /* RACH configuration dedicated */
6898    DU_ALLOC(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
6899    if(!recfgWithSync->rach_ConfigDedicated)
6900    {
6901       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for RACH config dedicated in BuildRecfgWithSync()");
6902       return RFAILED;
6903    }
6904
6905    if((BuildRachConfigDedicated(ueCb, recfgWithSync->rach_ConfigDedicated)) != ROK)
6906    {
6907       DU_LOG("\nERROR  -->  DU APP : Failed to build RACH config dedicated in BuildRecfgWithSync()");
6908       return RFAILED;
6909    }
6910
6911    return ROK;
6912 }
6913
6914 /*******************************************************************
6915  *
6916  * @brief Builds Spcell config
6917  *
6918  * @details
6919  *
6920  *    Function : BuildSpCellCfg
6921  *
6922  *    Functionality: Builds sp cell config in DuToCuRrcContainer
6923  *
6924  * @params[in] SpCellConfig_t spCellCfg
6925  *
6926  * @return ROK     - success
6927  *         RFAILED - failure
6928  *
6929  * ****************************************************************/
6930 uint8_t BuildSpCellCfg(DuUeCb *ueCb, SpCellConfig_t *spCellCfg)
6931 {
6932    spCellCfg->servCellIndex = NULLP;
6933    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
6934    if(!spCellCfg->servCellIndex)
6935    {
6936       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6937       return RFAILED;
6938    }
6939
6940    if(ueCb == NULLP)
6941       *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
6942    else
6943       *(spCellCfg->servCellIndex) = ueCb->macUeCfg.spCellCfg.servCellIdx;
6944
6945    spCellCfg->reconfigurationWithSync = NULLP;
6946    if(ueCb && (ueCb->ueState == UE_HANDIN_IN_PROGRESS))
6947    {
6948       DU_ALLOC(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
6949       if(!spCellCfg->reconfigurationWithSync)
6950       {
6951          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6952          return RFAILED;
6953       }
6954
6955       if((BuildRecfgWithSync(ueCb, spCellCfg->reconfigurationWithSync)) != ROK)
6956       {
6957          DU_LOG("\nERROR  -->  F1AP : Building of reconfiguration with sync failed at BuildSpCellCfg");
6958          return RFAILED;
6959       }
6960    }
6961
6962    spCellCfg->rlf_TimersAndConstants = NULLP;
6963    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
6964
6965    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6966    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
6967    {
6968       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6969       return RFAILED;
6970    }
6971    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
6972
6973    spCellCfg->spCellConfigDedicated = NULLP;
6974    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6975    if(!spCellCfg->spCellConfigDedicated)
6976    {
6977       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6978       return RFAILED;
6979    }
6980    if(BuildSpCellCfgDed(ueCb, spCellCfg->spCellConfigDedicated) != ROK)
6981    {
6982       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
6983       return RFAILED;
6984    }
6985
6986    return ROK;
6987 }
6988
6989 /*******************************************************************
6990  *
6991  * @brief Builds Phy cell group config
6992  *
6993  * @details
6994  *
6995  *    Function : BuildPhyCellGrpCfg
6996  *
6997  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
6998  *
6999  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
7000  *
7001  * @return ROK     - success
7002  *         RFAILED - failure
7003  *
7004  * ****************************************************************/
7005 uint8_t BuildPhyCellGrpCfg(DuUeCb *ueCb, PhysicalCellGroupConfig_t *phyCellGrpCfg)
7006 {
7007    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
7008    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
7009
7010    phyCellGrpCfg->p_NR_FR1 = NULLP;
7011    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
7012    if(!phyCellGrpCfg->p_NR_FR1)
7013    {
7014       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
7015       return RFAILED;
7016    }
7017
7018    if(ueCb == NULLP)
7019    {
7020       *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
7021       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
7022    }
7023    else
7024    {
7025       *(phyCellGrpCfg->p_NR_FR1) = ueCb->macUeCfg.phyCellGrpCfg.pNrFr1;
7026       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = ueCb->macUeCfg.phyCellGrpCfg.pdschHarqAckCodebook;
7027    }
7028
7029    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
7030    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
7031    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
7032    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
7033    phyCellGrpCfg->cs_RNTI = NULLP;
7034    phyCellGrpCfg->ext1 = NULLP;
7035    phyCellGrpCfg->ext2 = NULLP;
7036
7037    return ROK;
7038 }
7039 #ifdef NR_DRX
7040 /*******************************************************************
7041  *
7042  * @brief fill long cycle offset value of drx
7043  *
7044  * @details
7045  *
7046  *    Function : fillLongCycleOffsetValFromDuCb
7047  *
7048  *    Functionality: fill long cycle offset value of drx
7049  *
7050  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
7051  * struct DRX_ConfigRrc__drx_LongCycleStartOffset drx_LongCycleStartOffset
7052  *
7053  * @return ROK     - success
7054  *         RFAILED - failure
7055  *
7056  * ****************************************************************/
7057 void fillLongCycleOffsetValFromDuCb(DrxLongCycleStartOffset  drxLongCycleStartOffset,\
7058 struct DRX_ConfigRrc__drx_LongCycleStartOffset *drx_LongCycleStartOffset)
7059 {
7060
7061    drx_LongCycleStartOffset->present = convertLongDrxCycleLengthValueToEnum(drxLongCycleStartOffset.drxLongCycleStartOffsetChoice);
7062    switch(drx_LongCycleStartOffset->present)
7063    {
7064       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
7065          {
7066             drx_LongCycleStartOffset->choice.ms10 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7067             break;
7068          }
7069       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
7070          {
7071             drx_LongCycleStartOffset->choice.ms20 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7072             break;
7073          }
7074       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
7075          {
7076             drx_LongCycleStartOffset->choice.ms32 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7077             break;
7078          }
7079       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
7080          {
7081             drx_LongCycleStartOffset->choice.ms40 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7082             break;
7083          }
7084       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
7085          {
7086             drx_LongCycleStartOffset->choice.ms60 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7087             break;
7088          }
7089       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
7090          {
7091             drx_LongCycleStartOffset->choice.ms64 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7092             break;
7093          }
7094       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
7095          {
7096             drx_LongCycleStartOffset->choice.ms70 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7097             break;
7098          }
7099       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
7100          {
7101             drx_LongCycleStartOffset->choice.ms80 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7102             break;
7103          }
7104       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
7105          {
7106             drx_LongCycleStartOffset->choice.ms128 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7107             break;
7108          }
7109       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
7110          {
7111             drx_LongCycleStartOffset->choice.ms160 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7112             break;
7113          }
7114       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
7115          {
7116             drx_LongCycleStartOffset->choice.ms256 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7117             break;
7118          }
7119       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
7120          {
7121             drx_LongCycleStartOffset->choice.ms320 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7122             break;
7123          }
7124       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
7125          {
7126             drx_LongCycleStartOffset->choice.ms512 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7127             break;
7128          }
7129       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
7130          {
7131             drx_LongCycleStartOffset->choice.ms640 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7132             break;
7133          }
7134       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
7135          {
7136             drx_LongCycleStartOffset->choice.ms1024 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7137             break;
7138          }
7139       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
7140          {
7141             drx_LongCycleStartOffset->choice.ms1280 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7142             break;
7143          }
7144       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
7145          {
7146             drx_LongCycleStartOffset->choice.ms2048 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7147             break;
7148          }
7149       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
7150          {
7151             drx_LongCycleStartOffset->choice.ms2560 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7152             break;
7153          }
7154       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
7155          {
7156             drx_LongCycleStartOffset->choice.ms5120 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7157             break;
7158          }
7159       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
7160          {
7161             drx_LongCycleStartOffset->choice.ms10240 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7162             break;
7163          }
7164       default :
7165          break;
7166    }
7167 }
7168 /*******************************************************************
7169  *
7170  * @brief Builds drx config IE
7171  *
7172  * @details
7173  *
7174  *    Function : BuildDrxConfigRrc
7175  *
7176  *    Functionality: Build drx config in MacCellGrpCfg
7177  *
7178  * @params[in] struct MAC_CellGroupConfig__drx_ConfigRrc
7179  *
7180  * @return ROK     - success
7181  *         RFAILED - failure
7182  *
7183  * ****************************************************************/
7184 uint8_t BuildDrxConfigRrc(DuUeCb *ueCb, struct MAC_CellGroupConfig__drx_ConfigRrc *drxCfg)
7185 {
7186    drxCfg->present = MAC_CellGroupConfig__drx_ConfigRrc_PR_setup;
7187    DU_ALLOC(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
7188    if(!drxCfg->choice.setup)
7189    {
7190       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDrxConfigRrc");
7191       return RFAILED;
7192    }
7193    if(ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationTimerValInMs)
7194    {
7195       drxCfg->choice.setup->drx_onDurationTimer.present = DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds;
7196       drxCfg->choice.setup->drx_onDurationTimer.choice.milliSeconds = convertOnDurationTimerMilliSecondsValueToEnum(ueCb->macUeCfg.\
7197       macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationtimerValue.milliSeconds);
7198    }
7199    else
7200    {
7201       drxCfg->choice.setup->drx_onDurationTimer.present = DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds;
7202       drxCfg->choice.setup->drx_onDurationTimer.choice.subMilliSeconds = ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7203       drxOnDurationTimer.onDurationtimerValue.subMilliSeconds;
7204    }
7205    drxCfg->choice.setup->drx_InactivityTimer = convertDrxInactivityTimerValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxInactivityTimer);
7206    drxCfg->choice.setup->drx_HARQ_RTT_TimerDL = ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxHarqRttTimerDl;
7207    drxCfg->choice.setup->drx_HARQ_RTT_TimerUL = ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxHarqRttTimerUl;
7208    drxCfg->choice.setup->drx_RetransmissionTimerDL = convertDrxRetransmissionTimerDlValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7209    drxRetransmissionTimerDl);
7210    drxCfg->choice.setup->drx_RetransmissionTimerUL = convertDrxRetransmissionTimerUlValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7211    drxRetransmissionTimerUl);
7212    drxCfg->choice.setup->drx_SlotOffset = ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxSlotOffset;
7213    fillLongCycleOffsetValFromDuCb(ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxLongCycleStartOffset, &drxCfg->choice.setup->drx_LongCycleStartOffset);
7214
7215    if(ueCb->macUeCfg.macCellGrpCfg.drxCfg.shortDrxPres)
7216    {
7217       DU_ALLOC(drxCfg->choice.setup->shortDRX, sizeof(struct DRX_ConfigRrc__shortDRX));
7218       if(drxCfg->choice.setup->shortDRX)
7219       {
7220          drxCfg->choice.setup->shortDRX->drx_ShortCycle = convertShortDrxCycleLengthValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7221          shortDrx.drxShortCycle);
7222          drxCfg->choice.setup->shortDRX->drx_ShortCycleTimer = ueCb->macUeCfg.macCellGrpCfg.drxCfg.shortDrx.drxShortCycleTimer;
7223       }
7224       else
7225       {
7226          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDrxConfigRrc");
7227          return RFAILED;
7228       }
7229    }
7230    return ROK;
7231 }
7232 #endif
7233 /*******************************************************************
7234  *
7235  * @brief Builds Mac cell group config
7236  *
7237  * @details
7238  *
7239  *    Function : BuildMacCellGrpCfg
7240  *
7241  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
7242  *
7243  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
7244  *
7245  * @return ROK     - success
7246  *         RFAILED - failure
7247  *
7248  * ****************************************************************/
7249 uint8_t BuildMacCellGrpCfg(DuUeCb *ueCb, MAC_CellGroupConfig_t *macCellGrpCfg)
7250 {
7251    macCellGrpCfg->drx_ConfigRrc = NULLP;
7252 #ifdef NR_DRX
7253    if(ueCb)
7254    {
7255       DU_ALLOC(macCellGrpCfg->drx_ConfigRrc, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
7256       if(!macCellGrpCfg->drx_ConfigRrc)
7257       {
7258          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7259          return RFAILED;
7260       }
7261       if(BuildDrxConfigRrc(ueCb, macCellGrpCfg->drx_ConfigRrc) != ROK)
7262       {
7263          DU_LOG("\nERROR  -->  F1AP : failed to build drx config");
7264          return RFAILED;
7265       }
7266    }
7267 #endif
7268    macCellGrpCfg->schedulingRequestConfig = NULLP;
7269    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
7270    if(!macCellGrpCfg->schedulingRequestConfig)
7271    {
7272       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7273       return RFAILED;
7274    }
7275
7276    if(BuildSchedulingReqConfig(ueCb, macCellGrpCfg->schedulingRequestConfig) != ROK)
7277    {
7278       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
7279       return RFAILED;
7280    }
7281
7282    macCellGrpCfg->bsr_Config = NULLP;
7283    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
7284    if(!macCellGrpCfg->bsr_Config)
7285    {
7286       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7287       return RFAILED;
7288    }
7289
7290    if(BuildBsrConfig(ueCb, macCellGrpCfg->bsr_Config) != ROK)
7291    {
7292       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
7293       return RFAILED;
7294    }
7295
7296    macCellGrpCfg->tag_Config = NULLP;
7297    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
7298    if(!macCellGrpCfg->tag_Config)
7299    {
7300       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7301       return RFAILED;
7302    }
7303
7304    if(BuildTagConfig(ueCb, macCellGrpCfg->tag_Config) != ROK)
7305    {
7306       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
7307       return RFAILED;
7308    }
7309
7310    macCellGrpCfg->phr_Config = NULLP;
7311    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
7312    if(!macCellGrpCfg->phr_Config)
7313    {
7314       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7315       return RFAILED;
7316    }
7317
7318    if(BuildPhrConfig(ueCb, macCellGrpCfg->phr_Config) != ROK)
7319    {
7320       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
7321       return RFAILED;
7322    }
7323
7324    macCellGrpCfg->skipUplinkTxDynamic = false;
7325    macCellGrpCfg->ext1 = NULLP;
7326
7327    return ROK;
7328 }
7329 /*******************************************************************
7330  *
7331  * @brief Frees memeory allocated for SearchSpcToAddModList
7332  *
7333  * @details
7334  *
7335  *    Function : FreeSearchSpcToAddModList
7336  *
7337  *    Functionality: Deallocating memory of SearchSpcToAddModList
7338  *
7339  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
7340  *
7341  * @return void
7342  *
7343  4221 * ****************************************************************/
7344 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
7345 {
7346    uint8_t idx1=0;
7347    uint8_t idx2=0;
7348    struct  SearchSpace *searchSpc=NULLP;
7349
7350    if(searchSpcList->list.array)
7351    {
7352       if(searchSpcList->list.array[idx2])
7353       {
7354          searchSpc = searchSpcList->list.array[idx2];
7355          if(searchSpc->controlResourceSetId)
7356          {
7357             if(searchSpc->monitoringSlotPeriodicityAndOffset)
7358             {
7359                if(searchSpc->monitoringSymbolsWithinSlot)
7360                {
7361                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
7362                   {
7363                      if(searchSpc->nrofCandidates)
7364                      {
7365                         if(searchSpc->searchSpaceType)
7366                         {
7367                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
7368                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
7369                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
7370                                     SearchSpace__searchSpaceType));
7371                         }
7372                         DU_FREE(searchSpc->nrofCandidates,
7373                               sizeof(struct SearchSpace__nrofCandidates));
7374                      }
7375                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
7376                            searchSpc->monitoringSymbolsWithinSlot->size);
7377                   }
7378                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
7379                         sizeof(BIT_STRING_t));
7380                }
7381                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
7382                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
7383             }
7384             DU_FREE(searchSpc->controlResourceSetId,
7385                   sizeof(ControlResourceSetId_t));
7386          }
7387       }
7388       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
7389       {
7390          DU_FREE(searchSpcList->list.array[idx1],
7391                sizeof(struct SearchSpace));
7392       }
7393       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
7394    }
7395 }
7396 /*******************************************************************
7397  *
7398  * @brief Frees memory allocated for PdschTimeDomAllocList
7399  *
7400  * @details
7401  *
7402  *    Function : FreePdschTimeDomAllocList
7403  *
7404  *    Functionality: Deallocating memory of PdschTimeDomAllocList
7405  *
7406  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
7407  *
7408  * @return void
7409  *
7410  * ****************************************************************/
7411 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
7412 {
7413    uint8_t idx1=0;
7414
7415    if(timeDomAllocList->choice.setup)
7416    {
7417       if(timeDomAllocList->choice.setup->list.array)
7418       {
7419          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
7420          {
7421             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
7422             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
7423                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
7424          }
7425          DU_FREE(timeDomAllocList->choice.setup->list.array, \
7426                timeDomAllocList->choice.setup->list.size);
7427       }
7428       DU_FREE(timeDomAllocList->choice.setup,\
7429             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
7430    }
7431 }
7432 /*******************************************************************
7433  *
7434  * @brief Frees memory allocated for PuschTimeDomAllocList
7435  *
7436  *@details
7437  *
7438  *    Function : FreePuschTimeDomAllocList
7439  *
7440  *    Functionality: Deallocating memory of PuschTimeDomAllocList
7441  *
7442  * @params[in] PUSCH_Config_t *puschCfg
7443  *
7444  * @return void
7445  *
7446  * ****************************************************************/
7447 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
7448 {
7449    uint8_t rsrcListIdx=0;
7450    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7451
7452    if(puschCfg->pusch_TimeDomainAllocationList)
7453    {
7454       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7455       if(timeDomAllocList_t->choice.setup)
7456       {
7457          if(timeDomAllocList_t->choice.setup->list.array)
7458          {
7459             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
7460             {
7461                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
7462                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
7463                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
7464             }
7465             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
7466                   timeDomAllocList_t->choice.setup->list.size);
7467          }
7468          DU_FREE(timeDomAllocList_t->choice.setup, \
7469                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
7470       }
7471       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
7472       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
7473             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
7474    }
7475
7476 }
7477
7478 /*******************************************************************
7479  *
7480  * @brief Frees memory allocated for Dedicated PUCCH config
7481  *
7482  * @details
7483  *
7484  *    Function : FreeBWPUlDedPucchCfg
7485  *
7486  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
7487  *
7488  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
7489  *
7490  * @return void
7491  *
7492  * ****************************************************************/
7493 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
7494 {
7495    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
7496    PUCCH_Config_t *pucchCfg = NULLP;
7497    PUCCH_ResourceSet_t *rsrcSet = NULLP;
7498    PUCCH_Resource_t *rsrc = NULLP;
7499
7500    if(ulBwpPucchCfg)
7501    {
7502       if(ulBwpPucchCfg->choice.setup)
7503       {
7504          pucchCfg = ulBwpPucchCfg->choice.setup;
7505
7506          //Free resource set list
7507          if(pucchCfg->resourceSetToAddModList)
7508          {
7509             if(pucchCfg->resourceSetToAddModList->list.array)
7510             {
7511                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
7512                {
7513                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
7514                   if(rsrcSet->resourceList.list.array)
7515                   {
7516                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
7517                      {
7518                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
7519                      }
7520                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
7521                   }
7522                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
7523                }
7524                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
7525             }
7526             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
7527          }
7528
7529          //Free resource list
7530          if(pucchCfg->resourceToAddModList)
7531          {
7532             if(pucchCfg->resourceToAddModList->list.array)
7533             {
7534                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
7535                {
7536                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
7537                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
7538                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
7539                }
7540                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
7541             }
7542             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
7543          }
7544
7545          //PUCCH Format 1
7546          if(pucchCfg->format1)
7547          {
7548             if(pucchCfg->format1->choice.setup)
7549             {
7550                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
7551                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
7552             }
7553             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
7554          }
7555
7556          //DL DATA TO UL ACK
7557          if(pucchCfg->dl_DataToUL_ACK)
7558          {
7559             if(pucchCfg->dl_DataToUL_ACK->list.array)
7560             {
7561                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
7562                {
7563                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
7564                }
7565                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
7566             }
7567             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
7568          }
7569
7570          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
7571       }
7572       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
7573    }
7574 }
7575
7576 /*******************************************************************
7577  *
7578  * @brief Frees memory allocated for InitialUlBWP
7579  *
7580  * @details
7581  *
7582  *    Function : FreeInitialUlBWP
7583  *
7584  *    Functionality: Deallocating memory of InitialUlBWP
7585  *
7586  * @params[in] BWP_UplinkDedicated_t *ulBwp
7587  *
7588  * @return void
7589  *
7590  * ****************************************************************/
7591 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
7592 {
7593    uint8_t  rSetIdx, rsrcIdx;
7594    SRS_Config_t   *srsCfg = NULLP;
7595    PUSCH_Config_t *puschCfg = NULLP;
7596    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
7597    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
7598    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
7599    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
7600
7601    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
7602
7603    if(ulBwp->pusch_Config)
7604    {
7605       if(ulBwp->pusch_Config->choice.setup)
7606       {
7607          puschCfg=ulBwp->pusch_Config->choice.setup;
7608          if(puschCfg->dataScramblingIdentityPUSCH)
7609          {
7610             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
7611             {
7612                FreePuschTimeDomAllocList(puschCfg);
7613                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
7614                if(dmrsUlCfg->choice.setup)
7615                {
7616                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
7617                   {
7618                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
7619                      {
7620                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
7621                               sizeof(long));
7622                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
7623                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
7624                      }
7625                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
7626                            sizeof(long));
7627                   }
7628                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
7629                }
7630                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
7631                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
7632             }
7633             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
7634          }
7635          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
7636       }
7637       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
7638
7639       /* Free SRS-Config */
7640       if(ulBwp->srs_Config)
7641       {
7642          if(ulBwp->srs_Config->choice.setup)
7643          {
7644             srsCfg = ulBwp->srs_Config->choice.setup;
7645
7646             /* Free Resource Set to add/mod list */
7647             if(srsCfg->srs_ResourceSetToAddModList)
7648             {
7649                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
7650                if(rsrcSetList->list.array)
7651                {
7652                   rSetIdx = 0;
7653
7654                   /* Free SRS resource Id list in this SRS resource set */
7655                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
7656                   {
7657                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
7658
7659                      if(rsrcIdList->list.array)
7660                      {
7661                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
7662                         {
7663                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
7664                         }
7665                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
7666                      }
7667                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
7668                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
7669                   }
7670
7671                   /* Free resource type info for this SRS resource set */
7672                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
7673                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
7674
7675                   /* Free memory for each resource set */
7676                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
7677                   {
7678                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
7679                   }
7680                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
7681                }
7682                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
7683                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
7684             }
7685
7686             /* Free resource to add/modd list */
7687             if(srsCfg->srs_ResourceToAddModList)
7688             {
7689                resourceList = srsCfg->srs_ResourceToAddModList;
7690                if(resourceList->list.array)
7691                {
7692                   rsrcIdx = 0;
7693                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
7694                         sizeof(struct SRS_Resource__transmissionComb__n2));
7695                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
7696                         sizeof(struct SRS_Resource__resourceType__aperiodic));
7697
7698                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
7699                   {
7700                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
7701                   }
7702                   DU_FREE(resourceList->list.array, resourceList->list.size);
7703                }
7704                DU_FREE(srsCfg->srs_ResourceToAddModList, \
7705                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
7706             }
7707
7708             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
7709          }
7710          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
7711       }
7712    }
7713 }
7714 /*******************************************************************
7715  *
7716  * @brief Frees memory allocated for initialUplinkBWP
7717  *
7718  * @details
7719  *
7720  *    Function : FreeinitialUplinkBWP
7721  *
7722  *    Functionality: Deallocating memory of initialUplinkBWP
7723  *
7724  * @params[in] UplinkConfig_t *ulCfg
7725  *
7726  * @return void
7727  *
7728  *
7729  * ****************************************************************/
7730 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
7731 {
7732    BWP_UplinkDedicated_t *ulBwp=NULLP;
7733    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
7734
7735    if(ulCfg->initialUplinkBWP)
7736    {
7737       ulBwp=ulCfg->initialUplinkBWP;
7738       if(ulCfg->firstActiveUplinkBWP_Id)
7739       {
7740          if(ulCfg->pusch_ServingCellConfig)
7741          {
7742             puschCfg=ulCfg->pusch_ServingCellConfig;
7743             if(puschCfg->choice.setup)
7744             {
7745                if(puschCfg->choice.setup->ext1)
7746                {
7747                   DU_FREE(puschCfg->choice.setup->ext1->\
7748                         processingType2Enabled,sizeof(BOOLEAN_t));
7749                   DU_FREE(puschCfg->choice.setup->ext1->\
7750                         maxMIMO_Layers,sizeof(long));
7751                   DU_FREE(puschCfg->choice.setup->ext1, \
7752                         sizeof(struct PUSCH_ServingCellConfig__ext1));
7753                }
7754                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
7755             }
7756             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
7757          }
7758          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
7759       }
7760       FreeInitialUlBWP(ulBwp);
7761       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
7762    }
7763 }
7764 /*******************************************************************
7765  *
7766  * @brief Frees emmory allocated for BWPDlDedPdschCfg
7767  *
7768  * @details
7769  *
7770  *    Function : FreeBWPDlDedPdschCfg
7771  *
7772  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
7773  *
7774  * @params[in] BWP_DownlinkDedicated_t *dlBwp
7775  *
7776  * @return void
7777  *
7778  *
7779  * ****************************************************************/
7780 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
7781 {
7782    struct PDSCH_Config *pdschCfg=NULLP;
7783    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
7784    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
7785    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
7786
7787    if(dlBwp->pdsch_Config->choice.setup)
7788    {
7789       pdschCfg=dlBwp->pdsch_Config->choice.setup;
7790       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7791       {
7792          if(pdschCfg->pdsch_TimeDomainAllocationList)
7793          {
7794             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
7795             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
7796             {
7797                prbBndlType=&pdschCfg->prb_BundlingType;
7798                DU_FREE(prbBndlType->choice.staticBundling,\
7799                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
7800                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
7801             }
7802             FreePdschTimeDomAllocList(timeDomAllocList);
7803             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
7804                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
7805          }
7806          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
7807          if(dmrsDlCfg->choice.setup)
7808          {
7809             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
7810                   sizeof(long));
7811             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
7812          }
7813          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
7814                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
7815       }
7816       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
7817    }
7818 }
7819 /*******************************************************************
7820  *
7821  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
7822  *
7823  * @details
7824  *
7825  *    Function : FreeBWPDlDedPdcchCfg
7826  *
7827  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
7828  *
7829  * @params[in] BWP_DownlinkDedicated_t *dlBwp
7830  *
7831  * @return void
7832  *
7833  *
7834  * ****************************************************************/
7835 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
7836 {
7837    uint8_t idx1=0;
7838    uint8_t idx2=0;
7839    struct PDCCH_Config *pdcchCfg=NULLP;
7840    struct ControlResourceSet *controlRSet=NULLP;
7841    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
7842
7843    if(dlBwp->pdcch_Config->choice.setup)
7844    {
7845       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
7846       if(pdcchCfg->controlResourceSetToAddModList)
7847       {
7848          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
7849          if(controlRSetList->list.array)
7850          {
7851             controlRSet = controlRSetList->list.array[idx2];
7852             if(controlRSet)
7853             {
7854                if(controlRSet->frequencyDomainResources.buf)
7855                {
7856                   if(controlRSet->pdcch_DMRS_ScramblingID)
7857                   {
7858                      if(pdcchCfg->searchSpacesToAddModList)
7859                      {
7860                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
7861                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
7862                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
7863                      }
7864                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
7865                   }
7866                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
7867                         controlRSet->frequencyDomainResources.size);
7868                }
7869             }
7870             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
7871             {
7872                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
7873             }
7874             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
7875          }
7876          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
7877                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
7878       }
7879       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
7880    }
7881 }
7882
7883 /*******************************************************************
7884  *
7885  * @brief Free SCS specific carrier list in DL frequency info
7886  *
7887  * @details
7888  *
7889  *    Function : FreeScsSpecificCarrierListDl
7890  *
7891  *    Functionality: Free SCS specific carrier list in DL frequency info
7892  *
7893  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
7894  *
7895  * @return void
7896  *
7897  * ****************************************************************/
7898 void FreeScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
7899 {
7900    uint8_t listIdx = 0;
7901
7902    if(!scsCarrierList->list.array)
7903    {
7904       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
7905       {
7906          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
7907       }
7908       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
7909    }
7910 }
7911
7912 /*******************************************************************
7913  *
7914  * @brief Free DL frequency info in DL config common
7915  *
7916  * @details
7917  *
7918  *    Function : FreeFreqInfoDl
7919  *
7920  *    Functionality: Free DL frequency info in DL config common
7921  *
7922  * @params[in] Pointer to DownlinkConfigCommon_t
7923  *
7924  * @return void
7925  *
7926  * ****************************************************************/
7927 void FreeFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
7928 {
7929    uint8_t freqBandIdx = 0;
7930
7931    /* SSB Absolute Frequency */
7932    DU_FREE(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
7933
7934    /* NR Multi Frequency Band List */
7935    if(frequencyInfoDL->frequencyBandList.list.array)
7936    {
7937       for(freqBandIdx = 0; freqBandIdx < frequencyInfoDL->frequencyBandList.list.count; freqBandIdx++)
7938       {
7939          DU_FREE(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
7940       }
7941       DU_FREE(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
7942    }
7943
7944    /* Subcarrier Spacing specifc carrier List */
7945    FreeScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList);
7946 }
7947
7948 /*******************************************************************
7949  *
7950  * @brief Free DL config common in Serving cell config common
7951  *
7952  * @details
7953  *
7954  *    Function : FreeDlConfigCommon
7955  *
7956  *    Functionality: Free DL config common in Serving cell config common
7957  *
7958  * @params[in] Pointer to DownlinkConfigCommon_t
7959  *
7960  * @return void
7961  *
7962  * ****************************************************************/
7963 void FreeDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
7964 {
7965    /* DL Frequency Info */
7966    if(dlCfgCommon->frequencyInfoDL)
7967    {
7968       FreeFreqInfoDl(dlCfgCommon->frequencyInfoDL);
7969       DU_FREE(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
7970    }
7971
7972    /* DL BWP config common */
7973    if(dlCfgCommon->initialDownlinkBWP)
7974    {
7975       FreeBwpDlCommon(dlCfgCommon->initialDownlinkBWP);
7976       DU_FREE(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
7977    }
7978 }
7979
7980 /*******************************************************************
7981  *
7982  * @brief Free SCS specific carrier list in UL frequency Info
7983  *
7984  * @details
7985  *
7986  *    Function : FreeScsSpecificCarrierListUl
7987  *
7988  *    Functionality: Free SCS specific carrier list in UL frequency Info
7989  *
7990  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
7991  *
7992  * @return void
7993  *
7994  * ****************************************************************/
7995 void FreeScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
7996 {
7997    uint8_t listIdx = 0;
7998
7999    if(scsCarrierList->list.array)
8000    {
8001       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
8002       {
8003          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
8004       }
8005       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
8006    }
8007 }
8008
8009 /*******************************************************************
8010  *
8011  * @brief Free frequency info in UL config common
8012  *
8013  * @details
8014  *
8015  *    Function : FreeFreqInfoUl
8016  *
8017  *    Functionality: Free frequency info in UL config common
8018  *
8019  * @params[in] Pointer to FrequencyInfoUL_t
8020  *
8021  * @return void
8022  *
8023  * ****************************************************************/
8024 void FreeFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
8025 {
8026    uint8_t listIdx= 0;
8027
8028    /* NR Multi Frequency Band List */
8029    if(!frequencyInfoUL->frequencyBandList)
8030    {
8031       if(frequencyInfoUL->frequencyBandList->list.array)
8032       {
8033          for(listIdx = 0; listIdx < frequencyInfoUL->frequencyBandList->list.count; listIdx++)
8034          {
8035             DU_FREE(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
8036          }
8037          DU_FREE(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
8038       }
8039       DU_FREE(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
8040    }
8041
8042    /* Absolute frequency point A */
8043    DU_FREE(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
8044
8045    /* Subcarrier Spacing specifc carrier */
8046    FreeScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList);
8047
8048    /* P-MAX */
8049    DU_FREE(frequencyInfoUL->p_Max, sizeof(P_Max_t));
8050 }
8051
8052 /*******************************************************************
8053  *
8054  * @brief Free UL config common in Serving cell config common
8055  *
8056  * @details
8057  *
8058  *    Function : FreeUlConfigCommon
8059  *
8060  *    Functionality: Free UL config common in Serving cell config common
8061  *
8062  * @params[in] Pointer to UplinkConfigCommon_t
8063  *
8064  * @return void
8065  *
8066  * ****************************************************************/
8067 void FreeUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
8068 {
8069    /* UL Frequency Info */
8070    if(ulCfgCommon->frequencyInfoUL)
8071    {
8072       FreeFreqInfoUl(ulCfgCommon->frequencyInfoUL);
8073       DU_FREE(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
8074    }
8075
8076    /* UL BWP common */
8077    if(ulCfgCommon->initialUplinkBWP)
8078    {
8079       FreeBwpUlCommon(ulCfgCommon->initialUplinkBWP);
8080       DU_FREE(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
8081    }
8082 }
8083
8084 /*******************************************************************
8085  *
8086  * @brief Free SP cell config common in Reconfig with Sync
8087  *
8088  * @details
8089  *
8090  *    Function : FreeSpCellConfigCommon
8091  *
8092  *    Functionality: Free SP cell config common in Reconfig with Sync
8093  *
8094  * @params[in] Pointer to ServingCellConfigCommon_t
8095  *
8096  * @return void
8097  *
8098  * ****************************************************************/
8099 void FreeSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
8100 {
8101    /* Free Physical cell identity */
8102    DU_FREE(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
8103
8104    /* Free Downlink Config common */
8105    if(spCellConfigCommon->downlinkConfigCommon)
8106    {
8107       FreeDlConfigCommon(spCellConfigCommon->downlinkConfigCommon);
8108       DU_FREE(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
8109    }
8110
8111    /* Free Uplink Config common */
8112    if(spCellConfigCommon->uplinkConfigCommon)
8113    {
8114       FreeUlConfigCommon(spCellConfigCommon->uplinkConfigCommon);
8115       DU_FREE(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
8116    }
8117
8118    /* Free Timing Advance offset */
8119    DU_FREE(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
8120
8121    /* Free SSB Position in Burst */
8122    if(spCellConfigCommon->ssb_PositionsInBurst)
8123    {
8124       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.buf, \
8125          spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.size);
8126       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
8127    }
8128
8129    /* Free SSB Periodicity in Serving cell */
8130    DU_FREE(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
8131
8132    /* Free SSB subcarrier spacing */
8133    DU_FREE(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8134
8135    /* TDD UL-DL configuration common */
8136    DU_FREE(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
8137 }
8138
8139 /*******************************************************************
8140  *
8141  * @brief Free dedicated RACH configuration in Reconfiguration with sync
8142  *
8143  * @details
8144  *
8145  *    Function : FreeRecfgWithSync
8146  *
8147  *    Functionality:
8148  *       Free dedicated RACH configuration in Reconfiguration with sync
8149  *
8150  * @params[in] Pinter to Rach config dedicated struct
8151  *
8152  * @return void
8153  *
8154  * ****************************************************************/
8155 void FreeRachConfigDedicated(struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
8156 {
8157    uint8_t listIdx = 0;
8158    CFRA_t *cfra = NULLP;
8159    struct CFRA__resources__ssb *ssbResource = NULLP;
8160
8161    /* Uplink */
8162    if(rachCfgDed->choice.uplink)
8163    {
8164       /* CFRA : Contention free Random Access */
8165       if(rachCfgDed->choice.uplink->cfra)
8166       {
8167          cfra = rachCfgDed->choice.uplink->cfra;
8168
8169          /* CFRA occassions */
8170          if(cfra->occasions)
8171          {
8172             /* CFRA occassions : SSB per RACH occasion */
8173             DU_FREE(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
8174             DU_FREE(cfra->occasions, sizeof(struct CFRA__occasions));
8175          }
8176
8177          /* CFRA resource */
8178          cfra->resources.present = CFRA__resources_PR_ssb;
8179
8180          /* CFRA resource : SSB */
8181          if(cfra->resources.choice.ssb)
8182          {
8183             ssbResource = cfra->resources.choice.ssb;
8184
8185             /* CFRA SSB resource list */
8186             if(ssbResource->ssb_ResourceList.list.array)
8187             {
8188                for(listIdx = 0; listIdx < ssbResource->ssb_ResourceList.list.count; listIdx++)
8189                {
8190                   DU_FREE(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
8191                }
8192                DU_FREE(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
8193             }
8194             DU_FREE(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
8195          }
8196          DU_FREE(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
8197       }
8198       DU_FREE(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
8199    }
8200 }
8201
8202 /*******************************************************************
8203  *
8204  * @brief Frees reconfiguration with sync in SP cell config
8205  *
8206  * @details
8207  *
8208  *    Function : FreeRecfgWithSync
8209  *
8210  *    Functionality: Fress reconfiguration with sync in SP cell config
8211  *
8212  * @params[in] Pointer to ReconfigurationWithSync_t
8213  *
8214  * @return void
8215  *
8216  * ****************************************************************/
8217 void FreeRecfgWithSync(ReconfigurationWithSync_t *recfgWithSync)
8218 {
8219    /* Free SP Cell config common */
8220    if(recfgWithSync->spCellConfigCommon)
8221    {
8222       FreeSpCellConfigCommon(recfgWithSync->spCellConfigCommon);
8223       DU_FREE(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
8224    }
8225
8226    /* Free Dedicated RACH configuration */
8227    if(recfgWithSync->rach_ConfigDedicated)
8228    {
8229       FreeRachConfigDedicated(recfgWithSync->rach_ConfigDedicated);
8230       DU_FREE(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
8231    }
8232 }
8233
8234 /*******************************************************************
8235  *
8236  * @brief Frees emmory allocated for DUToCURRCContainer
8237  *
8238  * @details
8239  *
8240  *    Function : FreeMemDuToCuRrcCont
8241  *
8242  *    Functionality: Deallocating memory of DuToCuRrcContainer
8243  *
8244  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
8245  *
8246  * @return ROK     - success
8247  *         RFAILED - failure
8248  *
8249  * ****************************************************************/
8250 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
8251 {
8252    uint8_t idx=0;
8253    SpCellConfig_t *spCellCfg=NULLP;
8254    ServingCellConfig_t *srvCellCfg=NULLP;
8255    BWP_DownlinkDedicated_t *dlBwp=NULLP;
8256    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
8257    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
8258    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
8259    struct RLC_Config *rlcConfig=NULLP;
8260    struct LogicalChannelConfig *macLcConfig=NULLP;
8261    struct MAC_CellGroupConfig__drx_ConfigRrc *drxCfg=NULLP;
8262    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
8263    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
8264    struct TAG_Config *tagConfig=NULLP;
8265    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
8266    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
8267    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
8268
8269    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
8270    if(rlcBearerList)
8271    {
8272       if(rlcBearerList->list.array)
8273       {
8274          for(idx=0; idx<rlcBearerList->list.count; idx++)
8275          {
8276             if(rlcBearerList->list.array[idx])
8277             {
8278                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
8279                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
8280                if(rlcConfig)
8281                {
8282                   switch(rlcConfig->present)
8283                   {
8284                      case RLC_Config_PR_NOTHING:
8285                         break;
8286
8287                      case RLC_Config_PR_am:
8288                         {
8289                            if(rlcConfig->choice.am)
8290                            {
8291                               DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8292                               DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8293                               DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
8294                            }
8295                            break;
8296                         }
8297                      case RLC_Config_PR_um_Bi_Directional:
8298                         {
8299                            if(rlcConfig->choice.um_Bi_Directional)
8300                            {
8301                               DU_FREE(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8302                               DU_FREE(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8303                               DU_FREE(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
8304                            }
8305                            break;
8306                         }
8307                      case RLC_Config_PR_um_Uni_Directional_UL:
8308                         {
8309                            if(rlcConfig->choice.um_Uni_Directional_UL)
8310                            {
8311                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8312                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
8313                            }
8314                            break;
8315                         }
8316                      case RLC_Config_PR_um_Uni_Directional_DL:
8317                         {
8318                            if(rlcConfig->choice.um_Uni_Directional_DL )
8319                            {
8320                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8321                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
8322                            }
8323                            break;
8324                         }
8325                   }
8326                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
8327                }
8328                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
8329                if(macLcConfig)
8330                {
8331                   if(macLcConfig->ul_SpecificParameters)
8332                   {
8333                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
8334                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
8335                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
8336                   }
8337                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
8338                }
8339                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
8340             }
8341          }
8342          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
8343       }
8344       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8345    }
8346
8347    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
8348    if(macCellGrpCfg)
8349    {
8350       drxCfg = macCellGrpCfg->drx_ConfigRrc;
8351
8352       if(drxCfg)
8353       {
8354           switch(drxCfg->present)
8355           {
8356             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
8357                break;
8358             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
8359             {
8360                if(drxCfg->choice.setup)
8361                {
8362                   DU_FREE(drxCfg->choice.setup->shortDRX, sizeof(struct DRX_ConfigRrc__shortDRX));
8363                   DU_FREE(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
8364                }
8365             }
8366             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
8367                break;
8368           }
8369           DU_FREE(drxCfg, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
8370       }
8371       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
8372       if(schedulingRequestConfig)
8373       {
8374          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
8375          if(schReqList)
8376          {
8377             if(schReqList->list.array)
8378             {
8379                for(idx=0;idx<schReqList->list.count; idx++)
8380                {
8381                   if(schReqList->list.array[idx])
8382                   {
8383                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
8384                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
8385                   }
8386                }
8387                DU_FREE(schReqList->list.array, schReqList->list.size);
8388             }
8389             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
8390                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
8391             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
8392       }
8393       if(macCellGrpCfg->bsr_Config)
8394       {
8395          DU_FREE(macCellGrpCfg->bsr_Config->logicalChannelSR_DelayTimer, sizeof(long));
8396          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
8397       }
8398       tagConfig = macCellGrpCfg->tag_Config;
8399       if(tagConfig)
8400       {
8401          tagList = tagConfig->tag_ToAddModList;
8402          if(tagList)
8403          {
8404             if(tagList->list.array)
8405             {
8406                for(idx=0; idx<tagList->list.count; idx++)
8407                {
8408                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
8409                }
8410                DU_FREE(tagList->list.array, tagList->list.size);
8411             }
8412             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
8413          }
8414          DU_FREE(tagConfig, sizeof(struct TAG_Config));
8415       }
8416
8417       phrConfig = macCellGrpCfg->phr_Config;
8418       if(phrConfig)
8419       {
8420          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
8421          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
8422       }
8423
8424       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
8425    }
8426
8427    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
8428    if(phyCellGrpCfg)
8429    {
8430       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
8431       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
8432    }
8433
8434    spCellCfg = cellGrpCfg->spCellConfig;
8435    if(spCellCfg)
8436    {
8437       /* Free serving cell index */
8438       DU_FREE(spCellCfg->servCellIndex, sizeof(long));
8439
8440       /* Free Reconfiguration with sync */
8441       if(spCellCfg->reconfigurationWithSync)
8442       {
8443          FreeRecfgWithSync(spCellCfg->reconfigurationWithSync);
8444          DU_FREE(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
8445       }
8446
8447       /* Free rlmInSyncOutOfSyncThreshold */
8448       DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
8449
8450       /* Free SP Cell config dedicated */
8451       if(spCellCfg->spCellConfigDedicated)
8452       {
8453          srvCellCfg = spCellCfg->spCellConfigDedicated;
8454
8455          /* Free TDD UL-DL config dedicated */
8456          DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
8457
8458          /* Free Initial Downlink BWP */
8459          if(srvCellCfg->initialDownlinkBWP)
8460          {
8461             dlBwp = srvCellCfg->initialDownlinkBWP;
8462
8463             /* Free DL BWP PDCCH Config */
8464             if(dlBwp->pdcch_Config)
8465             {
8466                FreeBWPDlDedPdcchCfg(dlBwp);
8467                DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
8468             }
8469
8470             /* Free DL BWP PDSCH config */
8471             if(dlBwp->pdsch_Config)
8472             {
8473                FreeBWPDlDedPdschCfg(dlBwp);
8474                DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
8475             }
8476             DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
8477          }
8478
8479          /* Free First Active Downlink BWP */
8480          DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
8481
8482          /* Free Default downlink BWP */
8483          DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
8484
8485          /* Free Uplink config */
8486          if(srvCellCfg->uplinkConfig)
8487          {
8488             FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
8489             DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
8490          }
8491
8492          /* Free PDSCH serving cell config */
8493          if(srvCellCfg->pdsch_ServingCellConfig)
8494          {
8495             pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
8496             if(pdschCfg->choice.setup)
8497             {
8498                DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
8499                DU_FREE(pdschCfg->choice.setup, sizeof(struct PDSCH_ServingCellConfig));
8500             }
8501             DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
8502          }
8503
8504          DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
8505       }
8506       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
8507    }
8508    return ROK;
8509 }
8510
8511 /*******************************************************************
8512  *
8513  * @brief Builds CellGroupConfigRrc for DU To CU RRC Container
8514  *
8515  * @details
8516  *
8517  *    Function : BuildCellGroupConfigRrc
8518  *
8519  *    Functionality: Builds and copied Cell group config buffer into
8520  *       DuToCuRrcContainer
8521  *
8522  * @params[in] idx, index in F1AP msg
8523  *             DuToCuRRCContainer, DuToCuRRCContainer
8524  *
8525  * @return ROK     - success
8526  *         RFAILED - failure
8527  *
8528  * ****************************************************************/
8529 uint8_t BuildCellGroupConfigRrc(DuUeCb *ueCb, OCTET_STRING_t *duToCuRrcContainer)
8530 {
8531    uint8_t  ret = ROK;
8532    CellGroupConfigRrc_t  cellGrpCfg;
8533    asn_enc_rval_t        encRetVal;
8534    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
8535    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8536
8537    while(true)
8538    {
8539       cellGrpCfg.cellGroupId = CELL_GRP_ID;
8540
8541       cellGrpCfg.rlc_BearerToAddModList = NULLP;
8542       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8543       if(!cellGrpCfg.rlc_BearerToAddModList)
8544       {
8545          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8546          ret = RFAILED;
8547          break;
8548       }
8549       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList) != ROK)
8550       {
8551          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
8552          ret = RFAILED;
8553          break;
8554       }
8555
8556       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
8557       cellGrpCfg.mac_CellGroupConfig = NULLP;
8558       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
8559       if(!cellGrpCfg.mac_CellGroupConfig)
8560       {
8561          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8562          ret = RFAILED;
8563          break;
8564       }
8565       if(BuildMacCellGrpCfg(ueCb, cellGrpCfg.mac_CellGroupConfig) != ROK)
8566       {
8567          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
8568          ret = RFAILED;
8569          break;
8570       }
8571
8572       cellGrpCfg.physicalCellGroupConfig = NULLP;
8573       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
8574       if(!cellGrpCfg.physicalCellGroupConfig)
8575       {
8576          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8577          ret = RFAILED;
8578          break;
8579       }
8580       if(BuildPhyCellGrpCfg(ueCb, cellGrpCfg.physicalCellGroupConfig) != ROK)
8581       {
8582          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
8583          ret = RFAILED;
8584          break;
8585       }
8586
8587       cellGrpCfg.spCellConfig = NULLP;
8588       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
8589       if(!cellGrpCfg.spCellConfig)
8590       {
8591          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8592          ret = RFAILED;
8593          break;
8594       }
8595       if(BuildSpCellCfg(ueCb, cellGrpCfg.spCellConfig) != ROK)
8596       {
8597          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
8598          ret = RFAILED;
8599          break;
8600       }
8601
8602       cellGrpCfg.sCellToAddModList = NULLP;
8603       cellGrpCfg.sCellToReleaseList = NULLP;
8604       cellGrpCfg.ext1 = NULLP;
8605
8606       /* encode cellGrpCfg into duToCuRrcContainer */
8607       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
8608       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8609       encBufSize = 0;
8610       encRetVal = uper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
8611       /* Encode results */
8612       if(encRetVal.encoded == ENCODE_FAIL)
8613       {
8614          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
8615                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8616          ret = RFAILED;
8617          break;
8618       }
8619       else
8620       {
8621          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
8622 #ifdef DEBUG_ASN_PRINT
8623          for(int i=0; i< encBufSize; i++)
8624          {
8625             printf("%x",encBuf[i]);
8626          }
8627 #endif
8628       }
8629
8630       duToCuRrcContainer->size = encBufSize;
8631       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
8632       if(!duToCuRrcContainer->buf)
8633       {
8634          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
8635          ret = RFAILED;
8636          break;
8637       }
8638       if(ret == ROK)
8639       {
8640          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
8641       }
8642       break;
8643    }
8644    FreeMemDuToCuRrcCont(&cellGrpCfg);
8645    return ret;
8646 }
8647
8648 /*******************************************************************
8649  *
8650  * @brief Free memory allocated in InitialULRRCMessage
8651  *
8652  * @details
8653  *
8654  *    Function : freeInitUlRrcMsgTransfer
8655  *
8656  *    Functionality: Free memory allocated in InitialULRRCMessage
8657  *
8658  * @params[in]F1AP_PDU_t  *f1apMsg)
8659  *
8660  * @return ROK     - success
8661  *         RFAILED - failure
8662  *
8663  * ****************************************************************/
8664
8665 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
8666 {
8667    uint8_t ieIdx, arrIdx;
8668    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
8669
8670    if(f1apMsg)
8671    {
8672       if(f1apMsg->choice.initiatingMessage)
8673       {
8674          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
8675             choice.InitialULRRCMessageTransfer;
8676          if(initULRRCMsg->protocolIEs.list.array)
8677          {
8678             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
8679             {
8680                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
8681                {
8682                   case ProtocolIE_ID_id_NRCGI:
8683                   {
8684                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
8685                      {
8686                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
8687                         {
8688                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
8689                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
8690                         }
8691                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
8692                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
8693                      }
8694                      break;
8695                   }
8696                   case ProtocolIE_ID_id_RRCContainer:
8697                   {
8698                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8699                      {
8700                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
8701                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8702                      }
8703                      break;
8704                   }
8705                   case ProtocolIE_ID_id_DUtoCURRCContainer:
8706                   {
8707                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
8708                      {
8709                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
8710                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
8711                      }
8712                      break;
8713                   }
8714                   default:
8715                      break;
8716                }
8717              }
8718              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8719              {
8720                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
8721                 {
8722                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
8723                       sizeof(InitialULRRCMessageTransferIEs_t));
8724                 }
8725              }
8726              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
8727           }
8728          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8729       }
8730       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
8731    }
8732    else
8733    {
8734       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
8735       return RFAILED;
8736    }
8737    return ROK;
8738 }
8739
8740 /*******************************************************************
8741  *
8742  * @brief Builds and sends the InitialULRRCMessage
8743  *
8744  * @details
8745  *
8746  *    Function : BuildAndSendInitialRrcMsgTransfer
8747  *
8748  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
8749  *                   it to the CU through SCTP.
8750  *
8751  * @params[in]
8752  *
8753  * @return ROK     - success
8754  *         RFAILED - failure
8755  *
8756  * ****************************************************************/
8757 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
8758       uint16_t rrcContSize, uint8_t *rrcContainer)
8759 {
8760    uint8_t   ret;
8761    uint8_t   elementCnt;
8762    uint8_t   ieIdx, cellIdx, ueIdx;
8763    DuUeCb    *duUeCb = NULLP;
8764    asn_enc_rval_t  encRetVal;
8765    F1AP_PDU_t  *f1apMsg = NULLP;
8766    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
8767    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8768
8769    while(true)
8770    {
8771       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
8772       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8773       if(f1apMsg == NULLP)
8774       {
8775          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8776          break;
8777       }
8778       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8779       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8780       if(f1apMsg->choice.initiatingMessage == NULLP)
8781       {
8782          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
8783          break;
8784       }
8785       f1apMsg->choice.initiatingMessage->procedureCode =\
8786                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
8787       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
8788       f1apMsg->choice.initiatingMessage->value.present = \
8789                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
8790       initULRRCMsg =\
8791                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
8792       elementCnt = 5;
8793       initULRRCMsg->protocolIEs.list.count = elementCnt;
8794       initULRRCMsg->protocolIEs.list.size = \
8795                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
8796       /* Initialize the F1Setup members */
8797       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
8798       if(initULRRCMsg->protocolIEs.list.array == NULLP)
8799       {
8800          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
8801                RRCSetupRequestMessageTransferIEs failed");
8802          break;
8803       }
8804       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
8805       {
8806          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
8807                sizeof(InitialULRRCMessageTransferIEs_t));
8808          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
8809          {
8810             break;
8811          }
8812       }
8813       ieIdx = 0;
8814       /*GNB DU UE F1AP ID*/
8815       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8816                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8817       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
8818       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
8819                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
8820       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
8821
8822
8823       /*NRCGI*/
8824       ieIdx++;
8825       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8826                                                         ProtocolIE_ID_id_NRCGI;
8827       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
8828       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
8829                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
8830
8831       ret =\
8832            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
8833       if(ret!=ROK)
8834       {
8835          break;
8836       }
8837
8838       /*CRNTI*/
8839       ieIdx++;
8840       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8841                                                         ProtocolIE_ID_id_C_RNTI;
8842       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8843       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8844                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
8845       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
8846
8847       /*RRCContainer*/
8848       ieIdx++;
8849       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8850                                                         ProtocolIE_ID_id_RRCContainer;
8851       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8852       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8853                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
8854
8855       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
8856       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
8857             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
8858       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8859       {
8860          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
8861          break;
8862
8863       }
8864       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
8865             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8866
8867
8868       /*DUtoCURRCContainer*/
8869       ieIdx++;
8870       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
8871       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8872       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8873                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
8874
8875       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
8876       {
8877          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
8878          {
8879             if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
8880                   (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti == crnti))
8881             {
8882                duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
8883             }
8884          }
8885       }
8886
8887       ret = BuildCellGroupConfigRrc(duUeCb, &initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
8888       if(ret != ROK)
8889       {
8890          break;
8891       }
8892
8893       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8894
8895       /* Encode the Intial UL RRC Message transfer as APER */
8896       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8897       encBufSize = 0;
8898       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
8899       /* Encode results */
8900       if(encRetVal.encoded == ENCODE_FAIL)
8901       {
8902          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
8903                structure (at %s)\n",encRetVal.failed_type ? \
8904                encRetVal.failed_type->name : "unknown");
8905          ret = RFAILED;
8906          break;
8907       }
8908       else
8909       {
8910
8911          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
8912                Message transfer\n");
8913 #ifdef DEBUG_ASN_PRINT
8914          for(int i=0; i< encBufSize; i++)
8915          {
8916             printf("%x",encBuf[i]);
8917          }
8918 #endif
8919       }
8920       /* Sending  msg  */
8921       if(sendF1APMsg() != ROK)
8922       {
8923          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
8924          ret = RFAILED;
8925          break;
8926       }
8927       break;
8928    }
8929    freeInitUlRrcMsgTransfer(f1apMsg);
8930    return ret;
8931 }/* End of BuildAndSendInitialRrcMsgTransfer*/
8932
8933 /*****  UE SETUP REQUEST *****/
8934
8935 /*******************************************************************
8936  *
8937  * @brief Free Qos And Snssai Drb Info
8938  *
8939  * @details
8940  *
8941  *    Function : freeDrbQosAndSnssaiInfo
8942  *
8943  *    Functionality: Free Qos And Snssai Drb Info
8944  *
8945  * @params[in] LcCfg *lcCfg,
8946  * @return void
8947  *
8948  * ****************************************************************/
8949 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
8950 {
8951    if(lcCfg->snssai)
8952    {
8953       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
8954    }
8955    if(lcCfg->drbQos)
8956    {
8957       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
8958    }
8959 }
8960
8961 /******************************************************************
8962 *
8963 * @brief Function to delete the RLC Lc cfg from UE APP DB
8964 *
8965 * @details
8966 *
8967 *  Function : freeRlcLcCfg
8968 *
8969 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
8970 *
8971 *
8972  *****************************************************************/
8973
8974 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
8975 {
8976    switch(lcCfg->rlcMode)
8977    {
8978       case RLC_AM :
8979          {
8980             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
8981             break;
8982          }
8983       case RLC_UM_BI_DIRECTIONAL :
8984          {
8985             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
8986             break;
8987          }
8988       case RLC_UM_UNI_DIRECTIONAL_UL :
8989          {
8990             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
8991             break;
8992          }
8993       case RLC_UM_UNI_DIRECTIONAL_DL :
8994          {
8995             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
8996             break;
8997          }
8998       default:
8999          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
9000          break;
9001    }
9002    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
9003 }
9004
9005 /*******************************************************************
9006  *
9007  * @brief Function to free MacLcCfg
9008  *
9009  * @details
9010  *
9011  *    Function : freeMacLcCfg
9012  *
9013  *    Functionality: Function to free MacLcCfg
9014  *
9015  * @params[in] LcCfg *lcCfg,
9016  * @return void
9017  *
9018  * ****************************************************************/
9019
9020 void  freeMacLcCfg(LcCfg *lcCfg)
9021 {
9022     /* Deleting DRBQOS */
9023    if(lcCfg->drbQos)
9024    {
9025       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
9026    }
9027    /* Deleting SNSSAI */
9028    if(lcCfg->snssai)
9029    {
9030       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
9031    }
9032 }
9033 /*******************************************************************
9034  *
9035  * @brief Free UE NR Capability received in UE Context setup request
9036  *
9037  * @details
9038  *
9039  *    Function : freeAperDecodeUeNrCapability
9040  *
9041  *    Functionality:
9042  *       Free UE NR Capability received in UE Context setup request
9043  *
9044  * @params[in]
9045  * @return ROK     - success
9046  *         RFAILED - failure
9047  *
9048  * ****************************************************************/
9049 void freeAperDecodeUeNrCapability(void *ueNrCapability)
9050 {
9051    uint8_t arrIdx =0;
9052    FeatureSets_t *featureSets =NULLP;
9053    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
9054
9055    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
9056    {
9057       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
9058       {
9059          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
9060             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
9061       }
9062       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
9063    }
9064
9065    if(ueNrCap->featureSets)
9066    {
9067       featureSets = ueNrCap->featureSets;
9068       if(featureSets->featureSetsDownlinkPerCC)
9069       {
9070          if(featureSets->featureSetsDownlinkPerCC->list.array)
9071          {
9072             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
9073             {
9074                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
9075                {
9076                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
9077                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
9078                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
9079                }
9080             }
9081             free(featureSets->featureSetsDownlinkPerCC->list.array);
9082          }
9083          free(featureSets->featureSetsDownlinkPerCC);
9084       }
9085       if(featureSets->featureSetsUplinkPerCC)
9086       {
9087          if(featureSets->featureSetsUplinkPerCC->list.array)
9088          {
9089             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
9090             {
9091                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
9092                {
9093                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
9094                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
9095                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
9096                }
9097             }
9098             free(featureSets->featureSetsUplinkPerCC->list.array);
9099          }
9100          free(featureSets->featureSetsUplinkPerCC);
9101       }
9102       free(ueNrCap->featureSets);
9103    }
9104 }
9105
9106 /*******************************************************************
9107 *
9108 * @brief Function to free PdcchSearchSpcToAddModList
9109          where memory allocated by aper_decoder
9110 *
9111 * @details
9112 *
9113 *    Function : freeAperDecodePdcchSearchSpcToAddModList
9114 *
9115 *    Functionality: Function to free PdcchSearchSpcToAddModList
9116 *
9117 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
9118 * @return void
9119 *
9120 * ****************************************************************/
9121
9122 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
9123 {
9124    uint8_t searchSpcArrIdx=0;
9125    uint8_t searchSpcArrIdx1=0;
9126    struct  SearchSpace *searchSpc=NULLP;
9127
9128
9129    if(searchSpcList->list.array)
9130    {
9131       if(searchSpcList->list.array[searchSpcArrIdx1])
9132       {
9133          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
9134          if(searchSpc->controlResourceSetId)
9135          {
9136             if(searchSpc->monitoringSlotPeriodicityAndOffset)
9137             {
9138                if(searchSpc->monitoringSymbolsWithinSlot)
9139                {
9140                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
9141                   {
9142                      if(searchSpc->nrofCandidates)
9143                      {
9144                         if(searchSpc->searchSpaceType)
9145                         {
9146                            free(searchSpc->searchSpaceType->choice.ue_Specific);
9147                            free(searchSpc->searchSpaceType);
9148                         }
9149                         free(searchSpc->nrofCandidates);
9150                      }
9151                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
9152                   }
9153                   free(searchSpc->monitoringSymbolsWithinSlot);
9154                }
9155                free(searchSpc->monitoringSlotPeriodicityAndOffset);
9156             }
9157             free(searchSpc->controlResourceSetId);
9158          }
9159       }
9160       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
9161       {
9162          free(searchSpcList->list.array[searchSpcArrIdx]);
9163       }
9164       free(searchSpcList->list.array);
9165    }
9166 }
9167 /*******************************************************************
9168 *
9169 * @brief Function for free part for the memory allocated by aper_decoder
9170 *
9171 * @details
9172 *
9173 *    Function : freeAperDecodeBWPDlDedPdcchConfig
9174 *
9175 *    Functionality: Function to free BWPDlDedPdcchConfig
9176 *
9177 * @params[in]
9178 * @return void
9179 *
9180 * ****************************************************************/
9181
9182
9183 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
9184 {
9185    uint8_t arrIdx1=0;
9186    uint8_t arrIdx2=0;
9187    struct PDCCH_Config *pdcchCfg=NULLP;
9188    struct ControlResourceSet *controlRSet=NULLP;
9189    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
9190
9191    if(dlBwp->pdcch_Config->choice.setup)
9192    {
9193       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
9194       if(pdcchCfg->controlResourceSetToAddModList)
9195       {
9196          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
9197          if(controlRSetList->list.array)
9198          {
9199             controlRSet = controlRSetList->list.array[arrIdx2];
9200             if(controlRSet)
9201             {
9202                if(controlRSet->frequencyDomainResources.buf)
9203                {
9204                   if(controlRSet->pdcch_DMRS_ScramblingID)
9205                   {
9206                      if(pdcchCfg->searchSpacesToAddModList)
9207                      {
9208                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
9209                         free(pdcchCfg->searchSpacesToAddModList);
9210                      }
9211                      free(controlRSet->pdcch_DMRS_ScramblingID);
9212                   }
9213                   free(controlRSet->frequencyDomainResources.buf);
9214                }
9215             }
9216             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
9217             {
9218                free(controlRSetList->list.array[arrIdx1]);
9219             }
9220             free(controlRSetList->list.array);
9221          }
9222          free(pdcchCfg->controlResourceSetToAddModList);
9223       }
9224       free(dlBwp->pdcch_Config->choice.setup);
9225    }
9226 }
9227 /*******************************************************************
9228 *
9229 * @brief Function to free PdschTimeDomAllocationList
9230 *     where the memory allocated by aper_decoder
9231 *
9232 * @details
9233 *
9234 *    Function : freeAperDecodePdschTimeDomAllocationList
9235 *
9236 *    Functionality: Function to free PdschTimeDomAllocationList
9237 *
9238 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
9239 * @return void
9240 *
9241 * ****************************************************************/
9242
9243
9244 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
9245 {
9246    uint8_t arrIdx=0;
9247
9248    if(timeDomAllocList->choice.setup)
9249    {
9250       if(timeDomAllocList->choice.setup->list.array)
9251       {
9252          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
9253          {
9254             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
9255          }
9256          free(timeDomAllocList->choice.setup->list.array);
9257       }
9258       free(timeDomAllocList->choice.setup);
9259    }
9260 }
9261
9262 /*******************************************************************
9263 *
9264 * @brief Function to free BWPDlDedPdschConfig
9265 *        where the memory allocated by aper_decoder
9266 *
9267 * @details
9268 *
9269 *    Function : freeAperDecodeBWPDlDedPdschConfig
9270 *
9271 *    Functionality: Function to free BWPDlDedPdschConfig
9272 *
9273 * @params[in] BWP_DownlinkDedicated_t *dlBwp
9274 * @return void
9275 *
9276 * ****************************************************************/
9277
9278
9279 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
9280 {
9281    struct PDSCH_Config *pdschCfg=NULLP;
9282    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
9283    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
9284    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
9285
9286    if(dlBwp->pdsch_Config->choice.setup)
9287    {
9288       pdschCfg=dlBwp->pdsch_Config->choice.setup;
9289       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
9290       {
9291          if(pdschCfg->pdsch_TimeDomainAllocationList)
9292          {
9293             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
9294             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
9295             {
9296                prbBndlType=&pdschCfg->prb_BundlingType;
9297                free(prbBndlType->choice.staticBundling);
9298                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
9299             }
9300             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
9301             free(pdschCfg->pdsch_TimeDomainAllocationList);
9302          }
9303          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
9304          if(dmrsDlCfg->choice.setup)
9305          {
9306             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
9307             free(dmrsDlCfg->choice.setup);
9308          }
9309          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
9310       }
9311       free(dlBwp->pdsch_Config->choice.setup);
9312    }
9313 }
9314 /*******************************************************************
9315 *
9316 * @brief Function to free PuschTimeDomAllocListCfg
9317                  where the memory allocated by aper_decoder
9318 *
9319 * @details
9320 *
9321 *    Function : freeAperDecodePuschTimeDomAllocListCfg
9322 *
9323 *    Functionality: Function to free PuschTimeDomAllocListCfg
9324 *
9325 * @params[in] PUSCH_Config_t *puschCfg
9326 * @return void
9327 *
9328 * ****************************************************************/
9329
9330
9331 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
9332 {
9333    uint8_t arrIdx=0;
9334    uint8_t arrIdx1=0;
9335    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
9336
9337    if(puschCfg->pusch_TimeDomainAllocationList)
9338    {
9339       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
9340       if(timeDomAllocList_t->choice.setup)
9341       {
9342          if(timeDomAllocList_t->choice.setup->list.array)
9343          {
9344             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
9345             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
9346             {
9347                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
9348             }
9349             free(timeDomAllocList_t->choice.setup->list.array);
9350          }
9351          free(timeDomAllocList_t->choice.setup);
9352       }
9353       free(puschCfg->transformPrecoder);
9354       free(puschCfg->pusch_TimeDomainAllocationList);
9355    }
9356 }
9357 /*******************************************************************
9358 *
9359 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
9360 *
9361 * @details
9362 *
9363 *    Function : freeAperDecodeInitialUlBWPConfig
9364 *
9365 *    Functionality: Function to free InitialUlBWPConfig
9366 *
9367 * @params[in]  BWP_UplinkDedicated_t *ulBwp
9368 * @return void
9369 *
9370 * ****************************************************************/
9371
9372
9373 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
9374 {
9375    uint8_t  rSetIdx =0;
9376    uint8_t  rsrcIdx =0;
9377    SRS_Config_t   *srsCfg = NULLP;
9378    PUSCH_Config_t *puschCfg = NULLP;
9379    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
9380    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
9381    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
9382    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
9383
9384    if(ulBwp->pusch_Config)
9385    {
9386       if(ulBwp->pusch_Config->choice.setup)
9387       {
9388          puschCfg=ulBwp->pusch_Config->choice.setup;
9389          if(puschCfg->dataScramblingIdentityPUSCH)
9390          {
9391             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
9392             {
9393                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
9394                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
9395                if(dmrsUlCfg->choice.setup)
9396                {
9397                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
9398                   {
9399                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
9400                      {
9401                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
9402                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
9403                      }
9404                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
9405                   }
9406                   free(dmrsUlCfg->choice.setup);
9407                }
9408                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
9409             }
9410             free(puschCfg->dataScramblingIdentityPUSCH);
9411          }
9412          free(ulBwp->pusch_Config->choice.setup);
9413       }
9414       free(ulBwp->pusch_Config);
9415
9416       /* Free SRS-Config */
9417       if(ulBwp->srs_Config)
9418       {
9419          if(ulBwp->srs_Config->choice.setup)
9420          {
9421             srsCfg = ulBwp->srs_Config->choice.setup;
9422
9423             /* Free Resource Set to add/mod list */
9424             if(srsCfg->srs_ResourceSetToAddModList)
9425             {
9426                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
9427                if(rsrcSetList->list.array)
9428                {
9429                   rSetIdx = 0;
9430
9431                   /* Free SRS resource Id list in this SRS resource set */
9432                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
9433                   {
9434                      rsrcIdList =
9435                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
9436
9437                      if(rsrcIdList->list.array)
9438                      {
9439                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
9440                               rsrcIdx++)
9441                         {
9442                            free(rsrcIdList->list.array[rsrcIdx]);
9443                         }
9444                         free(rsrcIdList->list.array);
9445                      }
9446                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
9447                   }
9448
9449                   /* Free resource type info for this SRS resource set */
9450
9451                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
9452
9453                   /* Free memory for each resource set */
9454                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
9455                   {
9456                      free(rsrcSetList->list.array[rSetIdx]);
9457                   }
9458                   free(rsrcSetList->list.array);
9459                }
9460                free(srsCfg->srs_ResourceSetToAddModList);
9461             }
9462
9463             /* Free resource to add/modd list */
9464             if(srsCfg->srs_ResourceToAddModList)
9465             {
9466                resourceList = srsCfg->srs_ResourceToAddModList;
9467                if(resourceList->list.array)
9468                {
9469                   rsrcIdx = 0;
9470
9471                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
9472                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
9473
9474                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
9475                   {
9476                      free(resourceList->list.array[rsrcIdx]);
9477                   }
9478                   free(resourceList->list.array);
9479                }
9480                free(srsCfg->srs_ResourceToAddModList);
9481             }
9482
9483             free(ulBwp->srs_Config->choice.setup);
9484          }
9485          free(ulBwp->srs_Config);
9486       }
9487    }
9488 }
9489 /*******************************************************************
9490 *
9491 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
9492 *
9493 * @details
9494 *
9495 *    Function : freeAperDecodeinitialUplinkBWPConfig
9496 *
9497 *    Functionality: Function to free initialUplinkBWPConfig
9498 *
9499 * @params[in] UplinkConfig_t *ulCfg
9500 * @return void
9501 *
9502 * ****************************************************************/
9503
9504
9505 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
9506 {
9507    BWP_UplinkDedicated_t *ulBwp=NULLP;
9508    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
9509
9510    if(ulCfg->initialUplinkBWP)
9511    {
9512       ulBwp=ulCfg->initialUplinkBWP;
9513       if(ulCfg->firstActiveUplinkBWP_Id)
9514       {
9515          if(ulCfg->pusch_ServingCellConfig)
9516          {
9517             puschCfg=ulCfg->pusch_ServingCellConfig;
9518             if(puschCfg->choice.setup)
9519             {
9520                if(puschCfg->choice.setup->ext1)
9521                {
9522                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
9523                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
9524                   free(puschCfg->choice.setup->ext1);
9525                }
9526                free(puschCfg->choice.setup);
9527             }
9528             free(ulCfg->pusch_ServingCellConfig);
9529          }
9530          free(ulCfg->firstActiveUplinkBWP_Id);
9531       }
9532       freeAperDecodeInitialUlBWPConfig(ulBwp);
9533       free(ulCfg->initialUplinkBWP);
9534    }
9535 }
9536
9537 /*******************************************************************
9538  *
9539  * @brief Function to free DuUeCfg
9540  *
9541  * @details
9542  *
9543  *    Function : freeDuUeCfg
9544  *
9545  *    Functionality: Function to free DuUeCfg
9546  *
9547  * @params[in] DuUeCfg *ueCfg
9548  * @return void
9549  *
9550  * ****************************************************************/
9551 void freeDuUeCfg(UeCtxtActionType actionType, DuUeCfg *ueCfg)
9552 {
9553    uint8_t lcIdx = 0;
9554    uint8_t arrIdx = 0;
9555    SpCellConfig_t *spCellCfg = NULLP;
9556    ServingCellConfig_t *srvCellCfg = NULLP;
9557    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9558    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
9559    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9560    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
9561    struct RLC_Config *rlcConfig = NULLP;
9562    struct LogicalChannelConfig *macLcConfig = NULLP;
9563    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
9564    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
9565    struct TAG_Config *tagConfig = NULLP;
9566    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
9567    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
9568    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
9569    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
9570
9571    if(ueCfg->ueNrCapability)
9572    {
9573       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
9574       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
9575       ueCfg->ueNrCapability = NULLP;
9576    }
9577
9578    if(ueCfg->cellGrpCfg)
9579    {
9580       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
9581       if(rlcBearerList)
9582       {
9583          if(rlcBearerList->list.array)
9584          {
9585             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
9586             {
9587                if(rlcBearerList->list.array[arrIdx])
9588                {
9589                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
9590                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
9591
9592                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
9593                   {
9594                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
9595                   }
9596                   if(rlcConfig)
9597                   {
9598                      if(rlcConfig->choice.am)
9599                      {
9600                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
9601                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
9602                         free(rlcConfig->choice.am);
9603                      }
9604                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
9605                   }
9606                   if(macLcConfig)
9607                   {
9608                      if(macLcConfig->ul_SpecificParameters)
9609                      {
9610                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
9611                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
9612                         free(macLcConfig->ul_SpecificParameters);
9613                      }
9614                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
9615                   }
9616                   free(rlcBearerList->list.array[arrIdx]);
9617                }
9618             }
9619             free(rlcBearerList->list.array);
9620          }
9621          free(cellGrpCfg->rlc_BearerToAddModList);
9622       }
9623
9624       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
9625       if(macCellGrpCfg)
9626       {
9627          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
9628          if(schedulingRequestConfig)
9629          {
9630             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
9631             if(schReqList)
9632             {
9633                if(schReqList->list.array)
9634                {
9635                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
9636                   {
9637                      if(schReqList->list.array[arrIdx])
9638                      {
9639                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
9640                         free(schReqList->list.array[arrIdx]);
9641                      }
9642                   }
9643                   free(schReqList->list.array);
9644                }
9645                free(schedulingRequestConfig->schedulingRequestToAddModList);
9646             }
9647             free(macCellGrpCfg->schedulingRequestConfig);
9648          }
9649          if(macCellGrpCfg->bsr_Config)
9650          {
9651             free(macCellGrpCfg->bsr_Config);
9652          }
9653          tagConfig = macCellGrpCfg->tag_Config;
9654          if(tagConfig)
9655          {
9656             tagList = tagConfig->tag_ToAddModList;
9657             if(tagList)
9658             {
9659                if(tagList->list.array)
9660                {
9661                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
9662                   {
9663                      free(tagList->list.array[arrIdx]);
9664                   }
9665                   free(tagList->list.array);
9666                }
9667                free(tagConfig->tag_ToAddModList);
9668             }
9669             free(tagConfig);
9670          }
9671
9672          phrConfig = macCellGrpCfg->phr_Config;
9673          if(phrConfig)
9674          {
9675             free(phrConfig->choice.setup);
9676             free(phrConfig);
9677          }
9678
9679          free(macCellGrpCfg);
9680       }
9681
9682       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
9683       if(phyCellGrpCfg)
9684       {
9685          free(phyCellGrpCfg->p_NR_FR1);
9686          free(phyCellGrpCfg);
9687       }
9688
9689       spCellCfg = cellGrpCfg->spCellConfig;
9690       if(spCellCfg)
9691       {
9692          if(spCellCfg->servCellIndex)
9693          {
9694             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
9695             {
9696                if(spCellCfg->spCellConfigDedicated)
9697                {
9698                   srvCellCfg = spCellCfg->spCellConfigDedicated;
9699                   if(srvCellCfg->initialDownlinkBWP)
9700                   {
9701                      dlBwp = srvCellCfg->initialDownlinkBWP;
9702                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
9703                      {
9704                         if(srvCellCfg->defaultDownlinkBWP_Id)
9705                         {
9706                            if(srvCellCfg->uplinkConfig)
9707                            {
9708
9709                               if(srvCellCfg->pdsch_ServingCellConfig)
9710                               {
9711                                  pdschCfg=
9712                                     srvCellCfg->pdsch_ServingCellConfig;
9713                                  if(pdschCfg->choice.setup)
9714                                  {
9715
9716                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
9717                                     free(pdschCfg->choice.setup);
9718                                  }
9719
9720                                  free(srvCellCfg->pdsch_ServingCellConfig);
9721                               }
9722
9723                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
9724                               free(srvCellCfg->uplinkConfig);
9725                            }
9726                            free(srvCellCfg->defaultDownlinkBWP_Id);
9727                         }
9728
9729                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
9730                      }
9731                      if(dlBwp->pdcch_Config)
9732                      {
9733                         if(dlBwp->pdsch_Config)
9734                         {
9735                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
9736                            free(dlBwp->pdsch_Config);
9737                         }
9738                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
9739                         free(dlBwp->pdcch_Config);
9740                      }
9741                      free(srvCellCfg->initialDownlinkBWP);
9742                   }
9743
9744                   free(spCellCfg->spCellConfigDedicated);
9745                }
9746                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
9747             }
9748             free(spCellCfg->servCellIndex);
9749          }
9750          free(spCellCfg);
9751       }
9752       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9753       ueCfg->cellGrpCfg = NULLP;
9754    }
9755
9756    if(ueCfg->ambrCfg)
9757    {
9758       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
9759    }
9760
9761    if(actionType != UE_CTXT_CFG_QUERY)
9762    {
9763       for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
9764       {
9765          freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
9766       }
9767    }
9768
9769    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
9770    {
9771       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
9772    }
9773
9774    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
9775    {
9776       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
9777    }
9778 }
9779
9780 /*******************************************************************
9781  *
9782  * @brief Function to free UecontextSetupDb
9783  *
9784  * @details
9785  *
9786  *    Function : freeF1UeDb
9787  *
9788  *    Functionality: Function to free UecontextSetupDb
9789  *
9790  * @params[in] UecontextSetupDb *
9791  * @return void
9792  *
9793  * ****************************************************************/
9794
9795 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
9796 {
9797
9798    if(f1UeDb->dlRrcMsg)
9799    {
9800       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
9801       {
9802         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
9803                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
9804       }
9805       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
9806    }
9807    freeDuUeCfg(f1UeDb->actionType, &f1UeDb->duUeCfg);
9808    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
9809    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
9810 }
9811
9812 /*******************************************************************
9813  *
9814  * @brief Function to build Am cfg Info
9815  *
9816  * @details
9817  *
9818  *    Function : extractRlcAmCfg
9819  *
9820  *    Functionality: Function to build Am cfg Info
9821  *
9822  * @params[in] AmBearerCfg *
9823  *             void *
9824  *
9825  * @return ROK/RFAILED
9826  *
9827  * ****************************************************************/
9828
9829 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
9830 {
9831    if(rlcAmCfg)
9832    {
9833       /* UL AM */
9834       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
9835       {
9836          amCfgToSet->ulAmCfg.snLenUl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->dl_AM_RLC.sn_FieldLength));
9837          /*TODO: Check the timer value when sent by real CU */
9838          amCfgToSet->ulAmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_Reassembly);
9839          amCfgToSet->ulAmCfg.statProhTmr = convertProhibitTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_StatusProhibit);
9840       }
9841
9842       /* DL AM */
9843       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
9844       {
9845          amCfgToSet->dlAmCfg.snLenDl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->ul_AM_RLC.sn_FieldLength));
9846          amCfgToSet->dlAmCfg.pollRetxTmr = covertPollRetxTmrEnumToValue(rlcAmCfg->ul_AM_RLC.t_PollRetransmit);
9847          amCfgToSet->dlAmCfg.pollPdu   = covertPollPduEnumToValue(rlcAmCfg->ul_AM_RLC.pollPDU);
9848          amCfgToSet->dlAmCfg.pollByte  = covertPollByteEnumToValue(rlcAmCfg->ul_AM_RLC.pollByte);
9849          amCfgToSet->dlAmCfg.maxRetxTh = covertMaxRetxEnumToValue(rlcAmCfg->ul_AM_RLC.maxRetxThreshold);
9850       }
9851    }
9852 }
9853
9854 /*******************************************************************
9855  *
9856  * @brief Function to build Um Bi Info
9857  *
9858  * @details
9859  *
9860  *    Function : extractRlcUmBiCfg
9861  *
9862  *    Functionality: Function to build Um Bi Info
9863  *
9864  * @params[in] UmBiDirBearerCfg *
9865  *             void *
9866  *
9867  * @return ROK/RFAILED
9868  *
9869  * ****************************************************************/
9870
9871 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
9872 {
9873    if(rlcBiCfg)
9874    {
9875       /* UL UM BI DIR Cfg */
9876       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
9877       {
9878          umBiCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->dl_UM_RLC.sn_FieldLength));
9879          umBiCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcBiCfg->dl_UM_RLC.t_Reassembly);
9880       }
9881
9882       /* DL UM BI DIR Cfg */
9883       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
9884          umBiCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->ul_UM_RLC.sn_FieldLength));
9885    }
9886 }
9887
9888 /*******************************************************************
9889  *
9890  * @brief Function to build Um Ul Info
9891  *
9892  * @details
9893  *
9894  *    Function : extractRlcUmUlCfg
9895  *
9896  *    Functionality: Function to build Um Ul Info
9897  *
9898  * @params[in] UmUniDirUlBearerCfg *
9899  *             void *
9900  *
9901  * @return ROK/RFAILED
9902  *
9903  * ****************************************************************/
9904
9905 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
9906 {
9907    if(umUlCfg)
9908    {
9909       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
9910       {
9911          umUlCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umUlCfg->dl_UM_RLC.sn_FieldLength));
9912          umUlCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(umUlCfg->dl_UM_RLC.t_Reassembly);
9913       }
9914    }
9915 }
9916
9917 /*******************************************************************
9918  *
9919  * @brief Function to build Um Uni Dl Info
9920  *
9921  * @details
9922  *
9923  *    Function : extractRlcUmDlCfg
9924  *
9925  *    Functionality: Function to build Um Uni Dl Info
9926  *
9927  * @params[in] UmUniDirDlBearerCfg *
9928  *             void *
9929  *
9930  * @return ROK/RFAILED
9931  *
9932  * ****************************************************************/
9933 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
9934 {
9935    if(umDlCfg)
9936    {
9937       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
9938          umDlCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umDlCfg->ul_UM_RLC.sn_FieldLength));
9939    }
9940 }
9941
9942 /*******************************************************************
9943  *
9944  * @brief Function to extractRlcModeCfg
9945  *
9946  * @details
9947  *
9948  *    Function : extractRlcModeCfg
9949  *
9950  *    Functionality: Function to extractRlcModeCfg
9951  *
9952  * @params[in] RLC_Config_t *
9953  *             RlcBearerCfg *
9954  *             void  *
9955  * @return ROK/RFAILED
9956  *
9957  * ****************************************************************/
9958 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
9959 {
9960    if(lcCfg)
9961    {
9962       switch(rlcMode)
9963       {
9964          case RLC_AM :
9965             {
9966                if(lcCfg->choice.am)
9967                {
9968                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
9969                   if(rlcDbCfg->u.amCfg)
9970                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
9971                }
9972                break;
9973             }
9974          case RLC_UM_BI_DIRECTIONAL :
9975             {
9976                if(lcCfg->choice.um_Bi_Directional)
9977                {
9978                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
9979                   if(rlcDbCfg->u.umBiDirCfg)
9980                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
9981                }
9982                break;
9983             }
9984          case RLC_UM_UNI_DIRECTIONAL_UL :
9985             {
9986                if(lcCfg->choice.um_Uni_Directional_DL)
9987                {
9988                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
9989                   if(rlcDbCfg->u.umUniDirUlCfg)
9990                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
9991                }
9992                break;
9993             }
9994          case RLC_UM_UNI_DIRECTIONAL_DL :
9995             {
9996                if(lcCfg->choice.um_Uni_Directional_UL)
9997                {
9998                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
9999                   if(rlcDbCfg->u.umUniDirDlCfg)
10000                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
10001                }
10002                break;
10003             }
10004          default:
10005             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
10006             break;
10007       }
10008    }
10009 }
10010
10011 /*******************************************************************
10012  *
10013  * @brief Function to extract extractUlLcCfg
10014  *
10015  * @details
10016  *
10017  *    Function : extractUlLcCfg
10018  *
10019  *    Functionality: Function to extract extractUlLcCfg
10020  *
10021  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
10022  * @return void
10023  *
10024  * ****************************************************************/
10025
10026 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
10027 {
10028    if(ulLcCfg)
10029    {
10030       if(ulLcCfg->ul_SpecificParameters)
10031       {
10032          f1UlLcCfg->priority = \
10033             ulLcCfg->ul_SpecificParameters->priority;
10034       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
10035       {
10036          f1UlLcCfg->lcGroup = \
10037            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
10038       }
10039       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
10040       {
10041          f1UlLcCfg->schReqId = \
10042            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
10043       }
10044       f1UlLcCfg->pbr = \
10045          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
10046       f1UlLcCfg->bsd = \
10047          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
10048       }
10049    }
10050 }
10051
10052 /*******************************************************************
10053 *
10054 * @brief Function to extract Snssai Cfg Info from CU
10055 *
10056 * @details
10057 *
10058 *    Function : extractDrbSnssaiCfg
10059 *
10060 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
10061 *
10062 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
10063 * @return ROK/RFAILED
10064 *
10065 * ****************************************************************/
10066
10067 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
10068 {
10069    if(!(*snssaiToBeShared))
10070    {
10071       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
10072       if(snssaiToBeShared == NULLP)
10073       {
10074          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
10075          return RFAILED;
10076       }
10077    }
10078    if(RecvSnssai)
10079    {
10080       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
10081       if(RecvSnssai->sD)
10082       {
10083          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
10084       }
10085       else
10086       {
10087          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
10088          return RFAILED;
10089       }
10090    }
10091    return ROK;
10092 }
10093
10094 /*******************************************************************
10095  *
10096  * @brief Function to procRlcLcCfg
10097  *
10098  * @details
10099  *
10100  *    Function : procRlcLcCfg
10101  *
10102  *    Functionality: Function to procRlcLcCfg
10103  *
10104  * @params[in] rbId, lcId, rbType, rlcMod
10105  *             RLC_Config_t *, RlcBearerCfg * ,
10106  * @return void
10107  *
10108  * ****************************************************************/
10109
10110 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
10111    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
10112 {
10113    DRB_Information_t *drbInfo;
10114
10115    lcCfg->rbId   = rbId;
10116    lcCfg->configType = configType;
10117
10118    if(rbType == RB_TYPE_SRB)
10119    {
10120       lcCfg->rbType = RB_TYPE_SRB;
10121       lcCfg->lcId   = rbId;
10122       lcCfg->lcType = LCH_DCCH;
10123       lcCfg->rlcMode = RLC_AM;
10124    }
10125    else if(rbType == RB_TYPE_DRB)
10126    {
10127       lcCfg->rbType = RB_TYPE_DRB;
10128       lcCfg->lcId   = lcId;
10129       lcCfg->lcType = LCH_DTCH;
10130       lcCfg->rlcMode = rlcMode;
10131    }
10132    if(f1RlcCfg) /* rlc mode config recived */
10133    {
10134       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
10135    }
10136    if(qoSInformation != NULLP)
10137    {
10138       if(qoSInformation->present == QoSInformation_PR_choice_extension)
10139       {
10140          if(qoSInformation->choice.choice_extension->value.present ==\
10141                QoSInformation_ExtIEs__value_PR_DRB_Information)
10142          {
10143             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10144             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
10145             {
10146                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
10147                return;
10148             }
10149          }
10150       }
10151    }
10152 }
10153
10154 /*******************************************************************
10155  *
10156  * @brief Fills DrbQos Info received by CU
10157  *
10158  * @details
10159  *
10160  *    Function : extractQosInfo
10161  *
10162  *    Functionality: Fills DrbQos Info received  by CU
10163  *
10164  * @params[in] DrbQosInfo *qosToAdd,
10165  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
10166  * @return void
10167  *
10168  * ****************************************************************/
10169
10170 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
10171 {
10172    uint8_t qosCntIdx = 0;
10173    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
10174
10175    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
10176    qosToAdd->u.nonDyn5Qi.fiveQi     =\
10177                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
10178    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
10179    {
10180       qosToAdd->u.nonDyn5Qi.avgWindow = \
10181                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
10182    }
10183
10184    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume)
10185    {
10186       qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
10187                                               *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
10188    }
10189
10190    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
10191    {
10192       qosToAdd->u.nonDyn5Qi.priorLevel = \
10193                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
10194    }
10195    qosToAdd->ngRanRetPri.priorityLevel = \
10196                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
10197    qosToAdd->ngRanRetPri.preEmptionCap = \
10198                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
10199    qosToAdd->ngRanRetPri.preEmptionVul = \
10200                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
10201    if(qosFlowCfg->gBR_QoS_Flow_Information)
10202    {
10203       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
10204             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
10205             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
10206       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
10207             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
10208             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
10209       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
10210             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
10211             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
10212       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
10213             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
10214             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
10215    }
10216    /*Extracting PDU_SESSION_ID*/
10217    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
10218    if(qosIeExt)
10219    {
10220       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
10221       {
10222          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
10223                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
10224          {
10225             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
10226             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
10227          }
10228       }
10229    }
10230    qosToAdd->ulPduSessAggMaxBitRate = 0;
10231 }
10232
10233 /*******************************************************************
10234  *
10235  * @brief Function to extract GTP Tunnel Info from CU
10236  *
10237  * @details
10238  *
10239  *    Function : extractUpTnlInfo
10240  *
10241  *    Functionality: Function to extract GTP Tunnel Info from CU
10242  *
10243  * @params[in] F1AP message
10244  * @return ROK/RFAILED
10245  *
10246  * ****************************************************************/
10247
10248 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
10249    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
10250 {
10251    uint8_t tnlIdx;
10252    uint32_t ipv4_du = 0;
10253    GTPTunnel_t *gtpTunnel = NULLP;
10254
10255    upTnlInfo->drbId = drbId;
10256    upTnlInfo->configType = configType;
10257 #ifdef O1_ENABLE
10258    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
10259 #else
10260    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
10261 #endif
10262
10263    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
10264    {
10265       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
10266       {
10267          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
10268          {
10269             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
10270             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
10271             if(upTnlInfo->tnlCfg1 == NULLP)
10272             {
10273                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
10274                return RFAILED;
10275             }
10276             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
10277             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
10278             if(gtpTunnel->gTP_TEID.size > 0)
10279             {
10280                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
10281             }
10282          }
10283          break;
10284       }
10285    }
10286    return ROK;
10287 }
10288
10289 /*******************************************************************
10290 *
10291 * @brief Function to extract Drb Qos Cfg Info from CU
10292 *
10293 * @details
10294 *
10295 *    Function : extractDrbQosCfg
10296 *
10297 *    Functionality: Function to extract Drb Qos Cfg Info from CU
10298 *
10299 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
10300 * @return ROK/RFAILED
10301 *
10302 * ****************************************************************/
10303
10304 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
10305 {
10306    if(!macLcToAdd->drbQos)
10307    {
10308       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
10309       if(macLcToAdd->drbQos == NULLP)
10310       {
10311          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
10312          return RFAILED;
10313       }
10314
10315    }
10316    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
10317    {
10318       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
10319       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
10320    }
10321    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
10322    {
10323       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
10324       return RFAILED;
10325    }
10326    return ROK;
10327 }
10328 /*******************************************************************
10329  *
10330  * @brief Function to extract DRB info received from CU
10331  *
10332  * @details
10333  *
10334  *    Function : extractDrbCfg
10335  *
10336  *    Functionality: Function to extract DRB info received from CU
10337  *
10338  * @params[in] F1AP message
10339  * @return void
10340  *
10341  * ****************************************************************/
10342 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
10343 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
10344 {
10345    DRB_Information_t *drbInfo = NULLP;
10346
10347    if(drbItem != NULLP)
10348    {
10349       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
10350       {
10351          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10352          return RFAILED;
10353       }
10354       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10355       {
10356          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
10357          {
10358             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10359             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10360             {
10361                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10362                return RFAILED;
10363             }
10364          }
10365       }
10366    }
10367    else if(drbSetupModItem != NULLP)
10368    {
10369       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
10370       upTnlInfo) != ROK)
10371       {
10372          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10373          return RFAILED;
10374       }
10375       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10376       {
10377          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
10378          QoSInformation_ExtIEs__value_PR_DRB_Information)
10379          {
10380             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10381             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10382             {
10383                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10384                return RFAILED;
10385             }
10386
10387          }
10388       }
10389    }
10390    else if(drbModItem != NULLP)
10391    {
10392       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
10393       upTnlInfo) != ROK)
10394       {
10395          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10396          return RFAILED;
10397       }
10398       if(drbModItem->qoSInformation != NULLP)
10399       {
10400          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
10401          {
10402             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
10403                   QoSInformation_ExtIEs__value_PR_DRB_Information)
10404             {
10405                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10406                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10407                {
10408                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10409                   return RFAILED;
10410                }
10411
10412             }
10413          }
10414       }
10415    }
10416    return ROK;
10417 }
10418
10419 /*******************************************************************
10420  *
10421  * @brief Function to extract RB info received from CU
10422  *
10423  * @details
10424  *
10425  *    Function : extractMacRbCfg
10426  *
10427  *    Functionality: Function to extract RB info received from CU
10428  *
10429  * @params[in] F1AP message
10430  * @return ROK/RFAILED
10431  *
10432  * ****************************************************************/
10433
10434 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
10435 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10436 {
10437    if(drbCfg != NULLP)
10438    {
10439       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
10440       {
10441          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10442          return RFAILED;
10443       }
10444    }
10445    else if(drbSetupModCfg != NULLP)
10446    {
10447       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
10448       {
10449          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10450          return RFAILED;
10451       }
10452    }
10453    else if(drbModCfg != NULLP)
10454    {
10455       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
10456       {
10457          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10458          return RFAILED;
10459       }
10460    }
10461    else
10462    {
10463       lcCfg->drbQos = NULLP;
10464       lcCfg->snssai = NULLP;
10465       if(lcCfg->lcId == SRB2_LCID)
10466          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
10467       else
10468          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
10469    }
10470    if(ulLcCfg)
10471    {
10472       lcCfg->ulLcCfgPres = true;
10473       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
10474    }
10475    else
10476       lcCfg->ulLcCfgPres = false;
10477    return ROK;
10478 }
10479
10480 /*******************************************************************
10481  *
10482  * @brief Function processing LC config info received from CU
10483  *
10484  * @details
10485  *
10486  *    Function : procMacLcCfg
10487  *
10488  *    Functionality: Function processing LC config info received from CU
10489  *
10490  * @params[in] F1AP message
10491  * @return ROK/RFAILED
10492  *
10493  * ****************************************************************/
10494
10495 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
10496 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
10497 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10498 {
10499    uint8_t ret = ROK;
10500
10501    lcCfg->lcId = lcId;
10502    lcCfg->configType = configType;
10503    if(rbType == RB_TYPE_SRB)
10504    {
10505       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
10506    }
10507    else if(rbType == RB_TYPE_DRB)
10508    {
10509       if(drbItem != NULL)
10510         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
10511       else if(drbSetupModItem != NULL)
10512         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
10513       else if(drbModItem != NULL)
10514         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
10515    }
10516    return ret;
10517 }
10518
10519 /*******************************************************************
10520  *
10521  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
10522  *
10523  * @details
10524  *
10525  *    Function : extractRlcCfgToAddMod
10526  *
10527  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
10528  *
10529  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
10530  *             DuUeCfg Pointer
10531  * @return ROK/RFAILED
10532  *
10533  * ****************************************************************/
10534
10535 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
10536 {
10537   uint8_t idx, rbId, lcId, rlcMode, rbType;
10538   RLC_Config_t *f1RlcCfg = NULLP;
10539   LogicalChannelConfig_t *macUlLcCfg = NULLP;
10540
10541   for(idx = 0; idx < lcCfg->list.count; idx++)
10542   {
10543      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
10544      if(lcCfg->list.array[idx]->servedRadioBearer)
10545      {
10546         /* RadioBearer for SRB/DRB */
10547         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10548         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
10549         {
10550            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
10551            rbType = RB_TYPE_SRB;
10552         }
10553         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10554         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
10555         {
10556            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
10557            rbType = RB_TYPE_DRB;
10558         }
10559         else
10560         {
10561            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
10562            return RFAILED;
10563         }
10564         /* MAC UL LC Config */
10565         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
10566         {
10567            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
10568         }
10569      }
10570      else
10571      {
10572         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
10573         return RFAILED;
10574      }
10575      /* RLC Mode Config */
10576      if(lcCfg->list.array[idx]->rlc_Config)
10577      {
10578         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
10579         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
10580      }
10581
10582      /* Filling RLC/MAC Config*/
10583      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
10584      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
10585      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
10586      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
10587      {
10588         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
10589         return RFAILED;
10590      }
10591      (ueCfgDb->numRlcLcs)++;
10592      (ueCfgDb->numMacLcs)++;
10593      DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10594         rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10595   }
10596   //TODO: To send the failure cause in UeContextSetupRsp
10597   return ROK;
10598 }
10599
10600 /*******************************************************************
10601  *
10602  * @brief DeAlloc pdsch serv cell config info
10603  *
10604  * @details
10605  *
10606  *    Function : freeMacPdschServCellInfo
10607  *
10608  *    Functionality: DeAlloc pdsch serv cell config info
10609  *
10610  * @params[in] PdschServCellCfg pointer
10611  * @return void
10612  *
10613  * ****************************************************************/
10614
10615 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
10616 {
10617    if(pdsch->xOverhead)
10618    {
10619       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
10620    }
10621    if(pdsch->codeBlkGrpFlushInd)
10622    {
10623       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
10624    }
10625    if(pdsch->maxCodeBlkGrpPerTb)
10626    {
10627       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
10628    }
10629    if(pdsch->maxMimoLayers)
10630    {
10631       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
10632    }
10633 }
10634
10635 /*******************************************************************
10636  *
10637  * @brief Free Serving cell Info
10638  *
10639  * @details
10640  *
10641  *    Function : freeMacServingCellInfo
10642  *
10643  *    Functionality: Free Serving cell Info
10644  *
10645  * @params[in] ServCellCfgInfo *srvCellCfg
10646  * @return void
10647  *
10648  * ****************************************************************/
10649 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
10650 {
10651    uint8_t timeDomRsrcIdx;
10652
10653    if(srvCellCfg->initDlBwp.pdschPresent)
10654    {
10655       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
10656       {
10657          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
10658             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
10659       }
10660    }
10661
10662    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
10663    if(srvCellCfg->bwpInactivityTmr)
10664    {
10665       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
10666    }
10667
10668    if(srvCellCfg->initUlBwp.pucchPresent)
10669    {
10670       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10671    }
10672 }
10673
10674 /*******************************************************************
10675  *
10676  * @brief Free cell Grp Cfg Info
10677  *
10678  * @details
10679  *
10680  *    Function : freeUeReCfgCellGrpInfo
10681  *
10682  *    Functionality: Free cell Grp Cfg Info
10683  *
10684  * @params[in] MacUeCfg*  duUeCfg
10685  * @return void
10686  *
10687  * ****************************************************************/
10688
10689 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
10690 {
10691    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
10692 }
10693
10694 /*******************************************************************
10695  *
10696  * @brief Fills Reconfig SchReqReConfig
10697  *
10698  * @details
10699  *
10700  *    Function : extractSchReqReConfig
10701  *
10702  *    Functionality: Fills Reconfig SchReqReConfig
10703  *
10704  * @params[in] SchedulingRequestConfig_t *cuSchedReq
10705  *             SchedReqCfg*  macSchedReq
10706  * @return void
10707  *
10708  * ****************************************************************/
10709 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
10710 {
10711    uint8_t schReqIdx = 0;
10712    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
10713    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
10714
10715    if(cuSchedReq->schedulingRequestToAddModList)
10716    {
10717       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
10718       if(schReqListToAdd->list.count)
10719       {
10720          macSchedReq->addModListCount = schReqListToAdd->list.count;
10721          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
10722          {
10723             macSchedReq->addModList[schReqIdx].schedReqId = \
10724                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
10725             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
10726                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
10727             macSchedReq->addModList[schReqIdx].srTransMax    =\
10728                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
10729          }
10730       }
10731    }
10732    /* Scheduling Req To release */
10733    if(cuSchedReq->schedulingRequestToReleaseList)
10734    {
10735       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
10736       if(schReqListToRel->list.count)
10737       {
10738          macSchedReq->relListCount = schReqListToRel->list.count;
10739          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
10740          {
10741             macSchedReq->relList[schReqIdx] = \
10742                *schReqListToRel->list.array[schReqIdx];
10743          }
10744       }
10745    }
10746 }
10747
10748 /*******************************************************************
10749  *
10750  * @brief Fills TagReconfig
10751  *
10752  * @details
10753  *
10754  *    Function : extractTagReconfig
10755  *
10756  *    Functionality: Fills extractTagReconfig
10757  *
10758  * @params[in] TAG_Config_t *cuTagCfg
10759  *             TagCfg *macTagCfg
10760  * @return void
10761  *
10762  * ****************************************************************/
10763
10764 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
10765 {
10766   uint8_t tagIdx = 0;
10767   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
10768   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
10769
10770   /* Tag config to AddMod */
10771   if(cuTagCfg->tag_ToAddModList)
10772   {
10773      tagListToAddMod = cuTagCfg->tag_ToAddModList;
10774      if(tagListToAddMod->list.count)
10775      {
10776         macTagCfg->addModListCount = tagListToAddMod->list.count;
10777         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
10778         {
10779            macTagCfg->addModList[tagIdx].tagId =\
10780               tagListToAddMod->list.array[tagIdx]->tag_Id;
10781            macTagCfg->addModList[tagIdx].timeAlignTimer = \
10782
10783               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
10784         }
10785      }
10786   }
10787   /* Tag config to release */
10788   if(cuTagCfg->tag_ToReleaseList)
10789   {
10790      tagListToRel = cuTagCfg->tag_ToReleaseList;
10791      if(tagListToRel->list.count)
10792      {
10793         macTagCfg->relListCount = tagListToRel->list.count;
10794         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
10795         {
10796            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
10797         }
10798      }
10799   }
10800 }
10801
10802 /*******************************************************************
10803  *
10804  * @brief Fills PdcchCfg received by CU
10805  *
10806  * @details
10807  *
10808  *    Function : extractPdcchCfg
10809  *
10810  *    Functionality: Fills PdcchCfg received  by CU
10811  *
10812  * @params[in] PDCCH_Config_t *cuPdcchCfg,
10813  *             PdcchConfig *duPdcchCfg
10814  * @return void
10815  *
10816  * ****************************************************************/
10817
10818 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
10819 {
10820    uint8_t cRsetIdx = 0;
10821    uint8_t srchSpcIdx = 0;
10822
10823    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
10824    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
10825    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
10826    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
10827
10828
10829    /* Control Resource Set To Add/Mod List */
10830    if(cuPdcchCfg->controlResourceSetToAddModList)
10831    {
10832       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
10833       if(cRsetToAddModList->list.count)
10834       {
10835          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
10836          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
10837          {
10838             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
10839                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
10840             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
10841                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
10842             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
10843                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
10844                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
10845
10846             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
10847                 cRsetToAddModList->list.array[cRsetIdx]->duration;
10848
10849             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
10850                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
10851             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
10852             {
10853                //TODO: handle the case for Interleaved
10854             }
10855             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
10856                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
10857             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
10858             {
10859                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
10860                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
10861             }
10862          }
10863       }
10864    }
10865    /* Control Resource Set To Release List */
10866    if(cuPdcchCfg->controlResourceSetToReleaseList)
10867    {
10868       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
10869       if(cRsetToRelList->list.count)
10870       {
10871          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
10872          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
10873          {
10874             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
10875          }
10876       }
10877    }
10878
10879    /* Search space To Add/Mod List */
10880    if(cuPdcchCfg->searchSpacesToAddModList)
10881    {
10882       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
10883       if(srchSpcToAddModList->list.count)
10884       {
10885          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
10886          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
10887          {
10888             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
10889                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
10890             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
10891                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
10892             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
10893             {
10894                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
10895                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
10896             }
10897             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
10898             {
10899                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
10900                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
10901             }
10902             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
10903             {
10904                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
10905                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
10906                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
10907                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
10908                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
10909                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
10910
10911                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
10912                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
10913
10914                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
10915                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
10916             }
10917             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
10918             {
10919                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
10920                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
10921                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
10922                {
10923                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
10924                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
10925                }
10926
10927             }
10928          }
10929       }
10930    }
10931    /* Search space To Rel List */
10932    if(cuPdcchCfg->searchSpacesToReleaseList)
10933    {
10934       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
10935       if(srchSpcToRelList->list.count)
10936       {
10937          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
10938          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
10939          {
10940             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
10941                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
10942          }
10943       }
10944    }
10945 }
10946
10947 /*******************************************************************
10948  *
10949  * @brief Fills PdschCfg received by CU
10950  *
10951  * @details
10952  *
10953  *    Function : extractPdschCfg
10954  *
10955  *    Functionality: Fills PdschCfg received  by CU
10956  *
10957  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
10958  *                   which we have stored in F1UeContextSetupDb,
10959  *             PdschConfig *macPdschCfg = Used to Store the information which
10960  *                   needs to send in other layer, as well as this can be the variable
10961  *                   which stores the information in DuCb,
10962  *             PdschConfig *storedPdschCfg =  Null in case of sending the
10963  *                   information to other layer else it will have stored pdsch
10964  *                   configuration in copyOfmacUeCfg.
10965  * @return void
10966  *
10967  * ****************************************************************/
10968
10969 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
10970 {
10971    uint8_t timeDomIdx;
10972    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
10973
10974    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
10975    {
10976       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
10977             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
10978       {
10979          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
10980          {
10981             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
10982                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
10983          }
10984       }
10985    }
10986    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
10987    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
10988    {
10989       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
10990       if(timeDomAlloc->present ==\
10991             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
10992       {
10993          if(timeDomAlloc->choice.setup)
10994          {
10995             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
10996             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
10997             {
10998                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
10999                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
11000                {
11001                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
11002                   {
11003                      if(storedPdschCfg)
11004                      {
11005                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
11006                         {
11007                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
11008                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
11009                         }
11010                         else
11011                         {
11012                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
11013                         }
11014                      }
11015                      else
11016                      {
11017                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
11018                      }
11019                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
11020                      {
11021                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
11022                         return;
11023                      }
11024                   }
11025                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
11026                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
11027                }
11028                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
11029                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
11030                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
11031                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
11032             }
11033          }
11034       }
11035    }
11036    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
11037    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
11038       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
11039    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
11040    {
11041       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
11042       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
11043       {
11044          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
11045          {
11046             macPdschCfg->bundlingInfo.StaticBundling.size = \
11047                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
11048          }
11049       }
11050    }
11051    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
11052    {
11053       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
11054    }
11055
11056 }
11057
11058 /*******************************************************************
11059  *
11060  * @brief Fills PdschServingCellCfg received by CU
11061  *
11062  * @details
11063  *
11064  *    Function : extractPdschServingCellCfg
11065  *
11066  *    Functionality: Fills PdschCfg received  by CU
11067  *
11068  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
11069  *             PdschServCellCfg *macUePdschSrvCellCfg
11070  * @return ROK/RFAILED
11071  *
11072  * ****************************************************************/
11073
11074 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
11075 {
11076    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
11077    {
11078       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
11079       {
11080          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
11081          {
11082             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
11083                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
11084          }
11085          else
11086          {
11087             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
11088             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
11089             {
11090                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
11091                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
11092             }
11093             else
11094             {
11095                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
11096                return RFAILED;
11097             }
11098          }
11099          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
11100          {
11101             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
11102                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
11103          }
11104          else
11105          {
11106             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
11107             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
11108             {
11109                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
11110                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
11111             }
11112             else
11113             {
11114                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
11115                return RFAILED;
11116             }
11117          }
11118       }
11119    }
11120    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
11121    {
11122       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
11123    }
11124    if(cuPdschSrvCellCfg->ext1)
11125    {
11126       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
11127       {
11128         if(macUePdschSrvCellCfg->maxMimoLayers)
11129         {
11130            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
11131         }
11132         else
11133         {
11134            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
11135            if(macUePdschSrvCellCfg->maxMimoLayers)
11136            {
11137               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
11138            }
11139            else
11140            {
11141               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
11142               return RFAILED;
11143            }
11144         }
11145       }
11146    }
11147    if(cuPdschSrvCellCfg->xOverhead)
11148    {
11149       if(macUePdschSrvCellCfg->xOverhead)
11150       {
11151          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
11152       }
11153       else
11154       {
11155          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
11156          if(macUePdschSrvCellCfg->xOverhead)
11157          {
11158             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
11159          }
11160          else
11161          {
11162             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
11163             return RFAILED;
11164          }
11165       }
11166    }
11167    return ROK;
11168 }
11169
11170 /*******************************************************************
11171  *
11172  * @brief Fills PuschCfg received by CU
11173  *
11174  * @details
11175  *
11176  *    Function : extractPuschCfg
11177  *
11178  *    Functionality: Fills PuschCfg received  by CU
11179  *
11180  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
11181  *             PuschCfg *macPuschCfg
11182  * @return void
11183  *
11184  * ****************************************************************/
11185
11186 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
11187 {
11188    uint8_t timeDomIdx = 0;
11189    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
11190    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
11191
11192    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
11193    {
11194       if(cuPuschCfg->choice.setup)
11195       {
11196          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
11197          {
11198              macPuschCfg->dataScramblingId = \
11199                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
11200          }
11201          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
11202          {
11203             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
11204             {
11205                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
11206                {
11207                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
11208                   if(dmrsUlCfg->dmrs_AdditionalPosition)
11209                   {
11210                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
11211                         *(dmrsUlCfg->dmrs_AdditionalPosition);
11212                   }
11213                   if(dmrsUlCfg->transformPrecodingDisabled)
11214                   {
11215                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
11216                      {
11217                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
11218                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
11219                      }
11220                   }
11221                }
11222             }
11223          }
11224          /*Res Alloc Type for UL */
11225          if(cuPuschCfg->choice.setup->resourceAllocation)
11226          {
11227             macPuschCfg->resourceAllocType = \
11228                cuPuschCfg->choice.setup->resourceAllocation;
11229          }
11230          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
11231          {
11232             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
11233             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
11234             {
11235                if(timeDomAllocList->choice.setup)
11236                {
11237                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
11238                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
11239                   {
11240                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
11241                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
11242                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
11243                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
11244                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
11245                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
11246                   }
11247                }
11248             }
11249          }
11250          if(cuPuschCfg->choice.setup->transformPrecoder)
11251             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
11252       }
11253    }
11254 }
11255
11256 /*******************************************************************
11257  *
11258  * @brief Function to fill pucch Power Control
11259  *
11260  * @details
11261  *
11262  *    Function : extractPucchPowerControl
11263  *
11264  *    Functionality: Function to fill pucch Power Control
11265  *
11266  * @params[in] PucchPowerControl *pwrCtrl,
11267  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
11268  * @return void
11269  *
11270  * ****************************************************************/
11271
11272 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
11273 {
11274    uint8_t arrIdx;
11275
11276    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
11277       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
11278    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
11279       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
11280    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
11281       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
11282    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
11283       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
11284    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
11285       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
11286    if(cuPwrCtrlCfg->p0_Set)
11287    {
11288       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
11289       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
11290       {
11291          pwrCtrl->p0Set[arrIdx].p0PucchId =\
11292             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
11293          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
11294             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
11295       }
11296    }
11297    if(cuPwrCtrlCfg->pathlossReferenceRSs)
11298    {
11299       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
11300       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
11301       {
11302          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
11303             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
11304       }
11305    }
11306 }
11307
11308  /*******************************************************************
11309  *
11310  * @brief Function to extractResrcSetToAddModList sent by CU
11311  *
11312  * @details
11313  *
11314  *    Function : extractResrcSetToAddModList
11315  *
11316  *    Functionality: Fucntion to extractResrcSetToAddModList
11317  *
11318  * @params[in] PucchResrcSetCfg pointer,
11319  *             struct PUCCH_Config__resourceSetToAddModList pointer
11320  * @return void
11321  *
11322  * ****************************************************************/
11323
11324 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
11325 {
11326    uint8_t arrIdx, rsrcListIdx;
11327
11328    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
11329    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
11330    {
11331       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
11332          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
11333       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
11334          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
11335       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
11336       {
11337          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
11338             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
11339       }
11340
11341       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
11342       {
11343          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
11344             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
11345       }
11346       else
11347       {
11348          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
11349       }
11350    }
11351 }/* End of extractResrcSetToAddModList */
11352
11353 /*******************************************************************
11354  *
11355  * @brief Fills extractResrcToAddModList sent by CU
11356  *
11357  * @details
11358  *
11359  *    Function : extractResrcToAddModList
11360  *
11361  *    Functionality: Fills extractResrcToAddModList
11362  *
11363  * @params[in] PucchResrcCfg pointer,
11364  *             struct PUCCH_Config__resourceToAddModList pointer
11365  * @return ROk/RFAILED
11366  *
11367  * ****************************************************************/
11368
11369 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
11370 {
11371    uint8_t arrIdx;
11372
11373    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
11374    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
11375    {
11376       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
11377         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
11378       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
11379         cuResrcList->list.array[arrIdx]->startingPRB;
11380       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
11381       {
11382          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
11383            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
11384       }
11385       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
11386       {
11387          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
11388            *cuResrcList->list.array[arrIdx]->secondHopPRB;
11389       }
11390       /* PUCCH RSRC FORMAT */
11391       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
11392       {
11393          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
11394          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
11395          {
11396             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
11397             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
11398             {
11399                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
11400                return RFAILED;
11401             }
11402             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
11403                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
11404             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
11405                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
11406             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
11407                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
11408          }
11409       }
11410       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
11411       {
11412          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
11413          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
11414          {
11415             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
11416             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
11417             {
11418                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
11419                return RFAILED;
11420             }
11421             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
11422                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
11423             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
11424                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
11425             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
11426                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
11427             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
11428                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
11429          }
11430       }
11431       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
11432       {
11433          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
11434          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
11435          {
11436             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
11437             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
11438             {
11439                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
11440                return RFAILED;
11441             }
11442             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
11443                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
11444             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
11445                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
11446             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
11447                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
11448          }
11449       }
11450       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
11451       {
11452          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
11453          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
11454          {
11455             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
11456             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
11457             {
11458                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
11459                return RFAILED;
11460             }
11461             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
11462                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
11463             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
11464                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
11465             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
11466                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
11467          }
11468       }
11469       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
11470       {
11471          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
11472          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
11473          {
11474             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
11475             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
11476             {
11477                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
11478                return RFAILED;
11479             }
11480             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
11481                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
11482             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
11483                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
11484             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
11485                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
11486             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
11487                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
11488          }
11489       }
11490    }
11491    return ROK;
11492
11493 }/* End of extractResrcToAddModList */
11494
11495 /*******************************************************************
11496  *
11497  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
11498  *
11499  * @details
11500  *
11501  *    Function : fillPucchSchedReqPeriodAndOffset
11502  *
11503  *    Functionality: To fillPucchSchedReqPeriodAndOffset
11504  *
11505  * @params[in] macPeriodicty,
11506  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
11507  * @return void
11508  *
11509  * ****************************************************************/
11510
11511 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
11512    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
11513 {
11514    macPeriodicty = cuPeriodicty->present;
11515    switch(macPeriodicty)
11516    {
11517       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
11518          {
11519             macOffset     = cuPeriodicty->choice.sym2;
11520             break;
11521          }
11522       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
11523          {
11524             macOffset     = cuPeriodicty->choice.sym6or7;
11525             break;
11526          }
11527       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
11528          {
11529             macOffset     = cuPeriodicty->choice.sl1;
11530             break;
11531          }
11532       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
11533          {
11534             macOffset = cuPeriodicty->choice.sl2;
11535             break;
11536          }
11537       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
11538          {
11539             macOffset = cuPeriodicty->choice.sl4;
11540             break;
11541          }
11542       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
11543          {
11544             macOffset = cuPeriodicty->choice.sl5;
11545             break;
11546          }
11547       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
11548          {
11549             macOffset = cuPeriodicty->choice.sl8;
11550             break;
11551          }
11552       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
11553          {
11554             macOffset = cuPeriodicty->choice.sl10;
11555             break;
11556          }
11557       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
11558          {
11559             macOffset = cuPeriodicty->choice.sl16;
11560             break;
11561          }
11562       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
11563          {
11564             macOffset = cuPeriodicty->choice.sl20;
11565             break;
11566          }
11567       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
11568          {
11569             macOffset = cuPeriodicty->choice.sl40;
11570             break;
11571          }
11572       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
11573          {
11574             macOffset = cuPeriodicty->choice.sl80;
11575             break;
11576          }
11577       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
11578          {
11579             macOffset = cuPeriodicty->choice.sl160;
11580             break;
11581          }
11582       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
11583          {
11584             macOffset = cuPeriodicty->choice.sl320;
11585             break;
11586          }
11587       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
11588          {
11589             macOffset = cuPeriodicty->choice.sl640;
11590             break;
11591          }
11592       default :
11593          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
11594    }
11595 }
11596
11597 /*******************************************************************
11598  *
11599  * @brief Function to extractPucchFormatCfg sent by CU
11600  *
11601  * @details
11602  *
11603  *    Function : extractPucchFormatCfg
11604  *
11605  *    Functionality: Function to extractPucchFormatCfg
11606  *
11607  * @params[in] PucchFormatCfg pointer,
11608  *             PUCCH_FormatConfig_t pointer
11609  * @return void
11610  *
11611  * ****************************************************************/
11612
11613 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
11614  {
11615     if(cuFormatCfg->interslotFrequencyHopping)
11616        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
11617     if(cuFormatCfg->additionalDMRS)
11618        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
11619     if(cuFormatCfg->maxCodeRate)
11620        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
11621     if(cuFormatCfg->nrofSlots)
11622        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
11623     if(cuFormatCfg->pi2BPSK)
11624        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
11625     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
11626        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
11627  }/* End of extractPucchFormatCfg */
11628
11629 /*******************************************************************
11630  *
11631  * @brief Function to extractSchedReqCfgToAddMod sent by CU
11632  *
11633  * @details
11634  *
11635  *    Function : extractSchedReqCfgToAddMod
11636  *
11637  *    Functionality: Function to extractSchedReqCfgToAddMod
11638  *
11639  * @params[in] PucchSchedReqCfg pointer,
11640  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
11641  * @return void
11642  *
11643  * ****************************************************************/
11644
11645 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
11646 {
11647    uint8_t arrIdx;
11648
11649    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
11650    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
11651    {
11652       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
11653          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
11654       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
11655          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
11656       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
11657       {
11658          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
11659             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
11660       }
11661       if(cuSchedReqList->list.array[arrIdx]->resource)
11662       {
11663          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
11664             *cuSchedReqList->list.array[arrIdx]->resource;
11665       }
11666    }
11667
11668 }/* End of extractSchedReqCfgToAddMod */
11669
11670  /*******************************************************************
11671  *
11672  * @brief Fills PucchCfg received by CU
11673  *
11674  * @details
11675  *
11676  *    Function : extractPucchCfg
11677  *
11678  *    Functionality: Fills PucchCfg received  by CU
11679  *
11680  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
11681  *                is send by CU, which we have stored in F1UeContextSetupDb,
11682  *             PucchCfg *macPucchCfg = Used to Store the information which
11683  *                needs to send in other layer, as well as this can be the variable
11684  *                which stores the information in DuCb,
11685  *             PucchCfg *storedPucchCfg = Null in case of sending the
11686  *                information to other layer else it will have Pucch Cfg which
11687  *                we have stored in copyOfmacUeCfg.
11688  * @return ROK/RFAILED
11689  *
11690  * ****************************************************************/
11691
11692 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
11693 PucchCfg *storedPucchCfg)
11694 {
11695    uint8_t arrIdx;
11696
11697    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
11698    {
11699       if(cuPucchCfg->choice.setup)
11700       {
11701          /* Resource Set Cfg */
11702          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
11703          {
11704             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
11705             if(macPucchCfg->resrcSet == NULLP)
11706             {
11707                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
11708                return RFAILED;
11709             }
11710             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
11711             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
11712          }
11713
11714          /* Resource Cfg */
11715          if(cuPucchCfg->choice.setup->resourceToAddModList)
11716          {
11717             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
11718             if(macPucchCfg->resrc == NULLP)
11719             {
11720                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
11721                return RFAILED;
11722             }
11723             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
11724             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
11725          }
11726
11727          /* Format 1 Cfg */
11728          if(cuPucchCfg->choice.setup->format1)
11729          {
11730             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
11731             if(macPucchCfg->format1 == NULLP)
11732             {
11733                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
11734                return RFAILED;
11735             }
11736             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
11737             extractPucchFormatCfg(macPucchCfg->format1,\
11738                cuPucchCfg->choice.setup->format1->choice.setup);
11739          }
11740
11741          /* Format 2 Cfg */
11742          if(cuPucchCfg->choice.setup->format2)
11743          {
11744             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
11745             if(macPucchCfg->format2 == NULLP)
11746             {
11747                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
11748                return RFAILED;
11749             }
11750             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
11751             extractPucchFormatCfg(macPucchCfg->format2,\
11752                cuPucchCfg->choice.setup->format2->choice.setup);
11753          }
11754
11755          /* Format 3 Cfg */
11756          if(cuPucchCfg->choice.setup->format3)
11757          {
11758             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
11759             if(macPucchCfg->format3 == NULLP)
11760             {
11761                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
11762                return RFAILED;
11763             }
11764             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
11765             extractPucchFormatCfg(macPucchCfg->format3,\
11766                cuPucchCfg->choice.setup->format3->choice.setup);
11767          }
11768
11769          /* Format 4 Cfg */
11770          if(cuPucchCfg->choice.setup->format4)
11771          {
11772             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
11773             if(macPucchCfg->format4 == NULLP)
11774             {
11775                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
11776                return RFAILED;
11777             }
11778             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
11779             extractPucchFormatCfg(macPucchCfg->format4,\
11780                cuPucchCfg->choice.setup->format4->choice.setup);
11781          }
11782
11783          /* Sched Req List */
11784          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
11785          {
11786             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
11787             if(macPucchCfg->schedReq == NULLP)
11788             {
11789                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
11790                return RFAILED;
11791             }
11792             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
11793             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
11794             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
11795          }
11796
11797          /*TODO: Add support for  Spatial Info */
11798
11799          /* MultiCsiCfg */
11800          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
11801          {
11802             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
11803             if(macPucchCfg->multiCsiCfg == NULLP)
11804             {
11805                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
11806                return RFAILED;
11807             }
11808             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
11809             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
11810             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
11811             {
11812                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
11813                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
11814             }
11815          }
11816
11817          /* Dl_DataToUL_ACK */
11818          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
11819     {
11820        if(storedPucchCfg)
11821        {
11822           if(storedPucchCfg->dlDataToUlAck)
11823           {
11824              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
11825           }
11826           else
11827           {
11828             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
11829           }
11830        }
11831        else
11832        {
11833           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
11834        }
11835        if(macPucchCfg->dlDataToUlAck == NULLP)
11836        {
11837           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
11838           return RFAILED;
11839        }
11840        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
11841        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
11842        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
11843        {
11844           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
11845           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
11846        }
11847          }
11848
11849          /* Power Control */
11850          if(cuPucchCfg->choice.setup->pucch_PowerControl)
11851          {
11852             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
11853             if(macPucchCfg->powerControl == NULLP)
11854             {
11855                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
11856                return RFAILED;
11857             }
11858             extractPucchPowerControl(macPucchCfg->powerControl,\
11859                cuPucchCfg->choice.setup->pucch_PowerControl);
11860          }
11861       }
11862    }
11863    return ROK;
11864 }
11865
11866 /*******************************************************************
11867  *
11868  * @brief Fills ServingCellReconfig received by CU
11869  *
11870  * @details
11871  *
11872  *    Function : extractSpCellDedicatedCfg
11873  *
11874  *    Functionality: Fills ServingCellReconfig received  by CU
11875  *
11876  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
11877  *                  CU, which we have stored in F1UeContextSetupDb,
11878  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
11879  *                  which  needs to send in other layer, as well as this can be the
11880  *                  variable which stores the information in DuCb,
11881  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
11882  *                  information to other layer else it will have ServCellCfgInfo which
11883  *                  we have stored in copyOfmacUeCfg.
11884  * @return ROK/RFAILD
11885  *
11886  * ****************************************************************/
11887 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
11888 ServCellCfgInfo *storedSrvCellCfg)
11889 {
11890    uint8_t ret = ROK;
11891    BWP_DownlinkDedicated_t *dlBwp = NULLP;
11892    BWP_UplinkDedicated_t   *ulBwp = NULLP;
11893
11894    if(cuSrvCellCfg->initialDownlinkBWP)
11895    {
11896       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
11897       if(dlBwp->pdcch_Config)
11898       {
11899          if(dlBwp->pdcch_Config->choice.setup)
11900          {
11901             macSrvCellCfg->initDlBwp.pdcchPresent = true;
11902             if(storedSrvCellCfg)
11903             {
11904                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
11905                {
11906                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11907                }
11908                else
11909                {
11910                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11911                }
11912             }
11913             else
11914             {
11915                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11916             }
11917          }
11918       }
11919       if(dlBwp->pdsch_Config)
11920       {
11921          if(dlBwp->pdsch_Config->choice.setup)
11922          {
11923             macSrvCellCfg->initDlBwp.pdschPresent = true;
11924
11925             if(storedSrvCellCfg)
11926             {
11927                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
11928                {
11929                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
11930                }
11931                else
11932                {
11933                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
11934                         &storedSrvCellCfg->initDlBwp.pdschCfg);
11935                }
11936             }
11937             else
11938             {
11939                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
11940             }
11941          }
11942       }
11943    }
11944    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
11945       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
11946    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
11947       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
11948    if(cuSrvCellCfg->bwp_InactivityTimer)
11949    {
11950       if(macSrvCellCfg->bwpInactivityTmr)
11951       {
11952          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
11953       }
11954       else
11955       {
11956          macSrvCellCfg->bwpInactivityTmr = NULLP;
11957          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
11958          if(macSrvCellCfg->bwpInactivityTmr)
11959          {
11960             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
11961          }
11962          else
11963          {
11964             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
11965             return RFAILED;
11966          }
11967       }
11968    }
11969    if(cuSrvCellCfg->pdsch_ServingCellConfig)
11970    {
11971       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
11972       {
11973          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
11974          if(ret == RFAILED)
11975          {
11976             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
11977             return RFAILED;
11978          }
11979       }
11980    }
11981    if(cuSrvCellCfg->uplinkConfig)
11982    {
11983       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
11984       {
11985          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
11986          if(ulBwp->pusch_Config)
11987          {
11988             macSrvCellCfg->initUlBwp.puschPresent = true;
11989             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
11990          }
11991          if(ulBwp->pucch_Config)
11992          {
11993             macSrvCellCfg->initUlBwp.pucchPresent = true;
11994             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
11995             if(storedSrvCellCfg)
11996             {
11997                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
11998                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
11999                else
12000                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
12001                   &storedSrvCellCfg->initUlBwp.pucchCfg);
12002             }
12003             else
12004             {
12005                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
12006             }
12007          }
12008       }
12009       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
12010          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
12011    }
12012    return ret;
12013 }
12014
12015 #ifdef NR_DRX
12016
12017 /*******************************************************************
12018  *
12019  * @brief fill long cycle offset value of drx in UE structure
12020  *
12021  * @details
12022  *
12023  *    Function : fillLongCycleOffsetValueInUeDb
12024  *
12025  *    Functionality: fill long cycle offset value of drx in UE structure
12026  *
12027  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
12028  * struct DRX_ConfigRrc__drx_LongCycleStartOffset drx_LongCycleStartOffset
12029  *
12030  * @return ROK     - success
12031  *         RFAILED - failure
12032  *
12033  * ****************************************************************/
12034 void fillLongCycleOffsetValueInUeDb(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__drx_LongCycleStartOffset  *drx_LongCycleStartOffset)
12035 {
12036
12037    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = convertLongDrxCycleLengthEnumToValue(drx_LongCycleStartOffset->present);
12038    switch(drx_LongCycleStartOffset->present)
12039    {
12040       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
12041          {
12042             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms10;
12043             break;
12044          }
12045       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
12046          {
12047             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms20;
12048             break;
12049          }
12050       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
12051          {
12052             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms32;
12053             break;
12054          }
12055       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
12056         {
12057             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms40;
12058             break;
12059          }
12060       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
12061          {
12062             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms60;
12063             break;
12064          }
12065       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
12066          {
12067             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms64;
12068             break;
12069          }
12070       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
12071          {
12072             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms70;
12073             break;
12074          }
12075       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
12076          {
12077             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms80;
12078             break;
12079          }
12080       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
12081          {
12082             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms128;
12083             break;
12084          }
12085       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
12086          {
12087             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms160;
12088             break;
12089          }
12090       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
12091          {
12092             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms256;
12093             break;
12094          }
12095       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
12096          {
12097             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms320;
12098             break;
12099          }
12100       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
12101          {
12102             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms512;
12103             break;
12104          }
12105       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
12106          {
12107             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms640;
12108             break;
12109          }
12110       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
12111          {
12112             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms1024;
12113             break;
12114          }
12115       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
12116          {
12117             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms1280;
12118             break;
12119          }
12120       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
12121          {
12122             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms2048;
12123             break;
12124          }
12125       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
12126          {
12127             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms2560;
12128             break;
12129          }
12130        case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
12131          {
12132             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms5120;
12133             break;
12134          }
12135       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
12136          {
12137             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms10240;
12138             break;
12139          }
12140       default :
12141          break;
12142    }
12143 }
12144
12145 /*******************************************************************
12146  *
12147  * @brief Fills drx configuration structure with the help of drx_ConfigRrc
12148  *which recive from CU or storedDrxCfg which is already stored
12149  *
12150  * @details
12151  *
12152  *    Function : extractDrxConfiguration
12153  *
12154  *    Functionality: Fills Reconfig Cell group Info received by CU
12155  *
12156  * @params[in] cuMacCellGrpDrxConfig  = MAC_CellGroupConfig__drx_ConfigRrc information which
12157  *                       is send by CU, which we have stored in F1UeContextSetupDb
12158  *             DrxCfg * drxCfg  = Used to Store the information,
12159  *                      which needs to send in other layer, as well as this can be
12160  *                      the variable which stores the information in DuCb,
12161  *             DrxCfg *storedDrxCfg = Null in case of sending the
12162  *                      information to other layer else it will have the drx information
12163  *                      stored in the copyOfmacUeCfg which we have stored in F1UeContextSetupDb.
12164  *
12165  * @return void
12166  *
12167  * ****************************************************************/
12168 void extractDrxConfiguration(struct MAC_CellGroupConfig__drx_ConfigRrc *cuMacCellGrpDrxConfig, DrxCfg * drxCfg, DrxCfg *storedDrxCfg)
12169 {
12170    struct DRX_ConfigRrc *cuDrxConfig;
12171
12172    if(storedDrxCfg)
12173    {
12174       memcpy(drxCfg, storedDrxCfg, sizeof(DrxCfg));
12175    }
12176    else
12177    {
12178       if(cuMacCellGrpDrxConfig)
12179       {
12180          switch(cuMacCellGrpDrxConfig->present)
12181          {
12182             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
12183                break;
12184
12185             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
12186                {
12187                   cuDrxConfig = cuMacCellGrpDrxConfig->choice.setup;
12188                   if(cuDrxConfig)
12189                   {
12190                      switch(cuDrxConfig->drx_onDurationTimer.present)
12191                      {
12192                         case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
12193                            break;
12194                         case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
12195                            {
12196                               drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
12197                               drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=convertOnDurationTimerMilliSecondsEnumToValue(cuDrxConfig->\
12198                               drx_onDurationTimer.choice.milliSeconds);
12199                               break;
12200                            }
12201                         case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
12202                            {
12203                               drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
12204                               drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = cuDrxConfig->drx_onDurationTimer.choice.subMilliSeconds;
12205                               break;
12206                            }
12207                      }
12208                   }
12209                   fillLongCycleOffsetValueInUeDb(&drxCfg->drxLongCycleStartOffset, &cuDrxConfig->drx_LongCycleStartOffset);
12210                   drxCfg->drxInactivityTimer = convertDrxInactivityTimerEnumToValue(cuDrxConfig->drx_InactivityTimer);
12211                   drxCfg->drxHarqRttTimerDl = cuDrxConfig->drx_HARQ_RTT_TimerDL;
12212                   drxCfg->drxHarqRttTimerUl = cuDrxConfig->drx_HARQ_RTT_TimerUL;
12213                   drxCfg->drxRetransmissionTimerDl = convertDrxRetransmissionTimerDlEnumToValue(cuDrxConfig->drx_RetransmissionTimerDL);
12214                   drxCfg->drxRetransmissionTimerUl = convertDrxRetransmissionTimerUlEnumToValue(cuDrxConfig->drx_RetransmissionTimerUL);
12215                   drxCfg->drxSlotOffset = cuDrxConfig->drx_SlotOffset;
12216                   if(cuDrxConfig->shortDRX)
12217                   {
12218                      drxCfg->shortDrxPres=true;
12219                      drxCfg->shortDrx.drxShortCycle = convertShortDrxCycleLengthEnumToValue(cuDrxConfig->shortDRX->drx_ShortCycle);
12220                      drxCfg->shortDrx.drxShortCycleTimer = cuDrxConfig->shortDRX->drx_ShortCycleTimer;
12221                   }
12222                   else
12223                      drxCfg->shortDrxPres=false;
12224
12225                   break;
12226                }
12227
12228             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
12229                break;
12230          }
12231       }
12232    }
12233 }
12234 #endif
12235
12236 /*******************************************************************
12237  *
12238  * @brief Fills Reconfig Cell group Info received by CU
12239  *
12240  * @details
12241  *
12242  *    Function : extractUeReCfgCellInfo
12243  *
12244  *    Functionality: Fills Reconfig Cell group Info received by CU
12245  *
12246  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
12247  *                       is send by CU, which we have stored in F1UeContextSetupDb
12248  *             MacUeCfg *MacUeCfg = Used to Store the information,
12249  *                      which needs to send in other layer, as well as this can be
12250  *                      the variable which stores the information in DuCb,
12251  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
12252  *                      information to other layer else it will have copyOfmacUeCfg
12253  *                      which we have stored in F1UeContextSetupDb.
12254  *
12255  * @return ROK/RFAILED
12256  *
12257  * ****************************************************************/
12258 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
12259 {
12260    uint8_t ret = ROK;
12261    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
12262    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
12263    SpCellConfig_t            *spcellCfg = NULLP;
12264    ServingCellConfig_t       *servCellCfg = NULLP;
12265
12266    if(cellGrp)
12267    {
12268       /* Fill MacCell Group Reconfig  */
12269       if(cellGrp->mac_CellGroupConfig)
12270       {
12271          macUeCfg->macCellGrpCfgPres = true;
12272          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
12273
12274 #ifdef NR_DRX
12275          if(macCellGroup->drx_ConfigRrc)
12276          {
12277             if(storedMacUeCfg)
12278             {
12279                if(!storedMacUeCfg->macCellGrpCfgPres)
12280                {
12281                   extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg,NULL);
12282                }
12283                else
12284                {
12285                   extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg, &storedMacUeCfg->macCellGrpCfg.drxCfg);
12286                }
12287             }
12288             else
12289             {
12290                extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg,NULL);
12291             }
12292          }
12293 #endif
12294
12295          if(macCellGroup->schedulingRequestConfig)
12296          {
12297             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
12298          }
12299          if(macCellGroup->tag_Config)
12300          {
12301             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
12302          }
12303          if(macCellGroup->bsr_Config)
12304          {
12305             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
12306             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
12307             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
12308             {
12309                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
12310                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
12311             }
12312          }
12313          if(macCellGroup->phr_Config)
12314          {
12315             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
12316             {
12317                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
12318                if(macCellGroup->phr_Config->choice.setup)
12319                {
12320                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
12321                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
12322                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
12323                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
12324                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
12325                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
12326                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
12327                   macCellGroup->phr_Config->choice.setup->multiplePHR;
12328                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
12329                   macCellGroup->phr_Config->choice.setup->dummy;
12330                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
12331                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
12332                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
12333                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
12334                }
12335             }
12336          }
12337       }
12338       /* Fill Physical Cell Group Reconfig */
12339       if(cellGrp->physicalCellGroupConfig)
12340       {
12341          macUeCfg->phyCellGrpCfgPres = true;
12342          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
12343          if(phyCellGrpCfg->p_NR_FR1)
12344          {
12345             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
12346                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
12347          }
12348          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
12349       }
12350       /* Fill SpCell Reconfig */
12351       if(cellGrp->spCellConfig)
12352       {
12353          macUeCfg->spCellCfgPres = true;
12354          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
12355          if(spcellCfg->servCellIndex)
12356          {
12357             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
12358          }
12359          /* Fill Serving cell Reconfig info */
12360          if(cellGrp->spCellConfig->spCellConfigDedicated)
12361          {
12362             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
12363             if(storedMacUeCfg)
12364             {
12365                if(!storedMacUeCfg->spCellCfgPres)
12366                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
12367                else
12368                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
12369                         &storedMacUeCfg->spCellCfg.servCellCfg);
12370             }
12371             else
12372             {
12373                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
12374             }
12375             if(ret == RFAILED)
12376             {
12377                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
12378             }
12379          }
12380       }
12381    }
12382    return ret;
12383 }
12384 /*******************************************************************
12385 *
12386 * @brief free the memory allocated by decoder
12387 *
12388 * @details
12389 *
12390 *    Function : freeAperDecodeNrcgi
12391 *
12392 *    Functionality: Free Nrcgi values
12393 *
12394 * @params[in] NRCGI_t *nrcgi
12395 * @return void
12396 *
12397 * ****************************************************************/
12398
12399
12400 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
12401 {
12402     if(nrcgi->pLMN_Identity.buf != NULLP)
12403     {
12404        free(nrcgi->pLMN_Identity.buf);
12405     }
12406     if(nrcgi->nRCellIdentity.buf != NULLP)
12407     {
12408        free(nrcgi->nRCellIdentity.buf);
12409     }
12410 }
12411 /*******************************************************************
12412 *
12413 * @brief free the memory allocated by decoder
12414 *
12415 * @details
12416 *
12417 *    Function : freeAperDecodeCuToDuInfo
12418 *
12419 *    Functionality:  Free Cu To Du Information
12420 *
12421 * @params[in] CUtoDURRCInformation_t *rrcMsg
12422 * @return void
12423 *
12424 * ****************************************************************/
12425
12426
12427 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
12428 {
12429    uint8_t ieIdx =0;
12430    uint8_t arrIdx =0;
12431
12432    if(rrcMsg->uE_CapabilityRAT_ContainerList)
12433    {
12434       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
12435          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
12436       free(rrcMsg->uE_CapabilityRAT_ContainerList);
12437    }
12438
12439    if(rrcMsg->iE_Extensions)
12440    {
12441       if(rrcMsg->iE_Extensions->list.array)
12442       {
12443          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
12444          {
12445             if(rrcMsg->iE_Extensions->list.array[ieIdx])
12446             {
12447                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
12448                {
12449                   case ProtocolIE_ID_id_CellGroupConfig:
12450                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
12451                      {
12452                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
12453                      }
12454                      break;
12455                   default:
12456                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
12457                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
12458                      break;
12459                }
12460             }
12461          }
12462          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
12463          {
12464             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
12465          }
12466          free(rrcMsg->iE_Extensions->list.array);
12467
12468       }
12469
12470       free(rrcMsg->iE_Extensions);
12471    }
12472 }
12473 /*******************************************************************
12474 *
12475 * @brief free the memory allocated by decoder
12476 *
12477 * @details
12478 *
12479 *    Function : freeAperDecodeSplCellList
12480 *
12481 *    Functionality: Free Spl Cell List
12482                     where memory allocated by aper_decoder
12483 *
12484 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
12485 * @return void
12486 *
12487 * ****************************************************************/
12488
12489
12490 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
12491 {
12492     uint8_t  cellIdx =0;
12493
12494     if(spCellLst->list.array != NULLP)
12495     {
12496        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
12497        {
12498           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
12499           {
12500              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
12501           }
12502           if(spCellLst->list.array[cellIdx]!=NULLP)
12503           {
12504              free(spCellLst->list.array[cellIdx]);
12505           }
12506        }
12507        free(spCellLst->list.array);
12508     }
12509 }
12510 /*******************************************************************
12511 *
12512 * @brief free the memory allocated by decoder
12513 *
12514 * @details
12515 *
12516 *    Function : freeAperDecodeSRBSetup
12517 *
12518 *    Functionality: added free part for the memory allocated by aper_decoder
12519 *
12520 * @params[in] SRBs_ToBeSetup_List_t *srbSet
12521 * @return void
12522 *
12523 ****************************************************************/
12524
12525
12526 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
12527 {
12528     uint8_t srbIdx =0;
12529     if(srbSet->list.array != NULLP)
12530     {
12531        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
12532        {
12533           if(srbSet->list.array[srbIdx]!=NULLP)
12534           {
12535              free(srbSet->list.array[srbIdx]);
12536           }
12537        }
12538        free(srbSet->list.array);
12539     }
12540 }
12541
12542 /*******************************************************************
12543 *
12544 * @brief free the memory allocated by decoder
12545 *
12546 * @details
12547 *
12548 *    Function : freeAperDecodeULTnlInfo
12549 *
12550 *    Functionality: added free part for the memory allocated by aper_decoder
12551 *
12552 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12553 * @return void
12554 *
12555 * ****************************************************************/
12556
12557
12558 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12559 {
12560    uint8_t ulIdx=0;
12561    if(ulInfo->list.array != NULLP)
12562    {
12563       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
12564       {
12565          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
12566          {
12567             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
12568             {
12569                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12570                      transportLayerAddress.buf != NULLP)
12571                {
12572                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
12573                         !=NULLP)
12574                   {
12575                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
12576                   }
12577                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12578                         transportLayerAddress.buf);
12579                }
12580                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
12581             }
12582          }
12583          if(ulInfo->list.array[ulIdx]!=NULLP)
12584          {
12585             free(ulInfo->list.array[ulIdx]);
12586          }
12587       }
12588       free(ulInfo->list.array);
12589    }
12590 }
12591 /*******************************************************************
12592 *
12593 * @brief free the memory allocated by decoder
12594 *
12595 * @details
12596 *
12597 *    Function : freeAperDecodeDRBSetup
12598 *
12599 *    Functionality: free DRBSetup which is allocated by decoder
12600 *
12601 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
12602 * @return void
12603 *
12604 * ****************************************************************/
12605
12606 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
12607 {
12608    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
12609    uint8_t  flowIdx =0;
12610    uint8_t  drbIdx =0;
12611
12612    if(drbSet->list.array != NULLP)
12613    {
12614       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
12615       {
12616          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
12617          {
12618             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
12619             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
12620             {
12621                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12622                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
12623                {
12624                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12625                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12626                   {
12627                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12628                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12629                      {
12630
12631                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
12632                         {
12633
12634                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
12635                            {
12636
12637                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
12638                                     buf!=NULLP)
12639                               {
12640
12641                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
12642                                        flows_Mapped_To_DRB_List.list.array != NULLP)
12643                                  {
12644
12645                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12646                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
12647                                     {
12648
12649                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12650                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
12651                                        {
12652                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12653                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12654                                                 qoSFlowLevelQoSParameters.\
12655                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
12656                                           {
12657                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12658                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12659                                                    qoSFlowLevelQoSParameters.\
12660                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12661                                              {
12662
12663                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12664                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12665                                                       qoSFlowLevelQoSParameters.\
12666                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12667                                                 {
12668
12669
12670                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12671                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12672                                                          qoSFlowLevelQoSParameters.\
12673                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12674                                                 }
12675
12676                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12677                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12678                                                       qoSFlowLevelQoSParameters.\
12679                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12680                                              }
12681
12682                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12683
12684                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12685                                                    qoSFlowLevelQoSParameters.\
12686                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
12687                                           }
12688                                        }
12689                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12690                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
12691                                        {
12692
12693                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12694                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
12695                                        }
12696                                     }
12697
12698                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12699                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
12700                                  }
12701
12702                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12703                                        DRB_Information.sNSSAI.sD->buf);
12704                               }
12705
12706                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
12707                            }
12708
12709                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
12710
12711                         }
12712
12713                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12714
12715                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12716                      }
12717
12718                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12719                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12720                   }
12721
12722                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12723                         qoS_Characteristics.choice.non_Dynamic_5QI);
12724                }
12725                free(drbSetItem->qoSInformation.choice.choice_extension);
12726             }
12727             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
12728             if(drbSetItem->uLConfiguration)
12729             {
12730                free(drbSetItem->uLConfiguration);
12731             }
12732          }
12733          if(drbSet->list.array[drbIdx]!=NULLP)
12734          {
12735             free(drbSet->list.array[drbIdx]);
12736          }
12737       }
12738       free(drbSet->list.array);
12739    }
12740 }
12741
12742
12743 /*******************************************************************
12744  *
12745  * @brief builds Mac Cell Cfg
12746  *
12747  * @details
12748  *
12749  *    Function : procUeReCfgCellInfo
12750  *
12751  *    Functionality: builds Mac Cell Cfg
12752  *
12753  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
12754  *                       needs to send in other layer, as well as this can be
12755  *                       the variable which stores the information in DuCb.
12756  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
12757  *                       information to other layer else it will have copyOfmacUeCfg
12758  *                       which we have stored in F1UeContextSetupDb
12759  *             void *cellInfo = CellGroupConfigRrc_t information which is send
12760  *                        by CU, which we have stored in F1UeContextSetupDb
12761  *
12762  * @return void
12763  *
12764  * ****************************************************************/
12765 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend, MacUeCfg *storedMacUeCfg, void *cellInfo)
12766 {
12767    uint8_t ret = ROK;
12768    CellGroupConfigRrc_t *cellGrp = NULLP;
12769
12770    if(cellInfo)
12771    {
12772       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
12773       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
12774       if(ret == RFAILED)
12775          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
12776    }
12777    if(ret == RFAILED)
12778    {
12779       freeUeReCfgCellGrpInfo(macUeCfgToSend);
12780    }
12781    return ret;
12782 }
12783
12784 /*******************************************************************
12785  *
12786  * @brief Filling modulation info in mac ue cfg
12787  *
12788  * @details
12789  *
12790  *    Function : duFillModulationDetails
12791  *
12792  *    Functionality: Filling modulation info in mac ue cfg
12793  *
12794  * @params[in] MAC UE Config to be updated
12795  *             Current UE configuration
12796  *             UE NR capability from CU
12797  * @return ROK     - success
12798  *         RFAILED - failure
12799  *
12800  * ****************************************************************/
12801 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
12802 {
12803    UE_NR_Capability_t *ueNrCap=NULLP;
12804
12805    if(!ueCap && oldUeCfg)
12806    {
12807       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12808       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12809    }
12810    else
12811    {
12812       ueNrCap = (UE_NR_Capability_t *)ueCap;
12813
12814       /* Filling DL modulation info */
12815       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
12816          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
12817          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
12818       {
12819          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
12820          {
12821             case ModulationOrder_qpsk:
12822                {
12823                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
12824                   break;
12825                }
12826             case ModulationOrder_qam16:
12827                {
12828                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
12829                   break;
12830                }
12831             case ModulationOrder_qam64:
12832                {
12833                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
12834                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
12835                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
12836                   break;
12837                }
12838             case ModulationOrder_qam256:
12839                {
12840                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
12841                   break;
12842                }
12843             default:
12844                {
12845                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
12846                   if(oldUeCfg)
12847                      memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12848                   break;
12849                }
12850          }
12851       }
12852       else
12853       {
12854          if(oldUeCfg)
12855             memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12856       }
12857
12858       /* Filling UL modulation info */
12859       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
12860          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
12861          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
12862       {
12863          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
12864          {
12865             case ModulationOrder_qpsk:
12866                {
12867                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
12868                   break;
12869                }
12870             case ModulationOrder_qam16:
12871                {
12872                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
12873                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
12874                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
12875                   break;
12876                }
12877             case ModulationOrder_qam64:
12878                {
12879                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
12880                   break;
12881                }
12882             case ModulationOrder_qam256:
12883                {
12884                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
12885                   break;
12886                }
12887             default:
12888                {
12889                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
12890                   if(oldUeCfg)
12891                      memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12892                   break;
12893                }
12894          }
12895       }
12896       else
12897       {
12898          if(oldUeCfg)
12899             memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12900       }
12901    }
12902 }
12903
12904 /*******************************************************************
12905  *
12906  * @brief Function to extract info from CU to DU RRC container extension
12907  *
12908  * @details
12909  *
12910  *    Function : extractCuToDuRrcInfoExt
12911  *
12912  *    Functionality: Function to extract info from CU to DU RRC container
12913  *    extension
12914  *
12915  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
12916  *
12917  * @return ROK
12918  *         RFAILED
12919  *
12920  * ****************************************************************/
12921 uint8_t extractCuToDuRrcInfoExt(ProtocolExtensionContainer_4624P16_t *protocolIeExtn, DuUeCfg *ueCfgDb)
12922 {
12923    uint8_t ieIdx =0;
12924    uint16_t recvBufLen =0;
12925    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
12926    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
12927    asn_dec_rval_t rval; /* Decoder return value */
12928    memset(&rval, 0, sizeof(asn_dec_rval_t));
12929
12930    if(protocolIeExtn)
12931    {
12932       for(ieIdx = 0; ieIdx < protocolIeExtn->list.count; ieIdx++)
12933       {
12934          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[ieIdx]));
12935          switch(extIeInfo->id)
12936          {
12937             case ProtocolIE_ID_id_CellGroupConfig:
12938                {
12939                   /* decoding the CellGroup Buf received */
12940                   recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
12941                   DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
12942                   if(cellGrpCfg)
12943                   {
12944                      memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
12945                      rval = uper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
12946                            extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
12947                      if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12948                      {
12949                         DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
12950                         return RFAILED;
12951                      }
12952                      xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
12953
12954                      if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
12955                         return NULLP;
12956                      ueCfgDb->cellGrpCfg = cellGrpCfg;
12957                   }
12958                   break;
12959                }
12960
12961             case ProtocolIE_ID_id_HandoverPreparationInformation:
12962                {
12963                   DU_LOG("\nINFO -->  F1AP : Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
12964                   break;
12965                }
12966
12967             default:
12968                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation: %ld at decodeCellGrpCfg()", extIeInfo->id);
12969                break;
12970          }
12971       }
12972    }
12973    return ROK;
12974 }
12975
12976 /*******************************************************************
12977  *
12978  * @brief Fills Srb List received by CU
12979  *
12980  * @details
12981  *
12982  *    Function : procSrbListToSetup
12983  *
12984  *    Functionality: Fills Srb List received  by CU
12985  *
12986  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
12987  *             LcCfg pointer
12988  *             RlcBearerCfg pointer
12989  * @return void
12990  *
12991  * ****************************************************************/
12992 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
12993 {
12994
12995    /* Filling RLC INFO */
12996    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
12997
12998    /* Filling MAC INFO */
12999    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
13000    {
13001       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
13002       return RFAILED;
13003    }
13004
13005    return ROK;
13006 }
13007
13008
13009
13010 /*******************************************************************
13011  *
13012  * @brief extract Srb List received by CU
13013  *
13014  * @details
13015  *
13016  *    Function : extractSrbListToSetup
13017  *
13018  *    Functionality: extract Srb List received by CU
13019  *                   for both MAC and RLC
13020  *
13021  * @params[in] SRBs_ToBeSetup_Item_t pointer
13022  *             DuUeCfg pointer
13023  * @return ROK/RFAIED
13024  *
13025  * ****************************************************************/
13026
13027 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
13028 {
13029    uint8_t ret = ROK, srbIdx = 0, rlcLcIdx = 0;
13030    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
13031    LcCfg *macLcCtxt = NULLP;
13032    RlcBearerCfg *rlcLcCtxt = NULLP;
13033
13034    if(srbCfg)
13035    {
13036       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
13037       {
13038          macLcCtxt = NULL;
13039          rlcLcCtxt = NULL;
13040
13041          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
13042          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
13043          {
13044             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
13045             ret = RFAILED;
13046             break;
13047          }
13048          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
13049          {
13050             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
13051             ret = RFAILED;
13052             break;
13053          }
13054
13055          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numMacLcs; rlcLcIdx++)
13056          {
13057             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == srbItem->sRBID && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_SRB)
13058             {
13059                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13060                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13061                break;
13062             }
13063          }
13064          if(!macLcCtxt)
13065          {
13066             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
13067             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13068             ueCfgDb->numMacLcs++;
13069          }
13070          if(!rlcLcCtxt)
13071          {
13072             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
13073             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13074             ueCfgDb->numRlcLcs++;
13075          }
13076
13077          ret = procSrbListToSetup(srbItem, macLcCtxt, rlcLcCtxt);
13078
13079          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13080                srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13081          if(ret == RFAILED)
13082          {
13083             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
13084             break;
13085          }
13086       }
13087    }
13088    else
13089       ret = RFAILED;
13090
13091    return ret;
13092 }
13093
13094 /*******************************************************************
13095  *
13096  * @brief Fills Drb List received by CU
13097  *
13098  * @details
13099  *
13100  *    Function : procDrbListToSetupMod
13101  *
13102  *    Functionality: Fills Drb List received by CU
13103  *                   for both MAC and RLC
13104  *
13105  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
13106  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
13107  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
13108  * @return void
13109  *
13110  * ****************************************************************/
13111
13112 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
13113 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
13114 {
13115    uint8_t cfgIdx = 0;
13116    RlcMode rlcModeInfo;
13117
13118    if(drbItem != NULLP)
13119    {
13120       /* Filling RLC INFO */
13121       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
13122       qoSInformation);
13123
13124       /* Filling MAC INFO */
13125       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
13126       {
13127          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13128          return RFAILED;
13129       }
13130    }
13131    else if(drbSetupModItem != NULLP)
13132    {
13133       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
13134       &drbSetupModItem->qoSInformation);
13135
13136       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
13137       {
13138          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13139          return RFAILED;
13140       }
13141    }
13142    else if(drbModItem != NULLP)
13143    {
13144       /* Drb to Mod IEs doesnot have rlcMode to be modified
13145        * in ASN. Hence no change in RLC configurations */
13146       if(storedRlcUeCfg != NULLP)
13147       {
13148          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
13149          {
13150             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
13151             {
13152                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
13153                break;
13154             }
13155          }
13156       }
13157
13158       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
13159       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
13160       {
13161          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13162          return RFAILED;
13163       }
13164    }
13165    return ROK;
13166 }
13167
13168 /*******************************************************************
13169  *
13170  * @brief extract Drb List received by CU
13171  *
13172  * @details
13173  *
13174  *    Function : extractDrbListToSetupMod
13175  *
13176  *    Functionality: extract Drb List received by CU
13177  *                   for both MAC and RLC
13178  *
13179  * @params[in] DRBs_ToBeSetup_Item_t pointer
13180  *             DuUeCfg pointer
13181  * @return ROK/RFAIED
13182  *
13183  * ****************************************************************/
13184
13185 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
13186  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
13187 {
13188    uint8_t ret = ROK;
13189    uint8_t drbIdx = 0, rlcLcIdx = 0;
13190    uint8_t drbId = 0, lcId = 0;
13191    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
13192    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
13193    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
13194    LcCfg *macLcCtxt = NULLP;
13195    RlcBearerCfg *rlcLcCtxt = NULLP;
13196
13197    ret = ROK;
13198    if(drbCount > 0)
13199    {
13200       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
13201       {
13202          macLcCtxt = NULL;
13203          rlcLcCtxt = NULL;
13204
13205          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
13206          {
13207             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
13208             ret = RFAILED;
13209             break;
13210          }
13211          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
13212          {
13213             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
13214             ret = RFAILED;
13215             break;
13216          }
13217
13218          if(drbModCfg != NULLP)
13219          {
13220             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
13221             drbId = drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID;
13222          }
13223          else if(drbCfg != NULLP)
13224             drbId = drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item.dRBID;
13225          else if(drbSetupModCfg != NULL)
13226          {
13227             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
13228             drbId = drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item.dRBID;
13229          }
13230
13231          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numRlcLcs; rlcLcIdx++)
13232          {
13233             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == drbId && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_DRB)
13234             {
13235                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13236                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13237                break;
13238             }
13239          }
13240          if(!macLcCtxt)
13241          {
13242             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
13243             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13244             ueCfgDb->numMacLcs++;
13245          }
13246          if(!rlcLcCtxt)
13247          {
13248             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
13249             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13250             ueCfgDb->numRlcLcs++;
13251          }
13252
13253          if(drbModCfg != NULLP)
13254          {
13255             lcId = fetchLcId(drbId);
13256             if(lcId < MIN_DRB_LCID)
13257             {
13258                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
13259                break;
13260             }
13261             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
13262             macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13263             if(ret == RFAILED)
13264             {
13265                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
13266                break;
13267             }
13268          }
13269          else
13270          {
13271             lcId = getDrbLcId(drbBitMap);
13272             if(lcId == RFAILED)
13273             {
13274                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
13275                ret = RFAILED;
13276                break;
13277             }
13278             if(drbCfg != NULL)
13279             {
13280                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
13281                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13282                if(ret == RFAILED)
13283                {
13284                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
13285                   break;
13286                }
13287             }
13288             else if(drbSetupModCfg != NULL)
13289             {
13290                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
13291                      macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13292                if(ret == RFAILED)
13293                {
13294                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
13295                   break;
13296                }
13297                ueCfgDb->numDrbSetupMod++;
13298             }
13299          }
13300          ueCfgDb->numDrb++;
13301
13302          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13303                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13304          if(ret == RFAILED)
13305          {
13306             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
13307             break;
13308          }
13309       }
13310    }
13311    else
13312       ret = RFAILED;
13313
13314    return ret;
13315 }
13316
13317 /*******************************************************************
13318  *
13319  * @brief Function to extract Dl RRC Msg received from CU
13320  *
13321  * @details
13322  *
13323  *    Function : extractDlRrcMsg
13324  *
13325  *    Functionality: Function to extract Dl RRC Msg received from CU
13326  *
13327  * @params[in] F1AP message
13328  * @return ROK     - success
13329  *         RFAILED - failure
13330  *
13331  * ****************************************************************/
13332
13333 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
13334    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
13335 {
13336    uint8_t ret = ROK;
13337    dlRrcMsg->rrcMsgSize = rrcContainer->size;
13338    if(dlRrcMsg->rrcMsgSize > 0)
13339    {
13340       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
13341       if(!dlRrcMsg->rrcMsgPdu)
13342       {
13343          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
13344          ret = RFAILED;
13345       }
13346       else
13347       {
13348          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
13349          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
13350          dlRrcMsg->srbId = SRB1_LCID;
13351          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
13352       }
13353    }
13354    return ret;
13355 }
13356
13357 /*******************************************************************
13358  *
13359  * @brief Extract UE capability info
13360  *
13361  * @details
13362  *
13363  *    Function : extractUeCapability
13364  *
13365  *    Functionality: Extract UE capability info and stores in ue Cb
13366  *
13367  * @params[in] Octet string of UE capability RAT container list
13368  * @return ROK     - success
13369  *         RFAILED - failure
13370  *
13371  * ****************************************************************/
13372 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
13373 {
13374    uint8_t  idx;
13375    uint16_t recvBufLen;
13376    asn_dec_rval_t rval;
13377    UE_NR_Capability_t  *ueNrCap = NULLP;
13378    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
13379
13380    /* Decoding UE Capability RAT Container List */
13381    recvBufLen = ueCapablityListBuf->size;
13382    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13383    if(!ueCapRatContList)
13384    {
13385       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
13386       return NULLP;
13387    }
13388    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13389    memset(&rval, 0, sizeof(asn_dec_rval_t));
13390    rval = uper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
13391           ueCapablityListBuf->buf, recvBufLen, 0, 0);
13392    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13393    {
13394       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13395       return NULLP;
13396    }
13397    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
13398
13399    /* Free encoded buffer after decoding */
13400
13401    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
13402    {
13403       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
13404       {
13405          /* Decoding UE NR Capability */
13406           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
13407           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
13408           if(!ueNrCap)
13409           {
13410              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
13411              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13412              return NULLP;
13413           }
13414           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
13415           memset(&rval, 0, sizeof(asn_dec_rval_t));
13416           rval = uper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
13417                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
13418           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13419           {
13420              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13421              return NULLP;
13422           }
13423           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
13424
13425           /* Free encoded buffer after decoding */
13426           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
13427       }
13428       free(ueCapRatContList->list.array[idx]);
13429    }
13430
13431    /* Free Memory*/
13432    free(ueCapRatContList->list.array);
13433    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13434    return ueNrCap;
13435 }
13436
13437 /*******************************************************************
13438 *
13439 * @brief free UE context setup request from CU
13440 *
13441 * @details
13442 *
13443 *    Function : freeAperDecodeF1UeContextSetupReq
13444 *
13445 *    Functionality: freeing part for the memory allocated by aper_decoder
13446 *
13447 * @params[in] F1AP message
13448 * @return ROK     - success
13449 *         RFAILED - failure
13450 *
13451 * ****************************************************************/
13452 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
13453 {
13454    uint8_t ieIdx = 0;
13455
13456    if(ueSetReq->protocolIEs.list.array != NULLP)
13457    {
13458       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
13459       {
13460          if(ueSetReq->protocolIEs.list.array[ieIdx])
13461          {
13462             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13463             {
13464                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13465                   break;
13466                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13467                   break;
13468                case ProtocolIE_ID_id_SpCell_ID:
13469                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
13470                   break;
13471                case ProtocolIE_ID_id_ServCellIndex:
13472                   break;
13473                case ProtocolIE_ID_id_SpCellULConfigured:
13474                   break;
13475                case ProtocolIE_ID_id_CUtoDURRCInformation:
13476
13477                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
13478                   break;
13479                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
13480
13481                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
13482                   break;
13483                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13484
13485                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
13486                   break;
13487                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13488
13489                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
13490                   break;
13491                case ProtocolIE_ID_id_RRCContainer:
13492                   {
13493
13494                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
13495                      {
13496
13497                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13498                      }
13499                      break;
13500                   }
13501                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13502                   break;
13503                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
13504                   {
13505                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
13506                      {
13507                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
13508                      }
13509                      break;
13510                   }
13511 #ifdef NR_DRX
13512                case ProtocolIE_ID_id_DRXCycle:
13513                   {
13514                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleLength)
13515                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleLength);
13516                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleTimer)
13517                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleTimer);
13518                      break;
13519                   }
13520 #endif
13521                 default:
13522                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
13523             }
13524             free(ueSetReq->protocolIEs.list.array[ieIdx]);
13525          }
13526       }
13527       free(ueSetReq->protocolIEs.list.array);
13528    }
13529 }
13530 /*******************************************************************
13531  *
13532  * @brief Process UE context setup request from CU
13533  *
13534  * @details
13535  *
13536  *    Function : procF1UeContextSetupReq
13537  *
13538  *    Functionality: Process UE context setup request from CU
13539  *
13540  * @params[in] F1AP message
13541  * @return ROK     - success
13542  *         RFAILED - failure
13543  *
13544  * ****************************************************************/
13545 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
13546 {
13547    int8_t ueIdx = -1;
13548    uint8_t  ret=0, ieIdx=0, ieExtIdx = 0;
13549    //uint8_t servCellIdx = 0;
13550    bool ueCbFound = false, hoInProgress = false;
13551    uint16_t cellIdx=0;
13552    uint64_t nrCellId = 0;
13553    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
13554    DuUeCb   *duUeCb = NULL;
13555    UEContextSetupRequest_t   *ueSetReq = NULL;
13556    DRBs_ToBeSetup_List_t *drbCfg = NULL;
13557    CUtoDURRCInformation_t *rrcInfo = NULL;
13558 #ifdef NR_DRX
13559    DRXCycle_t *drxCycle;
13560 #endif
13561    ret = ROK;
13562
13563    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
13564    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13565    {
13566       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13567       {
13568          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13569             {
13570                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13571                break;
13572             }
13573
13574          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13575             {
13576                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13577                break;
13578             }
13579
13580          case ProtocolIE_ID_id_SpCell_ID:
13581             {
13582                bitStringToInt(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
13583
13584                GET_CELL_IDX(nrCellId, cellIdx);
13585                if(!duCb.actvCellLst[cellIdx])
13586                {
13587                   DU_LOG("\nERROR  -->  F1AP : Cell Id [%lu] not found", nrCellId);
13588                   ret = RFAILED;
13589                }
13590                break;
13591             }
13592
13593          case ProtocolIE_ID_id_ServCellIndex:
13594             {
13595                //servCellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
13596                break;
13597             }
13598
13599          case ProtocolIE_ID_id_SpCellULConfigured:
13600             {
13601                /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
13602                   UL, SUL or UL+SUL for the indicated cell for the UE */
13603                break;
13604             }
13605
13606          case ProtocolIE_ID_id_CUtoDURRCInformation:
13607             {
13608                rrcInfo = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation;
13609
13610                /* Search if UE context is present */
13611                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
13612                {
13613                   if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId)
13614                   {
13615                      ueCbFound = true;
13616                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13617                      break;
13618                   }
13619                }
13620
13621                /* Check if UE Handover scenario */
13622                if(rrcInfo->iE_Extensions)
13623                {
13624                   for(ieExtIdx = 0; ieExtIdx < rrcInfo->iE_Extensions->list.count; ieExtIdx++)
13625                   {
13626                      if(rrcInfo->iE_Extensions->list.array[ieExtIdx]->id == ProtocolIE_ID_id_HandoverPreparationInformation)
13627                      {
13628                         hoInProgress = true;
13629                         break;
13630                      }
13631                   }
13632                }
13633
13634                /* If UE context is not present, but UE is in handover */
13635                if(!ueCbFound && hoInProgress)
13636                {
13637                   ueIdx = getFreeBitFromUeBitMap(nrCellId);
13638                   if(ueIdx != -1)
13639                      gnbDuUeF1apId = ueIdx +1;
13640                   else
13641                   {
13642                      DU_LOG("\nERROR  -->  F1AP : No free UE IDX found in UE bit map of cell Id [%lu]", nrCellId);
13643                      ret = RFAILED;
13644                      break;
13645                   }
13646                   duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13647                   duUeCb->f1UeDb = NULL;
13648                   duUeCb->gnbCuUeF1apId = gnbCuUeF1apId;
13649                   duUeCb->gnbDuUeF1apId = gnbDuUeF1apId;
13650                   GET_CRNTI(duUeCb->crnti, duUeCb->gnbDuUeF1apId);
13651                   duUeCb->ueState = UE_HANDIN_IN_PROGRESS;
13652                }
13653
13654                if(duUeCb)
13655                {
13656                   DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13657                   if(duUeCb->f1UeDb)
13658                   {
13659                      memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13660                      duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
13661                      duUeCb->f1UeDb->cellIdx = cellIdx;
13662                   }
13663                   else
13664                   {
13665                      DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
13666                      ret = RFAILED;
13667                      break;
13668                   }
13669                }
13670                else
13671                {
13672                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13673                   ret = RFAILED;
13674                   break;
13675                }
13676
13677                /* Extract UE capability info */
13678                if(rrcInfo->uE_CapabilityRAT_ContainerList)
13679                {
13680                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = extractUeCapability(rrcInfo->uE_CapabilityRAT_ContainerList, duUeCb);
13681                }
13682
13683                /* Extract IE extension */
13684                if(rrcInfo->iE_Extensions)
13685                {
13686                   if(extractCuToDuRrcInfoExt(rrcInfo->iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
13687                   {
13688                      DU_LOG("\nERROR  -->  F1AP: Failed to extract CU to DU RRC information extension IE");
13689                      //TODO: Update the failure cause in ue context Setup Response
13690                      ret = RFAILED;
13691                   }
13692                }
13693                break;
13694             }
13695
13696 #ifdef NR_DRX
13697          case ProtocolIE_ID_id_DRXCycle:
13698             {
13699                duUeCb->f1UeDb->duUeCfg.drxCyclePres = true;
13700                drxCycle = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle;
13701                duUeCb->f1UeDb->duUeCfg.drxCycle.drxLongCycleLength =  convertLongDrxCycleLengthEnumToValue(drxCycle->longDRXCycleLength);
13702                if(drxCycle->shortDRXCycleLength)
13703                {
13704                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCyclePres = true;
13705                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycle = \
13706                   convertShortDrxCycleLengthEnumToValue(*(drxCycle->shortDRXCycleLength));
13707                }
13708                if(drxCycle->shortDRXCycleTimer)
13709                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycleTimer = *(drxCycle->shortDRXCycleTimer);
13710
13711                break;
13712             }
13713
13714 #endif
13715          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13716             {
13717                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
13718                         &duUeCb->f1UeDb->duUeCfg))
13719                {
13720                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
13721                   //TODO: Update the failure cause in ue context Setup Response
13722                   ret = RFAILED;
13723                }
13724                break;
13725             }
13726
13727          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13728             {
13729                drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
13730
13731                if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
13732                {
13733                   DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
13734                   //TODO: Update the failure cause in ue context Setup Response
13735                   ret = RFAILED;
13736                }
13737                break;
13738             }
13739          case ProtocolIE_ID_id_RRCContainer:
13740             {
13741                /* Filling Dl RRC Msg Info */
13742                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13743                if(!duUeCb->f1UeDb->dlRrcMsg)
13744                {
13745                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
13746                   ret = RFAILED;
13747                }
13748                else
13749                {
13750                   duUeCb->f1UeDb->dlRrcMsgPres = true;
13751                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13752                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13753                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
13754                }
13755                break;
13756             }
13757
13758          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13759             {
13760                if(duUeCb->f1UeDb->dlRrcMsg)
13761                {
13762                   if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
13763                   {
13764                      duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
13765                   }
13766                   else
13767                   {
13768                      DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
13769                   }
13770                }
13771                break;
13772             }
13773
13774          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
13775             {
13776                /* MaximumBitRate Uplink */
13777                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
13778                if(bitRateSize > 0)
13779                {
13780                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
13781                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
13782                   {
13783                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
13784                      ret = RFAILED;
13785                   }
13786                   else
13787                   {
13788                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
13789                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
13790                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
13791                   }
13792                }
13793                else
13794                   ret = RFAILED;
13795                break;
13796             }
13797
13798          default:
13799             {
13800                break;
13801             }
13802       } /* End of switch */
13803
13804       /* In case of any failure in any IE */
13805       if(ret == RFAILED)
13806       {
13807          // BuildAndSendUeContextSetupRsp(cellId,ueId);
13808          DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
13809          break;
13810       }
13811    } /* End of for loop of IEs */
13812
13813    if(ret == ROK)
13814       ret = duProcUeContextSetupRequest(duUeCb);
13815
13816    freeAperDecodeF1UeContextSetupReq(ueSetReq);
13817    return ret;
13818
13819 }
13820 /*******************************************************************
13821  * @brief Free the memory allocated for Dl Tunnel Info
13822  *
13823  * @details
13824  *
13825  *    Function : freeDlTnlInfo
13826  *
13827  *    Functionality:
13828  *       Free the memory allocated for Dl Tunnel Info
13829  *
13830  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
13831  * @return void
13832  *
13833  * ****************************************************************/
13834
13835 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
13836 {
13837    uint8_t arrIdx = 0;
13838
13839    if(tnlInfo)
13840    {
13841       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
13842       {
13843          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
13844                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
13845          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
13846                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
13847          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
13848          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
13849       }
13850       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
13851    }
13852 }
13853
13854 /*******************************************************************
13855  * @brief Free the memory allocated for DRB setup List
13856  *
13857  * @details
13858  *
13859  *    Function : freeDrbSetupList
13860  *
13861  *    Functionality:
13862  *       Free the memory allocated for DRB setup list
13863  *
13864  * @params[in] DRBs_Setup_List_t *
13865  * @return void
13866  *
13867  * ****************************************************************/
13868 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
13869 {
13870    uint8_t arrIdx = 0;
13871    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
13872
13873    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
13874    {
13875       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
13876       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
13877       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
13878    }
13879    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
13880 }
13881
13882 /*******************************************************************
13883  * @brief Free the memory allocated for UE Setup response
13884  *
13885  * @details
13886  *
13887  *    Function : FreeUeContextSetupRsp
13888  *
13889  *    Functionality:
13890  *       Free the memory allocated for UE Setup response
13891  *
13892  * @params[in] F1AP PDU for UE setup response
13893  * @return ROK     - success
13894  *         RFAILED - failure
13895  *
13896  * ****************************************************************/
13897 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
13898 {
13899    uint8_t idx;
13900    UEContextSetupResponse_t *ueSetRsp = NULLP;
13901
13902    if(f1apMsg)
13903    {
13904       if(f1apMsg->choice.successfulOutcome)
13905       {
13906          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
13907                     UEContextSetupResponse;
13908          if(ueSetRsp->protocolIEs.list.array)
13909          {
13910             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
13911             {
13912                if(ueSetRsp->protocolIEs.list.array[idx])
13913                {
13914                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
13915                   {
13916                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13917                         break;
13918                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13919                         break;
13920                      case ProtocolIE_ID_id_C_RNTI:
13921                         break;
13922                      case ProtocolIE_ID_id_DUtoCURRCInformation:
13923                         {
13924                            CellGroupConfig_t *cellGrpCfg = NULLP;
13925                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
13926                                          DUtoCURRCInformation.cellGroupConfig;
13927                            if(cellGrpCfg->buf != NULLP)
13928                            {
13929                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
13930                               cellGrpCfg = NULLP;
13931                            }
13932                            break;
13933                         }
13934                      case ProtocolIE_ID_id_DRBs_Setup_List:
13935                         {
13936                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
13937                            break;
13938                         }
13939                      default:
13940                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
13941                               ueSetRsp->protocolIEs.list.array[idx]->id);
13942                         break;
13943                   }
13944                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
13945                         sizeof(UEContextSetupResponseIEs_t));
13946                }
13947             }
13948             DU_FREE(ueSetRsp->protocolIEs.list.array, \
13949                   ueSetRsp->protocolIEs.list.size);
13950          }
13951          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13952       }
13953       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13954    }
13955 }
13956
13957 /*******************************************************************
13958  *
13959  * @brief Builds Ue context Setup Rsp DU To CU Info
13960  *
13961  * @details
13962  *
13963  *    Function : EncodeUeCntxtDuToCuInfo
13964  *
13965  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
13966  *
13967  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
13968  *
13969  * @return ROK     - success
13970  *         RFAILED - failure
13971  *
13972  ******************************************************************/
13973
13974 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
13975 {
13976    asn_enc_rval_t        encRetVal;
13977
13978    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
13979    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
13980    encBufSize = 0;
13981    encRetVal = uper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
13982    /* Encode results */
13983    if(encRetVal.encoded == ENCODE_FAIL)
13984    {
13985       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
13986             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13987       return RFAILED;
13988    }
13989    else
13990    {
13991       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
13992 #ifdef DEBUG_ASN_PRINT
13993       for(int i=0; i< encBufSize; i++)
13994       {
13995          printf("%x",encBuf[i]);
13996       }
13997 #endif
13998    }
13999    duToCuCellGrp->size = encBufSize;
14000    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
14001    if(!duToCuCellGrp->buf)
14002    {
14003       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
14004    }
14005    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
14006    return ROK;
14007 }
14008
14009 /*******************************************************************
14010  *
14011  * @brief Fills Dl Gtp tunnel Info
14012  *
14013  * @details
14014  *
14015  *    Function : fillGtpTunnelforDl
14016  *
14017  *    Functionality: Fills Dl Gtp tunnel Info
14018  *
14019  * @params[in]
14020  *
14021  * @return ROK     - success
14022  *         RFAILED - failure
14023  *
14024  * ****************************************************************/
14025
14026 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
14027 {
14028    uint8_t bufSize = 0;
14029
14030    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
14031    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
14032    if(gtpDl->transportLayerAddress.buf == NULLP)
14033    {
14034       return RFAILED;
14035    }
14036    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
14037
14038    /*GTP TEID*/
14039    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
14040    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
14041    if(gtpDl->gTP_TEID.buf == NULLP)
14042    {
14043       return RFAILED;
14044    }
14045    bufSize = 3; /*forming an Octect String*/
14046    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
14047
14048    return ROK;
14049 }
14050
14051 /*******************************************************************
14052  *
14053  * @brief Fills DL Tunnel Setup List
14054  *
14055  * @details
14056  *
14057  *    Function : fillDlTnlSetupList
14058  *
14059  *    Functionality: Fills the DL Tunnel Setup List
14060  *
14061  * @params[in]
14062  *
14063  * @return ROK     - success
14064  *         RFAILED - failure
14065  *
14066  * ****************************************************************/
14067
14068 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
14069 {
14070    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14071
14072    eleCount = 1;
14073    dlTnlInfo->list.count = eleCount;
14074    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
14075
14076    /* Initialize the DL Tnl Setup List Members */
14077    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
14078    if(dlTnlInfo->list.array == NULLP)
14079    {
14080       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
14081       ret = RFAILED;
14082    }
14083    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14084    {
14085       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
14086       if(dlTnlInfo->list.array[arrIdx] == NULLP)
14087       {
14088          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
14089          return RFAILED;
14090       }
14091       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
14092       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
14093       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
14094       {
14095          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
14096          return RFAILED;
14097       }
14098       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
14099                tnlCfg->tnlCfg1);
14100       if(ret != ROK)
14101          break;
14102    }
14103    return ret;
14104 }
14105
14106 /*******************************************************************
14107  *
14108  * @brief Fills the Drb Setup List for Ue Context Setup Response
14109  *
14110  * @details
14111  *
14112  *    Function : fillDrbSetupList
14113  *
14114  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
14115  *
14116  * @params[in]
14117  *
14118  * @return ROK     - success
14119  *         RFAILED - failure
14120  *
14121  * ****************************************************************/
14122 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
14123 {
14124    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14125    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
14126
14127    eleCount = ueCfg->numDrb;
14128    drbSetupList->list.count = eleCount;
14129    drbSetupList->list.size = \
14130         (eleCount * sizeof(DRBs_Setup_Item_t *));
14131
14132    /* Initialize the Drb Setup List Members */
14133    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
14134    if(drbSetupList->list.array == NULLP)
14135    {
14136       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
14137       ret = RFAILED;
14138    }
14139
14140    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14141    {
14142       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
14143       if(drbSetupList->list.array[arrIdx] == NULLP)
14144       {
14145          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
14146          return RFAILED;
14147       }
14148       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
14149       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
14150       drbItemIe->criticality = Criticality_reject;
14151       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
14152       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
14153       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
14154           &ueCfg->upTnlInfo[arrIdx]);
14155       if(ret != ROK)
14156          break;
14157    }
14158    return ret;
14159 }
14160
14161 /*******************************************************************
14162  *
14163  * @brief Builds and sends the UE Setup Response
14164  *
14165  * @details
14166  *
14167  *    Function : BuildAndSendUeContextSetupRsp
14168  *
14169  *    Functionality: Constructs the UE Setup Response and sends
14170  *                   it to the DU through SCTP.
14171  *
14172  * @params[in] uint8_t cellId,uint8_t ueId
14173  *
14174  * @return ROK     - success
14175  *         RFAILED - failure
14176  *
14177  * ****************************************************************/
14178 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
14179 {
14180    uint8_t   idx, ret, cellIdx, elementCnt;
14181    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
14182    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
14183    asn_enc_rval_t  encRetVal;        /* Encoder return value */
14184    F1AP_PDU_t               *f1apMsg = NULLP;
14185    UEContextSetupResponse_t *ueSetRsp = NULLP;
14186    DuUeCb                   *ueCb = NULLP;
14187
14188    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
14189
14190    while(true)
14191    {
14192       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14193       if(f1apMsg == NULLP)
14194       {
14195          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14196          ret = RFAILED;
14197          break;
14198       }
14199
14200       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
14201       DU_ALLOC(f1apMsg->choice.successfulOutcome,
14202             sizeof(SuccessfulOutcome_t));
14203       if(f1apMsg->choice.successfulOutcome == NULLP)
14204       {
14205          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
14206          ret = RFAILED;
14207          break;
14208       }
14209
14210       f1apMsg->choice.successfulOutcome->procedureCode = \
14211                                                          ProcedureCode_id_UEContextSetup;
14212       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
14213       f1apMsg->choice.successfulOutcome->value.present = \
14214                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
14215
14216       ueSetRsp =
14217          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
14218       elementCnt = 5;
14219       ueSetRsp->protocolIEs.list.count = elementCnt;
14220       ueSetRsp->protocolIEs.list.size = \
14221                                         elementCnt * sizeof(UEContextSetupResponse_t *);
14222
14223       /* Initialize the UESetup members */
14224       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
14225             ueSetRsp->protocolIEs.list.size);
14226       if(ueSetRsp->protocolIEs.list.array == NULLP)
14227       {
14228          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14229          ret = RFAILED;
14230          break;
14231       }
14232
14233       for(idx=0; idx<elementCnt; idx++)
14234       {
14235          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
14236                sizeof(UEContextSetupResponseIEs_t));
14237          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
14238          {
14239             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14240             ret = RFAILED;
14241             break;
14242          }
14243       }
14244       /* Fetching Ue Cb Info*/
14245       GET_CELL_IDX(cellId, cellIdx);
14246       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
14247       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
14248       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
14249
14250       idx = 0;
14251       /*GNB CU UE F1AP ID*/
14252       ueSetRsp->protocolIEs.list.array[idx]->id = \
14253                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14254       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14255       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14256                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
14257       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14258
14259       /*GNB DU UE F1AP ID*/
14260       idx++;
14261       ueSetRsp->protocolIEs.list.array[idx]->id = \
14262                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14263       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14264       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14265                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
14266       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14267
14268
14269       /*DUtoCURRC Information */
14270       idx++;
14271       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14272                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
14273       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14274       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14275                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
14276       BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
14277
14278       /* CRNTI */
14279       idx++;
14280       ueSetRsp->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_C_RNTI;
14281       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14282       ueSetRsp->protocolIEs.list.array[idx]->value.present = UEContextSetupResponseIEs__value_PR_C_RNTI;
14283       ueSetRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI = ueCb->crnti;
14284
14285
14286       /* Drb Setup List */
14287       idx++;
14288       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14289                                                    ProtocolIE_ID_id_DRBs_Setup_List;
14290       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14291       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14292                                                             UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
14293       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
14294             &ueCb->f1UeDb->duUeCfg);
14295       if(ret == RFAILED)
14296       {
14297          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
14298          freeF1UeDb(ueCb->f1UeDb);
14299          ueCb->f1UeDb = NULLP;
14300          break;
14301       }
14302
14303       /* Free UeContext Db created during Ue context Req */
14304       freeF1UeDb(ueCb->f1UeDb);
14305       ueCb->f1UeDb = NULLP;
14306
14307       /* TODO: To send Drb list */
14308       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14309
14310       /* Encode the UE context setup response type as APER */
14311       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
14312       encBufSize = 0;
14313       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14314             encBuf);
14315       /* Encode results */
14316       if(encRetVal.encoded == ENCODE_FAIL)
14317       {
14318          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
14319                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14320          ret = RFAILED;
14321          break;
14322       }
14323       else
14324       {
14325          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
14326 #ifdef DEBUG_ASN_PRINT
14327          for(int i=0; i< encBufSize; i++)
14328          {
14329             printf("%x",encBuf[i]);
14330          }
14331 #endif
14332       }
14333
14334       /* Sending  msg  */
14335       if(sendF1APMsg()  != ROK)
14336       {
14337          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
14338          ret = RFAILED;
14339          break;
14340       }
14341       break;
14342    }
14343    FreeUeContextSetupRsp(f1apMsg);
14344    return ret;
14345 }/* End of BuildAndSendUeContextSetupRsp */
14346 /*******************************************************************
14347 *
14348 * @brief  Build And Send Ue Context Rsp
14349 *
14350 * @details
14351 *
14352 *    Function : BuildAndSendUeCtxtRsp
14353 *
14354 *    Functionality : Build And Send Ue Context Rsp
14355
14356 * @params[in]
14357 * @return sucess = ROK
14358 *         failure = RFAILED
14359 *
14360 * ****************************************************************/
14361 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
14362 {
14363    uint8_t cellIdx = 0, actionType = 0;
14364
14365    GET_CELL_IDX(cellId, cellIdx);
14366    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
14367
14368    switch(actionType)
14369    {
14370       case UE_CTXT_SETUP:
14371          {
14372             if((BuildAndSendUeContextSetupRsp(cellId,ueId)) != ROK)
14373             {
14374                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextSetupRsp()");
14375                return RFAILED;
14376             }
14377             break;
14378          }
14379       case UE_CTXT_MOD:
14380          {
14381             if((BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1])) != ROK)
14382             {
14383                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextModRsp");
14384                return RFAILED;
14385             }
14386             break;
14387          }
14388       default:
14389          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
14390          break;
14391
14392    }
14393    return ROK;
14394 }
14395
14396 /*******************************************************************
14397  *
14398  * @brief deallocating the memory of  F1reset msg
14399  *
14400  * @details
14401  *
14402  *    Function : FreeF1ResetReq
14403  *
14404  *    Functionality :
14405  *         - freeing memory of F1reset request msg
14406  *
14407  * @params[in]
14408  * @return void
14409  *
14410  *
14411  * ****************************************************************/
14412 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
14413 {
14414    uint8_t idx =0 ;
14415    Reset_t *f1ResetMsg;
14416
14417    if(f1apMsg)
14418    {
14419       if(f1apMsg->choice.initiatingMessage)
14420       {
14421          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14422
14423          if(f1ResetMsg->protocolIEs.list.array)
14424          {
14425             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
14426             {
14427                if(f1ResetMsg->protocolIEs.list.array[idx])
14428                {
14429                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14430                }
14431             }
14432             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14433          }
14434          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14435       }
14436       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14437    }
14438 }
14439 /*******************************************************************
14440  *
14441  * @brief Build and Send F1reset request
14442  *
14443  * @details
14444  *
14445  *    Function : BuildAndSendF1ResetReq
14446  *
14447  *    Functionality:
14448  *         - Build and Send F1reset request msg
14449  *
14450  * @params[in]
14451  * @return ROK     - success
14452  *         RFAILED - failure
14453  *
14454  * ****************************************************************/
14455 uint8_t BuildAndSendF1ResetReq()
14456 {
14457    uint8_t          elementCnt=0;
14458    uint8_t          idx=0;
14459    uint8_t          ret= RFAILED;
14460    Reset_t          *f1ResetMsg = NULLP;
14461    F1AP_PDU_t       *f1apMsg = NULLP;
14462    asn_enc_rval_t   encRetVal;
14463    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
14464    do
14465    {
14466       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14467       if(f1apMsg == NULLP)
14468       {
14469          break;
14470       }
14471       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14472       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14473       if(f1apMsg->choice.initiatingMessage == NULLP)
14474       {
14475          break;
14476       }
14477       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
14478       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
14479       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
14480
14481       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14482
14483       elementCnt = 3;
14484       f1ResetMsg->protocolIEs.list.count = elementCnt;
14485       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
14486
14487       /* Initialize the F1Setup members */
14488       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14489       if(f1ResetMsg->protocolIEs.list.array == NULLP)
14490       {
14491          break;
14492       }
14493       for(idx=0; idx<elementCnt; idx++)
14494       {
14495          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14496          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
14497          {
14498             break;
14499          }
14500       }
14501
14502       /*TransactionID*/
14503       idx=0;
14504       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14505       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14506       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
14507       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
14508
14509       /*Cause*/
14510       idx++;
14511       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
14512       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
14513       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
14514       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
14515       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
14516
14517       /*Reset Type*/
14518       idx++;
14519       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
14520       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14521       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
14522       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
14523       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
14524
14525       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14526
14527       /* Encode the F1SetupRequest type as APER */
14528       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14529       encBufSize = 0;
14530       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14531             encBuf);
14532
14533       /* Encode results */
14534       if(encRetVal.encoded == ENCODE_FAIL)
14535       {
14536          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
14537                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14538          break;
14539       }
14540       else
14541       {
14542          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
14543 #ifdef DEBUG_ASN_PRINT
14544          for(idx=0; idx< encBufSize; idx++)
14545          {
14546             printf("%x",encBuf[idx]);
14547          }
14548 #endif
14549       }
14550
14551       if(sendF1APMsg() != ROK)
14552       {
14553          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
14554          break;
14555       }
14556
14557       ret = ROK;
14558       break;
14559    }while(true);
14560
14561    FreeF1ResetReq(f1apMsg);
14562    return ret;
14563 }
14564 /*******************************************************************
14565  *
14566  * @brief Build And Send F1ResetAck
14567  *
14568  * @details
14569  *
14570  *    Function : BuildAndSendF1ResetAck
14571  *
14572  *    Functionality:
14573  *         - Build And Send  F1ResetRSP
14574  *
14575  * @return ROK     - success
14576  *         RFAILED - failure
14577  *
14578  * ****************************************************************/
14579 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
14580 {
14581    uint8_t idx;
14582    ResetAcknowledge_t *f1ResetAck;
14583
14584    if(f1apMsg)
14585    {
14586       if(f1apMsg->choice.successfulOutcome)
14587       {
14588          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14589
14590          if(f1ResetAck->protocolIEs.list.array)
14591          {
14592             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
14593             {
14594                if(f1ResetAck->protocolIEs.list.array[idx])
14595                {
14596                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14597                }
14598             }
14599             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14600          }
14601          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14602       }
14603       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14604    }
14605 }
14606
14607 /*******************************************************************
14608  *
14609  * @brief Build And Send F1ResetAck
14610  *
14611  * @details
14612  *
14613  *    Function : BuildAndSendF1ResetAck
14614  *
14615  *    Functionality:
14616  *         - Build And Send  F1ResetRSP
14617  *
14618  *  @params[in]
14619  * @return ROK     - success
14620  *         RFAILED - failure
14621  *
14622  * ****************************************************************/
14623 uint8_t BuildAndSendF1ResetAck()
14624 {
14625    uint8_t                idx = 0;
14626    uint8_t                elementCnt = 0;
14627    uint8_t                ret = RFAILED;
14628    F1AP_PDU_t             *f1apMsg = NULL;
14629    ResetAcknowledge_t     *f1ResetAck = NULLP;
14630    asn_enc_rval_t         encRetVal;
14631    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
14632
14633    do{
14634       /* Allocate the memory for F1ResetRequest_t */
14635       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14636       if(f1apMsg == NULLP)
14637       {
14638          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14639          break;
14640       }
14641
14642       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
14643
14644       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14645       if(f1apMsg->choice.successfulOutcome == NULLP)
14646       {
14647          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14648          break;
14649       }
14650       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
14651       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
14652       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14653
14654       elementCnt = 1;
14655
14656       f1ResetAck->protocolIEs.list.count = elementCnt;
14657       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
14658
14659       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14660       if(f1ResetAck->protocolIEs.list.array == NULLP)
14661       {
14662          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
14663          break;
14664       }
14665
14666       for(idx=0; idx<elementCnt; idx++)
14667       {
14668          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14669          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
14670          {
14671             break;
14672          }
14673       }
14674       /*TransactionID*/
14675       idx = 0;
14676       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14677       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14678       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
14679       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
14680
14681       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14682
14683       /* Encode the F1SetupRequest type as UPER */
14684       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14685       encBufSize = 0;
14686       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
14687
14688       /* Check encode results */
14689       if(encRetVal.encoded == ENCODE_FAIL)
14690       {
14691          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
14692                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14693          break;
14694       }
14695       else
14696       {
14697          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
14698 #ifdef DEBUG_ASN_PRINT
14699          for(int i=0; i< encBufSize; i++)
14700          {
14701             printf("%x",encBuf[i]);
14702          }
14703 #endif
14704       }
14705       /* Sending msg */
14706       if(sendF1APMsg() != ROK)
14707       {
14708          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
14709          break;
14710       }
14711
14712       ret = ROK;
14713       break;
14714    }while(true);
14715
14716    FreeF1ResetAck(f1apMsg);
14717    return ret;
14718 }
14719 /******************************************************************
14720 *
14721 * @brief free F1 reset msg allocated by aper_decoder
14722 *
14723 * @details
14724 *
14725 *    Function : freeAperDecodeF1ResetMsg
14726 *
14727 *    Functionality: free F1 reset msg allocated by aper_decoder
14728 *
14729 * @params[in] Reset_t *f1ResetMsg
14730 * @return void
14731 *
14732 * ****************************************************************/
14733
14734 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
14735 {
14736    uint8_t ieIdx =0;
14737    if(f1ResetMsg->protocolIEs.list.array)
14738    {
14739       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
14740       {
14741          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
14742          {
14743             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
14744          }
14745       }
14746       free(f1ResetMsg->protocolIEs.list.array);
14747    }
14748 }
14749
14750 /******************************************************************
14751  *
14752  * @brief Processes DL RRC Message Transfer  sent by CU
14753  *
14754  * @details
14755  *
14756  *    Function : procF1ResetReq
14757  *
14758  *    Functionality: Processes DL RRC Message Transfer sent by CU
14759  *
14760  * @params[in] F1AP_PDU_t ASN decoded F1AP message
14761  * @return ROK     - success
14762  *         RFAILED - failure
14763  *
14764  * ****************************************************************/
14765 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
14766 {
14767    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
14768    uint8_t       ieIdx = 0;
14769    uint8_t        ret = ROK;
14770    Reset_t       *f1ResetMsg = NULLP;
14771
14772    DU_LOG("\nINFO   -->  Processing F1 reset request");
14773    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14774
14775    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
14776    {
14777       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
14778       {
14779          case ProtocolIE_ID_id_TransactionID:
14780             break;
14781
14782          case ProtocolIE_ID_id_Cause:
14783             break;
14784
14785          case ProtocolIE_ID_id_ResetType:
14786             {
14787                break;
14788             }
14789
14790          default:
14791             break;
14792       }
14793    }
14794    ret = BuildAndSendF1ResetAck();
14795    DU_LOG("\nINFO   -->  UE release is not supported for now");
14796
14797    freeAperDecodeF1ResetMsg(f1ResetMsg);
14798
14799    return ret;
14800 }
14801
14802 /*******************************************************************
14803  *
14804  * @brief free the RRC delivery report
14805  *
14806  * @details
14807  *
14808  *    Function : freeRrcDeliveryReport
14809  *
14810  *    Functionality: free the RRC delivery report
14811  *
14812  * @params[in]
14813  * @return ROK     - success
14814  *         RFAILED - failure
14815  *
14816  * ****************************************************************/
14817 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
14818 {
14819    uint8_t idx=0;
14820    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14821
14822    if(f1apMsg)
14823    {
14824       if(f1apMsg->choice.initiatingMessage)
14825       {
14826          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14827          if(rrcDeliveryReport->protocolIEs.list.array)
14828          {
14829             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
14830                   idx++)
14831             {
14832                if(rrcDeliveryReport->protocolIEs.list.array[idx])
14833                {
14834                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
14835                         sizeof(RRCDeliveryReportIEs_t));
14836                }
14837             }
14838             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
14839                   rrcDeliveryReport->protocolIEs.list.size);
14840          }
14841          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14842       }
14843       DU_FREE(f1apMsg,
14844             sizeof(F1AP_PDU_t));
14845    }
14846 }
14847
14848 /*******************************************************************
14849 *
14850 * @brief Builds and sends the RRC delivery report
14851 *
14852 * @details
14853 *
14854 *    Function : BuildAndSendRrcDeliveryReport
14855 *
14856 *    Functionality: Builds and sends the RRC delivery report
14857 *
14858 * @params[in]
14859 *
14860 * @return ROK     - success
14861 *         RFAILED - failure
14862 *
14863 * ****************************************************************/
14864 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
14865    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
14866 {
14867    uint8_t             ret = RFAILED;
14868    uint8_t             idx    = 0;
14869    uint8_t             idx1   = 0;
14870    uint8_t             elementCnt = 0;
14871    F1AP_PDU_t          *f1apMsg = NULLP;
14872    asn_enc_rval_t      encRetVal;
14873    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14874
14875    do{
14876
14877       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
14878       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14879       if(f1apMsg == NULLP)
14880       {
14881          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14882          break;
14883       }
14884       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14885       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14886       if(f1apMsg->choice.initiatingMessage == NULLP)
14887       {
14888          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
14889          break;
14890       }
14891       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
14892       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
14893       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
14894
14895       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14896       elementCnt = 4;
14897       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
14898       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
14899
14900       /* Initialize the F1Setup members */
14901       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
14902       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
14903       {
14904          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
14905          break;
14906       }
14907       for(idx =0 ;idx <elementCnt; idx++)
14908       {
14909          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
14910          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
14911          {
14912             break;
14913          }
14914       }
14915
14916       idx1 = 0;
14917
14918       /*GNB CU UE F1AP ID*/
14919       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14920       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
14921       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
14922       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14923
14924       /*GNB DU UE F1AP ID*/
14925       idx1++;
14926       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14927       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
14928       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
14929       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14930
14931       /*RRC delivery status*/
14932       idx1++;
14933       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
14934       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
14935       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
14936       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
14937       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
14938       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
14939       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
14940
14941       /* SRB ID */
14942       idx1++;
14943       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
14944       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
14945       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
14946       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
14947
14948       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14949
14950       /* Encode the RRC DELIVERY REPORT type as APER */
14951       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14952       encBufSize = 0;
14953       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14954             encBuf);
14955
14956       /* Encode results */
14957       if(encRetVal.encoded == ENCODE_FAIL)
14958       {
14959          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
14960                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14961          break;
14962       }
14963       else
14964       {
14965          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
14966 #ifdef DEBUG_ASN_PRINT
14967          for(idx=0; idx< encBufSize; idx++)
14968          {
14969             printf("%x",encBuf[idx]);
14970          }
14971 #endif
14972       }
14973
14974       /* Sending msg */
14975       if(sendF1APMsg() != ROK)
14976       {
14977          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
14978          break;
14979       }
14980       ret = ROK;
14981       break;
14982
14983    }while(true);
14984
14985    freeRrcDeliveryReport(f1apMsg);
14986    return ret;
14987 }
14988
14989 /*******************************************************************
14990  *
14991  * @brief Processes cells to be activated
14992  *
14993  * @details
14994  *
14995  *    Function : extractCellsToBeActivated
14996  *
14997  *    Functionality:
14998  *      - Processes cells to be activated list received in F1SetupRsp
14999  *
15000  * @params[in] void
15001  * @return ROK     - success
15002  *         RFAILED - failure
15003  *
15004  * ****************************************************************/
15005
15006 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
15007 {
15008    uint8_t  ret = ROK;
15009    uint16_t idx, pci = 0;
15010    uint64_t nci;
15011    Cells_to_be_Activated_List_Item_t cell;
15012
15013    for(idx=0; idx<cellsToActivate.list.count; idx++)
15014    {
15015       nci = 0;
15016       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
15017       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
15018
15019       if(cell.nRPCI)
15020       {
15021          pci = *cell.nRPCI;
15022       }
15023       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
15024    }
15025    return ret;
15026 }
15027 /******************************************************************
15028 *
15029 * @brief Processes F1 Setup Response allocated by aper_decoder
15030 *
15031 * @details
15032 *
15033 *    Function : freeF1SetupRsp
15034 *
15035 *    Functionality: free F1 Setup Response allocated by aper_decoder
15036 *
15037 * @params[in] F1SetupResponse_t *f1SetRspMsg
15038 * @return void
15039 *
15040 * ****************************************************************/
15041
15042 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
15043 {
15044    uint8_t ieIdx =0;
15045    uint8_t arrIdx =0;
15046    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
15047    RRC_Version_t      *rrcVer =NULLP;
15048
15049    if(f1SetRspMsg->protocolIEs.list.array)
15050    {
15051       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
15052       {
15053          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
15054          {
15055             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
15056             {
15057                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15058                   {
15059                      cellToActivate =
15060                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
15061                      if(cellToActivate->list.array)
15062                      {
15063                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
15064                         {
15065                            if(cellToActivate->list.array[arrIdx])
15066                            {
15067
15068                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
15069                               pLMN_Identity.buf)
15070                               {
15071                                  if(cellToActivate->list.array[0]->value.choice.\
15072                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
15073                                  {
15074                                     free(cellToActivate->list.array[0]->value.choice.\
15075                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
15076                                  }
15077
15078                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
15079                                        nRCGI.pLMN_Identity.buf);
15080                               }
15081                               free(cellToActivate->list.array[arrIdx]);
15082                            }
15083                         }
15084                         free(cellToActivate->list.array);
15085                      }
15086                      break;
15087                   }
15088                case ProtocolIE_ID_id_TransactionID:
15089                   {
15090                      break;
15091                   }
15092                case ProtocolIE_ID_id_gNB_CU_Name:
15093                   {
15094                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
15095                      break;
15096                   }
15097                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15098                   {
15099                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
15100                      if(rrcVer->latest_RRC_Version.buf)
15101                      {
15102                         if(rrcVer->iE_Extensions)
15103                         {
15104                            if(rrcVer->iE_Extensions->list.array)
15105                            {
15106                               if(rrcVer->iE_Extensions->list.array[0])
15107                               {
15108                                  if(rrcVer->iE_Extensions->list.\
15109                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
15110                                  {
15111                                     free(rrcVer->iE_Extensions->list.\
15112                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
15113                                  }
15114                                  free(rrcVer->iE_Extensions->list.array[0]);
15115                               }
15116                               free(rrcVer->iE_Extensions->list.array);
15117                            }
15118                            free(rrcVer->iE_Extensions);
15119                         }
15120                         free(rrcVer->latest_RRC_Version.buf);
15121                      }
15122                      break;
15123
15124                   }
15125                default:
15126                   {
15127                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15128                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
15129                   }
15130             }
15131             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
15132          }
15133       }
15134       free(f1SetRspMsg->protocolIEs.list.array);
15135    }
15136 }
15137 /******************************************************************
15138  *
15139  * @brief Processes F1 Setup Response sent by CU
15140  *
15141  * @details
15142  *
15143  *    Function : procF1SetupRsp
15144  *
15145  *    Functionality: Processes F1 Setup Response sent by CU
15146  *
15147  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15148  * @return ROK     - success
15149  *         RFAILED - failure
15150  *
15151  * ****************************************************************/
15152 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
15153 {
15154    uint8_t ret = ROK;
15155    uint16_t idx =0;
15156    F1SetupResponse_t *f1SetRspMsg = NULLP;
15157    GNB_CU_Name_t     *cuName = NULLP;
15158    F1SetupRsp  f1SetRspDb;
15159    RRC_Version_t      *rrcVer =NULLP;
15160
15161    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
15162
15163    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
15164    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
15165
15166    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
15167    {
15168       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
15169       {
15170          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15171             {
15172                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
15173                      value.choice.Cells_to_be_Activated_List);
15174                break;
15175             }
15176          case ProtocolIE_ID_id_TransactionID:
15177             {
15178                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
15179                                     value.choice.TransactionID;
15180                break;
15181             }
15182          case ProtocolIE_ID_id_gNB_CU_Name:
15183             {
15184                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
15185                         value.choice.GNB_CU_Name;
15186                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
15187                break;
15188             }
15189          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15190             {
15191                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
15192                strcpy(f1SetRspDb.rrcVersion.rrcVer,
15193                      (const char*)rrcVer->latest_RRC_Version.buf);
15194                break;
15195             }
15196          default:
15197             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15198                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
15199       }
15200       duProcF1SetupRsp();
15201    }
15202
15203    freeAperDecodeF1SetupRsp(f1SetRspMsg);
15204
15205    duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
15206    DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
15207    if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
15208    {
15209       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the buf of F1setup response");
15210       return RFAILED;
15211    }
15212    memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
15213
15214    if(BuildAndSendE2SetupReq() != ROK)
15215    {
15216       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
15217       return RFAILED;
15218    }
15219    return ret;
15220 }
15221 /*******************************************************************
15222 *
15223 * @brief free GNB DU config update ack
15224 *
15225 * @details
15226 *
15227 *    Function : freeAperDecodeGnbDuAck
15228 *
15229 *    Functionality: Processes GNB DU config update ack And
15230 *                     added free part for the memory allocated by aper_decoder
15231 *
15232 * @params[in] F1AP_PDU_t ASN decoded F1AP message
15233 * @return ROK     - success
15234 *         RFAILED - failure
15235 *
15236 * ****************************************************************/
15237
15238 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
15239 {
15240    uint8_t ieIdx = 0;
15241
15242    if(gnbDuAck->protocolIEs.list.array)
15243    {
15244       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15245       {
15246          if(gnbDuAck->protocolIEs.list.array[ieIdx])
15247          {
15248             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
15249          }
15250       }
15251       free(gnbDuAck->protocolIEs.list.array);
15252    }
15253 }
15254
15255 /*******************************************************************
15256 *
15257 * @brief Building  result of gnb-du config update ack output
15258 *
15259 * @details
15260 *
15261 *    Function : duProcGnbDuCfgUpdAckMsg
15262 *
15263 *    Functionality:
15264 *        Building output of gnb-du config update ack
15265 *
15266 * @params[in] transId
15267 * @return void
15268 *
15269 * ****************************************************************/
15270
15271 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
15272 {
15273    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
15274    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
15275    uint16_t cellIdx =0, crnti=0;
15276    uint64_t cellId =0;
15277    CmLList *f1apPduNode = NULLP;
15278    ReservedF1apPduInfo *f1apPduInfo =NULLP;
15279    F1AP_PDU_t *f1apMsgPdu = NULLP;
15280    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
15281    BIT_STRING_t *cellIdentity=NULLP;
15282    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
15283    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
15284    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
15285
15286    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
15287    f1apPduNode = searchFromReservedF1apPduList(transId);
15288    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
15289    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
15290
15291    if(f1apMsgPdu)
15292    {
15293       if(f1apMsgPdu->choice.initiatingMessage)
15294       {
15295          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
15296          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
15297          {
15298             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
15299             {
15300                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
15301                   {
15302                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
15303                                      Served_Cells_To_Delete_List;
15304                      if(cellsToDelete->list.array)
15305                      {
15306                         if(cellsToDelete->list.array[arrIdx])
15307                         {
15308                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
15309                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
15310                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
15311                            {
15312                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
15313                               bitStringToInt(cellIdentity, &cellId);
15314
15315                               GET_CELL_IDX(cellId, cellIdx);
15316                               if(duCb.actvCellLst[cellIdx] != NULLP)
15317                               {
15318                                  duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
15319                               }
15320                            }
15321                         }
15322                      }
15323
15324                      if(duCb.actvCellLst[cellIdx] != NULLP)
15325                      {
15326                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
15327                         {
15328                            ret = duSendCellDeletReq(cellId);
15329                            if(ret == RFAILED)
15330                            {
15331                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
15332                               request for cellId[%lu]", cellId);
15333                            }
15334                         }
15335                         else
15336                         {
15337                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
15338                            while(totalActiveUe)
15339                            {
15340                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
15341                               {
15342                                  ueIdx++;
15343                                  continue;
15344                               }
15345
15346                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
15347                               GET_UE_ID(crnti,ueId);
15348                               /* Sending Ue Context release request only for maximum supporting UEs */
15349                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
15350                               if(ret == RFAILED)
15351                               {
15352                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
15353                                  request for cellId[%lu]", cellId);
15354                               }
15355                               ueIdx++;
15356                               totalActiveUe--;
15357                            }
15358                         }
15359                      }
15360                      else
15361                      {
15362                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%lu] not found", cellId);
15363                         ret = RFAILED;
15364                      }
15365                      break;
15366                   }
15367
15368                default:
15369                   break;
15370             }
15371          }
15372       }
15373    }
15374
15375    FreeDUConfigUpdate(f1apMsgPdu);
15376    deleteFromReservedF1apPduList(f1apPduNode);
15377    return ret;
15378 }
15379
15380 /*******************************************************************
15381 *
15382 * @brief Processes GNB DU config update ack
15383 *
15384 * @details
15385 *
15386 *    Function : procF1GNBDUCfgUpdAck
15387 *
15388 *    Functionality: added free part for the memory allocated by aper_decoder
15389 *
15390 * @params[in] F1AP_PDU_t *f1apMsg
15391 * @return void
15392 *
15393 * ****************************************************************/
15394 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
15395 {
15396    uint8_t ieIdx=0,transId=0;
15397    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
15398
15399    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
15400    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
15401
15402    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15403    {
15404       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
15405       {
15406          case ProtocolIE_ID_id_TransactionID:
15407             {
15408                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
15409                break;
15410             }
15411          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15412             {
15413                break;
15414             }
15415          default :
15416             {
15417                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
15418                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
15419                break;
15420             }
15421       }
15422    }
15423
15424    duProcGnbDuCfgUpdAckMsg(transId);
15425
15426 #if 0
15427    /* presently we are not supporting F1 Reset from DU to CU , we are only
15428     * supporting F1 Reset from CU to DU */
15429
15430    if(BuildAndSendF1ResetReq() != ROK)
15431    {
15432       return RFAILED;
15433    }
15434 #endif
15435
15436    freeAperDecodeGnbDuAck(gnbDuAck);
15437    return ROK;
15438 }
15439 /******************************************************************
15440 *
15441 * @brief free DL RRC Message Transfer allocated by aper_decoder
15442 *
15443 * @details
15444 *
15445 *    Function : freeAperDecodef1DlRrcMsg
15446 *
15447 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
15448 *
15449 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
15450 * @return ROK     - success
15451 *         RFAILED - failure
15452 *
15453 * ****************************************************************/
15454
15455 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
15456 {
15457    uint8_t ieIdx =0;
15458    RRCContainer_t *rrcContainer = NULLP;
15459
15460    if(f1DlRrcMsg->protocolIEs.list.array)
15461    {
15462       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
15463       {
15464          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
15465          {
15466             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
15467             {
15468                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15469                   break;
15470                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15471                   break;
15472                case ProtocolIE_ID_id_SRBID:
15473                   break;
15474                case ProtocolIE_ID_id_RRCContainer:
15475                   {
15476                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
15477                      free(rrcContainer->buf);
15478                   }
15479                case ProtocolIE_ID_id_ExecuteDuplication:
15480                   break;
15481                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15482                   break;
15483                   break;
15484             }
15485             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
15486          }
15487       }
15488       free(f1DlRrcMsg->protocolIEs.list.array);
15489    }
15490 }
15491 /******************************************************************
15492  *
15493  * @brief Processes DL RRC Message Transfer  sent by CU
15494  *
15495  * @details
15496  *
15497  *    Function : procF1DlRrcMsgTrans
15498  *
15499  *    Functionality: Processes DL RRC Message Transfer sent by CU
15500  *
15501  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15502  * @return ROK     - success
15503  *         RFAILED - failure
15504  *
15505  * ****************************************************************/
15506 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
15507 {
15508    uint8_t  idx, ret;
15509    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
15510    F1DlRrcMsg dlMsg;
15511    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
15512
15513    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
15514    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
15515
15516    ret = ROK;
15517
15518    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
15519    {
15520       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
15521       {
15522          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15523             {
15524                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
15525                break;
15526             }
15527          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15528             {
15529                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
15530                break;
15531             }
15532          case ProtocolIE_ID_id_SRBID:
15533             {
15534                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
15535                break;
15536             }
15537          case ProtocolIE_ID_id_ExecuteDuplication:
15538             dlMsg.execDup = true;
15539             break;
15540
15541          case ProtocolIE_ID_id_RRCContainer:
15542             {
15543                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
15544                {
15545                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
15546                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
15547                   if(dlMsg.rrcMsgPdu)
15548                   {
15549                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
15550                         dlMsg.rrcMsgSize);
15551                   }
15552                   else
15553                   {
15554                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
15555                      return RFAILED;
15556                   }
15557                }
15558                else
15559                {
15560                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
15561                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
15562                   return RFAILED;
15563                }
15564                break;
15565             }
15566          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15567             {
15568                dlMsg.deliveryStatRpt = true;
15569                break;
15570             }
15571          default:
15572             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
15573                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
15574       }
15575    }
15576
15577    ret = duProcDlRrcMsg(&dlMsg);
15578
15579    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
15580    return ret;
15581 }
15582 /*******************************************************************
15583  *
15584 * @brief Builds the DRB to be Setup Mod list
15585 *
15586 * @details
15587 *
15588 *    Function :
15589 *
15590 *    Functionality: Constructs the DRB to be Setup Mod list
15591 *
15592 * @params[in] DRBs_SetupMod_List_t *drbSet
15593 *
15594 * @return ROK     - success
15595 *         RFAILED - failure
15596 *
15597 * ****************************************************************/
15598 uint8_t BuildSrbSetupModList(SRBs_SetupMod_List_t *srbList, DuUeCfg *ueCfg)
15599 {
15600    uint8_t srbIdx = 0;
15601    struct SRBs_SetupMod_ItemIEs *srbItemIe;
15602
15603    srbList->list.count = ueCfg->numRlcLcs;
15604    srbList->list.size = srbList->list.count * sizeof(SRBs_SetupMod_ItemIEs_t *);
15605
15606    DU_ALLOC(srbList->list.array, srbList->list.size);
15607    if(srbList->list.array == NULLP)
15608    {
15609       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15610       return RFAILED;
15611    }
15612
15613    for(srbIdx = 0; srbIdx < srbList->list.count; srbIdx++)
15614    {
15615       DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15616       if(srbList->list.array[srbIdx] == NULLP)
15617       {
15618          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15619          return RFAILED;
15620       }
15621    }
15622
15623    for(srbIdx=0; srbIdx < srbList->list.count; srbIdx++)
15624    {
15625       srbItemIe = (struct SRBs_SetupMod_ItemIEs *)srbList->list.array[srbIdx];
15626       srbItemIe->id = ProtocolIE_ID_id_SRBs_SetupMod_Item;
15627       srbItemIe->criticality = Criticality_reject;
15628       srbItemIe->value.present = SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item;
15629       srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID = ueCfg->rlcLcCfg[srbIdx].rbId;
15630       srbItemIe->value.choice.SRBs_SetupMod_Item.lCID = ueCfg->rlcLcCfg[srbIdx].lcId;
15631    }
15632    return ROK;
15633 }
15634
15635 /*******************************************************************
15636  *
15637 * @brief Builds the DRB to be Setup Mod list
15638 *
15639 * @details
15640 *
15641 *    Function :
15642 *
15643 *    Functionality: Constructs the DRB to be Setup Mod list
15644 *
15645 * @params[in] DRBs_SetupMod_List_t *drbSet
15646 *
15647 * @return ROK     - success
15648 *         RFAILED - failure
15649 *
15650 * ****************************************************************/
15651
15652 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
15653 {
15654    uint8_t arrIdx =0;
15655    uint8_t drbCnt =0;
15656    struct DRBs_SetupMod_ItemIEs *drbItemIe;
15657
15658    drbCnt = ueCfg->numDrbSetupMod;
15659
15660    if(!drbCnt)
15661    {
15662       DU_LOG("\nINFO  -->  F1AP : BuildDrbToBeSetupModList(): No DRB information to avaialble to add");
15663       return ROK;
15664    }
15665
15666    drbSet->list.count = drbCnt;
15667    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
15668    DU_ALLOC(drbSet->list.array, drbSet->list.size);
15669    if(drbSet->list.array == NULLP)
15670    {
15671       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15672       return  RFAILED;
15673    }
15674    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
15675    {
15676       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15677       if(drbSet->list.array[arrIdx] == NULLP)
15678       {
15679               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15680               return  RFAILED;
15681       }
15682
15683       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
15684       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
15685       drbItemIe->criticality = Criticality_reject;
15686       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
15687       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
15688       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
15689       &ueCfg->upTnlInfo[arrIdx])!= ROK)
15690       {
15691          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
15692          return RFAILED;
15693       }
15694
15695    }
15696
15697    return ROK;
15698 }
15699 /*******************************************************************
15700 * @brief Free the memory allocated for DRB setup List
15701 *
15702 * @details
15703 *
15704 *    Function : FreeDrbSetupModList
15705 *
15706 *    Functionality:
15707 *       Free the memory allocated for DRB setup list
15708 *
15709 * @params[in] DRBs_Setup_List_t *
15710 * @return void
15711 *
15712 * ****************************************************************/
15713 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
15714 {
15715    uint8_t arrIdx = 0;
15716    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
15717
15718    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
15719    {
15720       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
15721       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
15722       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15723    }
15724    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
15725 }
15726
15727 /*******************************************************************
15728 * @brief Free the memory allocated for SRB setup List
15729 *
15730 * @details
15731 *
15732 *    Function : FreeSrbSetupModList
15733 *
15734 *    Functionality:
15735 *       Free the memory allocated for SRB setup list
15736 *
15737 * @params[in] SRBs_Setup_List_t *
15738 * @return void
15739 *
15740 * ****************************************************************/
15741 void FreeSrbSetupModList(SRBs_SetupMod_List_t *srbSetupList)
15742 {
15743    uint8_t srbIdx = 0;
15744
15745    for(srbIdx = 0; srbIdx < srbSetupList->list.count; srbIdx++)
15746       DU_FREE(srbSetupList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15747    DU_FREE(srbSetupList->list.array, srbSetupList->list.size);
15748 }
15749
15750 /*******************************************************************
15751 * @brief Free the memory allocated for UE Context Mod Response
15752 *
15753 * @details
15754 *
15755 *    Function : FreeUeContextModResp
15756 *
15757 *    Functionality:
15758 *       Free the memory allocated for UE Context Mod Response
15759 *
15760 * @params[in] F1AP_PDU_t *f1apMsg
15761 * @return void
15762 *
15763 * ****************************************************************/
15764
15765 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
15766 {
15767    uint8_t ieIdx;
15768    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15769    if(f1apMsg)
15770    {
15771       if(f1apMsg->choice.successfulOutcome)
15772       {
15773          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15774          if(ueContextModifyRes->protocolIEs.list.array)
15775          {
15776             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
15777             {
15778                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
15779                {
15780                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
15781                   {
15782                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15783                         break;
15784                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15785                         break;
15786                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
15787                         {
15788                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15789                             value.choice.DRBs_SetupMod_List));
15790                             break;
15791                         }
15792                      case ProtocolIE_ID_id_SRBs_SetupMod_List:
15793                         {
15794                            FreeSrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
15795                               SRBs_SetupMod_List));
15796                            break;
15797                         }
15798                   }
15799                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15800                }
15801
15802             }
15803             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15804          }
15805          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15806       }
15807       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
15808    }
15809 }
15810
15811 /*****************************************************************i
15812 *
15813 * @brief Creating the ue context modifcation response and sending
15814 *
15815 * @details
15816 *
15817 *    Function : BuildAndSendUeContextModRsp
15818 *
15819 *    Functionality:
15820 *         - Creating the ue context modifcation response
15821 *
15822 * @params[in] uint8_t cellId,uint8_t ueId
15823 * @return ROK     - success
15824 *         RFAILED - failure
15825 *
15826 * ****************************************************************/
15827 uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb)
15828 {
15829    uint8_t   ieIdx = 0, tnlIdx = 0, rbIdx = 0;
15830    uint8_t   elementCnt = 0;
15831    uint8_t   ret = RFAILED;
15832    F1AP_PDU_t *f1apMsg = NULLP;
15833    asn_enc_rval_t  encRetVal;
15834    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15835
15836    DU_LOG("\nINFO  -->  F1AP : Building UE context modification response\n");
15837
15838    while(true)
15839    {
15840       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
15841       if(f1apMsg == NULLP)
15842       {
15843          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
15844          break;
15845       }
15846
15847       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
15848
15849       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15850       if(f1apMsg->choice.successfulOutcome == NULLP)
15851       {
15852          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
15853          break;
15854       }
15855       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
15856       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
15857       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
15858
15859       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15860
15861       if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
15862       {
15863          if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
15864             elementCnt =3;
15865          else
15866             elementCnt =2;
15867       }
15868       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15869          elementCnt = 5;
15870       if(ueCb->f1UeDb->actionType == UE_CTXT_RRC_RECFG_COMPLETE)
15871          elementCnt = 2;
15872       ueContextModifyRes->protocolIEs.list.count = elementCnt;
15873       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
15874
15875       /* Initialize the UE context modification members */
15876       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15877       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
15878       {
15879          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
15880          break;
15881       }
15882
15883       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
15884       {
15885          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15886          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
15887          {
15888             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
15889             break;
15890          }
15891       }
15892
15893       ieIdx=0;
15894       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
15895       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15896       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
15897       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
15898       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
15899
15900       ieIdx++;
15901       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
15902       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15903       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
15904       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
15905       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
15906
15907       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15908       {
15909          ieIdx++;
15910          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCInformation;
15911          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15912          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
15913          UEContextModificationResponseIEs__value_PR_DUtoCURRCInformation;
15914          BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
15915       }
15916
15917       if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || ((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbSetupMod)))
15918       {
15919          ieIdx++;
15920          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
15921          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15922          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
15923                                                                            UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
15924          if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15925          {
15926             for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
15927             {
15928                if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
15929                {
15930                   memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
15931                }
15932             }
15933          }
15934          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15935                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
15936          if(ret != ROK)
15937          {
15938             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB setupmod List ");
15939             break;
15940          }
15941       }
15942
15943       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15944       {
15945          ieIdx++;
15946          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_SRBs_SetupMod_List;
15947          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15948          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
15949                                                                             UEContextModificationResponseIEs__value_PR_SRBs_SetupMod_List;
15950          for(rbIdx = 0; rbIdx < ueCb->rlcUeCfg.numLcs; rbIdx++)
15951          {
15952             if(ueCb->rlcUeCfg.rlcLcCfg[rbIdx].rbType == RB_TYPE_SRB)
15953             {
15954                memcpy(&ueCb->f1UeDb->duUeCfg.rlcLcCfg[ueCb->f1UeDb->duUeCfg.numRlcLcs++], &ueCb->rlcUeCfg.rlcLcCfg[rbIdx],\
15955                      sizeof(RlcBearerCfg));
15956             }
15957          }
15958          ret = BuildSrbSetupModList(&ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.SRBs_SetupMod_List, \
15959                &ueCb->f1UeDb->duUeCfg);
15960          if(ret != ROK)
15961          {
15962             DU_LOG( "\nERROR  -->  F1AP : Failed to build SRB setupmod List ");
15963             break;
15964          }
15965       }
15966
15967       freeF1UeDb(ueCb->f1UeDb);
15968       ueCb->f1UeDb = NULLP;
15969
15970       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15971
15972       /* Encode the F1SetupRequest type as APER */
15973       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15974       encBufSize = 0;
15975       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
15976
15977       /* Encode results */
15978       if(encRetVal.encoded == ENCODE_FAIL)
15979       {
15980          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
15981                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15982          ret = RFAILED;
15983          break;
15984       }
15985       else
15986       {
15987          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
15988 #ifdef DEBUG_ASN_PRINT
15989          for(int i=0; i< encBufSize; i++)
15990          {
15991             printf("%x",encBuf[i]);
15992          }
15993 #endif
15994       }
15995
15996       /* Sending  msg  */
15997       if(sendF1APMsg() != ROK)
15998       {
15999          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
16000          ret = RFAILED;
16001          break;
16002       }
16003
16004       ret = ROK;
16005       break;
16006    }
16007    FreeUeContextModResp(f1apMsg);
16008    return ret;
16009 }
16010 /*******************************************************************
16011  *
16012  * @brief Deallocating the memory allocated by the aper decoder
16013  *          for QOSInfo
16014  *
16015  * @details
16016  *
16017  *    Function : freeAperDecodeQosInfo
16018  *
16019  *    Functionality:  Deallocating the memory allocated for QOSInfo
16020  *
16021  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
16022  *
16023  * @return void
16024  *
16025  * ****************************************************************/
16026
16027 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
16028 {
16029    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
16030    {
16031       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
16032       {
16033          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
16034          {
16035             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
16036          }
16037          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
16038       }
16039       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
16040    }
16041 }
16042 /*******************************************************************
16043  *
16044  * @brief Deallocating the memory allocated by the aper decoder
16045  *          for UlTnlInfoforDrb
16046  *
16047  * @details
16048  *
16049  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
16050  *
16051  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
16052  *
16053  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
16054  *
16055  * @return void
16056  *
16057  * ****************************************************************/
16058 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
16059 {
16060    uint8_t arrIdx =0;
16061
16062    if(ulInfo->list.array)
16063    {
16064       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
16065       {
16066          if(ulInfo->list.array[arrIdx])
16067          {
16068             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
16069             {
16070                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
16071                {
16072                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
16073                   {
16074                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16075                            gTP_TEID.buf);
16076                   }
16077                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16078                         transportLayerAddress.buf);
16079                }
16080                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
16081             }
16082             free(ulInfo->list.array[arrIdx]);
16083          }
16084       }
16085       free(ulInfo->list.array);
16086    }
16087 }
16088 /*******************************************************************
16089  *
16090  * @brief Deallocating the memory allocated by the aper decoder
16091  *          for DrbSetupModItem
16092  *
16093  * @details
16094  *
16095  *    Function : freeAperDecodeDrbSetupModItem
16096  *
16097  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
16098  *
16099  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
16100  *
16101  * @return void
16102  *
16103  * ****************************************************************/
16104
16105 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
16106 {
16107    uint8_t arrIdx =0;
16108    SNSSAI_t *snssai =NULLP;
16109    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
16110
16111    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
16112    switch(drbItem->qoSInformation.present)
16113    {
16114       case QoSInformation_PR_NOTHING:
16115          break;
16116       case QoSInformation_PR_eUTRANQoS:
16117          {
16118             if(drbItem->qoSInformation.choice.eUTRANQoS)
16119             {
16120                free(drbItem->qoSInformation.choice.eUTRANQoS);
16121             }
16122             break;
16123          }
16124       case QoSInformation_PR_choice_extension:
16125          {
16126             if(drbItem->qoSInformation.choice.choice_extension)
16127             {
16128                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
16129                      DRB_Information.dRB_QoS);
16130                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
16131                if(snssai->sST.buf)
16132                {
16133                   free(snssai->sST.buf);
16134                }
16135                if(snssai->sD)
16136                {
16137                   if(snssai->sD->buf)
16138                   {
16139                      free(snssai->sD->buf);
16140                   }
16141                   free(snssai->sD);
16142                }
16143
16144                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
16145                          DRB_Information.flows_Mapped_To_DRB_List;
16146                if(flowMap->list.array)
16147                {
16148                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
16149                   {
16150                      if(flowMap->list.array[arrIdx] )
16151                      {
16152                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
16153                         free(flowMap->list.array[arrIdx]);
16154                      }
16155                   }
16156                   free(flowMap->list.array);
16157                }
16158
16159                free(drbItem->qoSInformation.choice.choice_extension);
16160             }
16161             break;
16162          }
16163
16164    }
16165    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
16166    if(drbItem->uLConfiguration)
16167    {
16168       free(drbItem->uLConfiguration);
16169    }
16170 }
16171
16172 /*******************************************************************
16173  *
16174  * @brief Deallocating the memory allocated by the aper decoder
16175  *          for DrbToBeSetupModList
16176  *
16177  * @details
16178  *
16179  *    Function : freeAperDecodeDrbToBeSetupModList
16180  *
16181  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
16182  *
16183  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
16184  *
16185  * @return void
16186  *
16187  * ****************************************************************/
16188
16189 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
16190 {
16191    uint8_t arrIdx =0;
16192    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
16193
16194    if(drbSet->list.array)
16195    {
16196       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
16197       {
16198          if(drbSet->list.array[arrIdx] != NULLP)
16199          {
16200             if(arrIdx == 0)
16201             {
16202                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
16203                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
16204             }
16205             free(drbSet->list.array[arrIdx]);
16206          }
16207       }
16208       free(drbSet->list.array);
16209    }
16210
16211 }
16212 /*******************************************************************
16213  *
16214  * @brief Deallocating the memory allocated by the aper decoder
16215  *          for UeContextModificationReqMsg
16216  *
16217  * @details
16218  *
16219  *    Function : freeAperDecodeUeContextModificationReqMsg
16220  *
16221  *    Functionality:  Deallocating memory allocated for
16222  *                  UeContextModificationReqMsg
16223  *
16224  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
16225  *
16226  * @return void
16227  *
16228  * ****************************************************************/
16229 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *ueContextModifyReq )
16230 {
16231    uint8_t arrIdx, ieId;
16232
16233    if(ueContextModifyReq->protocolIEs.list.array)
16234    {
16235       for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
16236       {
16237          if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
16238          {
16239             ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
16240             switch(ieId)
16241             {
16242                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16243                   break;
16244                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16245                   break;
16246                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
16247                   {
16248                      freeAperDecodeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
16249                            value.choice.DRBs_ToBeSetupMod_List);
16250                      break;
16251                   }
16252                case ProtocolIE_ID_id_TransmissionActionIndicator:
16253                   break;
16254                case ProtocolIE_ID_id_RRCContainer:
16255                   {
16256                      free(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf);
16257                   }
16258             }
16259             free(ueContextModifyReq->protocolIEs.list.array[arrIdx]);
16260          }
16261       }
16262       free(ueContextModifyReq->protocolIEs.list.array);
16263    }
16264 }
16265 /*******************************************************************
16266  *
16267  * @brief processing the F1 UeContextModificationReq
16268  *
16269  * @details
16270  *
16271  *    Function : procF1UeContextModificationReq
16272  *
16273  *    Functionality:  processing the F1 UeContextModificationReq
16274  *
16275  * @params[in] F1AP_PDU_t *f1apMsg
16276  *
16277  * @return
16278  * ****************************************************************/
16279 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
16280 {
16281    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
16282    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0;
16283    DuUeCb   *duUeCb = NULLP;
16284    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
16285    DRBs_ToBeModified_List_t *drbModifiedCfg;
16286    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
16287
16288    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
16289    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
16290    {
16291       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
16292       {
16293          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16294             {
16295                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
16296                break;
16297             }
16298          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16299             {
16300                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
16301                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
16302                {
16303                   if(duCb.actvCellLst[cellIdx])
16304                   {
16305                      if((duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == gnbDuUeF1apId)&&\
16306                            (duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbCuUeF1apId == gnbCuUeF1apId))
16307                      {
16308                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1];
16309                         if(duUeCb->f1UeDb == NULLP)
16310                         {
16311                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
16312                            duUeCb->f1UeDb->cellIdx = cellIdx;
16313                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
16314                         }
16315                         break;
16316                      }
16317                   }
16318                }
16319                if(duUeCb == NULLP)
16320                {
16321                   DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
16322                   ret = RFAILED;
16323                }
16324                break;
16325             }
16326
16327          case ProtocolIE_ID_id_RRCContainer:
16328             {
16329                /* Filling Dl RRC Msg Info */
16330                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
16331                if(!duUeCb->f1UeDb->dlRrcMsg)
16332                {
16333                   DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16334                         Memory allocation failed ");
16335                   ret = RFAILED;
16336                }
16337                else
16338                {
16339                   duUeCb->f1UeDb->dlRrcMsgPres = true;
16340                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
16341                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
16342                         &ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
16343                         value.choice.RRCContainer);
16344                }
16345
16346                break;
16347             }
16348
16349          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
16350          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
16351             {
16352                if(duUeCb->f1UeDb)
16353                {
16354                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
16355                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
16356                   {
16357                      drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16358                                       choice.DRBs_ToBeSetupMod_List;
16359
16360                      if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
16361                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
16362                      {
16363                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
16364                         ret = RFAILED;
16365                      }
16366                   }
16367
16368                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
16369                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
16370
16371                   {
16372                      drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16373                                       choice.DRBs_ToBeModified_List;
16374                      if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
16375                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
16376                      {
16377                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
16378                         ret = RFAILED;
16379                      }
16380                   }
16381                }
16382                break;
16383             }
16384
16385          case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
16386             {
16387                DU_LOG("\nINFO  -->  DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
16388                if(duUeCb->f1UeDb)
16389                {
16390                   duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
16391                }
16392                break;
16393             }
16394
16395          case ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator:
16396             {
16397                if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator == \
16398                   RRCReconfigurationCompleteIndicator_true)
16399                {
16400                   duUeCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE;
16401                }
16402                break;
16403             }
16404          case ProtocolIE_ID_id_TransmissionActionIndicator:
16405             {
16406                if(duUeCb->f1UeDb)
16407                {
16408                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator  == TransmissionActionIndicator_stop)
16409                   {
16410                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = STOP_TRANSMISSION;
16411                   }
16412                   else
16413                   {
16414                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = RESTART_TRANSMISSION;
16415                   }
16416                }
16417                break;
16418             }
16419
16420          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
16421             {
16422                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
16423                {
16424                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
16425                }
16426                break;
16427             }
16428 #ifdef NR_DRX
16429          case ProtocolIE_ID_id_DRXConfigurationIndicator:
16430             {
16431                duUeCb->f1UeDb->duUeCfg.drxConfigIndicatorRelease = true;
16432                break;
16433             }
16434 #endif
16435
16436       }
16437    }
16438
16439    if(ret != RFAILED)
16440    {
16441       ret = duProcUeContextModReq(duUeCb);
16442    }
16443    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
16444    return ret;
16445 }
16446
16447 /*****************************************************************i
16448 *
16449 * @brief Free memory allocated for UE Context Release Request
16450 *
16451 * @details
16452 *
16453 *    Function : FreeUeContextReleaseReq
16454 *
16455 *    Functionality:
16456 *         - Free memory allocated for UE Context Release Request
16457 *
16458 * @params[in] F1AP_PDU_t *f1apMsg
16459 * @return void
16460 *
16461 * *************************************************************/
16462 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
16463 {
16464    uint8_t ieIdx;
16465    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
16466
16467    if(f1apMsg)
16468    {
16469       if(f1apMsg->choice.initiatingMessage)
16470       {
16471          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
16472          if(ueReleaseReq->protocolIEs.list.array)
16473          {
16474             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
16475             {
16476                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
16477             }
16478             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
16479          }
16480          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
16481       }
16482       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16483    }
16484
16485 }
16486 /*****************************************************************i
16487 *
16488 * @brief Build and Send UE Context Release Request
16489 *
16490 * @details
16491 *
16492 *    Function : BuildAndSendUeContextReleaseReq
16493 *
16494 *    Functionality:
16495 *         - Build and Send UE Context Release Request
16496 *
16497 * @params[in]
16498 * @return ROK     - success
16499 *         RFAILED - failure
16500 *
16501 * *************************************************************/
16502 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
16503 {
16504    bool memAllocFail = false;
16505    uint8_t ieIdx =0;
16506    uint8_t ret = RFAILED;
16507    uint16_t cellIdx =0;
16508    uint16_t crnti = 0;
16509    uint8_t  elementCnt = 0;
16510    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
16511    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
16512    asn_enc_rval_t encRetVal;
16513    F1AP_PDU_t *f1apMsg = NULLP;
16514    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
16515
16516    DU_LOG("\nINFO  --> Building the UE Context Release Request");
16517    do
16518    {
16519       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16520       if(f1apMsg == NULLP)
16521       {
16522          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
16523          break;
16524       }
16525
16526       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
16527       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
16528       if(f1apMsg->choice.initiatingMessage == NULLP)
16529       {
16530          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
16531          initiatingMessage");
16532          break;
16533       }
16534       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
16535       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
16536       f1apMsg->choice.initiatingMessage->value.present = \
16537       InitiatingMessage__value_PR_UEContextReleaseRequest;
16538
16539       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
16540
16541       elementCnt = 2;
16542
16543       ueReleaseReq->protocolIEs.list.count = elementCnt;
16544       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
16545
16546       /* Initialize the F1Setup members */
16547       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
16548       if(ueReleaseReq->protocolIEs.list.array == NULLP)
16549       {
16550          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
16551          break;
16552       }
16553       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
16554       {
16555          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
16556                sizeof(UEContextReleaseRequest_t));
16557          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
16558          {
16559             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
16560             memAllocFail = true;
16561             break;
16562          }
16563       }
16564       if(memAllocFail == true)
16565          break;
16566
16567       /* Fetching Ue Cb Info*/
16568       GET_CELL_IDX(cellId, cellIdx);
16569       if(duCb.actvCellLst[cellIdx] == NULLP)
16570       {
16571          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
16572          break;
16573       }
16574       else
16575       {
16576          GET_CRNTI(crnti, ueId);
16577          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
16578          {
16579             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
16580             break;
16581          }
16582          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
16583          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
16584       }
16585
16586       ieIdx=0;
16587       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16588       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16589       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
16590       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
16591       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16592
16593       ieIdx++;
16594       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16595       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16596       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
16597       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
16598       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16599
16600       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16601
16602       /* Encode the F1SetupRequest type as APER */
16603       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16604       encBufSize = 0;
16605       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
16606       /* Encode results */
16607       if(encRetVal.encoded == ENCODE_FAIL)
16608       {
16609          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
16610                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16611          break;
16612       }
16613       else
16614       {
16615          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
16616 #ifdef DEBUG_ASN_PRINT
16617          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
16618          {
16619             printf("%x",encBuf[ieIdx]);
16620          }
16621 #endif
16622       }
16623
16624       /* Sending msg */
16625       if(sendF1APMsg() != ROK)
16626       {
16627          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
16628          break;
16629       }
16630       ret = ROK;
16631       break;
16632    }while(true);
16633
16634    FreeUeContextReleaseReq(f1apMsg);
16635    return ret;
16636 }
16637 /*****************************************************************i
16638  *
16639  * @brief Free memory allocated for UE Context Release Complete
16640  *
16641  * @details
16642  *
16643  *    Function : FreeUeContextReleaseComplete
16644  *
16645  *    Functionality:
16646  *         - Free memory allocated for UE Context Release Complete
16647  *
16648  * @params[in] F1AP_PDU_t *f1apMsg
16649  * @return void
16650  *
16651  * *************************************************************/
16652 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
16653 {
16654    uint8_t ieIdx;
16655    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
16656
16657    if(f1apMsg)
16658    {
16659       if(f1apMsg->choice.successfulOutcome)
16660       {
16661          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
16662          if(ueReleaseComplete->protocolIEs.list.array)
16663          {
16664             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
16665             {
16666                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
16667             }
16668             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
16669          }
16670          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16671       }
16672       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16673    }
16674
16675 }
16676 /*****************************************************************i
16677  *
16678  * @brief Build and Send UE Context Release Complete
16679  *
16680  * @details
16681  *
16682  *    Function : BuildAndSendUeContextReleaseComplete
16683  *
16684  *    Functionality:
16685  *         - Build and Send UE Context Release Complete
16686  *
16687  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
16688  * @return ROK     - success
16689  *         RFAILED - failure
16690  *
16691  * *************************************************************/
16692 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
16693 {
16694    bool memAllocFail = false;
16695    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
16696    asn_enc_rval_t encRetVal;
16697    F1AP_PDU_t *f1apMsg = NULLP;
16698    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
16699
16700    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
16701    do
16702    {
16703       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16704       if(f1apMsg == NULLP)
16705       {
16706          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
16707          break;
16708       }
16709
16710       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
16711       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16712       if(f1apMsg->choice.successfulOutcome == NULLP)
16713       {
16714          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
16715                successfulOutcome");
16716          break;
16717       }
16718       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
16719       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
16720       f1apMsg->choice.successfulOutcome->value.present = \
16721       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
16722
16723       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
16724
16725       elementCnt = 2;
16726       ueReleaseComplete->protocolIEs.list.count = elementCnt;
16727       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
16728
16729       /* Initialize the UE Release Complete members */
16730       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
16731       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
16732       {
16733          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
16734          break;
16735       }
16736       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
16737       {
16738          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
16739                sizeof(UEContextReleaseComplete_t));
16740          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
16741          {
16742             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
16743             elements");
16744             memAllocFail = true;
16745             break;
16746          }
16747       }
16748       if(memAllocFail == true)
16749          break;
16750
16751
16752       ieIdx=0;
16753       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16754       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16755       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
16756       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
16757       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16758
16759       ieIdx++;
16760       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16761       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16762       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
16763       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
16764       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16765
16766       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16767
16768       /* Encode the F1SetupComplete type as APER */
16769       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16770       encBufSize = 0;
16771       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
16772       /* Encode results */
16773       if(encRetVal.encoded == ENCODE_FAIL)
16774       {
16775          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
16776                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16777          break;
16778       }
16779       else
16780       {
16781          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
16782 #ifdef DEBUG_ASN_PRINT
16783          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
16784          {
16785             printf("%x",encBuf[ieIdx]);
16786          }
16787 #endif
16788       }
16789
16790       /* Sending msg */
16791       if(sendF1APMsg() != ROK)
16792       {
16793          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
16794          break;
16795       }
16796       ret = ROK;
16797       break;
16798    }while(true);
16799
16800    if((ret == ROK) && (duCb.actvCellLst[cellId-1]) && (duCb.actvCellLst[cellId-1]->cellStatus == DELETION_IN_PROGRESS)
16801          && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
16802    {
16803       ret = duSendCellDeletReq(cellId);
16804       if(ret != ROK)
16805       {
16806          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
16807                Delete req for CellId");
16808       }
16809    }
16810    FreeUeContextReleaseComplete(f1apMsg);
16811    return ret;
16812
16813 }
16814
16815 /*******************************************************************
16816 *
16817 * @brief added free part for the memory allocated by aper_decoder
16818 *
16819 * @details
16820 *
16821 *    Function : freeAperDecodeUeContextReleaseCommand
16822 *
16823 *    Functionality: added free part for the memory allocated by aper_decoder
16824 *
16825 * @params[in] F1AP_PDU_t *f1apMsg
16826 * @return void
16827 *
16828 * ****************************************************************/
16829 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
16830 {
16831    uint8_t ieIdx=0;
16832    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
16833
16834    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
16835
16836    if(ueContextReleaseCommand->protocolIEs.list.array)
16837    {
16838       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
16839       {
16840          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
16841          {
16842             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
16843             {
16844                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16845                   break;
16846                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16847                   break;
16848                case ProtocolIE_ID_id_Cause:
16849                   break;
16850                case ProtocolIE_ID_id_RRCContainer:
16851                {
16852                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
16853                   {
16854                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
16855                   }
16856                   break;
16857                }
16858                default :
16859                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
16860                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
16861                   break;
16862             }
16863          }
16864          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
16865       }
16866       free(ueContextReleaseCommand->protocolIEs.list.array);
16867    }
16868 }
16869 /*******************************************************************
16870 *
16871 * @brief processing of UE Context Release Command
16872 *
16873 * @details
16874 *
16875 *    Function : procF1UeContextReleaseCommand
16876 *
16877 *    Functionality: processing of UE Context Release Command
16878 *
16879 * @params[in] F1AP_PDU_t *f1apMsg
16880 * @return void
16881 *
16882 * ****************************************************************/
16883 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
16884 {
16885    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
16886    uint16_t cellIdx =0, cellId = 0;
16887    bool ueIdxFound = false;
16888    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
16889    DuUeCb   *duUeCb = NULLP;
16890    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
16891
16892    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
16893
16894    if(ueContextReleaseCommand->protocolIEs.list.array)
16895    {
16896       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
16897       {
16898          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
16899          {
16900             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
16901             {
16902                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16903                   {
16904                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16905                                     value.choice.GNB_CU_UE_F1AP_ID;
16906                      break;
16907                   }
16908
16909                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16910                   {
16911                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16912                                      value.choice.GNB_DU_UE_F1AP_ID;
16913                      break;
16914                   }
16915
16916                case ProtocolIE_ID_id_Cause:
16917                   {
16918                      for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
16919                      {
16920                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
16921                         {
16922                            if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
16923                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
16924                            {
16925                               cellId = duCb.actvCellLst[cellIdx]->cellId;
16926                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
16927                               ueIdxFound = true;
16928                               break;
16929                            }
16930                         }
16931                         if(ueIdxFound == true)
16932                         {
16933                            break;
16934                         }
16935                      }
16936
16937                      if(!ueIdxFound)
16938                      {
16939                         DU_LOG("\nERROR  -->  F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
16940                         ret = RFAILED;
16941                      }
16942                      break;
16943                   }
16944
16945                case ProtocolIE_ID_id_RRCContainer:
16946                   {
16947                      if(ueIdxFound == true)
16948                      {
16949                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
16950                         if(duUeCb->f1UeDb)
16951                         {
16952                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
16953                            duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
16954                            duUeCb->f1UeDb->cellIdx = cellIdx;
16955                            /* Filling Dl RRC Msg Info */
16956                            DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
16957                            if(!duUeCb->f1UeDb->dlRrcMsg)
16958                            {
16959                               DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16960                                     Memory allocation failed ");
16961                               ret = RFAILED;
16962                            }
16963                            else
16964                            {
16965                               duUeCb->f1UeDb->dlRrcMsgPres = true;
16966                               memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
16967                               ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
16968                                     &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16969                                     value.choice.RRCContainer);
16970                            }
16971
16972                         }
16973                         else
16974                         {
16975                            DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16976                                  Memory allocation failed ");
16977                            ret = RFAILED;
16978
16979                         }
16980                      }
16981                      break;
16982                   }
16983                default :
16984                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
16985                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
16986                   break;
16987             }
16988          }
16989       }
16990    }
16991    if(ret != RFAILED)
16992    {
16993       duProcUeContextReleaseCommand(cellId, duUeCb);
16994    }
16995    freeAperDecodeUeContextReleaseCommand(f1apMsg);
16996    return ret;
16997 }
16998
16999 /**************************************************************
17000  *
17001  * @brief free the memory allocated by aper decoder for paging
17002  *
17003  * @details
17004  *
17005  *    Function : freeAperDecodePagingMsg
17006  *
17007  *    Functionality:
17008  *         - free the memory allocated by aper decoder for
17009  *         the paging f1ap msg
17010  *
17011  * @params[in] Paging_t   *paging
17012  * @return ROK     - success
17013  *         RFAILED - failure
17014  *
17015  ****************************************************************/
17016 void freeAperDecodePagingMsg(Paging_t   *paging)
17017 {
17018    uint8_t ieIdx, cellIdx;
17019    PagingCell_ItemIEs_t *pagingCellItemIes;
17020    PagingCell_Item_t *pagingCellItem;
17021    PagingCell_list_t  *pagingCelllist;
17022
17023    if(paging)
17024    {
17025       if(paging->protocolIEs.list.array)
17026       {
17027          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17028          {
17029             if(paging->protocolIEs.list.array[ieIdx])
17030             {
17031                switch(paging->protocolIEs.list.array[ieIdx]->id)
17032                {
17033                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17034                      {
17035                         free(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf);
17036                         break;
17037                      }
17038                   case ProtocolIE_ID_id_PagingIdentity:
17039                      {
17040                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
17041                         {
17042                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17043                            {
17044                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == \
17045                                     CNUEPagingIdentity_PR_fiveG_S_TMSI)
17046                               {
17047                                  free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf);
17048                               }
17049                               free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity);
17050                            }
17051                         }
17052                         break;
17053                      }
17054                   case ProtocolIE_ID_id_PagingCell_List:
17055                      {
17056                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17057                         if(pagingCelllist->list.array)
17058                         {
17059                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
17060                            {
17061                               if(pagingCelllist->list.array[cellIdx])
17062                               {
17063                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
17064                                  if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
17065                                  {
17066                                     pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17067                                     free(pagingCellItem->nRCGI.pLMN_Identity.buf);
17068                                     free(pagingCellItem->nRCGI.nRCellIdentity.buf);
17069                                  }
17070                                  free(pagingCelllist->list.array[cellIdx]);
17071                               }
17072                            }
17073                            free(pagingCelllist->list.array);
17074                         }
17075                         break;
17076                      }
17077                }
17078                free(paging->protocolIEs.list.array[ieIdx]);
17079             }
17080          }
17081          free(paging->protocolIEs.list.array);
17082
17083       }
17084    }
17085 }
17086
17087 /**************************************************************
17088  *
17089  * @brief processing the paging f1ap msg received from CU
17090  *
17091  * @details
17092  *
17093  *    Function : procPagingMsg
17094  *
17095  *    Functionality:
17096  *         - processing the paging f1ap msg received from CU
17097  *
17098  * @params[in] F1AP_PDU_t *f1apMsg
17099  * @return ROK     - success
17100  *         RFAILED - failure
17101  *
17102  *
17103  ****************************************************************/
17104 uint8_t procPagingMsg(F1AP_PDU_t *f1apMsg)
17105 {
17106    uint8_t ieIdx = 0, cellListIdx = 0;
17107    uint64_t cellId = 0;
17108    Paging_t   *paging = NULLP;
17109    PagingCell_list_t  *pagingCelllist = NULLP;
17110    PagingCell_ItemIEs_t *pagingCellItemIes = NULLP;
17111    PagingCell_Item_t *pagingCellItem = NULLP;
17112    DuPagingMsg *tmpPagingParam = NULLP;
17113
17114    paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
17115    if(paging)
17116    {
17117       if(paging->protocolIEs.list.array)
17118       {
17119          DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg));
17120          if(tmpPagingParam == NULLP)
17121          {
17122             DU_LOG("\nERROR  --> DU APP : Memory Allocation Failure in procPagingMsg");
17123             freeAperDecodePagingMsg(paging);
17124             return RFAILED;
17125          }
17126          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17127          {
17128             if(paging->protocolIEs.list.array[ieIdx])
17129             {
17130                switch(paging->protocolIEs.list.array[ieIdx]->id)
17131                {
17132                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17133                      {
17134                         bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10,\
17135                                          &tmpPagingParam->pagUeId);
17136                         break;
17137                      }
17138
17139                   case ProtocolIE_ID_id_PagingIdentity:
17140                      {
17141                         switch(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present)
17142                         {
17143                            case PagingIdentity_PR_cNUEPagingIdentity:
17144                               {
17145                                  if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17146                                  {
17147                                     bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.\
17148                                           cNUEPagingIdentity->choice.fiveG_S_TMSI, &tmpPagingParam->sTmsi);
17149
17150                                  }
17151                                  break;
17152                               }
17153                             case PagingIdentity_PR_rANUEPagingIdentity:
17154                                {
17155                                   /*TODO: This Identifier is specific to RAN Initiated Paging – Connected Mode Paging*/
17156                                   break;
17157                                }
17158                             default:
17159                                {
17160                                   DU_LOG("ERROR  -->  DU APP: Invalid UE Paging Identity, Skipping this Paging Message:");
17161                                   continue;
17162                                }
17163                         }
17164                      }
17165
17166                   case ProtocolIE_ID_id_PagingDRX:
17167                      {
17168                         tmpPagingParam->pagingDrxPres = TRUE;
17169                         tmpPagingParam->pagingDrx = convertPagingCycleEnumToValue(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX);
17170                         break;
17171                      }
17172
17173                   case ProtocolIE_ID_id_PagingPriority:
17174                      {
17175                         tmpPagingParam->pagPriority = paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority;
17176                         break;
17177                      }
17178
17179                   case ProtocolIE_ID_id_PagingCell_List:
17180                      {
17181                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17182                         if(pagingCelllist->list.array)
17183                         {
17184                            for(cellListIdx = 0; cellListIdx < pagingCelllist->list.count; cellListIdx++)
17185                            {
17186                               if(pagingCelllist->list.array[cellListIdx])
17187                               {
17188                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellListIdx];
17189                                  pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17190                                  bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId);
17191                                  if(processPagingMsg(cellId, tmpPagingParam) != ROK)
17192                                  {
17193                                     DU_LOG("\nERROR  --> DU APP : Paging Processing Failed at CellId:%lu",cellId);
17194                                     continue;
17195                                  }
17196                               }
17197                            }
17198                         }
17199                         break;
17200                      }
17201                    default:
17202                      {
17203                          DU_LOG("\nERROR  --> F1AP : Incorrect Paging IE option");
17204                          break;
17205                      }
17206                }
17207             }
17208          }
17209       }
17210    }
17211    DU_FREE(tmpPagingParam, sizeof(DuPagingMsg));
17212    freeAperDecodePagingMsg(paging);
17213
17214    return ROK;
17215 }
17216
17217 /**************************************************************
17218  *
17219  * @brief Handles received F1AP message and sends back response
17220  *
17221  * @details
17222  *
17223  *    Function : F1APMsgHdlr
17224  *
17225  *    Functionality:
17226  *         - Decodes received F1AP control message
17227  *         - Prepares response message, encodes and sends to SCTP
17228  *
17229  * @params[in]
17230  * @return ROK     - success
17231  *         RFAILED - failure
17232  *
17233  * ****************************************************************/
17234 void F1APMsgHdlr(Buffer *mBuf)
17235 {
17236    int i =0;
17237    char *recvBuf =NULLP;
17238    MsgLen copyCnt =0;
17239    MsgLen recvBufLen =0;
17240    F1AP_PDU_t *f1apMsg =NULLP;
17241    asn_dec_rval_t rval; /* Decoder return value */
17242    F1AP_PDU_t f1apasnmsg ;
17243    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
17244    ODU_PRINT_MSG(mBuf, 0,0);
17245
17246    /* Copy mBuf into char array to decode it */
17247    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
17248    DU_ALLOC(recvBuf, (Size)recvBufLen);
17249
17250    if(recvBuf == NULLP)
17251    {
17252       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
17253       return;
17254    }
17255    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
17256    {
17257       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
17258       return;
17259    }
17260
17261 #ifdef DEBUG_ASN_PRINT
17262    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
17263    for(i=0; i< recvBufLen; i++)
17264    {
17265       printf("%x",recvBuf[i]);
17266    }
17267 #endif
17268
17269    /* Decoding flat buffer into F1AP messsage */
17270    f1apMsg = &f1apasnmsg;
17271    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
17272
17273    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
17274
17275    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
17276    {
17277       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
17278       return;
17279    }
17280    printf("\n");
17281    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
17282
17283    switch(f1apMsg->present)
17284    {
17285       case F1AP_PDU_PR_successfulOutcome:
17286          {
17287             switch(f1apMsg->choice.successfulOutcome->value.present)
17288             {
17289                case SuccessfulOutcome__value_PR_ResetAcknowledge:
17290                   {
17291                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
17292                      break;
17293                   }
17294                case SuccessfulOutcome__value_PR_F1SetupResponse:
17295                   {
17296 #ifndef ODU_TEST_STUB
17297                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
17298 #endif
17299                      break;
17300                   }
17301
17302                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
17303                   {
17304                      procF1GNBDUCfgUpdAck(f1apMsg);
17305                      break;
17306                   }
17307
17308                default:
17309                   {
17310                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
17311                            f1apMsg->choice.successfulOutcome->value.present);
17312                      return;
17313                   }
17314             }/* End of switch(successfulOutcome) */
17315             free(f1apMsg->choice.successfulOutcome);
17316             break;
17317          }
17318       case F1AP_PDU_PR_initiatingMessage:
17319          {
17320             switch(f1apMsg->choice.initiatingMessage->value.present)
17321             {
17322                case InitiatingMessage__value_PR_Reset:
17323                   {
17324                      procF1ResetReq(f1apMsg);
17325                      break;
17326                   }
17327                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
17328                   {
17329                      procF1DlRrcMsgTrans(f1apMsg);
17330                      break;
17331                   }
17332                case InitiatingMessage__value_PR_UEContextSetupRequest:
17333                   {
17334                      procF1UeContextSetupReq(f1apMsg);
17335                      break;
17336                   }
17337                case InitiatingMessage__value_PR_UEContextModificationRequest:
17338                   {
17339                      procF1UeContextModificationReq(f1apMsg);
17340                      break;
17341                   }
17342                case InitiatingMessage__value_PR_UEContextReleaseCommand:
17343                   {
17344                       procF1UeContextReleaseCommand(f1apMsg);
17345                       break;
17346                   }
17347                case InitiatingMessage__value_PR_Paging:
17348                   {
17349                      procPagingMsg(f1apMsg);
17350                      break;
17351                   }
17352                default:
17353                   {
17354                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
17355                            f1apMsg->choice.initiatingMessage->value.present);
17356                      return;
17357                   }
17358             }/* End of switch(initiatingMessage) */
17359             free(f1apMsg->choice.initiatingMessage);
17360             break;
17361          }
17362
17363       default:
17364          {
17365             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
17366             return;
17367          }
17368          free(f1apMsg);
17369
17370    }/* End of switch(f1apMsg->present) */
17371
17372    DU_FREE(recvBuf, (Size)recvBufLen);
17373 } /* End of F1APMsgHdlr */
17374
17375 /**********************************************************************
17376   End of file
17377  **********************************************************************/