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 = (duCfgParam.duName != NULL) ? 5 : 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
1501       /*DU Name*/
1502       if(duCfgParam.duName != NULL)
1503       {
1504          ieIdx++;
1505          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1506          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1507          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1508          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1509             strlen((char *)duCfgParam.duName);
1510          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1511                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1512          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1513                buf == NULLP)
1514          {
1515             break;
1516          }
1517          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1518                choice.GNB_DU_Name.buf,
1519                (char*)&duCfgParam.duName);
1520
1521       }
1522
1523       /*Served Cell list */
1524       ieIdx++;
1525       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1526                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1527       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1528       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1529                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1530       duServedCell = &f1SetupReq->protocolIEs.list.\
1531                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1532       if(BuildServedCellList(duServedCell))
1533       {
1534          break;
1535       }
1536       /*RRC Version*/
1537       ieIdx++;
1538       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1539                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1540       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1541       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1542                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1543       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1544       if(BuildRrcVer(rrcVer))
1545       {
1546          break;
1547       }
1548       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1549
1550       /* Encode the F1SetupRequest type as APER */
1551       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1552       encBufSize = 0;
1553       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1554             encBuf);
1555
1556       /* Encode results */
1557       if(encRetVal.encoded == ENCODE_FAIL)
1558       {
1559          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1560                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1561          break;
1562       }
1563       else
1564       {
1565          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1566 #ifdef DEBUG_ASN_PRINT
1567          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1568          {
1569             printf("%x",encBuf[ieIdx]);
1570          }
1571 #endif
1572
1573          duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize;
1574          DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize);
1575          if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
1576          {
1577              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the encoding of f1setup req");
1578              return RFAILED;
1579          }
1580          memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
1581       }
1582
1583       /* Sending msg */
1584       if(sendF1APMsg() != ROK)
1585       {
1586          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1587          break;
1588       }
1589
1590       ret=ROK;
1591       break;
1592    }while(true);
1593
1594    FreeF1SetupReq(f1apMsg);
1595
1596    return ret;
1597 }/* End of BuildAndSendF1SetupReq */
1598
1599 /*******************************************************************
1600  *
1601  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1602  *
1603  * @details
1604  *
1605  *    Function : freeCellsToModifyItem
1606  *
1607  *    Functionality: Deallocating memory of variables allocated in
1608  *                    BuildAndSendDUConfigUpdate function
1609  *
1610  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1611  *
1612  * @return ROK     - void
1613  *
1614  * ****************************************************************/
1615
1616 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1617 {
1618    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1619    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1620    SliceSupportItem_t *sliceSupportItem = NULLP;
1621
1622    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1623    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1624
1625    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1626            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1627    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1628          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1629
1630    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1631    {
1632       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1633       {
1634          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1635
1636          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1637
1638          if(servedPlmnItem->iE_Extensions != NULLP)
1639          {
1640             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1641             {
1642                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1643                {
1644                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1645                         list.array != NULLP)
1646                   {
1647                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1648                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1649                      {
1650                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1651                               list.array[sliceLstIdx] != NULLP)
1652                         {
1653
1654                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1655                                               SliceSupportList.list.array[sliceLstIdx];
1656
1657                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1658                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1659                            {
1660                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1661                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1662                            }
1663                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1664                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1665                         }
1666                      }
1667                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1668                            choice.SliceSupportList.list.array,\
1669                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1670                            extensionValue.choice.SliceSupportList.list.size);
1671                   }
1672                }
1673                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1674                {
1675                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1676                }
1677                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1678             }
1679             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1680          }
1681       }
1682       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1683       {
1684          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1685       }
1686       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1687          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1688    }
1689
1690    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1691    {
1692       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1693    }
1694    else
1695    {
1696       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
1697       {
1698          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1699          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1700       }
1701    }
1702    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1703       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1704 }
1705
1706 /*******************************************************************
1707  *
1708  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1709  *
1710  * @details
1711  *
1712  *    Function : FreeDUConfigUpdate
1713  *
1714  *    Functionality: Deallocating memory of variables allocated in
1715  *                    BuildAndSendDUConfigUpdate function
1716  *
1717  * @params[in]  F1AP_PDU_t *f1apDuCfg
1718  *
1719  * @return ROK     - void
1720  *
1721  * ****************************************************************/
1722 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1723 {
1724    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1725    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1726    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1727    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1728    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1729    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1730
1731    if(f1apDuCfg != NULLP)
1732    {
1733       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1734       {
1735          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1736                        value.choice.GNBDUConfigurationUpdate;
1737          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1738          {
1739             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1740             {
1741                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1742                {
1743                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1744                   {
1745                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1746                         {
1747                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1748                                            value.choice.Served_Cells_To_Modify_List;
1749                            if(cellsToModify->list.array != NULLP)
1750                            {
1751                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1752                               {
1753                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1754                                  {
1755                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1756                                           Served_Cells_To_Modify_Item);
1757                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1758                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1759                                  }
1760                               }
1761                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1762                            }
1763                            break;
1764                         }
1765                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1766                         {
1767                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1768                                            value.choice.Served_Cells_To_Delete_List;
1769                            if(cellsToDelete->list.array != NULLP)
1770                            {
1771                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1772                               {
1773                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1774                                  {
1775                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1776                                           cellsToDelete->list.array[cellDeleteIdx]);
1777                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1778                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1779                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1780                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1781                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1782                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1783                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1784                                  }
1785                               }
1786                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1787                            }
1788
1789                            break;
1790                         }
1791                      case ProtocolIE_ID_id_gNB_DU_ID:
1792                         {
1793                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1794                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1795                            break;
1796                         }
1797                   }
1798                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1799                         sizeof(GNBDUConfigurationUpdateIEs_t));
1800                }
1801             }
1802             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1803          }
1804          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1805       }
1806       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1807    }
1808 }
1809
1810 /*******************************************************************
1811  *
1812  * @brief Fills Served Plmns required in ServCellInfo IE
1813  *
1814  * @details
1815  *
1816  *    Function : fillServedPlmns
1817  *
1818  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1819  *
1820  * @params[in] Pointer to ServedPLMNs_List_t *
1821  *
1822  * @return ROK     - success
1823  *         RFAILED - failure
1824  *
1825  *****************************************************************/
1826
1827 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1828 {
1829    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
1830
1831    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
1832    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
1833          array[arrayIdx]->pLMN_Identity.size);
1834    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
1835    {
1836       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1837       return RFAILED;
1838    }
1839    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
1840          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
1841    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1842    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
1843    {
1844       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1845       return RFAILED;
1846    }
1847
1848    ieListCnt=1;
1849    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
1850    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1851    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
1852          iE_Extensions->list.size);
1853    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
1854    {
1855       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1856       return RFAILED;
1857    }
1858    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
1859    {
1860       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
1861             sizeof(ServedPLMNs_ItemExtIEs_t));
1862       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
1863       {
1864          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1865          return RFAILED;
1866       }
1867    }
1868
1869    ieIdx = 0;
1870    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1871    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
1872    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
1873    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
1874    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1875    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1876       list.count = elementCnt;
1877    servedPlmn->list.array[arrayIdx]->\
1878       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1879       list.size = elementCnt * sizeof(SliceSupportItem_t *);
1880    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1881          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1882          list.array,servedPlmn->list.array[arrayIdx]->\
1883          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
1884    if(servedPlmn->list.array[arrayIdx]->\
1885          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1886          list.array == NULLP)
1887    {
1888       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1889       return RFAILED;
1890    }
1891
1892    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
1893    {
1894       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1895       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1896       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
1897       if(servedPlmn->list.array[arrayIdx]->\
1898       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1899       list.array[sliceLstIdx] == NULLP)
1900       {
1901          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1902          return RFAILED;
1903       }
1904
1905       servedPlmn->list.array[arrayIdx]->\
1906       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1907       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1908       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1909       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1910       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
1911       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
1912       sNSSAI.sST.size);
1913
1914       if(servedPlmn->list.array[arrayIdx]->\
1915       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1916       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1917       {
1918          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1919          return RFAILED;
1920       }
1921       servedPlmn->list.array[arrayIdx]->\
1922       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1923       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1924       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1925
1926       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1927       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1928       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1929       if(servedPlmn->list.array[arrayIdx]->\
1930       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1931       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1932       {
1933          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1934          return RFAILED;
1935       }
1936       servedPlmn->list.array[arrayIdx]->\
1937       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1938       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1939       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1940       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1941       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
1942       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1943       list.array[sliceLstIdx]->sNSSAI.sD->size);
1944       if(servedPlmn->list.array[arrayIdx]->\
1945       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1946       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1947       {
1948          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1949          return RFAILED;
1950       }
1951       memcpy(servedPlmn->list.array[arrayIdx]->\
1952       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1953       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1954       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
1955       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1956       list.array[sliceLstIdx]->sNSSAI.sD->size);
1957    }
1958    return ROK;
1959 }
1960
1961 /*******************************************************************
1962  *
1963  * @brief Fills Nr Fdd Info required in ServCellInfo IE
1964  *
1965  * @details
1966  *
1967  *    Function : fillNrFddInfo
1968  *
1969  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
1970  *
1971  * @params[in] FDD_Info_t *fDD
1972  *
1973  * @return ROK     - success
1974  *         RFAILED - failure
1975  *
1976  *****************************************************************/
1977
1978 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
1979 {
1980    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1981       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1982    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
1983    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1984    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1985          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1986    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1987    {
1988       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1989       return RFAILED;
1990    }
1991
1992    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
1993       sizeof(FreqBandNrItem_t));
1994    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
1995    {
1996       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1997       return RFAILED;
1998    }
1999
2000    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2001       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2002       freqBand[0].nrFreqBand;
2003    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2004    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2005       dlNrFreqInfo.nrArfcn;
2006    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2007    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2008    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2009    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2010    {
2011       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2012       return RFAILED;
2013    }
2014
2015    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
2016    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2017    {
2018       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2019       return RFAILED;
2020    }
2021
2022    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2023       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2024       freqBand[0].nrFreqBand;
2025    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2026
2027    /*Transmission Bandwidth*/
2028    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2029       f1Mode.mode.fdd.ulTxBw.nrScs;
2030    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2031       f1Mode.mode.fdd.ulTxBw.nrb;
2032    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2033       f1Mode.mode.fdd.dlTxBw.nrScs;
2034    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2035       f1Mode.mode.fdd.dlTxBw.nrb;
2036
2037    return ROK;
2038 }
2039
2040 /*******************************************************************
2041  *
2042  * @brief Fills ServCellInfo IE
2043  *
2044  * @details
2045  *
2046  *    Function : fillServedCellInfo
2047  *
2048  *    Functionality: Fills ServCellInfo
2049  *
2050  * @params[in] Pointer to Served_Cell_Information_t *
2051  *
2052  * @return ROK     - success
2053  *         RFAILED - failure
2054  *
2055  *****************************************************************/
2056
2057 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2058 {
2059    uint8_t ieIdx, ieListCnt;
2060
2061    /*nRCGI*/
2062    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2063    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2064          srvCellInfo->nRCGI.pLMN_Identity.size);
2065    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2066    {
2067       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2068       return RFAILED;
2069    }
2070    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2071          srvCellInfo->nRCGI.pLMN_Identity.buf);
2072    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2073    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2074          srvCellInfo->nRCGI.nRCellIdentity.size);
2075    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2076    {
2077       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2078       return RFAILED;
2079    }
2080
2081    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2082    /*nRPCI*/
2083    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2084
2085    /*servedPLMNs*/
2086    ieListCnt = 1;
2087    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2088    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2089    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2090    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2091    {
2092       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2093       return RFAILED;
2094    }
2095    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2096    {
2097       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2098       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2099       {
2100          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2101          return RFAILED;
2102       }
2103    }
2104    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2105    {
2106       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2107       return RFAILED;
2108    }
2109
2110 #ifndef NR_TDD
2111    /*nR Mode Info with FDD*/
2112    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2113    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2114    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2115    {
2116       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2117       return RFAILED;
2118    }
2119    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2120    {
2121        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2122       return RFAILED;
2123    }
2124 #else
2125    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2126    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2127    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2128    {
2129       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2130       return RFAILED;
2131    }
2132    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2133    {
2134       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2135       return RFAILED;
2136    }
2137 #endif
2138
2139    /*Measurement timing Config*/
2140    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2141    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2142          buf,srvCellInfo->measurementTimingConfiguration.size);
2143    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2144    {
2145       return RFAILED;
2146    }
2147    srvCellInfo->measurementTimingConfiguration.\
2148          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2149
2150    return ROK;
2151 }
2152
2153 /*******************************************************************
2154  *
2155  * @brief Fills ServCellToModItem IE
2156  *
2157  * @details
2158  *
2159  *    Function : fillServCellToModItem
2160  *
2161  *    Functionality: Fills ServCellToModItem IE
2162  *
2163  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2164  *
2165  * @return ROK     - success
2166  *         RFAILED - failure
2167  *
2168  *****************************************************************/
2169
2170 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2171 {
2172    /*pLMN_Identity*/
2173    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2174    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2175    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2176    {
2177       return RFAILED;
2178    }
2179    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2180          modifyItem->oldNRCGI.pLMN_Identity.buf);
2181
2182    /*nRCellIdentity*/
2183    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2184    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2185          modifyItem->oldNRCGI.nRCellIdentity.size);
2186    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2187    {
2188       return RFAILED;
2189    }
2190    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2191
2192    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2193       return RFAILED;
2194    else
2195       return ROK;
2196 }
2197
2198 /*******************************************************************
2199  *
2200  * @brief Builds ServCellToModList
2201  *
2202  * @details
2203  *
2204  *    Function : buildServCellToModList
2205  *
2206  *    Functionality: Builds the serv cell to Mod List
2207  *
2208  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2209  *
2210  * @return ROK     - success
2211  *         RFAILED - failure
2212  *
2213  *****************************************************************/
2214
2215 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2216 {
2217    uint8_t ieListCnt, ieIdx;
2218    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2219
2220    ieListCnt = 1;
2221    cellsToModify->list.count = ieListCnt;
2222    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2223    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2224    if(cellsToModify->list.array == NULLP)
2225    {
2226       return RFAILED;
2227    }
2228    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2229    {
2230       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2231       if(cellsToModify->list.array[ieIdx] == NULLP)
2232       {
2233          return RFAILED;
2234       }
2235    }
2236    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2237    cellsToModify->list.array[0]->criticality = Criticality_reject;
2238    cellsToModify->list.array[0]->value.present =\
2239       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2240    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2241
2242    if(fillServCellToModItem(modifyItem))
2243       return RFAILED;
2244    else
2245       return ROK;
2246 }
2247 /*******************************************************************
2248  *
2249  * @brief filling the DeleteItemList
2250  *
2251  * @details
2252  *
2253  *    Function : fillCellToDeleteItem
2254  *
2255  *    Functionality: Filling the DeleteItemIe
2256  *
2257  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2258  *
2259  * @return ROK     - success
2260  *         RFAILED - failure
2261  *
2262  *****************************************************************/
2263 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2264 {
2265    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2266
2267    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2268    deleteItemIe->criticality = Criticality_reject;
2269    deleteItemIe->value.present =\
2270    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2271    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2272
2273    /*pLMN_Identity*/
2274    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2275    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2276    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2277    {
2278       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2279       return RFAILED;
2280    }
2281    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2282          deleteItem->oldNRCGI.pLMN_Identity.buf);
2283
2284    /*nRCellIdentity*/
2285    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2286    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2287          deleteItem->oldNRCGI.nRCellIdentity.size);
2288    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2289    {
2290       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2291       return RFAILED;
2292    }
2293    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2294    return ROK;
2295 }
2296 /*******************************************************************
2297  *
2298  * @brief Builds ServCellToDeleteList
2299  *
2300  * @details
2301  *
2302  *    Function : buildServCellToDeleteList
2303  *
2304  *    Functionality: Builds the serv cell to delete List
2305  *
2306  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2307  *
2308  * @return ROK     - success
2309  *         RFAILED - failure
2310  *
2311  *****************************************************************/
2312
2313 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2314 {
2315    uint8_t ieListCnt, arrIdx;
2316
2317    ieListCnt = 1;
2318    cellsToDelete->list.count = ieListCnt;
2319    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2320
2321    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2322    if(cellsToDelete->list.array == NULLP)
2323    {
2324       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2325       return RFAILED;
2326    }
2327
2328    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2329    {
2330       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2331       if(cellsToDelete->list.array[arrIdx] == NULLP)
2332       {
2333          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2334          return RFAILED;
2335       }
2336    }
2337
2338    arrIdx=0;
2339    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2340    {
2341       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2342       return RFAILED;
2343    }
2344    return ROK;
2345 }
2346
2347 /*******************************************************************
2348  *
2349  * @brief Builds and sends the DUConfigUpdate
2350  *
2351  * @details
2352  *
2353  *    Function : BuildAndSendDUConfigUpdate
2354  *
2355  *    Functionality: Constructs the DU Update message and sends
2356  *                   it to the CU through SCTP.
2357  *
2358  * @params[in] void **buf,Buffer to which encoded pattern is written into
2359  * @params[in] int *size,size of buffer
2360  *
2361  * @return ROK     - success
2362  *         RFAILED - failure
2363  *
2364  * ****************************************************************/
2365 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2366 {
2367    uint8_t ret =0, ieIdx=0, elementCnt=0;
2368    bool memAlloctionFailure = false;
2369    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2370    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2371    asn_enc_rval_t encRetVal;     /* Encoder return value */
2372
2373    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2374    ret= RFAILED;
2375
2376    while(true)
2377    {
2378       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2379       /* Allocate the memory for F1DuCfg */
2380       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2381       if(f1apDuCfg == NULLP)
2382       {
2383          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2384          break;
2385       }
2386
2387       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2388       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2389       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2390       {
2391          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2392          break;
2393       }
2394
2395       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2396                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2397       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2398       f1apDuCfg->choice.initiatingMessage->value.present = \
2399                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2400       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2401                     choice.GNBDUConfigurationUpdate;
2402       elementCnt = 3;
2403       duCfgUpdate->protocolIEs.list.count = elementCnt;
2404       duCfgUpdate->protocolIEs.list.size = \
2405                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2406
2407       /* Initialize the F1Setup members */
2408       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2409       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2410       {
2411          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2412          break;
2413       }
2414       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2415       {
2416          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2417          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2418          {
2419             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2420             memAlloctionFailure = true;
2421             break;
2422          }
2423       }
2424
2425       if(memAlloctionFailure == true)
2426       {
2427          break;
2428       }
2429       /*TransactionID*/
2430       ieIdx = 0;
2431       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2432       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2433       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2434       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2435       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2436
2437       ieIdx++;
2438       if(servCellAction == SERV_CELL_TO_MODIFY)
2439       {
2440          /*Served Cell to Modify */
2441          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2442          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2443          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2444          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2445          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2446          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2447                   Served_Cells_To_Modify_List))
2448          {
2449             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2450             break;
2451          }
2452       }
2453       else
2454       {
2455          /*Served Cell to Delete */
2456          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2457          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2458          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2459          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2460          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2461          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2462          Served_Cells_To_Delete_List)!=ROK)
2463          {
2464             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2465             break;
2466          }
2467
2468       }
2469       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2470       /*GNB DU ID */
2471       ieIdx++;
2472       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2473       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2474       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2475       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2476       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2477       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2478             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2479       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2480       {
2481          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2482          break;
2483       }
2484       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2485
2486       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2487
2488       /* Encode the DU Config Update type as APER */
2489       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2490       encBufSize = 0;
2491       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2492
2493       /* Checking encode results */
2494       if(encRetVal.encoded == ENCODE_FAIL)
2495       {
2496          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2497                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2498          break;
2499       }
2500       else
2501       {
2502          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2503 #ifdef DEBUG_ASN_PRINT
2504          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2505          {
2506             printf("%x",encBuf[ieIdx]);
2507          }
2508 #endif
2509       }
2510       /* Sending msg */
2511       if(sendF1APMsg() != ROK)
2512       {
2513          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2514          break;
2515       }
2516
2517       ret = ROK;
2518       break;
2519    }
2520
2521    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2522    return ret;
2523 }
2524
2525
2526 /*******************************************************************
2527  *
2528  * @brief free the ULRRCMessageTransfer
2529  *
2530  * @details
2531  *
2532  *    Function : FreeULRRCMessageTransfer
2533  *
2534  *    Functionality: Deallocating the memory of variable allocated in
2535  *                      FreeULRRCMessageTransfer
2536  *
2537  * @params[in]
2538  *
2539  * @return ROK     - void
2540  *
2541  ******************************************************************/
2542 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2543 {
2544    uint8_t idx1;
2545    ULRRCMessageTransfer_t  *ulRRCMsg;
2546
2547    if(f1apMsg != NULLP)
2548    {
2549       if(f1apMsg->choice.initiatingMessage != NULLP)
2550       {
2551          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2552          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2553          {
2554             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2555             {
2556                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2557                {
2558                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2559                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2560                   {
2561                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2562                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2563                   }
2564                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2565                }
2566             }
2567             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2568          }
2569          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2570       }
2571       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2572    }
2573 }
2574 /*******************************************************************
2575  *
2576  * @brief Builds and sends the ULRRCMessageTransfer
2577  *
2578  * @details
2579  *
2580  *    Function : BuildAndSendULRRCMessageTransfer
2581  *
2582  *    Functionality: Constructs the UL RRC Message Transfer and sends
2583  *                   it to the CU through SCTP.
2584  *
2585  * @params[in]
2586  *
2587  * @return ROK     - success
2588  *         RFAILED - failure
2589  *
2590  * ****************************************************************/
2591 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  *ueCb, uint8_t lcId, \
2592       uint16_t msgLen, uint8_t *rrcMsg)
2593 {
2594    uint8_t                 elementCnt=0, idx1=0, idx=0;
2595    uint8_t                 ret = RFAILED;
2596    F1AP_PDU_t              *f1apMsg = NULLP;
2597    ULRRCMessageTransfer_t  *ulRRCMsg = NULLP;
2598    asn_enc_rval_t          encRetVal;        /* Encoder return value */
2599
2600    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2601
2602    while(true)
2603    {
2604       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2605
2606       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2607       if(f1apMsg == NULLP)
2608       {
2609          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2610          break;
2611       }
2612       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2613       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2614       if(f1apMsg->choice.initiatingMessage == NULLP)
2615       {
2616          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2617          break;
2618       }
2619       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2620       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2621       f1apMsg->choice.initiatingMessage->value.present = \
2622                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2623       ulRRCMsg =
2624          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2625       elementCnt = 4;
2626       ulRRCMsg->protocolIEs.list.count = elementCnt;
2627       ulRRCMsg->protocolIEs.list.size = \
2628                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2629
2630       /* Initialize the F1Setup members */
2631       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2632       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2633       {
2634          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2635          break;
2636       }
2637       for(idx=0; idx<elementCnt; idx++)
2638       {
2639          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2640          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2641          {
2642             break;
2643          }
2644       }
2645
2646       idx1 = 0;
2647
2648       /*GNB CU UE F1AP ID*/
2649       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2650       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2651       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2652                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2653       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
2654
2655       /*GNB DU UE F1AP ID*/
2656       idx1++;
2657       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2658       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2659       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2660                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2661       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
2662
2663       /*SRBID*/
2664       idx1++;
2665       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2666       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2667       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2668                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2669       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2670
2671       /*RRCContainer*/
2672       idx1++;
2673       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2674       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2675       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2676                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2677       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2678       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2679             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2680       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2681       {
2682          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2683          break;
2684       }
2685       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2686       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2687             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2688
2689       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2690
2691       /* Encode the F1SetupRequest type as APER */
2692       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2693       encBufSize = 0;
2694       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2695             encBuf);
2696       /* Encode results */
2697       if(encRetVal.encoded == ENCODE_FAIL)
2698       {
2699          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2700                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2701          break;
2702       }
2703       else
2704       {
2705          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2706 #ifdef DEBUG_ASN_PRINT
2707          for(int i=0; i< encBufSize; i++)
2708          {
2709             printf("%x",encBuf[i]);
2710          }
2711 #endif
2712       }
2713
2714       /* Sending  msg  */
2715       if(sendF1APMsg()  !=      ROK)
2716       {
2717          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2718          break;
2719       }
2720       ret = ROK;
2721       break;
2722    }
2723    FreeULRRCMessageTransfer(f1apMsg);
2724
2725    return ret;
2726 }/* End of BuildAndSendULRRCMessageTransfer*/
2727
2728 /*******************************************************************
2729  *
2730  * @brief Builds tag config
2731  *
2732  * @details
2733  *
2734  *    Function : BuildTagConfig
2735  *
2736  *    Functionality: Builds tag config in MacCellGroupConfig
2737  *
2738  * @params[in] TAG_Config *tag_Config
2739  *
2740  * @return ROK     - success
2741  *         RFAILED - failure
2742  *
2743  * ****************************************************************/
2744 uint8_t BuildTagConfig(DuUeCb *ueCb, struct TAG_Config *tagConfig)
2745 {
2746    struct TAG_Config__tag_ToAddModList *tagList;
2747    uint8_t                     idx, elementCnt;
2748
2749    tagConfig->tag_ToReleaseList = NULLP;
2750    tagConfig->tag_ToAddModList = NULLP;
2751    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2752    if(!tagConfig->tag_ToAddModList)
2753    {
2754       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2755       return RFAILED;
2756    }
2757
2758    if(ueCb == NULLP)
2759       elementCnt = ODU_VALUE_ONE;
2760    else
2761       elementCnt = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModListCount;
2762
2763    tagList = tagConfig->tag_ToAddModList;
2764    tagList->list.count = elementCnt;
2765    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2766
2767    tagList->list.array = NULLP;
2768    DU_ALLOC(tagList->list.array, tagList->list.size);
2769    if(!tagList->list.array)
2770    {
2771       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2772       return RFAILED;
2773    }
2774
2775    for(idx=0; idx<tagList->list.count; idx++)
2776    {
2777       tagList->list.array[idx] = NULLP;
2778       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2779       if(!tagList->list.array[idx])
2780       {
2781          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2782          return RFAILED;
2783       }
2784    }
2785
2786    if(ueCb == NULLP)
2787    {
2788       idx = 0;
2789       tagList->list.array[idx]->tag_Id = TAG_ID;
2790       tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2791    }
2792    else
2793    {
2794       for(idx=0; idx<tagList->list.count; idx++)
2795       {
2796          tagList->list.array[idx]->tag_Id = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].tagId;
2797          tagList->list.array[idx]->timeAlignmentTimer = ueCb->macUeCfg.macCellGrpCfg.tagCfg.addModList[idx].timeAlignTimer;
2798       }
2799    }
2800
2801    return ROK;
2802 }
2803
2804 /*******************************************************************
2805  *
2806  * @brief Builds PHR Config
2807  *
2808  * @details
2809  *
2810  *    Function : BuildPhrConfig
2811  *
2812  *    Functionality: Builds phrConfig in MacCellGroupConfig
2813  *
2814  * @params[in] PHR Config *
2815  *
2816  * @return ROK     - success
2817  *         RFAILED - failure
2818  *
2819  * ****************************************************************/
2820 uint8_t BuildPhrConfig(DuUeCb *ueCb, struct MAC_CellGroupConfig__phr_Config *phrConfig)
2821 {
2822
2823    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2824    phrConfig->choice.setup = NULLP;
2825    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2826    if(!phrConfig->choice.setup)
2827    {
2828       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2829       return RFAILED;
2830    }
2831
2832    if(ueCb == NULLP)
2833    {
2834       phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2835       phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2836       phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2837       phrConfig->choice.setup->multiplePHR              = false;
2838       phrConfig->choice.setup->dummy                    = false;
2839       phrConfig->choice.setup->phr_Type2OtherCell       = false;
2840       phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2841    }
2842    else
2843    {
2844       phrConfig->choice.setup->phr_PeriodicTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.periodicTimer;
2845       phrConfig->choice.setup->phr_ProhibitTimer        = ueCb->macUeCfg.macCellGrpCfg.phrCfg.prohibitTimer;
2846       phrConfig->choice.setup->phr_Tx_PowerFactorChange = ueCb->macUeCfg.macCellGrpCfg.phrCfg.txPowerFactor;
2847       phrConfig->choice.setup->multiplePHR              = ueCb->macUeCfg.macCellGrpCfg.phrCfg.multiplePHR;
2848       phrConfig->choice.setup->dummy                    = ueCb->macUeCfg.macCellGrpCfg.phrCfg.dummy;
2849       phrConfig->choice.setup->phr_Type2OtherCell       = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrType2OtherCell;
2850       phrConfig->choice.setup->phr_ModeOtherCG          = ueCb->macUeCfg.macCellGrpCfg.phrCfg.phrOtherCG;
2851    }
2852
2853    return ROK;
2854 }
2855
2856 /*******************************************************************
2857  *
2858  * @brief Builds BSR Config
2859  *
2860  * @details
2861  *
2862  *    Function : BuildBsrConfig
2863  *
2864  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2865  *
2866  * @params[in] BSR_Config *bsrConfig
2867  *
2868  * @return ROK     - success
2869  *         RFAILED - failure
2870  *
2871  * ****************************************************************/
2872 uint8_t BuildBsrConfig(DuUeCb *ueCb, struct BSR_Config *bsrConfig)
2873 {
2874    if(ueCb == NULLP)
2875    {
2876       bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2877       bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2878       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2879    }
2880    else
2881    {
2882       bsrConfig->periodicBSR_Timer = convertBsrPeriodicTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.periodicTimer);
2883       bsrConfig->retxBSR_Timer     = convertBsrRetxTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.retxTimer);
2884
2885       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2886       DU_ALLOC(bsrConfig->logicalChannelSR_DelayTimer, sizeof(long));
2887       if(bsrConfig->logicalChannelSR_DelayTimer == NULLP)
2888       {
2889          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildBsrConfig");
2890          return RFAILED;
2891       }
2892       *(bsrConfig->logicalChannelSR_DelayTimer) = convertLcSrDelayTmrValueToEnum(ueCb->macUeCfg.macCellGrpCfg.bsrTmrCfg.srDelayTimer);
2893    }
2894
2895    return ROK;
2896 }
2897
2898 /*******************************************************************
2899  *
2900  * @brief Builds scheduling request config
2901  *
2902  * @details
2903  *
2904  *    Function : BuildSchedulingReqConfig
2905  *
2906  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2907  *
2908  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2909  *
2910  * @return ROK     - success
2911  *         RFAILED - failure
2912  *
2913  * ****************************************************************/
2914 uint8_t BuildSchedulingReqConfig(DuUeCb *ueCb, struct SchedulingRequestConfig *schedulingRequestConfig)
2915 {
2916    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2917    uint8_t                     idx, elementCnt;
2918
2919    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2920    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2921          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2922    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2923    {
2924       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2925       return RFAILED;
2926    }
2927
2928    if(ueCb == NULLP)
2929       elementCnt = ODU_VALUE_ONE;
2930    else
2931       elementCnt = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModListCount;
2932
2933    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2934    schReqList->list.count = elementCnt;
2935    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2936
2937    schReqList->list.array = NULLP;
2938    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2939    if(!schReqList->list.array)
2940    {
2941       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2942       return RFAILED;
2943    }
2944
2945    for(idx=0; idx<schReqList->list.count; idx++)
2946    {
2947       schReqList->list.array[idx] = NULLP;
2948       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2949       if(!schReqList->list.array[idx])
2950       {
2951          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2952          return RFAILED;
2953       }
2954    }
2955
2956    if(ueCb == NULLP)
2957    {
2958       idx = 0;
2959       schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2960
2961       schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2962       DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2963       if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2964       {
2965          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2966          return RFAILED;
2967       }
2968       *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2969       schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2970    }
2971    else
2972    {
2973       for(idx=0; idx<schReqList->list.count; idx++)
2974       {
2975          schReqList->list.array[idx]->schedulingRequestId = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].schedReqId;
2976
2977          schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2978          DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2979          if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2980          {
2981             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2982             return RFAILED;
2983          }
2984          *(schReqList->list.array[idx]->sr_ProhibitTimer) = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srProhibitTmr;
2985          schReqList->list.array[idx]->sr_TransMax = ueCb->macUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srTransMax;
2986       }
2987    }
2988
2989    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2990
2991    return ROK;
2992 }
2993
2994 /*******************************************************************
2995  *
2996  * @brief Builds RLC Configuration for AM mode
2997  *
2998  * @details
2999  *
3000  *    Function : BuildRlcConfigAm
3001  *
3002  *    Functionality:
3003  *       Builds AM mode RLC Config in BuildRlcBearerToAddModList
3004  *
3005  * @params[in] AmBearerCfg *amCfg
3006  *             RLC_Config_t  *rlcConfig
3007  *
3008  * @return ROK     - success
3009  *         RFAILED - failure
3010  *
3011  * ****************************************************************/
3012 uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig)
3013 {
3014    rlcConfig->choice.am = NULLP;
3015    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3016    if(!rlcConfig->choice.am)
3017    {
3018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3019       return RFAILED;
3020    }
3021
3022    /* Fill AM UL configuration */
3023    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3024    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3025    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3026    {
3027       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3028       return RFAILED;
3029    }
3030
3031    /* Fill default AM UL configuration if input pointer to DU database is NULL */
3032    if(amCfg == NULLP)
3033    {
3034       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3035       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3036       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3037       rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3038       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3039    }
3040    else
3041    {
3042       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->dlAmCfg.snLenDl);
3043       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = covertPollRetxTmrValueToEnum(amCfg->dlAmCfg.pollRetxTmr);
3044       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = covertPollPduValueToEnum(amCfg->dlAmCfg.pollPdu);
3045       rlcConfig->choice.am->ul_AM_RLC.pollByte          = covertPollByteValueToEnum(amCfg->dlAmCfg.pollByte);
3046       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = covertMaxRetxValueToEnum(amCfg->dlAmCfg.maxRetxTh);
3047    }
3048
3049    /* Fill AM DL configuraion */
3050    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3051    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3052    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3053    {
3054       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3055       return RFAILED;
3056    }
3057
3058    /* Fill default AM DL configuration if input pointer to DU database is NULL */
3059    if(amCfg == NULLP)
3060    {
3061       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3062       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3063       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3064    }
3065    else /* Fill AM configuration from DU database */
3066    {
3067       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->ulAmCfg.snLenUl);
3068       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = convertReasmblTmrValueToEnum(amCfg->ulAmCfg.reAssemTmr);
3069       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = convertProhibitTmrValueToEnum(amCfg->ulAmCfg.statProhTmr);
3070    }
3071    return ROK;
3072 }
3073
3074 /*******************************************************************
3075  *
3076  * @brief Builds RLC Config for UM Bidirection
3077  *
3078  * @details
3079  *
3080  *    Function : BuildRlcConfig UmBiDir
3081  *
3082  *    Functionality:
3083  *       Builds RLC Config for UM Bidirection in BuildRlcBearerToAddModList
3084  *
3085  * @params[in] UmBiDirBearerCfg *umBiDirCfg
3086  *             RLC_Config_t *rlcConfig
3087  *
3088  * @return ROK     - success
3089  *         RFAILED - failure
3090  *
3091  * ****************************************************************/
3092 uint8_t BuildRlcConfigUmBiDir(UmBiDirBearerCfg *umBiDirCfg, struct RLC_Config *rlcConfig)
3093 {
3094    rlcConfig->choice.um_Bi_Directional = NULLP;
3095    DU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
3096    if(rlcConfig->choice.um_Bi_Directional == NULLP)
3097    {
3098       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3099       return RFAILED;
3100    }
3101
3102    /* Fill UM Bidirectional UL configuration */
3103    rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
3104    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3105    if(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength == NULLP)
3106    {
3107       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3108       return RFAILED;
3109    }
3110
3111    if(umBiDirCfg != NULLP)
3112    {
3113       *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->dlUmCfg.snLenDlUm);
3114    }
3115
3116    /* Fill UM Bidirectional DL configuration */
3117    rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
3118    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3119    if(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength == NULLP)
3120    {
3121       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3122       return RFAILED;
3123    }
3124
3125    if(umBiDirCfg != NULLP)
3126    {
3127       *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->ulUmCfg.snLenUlUm);
3128       rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umBiDirCfg->ulUmCfg.reAssemTmr);
3129    }
3130
3131    return ROK;
3132 }
3133
3134 /*******************************************************************
3135  *
3136  * @brief Builds RLC Config for UM Uni directional UL
3137  *
3138  * @details
3139  *
3140  *    Function : BuildRlcConfigUmUniDirUl
3141  *
3142  *    Functionality:
3143  *       Builds RLC Config for UM Unidirection UL in BuildRlcBearerToAddModList
3144  *
3145  * @params[in] UmUniDirDlBearerCfg *umUniDirDlCfg
3146  *             RLC_Config_t *rlcConfig
3147  *
3148  * @return ROK     - success
3149  *         RFAILED - failure
3150  *
3151  * ****************************************************************/
3152 uint8_t BuildRlcConfigUmUniDirUl(UmUniDirDlBearerCfg *umUniDirDlCfg, RLC_Config_t *rlcConfig)
3153 {
3154    rlcConfig->choice.um_Uni_Directional_UL = NULLP;
3155    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
3156    if(rlcConfig->choice.um_Uni_Directional_UL == NULLP)
3157    {
3158       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3159       return RFAILED;
3160    }
3161
3162    rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength = NULLP;
3163    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3164    if(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength == NULLP)
3165    {
3166       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3167       return RFAILED;
3168    }
3169
3170    if(umUniDirDlCfg != NULLP)
3171    {
3172       *(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirDlCfg->dlUmCfg.snLenDlUm);
3173    }
3174
3175    return ROK;
3176 }
3177
3178 /*******************************************************************
3179  *
3180  * @brief Builds RLC Config for UM Uni directional DL
3181  *
3182  * @details
3183  *
3184  *    Function : BuildRlcConfigUmUniDirDl
3185  *
3186  *    Functionality:
3187  *       Builds RLC Config for UM Unidirection DL in BuildRlcBearerToAddModList
3188  *
3189  * @params[in] UmUniDirUlBearerCfg *umUniDirUlCfg
3190  *             RLC_Config_t *rlcConfig
3191  *
3192  * @return ROK     - success
3193  *         RFAILED - failure
3194  *
3195  * ****************************************************************/
3196 uint8_t BuildRlcConfigUmUniDirDl(UmUniDirUlBearerCfg *umUniDirUlCfg, RLC_Config_t *rlcConfig)
3197 {
3198    rlcConfig->choice.um_Uni_Directional_DL = NULLP;
3199    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
3200    if(rlcConfig->choice.um_Uni_Directional_DL == NULLP)
3201    {
3202       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3203       return RFAILED;
3204    }
3205
3206    rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength = NULLP;
3207    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3208    if(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength == NULLP)
3209    {
3210       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3211       return RFAILED;
3212    }
3213
3214    if(umUniDirUlCfg != NULLP)
3215    {
3216       *(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirUlCfg->ulUmCfg.snLenUlUm);
3217       rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umUniDirUlCfg->ulUmCfg.reAssemTmr);
3218    }
3219
3220    return ROK;
3221 }
3222
3223 /*******************************************************************
3224  *
3225  * @brief Builds RLC Config
3226  *
3227  * @details
3228  *
3229  *    Function : BuildRlcConfig
3230  *
3231  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3232  *
3233  * @params[in] RLC_Config_t *rlcConfig
3234  *
3235  * @return ROK     - success
3236  *         RFAILED - failure
3237  *
3238  * ****************************************************************/
3239 uint8_t BuildRlcConfig(RlcBearerCfg *rbCfg, struct RLC_Config *rlcConfig)
3240 {
3241
3242    /* Fill default values if rbCfg is NULL */
3243    if(rbCfg == NULLP)
3244    {
3245       rlcConfig->present = RLC_Config_PR_am;
3246       BuildRlcConfigAm(NULLP, rlcConfig);
3247    }
3248    /* If RbCfg is present, fill RLC configurations from DU Database */
3249    else
3250    {
3251       rlcConfig->present = covertRlcModeFromIntEnumToRrcEnum(rbCfg->rlcMode);
3252       switch(rlcConfig->present)
3253       {
3254          case RLC_Config_PR_am:
3255             BuildRlcConfigAm(rbCfg->u.amCfg, rlcConfig);
3256             break;
3257          case RLC_Config_PR_um_Bi_Directional:
3258             BuildRlcConfigUmBiDir(rbCfg->u.umBiDirCfg, rlcConfig);
3259             break;
3260          case RLC_Config_PR_um_Uni_Directional_UL:
3261             BuildRlcConfigUmUniDirUl(rbCfg->u.umUniDirDlCfg, rlcConfig);
3262             break;
3263          case RLC_Config_PR_um_Uni_Directional_DL:
3264             BuildRlcConfigUmUniDirDl(rbCfg->u.umUniDirUlCfg, rlcConfig);
3265             break;
3266          case RLC_Config_PR_NOTHING:
3267          default:
3268             break;
3269       }
3270    }
3271
3272    return ROK;
3273 }
3274
3275 /*******************************************************************
3276  *
3277  * @brief Builds MAC LC Config
3278  *
3279  * @details
3280  *
3281  *    Function : BuildMacLCConfig
3282  *
3283  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3284  *
3285  * @params[in] struct LogicalChannelConfig macLcConfig
3286  *
3287  * @return ROK     - success
3288  *         RFAILED - failure
3289  *
3290  * ****************************************************************/
3291 uint8_t BuildMacLCConfig(LcCfg *lcCfgDb, struct LogicalChannelConfig *macLcConfig)
3292 {
3293    macLcConfig->ul_SpecificParameters = NULLP;
3294    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3295    if(!macLcConfig->ul_SpecificParameters)
3296    {
3297       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3298       return RFAILED;
3299    }
3300
3301    if(lcCfgDb == NULLP)
3302    {
3303       macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3304       macLcConfig->ul_SpecificParameters->prioritisedBitRate =  PRIORTISIED_BIT_RATE;
3305       macLcConfig->ul_SpecificParameters->bucketSizeDuration =  BUCKET_SIZE_DURATION;
3306    }
3307    else
3308    {
3309       macLcConfig->ul_SpecificParameters->priority = lcCfgDb->ulLcCfg.priority;
3310       macLcConfig->ul_SpecificParameters->prioritisedBitRate = lcCfgDb->ulLcCfg.pbr;
3311       macLcConfig->ul_SpecificParameters->bucketSizeDuration = lcCfgDb->ulLcCfg.bsd;
3312    }
3313
3314    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3315    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3316    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3317    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3318
3319    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3320    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3321    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3322    {
3323       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3324       return RFAILED;
3325    }
3326
3327    if(lcCfgDb == NULLP)
3328       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3329    else
3330       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = lcCfgDb->ulLcCfg.lcGroup;
3331
3332    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3333    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3334    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3335    {
3336       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3337       return RFAILED;
3338    }
3339
3340    if(lcCfgDb == NULLP)
3341       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3342    else
3343       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = lcCfgDb->ulLcCfg.schReqId;
3344
3345    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3346    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3347    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3348
3349    return ROK;
3350 }
3351
3352 /*******************************************************************
3353  *
3354  * @brief Builds RLC Bearer to Add/Mod list
3355  *
3356  * @details
3357  *
3358  *    Function :BuildRlcBearerToAddModList
3359  *
3360  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3361  *
3362  * @params[in] rlc_BearerToAddModList
3363  *
3364  * @return ROK     - success
3365  *         RFAILED - failure
3366  *
3367  * ****************************************************************/
3368 uint8_t BuildRlcBearerToAddModList(DuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3369 {
3370    uint8_t  idx = 0, lcIdx=0, macLcIdx = 0, elementCnt = 0;
3371
3372    if(ueCb == NULLP)
3373       elementCnt = 1;
3374    else if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
3375       elementCnt = ueCb->rlcUeCfg.numLcs;
3376    else
3377    {
3378       for(lcIdx = 0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3379       {
3380          if(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == false)
3381             elementCnt++;
3382       }
3383    }
3384    rlcBearerList->list.count = elementCnt;
3385    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3386
3387    rlcBearerList->list.array = NULLP;
3388    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3389    if(!rlcBearerList->list.array)
3390    {
3391       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3392       return RFAILED;
3393    }
3394
3395    for(idx=0; idx<rlcBearerList->list.count; idx++)
3396    {
3397       rlcBearerList->list.array[idx] = NULLP;
3398       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3399       if(!rlcBearerList->list.array[idx])
3400       {
3401          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3402          return RFAILED;
3403       }
3404    }
3405
3406    if(ueCb == NULLP)
3407    {
3408       idx=0;
3409       rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3410       DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3411       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3412       {
3413          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3414          return RFAILED;
3415       }
3416       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3417       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB1_LCID;
3418       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3419
3420       /* Fill RLC related Configurations for this Radio Bearer */
3421       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3422       DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3423       if(!rlcBearerList->list.array[idx]->rlc_Config)
3424       {
3425          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3426          return RFAILED;
3427       }
3428       if(BuildRlcConfig(NULLP, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3429       {
3430          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3431          return RFAILED;
3432       }
3433
3434       /* Fill MAC related configurations for this Radio Bearer */
3435       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3436       DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3437       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3438       {
3439          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3440          return RFAILED;
3441       }
3442       if(BuildMacLCConfig(NULLP, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3443       {
3444          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3445          return RFAILED;
3446       }
3447    }
3448    else
3449    {
3450       idx=0;
3451       for(lcIdx=0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3452       {
3453          if((ueCb->f1UeDb->actionType != UE_CTXT_CFG_QUERY) && (ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == true))
3454             continue;
3455
3456          /* Fill Logical channel identity */
3457          rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId;
3458
3459          /* Fill Radio Bearer Id and type (DRB/SRB) for this logical channel */
3460          DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3461          if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3462          {
3463             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3464             return RFAILED;
3465          }
3466          rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3467                                                                       covertRbTypeFromIntEnumToRrcEnum(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbType);
3468          switch(rlcBearerList->list.array[idx]->servedRadioBearer->present)
3469          {
3470             case RLC_BearerConfig__servedRadioBearer_PR_srb_Identity:
3471                rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3472                break;
3473             case RLC_BearerConfig__servedRadioBearer_PR_drb_Identity:
3474                rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3475                break;
3476             case RLC_BearerConfig__servedRadioBearer_PR_NOTHING:
3477             default:
3478                break;
3479          }
3480          ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent = true;
3481
3482          rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3483
3484          /* Fill RLC related Configurations for this Radio Bearer */
3485          rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3486          DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3487          if(!rlcBearerList->list.array[idx]->rlc_Config)
3488          {
3489             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3490             return RFAILED;
3491          }
3492          if(BuildRlcConfig(&ueCb->rlcUeCfg.rlcLcCfg[lcIdx], rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3493          {
3494             DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3495             return RFAILED;
3496          }
3497
3498          /* Fill MAC related configurations for this Radio Bearer */
3499          rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3500          DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3501          if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3502          {
3503             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3504             return RFAILED;
3505          }
3506          for(macLcIdx = 0; macLcIdx < ueCb->macUeCfg.numLcs; macLcIdx++)
3507          {
3508             if(ueCb->macUeCfg.lcCfgList[macLcIdx].lcId == ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId)
3509             {
3510                if(BuildMacLCConfig(&ueCb->macUeCfg.lcCfgList[macLcIdx], rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3511                {
3512                   DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3513                   return RFAILED;
3514                }
3515                break;
3516             }
3517          }
3518
3519          idx++;
3520       }
3521    }
3522    return ROK;
3523 }
3524
3525 /*******************************************************************
3526  *
3527  * @brief Build Control resource set to add/modify list
3528  *
3529  * @details
3530  *
3531  *    Function : BuildControlRSetToAddModList
3532  *
3533  *    Functionality: Build Control resource set to add/modify list
3534  *
3535  * @params[in]
3536  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3537  *
3538  * @return ROK     - success
3539  *         RFAILED - failure
3540  *
3541  * ****************************************************************/
3542 uint8_t BuildControlRSetToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList)
3543 {
3544    uint8_t idx;
3545    uint8_t elementCnt;
3546    uint8_t numBytes, bitsUnused;
3547    struct ControlResourceSet *controlRSet;
3548    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3549    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3550
3551    if(pdcchCfg == NULLP)
3552       elementCnt = 1;
3553    else
3554       elementCnt = pdcchCfg->numCRsetToAddMod;
3555
3556    controlRSetList->list.count = elementCnt;
3557    controlRSetList->list.size = elementCnt * sizeof(struct ControlResourceSet *);
3558
3559    controlRSetList->list.array = NULLP;
3560    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3561    if(!controlRSetList->list.array)
3562    {
3563       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3564       return RFAILED;
3565    }
3566
3567    for(idx = 0; idx < elementCnt; idx++)
3568    {
3569       controlRSetList->list.array[idx] = NULLP;
3570       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3571       if(!controlRSetList->list.array[idx])
3572       {
3573          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3574          return RFAILED;
3575       }
3576    }
3577
3578    for(idx = 0; idx < elementCnt; idx++)
3579    {
3580       controlRSet = controlRSetList->list.array[idx];
3581
3582       if(pdcchCfg == NULLP)
3583          controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3584       else
3585          controlRSet->controlResourceSetId = pdcchCfg->cRSetToAddModList[idx].cRSetId;
3586
3587       /* size 6 bytes
3588        * 3 LSBs unsued
3589        * Bit string stored ff0000000000
3590        */
3591       numBytes = 6;
3592       bitsUnused = 3;
3593       controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3594
3595       controlRSet->frequencyDomainResources.buf = NULLP;
3596       DU_ALLOC(controlRSet->frequencyDomainResources.buf, controlRSet->frequencyDomainResources.size);
3597       if(!controlRSet->frequencyDomainResources.buf)
3598       {
3599          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3600          return RFAILED;
3601       }
3602
3603       memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3604
3605       if(pdcchCfg == NULLP)
3606       {
3607          coreset0EndPrb = CORESET0_END_PRB;
3608          coreset1StartPrb = coreset0EndPrb + 6;
3609          coreset1NumPrb = CORESET1_NUM_PRB;
3610          /* calculate the PRBs */
3611          fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3612          memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3613          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3614
3615          controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3616          controlRSet->cce_REG_MappingType.present = ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3617          controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3618       }
3619       else
3620       {
3621          memcpy(controlRSet->frequencyDomainResources.buf, pdcchCfg->cRSetToAddModList[idx].freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
3622          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3623          controlRSet->duration = pdcchCfg->cRSetToAddModList[idx].duration;
3624          controlRSet->cce_REG_MappingType.present = pdcchCfg->cRSetToAddModList[idx].cceRegMappingType;
3625          controlRSet->precoderGranularity = pdcchCfg->cRSetToAddModList[idx].precoderGranularity;
3626       }
3627       controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3628       controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3629       controlRSet->tci_PresentInDCI = NULLP;
3630
3631 #if 0
3632       uint8_t tciStateIdx;
3633
3634       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3635             sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3636       if(!controlRset->tci_StatesPDCCH_ToAddList)
3637       {
3638          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3639          return RFAILED;
3640       }
3641
3642       elementCnt = 1;
3643       controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3644       controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3645       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3646             controlRset->tci_StatesPDCCH_ToAddList->list.size)
3647          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3648          {
3649             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3650             return RFAILED;
3651          }
3652
3653       for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3654       {
3655          DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3656          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3657          {
3658             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3659             return RFAILED;
3660          }
3661       }
3662
3663       tciStateIdx = 0;
3664       /* TODO */
3665       *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3666
3667       DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3668       if(!controlRset->tci_PresentInDCI)
3669       {
3670          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3671          return RFAILED;
3672       }
3673       /* TODO */
3674       *(controlRset->tci_PresentInDCI);
3675 #endif
3676
3677       controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3678       DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3679       if(!controlRSet->pdcch_DMRS_ScramblingID)
3680       {
3681          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3682          return RFAILED;
3683       }
3684       if(pdcchCfg == NULLP)
3685          *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3686       else
3687          *(controlRSet->pdcch_DMRS_ScramblingID) = pdcchCfg->cRSetToAddModList[idx].dmrsScramblingId;
3688    }
3689    return ROK;
3690 } /* End BuildControlRSetToAddModList */
3691
3692 /*******************************************************************
3693  *
3694  * @brief Build search space to add/modify list
3695  *
3696  * @details
3697  *
3698  *    Function : BuildSearchSpcToAddModList
3699  *
3700  *    Functionality: Build search space to add/modify list
3701  *
3702  * @params[in]
3703  * @return ROK     - success
3704  *         RFAILED - failure
3705  *
3706  * ****************************************************************/
3707 uint8_t BuildSearchSpcToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
3708 {
3709    uint8_t idx;
3710    uint8_t numBytes;
3711    uint8_t byteIdx;
3712    uint8_t bitsUnused;
3713    uint8_t elementCnt;
3714    struct SearchSpace *searchSpc;
3715
3716    if(pdcchCfg == NULLP)
3717       elementCnt = 1;
3718    else
3719       elementCnt = pdcchCfg->numSearchSpcToAddMod;
3720
3721    searchSpcList->list.count = elementCnt;
3722    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3723
3724    searchSpcList->list.array = NULLP;
3725    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3726    if(!searchSpcList->list.array)
3727    {
3728       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3729       return RFAILED;
3730    }
3731
3732    for(idx = 0; idx < elementCnt; idx++)
3733    {
3734       searchSpcList->list.array[idx] = NULLP;
3735       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3736       if(!searchSpcList->list.array[idx])
3737       {
3738          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3739          return RFAILED;
3740       }
3741    }
3742
3743    for(idx = 0; idx < elementCnt; idx++)
3744    {
3745       searchSpc = searchSpcList->list.array[idx];
3746
3747       if(pdcchCfg == NULLP)
3748          searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3749       else
3750          searchSpc->searchSpaceId = pdcchCfg->searchSpcToAddModList[idx].searchSpaceId;
3751
3752       searchSpc->controlResourceSetId = NULLP;
3753       DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3754       if(!searchSpc->controlResourceSetId)
3755       {
3756          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3757          return RFAILED;
3758       }
3759       if(pdcchCfg == NULLP)
3760          *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3761       else
3762          *(searchSpc->controlResourceSetId) = pdcchCfg->searchSpcToAddModList[idx].cRSetId;
3763
3764       searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3765       DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3766       if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3767       {
3768          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3769          return RFAILED;
3770       }
3771       if(pdcchCfg == NULLP)
3772          searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3773       else
3774          searchSpc->monitoringSlotPeriodicityAndOffset->present = pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset;
3775
3776       searchSpc->duration = NULLP;
3777       searchSpc->monitoringSymbolsWithinSlot = NULLP;
3778       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3779       if(!searchSpc->monitoringSymbolsWithinSlot)
3780       {
3781          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3782          return RFAILED;
3783       }
3784
3785       /* Values taken from reference logs :
3786        * size 2 bytes
3787        * 2 LSBs unsued
3788        * Bit string stores 8000
3789        */
3790       numBytes = 2;
3791       bitsUnused = 2;
3792       searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3793       searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3794       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
3795       if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3796       {
3797          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3798          return RFAILED;
3799       }
3800       if(pdcchCfg == NULLP)
3801       {
3802          byteIdx = 0;
3803          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3804          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3805       }
3806       else
3807          memcpy(searchSpc->monitoringSymbolsWithinSlot->buf, pdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot, numBytes);
3808       searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3809
3810       searchSpc->nrofCandidates = NULLP;
3811       DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3812       if(!searchSpc->nrofCandidates)
3813       {
3814          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3815          return RFAILED;
3816       }
3817
3818       if(pdcchCfg == NULLP)
3819       {
3820          searchSpc->nrofCandidates->aggregationLevel1 = PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3821          searchSpc->nrofCandidates->aggregationLevel2 = PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3822          searchSpc->nrofCandidates->aggregationLevel4 = PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3823          searchSpc->nrofCandidates->aggregationLevel8 = PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3824          searchSpc->nrofCandidates->aggregationLevel16 = PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3825       }
3826       else
3827       {
3828          searchSpc->nrofCandidates->aggregationLevel1 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1;
3829          searchSpc->nrofCandidates->aggregationLevel2 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2;
3830          searchSpc->nrofCandidates->aggregationLevel4 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4;
3831          searchSpc->nrofCandidates->aggregationLevel8 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8;
3832          searchSpc->nrofCandidates->aggregationLevel16 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16;
3833       }
3834
3835       searchSpc->searchSpaceType = NULLP;
3836       DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3837       if(!searchSpc->searchSpaceType)
3838       {
3839          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3840          return RFAILED;
3841       }
3842       if(pdcchCfg == NULLP)
3843          searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3844       else
3845          searchSpc->searchSpaceType->present = pdcchCfg->searchSpcToAddModList[idx].searchSpaceType;
3846
3847       searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3848       DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3849       if(!searchSpc->searchSpaceType->choice.ue_Specific)
3850       {
3851          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3852          return RFAILED;
3853       }
3854       if(pdcchCfg == NULLP)
3855          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3856       else
3857          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = pdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat;
3858    }
3859    return ROK;
3860 }/* End BuildSearchSpcToAddModList */
3861
3862 /*******************************************************************
3863  *
3864  * @brief Builds BWP DL dedicated PDCCH config
3865  *
3866  * @details
3867  *
3868  *    Function : BuildBWPDlDedPdcchCfg
3869  *
3870  *    Functionality: Builds BWP DL dedicated PDCCH config
3871  *
3872  * @params[in] struct PDCCH_Config *pdcchCfg
3873  *
3874  * @return ROK     - success
3875  *         RFAILED - failure
3876  *
3877  * ****************************************************************/
3878 uint8_t BuildBWPDlDedPdcchCfg(PdcchConfig *pdcchCfgDb, struct PDCCH_Config *pdcchCfg)
3879 {
3880    pdcchCfg->controlResourceSetToAddModList = NULLP;
3881    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3882    if(!pdcchCfg->controlResourceSetToAddModList)
3883    {
3884       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3885       return RFAILED;
3886    }
3887
3888    if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
3889    {
3890       DU_LOG("\nERROR  --> F1AP : Failed in BuildControlRSetToAddModList()");
3891       return RFAILED;
3892    }
3893
3894    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3895
3896    pdcchCfg->searchSpacesToAddModList = NULLP;
3897    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3898    if(!pdcchCfg->searchSpacesToAddModList)
3899    {
3900       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3901       return RFAILED;
3902    }
3903
3904    if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
3905    {
3906       DU_LOG("\nERROR  --> F1AP : Failed in BuildSearchSpcToAddModList()");
3907       return RFAILED;
3908    }
3909
3910    pdcchCfg->searchSpacesToReleaseList = NULLP;
3911    pdcchCfg->downlinkPreemption = NULLP;
3912    pdcchCfg->tpc_PUSCH = NULLP;
3913    pdcchCfg->tpc_PUCCH = NULLP;
3914    pdcchCfg->tpc_SRS = NULLP;
3915
3916    return ROK;
3917 }
3918
3919 /*******************************************************************
3920  *
3921  * @brief Builds DMRS DL PDSCH Mapping type A
3922  *
3923  * @details
3924  *
3925  *    Function : BuildDMRSDLPdschMapTypeA
3926  *
3927  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3928  *
3929  * @params[in]
3930  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3931  * @return ROK     - success
3932  *         RFAILED - failure
3933  *
3934  * ****************************************************************/
3935 uint8_t BuildDMRSDLPdschMapTypeA(PdschConfig *pdschCfg, struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg)
3936 {
3937    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3938    dmrsDlCfg->choice.setup = NULLP;
3939    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3940    if(!dmrsDlCfg->choice.setup)
3941    {
3942       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3943       return RFAILED;
3944    }
3945
3946    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3947    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3948    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3949    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3950    {
3951       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3952       return RFAILED;
3953    }
3954    if(pdschCfg == NULLP)
3955       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3956    else
3957       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = pdschCfg->dmrsDlCfgForPdschMapTypeA.addPos;
3958
3959    dmrsDlCfg->choice.setup->maxLength = NULLP;
3960    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3961    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3962    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3963
3964    return ROK;
3965 }
3966
3967 /*******************************************************************
3968  *
3969  * @brief Builds TCI states to add/modify list
3970  *
3971  * @details
3972  *
3973  *    Function : BuildTCIStatesToAddModList
3974  *
3975  *    Functionality:Builds TCI states to add/modify list
3976  *
3977  * @params[in]
3978  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3979  *
3980  * @return ROK     - success
3981  *         RFAILED - failure
3982  *
3983  * ****************************************************************/
3984 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3985 {
3986    return ROK;
3987 }
3988
3989 /*******************************************************************
3990  *
3991  * @brief Builds PDSCH time domain allocation list
3992  *
3993  * @details
3994  *
3995  *    Function : BuildPdschTimeDomAllocList
3996  *
3997  *    Functionality: Builds PDSCH time domain allocation list
3998  *
3999  * @params[in]
4000  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4001  *
4002  * @return ROK     - success
4003  *         RFAILED - failure
4004  *
4005  * ****************************************************************/
4006 uint8_t BuildPdschTimeDomAllocList(PdschConfig *pdschCfg, struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4007 {
4008    uint8_t idx;
4009    uint8_t elementCnt;
4010    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
4011
4012    timeDomAllocList->present = PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
4013
4014    timeDomAllocList->choice.setup = NULLP;
4015    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4016    if(!timeDomAllocList->choice.setup)
4017    {
4018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4019       return RFAILED;
4020    }
4021
4022 if(pdschCfg == NULLP)
4023    elementCnt = 2;
4024 else
4025 elementCnt = pdschCfg->numTimeDomRsrcAlloc;
4026    timeDomAllocList->choice.setup->list.count = elementCnt;
4027    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
4028
4029    timeDomAllocList->choice.setup->list.array = NULLP;
4030    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4031    if(!timeDomAllocList->choice.setup->list.array)
4032    {
4033       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4034       return RFAILED;
4035    }
4036
4037    for(idx = 0; idx < elementCnt; idx++)
4038    {
4039       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4040       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
4041             sizeof(struct PDSCH_TimeDomainResourceAllocation));
4042       if(!timeDomAllocList->choice.setup->list.array[idx])
4043       {
4044          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4045          return RFAILED;
4046       }
4047    }
4048
4049    if(pdschCfg == NULLP)
4050    {
4051       idx = 0;
4052       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4053       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4054       if(!timeDomAlloc->k0)
4055       {
4056          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4057          return RFAILED;
4058       }
4059       *(timeDomAlloc->k0) = 0;
4060       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4061       timeDomAlloc->startSymbolAndLength = \
4062                                            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4063
4064       idx++;
4065       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4066       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4067       if(!timeDomAlloc->k0)
4068       {
4069          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4070          return RFAILED;
4071       }
4072       *(timeDomAlloc->k0) = 1;
4073       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4074       timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4075    }
4076    else
4077    {
4078       for(idx = 0; idx < elementCnt; idx++)
4079       {
4080          timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4081          DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4082          if(!timeDomAlloc->k0)
4083          {
4084             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4085             return RFAILED;
4086          }
4087          if(pdschCfg->timeDomRsrcAllociList[idx].k0)
4088             *(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
4089          timeDomAlloc->mappingType = pdschCfg->timeDomRsrcAllociList[idx].mappingType;
4090          timeDomAlloc->startSymbolAndLength = pdschCfg->timeDomRsrcAllociList[idx].startSymbolAndLength;
4091       }
4092    }
4093
4094    return ROK;
4095 }
4096
4097 /*******************************************************************
4098  *
4099  * @brief Builds PDSCH PRB Bundling type
4100  *
4101  * @details
4102  *
4103  *    Function : BuildPdschPrbBundlingType
4104  *
4105  *    Functionality: Builds PDSCH PRB Bundling type
4106  *
4107  * @params[in]
4108  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4109  *
4110  * @return ROK     - success
4111  *         RFAILED - failure
4112  *
4113  * ****************************************************************/
4114 uint8_t BuildPdschPrbBundlingType(PdschConfig *pdschCfg, struct PDSCH_Config__prb_BundlingType *prbBndlType)
4115 {
4116    if(pdschCfg == NULLP)
4117       prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4118    else
4119       prbBndlType->present = pdschCfg->bundlingType;
4120
4121    prbBndlType->choice.staticBundling = NULLP;
4122    DU_ALLOC(prbBndlType->choice.staticBundling, \
4123          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4124    if(!prbBndlType->choice.staticBundling)
4125    {
4126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4127       return RFAILED;
4128    }
4129    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4130
4131    return ROK;
4132 }
4133
4134 /*******************************************************************
4135  *
4136  * @brief Builds BWP DL dedicated PDSCH config
4137  *
4138  * @details
4139  *
4140  *    Function : BuildBWPDlDedPdschCfg
4141  *
4142  *    Functionality: Builds BWP DL dedicated PDSCH config
4143  *
4144  * @params[in] struct PDSCH_Config *pdschCfg
4145  *
4146  * @return ROK     - success
4147  *         RFAILED - failure
4148  *
4149  * ****************************************************************/
4150 uint8_t BuildBWPDlDedPdschCfg(PdschConfig *pdschCfgDb, struct PDSCH_Config *pdschCfg)
4151 {
4152    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4153
4154    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4155    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4156    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4157    {
4158       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4159       return RFAILED;
4160    }
4161
4162    if(BuildDMRSDLPdschMapTypeA(pdschCfgDb, pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4163    {
4164       return RFAILED;
4165    }
4166
4167    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4168    pdschCfg->tci_StatesToAddModList = NULLP;
4169    pdschCfg->tci_StatesToReleaseList = NULLP;
4170    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4171 #if 0
4172    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4173    if(!pdschCfg->tci_StatesToAddModList)
4174    {
4175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4176       return RFAILED;
4177    }
4178    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4179    {
4180       return RFAILED;
4181    }
4182 #endif
4183
4184 if(pdschCfgDb == NULLP)
4185    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4186 else
4187 pdschCfg->resourceAllocation = pdschCfgDb->resourceAllocType;
4188
4189    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4190    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4191    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4192    {
4193       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4194       return RFAILED;
4195    }
4196    if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4197    {
4198       return RFAILED;
4199    }
4200
4201    pdschCfg->pdsch_AggregationFactor = NULLP;
4202    pdschCfg->rateMatchPatternToAddModList = NULLP;
4203    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4204    pdschCfg->rateMatchPatternGroup1 = NULLP;
4205    pdschCfg->rateMatchPatternGroup2 = NULLP;
4206    if(pdschCfgDb == NULLP)
4207       pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4208    else
4209       pdschCfg->rbg_Size = pdschCfgDb->rbgSize;
4210    pdschCfg->mcs_Table = NULLP;
4211
4212    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4213    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4214    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4215    {
4216       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4217       return RFAILED;
4218    }
4219    if(pdschCfgDb == NULLP)
4220       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4221    else
4222       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = pdschCfgDb->numCodeWordsSchByDci;
4223
4224    if(BuildPdschPrbBundlingType(pdschCfgDb, &pdschCfg->prb_BundlingType) != ROK)
4225    {
4226       return RFAILED;
4227    }
4228
4229    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4230    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4231    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4232    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4233    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4234    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4235    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4236
4237    return ROK;
4238 }
4239
4240 /*******************************************************************
4241  *
4242  * @brief Builds intitial DL BWP
4243  * @details
4244  *
4245  *    Function : BuildInitialDlBWP
4246  *
4247  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4248  *
4249  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4250  *
4251  * @return ROK     - success
4252  *         RFAILED - failure
4253  *
4254  * ****************************************************************/
4255 uint8_t BuildInitialDlBWP(InitialDlBwp *initiDlBwp, BWP_DownlinkDedicated_t *dlBwp)
4256 {
4257    PdcchConfig *pdcchCfg = NULLP;
4258    PdschConfig *pdschCfg = NULLP;
4259
4260    if(initiDlBwp)
4261    {
4262       if(initiDlBwp->pdcchPresent)
4263          pdcchCfg = &initiDlBwp->pdcchCfg;
4264       if(initiDlBwp->pdschPresent)
4265          pdschCfg = &initiDlBwp->pdschCfg;
4266    }
4267
4268    dlBwp->pdcch_Config = NULLP;
4269    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4270    if(!dlBwp->pdcch_Config)
4271    {
4272       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4273       return RFAILED;
4274    }
4275    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4276
4277    dlBwp->pdcch_Config->choice.setup = NULLP;
4278    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4279    if(!dlBwp->pdcch_Config->choice.setup)
4280    {
4281       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4282       return RFAILED;
4283    }
4284    if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
4285    {
4286       return RFAILED;
4287    }
4288
4289    dlBwp->pdsch_Config = NULLP;
4290    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4291    if(!dlBwp->pdsch_Config)
4292    {
4293       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4294       return RFAILED;
4295    }
4296    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4297
4298    dlBwp->pdsch_Config->choice.setup = NULLP;
4299    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4300    if(!dlBwp->pdsch_Config->choice.setup)
4301    {
4302       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4303       return RFAILED;
4304    }
4305
4306    if(BuildBWPDlDedPdschCfg(pdschCfg, dlBwp->pdsch_Config->choice.setup) != ROK)
4307    {
4308       return RFAILED;
4309    }
4310
4311    dlBwp->sps_Config = NULLP;
4312    dlBwp->radioLinkMonitoringConfig = NULLP;
4313    return ROK;
4314 }
4315
4316 /*******************************************************************
4317  *
4318  * @brief Builds DMRS UL Pusch Mapping type A
4319  *
4320  * @details
4321  *
4322  *    Function : BuildDMRSULPuschMapTypeA
4323  *
4324  *    Functionality: Builds DMRS UL Pusch Mapping type A
4325  *
4326  * @params[in]
4327  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4328  * @return ROK     - success
4329  *         RFAILED - failure
4330  *
4331  * ****************************************************************/
4332 uint8_t BuildDMRSULPuschMapTypeA(DmrsUlCfg *ulDmrsCfgDb, struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg)
4333 {
4334    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4335    dmrsUlCfg->choice.setup= NULLP;
4336    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4337    if(!dmrsUlCfg->choice.setup)
4338    {
4339       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4340       return RFAILED;
4341    }
4342
4343    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4344    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4345    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4346    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4347    {
4348       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4349       return RFAILED;
4350    }
4351    if(ulDmrsCfgDb == NULLP)
4352       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4353    else
4354       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = ulDmrsCfgDb->addPos;
4355
4356    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4357    dmrsUlCfg->choice.setup->maxLength = NULLP;
4358    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4359    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4360    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4361    {
4362       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4363       return RFAILED;
4364    }
4365
4366    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4367    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4368          sizeof(long));
4369    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4370    {
4371       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4372       return RFAILED;
4373    }
4374    if(ulDmrsCfgDb == NULLP)
4375       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4376    else
4377       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = ulDmrsCfgDb->transPrecodDisabled.scramblingId0;
4378
4379    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4380    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4381    return ROK;
4382 }
4383
4384 /*******************************************************************
4385  *
4386  * @brief Build PUSCH time domain allocation list
4387  *
4388  * @details
4389  *
4390  *    Function : BuildPuschTimeDomAllocList
4391  *
4392  *    Functionality: Build PUSCH time domain allocation list
4393  *
4394  * @params[in]
4395  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4396  *
4397  * @return ROK     - success
4398  *         RFAILED - failure
4399  *
4400  * ****************************************************************/
4401 uint8_t BuildPuschTimeDomAllocList(PuschCfg *puschCfgDb, struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList)
4402 {
4403    uint8_t idx;
4404    uint8_t elementCnt;
4405    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4406
4407    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4408    timeDomAllocList->choice.setup = NULLP;
4409    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4410    if(!timeDomAllocList->choice.setup)
4411    {
4412       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4413       return RFAILED;
4414    }
4415
4416    if(puschCfgDb == NULLP)
4417       elementCnt = 2;
4418    else
4419       elementCnt = puschCfgDb->numTimeDomRsrcAlloc;
4420
4421    timeDomAllocList->choice.setup->list.count = elementCnt;
4422    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4423    timeDomAllocList->choice.setup->list.array = NULLP;
4424    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4425    if(!timeDomAllocList->choice.setup->list.array)
4426    {
4427       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4428       return RFAILED;
4429    }
4430
4431    for(idx = 0; idx < elementCnt; idx++)
4432    {
4433       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4434       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
4435       if(!timeDomAllocList->choice.setup->list.array[idx])
4436       {
4437          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4438          return RFAILED;
4439       }
4440    }
4441
4442    for(idx = 0; idx < elementCnt; idx++)
4443    {
4444       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4445       DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4446       if(!timeDomAlloc->k2)
4447       {
4448          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4449          return RFAILED;
4450       }
4451       if(puschCfgDb == NULLP)
4452       {
4453          if(idx == 0)
4454             *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4455          else if(idx == 1)
4456             *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4457
4458          timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4459          timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4460       }
4461       else
4462       {
4463          *(timeDomAlloc->k2) = puschCfgDb->timeDomRsrcAllocList[idx].k2;
4464          timeDomAlloc->mappingType = puschCfgDb->timeDomRsrcAllocList[idx].mappingType;
4465          timeDomAlloc->startSymbolAndLength = puschCfgDb->timeDomRsrcAllocList[idx].startSymbolAndLength;
4466       }
4467    }
4468
4469    return ROK;
4470 }
4471
4472 /*******************************************************************
4473  *
4474  * @brief Builds BWP UL dedicated PUSCH Config
4475  *
4476  * @details
4477  *
4478  *    Function : BuildBWPUlDedPuschCfg
4479  *
4480  *    Functionality:
4481  *      Builds BWP UL dedicated PUSCH Config
4482  *
4483  * @params[in] : PUSCH_Config_t *puschCfg
4484  *
4485  * @return ROK     - success
4486  *         RFAILED - failure
4487  *
4488  * ****************************************************************/
4489 uint8_t BuildBWPUlDedPuschCfg(PuschCfg *puschCfgDb, PUSCH_Config_t *puschCfg)
4490 {
4491    DmrsUlCfg *ulDmrsCfg = NULLP;
4492
4493    if(puschCfgDb)
4494       ulDmrsCfg = &puschCfgDb->dmrsUlCfgForPuschMapTypeA;
4495
4496    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4497    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4498    if(!puschCfg->dataScramblingIdentityPUSCH)
4499    {
4500       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4501       return RFAILED;
4502    }
4503    if(puschCfgDb == NULLP)
4504       *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4505    else
4506       *(puschCfg->dataScramblingIdentityPUSCH) = puschCfgDb->dataScramblingId;
4507
4508    puschCfg->txConfig = NULLP;
4509    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4510    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4511    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4512    {
4513       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4514       return RFAILED;
4515    }
4516
4517    if(BuildDMRSULPuschMapTypeA(ulDmrsCfg, puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4518    {
4519       return RFAILED;
4520    }
4521
4522    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4523    puschCfg->pusch_PowerControl = NULLP;
4524    puschCfg->frequencyHopping = NULLP;
4525    puschCfg->frequencyHoppingOffsetLists = NULLP;
4526
4527    if(puschCfgDb == NULLP)
4528       puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4529    else
4530       puschCfg->resourceAllocation = puschCfgDb->resourceAllocType;
4531
4532    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4533    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4534    if(!puschCfg->pusch_TimeDomainAllocationList)
4535    {
4536       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4537       return RFAILED;
4538    }
4539
4540    if(BuildPuschTimeDomAllocList(puschCfgDb, puschCfg->pusch_TimeDomainAllocationList) != ROK)
4541    {
4542       return RFAILED;
4543    }
4544
4545    puschCfg->pusch_AggregationFactor = NULLP;
4546    puschCfg->mcs_Table = NULLP;
4547    puschCfg->mcs_TableTransformPrecoder = NULLP;
4548    puschCfg->transformPrecoder = NULLP;
4549    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4550    if(!puschCfg->transformPrecoder)
4551    {
4552       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4553       return RFAILED;
4554    }
4555    if(puschCfgDb == NULLP)
4556       *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4557    else
4558       *(puschCfg->transformPrecoder) = puschCfgDb->transformPrecoder;
4559
4560    puschCfg->codebookSubset = NULLP;
4561    puschCfg->maxRank = NULLP;
4562    puschCfg->rbg_Size = NULLP;
4563    puschCfg->uci_OnPUSCH = NULLP;
4564    puschCfg->tp_pi2BPSK = NULLP;
4565
4566    return ROK;
4567 }
4568
4569 /*******************************************************************
4570  *
4571  * @brief Builds PUCCH resource set add/modify list
4572  *
4573  * @details
4574  *
4575  *    Function : BuildPucchRsrcSetAddModList
4576  *
4577  *    Functionality:
4578  *      Builds PUCCH resource set add/modify list
4579  *
4580  * @params[in] : PucchResrcSetCfg *rsrcSetCfgDb
4581  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4582  *
4583  * @return ROK     - success
4584  *         RFAILED - failure
4585  *
4586  * ****************************************************************/
4587 uint8_t BuildPucchRsrcSetAddModList(PucchResrcSetCfg *rsrcSetCfgDb, \
4588    struct PUCCH_Config__resourceSetToAddModList *resourceSetToAddModList)
4589 {
4590    uint8_t elementCnt = 0, rsrcSetIdx = 0, rsrcIdx = 0;
4591    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4592
4593    if(rsrcSetCfgDb == NULLP)
4594       elementCnt = 1;
4595    else
4596       elementCnt = rsrcSetCfgDb->resrcSetToAddModListCount;
4597
4598    resourceSetToAddModList->list.count = elementCnt;
4599    resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4600    DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
4601    if(resourceSetToAddModList->list.array == NULLP)
4602    {
4603       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4604       return RFAILED;
4605    }
4606    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4607    {
4608       DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4609       if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4610       {
4611          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4612          return RFAILED;
4613       }
4614    }
4615
4616    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4617    {
4618       rsrcSet = resourceSetToAddModList->list.array[rsrcSetIdx];
4619
4620       /* Resource set Id */
4621       if(rsrcSetCfgDb == NULLP)
4622          rsrcSet->pucch_ResourceSetId = 1;
4623       else
4624          rsrcSet->pucch_ResourceSetId = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcSetId;
4625
4626       /* Resource list of a resource set */
4627       if(rsrcSetCfgDb == NULLP)
4628          elementCnt = 1;
4629       else
4630          elementCnt = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcListCount;
4631       rsrcSet->resourceList.list.count = elementCnt;
4632       rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4633       DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4634       if(rsrcSet->resourceList.list.array == NULLP)
4635       {
4636          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4637          return RFAILED;
4638       }
4639
4640       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4641       {
4642          DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4643          if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4644          {
4645             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4646             return RFAILED;
4647          }
4648       }
4649       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4650       {
4651          if(rsrcSetCfgDb == NULLP)
4652             *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4653          else
4654             *(rsrcSet->resourceList.list.array[rsrcIdx]) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcList[rsrcIdx];
4655       }
4656
4657       /* Max payload size (minus 1) in a Resource set */
4658       rsrcSet->maxPayloadMinus1 = NULLP;
4659       if(rsrcSetCfgDb && rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize)
4660       {
4661          DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
4662          if(rsrcSet->maxPayloadMinus1 == NULLP)
4663          {
4664             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4665             return RFAILED;
4666          }
4667          *(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
4668       }
4669    }
4670    return ROK;
4671 }
4672
4673 /*******************************************************************
4674  *
4675  * @brief Builds PUCCH resource add/modify list
4676  *
4677  * @details
4678  *
4679  *    Function : BuildPucchRsrcAdddModList
4680  *
4681  *    Functionality:
4682  *      Builds PUCCH resource add/modify list
4683  *
4684  * @params[in] : PucchResrcCfg *rsrcSetCfgDb
4685  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4686  *
4687  * @return ROK     - success
4688  *         RFAILED - failure
4689  *
4690  * ****************************************************************/
4691 uint8_t BuildPucchRsrcAddModList(PucchResrcCfg *rsrcCfgDb, struct PUCCH_Config__resourceToAddModList  *resourceToAddModList)
4692 {
4693    uint8_t elementCnt = 0, rsrcIdx = 0;
4694    PUCCH_Resource_t *rsrc = NULLP;
4695
4696    if(rsrcCfgDb == NULLP)
4697       elementCnt = 1;
4698    else
4699       elementCnt = rsrcCfgDb->resrcToAddModListCount;
4700    resourceToAddModList->list.count = elementCnt;
4701    resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4702    DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
4703    if(resourceToAddModList->list.array == NULLP)
4704    {
4705       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4706       return RFAILED;
4707    }
4708    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4709    {
4710       DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4711       if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
4712       {
4713          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4714          return RFAILED;
4715       }
4716    }
4717
4718    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4719    {
4720       rsrc = resourceToAddModList->list.array[rsrcIdx];
4721
4722       if(rsrcCfgDb == NULLP)
4723       {
4724          rsrc->pucch_ResourceId = 1;
4725          rsrc->startingPRB = 0;
4726          rsrc->format.present = PUCCH_Resource__format_PR_format1;
4727          DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4728          if(rsrc->format.choice.format1 == NULLP)
4729          {
4730             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4731             return RFAILED;
4732          }
4733          rsrc->format.choice.format1->initialCyclicShift = 0;
4734          rsrc->format.choice.format1->nrofSymbols = 4;
4735          rsrc->format.choice.format1->startingSymbolIndex = 0;
4736          rsrc->format.choice.format1->timeDomainOCC = 0;
4737       }
4738       else
4739       {
4740          rsrc->pucch_ResourceId = rsrcCfgDb->resrcToAddModList[rsrcIdx].resrcId;
4741          rsrc->startingPRB = rsrcCfgDb->resrcToAddModList[rsrcIdx].startPrb;
4742          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop)
4743          {
4744             DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
4745             if(rsrc->intraSlotFrequencyHopping == NULLP)
4746             {
4747                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4748                return RFAILED;
4749             }
4750             *(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
4751          }
4752          else
4753             rsrc->intraSlotFrequencyHopping = NULLP;
4754
4755          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop)
4756          {
4757             DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
4758             if(rsrc->secondHopPRB == NULLP)
4759             {
4760                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4761                return RFAILED;
4762             }
4763             *(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
4764          }
4765          else
4766             rsrc->secondHopPRB = NULLP;
4767          rsrc->format.present = covertPucchFormatIntEnumToRrcEnum(rsrcCfgDb->resrcToAddModList[rsrcIdx].pucchFormat);
4768
4769          switch(rsrc->format.present)
4770          {
4771             case PUCCH_Resource__format_PR_NOTHING:
4772                break;
4773             case PUCCH_Resource__format_PR_format0:
4774                {
4775                   DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
4776                   if(rsrc->format.choice.format0 == NULLP)
4777                   {
4778                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4779                      return RFAILED;
4780                   }
4781                   rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
4782                   rsrc->format.choice.format0->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->numSymbols;
4783                   rsrc->format.choice.format0->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->startSymbolIdx;
4784                   break;
4785                }
4786
4787             case PUCCH_Resource__format_PR_format1:
4788                {
4789                   DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4790                   if(rsrc->format.choice.format1 == NULLP)
4791                   {
4792                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4793                      return RFAILED;
4794                   }
4795                   rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
4796                   rsrc->format.choice.format1->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->numSymbols;
4797                   rsrc->format.choice.format1->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->startSymbolIdx;
4798                   rsrc->format.choice.format1->timeDomainOCC = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->timeDomOCC;
4799                   break;
4800                }
4801
4802             case PUCCH_Resource__format_PR_format2:
4803                {
4804                   DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
4805                   if(rsrc->format.choice.format2 == NULLP)
4806                   {
4807                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4808                      return RFAILED;
4809                   }
4810                   rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
4811                   rsrc->format.choice.format2->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numSymbols;
4812                   rsrc->format.choice.format2->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->startSymbolIdx;
4813                   break;
4814                }
4815
4816             case PUCCH_Resource__format_PR_format3:
4817                {
4818                   DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
4819                   if(rsrc->format.choice.format3 == NULLP)
4820                   {
4821                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4822                      return RFAILED;
4823                   }
4824                   rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
4825                   rsrc->format.choice.format3->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numSymbols;
4826                   rsrc->format.choice.format3->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->startSymbolIdx;
4827                   break;
4828                }
4829
4830             case PUCCH_Resource__format_PR_format4:
4831                {
4832                   DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
4833                   if(rsrc->format.choice.format4 == NULLP)
4834                   {
4835                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4836                      return RFAILED;
4837                   }
4838                   rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
4839                   rsrc->format.choice.format4->occ_Length = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occLen;
4840                   rsrc->format.choice.format4->occ_Index = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occIdx;
4841                   rsrc->format.choice.format4->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->startSymbolIdx;
4842                   break;
4843                }
4844          }
4845       }
4846    }
4847    return ROK;
4848 }
4849
4850 /*******************************************************************
4851  *
4852  * @brief Builds PUCCH format  config
4853  *
4854  * @details
4855  *
4856  *    Function : BuildPucchFormat
4857  *
4858  *    Functionality: Builds PUCCH format  config
4859  *
4860  * @params[in] : PucchFormatCfg *formatDb
4861  *               PUCCH_FormatConfig_t *format
4862  *
4863  * @return ROK     - success
4864  *         RFAILED - failure
4865  *
4866  * ****************************************************************/
4867 uint8_t BuildPucchFormat(PucchFormatCfg *formatDb, PUCCH_FormatConfig_t *format)
4868 {
4869    /* Inter Slot Fequency hopping */
4870    format->interslotFrequencyHopping = NULLP;
4871    if((formatDb != NULLP) && (formatDb->interSlotFreqHop == true))
4872    {
4873       DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
4874       if(format->interslotFrequencyHopping)
4875       {
4876          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4877          return RFAILED;
4878       }
4879       *(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
4880    }
4881
4882    /* Additional DMRS */
4883    format->additionalDMRS = NULLP;
4884    if((formatDb != NULLP) && (formatDb->addDmrs == true))
4885    {
4886       DU_ALLOC(format->additionalDMRS, sizeof(long));
4887       if(format->additionalDMRS)
4888       {
4889          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4890          return RFAILED;
4891       }
4892       *(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
4893    }
4894
4895     /* Maximum code rate */
4896    format->maxCodeRate = NULLP;
4897    if((formatDb != NULLP) && (formatDb->maxCodeRate != 0))
4898    {
4899       DU_ALLOC(format->maxCodeRate, sizeof(long));
4900       if(format->maxCodeRate)
4901       {
4902          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4903          return RFAILED;
4904       }
4905       *(format->maxCodeRate) = formatDb->maxCodeRate;
4906    }
4907
4908    /* Number of slots */
4909    format->nrofSlots = NULLP;
4910    if((formatDb == NULLP) || ((formatDb != NULLP) && (formatDb->numSlots != 0)))
4911    {
4912       DU_ALLOC(format->nrofSlots, sizeof(long));
4913       if(format->nrofSlots == NULLP)
4914       {
4915          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4916          return RFAILED;
4917       }
4918       if(formatDb == NULLP)
4919          *(format->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4920       else
4921          *(format->nrofSlots) = formatDb->numSlots;
4922    }
4923
4924    /* Pi2BPSK*/
4925    format->pi2BPSK = NULLP;
4926    if((formatDb != NULLP) && (formatDb->pi2BPSK == true))
4927    {
4928       DU_ALLOC(format->pi2BPSK, sizeof(long));
4929       if(format->pi2BPSK)
4930       {
4931          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4932          return RFAILED;
4933       }
4934       *(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
4935    }
4936
4937    /* Simultaneous HARQ ACK and CSI */
4938    format->simultaneousHARQ_ACK_CSI = NULLP;
4939    if((formatDb != NULLP) && (formatDb->harqAckCSI == true))
4940    {
4941       DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
4942       if(format->simultaneousHARQ_ACK_CSI)
4943       {
4944          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4945          return RFAILED;
4946       }
4947       *(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
4948    }
4949
4950    return ROK;
4951 }
4952
4953
4954 /*******************************************************************
4955  *
4956  * @brief Builds PUCCH scheduling request list
4957  *
4958  * @details
4959  *
4960  *    Function : BuildPucchSchReqAddModList
4961  *
4962  *    Functionality:
4963  *      Builds PUCCH scheduling request list
4964  *
4965  * @params[in] : PucchSchedReqCfg *schReqDb
4966  *               struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList
4967  *
4968  * @return ROK     - success
4969  *         RFAILED - failure
4970  *
4971  * ****************************************************************/
4972 uint8_t BuildPucchSchReqAddModList(PucchSchedReqCfg *schReqDb, \
4973    struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList)
4974 {
4975    uint8_t elementCnt = 0, schReqIdx = 0;
4976    SchedulingRequestResourceConfig_t *schReqRsrc;
4977
4978    elementCnt = schReqDb->schedAddModListCount;
4979    schReqRsrcToAddModList->list.count = elementCnt;
4980    schReqRsrcToAddModList->list.size = elementCnt *sizeof(struct SchedulingRequestResourceConfig *);
4981
4982    schReqRsrcToAddModList->list.array = NULLP;
4983    DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
4984    if(schReqRsrcToAddModList->list.array == NULLP)
4985    {
4986       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4987       return RFAILED;
4988    }
4989
4990    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4991    {
4992       DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
4993       if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
4994       {
4995          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4996          return RFAILED;
4997       }
4998    }
4999
5000    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
5001    {
5002       schReqRsrc = schReqRsrcToAddModList->list.array[schReqIdx];
5003       schReqRsrc->schedulingRequestResourceId = schReqDb->schedAddModList[schReqIdx].resrcId;
5004       schReqRsrc->schedulingRequestID = schReqDb->schedAddModList[schReqIdx].requestId;
5005
5006       if(schReqDb->schedAddModList[schReqIdx].periodicity)
5007       {
5008          schReqRsrc->periodicityAndOffset = NULLP;
5009          DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
5010          if(schReqRsrc->periodicityAndOffset == NULLP)
5011          {
5012             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5013             return RFAILED;
5014          }
5015
5016          schReqRsrc->periodicityAndOffset->present = schReqDb->schedAddModList[schReqIdx].periodicity;
5017          switch(schReqRsrc->periodicityAndOffset->present)
5018          {
5019             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_NOTHING:
5020                break;
5021             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
5022                schReqRsrc->periodicityAndOffset->choice.sym2 = schReqDb->schedAddModList[schReqIdx].offset;
5023                break;
5024             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
5025                schReqRsrc->periodicityAndOffset->choice.sym6or7 = schReqDb->schedAddModList[schReqIdx].offset;
5026                break;
5027             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
5028                schReqRsrc->periodicityAndOffset->choice.sl1 = schReqDb->schedAddModList[schReqIdx].offset;
5029                break;
5030             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
5031                schReqRsrc->periodicityAndOffset->choice.sl2 = schReqDb->schedAddModList[schReqIdx].offset;
5032                break;
5033             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
5034                schReqRsrc->periodicityAndOffset->choice.sl4 = schReqDb->schedAddModList[schReqIdx].offset;
5035                break;
5036             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
5037                schReqRsrc->periodicityAndOffset->choice.sl5 = schReqDb->schedAddModList[schReqIdx].offset;
5038                break;
5039             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
5040                schReqRsrc->periodicityAndOffset->choice.sl8 = schReqDb->schedAddModList[schReqIdx].offset;
5041                break;
5042             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
5043                schReqRsrc->periodicityAndOffset->choice.sl10 = schReqDb->schedAddModList[schReqIdx].offset;
5044                break;
5045             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
5046                schReqRsrc->periodicityAndOffset->choice.sl16 = schReqDb->schedAddModList[schReqIdx].offset;
5047                break;
5048             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
5049                schReqRsrc->periodicityAndOffset->choice.sl20 = schReqDb->schedAddModList[schReqIdx].offset;
5050                break;
5051             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
5052                schReqRsrc->periodicityAndOffset->choice.sl40 = schReqDb->schedAddModList[schReqIdx].offset;
5053                break;
5054             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
5055                schReqRsrc->periodicityAndOffset->choice.sl80 = schReqDb->schedAddModList[schReqIdx].offset;
5056                break;
5057             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
5058                schReqRsrc->periodicityAndOffset->choice.sl160 = schReqDb->schedAddModList[schReqIdx].offset;
5059                break;
5060             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
5061                schReqRsrc->periodicityAndOffset->choice.sl320 = schReqDb->schedAddModList[schReqIdx].offset;
5062                break;
5063             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
5064                schReqRsrc->periodicityAndOffset->choice.sl640 = schReqDb->schedAddModList[schReqIdx].offset;
5065                break;
5066          }
5067       }
5068
5069       if(schReqDb->schedAddModList[schReqIdx].resrc)
5070       {
5071          schReqRsrc->resource = NULLP;
5072          DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
5073          if(schReqRsrc->resource == NULLP)
5074          {
5075             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5076             return RFAILED;
5077          }
5078          *(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
5079
5080       }
5081    }
5082    return ROK;
5083 }
5084
5085 /*******************************************************************
5086  *
5087  * @brief Builds PUCCH multi csi resource list
5088  *
5089  * @details
5090  *
5091  *    Function : BuildPucchMultiCsiRsrcList
5092  *
5093  *    Functionality:
5094  *      Builds PUCCH multi csi resource list
5095  *
5096  * @params[in] : PucchMultiCsiCfg *multiCsiDb
5097  *               struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList
5098  *
5099  * @return ROK     - success
5100  *         RFAILED - failure
5101  *
5102  * ****************************************************************/
5103 uint8_t BuildPucchMultiCsiRsrcList(PucchMultiCsiCfg *multiCsiDb, struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList)
5104 {
5105    uint8_t elementCnt = 0, rsrcIdx = 0;
5106
5107    elementCnt = multiCsiDb->multiCsiResrcListCount;
5108    multiCsiRsrcList->list.count = elementCnt;
5109    multiCsiRsrcList->list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
5110    multiCsiRsrcList->list.array = NULLP;
5111    DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
5112    if(multiCsiRsrcList->list.array == NULLP)
5113    {
5114       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5115       return RFAILED;
5116    }
5117
5118    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5119    {
5120       DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5121       if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
5122       {
5123          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5124          return RFAILED;
5125       }
5126    }
5127
5128    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5129    {
5130       *(multiCsiRsrcList->list.array[rsrcIdx]) = multiCsiDb->multiCsiResrcList[rsrcIdx];
5131    }
5132    return ROK;
5133 }
5134
5135 /*******************************************************************
5136  *
5137  * @brief Builds DL data -to- Ul Ack list
5138  *
5139  * @details
5140  *
5141  *    Function : BuildDlDataToUlAckList
5142  *
5143  *    Functionality: Builds DL data -to- Ul Ack list
5144  *
5145  * @params[in] : PucchDlDataToUlAck *dlDataToUlAckDb
5146  *               struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList
5147  *
5148  * @return ROK     - success
5149  *         RFAILED - failure
5150  *
5151  * ****************************************************************/
5152 uint8_t BuildDlDataToUlAckList(PucchDlDataToUlAck *dlDataToUlAckDb, struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList)
5153 {
5154    uint8_t elementCnt = 0, arrIdx = 0;
5155
5156    if(dlDataToUlAckDb == NULLP)
5157       elementCnt = 2;
5158    else
5159       elementCnt = dlDataToUlAckDb->dlDataToUlAckListCount;
5160
5161    dlDataToUlACKList->list.count = elementCnt;
5162    dlDataToUlACKList->list.size = elementCnt * sizeof(long *);
5163    DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
5164    if(dlDataToUlACKList->list.array == NULLP)
5165    {
5166       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5167       return RFAILED;
5168    }
5169
5170    for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5171    {
5172       DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
5173       if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
5174       {
5175          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5176          return RFAILED;
5177       }
5178    }
5179
5180    if(dlDataToUlAckDb == NULLP)
5181    {
5182       arrIdx = 0;
5183       *(dlDataToUlACKList->list.array[arrIdx++]) = 1;
5184       *(dlDataToUlACKList->list.array[arrIdx]) = 2;
5185    }
5186    else
5187    {
5188       for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5189       {
5190          *(dlDataToUlACKList->list.array[arrIdx]) = dlDataToUlAckDb->dlDataToUlAckList[arrIdx];
5191       }
5192    }
5193    return ROK;
5194 }
5195
5196 /*******************************************************************
5197  *
5198  * @brief Builds BWP UL dedicated PUCCH Config
5199  *
5200  * @details
5201  *
5202  *    Function : BuildBWPUlDedPucchCfg
5203  *
5204  *    Functionality:
5205  *      Builds BWP UL dedicated PUCCH Config
5206  *
5207  * @params[in] : PUCCH_Config_t *pucchCfg
5208  *
5209  * @return ROK     - success
5210  *         RFAILED - failure
5211  *
5212  * ****************************************************************/
5213 uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg)
5214 {
5215    PucchResrcSetCfg *rsrcSetCfgDb = NULLP;
5216    PucchResrcCfg *rsrcCfgDb = NULLP;
5217    PucchFormatCfg *format1Db = NULLP;
5218    PucchFormatCfg *format2Db = NULLP;
5219    PucchFormatCfg *format3Db = NULLP;
5220    PucchFormatCfg *format4Db = NULLP;
5221    PucchSchedReqCfg *schReqDb = NULLP;
5222    PucchMultiCsiCfg  *multiCsiDb = NULLP;
5223    PucchDlDataToUlAck *dlDataToUlAckDb = NULLP;
5224
5225    if(pucchCfgDb)
5226    {
5227       rsrcSetCfgDb = pucchCfgDb->resrcSet;
5228       rsrcCfgDb = pucchCfgDb->resrc;
5229       format1Db = pucchCfgDb->format1;
5230       format2Db = pucchCfgDb->format2;
5231       format3Db = pucchCfgDb->format3;
5232       format4Db = pucchCfgDb->format4;
5233       schReqDb = pucchCfgDb->schedReq;
5234       multiCsiDb = pucchCfgDb->multiCsiCfg;
5235       dlDataToUlAckDb = pucchCfgDb->dlDataToUlAck;
5236    }
5237
5238    /* RESOURCE SET */
5239    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5240    if(pucchCfg->resourceSetToAddModList == NULL)
5241    {
5242       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5243       return RFAILED;
5244    }
5245
5246    if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
5247    {
5248       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5249       return RFAILED;
5250    }
5251
5252    /* PUCCH RESOURCE */
5253    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5254    if(pucchCfg->resourceToAddModList == NULLP)
5255    {
5256       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5257       return RFAILED;
5258    }
5259
5260    if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
5261    {
5262       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5263       return RFAILED;
5264    }
5265
5266    /* PUCCH Format 1 */
5267    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5268    if(pucchCfg->format1 == NULLP)
5269    {
5270       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5271       return RFAILED;
5272    }
5273
5274    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
5275    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5276    if(pucchCfg->format1->choice.setup == NULLP)
5277    {
5278       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5279       return RFAILED;
5280    }
5281
5282    if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
5283    {
5284       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5285       return RFAILED;
5286    }
5287
5288    /* PUCCH Format 2 */
5289    if(format2Db)
5290    {
5291       DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
5292       if(pucchCfg->format2 == NULLP)
5293       {
5294          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5295          return RFAILED;
5296       }
5297
5298       pucchCfg->format2->present = PUCCH_Config__format2_PR_setup;
5299       DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
5300       if(pucchCfg->format2->choice.setup == NULLP)
5301       {
5302          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5303          return RFAILED;
5304       }
5305
5306       if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
5307       {
5308          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5309          return RFAILED;
5310       }
5311    }
5312
5313    /* PUCCH Format 3 */
5314    if(format3Db)
5315    {
5316       DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
5317       if(pucchCfg->format3 == NULLP)
5318       {
5319          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5320          return RFAILED;
5321       }
5322
5323       pucchCfg->format3->present = PUCCH_Config__format3_PR_setup;
5324       DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
5325       if(pucchCfg->format3->choice.setup == NULLP)
5326       {
5327          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5328          return RFAILED;
5329       }
5330
5331       if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
5332       {
5333          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5334          return RFAILED;
5335       }
5336    }
5337
5338    /* PUCCH Format 4 */
5339    if(format4Db)
5340    {
5341       DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
5342       if(pucchCfg->format4 == NULLP)
5343       {
5344          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5345          return RFAILED;
5346       }
5347
5348       pucchCfg->format4->present = PUCCH_Config__format4_PR_setup;
5349       DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
5350       if(pucchCfg->format4->choice.setup == NULLP)
5351       {
5352          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5353          return RFAILED;
5354       }
5355
5356       if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
5357       {
5358          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5359          return RFAILED;
5360       }
5361    }
5362
5363    /* Scheduling Request */
5364    if(schReqDb && (schReqDb->schedAddModListCount != 0))
5365    {
5366       pucchCfg->schedulingRequestResourceToAddModList = NULLP;
5367       DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
5368       if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
5369       {
5370          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5371          return RFAILED;
5372       }
5373
5374       if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
5375       {
5376          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5377          return RFAILED;
5378       }
5379    }
5380
5381    /* Multi CSI */
5382    if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
5383    {
5384       pucchCfg->multi_CSI_PUCCH_ResourceList = NULLP;
5385       DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
5386       if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
5387       {
5388          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5389          return RFAILED;
5390       }
5391
5392       if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
5393       {
5394          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5395          return RFAILED;
5396       }
5397    }
5398
5399    /* DL DATA TO UL ACK */
5400    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5401    if(pucchCfg->dl_DataToUL_ACK == NULLP)
5402    {
5403       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5404       return RFAILED;
5405    }
5406
5407    if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
5408    {
5409       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5410       return RFAILED;
5411    }
5412
5413    /* TODO : spatial relation info add/mod list and power control*/
5414
5415    return ROK;
5416 }
5417
5418 /*******************************************************************
5419  *
5420  * @brief Fills SRS resource to add/modify list
5421  *
5422  * @details
5423  *
5424  *    Function : BuildSrsRsrcAddModList
5425  *
5426  *    Functionality: Fills SRS resource to add/modify list
5427  *
5428  * @params[in]
5429  * @return ROK     - success
5430  *         RFAILED - failure
5431  *
5432  * ****************************************************************/
5433 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
5434 {
5435    uint8_t   elementCnt;
5436    uint8_t   rsrcIdx;
5437
5438    elementCnt = 1;
5439    resourceList->list.count = elementCnt;
5440    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
5441    resourceList->list.array = NULLP;
5442    DU_ALLOC(resourceList->list.array, resourceList->list.size);
5443    if(!resourceList->list.array)
5444    {
5445       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5446       return RFAILED;
5447    }
5448
5449    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5450    {
5451       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5452       if(!resourceList->list.array[rsrcIdx])
5453       {
5454          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5455          return RFAILED;
5456       }
5457    }
5458
5459    rsrcIdx = 0;
5460    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
5461    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
5462    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
5463
5464    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
5465    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
5466          sizeof(struct SRS_Resource__transmissionComb__n2));
5467    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
5468    {
5469       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5470       return RFAILED;
5471    }
5472    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
5473       = SRS_COMB_OFFSET_N2;
5474    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
5475       = SRS_CYCLIC_SHIFT_N2;
5476
5477    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
5478                                                                       PUSCH_START_SYMBOL;
5479    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
5480                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
5481    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
5482                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
5483
5484    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
5485    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
5486    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
5487    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
5488    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
5489    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
5490                                                                SRS_Resource__groupOrSequenceHopping_neither;
5491
5492    /* Setting resource type to aperiodic for intergration purposes */
5493    resourceList->list.array[rsrcIdx]->resourceType.present = \
5494                                                              SRS_Resource__resourceType_PR_aperiodic;
5495    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
5496    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
5497          sizeof(struct SRS_Resource__resourceType__aperiodic));
5498    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
5499    {
5500       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5501       return RFAILED;
5502    }
5503    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
5504
5505    return ROK;
5506 }
5507
5508 /*******************************************************************
5509  *
5510  * @brief Build SRS resource set Add/mod list
5511  *
5512  * @details
5513  *
5514  *    Function : BuildSrsRsrcSetAddModList
5515  *
5516  *    Functionality: Build SRS resource set Add/mod list
5517  *
5518  * @params[in]
5519  * @return ROK     - success
5520  *         RFAILED - failure
5521  *
5522  * ****************************************************************/
5523    uint8_t BuildSrsRsrcSetAddModList
5524 (
5525  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
5526  )
5527 {
5528    uint8_t  elementCnt;
5529    uint8_t  rSetIdx;
5530    uint8_t  rsrcIdx;
5531    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
5532
5533    elementCnt = 1;
5534    rsrcSetList->list.count = elementCnt;
5535    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
5536    rsrcSetList->list.array = NULLP;
5537    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
5538    if(!rsrcSetList->list.array)
5539    {
5540       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5541       return RFAILED;
5542    }
5543
5544    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5545    {
5546       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5547       if(!rsrcSetList->list.array[rSetIdx])
5548       {
5549          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5550          return RFAILED;
5551       }
5552    }
5553
5554    rSetIdx = 0;
5555    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
5556
5557    /* Fill Resource Id list in resource set */
5558    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
5559    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5560          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5561    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5562    {
5563       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5564       return RFAILED;
5565    }
5566
5567    elementCnt = 1;
5568    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5569    rsrcIdList->list.count = elementCnt;
5570    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
5571    rsrcIdList->list.array = NULLP;
5572    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
5573    if(!rsrcIdList->list.array)
5574    {
5575       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5576       return RFAILED;
5577    }
5578
5579    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5580    {
5581       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5582       if(!rsrcIdList->list.array[rsrcIdx])
5583       {
5584          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5585          return RFAILED;
5586       }
5587    }
5588
5589    rsrcIdx = 0;
5590    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
5591
5592    /* Fill resource type */
5593    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
5594                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
5595
5596    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
5597    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5598          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5599    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
5600    {
5601       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5602       return RFAILED;
5603    }
5604    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
5605       = APERIODIC_SRS_RESRC_TRIGGER;
5606
5607    /* TODO : Fill values for below IEs as expected by Viavi */
5608    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
5609    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
5610
5611
5612    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
5613    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
5614    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
5615    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
5616    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
5617
5618    return ROK;
5619 }
5620
5621 /*******************************************************************
5622  *
5623  * @brief Builds BWP UL dedicated SRS Config
5624  *
5625  * @details
5626  *
5627  *    Function : BuildBWPUlDedSrsCfg
5628  *
5629  *    Functionality: Builds BWP UL dedicated SRS Config
5630  *
5631  * @params[in] SRS Config
5632  * @return ROK     - success
5633  *         RFAILED - failure
5634  *
5635  * ****************************************************************/
5636 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
5637 {
5638    srsCfg->srs_ResourceSetToReleaseList = NULLP;
5639    srsCfg->srs_ResourceSetToAddModList = NULLP;
5640    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
5641          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5642    if(!srsCfg->srs_ResourceSetToAddModList)
5643    {
5644       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5645       return RFAILED;
5646    }
5647    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
5648    {
5649       return RFAILED;
5650    }
5651
5652    srsCfg->srs_ResourceToReleaseList = NULLP;
5653
5654    /* Resource to Add/Modify list */
5655    srsCfg->srs_ResourceToAddModList = NULLP;
5656    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
5657          sizeof(struct SRS_Config__srs_ResourceToAddModList));
5658    if(!srsCfg->srs_ResourceToAddModList)
5659    {
5660       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5661       return RFAILED;
5662    }
5663
5664    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
5665    {
5666       return RFAILED;
5667    }
5668
5669    srsCfg->tpc_Accumulation = NULLP;
5670
5671    return ROK;
5672 }
5673
5674
5675
5676 /*******************************************************************
5677  *
5678  * @brief Builds Pusch Serving cell Config
5679  *
5680  * @details
5681  *
5682  *    Function : BuildPuschSrvCellCfg
5683  *
5684  *    Functionality: Builds Pusch Serving cell Config
5685  *
5686  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
5687  *
5688  * @return ROK     - success
5689  *         RFAILED - failure
5690  *
5691  * ****************************************************************/
5692 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
5693 {
5694    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
5695    puschCfg->choice.setup = NULLP;
5696    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5697    if(!puschCfg->choice.setup)
5698    {
5699       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5700       return RFAILED;
5701    }
5702
5703    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5704    puschCfg->choice.setup->rateMatching = NULLP;
5705    puschCfg->choice.setup->xOverhead = NULLP;
5706    puschCfg->choice.setup->ext1 = NULLP;
5707    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
5708    if(!puschCfg->choice.setup->ext1)
5709    {
5710       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5711       return RFAILED;
5712    }
5713
5714    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
5715    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5716    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
5717    {
5718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5719       return RFAILED;
5720    }
5721    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5722
5723    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5724    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5725    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5726    {
5727       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5728       return RFAILED;
5729    }
5730    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5731    return ROK;
5732 }
5733
5734 /*******************************************************************
5735  *
5736  * @brief Builds inital UL BWP
5737  *
5738  * @details
5739  *
5740  *    Function : BuildInitialUlBWP
5741  *
5742  *    Functionality: Builds initial UL BWP
5743  *
5744  * @params[in] BWP_UplinkDedicated_t *ulBwp
5745  * @return ROK     - success
5746  *         RFAILED - failure
5747  *
5748  * ****************************************************************/
5749 uint8_t BuildInitialUlBWP(InitialUlBwp *initUlBwp, BWP_UplinkDedicated_t *ulBwp)
5750 {
5751    PucchCfg *pucchCfg = NULLP;
5752    PuschCfg *puschCfg = NULLP;
5753
5754    if(initUlBwp)
5755    {
5756       if(initUlBwp->pucchPresent)
5757          pucchCfg = &initUlBwp->pucchCfg;
5758       if(initUlBwp->puschPresent)
5759          puschCfg = &initUlBwp->puschCfg;
5760    }
5761
5762    ulBwp->pucch_Config = NULLP;
5763    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5764    if(!ulBwp->pucch_Config)
5765    {
5766       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5767       return RFAILED;
5768    }
5769
5770    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
5771    ulBwp->pucch_Config->choice.setup = NULLP;
5772    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5773    if(!ulBwp->pucch_Config->choice.setup)
5774    {
5775       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5776       return RFAILED;
5777    }
5778
5779    if(BuildBWPUlDedPucchCfg(pucchCfg, ulBwp->pucch_Config->choice.setup) != ROK)
5780    {
5781       return RFAILED;
5782    }
5783
5784    /* Fill BWP UL dedicated PUSCH config */
5785    ulBwp->pusch_Config = NULLP;
5786    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5787    if(!ulBwp->pusch_Config)
5788    {
5789       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5790       return RFAILED;
5791    }
5792
5793    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
5794    ulBwp->pusch_Config->choice.setup = NULLP;
5795    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5796    if(!ulBwp->pusch_Config->choice.setup)
5797    {
5798       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5799       return RFAILED;
5800    }
5801
5802    if(BuildBWPUlDedPuschCfg(puschCfg, ulBwp->pusch_Config->choice.setup) != ROK)
5803    {
5804       return RFAILED;
5805    }
5806
5807    ulBwp->configuredGrantConfig = NULLP;
5808
5809    /* Fill BPW UL dedicated SRS config */
5810    ulBwp->srs_Config = NULLP;
5811    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5812    if(!ulBwp->srs_Config)
5813    {
5814       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5815       return RFAILED;
5816    }
5817
5818    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
5819    ulBwp->srs_Config->choice.setup = NULLP;
5820    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5821    if(!ulBwp->srs_Config->choice.setup)
5822    {
5823       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5824       return RFAILED;
5825    }
5826
5827    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
5828    {
5829       return RFAILED;
5830    }
5831
5832    ulBwp->beamFailureRecoveryConfig = NULLP;
5833
5834    return ROK;
5835 }
5836
5837 /*******************************************************************
5838  *
5839  * @brief Builds UL config
5840  * @details
5841  *
5842  *    Function : BuildUlCfg
5843  *
5844  *    Functionality: Builds UL config in spCellCfgDed
5845  *
5846  * @params[in] UplinkConfig_t *ulCfg
5847  *
5848  * @return ROK     - success
5849  *         RFAILED - failure
5850  *
5851  * ****************************************************************/
5852 uint8_t BuildUlCfg(ServCellCfgInfo *servCellCfg, UplinkConfig_t *ulCfg)
5853 {
5854    InitialUlBwp *initUlBwp = NULLP;
5855
5856    if(servCellCfg)
5857    {
5858       initUlBwp = &servCellCfg->initUlBwp;
5859    }
5860
5861    ulCfg->initialUplinkBWP = NULLP;
5862    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5863    if(!ulCfg->initialUplinkBWP)
5864    {
5865       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5866       return RFAILED;
5867    }
5868
5869    if(BuildInitialUlBWP(initUlBwp, ulCfg->initialUplinkBWP) != ROK)
5870    {
5871       return RFAILED;
5872    }
5873
5874    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5875    ulCfg->uplinkBWP_ToAddModList = NULLP;
5876    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5877    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5878    if(!ulCfg->firstActiveUplinkBWP_Id)
5879    {
5880       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5881       return RFAILED;
5882    }
5883    if(servCellCfg == NULLP)
5884       *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5885    else
5886       *(ulCfg->firstActiveUplinkBWP_Id) = servCellCfg->firstActvUlBwpId;
5887
5888    ulCfg->pusch_ServingCellConfig = NULLP;
5889    DU_ALLOC(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5890    if(!ulCfg->pusch_ServingCellConfig)
5891    {
5892       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5893       return RFAILED;
5894    }
5895
5896    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5897    {
5898       return RFAILED;
5899    }
5900
5901    ulCfg->carrierSwitching = NULLP;
5902    ulCfg->ext1 = NULLP;
5903    return ROK;
5904 }
5905
5906 /*******************************************************************
5907  *
5908  * @brief Builds PDSCH serving cell config
5909  * @details
5910  *
5911  *    Function : BuildPdschSrvCellCfg
5912  *
5913  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5914  *
5915  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5916  *
5917  * @return ROK     - success
5918  *         RFAILED - failure
5919  *
5920  * ****************************************************************/
5921 uint8_t BuildPdschSrvCellCfg(PdschServCellCfg *pdschServCellDb, struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5922 {
5923    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5924    pdschCfg->choice.setup = NULLP;
5925    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5926    if(!pdschCfg->choice.setup)
5927    {
5928       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5929       return RFAILED;
5930    }
5931
5932    /* Code Block Group Transmission */
5933    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5934    if(pdschServCellDb && (pdschServCellDb->maxCodeBlkGrpPerTb || pdschServCellDb->codeBlkGrpFlushInd))
5935    {
5936       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission, sizeof(struct PDSCH_ServingCellConfig__codeBlockGroupTransmission));
5937       if(pdschCfg->choice.setup->codeBlockGroupTransmission == NULLP)
5938       {
5939          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5940          return RFAILED;
5941       }
5942
5943       pdschCfg->choice.setup->codeBlockGroupTransmission->present = PDSCH_ServingCellConfig__codeBlockGroupTransmission_PR_setup;
5944       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup = NULLP;
5945       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup, sizeof(struct PDSCH_CodeBlockGroupTransmission ));
5946       if(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup == NULLP)
5947       {
5948          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5949          return RFAILED;
5950       }
5951
5952       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock = \
5953          *(pdschServCellDb->maxCodeBlkGrpPerTb);
5954       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator = \
5955          *(pdschServCellDb->codeBlkGrpFlushInd);
5956    }
5957
5958    /* xOverhead */
5959    pdschCfg->choice.setup->xOverhead = NULLP;
5960    if(pdschServCellDb && pdschServCellDb->xOverhead)
5961    {
5962       DU_ALLOC(pdschCfg->choice.setup->xOverhead, sizeof(long));
5963       if(pdschCfg->choice.setup->xOverhead == NULLP)
5964       {
5965          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5966          return RFAILED;
5967       }
5968       *(pdschCfg->choice.setup->xOverhead) = *(pdschServCellDb->xOverhead);
5969    }
5970
5971    /* Number of HARQ processes */
5972    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5973    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5974    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5975    {
5976       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5977       return RFAILED;
5978    }
5979
5980    if(pdschServCellDb == NULLP)
5981    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = PDSCH_NUM_HARQ_PROC;
5982    else
5983    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = pdschServCellDb->numHarqProcForPdsch;
5984
5985    pdschCfg->choice.setup->pucch_Cell = NULLP;
5986
5987    /* Extension */
5988    pdschCfg->choice.setup->ext1 = NULLP;
5989    if(pdschServCellDb && pdschServCellDb->maxMimoLayers)
5990    {
5991       DU_ALLOC(pdschCfg->choice.setup->ext1, sizeof(struct PDSCH_ServingCellConfig__ext1));
5992       if(pdschCfg->choice.setup->ext1 == NULLP)
5993       {
5994          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5995          return RFAILED;
5996       }
5997
5998       DU_ALLOC(pdschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5999       if(pdschCfg->choice.setup->ext1->maxMIMO_Layers == NULLP)
6000       {
6001          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6002          return RFAILED;
6003       }
6004       *(pdschCfg->choice.setup->ext1->maxMIMO_Layers) = *(pdschServCellDb->maxMimoLayers);
6005    }
6006
6007    return ROK;
6008 }
6009
6010 /*******************************************************************
6011  *
6012  * @brief Builds CSI Meas config
6013  * @details
6014  *
6015  *    Function : BuildCsiMeasCfg
6016  *
6017  *    Functionality: Builds CSI Meas config in spCellCfgDed
6018  *
6019  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
6020  *
6021  * @return ROK     - success
6022  *         RFAILED - failure
6023  *
6024  * ****************************************************************/
6025 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
6026 {
6027
6028    return ROK;
6029 }
6030
6031 /*******************************************************************
6032  *
6033  * @brief Builds DL BWP to add/modify list
6034  * @details
6035  *
6036  *    Function : BuildDlBwpToAddModList
6037  *
6038  *    Functionality: Builds DL BWP to add/modify list
6039  *
6040  * @params[in] ServCellCfgInfo *servCellCfg,
6041  *             struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList
6042  *
6043  * @return ROK     - success
6044  *         RFAILED - failure
6045  *
6046  * ****************************************************************/
6047 uint8_t BuildDlBwpToAddModList(ServCellCfgInfo *servCellCfg, struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList)
6048 {
6049    uint8_t elementCnt, idx;
6050
6051    elementCnt = servCellCfg->numDlBwpToAdd;
6052    dlBwpAddModList->list.count = elementCnt;
6053    dlBwpAddModList->list.size = elementCnt * sizeof(struct BWP_Downlink *);
6054    dlBwpAddModList->list.array = NULLP;
6055    DU_ALLOC(dlBwpAddModList->list.array, dlBwpAddModList->list.size);
6056    if(dlBwpAddModList->list.array == NULLP)
6057    {
6058       DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6059       return RFAILED;
6060    }
6061
6062    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6063    {
6064       DU_ALLOC(dlBwpAddModList->list.array[idx], sizeof(BWP_Downlink_t));
6065       if(dlBwpAddModList->list.array[idx] == NULLP)
6066       {
6067          DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6068          return RFAILED;
6069       }
6070    }
6071
6072    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6073    {
6074       dlBwpAddModList->list.array[idx]->bwp_Id = servCellCfg->DlBwpToAddList[idx].bwpId;
6075       dlBwpAddModList->list.array[idx]->bwp_Common = NULLP;
6076       dlBwpAddModList->list.array[idx]->bwp_Dedicated = NULLP;
6077    }
6078    return ROK;
6079 }
6080
6081 /*******************************************************************
6082  *
6083  * @brief Builds Spcell config dedicated
6084  * @details
6085  *
6086  *    Function : BuildSpCellCfgDed
6087  *
6088  *    Functionality: Builds sp cell config dedicated in spCellCfg
6089  *
6090  * @params[in] ServingCellConfig_t srvCellCfg
6091  *
6092  * @return ROK     - success
6093  *         RFAILED - failure
6094  *
6095  * ****************************************************************/
6096 uint8_t BuildSpCellCfgDed(DuUeCb *ueCb, ServingCellConfig_t *srvCellCfg)
6097 {
6098    ServCellCfgInfo *servCellCfg = NULLP;
6099    InitialDlBwp *initDlBwp = NULLP;
6100    PdschServCellCfg *pdschServCellDb = NULLP;
6101
6102    if(ueCb)
6103    {
6104       servCellCfg = &ueCb->macUeCfg.spCellCfg.servCellCfg;
6105       initDlBwp = &servCellCfg->initDlBwp;
6106       pdschServCellDb = &servCellCfg->pdschServCellCfg;
6107    }
6108
6109    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
6110    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
6111    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
6112    {
6113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6114       return RFAILED;
6115    }
6116
6117    srvCellCfg->initialDownlinkBWP = NULLP;
6118    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6119    if(!srvCellCfg->initialDownlinkBWP)
6120    {
6121       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6122       return RFAILED;
6123    }
6124
6125    if(BuildInitialDlBWP(initDlBwp, srvCellCfg->initialDownlinkBWP) != ROK)
6126    {
6127       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6128       return RFAILED;
6129    }
6130
6131    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
6132
6133    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
6134    if(ueCb && ueCb->macUeCfg.spCellCfg.servCellCfg.numDlBwpToAdd)
6135    {
6136       DU_ALLOC(srvCellCfg->downlinkBWP_ToAddModList, sizeof(struct ServingCellConfig__downlinkBWP_ToAddModList));
6137       if(srvCellCfg->downlinkBWP_ToAddModList == NULLP)
6138       {
6139          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6140          return RFAILED;
6141       }
6142
6143       if(BuildDlBwpToAddModList(&ueCb->macUeCfg.spCellCfg.servCellCfg, srvCellCfg->downlinkBWP_ToAddModList) != ROK)
6144       {
6145          DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6146          return RFAILED;
6147       }
6148    }
6149
6150    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
6151    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6152    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
6153    {
6154       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6155       return RFAILED;
6156    }
6157    if(ueCb == NULLP)
6158       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6159    else
6160       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.firstActvDlBwpId;
6161
6162    srvCellCfg->bwp_InactivityTimer = NULLP;
6163
6164    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
6165    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6166    if(!srvCellCfg->defaultDownlinkBWP_Id)
6167    {
6168       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6169       return RFAILED;
6170    }
6171    if(ueCb == NULLP)
6172       *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6173    else
6174       *(srvCellCfg->defaultDownlinkBWP_Id) = ueCb->macUeCfg.spCellCfg.servCellCfg.defaultDlBwpId;
6175
6176    srvCellCfg->uplinkConfig = NULLP;
6177    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6178    if(!srvCellCfg->uplinkConfig)
6179    {
6180       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6181       return RFAILED;
6182    }
6183
6184    if(BuildUlCfg(servCellCfg, srvCellCfg->uplinkConfig) != ROK)
6185    {
6186       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
6187       return RFAILED;
6188    }
6189    srvCellCfg->supplementaryUplink = NULLP;
6190    srvCellCfg->pdcch_ServingCellConfig = NULLP;
6191
6192    srvCellCfg->pdsch_ServingCellConfig = NULLP;
6193    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
6194    if(!srvCellCfg->pdsch_ServingCellConfig)
6195    {
6196       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6197       return RFAILED;
6198    }
6199
6200    if(BuildPdschSrvCellCfg(pdschServCellDb, srvCellCfg->pdsch_ServingCellConfig) != ROK)
6201    {
6202       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
6203       return RFAILED;
6204    }
6205
6206    srvCellCfg->csi_MeasConfig = NULLP;
6207 #if 0
6208    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
6209       if(!srvCellCfg->csi_MeasConfig)
6210       {
6211          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6212          return RFAILED;
6213       }
6214
6215    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
6216    {
6217       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
6218       return RFAILED;
6219    }
6220 #endif
6221    srvCellCfg->sCellDeactivationTimer = NULLP;
6222    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
6223    srvCellCfg->tag_Id = TAG_ID;
6224    srvCellCfg->dummy = NULLP;
6225    srvCellCfg->pathlossReferenceLinking = NULLP;
6226    srvCellCfg->servingCellMO = NULLP;
6227    srvCellCfg->ext1 = NULLP;
6228
6229    return ROK;
6230 }
6231
6232 /*******************************************************************
6233  *
6234  * @brief Fills SCS specific carrier list in DL frequency info
6235  *
6236  * @details
6237  *
6238  *    Function : BuildScsSpecificCarrierListDl
6239  *
6240  *    Functionality: Fills SCS specific carrier list in DL frequency info
6241  *
6242  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
6243  *
6244  * @return ROK     - success
6245  *         RFAILED - failure
6246  *
6247  * ****************************************************************/
6248 uint8_t BuildScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
6249 {
6250    uint8_t elementCnt = 0, listIdx = 0;
6251    ScsSpecCarrier duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.dlScsCarrier;
6252
6253    elementCnt = ODU_VALUE_ONE;
6254    scsCarrierList->list.count = elementCnt;
6255    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6256
6257    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6258    if(!scsCarrierList->list.array)
6259    {
6260       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for scs carrier list array \
6261          in BuildScsSpecificCarrierListDl()");
6262       return RFAILED;
6263    }
6264
6265    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6266    {
6267       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6268       if(!scsCarrierList->list.array[listIdx])
6269       {
6270          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SCS Specific Carrier list array \
6271             element in BuildScsSpecificCarrierListDl()");
6272          return RFAILED;
6273       }
6274    }
6275
6276    listIdx = 0;
6277    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6278    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6279    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6280
6281    return ROK;
6282 }
6283
6284 /*******************************************************************
6285  *
6286  * @brief Fills DL frequency info in DL config common
6287  *
6288  * @details
6289  *
6290  *    Function : BuildFreqInfoDl
6291  *
6292  *    Functionality: Fills DL frequency info in DL config common
6293  *
6294  * @params[in] Pointer to DownlinkConfigCommon_t
6295  *
6296  * @return ROK     - success
6297  *         RFAILED - failure
6298  *
6299  * ****************************************************************/
6300 uint8_t BuildFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
6301 {
6302    uint8_t freqBandIdx = 0, elementCnt = 0;
6303    DlCfgCommon  dlCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg;
6304
6305    /* TODO : Fill SSB Absolute Frequency */
6306    /*
6307       DU_ALLOC(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
6308       if(!frequencyInfoDL->absoluteFrequencySSB)
6309       {
6310       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB Absolute Frequency in BuildFreqInfoDl()");
6311       return RFAILED;
6312       }
6313       frequencyInfoDL->absoluteFrequencySSB = ?;
6314       */
6315
6316    /* NR Multi Frequency Band List */
6317    elementCnt = ODU_VALUE_ONE;
6318    frequencyInfoDL->frequencyBandList.list.count = elementCnt;
6319    frequencyInfoDL->frequencyBandList.list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6320
6321    DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
6322    if(!frequencyInfoDL->frequencyBandList.list.array)
6323    {
6324       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for Frequency Band List array in BuildFreqInfoDl()");
6325       return RFAILED;
6326    }
6327
6328    for(freqBandIdx = 0; freqBandIdx < elementCnt; freqBandIdx++)
6329    {
6330       DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
6331       if(!frequencyInfoDL->frequencyBandList.list.array[freqBandIdx])
6332       {
6333          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoDl()");
6334          return RFAILED;
6335       }
6336    }
6337
6338    freqBandIdx = 0;
6339    *(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx]) = dlCfg.freqBandInd;
6340
6341    /* TODO : Absolute Frequency to Point A */
6342    //frequencyInfoDL->absoluteFrequencyPointA
6343
6344    /* Subcarrier Spacing specifc carrier List */
6345    if((BuildScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList)) != ROK)
6346    {
6347       DU_LOG("\nERROR  -->  DU APP : Failed to fill SCS specific carrier list DL in BuildFreqInfoDl()");
6348       return RFAILED;
6349    }
6350
6351    return ROK;
6352
6353 }
6354
6355 /*******************************************************************
6356  *
6357  * @brief Fills DL config common in Serving cell config common
6358  *
6359  * @details
6360  *
6361  *    Function : BuildDlConfigCommon
6362  *
6363  *    Functionality: Fills DL config common in Serving cell config common
6364  *
6365  * @params[in] Pointer to DownlinkConfigCommon_t
6366  *
6367  * @return ROK     - success
6368  *         RFAILED - failure
6369  *
6370  * ****************************************************************/
6371 uint8_t BuildDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
6372 {
6373    /* DL Frequency Info */
6374    DU_ALLOC(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
6375    if(!dlCfgCommon->frequencyInfoDL)
6376    {
6377       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL frequency info in BuildDlConfigCommon()");
6378       return RFAILED;
6379    }
6380    if((BuildFreqInfoDl(dlCfgCommon->frequencyInfoDL))!= ROK)
6381    {
6382       DU_LOG("\nERROR  --> DU APP : Failed to fill DL frequency info in BuildDlConfigCommon()");
6383       return RFAILED;
6384    }
6385
6386    /* DL BWP config common */
6387    DU_ALLOC(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
6388    if(!dlCfgCommon->initialDownlinkBWP)
6389    {
6390       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL BWP config common in BuildDlConfigCommon()");
6391       return RFAILED;
6392    }
6393    if((BuildBwpDlCommon(dlCfgCommon->initialDownlinkBWP)) != ROK)
6394    {
6395       DU_LOG("\nERROR  --> DU APP : Failed to fill DL DWP config common in BuildDlConfigCommon()");
6396       return RFAILED;
6397    }
6398
6399    return ROK;
6400 }
6401
6402 /*******************************************************************
6403  *
6404  * @brief Fills SCS specific carrier list in UL frequency Info
6405  *
6406  * @details
6407  *
6408  *    Function : BuildScsSpecificCarrierListUl
6409  *
6410  *    Functionality: Fills SCS specific carrier list in UL frequency Info
6411  *
6412  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
6413  *
6414  * @return ROK     - success
6415  *         RFAILED - failure
6416  *
6417  * ****************************************************************/
6418 uint8_t BuildScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
6419 {
6420    uint8_t elementCnt = 0, listIdx = 0;
6421    ScsSpecCarrier   duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.ulScsCarrier;
6422
6423    elementCnt = ODU_VALUE_ONE;
6424    scsCarrierList->list.count = elementCnt;
6425    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6426
6427    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6428    if(!scsCarrierList->list.array)
6429    {
6430       DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6431       return RFAILED;
6432    }
6433
6434    for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
6435    {
6436       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6437       if(!scsCarrierList->list.array[listIdx])
6438       {
6439          DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6440          return RFAILED;
6441       }
6442    }
6443    listIdx = 0;
6444    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6445    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6446    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6447
6448    return ROK;
6449 }
6450
6451 /*******************************************************************
6452  *
6453  * @brief Fills frequency info in UL config common
6454  *
6455  * @details
6456  *
6457  *    Function : BuildFreqInfoUl
6458  *
6459  *    Functionality: Fills frequency info in UL config common
6460  *
6461  * @params[in] Pointer to FrequencyInfoUL_t
6462  *
6463  * @return ROK     - success
6464  *         RFAILED - failure
6465  *
6466  * ****************************************************************/
6467 uint8_t BuildFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
6468 {
6469    uint8_t elementCnt = 0, listIdx= 0;
6470    UlCfgCommon  ulCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg;
6471
6472    /* NR Multi Frequency Band List */
6473    DU_ALLOC(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
6474    if(!frequencyInfoUL->frequencyBandList)
6475    {
6476       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band list in BuildFreqInfoUl()");
6477       return RFAILED;
6478    }
6479
6480    elementCnt = ODU_VALUE_ONE;
6481    frequencyInfoUL->frequencyBandList->list.count = elementCnt;
6482    frequencyInfoUL->frequencyBandList->list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6483
6484    DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
6485    if(!frequencyInfoUL->frequencyBandList->list.array)
6486    {
6487       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array in BuildFreqInfoUl()");
6488       return RFAILED;
6489    }
6490
6491    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6492    {
6493       DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
6494       if(!frequencyInfoUL->frequencyBandList->list.array[listIdx])
6495       {
6496          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoUl()");
6497          return RFAILED;
6498       }
6499    }
6500
6501    listIdx = 0;
6502    *(frequencyInfoUL->frequencyBandList->list.array[listIdx]) = ulCfg.freqBandInd;
6503
6504    /* TODO : Fill Absolute frequency point A */
6505    /*
6506       DU_ALLOC(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
6507       if(!frequencyInfoUL->absoluteFrequencyPointA)
6508       {
6509       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for absolute frequency point A in BuildFreqInfoUl()");
6510       return RFAILED;
6511       }
6512     *(frequencyInfoUL->absoluteFrequencyPointA) = ?;
6513     */
6514
6515    /* Subcarrier Spacing specifc carrier */
6516    if((BuildScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList)) != ROK)
6517    {
6518       DU_LOG("\nERROR  --> DU APP : Failed to fill SCS Specific Carrier list UL in BuildFreqInfoUl()");
6519       return RFAILED;
6520    }
6521
6522    /* P-MAX */
6523    DU_ALLOC(frequencyInfoUL->p_Max, sizeof(P_Max_t));
6524    if(!frequencyInfoUL->p_Max)
6525    {
6526       DU_LOG("\nERROR  -->  DU APP : UL Frequency Infoo  memory allocation failure");
6527       return RFAILED;
6528    }
6529    *frequencyInfoUL->p_Max = ulCfg.pMax;
6530
6531    return ROK;
6532 }
6533
6534 /*******************************************************************
6535  *
6536  * @brief Fills UL config common in Serving cell config common
6537  *
6538  * @details
6539  *
6540  *    Function : BuildUlConfigCommon
6541  *
6542  *    Functionality: Fills UL config common in Serving cell config common
6543  *
6544  * @params[in] Pointer to UplinkConfigCommon_t
6545  *
6546  * @return ROK     - success
6547  *         RFAILED - failure
6548  *
6549  * ****************************************************************/
6550 uint8_t BuildUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
6551 {
6552    /* UL Frequency Info */
6553    DU_ALLOC(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
6554    if(!ulCfgCommon->frequencyInfoUL)
6555    {
6556       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for UL frequency info in BuildUlConfigCommon()");
6557       return RFAILED;
6558    }
6559
6560    if((BuildFreqInfoUl(ulCfgCommon->frequencyInfoUL)) != ROK)
6561    {
6562       DU_LOG("\nERROR  -->  DU APP : Failed to fill frequency info UL in BuildUlConfigCommon()");
6563       return RFAILED;
6564    }
6565
6566    /* UL BWP common */
6567    DU_ALLOC(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
6568    if(!ulCfgCommon->initialUplinkBWP)
6569    {
6570       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for initial UL BWP in BuildUlConfigCommon()");
6571       return RFAILED;
6572    }
6573
6574    if((BuildBwpUlCommon(ulCfgCommon->initialUplinkBWP)) != ROK)
6575    {
6576       DU_LOG("\nERROR  -->  DU APP : Failed to fill BWP UL common in BuildUlConfigCommon()");
6577       return RFAILED;
6578    }
6579
6580    /* Time Alignment timer */
6581    ulCfgCommon->dummy = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.timeAlignTimerComm;
6582
6583    return ROK;
6584 }
6585
6586 /*******************************************************************
6587  *
6588  * @brief Fills SSB position in burst in SP cell config common
6589  *
6590  * @details
6591  *
6592  *    Function : BuildSsbPosInBurst
6593  *
6594  *    Functionality:
6595  *       Fills SSB position in burst in SP cell config common
6596  *
6597  * @params[in] Pointer to struct ServingCellConfigCommon__ssb_PositionsInBurst
6598  *
6599  * @return ROK     - success
6600  *         RFAILED - failure
6601  *
6602  * ****************************************************************/
6603 uint8_t BuildSsbPosInBurst(struct ServingCellConfigCommon__ssb_PositionsInBurst *ssbPosInBurst)
6604 {
6605    uint8_t bitStringSizeInBytes = 0;
6606
6607    ssbPosInBurst->present = ServingCellConfigCommon__ssb_PositionsInBurst_PR_mediumBitmap;
6608
6609    /* As per spec 38.331,in the definition of ServingCellConfigCommon */
6610    bitStringSizeInBytes = 1;
6611    ssbPosInBurst->choice.mediumBitmap.size = bitStringSizeInBytes * sizeof(uint8_t);
6612
6613    DU_ALLOC(ssbPosInBurst->choice.mediumBitmap.buf, ssbPosInBurst->choice.mediumBitmap.size);
6614    if(!ssbPosInBurst->choice.mediumBitmap.buf)
6615    {
6616       DU_LOG("\nERROR  -->  DU APP : Memory Allocation failed for medium bit map buffer in BuildSsbPosInBurst()");
6617       return RFAILED;
6618    }
6619
6620    if((fillBitString(&ssbPosInBurst->choice.mediumBitmap, 0, bitStringSizeInBytes, \
6621                duCfgParam.sib1Params.srvCellCfgCommSib.ssbPosInBurst)) != ROK)
6622    {
6623       DU_LOG("\nERROR  -->  DU APP : Failed to fill medium bit map in BuildSsbPosInBurst()");
6624       return RFAILED;
6625    }
6626
6627    return ROK;
6628 }
6629
6630 /*******************************************************************
6631  *
6632  * @brief Fills SP cell config common in Reconfig with Sync
6633  *
6634  * @details
6635  *
6636  *    Function : BuildSpCellConfigCommon
6637  *
6638  *    Functionality: Fills SP cell config common in Reconfig with Sync
6639  *
6640  * @params[in] Pointer to ServingCellConfigCommon_t
6641  *
6642  * @return ROK     - success
6643  *         RFAILED - failure
6644  *
6645  * ****************************************************************/
6646 uint8_t BuildSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
6647 {
6648    /* Physical Cell Identity */
6649    DU_ALLOC(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
6650    if(!spCellConfigCommon->physCellId)
6651    {
6652       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for physical cell id in BuildSpCellConfigCommon()");
6653       return RFAILED;
6654    }
6655    *(spCellConfigCommon->physCellId) = NR_PCI;
6656
6657    /* Downlink Config Common */
6658    DU_ALLOC(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
6659    if(!spCellConfigCommon->downlinkConfigCommon)
6660    {
6661       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for DL Config Common in BuildSpCellConfigCommon()");
6662       return RFAILED;
6663    }
6664    if((BuildDlConfigCommon(spCellConfigCommon->downlinkConfigCommon)) != ROK)
6665    {
6666       DU_LOG("\nERROR  -->  DU APP : Failed to fill DL config commin in BuildSpCellConfigCommon()");
6667       return RFAILED;
6668    }
6669
6670    /* Uplinlink Config Common */
6671    DU_ALLOC(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
6672    if(!spCellConfigCommon->uplinkConfigCommon)
6673    {
6674       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for UL Config Common in BuildSpCellConfigCommon()");
6675       return RFAILED;
6676    }
6677    if((BuildUlConfigCommon(spCellConfigCommon->uplinkConfigCommon)) != ROK)
6678    {
6679       DU_LOG("\nERROR  -->  DU APP : Failed to fill UL config commin in BuildSpCellConfigCommon()");
6680       return RFAILED;
6681    }
6682
6683    /* Timing Advance offset */
6684    DU_ALLOC(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
6685    if(!spCellConfigCommon->n_TimingAdvanceOffset)
6686    {
6687       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for Timing Advance Offset in BuildSpCellConfigCommon()");
6688       return RFAILED;
6689    }
6690    *(spCellConfigCommon->n_TimingAdvanceOffset) = ServingCellConfigCommon__n_TimingAdvanceOffset_n0;
6691
6692    /* SSB Position In Burst */
6693    DU_ALLOC(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
6694    if(!spCellConfigCommon->ssb_PositionsInBurst)
6695    {
6696       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Position In Burst in BuildSpCellConfigCommon()");
6697       return RFAILED;
6698    }
6699    if((BuildSsbPosInBurst(spCellConfigCommon->ssb_PositionsInBurst)) != ROK)
6700    {
6701       DU_LOG("\nERROR  -->  DU APP : Failed to fill SSB Position In Burst in BuildSpCellConfigCommon()");
6702       return RFAILED;
6703    }
6704
6705    /* SSB Periodicity in Serving cell */
6706    DU_ALLOC(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
6707    if(!spCellConfigCommon->ssb_periodicityServingCell)
6708    {
6709       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Periodicity serving cell in \
6710          BuildSpCellConfigCommon()");
6711       return RFAILED;
6712    }
6713    *(spCellConfigCommon->ssb_periodicityServingCell) = \
6714       convertSsbPeriodicityValueToEnum(duCfgParam.sib1Params.srvCellCfgCommSib.ssbPrdServingCell);
6715
6716    /* DMRS Type A position */
6717    spCellConfigCommon->dmrs_TypeA_Position = convertDmrsTypeAPosValueToEnum(duCfgParam.macCellCfg.dmrsTypeAPos);
6718
6719    /* SSB subcarrier spacing */
6720    DU_ALLOC(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
6721    if(!spCellConfigCommon->ssbSubcarrierSpacing)
6722    {
6723       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for sub-carrier spacing in BuildSpCellConfigCommon()");
6724       return RFAILED;
6725    }
6726    *(spCellConfigCommon->ssbSubcarrierSpacing) = duCfgParam.sib1Params.srvCellCfgCommSib.scs;
6727
6728    /* TDD UL-DL configuration common */
6729    DU_ALLOC(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
6730    if(!spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)
6731    {
6732       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for TDD UL-DL config common in BuildSpCellConfigCommon()");
6733       return RFAILED;
6734    }
6735    if((BuildTddUlDlCfgComm(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)) != ROK)
6736    {
6737       DU_LOG("\nERROR  -->  DU APP : Failed to fill TDD UL-DL config common in BuildSpCellConfigCommon()");
6738       return RFAILED;
6739    }
6740
6741    /* SS PBCH Block Power */
6742    spCellConfigCommon->ss_PBCH_BlockPower = duCfgParam.sib1Params.srvCellCfgCommSib.ssPbchBlockPwr;
6743
6744    return ROK;
6745 }
6746
6747 /*******************************************************************
6748  *
6749  * @brief Fills dedicated RACH configuration in Reconfiguration with sync
6750  *
6751  * @details
6752  *
6753  *    Function : BuildRecfgWithSync
6754  *
6755  *    Functionality:
6756  *       Fills dedicated RACH configuration in Reconfiguration with sync
6757  *
6758  * @params[in] DU UE CB
6759  *             Pointer to Rach config dedicated struct
6760  *
6761  * @return ROK     - success
6762  *         RFAILED - failure
6763  *
6764  * ****************************************************************/
6765 uint8_t BuildRachConfigDedicated(DuUeCb *ueCb, struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
6766 {
6767    uint8_t elementCnt = 0, listIdx = 0;
6768    CFRA_t *cfra = NULLP;
6769    struct CFRA__resources__ssb *ssbResource = NULLP;
6770    RachCfgCommon duRachCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.rachCfg;
6771
6772    rachCfgDed->present = ReconfigurationWithSync__rach_ConfigDedicated_PR_uplink;
6773
6774    /* Uplink */
6775    DU_ALLOC(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
6776    if(!rachCfgDed->choice.uplink)
6777    {
6778       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for RACH uplink configuration in BuildRachConfigDedicated()");
6779       return RFAILED;
6780    }
6781
6782    /* CFRA : Contention free Random Access */
6783    DU_ALLOC(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
6784    if(!rachCfgDed->choice.uplink->cfra)
6785    {
6786       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA in BuildRachConfigDedicated()");
6787       return RFAILED;
6788    }
6789    cfra = rachCfgDed->choice.uplink->cfra;
6790
6791    /* CFRA occassions */
6792    DU_ALLOC(cfra->occasions, sizeof(struct CFRA__occasions));
6793    if(!cfra->occasions)
6794    {
6795       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA occassion in BuildRachConfigDedicated()");
6796       return RFAILED;
6797    }
6798
6799    /* CFRA occassions : RACH generic configuration */
6800    cfra->occasions->rach_ConfigGeneric.prach_ConfigurationIndex = duRachCfg.prachCfgIdx;
6801    cfra->occasions->rach_ConfigGeneric.msg1_FDM = duRachCfg.msg1Fdm;
6802    cfra->occasions->rach_ConfigGeneric.msg1_FrequencyStart = duRachCfg.msg1FreqStart;
6803    cfra->occasions->rach_ConfigGeneric.zeroCorrelationZoneConfig = duRachCfg.zeroCorrZoneCfg;
6804    cfra->occasions->rach_ConfigGeneric.preambleReceivedTargetPower = duRachCfg.preambleRcvdTgtPwr;
6805    cfra->occasions->rach_ConfigGeneric.preambleTransMax = duRachCfg.preambleTransMax;
6806    cfra->occasions->rach_ConfigGeneric.powerRampingStep = duRachCfg.pwrRampingStep;
6807    cfra->occasions->rach_ConfigGeneric.ra_ResponseWindow = duRachCfg.raRspWindow;
6808
6809    /* CFRA occassions : SSB per RACH occasion */
6810    DU_ALLOC(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
6811    if(!cfra->occasions->ssb_perRACH_Occasion)
6812    {
6813       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB per RACH occassion in BuildRachConfigDedicated()");
6814       return RFAILED;
6815    }
6816    *(cfra->occasions->ssb_perRACH_Occasion) = convertCFRASsbPerRachOccasionValueToEnum(duCfgParam.macCellCfg.prachCfg.ssbPerRach);
6817
6818    /* CFRA resource */
6819    cfra->resources.present = CFRA__resources_PR_ssb;
6820
6821    /* CFRA resource : SSB */
6822    DU_ALLOC(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
6823    if(!cfra->resources.choice.ssb)
6824    {
6825       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA resource - SSB in BuildRachConfigDedicated()");
6826       return RFAILED;
6827    }
6828    ssbResource = cfra->resources.choice.ssb;
6829
6830    /* CFRA SSB resource list */
6831    elementCnt = ueCb->cfraResource.numSsb;
6832    ssbResource->ssb_ResourceList.list.count = elementCnt;
6833    ssbResource->ssb_ResourceList.list.size = elementCnt * sizeof(CFRA_SSB_Resource_t *);
6834
6835    DU_ALLOC(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
6836    if(!ssbResource->ssb_ResourceList.list.array)
6837    {
6838       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list in BuildRachConfigDedicated()");
6839       return RFAILED;
6840    }
6841
6842    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6843    {
6844       DU_ALLOC(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
6845       if(!ssbResource->ssb_ResourceList.list.array[listIdx])
6846       {
6847          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list element in BuildRachConfigDedicated()");
6848          return RFAILED;
6849       }
6850       ssbResource->ssb_ResourceList.list.array[listIdx]->ssb = ueCb->cfraResource.ssbResource[listIdx].ssbIdx;
6851       ssbResource->ssb_ResourceList.list.array[listIdx]->ra_PreambleIndex = ueCb->cfraResource.ssbResource[listIdx].raPreambleIdx;
6852    }
6853
6854    return ROK;
6855 }
6856
6857 /*******************************************************************
6858  *
6859  * @brief Fills reconfiguration with sync in SP cell config
6860  *
6861  * @details
6862  *
6863  *    Function : BuildRecfgWithSync
6864  *
6865  *    Functionality: Fills reconfiguration with sync in SP cell config
6866  *
6867  * @params[in] DU UE CB
6868  *             Pointer to ReconfigurationWithSync_t
6869  *
6870  * @return ROK     - success
6871  *         RFAILED - failure
6872  *
6873  * ****************************************************************/
6874 uint8_t BuildRecfgWithSync(DuUeCb *ueCb, ReconfigurationWithSync_t *recfgWithSync)
6875 {
6876    /* SP Cell Config Common */
6877    DU_ALLOC(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
6878    if(!recfgWithSync->spCellConfigCommon)
6879    {
6880       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for spCellConfigCommon in BuildRecfgWithSync()");
6881       return RFAILED;
6882    }
6883
6884    if((BuildSpCellConfigCommon(recfgWithSync->spCellConfigCommon)) != ROK)
6885    {
6886       DU_LOG("\nERROR  -->  DU APP : Failed to build SpCellConfigCommon in BuildRecfgWithSync()");
6887       return RFAILED;
6888    }
6889
6890    /* New UE Identity */
6891    recfgWithSync->newUE_Identity = ueCb->crnti;
6892
6893    /* T304 timer */
6894    recfgWithSync->t304 = ReconfigurationWithSync__t304_ms1000;
6895
6896    /* RACH configuration dedicated */
6897    DU_ALLOC(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
6898    if(!recfgWithSync->rach_ConfigDedicated)
6899    {
6900       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for RACH config dedicated in BuildRecfgWithSync()");
6901       return RFAILED;
6902    }
6903
6904    if((BuildRachConfigDedicated(ueCb, recfgWithSync->rach_ConfigDedicated)) != ROK)
6905    {
6906       DU_LOG("\nERROR  -->  DU APP : Failed to build RACH config dedicated in BuildRecfgWithSync()");
6907       return RFAILED;
6908    }
6909
6910    return ROK;
6911 }
6912
6913 /*******************************************************************
6914  *
6915  * @brief Builds Spcell config
6916  *
6917  * @details
6918  *
6919  *    Function : BuildSpCellCfg
6920  *
6921  *    Functionality: Builds sp cell config in DuToCuRrcContainer
6922  *
6923  * @params[in] SpCellConfig_t spCellCfg
6924  *
6925  * @return ROK     - success
6926  *         RFAILED - failure
6927  *
6928  * ****************************************************************/
6929 uint8_t BuildSpCellCfg(DuUeCb *ueCb, SpCellConfig_t *spCellCfg)
6930 {
6931    spCellCfg->servCellIndex = NULLP;
6932    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
6933    if(!spCellCfg->servCellIndex)
6934    {
6935       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6936       return RFAILED;
6937    }
6938
6939    if(ueCb == NULLP)
6940       *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
6941    else
6942       *(spCellCfg->servCellIndex) = ueCb->macUeCfg.spCellCfg.servCellIdx;
6943
6944    spCellCfg->reconfigurationWithSync = NULLP;
6945    if(ueCb && (ueCb->ueState == UE_HANDIN_IN_PROGRESS))
6946    {
6947       DU_ALLOC(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
6948       if(!spCellCfg->reconfigurationWithSync)
6949       {
6950          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6951          return RFAILED;
6952       }
6953
6954       if((BuildRecfgWithSync(ueCb, spCellCfg->reconfigurationWithSync)) != ROK)
6955       {
6956          DU_LOG("\nERROR  -->  F1AP : Building of reconfiguration with sync failed at BuildSpCellCfg");
6957          return RFAILED;
6958       }
6959    }
6960
6961    spCellCfg->rlf_TimersAndConstants = NULLP;
6962    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
6963
6964    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6965    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
6966    {
6967       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6968       return RFAILED;
6969    }
6970    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
6971
6972    spCellCfg->spCellConfigDedicated = NULLP;
6973    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6974    if(!spCellCfg->spCellConfigDedicated)
6975    {
6976       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6977       return RFAILED;
6978    }
6979    if(BuildSpCellCfgDed(ueCb, spCellCfg->spCellConfigDedicated) != ROK)
6980    {
6981       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
6982       return RFAILED;
6983    }
6984
6985    return ROK;
6986 }
6987
6988 /*******************************************************************
6989  *
6990  * @brief Builds Phy cell group config
6991  *
6992  * @details
6993  *
6994  *    Function : BuildPhyCellGrpCfg
6995  *
6996  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
6997  *
6998  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
6999  *
7000  * @return ROK     - success
7001  *         RFAILED - failure
7002  *
7003  * ****************************************************************/
7004 uint8_t BuildPhyCellGrpCfg(DuUeCb *ueCb, PhysicalCellGroupConfig_t *phyCellGrpCfg)
7005 {
7006    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
7007    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
7008
7009    phyCellGrpCfg->p_NR_FR1 = NULLP;
7010    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
7011    if(!phyCellGrpCfg->p_NR_FR1)
7012    {
7013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
7014       return RFAILED;
7015    }
7016
7017    if(ueCb == NULLP)
7018    {
7019       *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
7020       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
7021    }
7022    else
7023    {
7024       *(phyCellGrpCfg->p_NR_FR1) = ueCb->macUeCfg.phyCellGrpCfg.pNrFr1;
7025       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = ueCb->macUeCfg.phyCellGrpCfg.pdschHarqAckCodebook;
7026    }
7027
7028    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
7029    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
7030    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
7031    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
7032    phyCellGrpCfg->cs_RNTI = NULLP;
7033    phyCellGrpCfg->ext1 = NULLP;
7034    phyCellGrpCfg->ext2 = NULLP;
7035
7036    return ROK;
7037 }
7038 #ifdef NR_DRX
7039 /*******************************************************************
7040  *
7041  * @brief fill long cycle offset value of drx
7042  *
7043  * @details
7044  *
7045  *    Function : fillLongCycleOffsetValFromDuCb
7046  *
7047  *    Functionality: fill long cycle offset value of drx
7048  *
7049  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
7050  * struct DRX_ConfigRrc__drx_LongCycleStartOffset drx_LongCycleStartOffset
7051  *
7052  * @return ROK     - success
7053  *         RFAILED - failure
7054  *
7055  * ****************************************************************/
7056 void fillLongCycleOffsetValFromDuCb(DrxLongCycleStartOffset  drxLongCycleStartOffset,\
7057 struct DRX_ConfigRrc__drx_LongCycleStartOffset *drx_LongCycleStartOffset)
7058 {
7059
7060    drx_LongCycleStartOffset->present = convertLongDrxCycleLengthValueToEnum(drxLongCycleStartOffset.drxLongCycleStartOffsetChoice);
7061    switch(drx_LongCycleStartOffset->present)
7062    {
7063       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
7064          {
7065             drx_LongCycleStartOffset->choice.ms10 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7066             break;
7067          }
7068       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
7069          {
7070             drx_LongCycleStartOffset->choice.ms20 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7071             break;
7072          }
7073       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
7074          {
7075             drx_LongCycleStartOffset->choice.ms32 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7076             break;
7077          }
7078       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
7079          {
7080             drx_LongCycleStartOffset->choice.ms40 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7081             break;
7082          }
7083       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
7084          {
7085             drx_LongCycleStartOffset->choice.ms60 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7086             break;
7087          }
7088       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
7089          {
7090             drx_LongCycleStartOffset->choice.ms64 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7091             break;
7092          }
7093       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
7094          {
7095             drx_LongCycleStartOffset->choice.ms70 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7096             break;
7097          }
7098       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
7099          {
7100             drx_LongCycleStartOffset->choice.ms80 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7101             break;
7102          }
7103       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
7104          {
7105             drx_LongCycleStartOffset->choice.ms128 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7106             break;
7107          }
7108       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
7109          {
7110             drx_LongCycleStartOffset->choice.ms160 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7111             break;
7112          }
7113       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
7114          {
7115             drx_LongCycleStartOffset->choice.ms256 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7116             break;
7117          }
7118       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
7119          {
7120             drx_LongCycleStartOffset->choice.ms320 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7121             break;
7122          }
7123       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
7124          {
7125             drx_LongCycleStartOffset->choice.ms512 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7126             break;
7127          }
7128       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
7129          {
7130             drx_LongCycleStartOffset->choice.ms640 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7131             break;
7132          }
7133       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
7134          {
7135             drx_LongCycleStartOffset->choice.ms1024 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7136             break;
7137          }
7138       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
7139          {
7140             drx_LongCycleStartOffset->choice.ms1280 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7141             break;
7142          }
7143       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
7144          {
7145             drx_LongCycleStartOffset->choice.ms2048 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7146             break;
7147          }
7148       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
7149          {
7150             drx_LongCycleStartOffset->choice.ms2560 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7151             break;
7152          }
7153       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
7154          {
7155             drx_LongCycleStartOffset->choice.ms5120 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7156             break;
7157          }
7158       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
7159          {
7160             drx_LongCycleStartOffset->choice.ms10240 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7161             break;
7162          }
7163       default :
7164          break;
7165    }
7166 }
7167 /*******************************************************************
7168  *
7169  * @brief Builds drx config IE
7170  *
7171  * @details
7172  *
7173  *    Function : BuildDrxConfigRrc
7174  *
7175  *    Functionality: Build drx config in MacCellGrpCfg
7176  *
7177  * @params[in] struct MAC_CellGroupConfig__drx_ConfigRrc
7178  *
7179  * @return ROK     - success
7180  *         RFAILED - failure
7181  *
7182  * ****************************************************************/
7183 uint8_t BuildDrxConfigRrc(DuUeCb *ueCb, struct MAC_CellGroupConfig__drx_ConfigRrc *drxCfg)
7184 {
7185    drxCfg->present = MAC_CellGroupConfig__drx_ConfigRrc_PR_setup;
7186    DU_ALLOC(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
7187    if(!drxCfg->choice.setup)
7188    {
7189       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDrxConfigRrc");
7190       return RFAILED;
7191    }
7192    if(ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationTimerValInMs)
7193    {
7194       drxCfg->choice.setup->drx_onDurationTimer.present = DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds;
7195       drxCfg->choice.setup->drx_onDurationTimer.choice.milliSeconds = convertOnDurationTimerMilliSecondsValueToEnum(ueCb->macUeCfg.\
7196       macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationtimerValue.milliSeconds);
7197    }
7198    else
7199    {
7200       drxCfg->choice.setup->drx_onDurationTimer.present = DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds;
7201       drxCfg->choice.setup->drx_onDurationTimer.choice.subMilliSeconds = ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7202       drxOnDurationTimer.onDurationtimerValue.subMilliSeconds;
7203    }
7204    drxCfg->choice.setup->drx_InactivityTimer = convertDrxInactivityTimerValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxInactivityTimer);
7205    drxCfg->choice.setup->drx_HARQ_RTT_TimerDL = ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxHarqRttTimerDl;
7206    drxCfg->choice.setup->drx_HARQ_RTT_TimerUL = ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxHarqRttTimerUl;
7207    drxCfg->choice.setup->drx_RetransmissionTimerDL = convertDrxRetransmissionTimerDlValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7208    drxRetransmissionTimerDl);
7209    drxCfg->choice.setup->drx_RetransmissionTimerUL = convertDrxRetransmissionTimerUlValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7210    drxRetransmissionTimerUl);
7211    drxCfg->choice.setup->drx_SlotOffset = ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxSlotOffset;
7212    fillLongCycleOffsetValFromDuCb(ueCb->macUeCfg.macCellGrpCfg.drxCfg.drxLongCycleStartOffset, &drxCfg->choice.setup->drx_LongCycleStartOffset);
7213
7214    if(ueCb->macUeCfg.macCellGrpCfg.drxCfg.shortDrxPres)
7215    {
7216       DU_ALLOC(drxCfg->choice.setup->shortDRX, sizeof(struct DRX_ConfigRrc__shortDRX));
7217       if(drxCfg->choice.setup->shortDRX)
7218       {
7219          drxCfg->choice.setup->shortDRX->drx_ShortCycle = convertShortDrxCycleLengthValueToEnum(ueCb->macUeCfg.macCellGrpCfg.drxCfg.\
7220          shortDrx.drxShortCycle);
7221          drxCfg->choice.setup->shortDRX->drx_ShortCycleTimer = ueCb->macUeCfg.macCellGrpCfg.drxCfg.shortDrx.drxShortCycleTimer;
7222       }
7223       else
7224       {
7225          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDrxConfigRrc");
7226          return RFAILED;
7227       }
7228    }
7229    return ROK;
7230 }
7231 #endif
7232 /*******************************************************************
7233  *
7234  * @brief Builds Mac cell group config
7235  *
7236  * @details
7237  *
7238  *    Function : BuildMacCellGrpCfg
7239  *
7240  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
7241  *
7242  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
7243  *
7244  * @return ROK     - success
7245  *         RFAILED - failure
7246  *
7247  * ****************************************************************/
7248 uint8_t BuildMacCellGrpCfg(DuUeCb *ueCb, MAC_CellGroupConfig_t *macCellGrpCfg)
7249 {
7250    macCellGrpCfg->drx_ConfigRrc = NULLP;
7251 #ifdef NR_DRX
7252    if(ueCb)
7253    {
7254       DU_ALLOC(macCellGrpCfg->drx_ConfigRrc, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
7255       if(!macCellGrpCfg->drx_ConfigRrc)
7256       {
7257          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7258          return RFAILED;
7259       }
7260       if(BuildDrxConfigRrc(ueCb, macCellGrpCfg->drx_ConfigRrc) != ROK)
7261       {
7262          DU_LOG("\nERROR  -->  F1AP : failed to build drx config");
7263          return RFAILED;
7264       }
7265    }
7266 #endif
7267    macCellGrpCfg->schedulingRequestConfig = NULLP;
7268    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
7269    if(!macCellGrpCfg->schedulingRequestConfig)
7270    {
7271       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7272       return RFAILED;
7273    }
7274
7275    if(BuildSchedulingReqConfig(ueCb, macCellGrpCfg->schedulingRequestConfig) != ROK)
7276    {
7277       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
7278       return RFAILED;
7279    }
7280
7281    macCellGrpCfg->bsr_Config = NULLP;
7282    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
7283    if(!macCellGrpCfg->bsr_Config)
7284    {
7285       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7286       return RFAILED;
7287    }
7288
7289    if(BuildBsrConfig(ueCb, macCellGrpCfg->bsr_Config) != ROK)
7290    {
7291       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
7292       return RFAILED;
7293    }
7294
7295    macCellGrpCfg->tag_Config = NULLP;
7296    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
7297    if(!macCellGrpCfg->tag_Config)
7298    {
7299       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7300       return RFAILED;
7301    }
7302
7303    if(BuildTagConfig(ueCb, macCellGrpCfg->tag_Config) != ROK)
7304    {
7305       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
7306       return RFAILED;
7307    }
7308
7309    macCellGrpCfg->phr_Config = NULLP;
7310    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
7311    if(!macCellGrpCfg->phr_Config)
7312    {
7313       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7314       return RFAILED;
7315    }
7316
7317    if(BuildPhrConfig(ueCb, macCellGrpCfg->phr_Config) != ROK)
7318    {
7319       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
7320       return RFAILED;
7321    }
7322
7323    macCellGrpCfg->skipUplinkTxDynamic = false;
7324    macCellGrpCfg->ext1 = NULLP;
7325
7326    return ROK;
7327 }
7328 /*******************************************************************
7329  *
7330  * @brief Frees memeory allocated for SearchSpcToAddModList
7331  *
7332  * @details
7333  *
7334  *    Function : FreeSearchSpcToAddModList
7335  *
7336  *    Functionality: Deallocating memory of SearchSpcToAddModList
7337  *
7338  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
7339  *
7340  * @return void
7341  *
7342  4221 * ****************************************************************/
7343 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
7344 {
7345    uint8_t idx1=0;
7346    uint8_t idx2=0;
7347    struct  SearchSpace *searchSpc=NULLP;
7348
7349    if(searchSpcList->list.array)
7350    {
7351       if(searchSpcList->list.array[idx2])
7352       {
7353          searchSpc = searchSpcList->list.array[idx2];
7354          if(searchSpc->controlResourceSetId)
7355          {
7356             if(searchSpc->monitoringSlotPeriodicityAndOffset)
7357             {
7358                if(searchSpc->monitoringSymbolsWithinSlot)
7359                {
7360                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
7361                   {
7362                      if(searchSpc->nrofCandidates)
7363                      {
7364                         if(searchSpc->searchSpaceType)
7365                         {
7366                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
7367                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
7368                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
7369                                     SearchSpace__searchSpaceType));
7370                         }
7371                         DU_FREE(searchSpc->nrofCandidates,
7372                               sizeof(struct SearchSpace__nrofCandidates));
7373                      }
7374                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
7375                            searchSpc->monitoringSymbolsWithinSlot->size);
7376                   }
7377                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
7378                         sizeof(BIT_STRING_t));
7379                }
7380                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
7381                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
7382             }
7383             DU_FREE(searchSpc->controlResourceSetId,
7384                   sizeof(ControlResourceSetId_t));
7385          }
7386       }
7387       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
7388       {
7389          DU_FREE(searchSpcList->list.array[idx1],
7390                sizeof(struct SearchSpace));
7391       }
7392       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
7393    }
7394 }
7395 /*******************************************************************
7396  *
7397  * @brief Frees memory allocated for PdschTimeDomAllocList
7398  *
7399  * @details
7400  *
7401  *    Function : FreePdschTimeDomAllocList
7402  *
7403  *    Functionality: Deallocating memory of PdschTimeDomAllocList
7404  *
7405  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
7406  *
7407  * @return void
7408  *
7409  * ****************************************************************/
7410 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
7411 {
7412    uint8_t idx1=0;
7413
7414    if(timeDomAllocList->choice.setup)
7415    {
7416       if(timeDomAllocList->choice.setup->list.array)
7417       {
7418          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
7419          {
7420             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
7421             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
7422                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
7423          }
7424          DU_FREE(timeDomAllocList->choice.setup->list.array, \
7425                timeDomAllocList->choice.setup->list.size);
7426       }
7427       DU_FREE(timeDomAllocList->choice.setup,\
7428             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
7429    }
7430 }
7431 /*******************************************************************
7432  *
7433  * @brief Frees memory allocated for PuschTimeDomAllocList
7434  *
7435  *@details
7436  *
7437  *    Function : FreePuschTimeDomAllocList
7438  *
7439  *    Functionality: Deallocating memory of PuschTimeDomAllocList
7440  *
7441  * @params[in] PUSCH_Config_t *puschCfg
7442  *
7443  * @return void
7444  *
7445  * ****************************************************************/
7446 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
7447 {
7448    uint8_t rsrcListIdx=0;
7449    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7450
7451    if(puschCfg->pusch_TimeDomainAllocationList)
7452    {
7453       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7454       if(timeDomAllocList_t->choice.setup)
7455       {
7456          if(timeDomAllocList_t->choice.setup->list.array)
7457          {
7458             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
7459             {
7460                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
7461                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
7462                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
7463             }
7464             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
7465                   timeDomAllocList_t->choice.setup->list.size);
7466          }
7467          DU_FREE(timeDomAllocList_t->choice.setup, \
7468                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
7469       }
7470       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
7471       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
7472             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
7473    }
7474
7475 }
7476
7477 /*******************************************************************
7478  *
7479  * @brief Frees memory allocated for Dedicated PUCCH config
7480  *
7481  * @details
7482  *
7483  *    Function : FreeBWPUlDedPucchCfg
7484  *
7485  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
7486  *
7487  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
7488  *
7489  * @return void
7490  *
7491  * ****************************************************************/
7492 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
7493 {
7494    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
7495    PUCCH_Config_t *pucchCfg = NULLP;
7496    PUCCH_ResourceSet_t *rsrcSet = NULLP;
7497    PUCCH_Resource_t *rsrc = NULLP;
7498
7499    if(ulBwpPucchCfg)
7500    {
7501       if(ulBwpPucchCfg->choice.setup)
7502       {
7503          pucchCfg = ulBwpPucchCfg->choice.setup;
7504
7505          //Free resource set list
7506          if(pucchCfg->resourceSetToAddModList)
7507          {
7508             if(pucchCfg->resourceSetToAddModList->list.array)
7509             {
7510                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
7511                {
7512                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
7513                   if(rsrcSet->resourceList.list.array)
7514                   {
7515                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
7516                      {
7517                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
7518                      }
7519                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
7520                   }
7521                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
7522                }
7523                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
7524             }
7525             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
7526          }
7527
7528          //Free resource list
7529          if(pucchCfg->resourceToAddModList)
7530          {
7531             if(pucchCfg->resourceToAddModList->list.array)
7532             {
7533                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
7534                {
7535                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
7536                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
7537                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
7538                }
7539                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
7540             }
7541             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
7542          }
7543
7544          //PUCCH Format 1
7545          if(pucchCfg->format1)
7546          {
7547             if(pucchCfg->format1->choice.setup)
7548             {
7549                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
7550                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
7551             }
7552             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
7553          }
7554
7555          //DL DATA TO UL ACK
7556          if(pucchCfg->dl_DataToUL_ACK)
7557          {
7558             if(pucchCfg->dl_DataToUL_ACK->list.array)
7559             {
7560                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
7561                {
7562                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
7563                }
7564                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
7565             }
7566             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
7567          }
7568
7569          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
7570       }
7571       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
7572    }
7573 }
7574
7575 /*******************************************************************
7576  *
7577  * @brief Frees memory allocated for InitialUlBWP
7578  *
7579  * @details
7580  *
7581  *    Function : FreeInitialUlBWP
7582  *
7583  *    Functionality: Deallocating memory of InitialUlBWP
7584  *
7585  * @params[in] BWP_UplinkDedicated_t *ulBwp
7586  *
7587  * @return void
7588  *
7589  * ****************************************************************/
7590 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
7591 {
7592    uint8_t  rSetIdx, rsrcIdx;
7593    SRS_Config_t   *srsCfg = NULLP;
7594    PUSCH_Config_t *puschCfg = NULLP;
7595    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
7596    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
7597    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
7598    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
7599
7600    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
7601
7602    if(ulBwp->pusch_Config)
7603    {
7604       if(ulBwp->pusch_Config->choice.setup)
7605       {
7606          puschCfg=ulBwp->pusch_Config->choice.setup;
7607          if(puschCfg->dataScramblingIdentityPUSCH)
7608          {
7609             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
7610             {
7611                FreePuschTimeDomAllocList(puschCfg);
7612                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
7613                if(dmrsUlCfg->choice.setup)
7614                {
7615                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
7616                   {
7617                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
7618                      {
7619                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
7620                               sizeof(long));
7621                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
7622                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
7623                      }
7624                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
7625                            sizeof(long));
7626                   }
7627                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
7628                }
7629                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
7630                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
7631             }
7632             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
7633          }
7634          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
7635       }
7636       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
7637
7638       /* Free SRS-Config */
7639       if(ulBwp->srs_Config)
7640       {
7641          if(ulBwp->srs_Config->choice.setup)
7642          {
7643             srsCfg = ulBwp->srs_Config->choice.setup;
7644
7645             /* Free Resource Set to add/mod list */
7646             if(srsCfg->srs_ResourceSetToAddModList)
7647             {
7648                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
7649                if(rsrcSetList->list.array)
7650                {
7651                   rSetIdx = 0;
7652
7653                   /* Free SRS resource Id list in this SRS resource set */
7654                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
7655                   {
7656                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
7657
7658                      if(rsrcIdList->list.array)
7659                      {
7660                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
7661                         {
7662                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
7663                         }
7664                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
7665                      }
7666                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
7667                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
7668                   }
7669
7670                   /* Free resource type info for this SRS resource set */
7671                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
7672                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
7673
7674                   /* Free memory for each resource set */
7675                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
7676                   {
7677                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
7678                   }
7679                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
7680                }
7681                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
7682                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
7683             }
7684
7685             /* Free resource to add/modd list */
7686             if(srsCfg->srs_ResourceToAddModList)
7687             {
7688                resourceList = srsCfg->srs_ResourceToAddModList;
7689                if(resourceList->list.array)
7690                {
7691                   rsrcIdx = 0;
7692                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
7693                         sizeof(struct SRS_Resource__transmissionComb__n2));
7694                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
7695                         sizeof(struct SRS_Resource__resourceType__aperiodic));
7696
7697                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
7698                   {
7699                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
7700                   }
7701                   DU_FREE(resourceList->list.array, resourceList->list.size);
7702                }
7703                DU_FREE(srsCfg->srs_ResourceToAddModList, \
7704                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
7705             }
7706
7707             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
7708          }
7709          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
7710       }
7711    }
7712 }
7713 /*******************************************************************
7714  *
7715  * @brief Frees memory allocated for initialUplinkBWP
7716  *
7717  * @details
7718  *
7719  *    Function : FreeinitialUplinkBWP
7720  *
7721  *    Functionality: Deallocating memory of initialUplinkBWP
7722  *
7723  * @params[in] UplinkConfig_t *ulCfg
7724  *
7725  * @return void
7726  *
7727  *
7728  * ****************************************************************/
7729 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
7730 {
7731    BWP_UplinkDedicated_t *ulBwp=NULLP;
7732    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
7733
7734    if(ulCfg->initialUplinkBWP)
7735    {
7736       ulBwp=ulCfg->initialUplinkBWP;
7737       if(ulCfg->firstActiveUplinkBWP_Id)
7738       {
7739          if(ulCfg->pusch_ServingCellConfig)
7740          {
7741             puschCfg=ulCfg->pusch_ServingCellConfig;
7742             if(puschCfg->choice.setup)
7743             {
7744                if(puschCfg->choice.setup->ext1)
7745                {
7746                   DU_FREE(puschCfg->choice.setup->ext1->\
7747                         processingType2Enabled,sizeof(BOOLEAN_t));
7748                   DU_FREE(puschCfg->choice.setup->ext1->\
7749                         maxMIMO_Layers,sizeof(long));
7750                   DU_FREE(puschCfg->choice.setup->ext1, \
7751                         sizeof(struct PUSCH_ServingCellConfig__ext1));
7752                }
7753                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
7754             }
7755             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
7756          }
7757          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
7758       }
7759       FreeInitialUlBWP(ulBwp);
7760       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
7761    }
7762 }
7763 /*******************************************************************
7764  *
7765  * @brief Frees emmory allocated for BWPDlDedPdschCfg
7766  *
7767  * @details
7768  *
7769  *    Function : FreeBWPDlDedPdschCfg
7770  *
7771  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
7772  *
7773  * @params[in] BWP_DownlinkDedicated_t *dlBwp
7774  *
7775  * @return void
7776  *
7777  *
7778  * ****************************************************************/
7779 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
7780 {
7781    struct PDSCH_Config *pdschCfg=NULLP;
7782    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
7783    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
7784    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
7785
7786    if(dlBwp->pdsch_Config->choice.setup)
7787    {
7788       pdschCfg=dlBwp->pdsch_Config->choice.setup;
7789       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7790       {
7791          if(pdschCfg->pdsch_TimeDomainAllocationList)
7792          {
7793             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
7794             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
7795             {
7796                prbBndlType=&pdschCfg->prb_BundlingType;
7797                DU_FREE(prbBndlType->choice.staticBundling,\
7798                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
7799                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
7800             }
7801             FreePdschTimeDomAllocList(timeDomAllocList);
7802             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
7803                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
7804          }
7805          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
7806          if(dmrsDlCfg->choice.setup)
7807          {
7808             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
7809                   sizeof(long));
7810             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
7811          }
7812          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
7813                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
7814       }
7815       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
7816    }
7817 }
7818 /*******************************************************************
7819  *
7820  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
7821  *
7822  * @details
7823  *
7824  *    Function : FreeBWPDlDedPdcchCfg
7825  *
7826  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
7827  *
7828  * @params[in] BWP_DownlinkDedicated_t *dlBwp
7829  *
7830  * @return void
7831  *
7832  *
7833  * ****************************************************************/
7834 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
7835 {
7836    uint8_t idx1=0;
7837    uint8_t idx2=0;
7838    struct PDCCH_Config *pdcchCfg=NULLP;
7839    struct ControlResourceSet *controlRSet=NULLP;
7840    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
7841
7842    if(dlBwp->pdcch_Config->choice.setup)
7843    {
7844       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
7845       if(pdcchCfg->controlResourceSetToAddModList)
7846       {
7847          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
7848          if(controlRSetList->list.array)
7849          {
7850             controlRSet = controlRSetList->list.array[idx2];
7851             if(controlRSet)
7852             {
7853                if(controlRSet->frequencyDomainResources.buf)
7854                {
7855                   if(controlRSet->pdcch_DMRS_ScramblingID)
7856                   {
7857                      if(pdcchCfg->searchSpacesToAddModList)
7858                      {
7859                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
7860                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
7861                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
7862                      }
7863                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
7864                   }
7865                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
7866                         controlRSet->frequencyDomainResources.size);
7867                }
7868             }
7869             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
7870             {
7871                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
7872             }
7873             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
7874          }
7875          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
7876                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
7877       }
7878       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
7879    }
7880 }
7881
7882 /*******************************************************************
7883  *
7884  * @brief Free SCS specific carrier list in DL frequency info
7885  *
7886  * @details
7887  *
7888  *    Function : FreeScsSpecificCarrierListDl
7889  *
7890  *    Functionality: Free SCS specific carrier list in DL frequency info
7891  *
7892  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
7893  *
7894  * @return void
7895  *
7896  * ****************************************************************/
7897 void FreeScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
7898 {
7899    uint8_t listIdx = 0;
7900
7901    if(!scsCarrierList->list.array)
7902    {
7903       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
7904       {
7905          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
7906       }
7907       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
7908    }
7909 }
7910
7911 /*******************************************************************
7912  *
7913  * @brief Free DL frequency info in DL config common
7914  *
7915  * @details
7916  *
7917  *    Function : FreeFreqInfoDl
7918  *
7919  *    Functionality: Free DL frequency info in DL config common
7920  *
7921  * @params[in] Pointer to DownlinkConfigCommon_t
7922  *
7923  * @return void
7924  *
7925  * ****************************************************************/
7926 void FreeFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
7927 {
7928    uint8_t freqBandIdx = 0;
7929
7930    /* SSB Absolute Frequency */
7931    DU_FREE(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
7932
7933    /* NR Multi Frequency Band List */
7934    if(frequencyInfoDL->frequencyBandList.list.array)
7935    {
7936       for(freqBandIdx = 0; freqBandIdx < frequencyInfoDL->frequencyBandList.list.count; freqBandIdx++)
7937       {
7938          DU_FREE(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
7939       }
7940       DU_FREE(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
7941    }
7942
7943    /* Subcarrier Spacing specifc carrier List */
7944    FreeScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList);
7945 }
7946
7947 /*******************************************************************
7948  *
7949  * @brief Free DL config common in Serving cell config common
7950  *
7951  * @details
7952  *
7953  *    Function : FreeDlConfigCommon
7954  *
7955  *    Functionality: Free DL config common in Serving cell config common
7956  *
7957  * @params[in] Pointer to DownlinkConfigCommon_t
7958  *
7959  * @return void
7960  *
7961  * ****************************************************************/
7962 void FreeDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
7963 {
7964    /* DL Frequency Info */
7965    if(dlCfgCommon->frequencyInfoDL)
7966    {
7967       FreeFreqInfoDl(dlCfgCommon->frequencyInfoDL);
7968       DU_FREE(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
7969    }
7970
7971    /* DL BWP config common */
7972    if(dlCfgCommon->initialDownlinkBWP)
7973    {
7974       FreeBwpDlCommon(dlCfgCommon->initialDownlinkBWP);
7975       DU_FREE(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
7976    }
7977 }
7978
7979 /*******************************************************************
7980  *
7981  * @brief Free SCS specific carrier list in UL frequency Info
7982  *
7983  * @details
7984  *
7985  *    Function : FreeScsSpecificCarrierListUl
7986  *
7987  *    Functionality: Free SCS specific carrier list in UL frequency Info
7988  *
7989  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
7990  *
7991  * @return void
7992  *
7993  * ****************************************************************/
7994 void FreeScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
7995 {
7996    uint8_t listIdx = 0;
7997
7998    if(scsCarrierList->list.array)
7999    {
8000       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
8001       {
8002          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
8003       }
8004       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
8005    }
8006 }
8007
8008 /*******************************************************************
8009  *
8010  * @brief Free frequency info in UL config common
8011  *
8012  * @details
8013  *
8014  *    Function : FreeFreqInfoUl
8015  *
8016  *    Functionality: Free frequency info in UL config common
8017  *
8018  * @params[in] Pointer to FrequencyInfoUL_t
8019  *
8020  * @return void
8021  *
8022  * ****************************************************************/
8023 void FreeFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
8024 {
8025    uint8_t listIdx= 0;
8026
8027    /* NR Multi Frequency Band List */
8028    if(!frequencyInfoUL->frequencyBandList)
8029    {
8030       if(frequencyInfoUL->frequencyBandList->list.array)
8031       {
8032          for(listIdx = 0; listIdx < frequencyInfoUL->frequencyBandList->list.count; listIdx++)
8033          {
8034             DU_FREE(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
8035          }
8036          DU_FREE(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
8037       }
8038       DU_FREE(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
8039    }
8040
8041    /* Absolute frequency point A */
8042    DU_FREE(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
8043
8044    /* Subcarrier Spacing specifc carrier */
8045    FreeScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList);
8046
8047    /* P-MAX */
8048    DU_FREE(frequencyInfoUL->p_Max, sizeof(P_Max_t));
8049 }
8050
8051 /*******************************************************************
8052  *
8053  * @brief Free UL config common in Serving cell config common
8054  *
8055  * @details
8056  *
8057  *    Function : FreeUlConfigCommon
8058  *
8059  *    Functionality: Free UL config common in Serving cell config common
8060  *
8061  * @params[in] Pointer to UplinkConfigCommon_t
8062  *
8063  * @return void
8064  *
8065  * ****************************************************************/
8066 void FreeUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
8067 {
8068    /* UL Frequency Info */
8069    if(ulCfgCommon->frequencyInfoUL)
8070    {
8071       FreeFreqInfoUl(ulCfgCommon->frequencyInfoUL);
8072       DU_FREE(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
8073    }
8074
8075    /* UL BWP common */
8076    if(ulCfgCommon->initialUplinkBWP)
8077    {
8078       FreeBwpUlCommon(ulCfgCommon->initialUplinkBWP);
8079       DU_FREE(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
8080    }
8081 }
8082
8083 /*******************************************************************
8084  *
8085  * @brief Free SP cell config common in Reconfig with Sync
8086  *
8087  * @details
8088  *
8089  *    Function : FreeSpCellConfigCommon
8090  *
8091  *    Functionality: Free SP cell config common in Reconfig with Sync
8092  *
8093  * @params[in] Pointer to ServingCellConfigCommon_t
8094  *
8095  * @return void
8096  *
8097  * ****************************************************************/
8098 void FreeSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
8099 {
8100    /* Free Physical cell identity */
8101    DU_FREE(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
8102
8103    /* Free Downlink Config common */
8104    if(spCellConfigCommon->downlinkConfigCommon)
8105    {
8106       FreeDlConfigCommon(spCellConfigCommon->downlinkConfigCommon);
8107       DU_FREE(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
8108    }
8109
8110    /* Free Uplink Config common */
8111    if(spCellConfigCommon->uplinkConfigCommon)
8112    {
8113       FreeUlConfigCommon(spCellConfigCommon->uplinkConfigCommon);
8114       DU_FREE(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
8115    }
8116
8117    /* Free Timing Advance offset */
8118    DU_FREE(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
8119
8120    /* Free SSB Position in Burst */
8121    if(spCellConfigCommon->ssb_PositionsInBurst)
8122    {
8123       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.buf, \
8124          spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.size);
8125       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
8126    }
8127
8128    /* Free SSB Periodicity in Serving cell */
8129    DU_FREE(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
8130
8131    /* Free SSB subcarrier spacing */
8132    DU_FREE(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8133
8134    /* TDD UL-DL configuration common */
8135    DU_FREE(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
8136 }
8137
8138 /*******************************************************************
8139  *
8140  * @brief Free dedicated RACH configuration in Reconfiguration with sync
8141  *
8142  * @details
8143  *
8144  *    Function : FreeRecfgWithSync
8145  *
8146  *    Functionality:
8147  *       Free dedicated RACH configuration in Reconfiguration with sync
8148  *
8149  * @params[in] Pinter to Rach config dedicated struct
8150  *
8151  * @return void
8152  *
8153  * ****************************************************************/
8154 void FreeRachConfigDedicated(struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
8155 {
8156    uint8_t listIdx = 0;
8157    CFRA_t *cfra = NULLP;
8158    struct CFRA__resources__ssb *ssbResource = NULLP;
8159
8160    /* Uplink */
8161    if(rachCfgDed->choice.uplink)
8162    {
8163       /* CFRA : Contention free Random Access */
8164       if(rachCfgDed->choice.uplink->cfra)
8165       {
8166          cfra = rachCfgDed->choice.uplink->cfra;
8167
8168          /* CFRA occassions */
8169          if(cfra->occasions)
8170          {
8171             /* CFRA occassions : SSB per RACH occasion */
8172             DU_FREE(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
8173             DU_FREE(cfra->occasions, sizeof(struct CFRA__occasions));
8174          }
8175
8176          /* CFRA resource */
8177          cfra->resources.present = CFRA__resources_PR_ssb;
8178
8179          /* CFRA resource : SSB */
8180          if(cfra->resources.choice.ssb)
8181          {
8182             ssbResource = cfra->resources.choice.ssb;
8183
8184             /* CFRA SSB resource list */
8185             if(ssbResource->ssb_ResourceList.list.array)
8186             {
8187                for(listIdx = 0; listIdx < ssbResource->ssb_ResourceList.list.count; listIdx++)
8188                {
8189                   DU_FREE(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
8190                }
8191                DU_FREE(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
8192             }
8193             DU_FREE(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
8194          }
8195          DU_FREE(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
8196       }
8197       DU_FREE(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
8198    }
8199 }
8200
8201 /*******************************************************************
8202  *
8203  * @brief Frees reconfiguration with sync in SP cell config
8204  *
8205  * @details
8206  *
8207  *    Function : FreeRecfgWithSync
8208  *
8209  *    Functionality: Fress reconfiguration with sync in SP cell config
8210  *
8211  * @params[in] Pointer to ReconfigurationWithSync_t
8212  *
8213  * @return void
8214  *
8215  * ****************************************************************/
8216 void FreeRecfgWithSync(ReconfigurationWithSync_t *recfgWithSync)
8217 {
8218    /* Free SP Cell config common */
8219    if(recfgWithSync->spCellConfigCommon)
8220    {
8221       FreeSpCellConfigCommon(recfgWithSync->spCellConfigCommon);
8222       DU_FREE(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
8223    }
8224
8225    /* Free Dedicated RACH configuration */
8226    if(recfgWithSync->rach_ConfigDedicated)
8227    {
8228       FreeRachConfigDedicated(recfgWithSync->rach_ConfigDedicated);
8229       DU_FREE(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
8230    }
8231 }
8232
8233 /*******************************************************************
8234  *
8235  * @brief Frees emmory allocated for DUToCURRCContainer
8236  *
8237  * @details
8238  *
8239  *    Function : FreeMemDuToCuRrcCont
8240  *
8241  *    Functionality: Deallocating memory of DuToCuRrcContainer
8242  *
8243  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
8244  *
8245  * @return ROK     - success
8246  *         RFAILED - failure
8247  *
8248  * ****************************************************************/
8249 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
8250 {
8251    uint8_t idx=0;
8252    SpCellConfig_t *spCellCfg=NULLP;
8253    ServingCellConfig_t *srvCellCfg=NULLP;
8254    BWP_DownlinkDedicated_t *dlBwp=NULLP;
8255    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
8256    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
8257    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
8258    struct RLC_Config *rlcConfig=NULLP;
8259    struct LogicalChannelConfig *macLcConfig=NULLP;
8260    struct MAC_CellGroupConfig__drx_ConfigRrc *drxCfg=NULLP;
8261    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
8262    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
8263    struct TAG_Config *tagConfig=NULLP;
8264    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
8265    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
8266    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
8267
8268    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
8269    if(rlcBearerList)
8270    {
8271       if(rlcBearerList->list.array)
8272       {
8273          for(idx=0; idx<rlcBearerList->list.count; idx++)
8274          {
8275             if(rlcBearerList->list.array[idx])
8276             {
8277                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
8278                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
8279                if(rlcConfig)
8280                {
8281                   switch(rlcConfig->present)
8282                   {
8283                      case RLC_Config_PR_NOTHING:
8284                         break;
8285
8286                      case RLC_Config_PR_am:
8287                         {
8288                            if(rlcConfig->choice.am)
8289                            {
8290                               DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8291                               DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8292                               DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
8293                            }
8294                            break;
8295                         }
8296                      case RLC_Config_PR_um_Bi_Directional:
8297                         {
8298                            if(rlcConfig->choice.um_Bi_Directional)
8299                            {
8300                               DU_FREE(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8301                               DU_FREE(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8302                               DU_FREE(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
8303                            }
8304                            break;
8305                         }
8306                      case RLC_Config_PR_um_Uni_Directional_UL:
8307                         {
8308                            if(rlcConfig->choice.um_Uni_Directional_UL)
8309                            {
8310                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8311                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
8312                            }
8313                            break;
8314                         }
8315                      case RLC_Config_PR_um_Uni_Directional_DL:
8316                         {
8317                            if(rlcConfig->choice.um_Uni_Directional_DL )
8318                            {
8319                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8320                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
8321                            }
8322                            break;
8323                         }
8324                   }
8325                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
8326                }
8327                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
8328                if(macLcConfig)
8329                {
8330                   if(macLcConfig->ul_SpecificParameters)
8331                   {
8332                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
8333                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
8334                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
8335                   }
8336                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
8337                }
8338                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
8339             }
8340          }
8341          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
8342       }
8343       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8344    }
8345
8346    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
8347    if(macCellGrpCfg)
8348    {
8349       drxCfg = macCellGrpCfg->drx_ConfigRrc;
8350
8351       if(drxCfg)
8352       {
8353           switch(drxCfg->present)
8354           {
8355             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
8356                break;
8357             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
8358             {
8359                if(drxCfg->choice.setup)
8360                {
8361                   DU_FREE(drxCfg->choice.setup->shortDRX, sizeof(struct DRX_ConfigRrc__shortDRX));
8362                   DU_FREE(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
8363                }
8364             }
8365             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
8366                break;
8367           }
8368           DU_FREE(drxCfg, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
8369       }
8370       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
8371       if(schedulingRequestConfig)
8372       {
8373          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
8374          if(schReqList)
8375          {
8376             if(schReqList->list.array)
8377             {
8378                for(idx=0;idx<schReqList->list.count; idx++)
8379                {
8380                   if(schReqList->list.array[idx])
8381                   {
8382                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
8383                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
8384                   }
8385                }
8386                DU_FREE(schReqList->list.array, schReqList->list.size);
8387             }
8388             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
8389                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
8390             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
8391       }
8392       if(macCellGrpCfg->bsr_Config)
8393       {
8394          DU_FREE(macCellGrpCfg->bsr_Config->logicalChannelSR_DelayTimer, sizeof(long));
8395          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
8396       }
8397       tagConfig = macCellGrpCfg->tag_Config;
8398       if(tagConfig)
8399       {
8400          tagList = tagConfig->tag_ToAddModList;
8401          if(tagList)
8402          {
8403             if(tagList->list.array)
8404             {
8405                for(idx=0; idx<tagList->list.count; idx++)
8406                {
8407                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
8408                }
8409                DU_FREE(tagList->list.array, tagList->list.size);
8410             }
8411             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
8412          }
8413          DU_FREE(tagConfig, sizeof(struct TAG_Config));
8414       }
8415
8416       phrConfig = macCellGrpCfg->phr_Config;
8417       if(phrConfig)
8418       {
8419          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
8420          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
8421       }
8422
8423       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
8424    }
8425
8426    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
8427    if(phyCellGrpCfg)
8428    {
8429       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
8430       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
8431    }
8432
8433    spCellCfg = cellGrpCfg->spCellConfig;
8434    if(spCellCfg)
8435    {
8436       /* Free serving cell index */
8437       DU_FREE(spCellCfg->servCellIndex, sizeof(long));
8438
8439       /* Free Reconfiguration with sync */
8440       if(spCellCfg->reconfigurationWithSync)
8441       {
8442          FreeRecfgWithSync(spCellCfg->reconfigurationWithSync);
8443          DU_FREE(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
8444       }
8445
8446       /* Free rlmInSyncOutOfSyncThreshold */
8447       DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
8448
8449       /* Free SP Cell config dedicated */
8450       if(spCellCfg->spCellConfigDedicated)
8451       {
8452          srvCellCfg = spCellCfg->spCellConfigDedicated;
8453
8454          /* Free TDD UL-DL config dedicated */
8455          DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
8456
8457          /* Free Initial Downlink BWP */
8458          if(srvCellCfg->initialDownlinkBWP)
8459          {
8460             dlBwp = srvCellCfg->initialDownlinkBWP;
8461
8462             /* Free DL BWP PDCCH Config */
8463             if(dlBwp->pdcch_Config)
8464             {
8465                FreeBWPDlDedPdcchCfg(dlBwp);
8466                DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
8467             }
8468
8469             /* Free DL BWP PDSCH config */
8470             if(dlBwp->pdsch_Config)
8471             {
8472                FreeBWPDlDedPdschCfg(dlBwp);
8473                DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
8474             }
8475             DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
8476          }
8477
8478          /* Free First Active Downlink BWP */
8479          DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
8480
8481          /* Free Default downlink BWP */
8482          DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
8483
8484          /* Free Uplink config */
8485          if(srvCellCfg->uplinkConfig)
8486          {
8487             FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
8488             DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
8489          }
8490
8491          /* Free PDSCH serving cell config */
8492          if(srvCellCfg->pdsch_ServingCellConfig)
8493          {
8494             pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
8495             if(pdschCfg->choice.setup)
8496             {
8497                DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
8498                DU_FREE(pdschCfg->choice.setup, sizeof(struct PDSCH_ServingCellConfig));
8499             }
8500             DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
8501          }
8502
8503          DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
8504       }
8505       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
8506    }
8507    return ROK;
8508 }
8509
8510 /*******************************************************************
8511  *
8512  * @brief Builds CellGroupConfigRrc for DU To CU RRC Container
8513  *
8514  * @details
8515  *
8516  *    Function : BuildCellGroupConfigRrc
8517  *
8518  *    Functionality: Builds and copied Cell group config buffer into
8519  *       DuToCuRrcContainer
8520  *
8521  * @params[in] idx, index in F1AP msg
8522  *             DuToCuRRCContainer, DuToCuRRCContainer
8523  *
8524  * @return ROK     - success
8525  *         RFAILED - failure
8526  *
8527  * ****************************************************************/
8528 uint8_t BuildCellGroupConfigRrc(DuUeCb *ueCb, OCTET_STRING_t *duToCuRrcContainer)
8529 {
8530    uint8_t  ret = ROK;
8531    CellGroupConfigRrc_t  cellGrpCfg;
8532    asn_enc_rval_t        encRetVal;
8533    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
8534    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8535
8536    while(true)
8537    {
8538       cellGrpCfg.cellGroupId = CELL_GRP_ID;
8539
8540       cellGrpCfg.rlc_BearerToAddModList = NULLP;
8541       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8542       if(!cellGrpCfg.rlc_BearerToAddModList)
8543       {
8544          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8545          ret = RFAILED;
8546          break;
8547       }
8548       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList) != ROK)
8549       {
8550          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
8551          ret = RFAILED;
8552          break;
8553       }
8554
8555       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
8556       cellGrpCfg.mac_CellGroupConfig = NULLP;
8557       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
8558       if(!cellGrpCfg.mac_CellGroupConfig)
8559       {
8560          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8561          ret = RFAILED;
8562          break;
8563       }
8564       if(BuildMacCellGrpCfg(ueCb, cellGrpCfg.mac_CellGroupConfig) != ROK)
8565       {
8566          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
8567          ret = RFAILED;
8568          break;
8569       }
8570
8571       cellGrpCfg.physicalCellGroupConfig = NULLP;
8572       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
8573       if(!cellGrpCfg.physicalCellGroupConfig)
8574       {
8575          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8576          ret = RFAILED;
8577          break;
8578       }
8579       if(BuildPhyCellGrpCfg(ueCb, cellGrpCfg.physicalCellGroupConfig) != ROK)
8580       {
8581          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
8582          ret = RFAILED;
8583          break;
8584       }
8585
8586       cellGrpCfg.spCellConfig = NULLP;
8587       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
8588       if(!cellGrpCfg.spCellConfig)
8589       {
8590          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8591          ret = RFAILED;
8592          break;
8593       }
8594       if(BuildSpCellCfg(ueCb, cellGrpCfg.spCellConfig) != ROK)
8595       {
8596          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
8597          ret = RFAILED;
8598          break;
8599       }
8600
8601       cellGrpCfg.sCellToAddModList = NULLP;
8602       cellGrpCfg.sCellToReleaseList = NULLP;
8603       cellGrpCfg.ext1 = NULLP;
8604
8605       /* encode cellGrpCfg into duToCuRrcContainer */
8606       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
8607       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8608       encBufSize = 0;
8609       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
8610       /* Encode results */
8611       if(encRetVal.encoded == ENCODE_FAIL)
8612       {
8613          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
8614                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8615          ret = RFAILED;
8616          break;
8617       }
8618       else
8619       {
8620          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
8621 #ifdef DEBUG_ASN_PRINT
8622          for(int i=0; i< encBufSize; i++)
8623          {
8624             printf("%x",encBuf[i]);
8625          }
8626 #endif
8627       }
8628
8629       duToCuRrcContainer->size = encBufSize;
8630       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
8631       if(!duToCuRrcContainer->buf)
8632       {
8633          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
8634          ret = RFAILED;
8635          break;
8636       }
8637       if(ret == ROK)
8638       {
8639          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
8640       }
8641       break;
8642    }
8643    FreeMemDuToCuRrcCont(&cellGrpCfg);
8644    return ret;
8645 }
8646
8647 /*******************************************************************
8648  *
8649  * @brief Free memory allocated in InitialULRRCMessage
8650  *
8651  * @details
8652  *
8653  *    Function : freeInitUlRrcMsgTransfer
8654  *
8655  *    Functionality: Free memory allocated in InitialULRRCMessage
8656  *
8657  * @params[in]F1AP_PDU_t  *f1apMsg)
8658  *
8659  * @return ROK     - success
8660  *         RFAILED - failure
8661  *
8662  * ****************************************************************/
8663
8664 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
8665 {
8666    uint8_t ieIdx, arrIdx;
8667    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
8668
8669    if(f1apMsg)
8670    {
8671       if(f1apMsg->choice.initiatingMessage)
8672       {
8673          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
8674             choice.InitialULRRCMessageTransfer;
8675          if(initULRRCMsg->protocolIEs.list.array)
8676          {
8677             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
8678             {
8679                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
8680                {
8681                   case ProtocolIE_ID_id_NRCGI:
8682                   {
8683                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
8684                      {
8685                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
8686                         {
8687                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
8688                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
8689                         }
8690                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
8691                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
8692                      }
8693                      break;
8694                   }
8695                   case ProtocolIE_ID_id_RRCContainer:
8696                   {
8697                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8698                      {
8699                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
8700                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8701                      }
8702                      break;
8703                   }
8704                   case ProtocolIE_ID_id_DUtoCURRCContainer:
8705                   {
8706                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
8707                      {
8708                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
8709                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
8710                      }
8711                      break;
8712                   }
8713                   default:
8714                      break;
8715                }
8716              }
8717              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8718              {
8719                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
8720                 {
8721                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
8722                       sizeof(InitialULRRCMessageTransferIEs_t));
8723                 }
8724              }
8725              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
8726           }
8727          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8728       }
8729       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
8730    }
8731    else
8732    {
8733       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
8734       return RFAILED;
8735    }
8736    return ROK;
8737 }
8738
8739 /*******************************************************************
8740  *
8741  * @brief Builds and sends the InitialULRRCMessage
8742  *
8743  * @details
8744  *
8745  *    Function : BuildAndSendInitialRrcMsgTransfer
8746  *
8747  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
8748  *                   it to the CU through SCTP.
8749  *
8750  * @params[in]
8751  *
8752  * @return ROK     - success
8753  *         RFAILED - failure
8754  *
8755  * ****************************************************************/
8756 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
8757       uint16_t rrcContSize, uint8_t *rrcContainer)
8758 {
8759    uint8_t   ret;
8760    uint8_t   elementCnt;
8761    uint8_t   ieIdx, cellIdx, ueIdx;
8762    DuUeCb    *duUeCb = NULLP;
8763    asn_enc_rval_t  encRetVal;
8764    F1AP_PDU_t  *f1apMsg = NULLP;
8765    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
8766    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8767
8768    while(true)
8769    {
8770       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
8771       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8772       if(f1apMsg == NULLP)
8773       {
8774          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8775          break;
8776       }
8777       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8778       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8779       if(f1apMsg->choice.initiatingMessage == NULLP)
8780       {
8781          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
8782          break;
8783       }
8784       f1apMsg->choice.initiatingMessage->procedureCode =\
8785                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
8786       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
8787       f1apMsg->choice.initiatingMessage->value.present = \
8788                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
8789       initULRRCMsg =\
8790                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
8791       elementCnt = 5;
8792       initULRRCMsg->protocolIEs.list.count = elementCnt;
8793       initULRRCMsg->protocolIEs.list.size = \
8794                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
8795       /* Initialize the F1Setup members */
8796       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
8797       if(initULRRCMsg->protocolIEs.list.array == NULLP)
8798       {
8799          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
8800                RRCSetupRequestMessageTransferIEs failed");
8801          break;
8802       }
8803       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
8804       {
8805          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
8806                sizeof(InitialULRRCMessageTransferIEs_t));
8807          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
8808          {
8809             break;
8810          }
8811       }
8812       ieIdx = 0;
8813       /*GNB DU UE F1AP ID*/
8814       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8815                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8816       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
8817       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
8818                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
8819       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
8820
8821
8822       /*NRCGI*/
8823       ieIdx++;
8824       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8825                                                         ProtocolIE_ID_id_NRCGI;
8826       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
8827       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
8828                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
8829
8830       ret =\
8831            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
8832       if(ret!=ROK)
8833       {
8834          break;
8835       }
8836
8837       /*CRNTI*/
8838       ieIdx++;
8839       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8840                                                         ProtocolIE_ID_id_C_RNTI;
8841       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8842       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8843                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
8844       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
8845
8846       /*RRCContainer*/
8847       ieIdx++;
8848       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8849                                                         ProtocolIE_ID_id_RRCContainer;
8850       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8851       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8852                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
8853
8854       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
8855       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
8856             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
8857       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8858       {
8859          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
8860          break;
8861
8862       }
8863       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
8864             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8865
8866
8867       /*DUtoCURRCContainer*/
8868       ieIdx++;
8869       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
8870       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8871       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8872                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
8873
8874       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
8875       {
8876          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
8877          {
8878             if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
8879                   (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti == crnti))
8880             {
8881                duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
8882             }
8883          }
8884       }
8885
8886       ret = BuildCellGroupConfigRrc(duUeCb, &initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
8887       if(ret != ROK)
8888       {
8889          break;
8890       }
8891
8892       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8893
8894       /* Encode the Intial UL RRC Message transfer as APER */
8895       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8896       encBufSize = 0;
8897       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
8898       /* Encode results */
8899       if(encRetVal.encoded == ENCODE_FAIL)
8900       {
8901          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
8902                structure (at %s)\n",encRetVal.failed_type ? \
8903                encRetVal.failed_type->name : "unknown");
8904          ret = RFAILED;
8905          break;
8906       }
8907       else
8908       {
8909
8910          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
8911                Message transfer\n");
8912 #ifdef DEBUG_ASN_PRINT
8913          for(int i=0; i< encBufSize; i++)
8914          {
8915             printf("%x",encBuf[i]);
8916          }
8917 #endif
8918       }
8919       /* Sending  msg  */
8920       if(sendF1APMsg() != ROK)
8921       {
8922          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
8923          ret = RFAILED;
8924          break;
8925       }
8926       break;
8927    }
8928    freeInitUlRrcMsgTransfer(f1apMsg);
8929    return ret;
8930 }/* End of BuildAndSendInitialRrcMsgTransfer*/
8931
8932 /*****  UE SETUP REQUEST *****/
8933
8934 /*******************************************************************
8935  *
8936  * @brief Free Qos And Snssai Drb Info
8937  *
8938  * @details
8939  *
8940  *    Function : freeDrbQosAndSnssaiInfo
8941  *
8942  *    Functionality: Free Qos And Snssai Drb Info
8943  *
8944  * @params[in] LcCfg *lcCfg,
8945  * @return void
8946  *
8947  * ****************************************************************/
8948 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
8949 {
8950    if(lcCfg->snssai)
8951    {
8952       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
8953    }
8954    if(lcCfg->drbQos)
8955    {
8956       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
8957    }
8958 }
8959
8960 /******************************************************************
8961 *
8962 * @brief Function to delete the RLC Lc cfg from UE APP DB
8963 *
8964 * @details
8965 *
8966 *  Function : freeRlcLcCfg
8967 *
8968 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
8969 *
8970 *
8971  *****************************************************************/
8972
8973 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
8974 {
8975    switch(lcCfg->rlcMode)
8976    {
8977       case RLC_AM :
8978          {
8979             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
8980             break;
8981          }
8982       case RLC_UM_BI_DIRECTIONAL :
8983          {
8984             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
8985             break;
8986          }
8987       case RLC_UM_UNI_DIRECTIONAL_UL :
8988          {
8989             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
8990             break;
8991          }
8992       case RLC_UM_UNI_DIRECTIONAL_DL :
8993          {
8994             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
8995             break;
8996          }
8997       default:
8998          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
8999          break;
9000    }
9001    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
9002 }
9003
9004 /*******************************************************************
9005  *
9006  * @brief Function to free MacLcCfg
9007  *
9008  * @details
9009  *
9010  *    Function : freeMacLcCfg
9011  *
9012  *    Functionality: Function to free MacLcCfg
9013  *
9014  * @params[in] LcCfg *lcCfg,
9015  * @return void
9016  *
9017  * ****************************************************************/
9018
9019 void  freeMacLcCfg(LcCfg *lcCfg)
9020 {
9021     /* Deleting DRBQOS */
9022    if(lcCfg->drbQos)
9023    {
9024       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
9025    }
9026    /* Deleting SNSSAI */
9027    if(lcCfg->snssai)
9028    {
9029       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
9030    }
9031 }
9032 /*******************************************************************
9033  *
9034  * @brief Free UE NR Capability received in UE Context setup request
9035  *
9036  * @details
9037  *
9038  *    Function : freeAperDecodeUeNrCapability
9039  *
9040  *    Functionality:
9041  *       Free UE NR Capability received in UE Context setup request
9042  *
9043  * @params[in]
9044  * @return ROK     - success
9045  *         RFAILED - failure
9046  *
9047  * ****************************************************************/
9048 void freeAperDecodeUeNrCapability(void *ueNrCapability)
9049 {
9050    uint8_t arrIdx =0;
9051    FeatureSets_t *featureSets =NULLP;
9052    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
9053
9054    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
9055    {
9056       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
9057       {
9058          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
9059             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
9060       }
9061       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
9062    }
9063
9064    if(ueNrCap->featureSets)
9065    {
9066       featureSets = ueNrCap->featureSets;
9067       if(featureSets->featureSetsDownlinkPerCC)
9068       {
9069          if(featureSets->featureSetsDownlinkPerCC->list.array)
9070          {
9071             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
9072             {
9073                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
9074                {
9075                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
9076                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
9077                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
9078                }
9079             }
9080             free(featureSets->featureSetsDownlinkPerCC->list.array);
9081          }
9082          free(featureSets->featureSetsDownlinkPerCC);
9083       }
9084       if(featureSets->featureSetsUplinkPerCC)
9085       {
9086          if(featureSets->featureSetsUplinkPerCC->list.array)
9087          {
9088             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
9089             {
9090                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
9091                {
9092                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
9093                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
9094                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
9095                }
9096             }
9097             free(featureSets->featureSetsUplinkPerCC->list.array);
9098          }
9099          free(featureSets->featureSetsUplinkPerCC);
9100       }
9101       free(ueNrCap->featureSets);
9102    }
9103 }
9104
9105 /*******************************************************************
9106 *
9107 * @brief Function to free PdcchSearchSpcToAddModList
9108          where memory allocated by aper_decoder
9109 *
9110 * @details
9111 *
9112 *    Function : freeAperDecodePdcchSearchSpcToAddModList
9113 *
9114 *    Functionality: Function to free PdcchSearchSpcToAddModList
9115 *
9116 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
9117 * @return void
9118 *
9119 * ****************************************************************/
9120
9121 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
9122 {
9123    uint8_t searchSpcArrIdx=0;
9124    uint8_t searchSpcArrIdx1=0;
9125    struct  SearchSpace *searchSpc=NULLP;
9126
9127
9128    if(searchSpcList->list.array)
9129    {
9130       if(searchSpcList->list.array[searchSpcArrIdx1])
9131       {
9132          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
9133          if(searchSpc->controlResourceSetId)
9134          {
9135             if(searchSpc->monitoringSlotPeriodicityAndOffset)
9136             {
9137                if(searchSpc->monitoringSymbolsWithinSlot)
9138                {
9139                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
9140                   {
9141                      if(searchSpc->nrofCandidates)
9142                      {
9143                         if(searchSpc->searchSpaceType)
9144                         {
9145                            free(searchSpc->searchSpaceType->choice.ue_Specific);
9146                            free(searchSpc->searchSpaceType);
9147                         }
9148                         free(searchSpc->nrofCandidates);
9149                      }
9150                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
9151                   }
9152                   free(searchSpc->monitoringSymbolsWithinSlot);
9153                }
9154                free(searchSpc->monitoringSlotPeriodicityAndOffset);
9155             }
9156             free(searchSpc->controlResourceSetId);
9157          }
9158       }
9159       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
9160       {
9161          free(searchSpcList->list.array[searchSpcArrIdx]);
9162       }
9163       free(searchSpcList->list.array);
9164    }
9165 }
9166 /*******************************************************************
9167 *
9168 * @brief Function for free part for the memory allocated by aper_decoder
9169 *
9170 * @details
9171 *
9172 *    Function : freeAperDecodeBWPDlDedPdcchConfig
9173 *
9174 *    Functionality: Function to free BWPDlDedPdcchConfig
9175 *
9176 * @params[in]
9177 * @return void
9178 *
9179 * ****************************************************************/
9180
9181
9182 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
9183 {
9184    uint8_t arrIdx1=0;
9185    uint8_t arrIdx2=0;
9186    struct PDCCH_Config *pdcchCfg=NULLP;
9187    struct ControlResourceSet *controlRSet=NULLP;
9188    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
9189
9190    if(dlBwp->pdcch_Config->choice.setup)
9191    {
9192       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
9193       if(pdcchCfg->controlResourceSetToAddModList)
9194       {
9195          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
9196          if(controlRSetList->list.array)
9197          {
9198             controlRSet = controlRSetList->list.array[arrIdx2];
9199             if(controlRSet)
9200             {
9201                if(controlRSet->frequencyDomainResources.buf)
9202                {
9203                   if(controlRSet->pdcch_DMRS_ScramblingID)
9204                   {
9205                      if(pdcchCfg->searchSpacesToAddModList)
9206                      {
9207                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
9208                         free(pdcchCfg->searchSpacesToAddModList);
9209                      }
9210                      free(controlRSet->pdcch_DMRS_ScramblingID);
9211                   }
9212                   free(controlRSet->frequencyDomainResources.buf);
9213                }
9214             }
9215             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
9216             {
9217                free(controlRSetList->list.array[arrIdx1]);
9218             }
9219             free(controlRSetList->list.array);
9220          }
9221          free(pdcchCfg->controlResourceSetToAddModList);
9222       }
9223       free(dlBwp->pdcch_Config->choice.setup);
9224    }
9225 }
9226 /*******************************************************************
9227 *
9228 * @brief Function to free PdschTimeDomAllocationList
9229 *     where the memory allocated by aper_decoder
9230 *
9231 * @details
9232 *
9233 *    Function : freeAperDecodePdschTimeDomAllocationList
9234 *
9235 *    Functionality: Function to free PdschTimeDomAllocationList
9236 *
9237 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
9238 * @return void
9239 *
9240 * ****************************************************************/
9241
9242
9243 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
9244 {
9245    uint8_t arrIdx=0;
9246
9247    if(timeDomAllocList->choice.setup)
9248    {
9249       if(timeDomAllocList->choice.setup->list.array)
9250       {
9251          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
9252          {
9253             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
9254          }
9255          free(timeDomAllocList->choice.setup->list.array);
9256       }
9257       free(timeDomAllocList->choice.setup);
9258    }
9259 }
9260
9261 /*******************************************************************
9262 *
9263 * @brief Function to free BWPDlDedPdschConfig
9264 *        where the memory allocated by aper_decoder
9265 *
9266 * @details
9267 *
9268 *    Function : freeAperDecodeBWPDlDedPdschConfig
9269 *
9270 *    Functionality: Function to free BWPDlDedPdschConfig
9271 *
9272 * @params[in] BWP_DownlinkDedicated_t *dlBwp
9273 * @return void
9274 *
9275 * ****************************************************************/
9276
9277
9278 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
9279 {
9280    struct PDSCH_Config *pdschCfg=NULLP;
9281    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
9282    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
9283    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
9284
9285    if(dlBwp->pdsch_Config->choice.setup)
9286    {
9287       pdschCfg=dlBwp->pdsch_Config->choice.setup;
9288       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
9289       {
9290          if(pdschCfg->pdsch_TimeDomainAllocationList)
9291          {
9292             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
9293             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
9294             {
9295                prbBndlType=&pdschCfg->prb_BundlingType;
9296                free(prbBndlType->choice.staticBundling);
9297                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
9298             }
9299             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
9300             free(pdschCfg->pdsch_TimeDomainAllocationList);
9301          }
9302          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
9303          if(dmrsDlCfg->choice.setup)
9304          {
9305             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
9306             free(dmrsDlCfg->choice.setup);
9307          }
9308          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
9309       }
9310       free(dlBwp->pdsch_Config->choice.setup);
9311    }
9312 }
9313 /*******************************************************************
9314 *
9315 * @brief Function to free PuschTimeDomAllocListCfg
9316                  where the memory allocated by aper_decoder
9317 *
9318 * @details
9319 *
9320 *    Function : freeAperDecodePuschTimeDomAllocListCfg
9321 *
9322 *    Functionality: Function to free PuschTimeDomAllocListCfg
9323 *
9324 * @params[in] PUSCH_Config_t *puschCfg
9325 * @return void
9326 *
9327 * ****************************************************************/
9328
9329
9330 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
9331 {
9332    uint8_t arrIdx=0;
9333    uint8_t arrIdx1=0;
9334    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
9335
9336    if(puschCfg->pusch_TimeDomainAllocationList)
9337    {
9338       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
9339       if(timeDomAllocList_t->choice.setup)
9340       {
9341          if(timeDomAllocList_t->choice.setup->list.array)
9342          {
9343             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
9344             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
9345             {
9346                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
9347             }
9348             free(timeDomAllocList_t->choice.setup->list.array);
9349          }
9350          free(timeDomAllocList_t->choice.setup);
9351       }
9352       free(puschCfg->transformPrecoder);
9353       free(puschCfg->pusch_TimeDomainAllocationList);
9354    }
9355 }
9356 /*******************************************************************
9357 *
9358 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
9359 *
9360 * @details
9361 *
9362 *    Function : freeAperDecodeInitialUlBWPConfig
9363 *
9364 *    Functionality: Function to free InitialUlBWPConfig
9365 *
9366 * @params[in]  BWP_UplinkDedicated_t *ulBwp
9367 * @return void
9368 *
9369 * ****************************************************************/
9370
9371
9372 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
9373 {
9374    uint8_t  rSetIdx =0;
9375    uint8_t  rsrcIdx =0;
9376    SRS_Config_t   *srsCfg = NULLP;
9377    PUSCH_Config_t *puschCfg = NULLP;
9378    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
9379    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
9380    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
9381    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
9382
9383    if(ulBwp->pusch_Config)
9384    {
9385       if(ulBwp->pusch_Config->choice.setup)
9386       {
9387          puschCfg=ulBwp->pusch_Config->choice.setup;
9388          if(puschCfg->dataScramblingIdentityPUSCH)
9389          {
9390             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
9391             {
9392                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
9393                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
9394                if(dmrsUlCfg->choice.setup)
9395                {
9396                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
9397                   {
9398                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
9399                      {
9400                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
9401                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
9402                      }
9403                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
9404                   }
9405                   free(dmrsUlCfg->choice.setup);
9406                }
9407                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
9408             }
9409             free(puschCfg->dataScramblingIdentityPUSCH);
9410          }
9411          free(ulBwp->pusch_Config->choice.setup);
9412       }
9413       free(ulBwp->pusch_Config);
9414
9415       /* Free SRS-Config */
9416       if(ulBwp->srs_Config)
9417       {
9418          if(ulBwp->srs_Config->choice.setup)
9419          {
9420             srsCfg = ulBwp->srs_Config->choice.setup;
9421
9422             /* Free Resource Set to add/mod list */
9423             if(srsCfg->srs_ResourceSetToAddModList)
9424             {
9425                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
9426                if(rsrcSetList->list.array)
9427                {
9428                   rSetIdx = 0;
9429
9430                   /* Free SRS resource Id list in this SRS resource set */
9431                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
9432                   {
9433                      rsrcIdList =
9434                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
9435
9436                      if(rsrcIdList->list.array)
9437                      {
9438                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
9439                               rsrcIdx++)
9440                         {
9441                            free(rsrcIdList->list.array[rsrcIdx]);
9442                         }
9443                         free(rsrcIdList->list.array);
9444                      }
9445                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
9446                   }
9447
9448                   /* Free resource type info for this SRS resource set */
9449
9450                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
9451
9452                   /* Free memory for each resource set */
9453                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
9454                   {
9455                      free(rsrcSetList->list.array[rSetIdx]);
9456                   }
9457                   free(rsrcSetList->list.array);
9458                }
9459                free(srsCfg->srs_ResourceSetToAddModList);
9460             }
9461
9462             /* Free resource to add/modd list */
9463             if(srsCfg->srs_ResourceToAddModList)
9464             {
9465                resourceList = srsCfg->srs_ResourceToAddModList;
9466                if(resourceList->list.array)
9467                {
9468                   rsrcIdx = 0;
9469
9470                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
9471                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
9472
9473                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
9474                   {
9475                      free(resourceList->list.array[rsrcIdx]);
9476                   }
9477                   free(resourceList->list.array);
9478                }
9479                free(srsCfg->srs_ResourceToAddModList);
9480             }
9481
9482             free(ulBwp->srs_Config->choice.setup);
9483          }
9484          free(ulBwp->srs_Config);
9485       }
9486    }
9487 }
9488 /*******************************************************************
9489 *
9490 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
9491 *
9492 * @details
9493 *
9494 *    Function : freeAperDecodeinitialUplinkBWPConfig
9495 *
9496 *    Functionality: Function to free initialUplinkBWPConfig
9497 *
9498 * @params[in] UplinkConfig_t *ulCfg
9499 * @return void
9500 *
9501 * ****************************************************************/
9502
9503
9504 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
9505 {
9506    BWP_UplinkDedicated_t *ulBwp=NULLP;
9507    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
9508
9509    if(ulCfg->initialUplinkBWP)
9510    {
9511       ulBwp=ulCfg->initialUplinkBWP;
9512       if(ulCfg->firstActiveUplinkBWP_Id)
9513       {
9514          if(ulCfg->pusch_ServingCellConfig)
9515          {
9516             puschCfg=ulCfg->pusch_ServingCellConfig;
9517             if(puschCfg->choice.setup)
9518             {
9519                if(puschCfg->choice.setup->ext1)
9520                {
9521                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
9522                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
9523                   free(puschCfg->choice.setup->ext1);
9524                }
9525                free(puschCfg->choice.setup);
9526             }
9527             free(ulCfg->pusch_ServingCellConfig);
9528          }
9529          free(ulCfg->firstActiveUplinkBWP_Id);
9530       }
9531       freeAperDecodeInitialUlBWPConfig(ulBwp);
9532       free(ulCfg->initialUplinkBWP);
9533    }
9534 }
9535
9536 /*******************************************************************
9537  *
9538  * @brief Function to free DuUeCfg
9539  *
9540  * @details
9541  *
9542  *    Function : freeDuUeCfg
9543  *
9544  *    Functionality: Function to free DuUeCfg
9545  *
9546  * @params[in] DuUeCfg *ueCfg
9547  * @return void
9548  *
9549  * ****************************************************************/
9550 void freeDuUeCfg(UeCtxtActionType actionType, DuUeCfg *ueCfg)
9551 {
9552    uint8_t lcIdx = 0;
9553    uint8_t arrIdx = 0;
9554    SpCellConfig_t *spCellCfg = NULLP;
9555    ServingCellConfig_t *srvCellCfg = NULLP;
9556    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9557    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
9558    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9559    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
9560    struct RLC_Config *rlcConfig = NULLP;
9561    struct LogicalChannelConfig *macLcConfig = NULLP;
9562    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
9563    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
9564    struct TAG_Config *tagConfig = NULLP;
9565    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
9566    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
9567    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
9568    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
9569
9570    if(ueCfg->ueNrCapability)
9571    {
9572       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
9573       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
9574       ueCfg->ueNrCapability = NULLP;
9575    }
9576
9577    if(ueCfg->cellGrpCfg)
9578    {
9579       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
9580       if(rlcBearerList)
9581       {
9582          if(rlcBearerList->list.array)
9583          {
9584             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
9585             {
9586                if(rlcBearerList->list.array[arrIdx])
9587                {
9588                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
9589                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
9590
9591                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
9592                   {
9593                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
9594                   }
9595                   if(rlcConfig)
9596                   {
9597                      if(rlcConfig->choice.am)
9598                      {
9599                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
9600                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
9601                         free(rlcConfig->choice.am);
9602                      }
9603                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
9604                   }
9605                   if(macLcConfig)
9606                   {
9607                      if(macLcConfig->ul_SpecificParameters)
9608                      {
9609                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
9610                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
9611                         free(macLcConfig->ul_SpecificParameters);
9612                      }
9613                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
9614                   }
9615                   free(rlcBearerList->list.array[arrIdx]);
9616                }
9617             }
9618             free(rlcBearerList->list.array);
9619          }
9620          free(cellGrpCfg->rlc_BearerToAddModList);
9621       }
9622
9623       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
9624       if(macCellGrpCfg)
9625       {
9626          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
9627          if(schedulingRequestConfig)
9628          {
9629             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
9630             if(schReqList)
9631             {
9632                if(schReqList->list.array)
9633                {
9634                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
9635                   {
9636                      if(schReqList->list.array[arrIdx])
9637                      {
9638                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
9639                         free(schReqList->list.array[arrIdx]);
9640                      }
9641                   }
9642                   free(schReqList->list.array);
9643                }
9644                free(schedulingRequestConfig->schedulingRequestToAddModList);
9645             }
9646             free(macCellGrpCfg->schedulingRequestConfig);
9647          }
9648          if(macCellGrpCfg->bsr_Config)
9649          {
9650             free(macCellGrpCfg->bsr_Config);
9651          }
9652          tagConfig = macCellGrpCfg->tag_Config;
9653          if(tagConfig)
9654          {
9655             tagList = tagConfig->tag_ToAddModList;
9656             if(tagList)
9657             {
9658                if(tagList->list.array)
9659                {
9660                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
9661                   {
9662                      free(tagList->list.array[arrIdx]);
9663                   }
9664                   free(tagList->list.array);
9665                }
9666                free(tagConfig->tag_ToAddModList);
9667             }
9668             free(tagConfig);
9669          }
9670
9671          phrConfig = macCellGrpCfg->phr_Config;
9672          if(phrConfig)
9673          {
9674             free(phrConfig->choice.setup);
9675             free(phrConfig);
9676          }
9677
9678          free(macCellGrpCfg);
9679       }
9680
9681       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
9682       if(phyCellGrpCfg)
9683       {
9684          free(phyCellGrpCfg->p_NR_FR1);
9685          free(phyCellGrpCfg);
9686       }
9687
9688       spCellCfg = cellGrpCfg->spCellConfig;
9689       if(spCellCfg)
9690       {
9691          if(spCellCfg->servCellIndex)
9692          {
9693             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
9694             {
9695                if(spCellCfg->spCellConfigDedicated)
9696                {
9697                   srvCellCfg = spCellCfg->spCellConfigDedicated;
9698                   if(srvCellCfg->initialDownlinkBWP)
9699                   {
9700                      dlBwp = srvCellCfg->initialDownlinkBWP;
9701                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
9702                      {
9703                         if(srvCellCfg->defaultDownlinkBWP_Id)
9704                         {
9705                            if(srvCellCfg->uplinkConfig)
9706                            {
9707
9708                               if(srvCellCfg->pdsch_ServingCellConfig)
9709                               {
9710                                  pdschCfg=
9711                                     srvCellCfg->pdsch_ServingCellConfig;
9712                                  if(pdschCfg->choice.setup)
9713                                  {
9714
9715                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
9716                                     free(pdschCfg->choice.setup);
9717                                  }
9718
9719                                  free(srvCellCfg->pdsch_ServingCellConfig);
9720                               }
9721
9722                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
9723                               free(srvCellCfg->uplinkConfig);
9724                            }
9725                            free(srvCellCfg->defaultDownlinkBWP_Id);
9726                         }
9727
9728                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
9729                      }
9730                      if(dlBwp->pdcch_Config)
9731                      {
9732                         if(dlBwp->pdsch_Config)
9733                         {
9734                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
9735                            free(dlBwp->pdsch_Config);
9736                         }
9737                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
9738                         free(dlBwp->pdcch_Config);
9739                      }
9740                      free(srvCellCfg->initialDownlinkBWP);
9741                   }
9742
9743                   free(spCellCfg->spCellConfigDedicated);
9744                }
9745                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
9746             }
9747             free(spCellCfg->servCellIndex);
9748          }
9749          free(spCellCfg);
9750       }
9751       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9752       ueCfg->cellGrpCfg = NULLP;
9753    }
9754
9755    if(ueCfg->ambrCfg)
9756    {
9757       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
9758    }
9759
9760    if(actionType != UE_CTXT_CFG_QUERY)
9761    {
9762       for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
9763       {
9764          freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
9765       }
9766    }
9767
9768    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
9769    {
9770       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
9771    }
9772
9773    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
9774    {
9775       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
9776    }
9777 }
9778
9779 /*******************************************************************
9780  *
9781  * @brief Function to free UecontextSetupDb
9782  *
9783  * @details
9784  *
9785  *    Function : freeF1UeDb
9786  *
9787  *    Functionality: Function to free UecontextSetupDb
9788  *
9789  * @params[in] UecontextSetupDb *
9790  * @return void
9791  *
9792  * ****************************************************************/
9793
9794 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
9795 {
9796
9797    if(f1UeDb->dlRrcMsg)
9798    {
9799       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
9800       {
9801         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
9802                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
9803       }
9804       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
9805    }
9806    freeDuUeCfg(f1UeDb->actionType, &f1UeDb->duUeCfg);
9807    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
9808    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
9809 }
9810
9811 /*******************************************************************
9812  *
9813  * @brief Function to build Am cfg Info
9814  *
9815  * @details
9816  *
9817  *    Function : extractRlcAmCfg
9818  *
9819  *    Functionality: Function to build Am cfg Info
9820  *
9821  * @params[in] AmBearerCfg *
9822  *             void *
9823  *
9824  * @return ROK/RFAILED
9825  *
9826  * ****************************************************************/
9827
9828 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
9829 {
9830    if(rlcAmCfg)
9831    {
9832       /* UL AM */
9833       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
9834       {
9835          amCfgToSet->ulAmCfg.snLenUl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->dl_AM_RLC.sn_FieldLength));
9836          /*TODO: Check the timer value when sent by real CU */
9837          amCfgToSet->ulAmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_Reassembly);
9838          amCfgToSet->ulAmCfg.statProhTmr = convertProhibitTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_StatusProhibit);
9839       }
9840
9841       /* DL AM */
9842       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
9843       {
9844          amCfgToSet->dlAmCfg.snLenDl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->ul_AM_RLC.sn_FieldLength));
9845          amCfgToSet->dlAmCfg.pollRetxTmr = covertPollRetxTmrEnumToValue(rlcAmCfg->ul_AM_RLC.t_PollRetransmit);
9846          amCfgToSet->dlAmCfg.pollPdu   = covertPollPduEnumToValue(rlcAmCfg->ul_AM_RLC.pollPDU);
9847          amCfgToSet->dlAmCfg.pollByte  = covertPollByteEnumToValue(rlcAmCfg->ul_AM_RLC.pollByte);
9848          amCfgToSet->dlAmCfg.maxRetxTh = covertMaxRetxEnumToValue(rlcAmCfg->ul_AM_RLC.maxRetxThreshold);
9849       }
9850    }
9851 }
9852
9853 /*******************************************************************
9854  *
9855  * @brief Function to build Um Bi Info
9856  *
9857  * @details
9858  *
9859  *    Function : extractRlcUmBiCfg
9860  *
9861  *    Functionality: Function to build Um Bi Info
9862  *
9863  * @params[in] UmBiDirBearerCfg *
9864  *             void *
9865  *
9866  * @return ROK/RFAILED
9867  *
9868  * ****************************************************************/
9869
9870 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
9871 {
9872    if(rlcBiCfg)
9873    {
9874       /* UL UM BI DIR Cfg */
9875       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
9876       {
9877          umBiCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->dl_UM_RLC.sn_FieldLength));
9878          umBiCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcBiCfg->dl_UM_RLC.t_Reassembly);
9879       }
9880
9881       /* DL UM BI DIR Cfg */
9882       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
9883          umBiCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->ul_UM_RLC.sn_FieldLength));
9884    }
9885 }
9886
9887 /*******************************************************************
9888  *
9889  * @brief Function to build Um Ul Info
9890  *
9891  * @details
9892  *
9893  *    Function : extractRlcUmUlCfg
9894  *
9895  *    Functionality: Function to build Um Ul Info
9896  *
9897  * @params[in] UmUniDirUlBearerCfg *
9898  *             void *
9899  *
9900  * @return ROK/RFAILED
9901  *
9902  * ****************************************************************/
9903
9904 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
9905 {
9906    if(umUlCfg)
9907    {
9908       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
9909       {
9910          umUlCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umUlCfg->dl_UM_RLC.sn_FieldLength));
9911          umUlCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(umUlCfg->dl_UM_RLC.t_Reassembly);
9912       }
9913    }
9914 }
9915
9916 /*******************************************************************
9917  *
9918  * @brief Function to build Um Uni Dl Info
9919  *
9920  * @details
9921  *
9922  *    Function : extractRlcUmDlCfg
9923  *
9924  *    Functionality: Function to build Um Uni Dl Info
9925  *
9926  * @params[in] UmUniDirDlBearerCfg *
9927  *             void *
9928  *
9929  * @return ROK/RFAILED
9930  *
9931  * ****************************************************************/
9932 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
9933 {
9934    if(umDlCfg)
9935    {
9936       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
9937          umDlCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umDlCfg->ul_UM_RLC.sn_FieldLength));
9938    }
9939 }
9940
9941 /*******************************************************************
9942  *
9943  * @brief Function to extractRlcModeCfg
9944  *
9945  * @details
9946  *
9947  *    Function : extractRlcModeCfg
9948  *
9949  *    Functionality: Function to extractRlcModeCfg
9950  *
9951  * @params[in] RLC_Config_t *
9952  *             RlcBearerCfg *
9953  *             void  *
9954  * @return ROK/RFAILED
9955  *
9956  * ****************************************************************/
9957 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
9958 {
9959    if(lcCfg)
9960    {
9961       switch(rlcMode)
9962       {
9963          case RLC_AM :
9964             {
9965                if(lcCfg->choice.am)
9966                {
9967                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
9968                   if(rlcDbCfg->u.amCfg)
9969                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
9970                }
9971                break;
9972             }
9973          case RLC_UM_BI_DIRECTIONAL :
9974             {
9975                if(lcCfg->choice.um_Bi_Directional)
9976                {
9977                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
9978                   if(rlcDbCfg->u.umBiDirCfg)
9979                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
9980                }
9981                break;
9982             }
9983          case RLC_UM_UNI_DIRECTIONAL_UL :
9984             {
9985                if(lcCfg->choice.um_Uni_Directional_DL)
9986                {
9987                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
9988                   if(rlcDbCfg->u.umUniDirUlCfg)
9989                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
9990                }
9991                break;
9992             }
9993          case RLC_UM_UNI_DIRECTIONAL_DL :
9994             {
9995                if(lcCfg->choice.um_Uni_Directional_UL)
9996                {
9997                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
9998                   if(rlcDbCfg->u.umUniDirDlCfg)
9999                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
10000                }
10001                break;
10002             }
10003          default:
10004             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
10005             break;
10006       }
10007    }
10008 }
10009
10010 /*******************************************************************
10011  *
10012  * @brief Function to extract extractUlLcCfg
10013  *
10014  * @details
10015  *
10016  *    Function : extractUlLcCfg
10017  *
10018  *    Functionality: Function to extract extractUlLcCfg
10019  *
10020  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
10021  * @return void
10022  *
10023  * ****************************************************************/
10024
10025 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
10026 {
10027    if(ulLcCfg)
10028    {
10029       if(ulLcCfg->ul_SpecificParameters)
10030       {
10031          f1UlLcCfg->priority = \
10032             ulLcCfg->ul_SpecificParameters->priority;
10033       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
10034       {
10035          f1UlLcCfg->lcGroup = \
10036            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
10037       }
10038       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
10039       {
10040          f1UlLcCfg->schReqId = \
10041            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
10042       }
10043       f1UlLcCfg->pbr = \
10044          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
10045       f1UlLcCfg->bsd = \
10046          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
10047       }
10048    }
10049 }
10050
10051 /*******************************************************************
10052 *
10053 * @brief Function to extract Snssai Cfg Info from CU
10054 *
10055 * @details
10056 *
10057 *    Function : extractDrbSnssaiCfg
10058 *
10059 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
10060 *
10061 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
10062 * @return ROK/RFAILED
10063 *
10064 * ****************************************************************/
10065
10066 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
10067 {
10068    if(!(*snssaiToBeShared))
10069    {
10070       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
10071       if(snssaiToBeShared == NULLP)
10072       {
10073          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
10074          return RFAILED;
10075       }
10076    }
10077    if(RecvSnssai)
10078    {
10079       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
10080       if(RecvSnssai->sD)
10081       {
10082          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
10083       }
10084       else
10085       {
10086          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
10087          return RFAILED;
10088       }
10089    }
10090    return ROK;
10091 }
10092
10093 /*******************************************************************
10094  *
10095  * @brief Function to procRlcLcCfg
10096  *
10097  * @details
10098  *
10099  *    Function : procRlcLcCfg
10100  *
10101  *    Functionality: Function to procRlcLcCfg
10102  *
10103  * @params[in] rbId, lcId, rbType, rlcMod
10104  *             RLC_Config_t *, RlcBearerCfg * ,
10105  * @return void
10106  *
10107  * ****************************************************************/
10108
10109 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
10110    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
10111 {
10112    DRB_Information_t *drbInfo;
10113
10114    lcCfg->rbId   = rbId;
10115    lcCfg->configType = configType;
10116
10117    if(rbType == RB_TYPE_SRB)
10118    {
10119       lcCfg->rbType = RB_TYPE_SRB;
10120       lcCfg->lcId   = rbId;
10121       lcCfg->lcType = LCH_DCCH;
10122       lcCfg->rlcMode = RLC_AM;
10123    }
10124    else if(rbType == RB_TYPE_DRB)
10125    {
10126       lcCfg->rbType = RB_TYPE_DRB;
10127       lcCfg->lcId   = lcId;
10128       lcCfg->lcType = LCH_DTCH;
10129       lcCfg->rlcMode = rlcMode;
10130    }
10131    if(f1RlcCfg) /* rlc mode config recived */
10132    {
10133       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
10134    }
10135    if(qoSInformation != NULLP)
10136    {
10137       if(qoSInformation->present == QoSInformation_PR_choice_extension)
10138       {
10139          if(qoSInformation->choice.choice_extension->value.present ==\
10140                QoSInformation_ExtIEs__value_PR_DRB_Information)
10141          {
10142             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10143             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
10144             {
10145                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
10146                return;
10147             }
10148          }
10149       }
10150    }
10151 }
10152
10153 /*******************************************************************
10154  *
10155  * @brief Fills DrbQos Info received by CU
10156  *
10157  * @details
10158  *
10159  *    Function : extractQosInfo
10160  *
10161  *    Functionality: Fills DrbQos Info received  by CU
10162  *
10163  * @params[in] DrbQosInfo *qosToAdd,
10164  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
10165  * @return void
10166  *
10167  * ****************************************************************/
10168
10169 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
10170 {
10171    uint8_t qosCntIdx = 0;
10172    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
10173
10174    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
10175    qosToAdd->u.nonDyn5Qi.fiveQi     =\
10176                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
10177    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
10178    {
10179       qosToAdd->u.nonDyn5Qi.avgWindow = \
10180                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
10181    }
10182
10183    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume)
10184    {
10185       qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
10186                                               *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
10187    }
10188
10189    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
10190    {
10191       qosToAdd->u.nonDyn5Qi.priorLevel = \
10192                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
10193    }
10194    qosToAdd->ngRanRetPri.priorityLevel = \
10195                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
10196    qosToAdd->ngRanRetPri.preEmptionCap = \
10197                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
10198    qosToAdd->ngRanRetPri.preEmptionVul = \
10199                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
10200    if(qosFlowCfg->gBR_QoS_Flow_Information)
10201    {
10202       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
10203             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
10204             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
10205       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
10206             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
10207             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
10208       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
10209             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
10210             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
10211       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
10212             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
10213             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
10214    }
10215    /*Extracting PDU_SESSION_ID*/
10216    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
10217    if(qosIeExt)
10218    {
10219       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
10220       {
10221          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
10222                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
10223          {
10224             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
10225             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
10226          }
10227       }
10228    }
10229    qosToAdd->ulPduSessAggMaxBitRate = 0;
10230 }
10231
10232 /*******************************************************************
10233  *
10234  * @brief Function to extract GTP Tunnel Info from CU
10235  *
10236  * @details
10237  *
10238  *    Function : extractUpTnlInfo
10239  *
10240  *    Functionality: Function to extract GTP Tunnel Info from CU
10241  *
10242  * @params[in] F1AP message
10243  * @return ROK/RFAILED
10244  *
10245  * ****************************************************************/
10246
10247 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
10248    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
10249 {
10250    uint8_t tnlIdx;
10251    uint32_t ipv4_du = 0;
10252    GTPTunnel_t *gtpTunnel = NULLP;
10253
10254    upTnlInfo->drbId = drbId;
10255    upTnlInfo->configType = configType;
10256 #ifdef O1_ENABLE
10257    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
10258 #else
10259    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
10260 #endif
10261
10262    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
10263    {
10264       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
10265       {
10266          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
10267          {
10268             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
10269             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
10270             if(upTnlInfo->tnlCfg1 == NULLP)
10271             {
10272                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
10273                return RFAILED;
10274             }
10275             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
10276             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
10277             if(gtpTunnel->gTP_TEID.size > 0)
10278             {
10279                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
10280             }
10281          }
10282          break;
10283       }
10284    }
10285    return ROK;
10286 }
10287
10288 /*******************************************************************
10289 *
10290 * @brief Function to extract Drb Qos Cfg Info from CU
10291 *
10292 * @details
10293 *
10294 *    Function : extractDrbQosCfg
10295 *
10296 *    Functionality: Function to extract Drb Qos Cfg Info from CU
10297 *
10298 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
10299 * @return ROK/RFAILED
10300 *
10301 * ****************************************************************/
10302
10303 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
10304 {
10305    if(!macLcToAdd->drbQos)
10306    {
10307       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
10308       if(macLcToAdd->drbQos == NULLP)
10309       {
10310          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
10311          return RFAILED;
10312       }
10313
10314    }
10315    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
10316    {
10317       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
10318       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
10319    }
10320    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
10321    {
10322       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
10323       return RFAILED;
10324    }
10325    return ROK;
10326 }
10327 /*******************************************************************
10328  *
10329  * @brief Function to extract DRB info received from CU
10330  *
10331  * @details
10332  *
10333  *    Function : extractDrbCfg
10334  *
10335  *    Functionality: Function to extract DRB info received from CU
10336  *
10337  * @params[in] F1AP message
10338  * @return void
10339  *
10340  * ****************************************************************/
10341 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
10342 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
10343 {
10344    DRB_Information_t *drbInfo = NULLP;
10345
10346    if(drbItem != NULLP)
10347    {
10348       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
10349       {
10350          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10351          return RFAILED;
10352       }
10353       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10354       {
10355          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
10356          {
10357             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10358             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10359             {
10360                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10361                return RFAILED;
10362             }
10363          }
10364       }
10365    }
10366    else if(drbSetupModItem != NULLP)
10367    {
10368       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
10369       upTnlInfo) != ROK)
10370       {
10371          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10372          return RFAILED;
10373       }
10374       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10375       {
10376          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
10377          QoSInformation_ExtIEs__value_PR_DRB_Information)
10378          {
10379             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10380             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10381             {
10382                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10383                return RFAILED;
10384             }
10385
10386          }
10387       }
10388    }
10389    else if(drbModItem != NULLP)
10390    {
10391       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
10392       upTnlInfo) != ROK)
10393       {
10394          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10395          return RFAILED;
10396       }
10397       if(drbModItem->qoSInformation != NULLP)
10398       {
10399          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
10400          {
10401             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
10402                   QoSInformation_ExtIEs__value_PR_DRB_Information)
10403             {
10404                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10405                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
10406                {
10407                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10408                   return RFAILED;
10409                }
10410
10411             }
10412          }
10413       }
10414    }
10415    return ROK;
10416 }
10417
10418 /*******************************************************************
10419  *
10420  * @brief Function to extract RB info received from CU
10421  *
10422  * @details
10423  *
10424  *    Function : extractMacRbCfg
10425  *
10426  *    Functionality: Function to extract RB info received from CU
10427  *
10428  * @params[in] F1AP message
10429  * @return ROK/RFAILED
10430  *
10431  * ****************************************************************/
10432
10433 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
10434 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10435 {
10436    if(drbCfg != NULLP)
10437    {
10438       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
10439       {
10440          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10441          return RFAILED;
10442       }
10443    }
10444    else if(drbSetupModCfg != NULLP)
10445    {
10446       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
10447       {
10448          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10449          return RFAILED;
10450       }
10451    }
10452    else if(drbModCfg != NULLP)
10453    {
10454       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
10455       {
10456          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10457          return RFAILED;
10458       }
10459    }
10460    else
10461    {
10462       lcCfg->drbQos = NULLP;
10463       lcCfg->snssai = NULLP;
10464       if(lcCfg->lcId == SRB2_LCID)
10465          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
10466       else
10467          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
10468    }
10469    if(ulLcCfg)
10470    {
10471       lcCfg->ulLcCfgPres = true;
10472       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
10473    }
10474    else
10475       lcCfg->ulLcCfgPres = false;
10476    return ROK;
10477 }
10478
10479 /*******************************************************************
10480  *
10481  * @brief Function processing LC config info received from CU
10482  *
10483  * @details
10484  *
10485  *    Function : procMacLcCfg
10486  *
10487  *    Functionality: Function processing LC config info received from CU
10488  *
10489  * @params[in] F1AP message
10490  * @return ROK/RFAILED
10491  *
10492  * ****************************************************************/
10493
10494 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
10495 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
10496 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10497 {
10498    uint8_t ret = ROK;
10499
10500    lcCfg->lcId = lcId;
10501    lcCfg->configType = configType;
10502    if(rbType == RB_TYPE_SRB)
10503    {
10504       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
10505    }
10506    else if(rbType == RB_TYPE_DRB)
10507    {
10508       if(drbItem != NULL)
10509         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
10510       else if(drbSetupModItem != NULL)
10511         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
10512       else if(drbModItem != NULL)
10513         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
10514    }
10515    return ret;
10516 }
10517
10518 /*******************************************************************
10519  *
10520  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
10521  *
10522  * @details
10523  *
10524  *    Function : extractRlcCfgToAddMod
10525  *
10526  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
10527  *
10528  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
10529  *             DuUeCfg Pointer
10530  * @return ROK/RFAILED
10531  *
10532  * ****************************************************************/
10533
10534 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
10535 {
10536   uint8_t idx, rbId, lcId, rlcMode, rbType;
10537   RLC_Config_t *f1RlcCfg = NULLP;
10538   LogicalChannelConfig_t *macUlLcCfg = NULLP;
10539
10540   for(idx = 0; idx < lcCfg->list.count; idx++)
10541   {
10542      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
10543      if(lcCfg->list.array[idx]->servedRadioBearer)
10544      {
10545         /* RadioBearer for SRB/DRB */
10546         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10547         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
10548         {
10549            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
10550            rbType = RB_TYPE_SRB;
10551         }
10552         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10553         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
10554         {
10555            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
10556            rbType = RB_TYPE_DRB;
10557         }
10558         else
10559         {
10560            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
10561            return RFAILED;
10562         }
10563         /* MAC UL LC Config */
10564         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
10565         {
10566            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
10567         }
10568      }
10569      else
10570      {
10571         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
10572         return RFAILED;
10573      }
10574      /* RLC Mode Config */
10575      if(lcCfg->list.array[idx]->rlc_Config)
10576      {
10577         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
10578         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
10579      }
10580
10581      /* Filling RLC/MAC Config*/
10582      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
10583      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
10584      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
10585      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
10586      {
10587         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
10588         return RFAILED;
10589      }
10590      (ueCfgDb->numRlcLcs)++;
10591      (ueCfgDb->numMacLcs)++;
10592      DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10593         rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10594   }
10595   //TODO: To send the failure cause in UeContextSetupRsp
10596   return ROK;
10597 }
10598
10599 /*******************************************************************
10600  *
10601  * @brief DeAlloc pdsch serv cell config info
10602  *
10603  * @details
10604  *
10605  *    Function : freeMacPdschServCellInfo
10606  *
10607  *    Functionality: DeAlloc pdsch serv cell config info
10608  *
10609  * @params[in] PdschServCellCfg pointer
10610  * @return void
10611  *
10612  * ****************************************************************/
10613
10614 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
10615 {
10616    if(pdsch->xOverhead)
10617    {
10618       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
10619    }
10620    if(pdsch->codeBlkGrpFlushInd)
10621    {
10622       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
10623    }
10624    if(pdsch->maxCodeBlkGrpPerTb)
10625    {
10626       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
10627    }
10628    if(pdsch->maxMimoLayers)
10629    {
10630       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
10631    }
10632 }
10633
10634 /*******************************************************************
10635  *
10636  * @brief Free Serving cell Info
10637  *
10638  * @details
10639  *
10640  *    Function : freeMacServingCellInfo
10641  *
10642  *    Functionality: Free Serving cell Info
10643  *
10644  * @params[in] ServCellCfgInfo *srvCellCfg
10645  * @return void
10646  *
10647  * ****************************************************************/
10648 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
10649 {
10650    uint8_t timeDomRsrcIdx;
10651
10652    if(srvCellCfg->initDlBwp.pdschPresent)
10653    {
10654       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
10655       {
10656          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
10657             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
10658       }
10659    }
10660
10661    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
10662    if(srvCellCfg->bwpInactivityTmr)
10663    {
10664       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
10665    }
10666
10667    if(srvCellCfg->initUlBwp.pucchPresent)
10668    {
10669       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10670    }
10671 }
10672
10673 /*******************************************************************
10674  *
10675  * @brief Free cell Grp Cfg Info
10676  *
10677  * @details
10678  *
10679  *    Function : freeUeReCfgCellGrpInfo
10680  *
10681  *    Functionality: Free cell Grp Cfg Info
10682  *
10683  * @params[in] MacUeCfg*  duUeCfg
10684  * @return void
10685  *
10686  * ****************************************************************/
10687
10688 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
10689 {
10690    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
10691 }
10692
10693 /*******************************************************************
10694  *
10695  * @brief Fills Reconfig SchReqReConfig
10696  *
10697  * @details
10698  *
10699  *    Function : extractSchReqReConfig
10700  *
10701  *    Functionality: Fills Reconfig SchReqReConfig
10702  *
10703  * @params[in] SchedulingRequestConfig_t *cuSchedReq
10704  *             SchedReqCfg*  macSchedReq
10705  * @return void
10706  *
10707  * ****************************************************************/
10708 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
10709 {
10710    uint8_t schReqIdx = 0;
10711    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
10712    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
10713
10714    if(cuSchedReq->schedulingRequestToAddModList)
10715    {
10716       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
10717       if(schReqListToAdd->list.count)
10718       {
10719          macSchedReq->addModListCount = schReqListToAdd->list.count;
10720          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
10721          {
10722             macSchedReq->addModList[schReqIdx].schedReqId = \
10723                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
10724             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
10725                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
10726             macSchedReq->addModList[schReqIdx].srTransMax    =\
10727                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
10728          }
10729       }
10730    }
10731    /* Scheduling Req To release */
10732    if(cuSchedReq->schedulingRequestToReleaseList)
10733    {
10734       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
10735       if(schReqListToRel->list.count)
10736       {
10737          macSchedReq->relListCount = schReqListToRel->list.count;
10738          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
10739          {
10740             macSchedReq->relList[schReqIdx] = \
10741                *schReqListToRel->list.array[schReqIdx];
10742          }
10743       }
10744    }
10745 }
10746
10747 /*******************************************************************
10748  *
10749  * @brief Fills TagReconfig
10750  *
10751  * @details
10752  *
10753  *    Function : extractTagReconfig
10754  *
10755  *    Functionality: Fills extractTagReconfig
10756  *
10757  * @params[in] TAG_Config_t *cuTagCfg
10758  *             TagCfg *macTagCfg
10759  * @return void
10760  *
10761  * ****************************************************************/
10762
10763 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
10764 {
10765   uint8_t tagIdx = 0;
10766   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
10767   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
10768
10769   /* Tag config to AddMod */
10770   if(cuTagCfg->tag_ToAddModList)
10771   {
10772      tagListToAddMod = cuTagCfg->tag_ToAddModList;
10773      if(tagListToAddMod->list.count)
10774      {
10775         macTagCfg->addModListCount = tagListToAddMod->list.count;
10776         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
10777         {
10778            macTagCfg->addModList[tagIdx].tagId =\
10779               tagListToAddMod->list.array[tagIdx]->tag_Id;
10780            macTagCfg->addModList[tagIdx].timeAlignTimer = \
10781
10782               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
10783         }
10784      }
10785   }
10786   /* Tag config to release */
10787   if(cuTagCfg->tag_ToReleaseList)
10788   {
10789      tagListToRel = cuTagCfg->tag_ToReleaseList;
10790      if(tagListToRel->list.count)
10791      {
10792         macTagCfg->relListCount = tagListToRel->list.count;
10793         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
10794         {
10795            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
10796         }
10797      }
10798   }
10799 }
10800
10801 /*******************************************************************
10802  *
10803  * @brief Fills PdcchCfg received by CU
10804  *
10805  * @details
10806  *
10807  *    Function : extractPdcchCfg
10808  *
10809  *    Functionality: Fills PdcchCfg received  by CU
10810  *
10811  * @params[in] PDCCH_Config_t *cuPdcchCfg,
10812  *             PdcchConfig *duPdcchCfg
10813  * @return void
10814  *
10815  * ****************************************************************/
10816
10817 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
10818 {
10819    uint8_t cRsetIdx = 0;
10820    uint8_t srchSpcIdx = 0;
10821
10822    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
10823    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
10824    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
10825    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
10826
10827
10828    /* Control Resource Set To Add/Mod List */
10829    if(cuPdcchCfg->controlResourceSetToAddModList)
10830    {
10831       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
10832       if(cRsetToAddModList->list.count)
10833       {
10834          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
10835          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
10836          {
10837             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
10838                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
10839             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
10840                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
10841             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
10842                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
10843                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
10844
10845             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
10846                 cRsetToAddModList->list.array[cRsetIdx]->duration;
10847
10848             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
10849                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
10850             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
10851             {
10852                //TODO: handle the case for Interleaved
10853             }
10854             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
10855                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
10856             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
10857             {
10858                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
10859                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
10860             }
10861          }
10862       }
10863    }
10864    /* Control Resource Set To Release List */
10865    if(cuPdcchCfg->controlResourceSetToReleaseList)
10866    {
10867       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
10868       if(cRsetToRelList->list.count)
10869       {
10870          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
10871          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
10872          {
10873             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
10874          }
10875       }
10876    }
10877
10878    /* Search space To Add/Mod List */
10879    if(cuPdcchCfg->searchSpacesToAddModList)
10880    {
10881       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
10882       if(srchSpcToAddModList->list.count)
10883       {
10884          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
10885          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
10886          {
10887             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
10888                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
10889             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
10890                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
10891             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
10892             {
10893                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
10894                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
10895             }
10896             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
10897             {
10898                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
10899                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
10900             }
10901             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
10902             {
10903                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
10904                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
10905                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
10906                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
10907                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
10908                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
10909
10910                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
10911                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
10912
10913                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
10914                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
10915             }
10916             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
10917             {
10918                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
10919                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
10920                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
10921                {
10922                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
10923                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
10924                }
10925
10926             }
10927          }
10928       }
10929    }
10930    /* Search space To Rel List */
10931    if(cuPdcchCfg->searchSpacesToReleaseList)
10932    {
10933       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
10934       if(srchSpcToRelList->list.count)
10935       {
10936          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
10937          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
10938          {
10939             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
10940                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
10941          }
10942       }
10943    }
10944 }
10945
10946 /*******************************************************************
10947  *
10948  * @brief Fills PdschCfg received by CU
10949  *
10950  * @details
10951  *
10952  *    Function : extractPdschCfg
10953  *
10954  *    Functionality: Fills PdschCfg received  by CU
10955  *
10956  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
10957  *                   which we have stored in F1UeContextSetupDb,
10958  *             PdschConfig *macPdschCfg = Used to Store the information which
10959  *                   needs to send in other layer, as well as this can be the variable
10960  *                   which stores the information in DuCb,
10961  *             PdschConfig *storedPdschCfg =  Null in case of sending the
10962  *                   information to other layer else it will have stored pdsch
10963  *                   configuration in copyOfmacUeCfg.
10964  * @return void
10965  *
10966  * ****************************************************************/
10967
10968 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
10969 {
10970    uint8_t timeDomIdx;
10971    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
10972
10973    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
10974    {
10975       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
10976             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
10977       {
10978          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
10979          {
10980             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
10981                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
10982          }
10983       }
10984    }
10985    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
10986    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
10987    {
10988       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
10989       if(timeDomAlloc->present ==\
10990             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
10991       {
10992          if(timeDomAlloc->choice.setup)
10993          {
10994             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
10995             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
10996             {
10997                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
10998                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
10999                {
11000                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
11001                   {
11002                      if(storedPdschCfg)
11003                      {
11004                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
11005                         {
11006                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
11007                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
11008                         }
11009                         else
11010                         {
11011                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
11012                         }
11013                      }
11014                      else
11015                      {
11016                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
11017                      }
11018                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
11019                      {
11020                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
11021                         return;
11022                      }
11023                   }
11024                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
11025                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
11026                }
11027                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
11028                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
11029                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
11030                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
11031             }
11032          }
11033       }
11034    }
11035    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
11036    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
11037       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
11038    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
11039    {
11040       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
11041       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
11042       {
11043          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
11044          {
11045             macPdschCfg->bundlingInfo.StaticBundling.size = \
11046                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
11047          }
11048       }
11049    }
11050    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
11051    {
11052       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
11053    }
11054
11055 }
11056
11057 /*******************************************************************
11058  *
11059  * @brief Fills PdschServingCellCfg received by CU
11060  *
11061  * @details
11062  *
11063  *    Function : extractPdschServingCellCfg
11064  *
11065  *    Functionality: Fills PdschCfg received  by CU
11066  *
11067  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
11068  *             PdschServCellCfg *macUePdschSrvCellCfg
11069  * @return ROK/RFAILED
11070  *
11071  * ****************************************************************/
11072
11073 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
11074 {
11075    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
11076    {
11077       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
11078       {
11079          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
11080          {
11081             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
11082                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
11083          }
11084          else
11085          {
11086             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
11087             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
11088             {
11089                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
11090                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
11091             }
11092             else
11093             {
11094                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
11095                return RFAILED;
11096             }
11097          }
11098          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
11099          {
11100             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
11101                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
11102          }
11103          else
11104          {
11105             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
11106             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
11107             {
11108                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
11109                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
11110             }
11111             else
11112             {
11113                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
11114                return RFAILED;
11115             }
11116          }
11117       }
11118    }
11119    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
11120    {
11121       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
11122    }
11123    if(cuPdschSrvCellCfg->ext1)
11124    {
11125       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
11126       {
11127         if(macUePdschSrvCellCfg->maxMimoLayers)
11128         {
11129            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
11130         }
11131         else
11132         {
11133            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
11134            if(macUePdschSrvCellCfg->maxMimoLayers)
11135            {
11136               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
11137            }
11138            else
11139            {
11140               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
11141               return RFAILED;
11142            }
11143         }
11144       }
11145    }
11146    if(cuPdschSrvCellCfg->xOverhead)
11147    {
11148       if(macUePdschSrvCellCfg->xOverhead)
11149       {
11150          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
11151       }
11152       else
11153       {
11154          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
11155          if(macUePdschSrvCellCfg->xOverhead)
11156          {
11157             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
11158          }
11159          else
11160          {
11161             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
11162             return RFAILED;
11163          }
11164       }
11165    }
11166    return ROK;
11167 }
11168
11169 /*******************************************************************
11170  *
11171  * @brief Fills PuschCfg received by CU
11172  *
11173  * @details
11174  *
11175  *    Function : extractPuschCfg
11176  *
11177  *    Functionality: Fills PuschCfg received  by CU
11178  *
11179  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
11180  *             PuschCfg *macPuschCfg
11181  * @return void
11182  *
11183  * ****************************************************************/
11184
11185 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
11186 {
11187    uint8_t timeDomIdx = 0;
11188    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
11189    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
11190
11191    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
11192    {
11193       if(cuPuschCfg->choice.setup)
11194       {
11195          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
11196          {
11197              macPuschCfg->dataScramblingId = \
11198                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
11199          }
11200          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
11201          {
11202             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
11203             {
11204                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
11205                {
11206                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
11207                   if(dmrsUlCfg->dmrs_AdditionalPosition)
11208                   {
11209                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
11210                         *(dmrsUlCfg->dmrs_AdditionalPosition);
11211                   }
11212                   if(dmrsUlCfg->transformPrecodingDisabled)
11213                   {
11214                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
11215                      {
11216                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
11217                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
11218                      }
11219                   }
11220                }
11221             }
11222          }
11223          /*Res Alloc Type for UL */
11224          if(cuPuschCfg->choice.setup->resourceAllocation)
11225          {
11226             macPuschCfg->resourceAllocType = \
11227                cuPuschCfg->choice.setup->resourceAllocation;
11228          }
11229          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
11230          {
11231             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
11232             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
11233             {
11234                if(timeDomAllocList->choice.setup)
11235                {
11236                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
11237                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
11238                   {
11239                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
11240                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
11241                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
11242                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
11243                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
11244                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
11245                   }
11246                }
11247             }
11248          }
11249          if(cuPuschCfg->choice.setup->transformPrecoder)
11250             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
11251       }
11252    }
11253 }
11254
11255 /*******************************************************************
11256  *
11257  * @brief Function to fill pucch Power Control
11258  *
11259  * @details
11260  *
11261  *    Function : extractPucchPowerControl
11262  *
11263  *    Functionality: Function to fill pucch Power Control
11264  *
11265  * @params[in] PucchPowerControl *pwrCtrl,
11266  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
11267  * @return void
11268  *
11269  * ****************************************************************/
11270
11271 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
11272 {
11273    uint8_t arrIdx;
11274
11275    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
11276       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
11277    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
11278       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
11279    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
11280       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
11281    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
11282       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
11283    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
11284       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
11285    if(cuPwrCtrlCfg->p0_Set)
11286    {
11287       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
11288       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
11289       {
11290          pwrCtrl->p0Set[arrIdx].p0PucchId =\
11291             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
11292          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
11293             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
11294       }
11295    }
11296    if(cuPwrCtrlCfg->pathlossReferenceRSs)
11297    {
11298       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
11299       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
11300       {
11301          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
11302             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
11303       }
11304    }
11305 }
11306
11307  /*******************************************************************
11308  *
11309  * @brief Function to extractResrcSetToAddModList sent by CU
11310  *
11311  * @details
11312  *
11313  *    Function : extractResrcSetToAddModList
11314  *
11315  *    Functionality: Fucntion to extractResrcSetToAddModList
11316  *
11317  * @params[in] PucchResrcSetCfg pointer,
11318  *             struct PUCCH_Config__resourceSetToAddModList pointer
11319  * @return void
11320  *
11321  * ****************************************************************/
11322
11323 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
11324 {
11325    uint8_t arrIdx, rsrcListIdx;
11326
11327    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
11328    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
11329    {
11330       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
11331          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
11332       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
11333          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
11334       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
11335       {
11336          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
11337             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
11338       }
11339
11340       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
11341       {
11342          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
11343             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
11344       }
11345       else
11346       {
11347          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
11348       }
11349    }
11350 }/* End of extractResrcSetToAddModList */
11351
11352 /*******************************************************************
11353  *
11354  * @brief Fills extractResrcToAddModList sent by CU
11355  *
11356  * @details
11357  *
11358  *    Function : extractResrcToAddModList
11359  *
11360  *    Functionality: Fills extractResrcToAddModList
11361  *
11362  * @params[in] PucchResrcCfg pointer,
11363  *             struct PUCCH_Config__resourceToAddModList pointer
11364  * @return ROk/RFAILED
11365  *
11366  * ****************************************************************/
11367
11368 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
11369 {
11370    uint8_t arrIdx;
11371
11372    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
11373    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
11374    {
11375       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
11376         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
11377       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
11378         cuResrcList->list.array[arrIdx]->startingPRB;
11379       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
11380       {
11381          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
11382            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
11383       }
11384       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
11385       {
11386          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
11387            *cuResrcList->list.array[arrIdx]->secondHopPRB;
11388       }
11389       /* PUCCH RSRC FORMAT */
11390       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
11391       {
11392          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
11393          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
11394          {
11395             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
11396             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
11397             {
11398                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
11399                return RFAILED;
11400             }
11401             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
11402                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
11403             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
11404                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
11405             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
11406                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
11407          }
11408       }
11409       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
11410       {
11411          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
11412          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
11413          {
11414             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
11415             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
11416             {
11417                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
11418                return RFAILED;
11419             }
11420             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
11421                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
11422             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
11423                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
11424             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
11425                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
11426             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
11427                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
11428          }
11429       }
11430       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
11431       {
11432          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
11433          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
11434          {
11435             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
11436             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
11437             {
11438                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
11439                return RFAILED;
11440             }
11441             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
11442                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
11443             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
11444                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
11445             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
11446                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
11447          }
11448       }
11449       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
11450       {
11451          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
11452          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
11453          {
11454             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
11455             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
11456             {
11457                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
11458                return RFAILED;
11459             }
11460             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
11461                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
11462             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
11463                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
11464             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
11465                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
11466          }
11467       }
11468       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
11469       {
11470          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
11471          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
11472          {
11473             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
11474             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
11475             {
11476                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
11477                return RFAILED;
11478             }
11479             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
11480                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
11481             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
11482                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
11483             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
11484                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
11485             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
11486                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
11487          }
11488       }
11489    }
11490    return ROK;
11491
11492 }/* End of extractResrcToAddModList */
11493
11494 /*******************************************************************
11495  *
11496  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
11497  *
11498  * @details
11499  *
11500  *    Function : fillPucchSchedReqPeriodAndOffset
11501  *
11502  *    Functionality: To fillPucchSchedReqPeriodAndOffset
11503  *
11504  * @params[in] macPeriodicty,
11505  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
11506  * @return void
11507  *
11508  * ****************************************************************/
11509
11510 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
11511    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
11512 {
11513    macPeriodicty = cuPeriodicty->present;
11514    switch(macPeriodicty)
11515    {
11516       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
11517          {
11518             macOffset     = cuPeriodicty->choice.sym2;
11519             break;
11520          }
11521       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
11522          {
11523             macOffset     = cuPeriodicty->choice.sym6or7;
11524             break;
11525          }
11526       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
11527          {
11528             macOffset     = cuPeriodicty->choice.sl1;
11529             break;
11530          }
11531       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
11532          {
11533             macOffset = cuPeriodicty->choice.sl2;
11534             break;
11535          }
11536       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
11537          {
11538             macOffset = cuPeriodicty->choice.sl4;
11539             break;
11540          }
11541       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
11542          {
11543             macOffset = cuPeriodicty->choice.sl5;
11544             break;
11545          }
11546       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
11547          {
11548             macOffset = cuPeriodicty->choice.sl8;
11549             break;
11550          }
11551       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
11552          {
11553             macOffset = cuPeriodicty->choice.sl10;
11554             break;
11555          }
11556       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
11557          {
11558             macOffset = cuPeriodicty->choice.sl16;
11559             break;
11560          }
11561       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
11562          {
11563             macOffset = cuPeriodicty->choice.sl20;
11564             break;
11565          }
11566       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
11567          {
11568             macOffset = cuPeriodicty->choice.sl40;
11569             break;
11570          }
11571       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
11572          {
11573             macOffset = cuPeriodicty->choice.sl80;
11574             break;
11575          }
11576       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
11577          {
11578             macOffset = cuPeriodicty->choice.sl160;
11579             break;
11580          }
11581       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
11582          {
11583             macOffset = cuPeriodicty->choice.sl320;
11584             break;
11585          }
11586       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
11587          {
11588             macOffset = cuPeriodicty->choice.sl640;
11589             break;
11590          }
11591       default :
11592          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
11593    }
11594 }
11595
11596 /*******************************************************************
11597  *
11598  * @brief Function to extractPucchFormatCfg sent by CU
11599  *
11600  * @details
11601  *
11602  *    Function : extractPucchFormatCfg
11603  *
11604  *    Functionality: Function to extractPucchFormatCfg
11605  *
11606  * @params[in] PucchFormatCfg pointer,
11607  *             PUCCH_FormatConfig_t pointer
11608  * @return void
11609  *
11610  * ****************************************************************/
11611
11612 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
11613  {
11614     if(cuFormatCfg->interslotFrequencyHopping)
11615        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
11616     if(cuFormatCfg->additionalDMRS)
11617        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
11618     if(cuFormatCfg->maxCodeRate)
11619        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
11620     if(cuFormatCfg->nrofSlots)
11621        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
11622     if(cuFormatCfg->pi2BPSK)
11623        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
11624     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
11625        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
11626  }/* End of extractPucchFormatCfg */
11627
11628 /*******************************************************************
11629  *
11630  * @brief Function to extractSchedReqCfgToAddMod sent by CU
11631  *
11632  * @details
11633  *
11634  *    Function : extractSchedReqCfgToAddMod
11635  *
11636  *    Functionality: Function to extractSchedReqCfgToAddMod
11637  *
11638  * @params[in] PucchSchedReqCfg pointer,
11639  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
11640  * @return void
11641  *
11642  * ****************************************************************/
11643
11644 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
11645 {
11646    uint8_t arrIdx;
11647
11648    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
11649    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
11650    {
11651       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
11652          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
11653       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
11654          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
11655       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
11656       {
11657          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
11658             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
11659       }
11660       if(cuSchedReqList->list.array[arrIdx]->resource)
11661       {
11662          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
11663             *cuSchedReqList->list.array[arrIdx]->resource;
11664       }
11665    }
11666
11667 }/* End of extractSchedReqCfgToAddMod */
11668
11669  /*******************************************************************
11670  *
11671  * @brief Fills PucchCfg received by CU
11672  *
11673  * @details
11674  *
11675  *    Function : extractPucchCfg
11676  *
11677  *    Functionality: Fills PucchCfg received  by CU
11678  *
11679  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
11680  *                is send by CU, which we have stored in F1UeContextSetupDb,
11681  *             PucchCfg *macPucchCfg = Used to Store the information which
11682  *                needs to send in other layer, as well as this can be the variable
11683  *                which stores the information in DuCb,
11684  *             PucchCfg *storedPucchCfg = Null in case of sending the
11685  *                information to other layer else it will have Pucch Cfg which
11686  *                we have stored in copyOfmacUeCfg.
11687  * @return ROK/RFAILED
11688  *
11689  * ****************************************************************/
11690
11691 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
11692 PucchCfg *storedPucchCfg)
11693 {
11694    uint8_t arrIdx;
11695
11696    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
11697    {
11698       if(cuPucchCfg->choice.setup)
11699       {
11700          /* Resource Set Cfg */
11701          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
11702          {
11703             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
11704             if(macPucchCfg->resrcSet == NULLP)
11705             {
11706                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
11707                return RFAILED;
11708             }
11709             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
11710             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
11711          }
11712
11713          /* Resource Cfg */
11714          if(cuPucchCfg->choice.setup->resourceToAddModList)
11715          {
11716             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
11717             if(macPucchCfg->resrc == NULLP)
11718             {
11719                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
11720                return RFAILED;
11721             }
11722             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
11723             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
11724          }
11725
11726          /* Format 1 Cfg */
11727          if(cuPucchCfg->choice.setup->format1)
11728          {
11729             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
11730             if(macPucchCfg->format1 == NULLP)
11731             {
11732                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
11733                return RFAILED;
11734             }
11735             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
11736             extractPucchFormatCfg(macPucchCfg->format1,\
11737                cuPucchCfg->choice.setup->format1->choice.setup);
11738          }
11739
11740          /* Format 2 Cfg */
11741          if(cuPucchCfg->choice.setup->format2)
11742          {
11743             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
11744             if(macPucchCfg->format2 == NULLP)
11745             {
11746                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
11747                return RFAILED;
11748             }
11749             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
11750             extractPucchFormatCfg(macPucchCfg->format2,\
11751                cuPucchCfg->choice.setup->format2->choice.setup);
11752          }
11753
11754          /* Format 3 Cfg */
11755          if(cuPucchCfg->choice.setup->format3)
11756          {
11757             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
11758             if(macPucchCfg->format3 == NULLP)
11759             {
11760                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
11761                return RFAILED;
11762             }
11763             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
11764             extractPucchFormatCfg(macPucchCfg->format3,\
11765                cuPucchCfg->choice.setup->format3->choice.setup);
11766          }
11767
11768          /* Format 4 Cfg */
11769          if(cuPucchCfg->choice.setup->format4)
11770          {
11771             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
11772             if(macPucchCfg->format4 == NULLP)
11773             {
11774                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
11775                return RFAILED;
11776             }
11777             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
11778             extractPucchFormatCfg(macPucchCfg->format4,\
11779                cuPucchCfg->choice.setup->format4->choice.setup);
11780          }
11781
11782          /* Sched Req List */
11783          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
11784          {
11785             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
11786             if(macPucchCfg->schedReq == NULLP)
11787             {
11788                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
11789                return RFAILED;
11790             }
11791             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
11792             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
11793             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
11794          }
11795
11796          /*TODO: Add support for  Spatial Info */
11797
11798          /* MultiCsiCfg */
11799          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
11800          {
11801             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
11802             if(macPucchCfg->multiCsiCfg == NULLP)
11803             {
11804                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
11805                return RFAILED;
11806             }
11807             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
11808             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
11809             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
11810             {
11811                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
11812                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
11813             }
11814          }
11815
11816          /* Dl_DataToUL_ACK */
11817          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
11818     {
11819        if(storedPucchCfg)
11820        {
11821           if(storedPucchCfg->dlDataToUlAck)
11822           {
11823              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
11824           }
11825           else
11826           {
11827             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
11828           }
11829        }
11830        else
11831        {
11832           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
11833        }
11834        if(macPucchCfg->dlDataToUlAck == NULLP)
11835        {
11836           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
11837           return RFAILED;
11838        }
11839        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
11840        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
11841        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
11842        {
11843           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
11844           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
11845        }
11846          }
11847
11848          /* Power Control */
11849          if(cuPucchCfg->choice.setup->pucch_PowerControl)
11850          {
11851             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
11852             if(macPucchCfg->powerControl == NULLP)
11853             {
11854                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
11855                return RFAILED;
11856             }
11857             extractPucchPowerControl(macPucchCfg->powerControl,\
11858                cuPucchCfg->choice.setup->pucch_PowerControl);
11859          }
11860       }
11861    }
11862    return ROK;
11863 }
11864
11865 /*******************************************************************
11866  *
11867  * @brief Fills ServingCellReconfig received by CU
11868  *
11869  * @details
11870  *
11871  *    Function : extractSpCellDedicatedCfg
11872  *
11873  *    Functionality: Fills ServingCellReconfig received  by CU
11874  *
11875  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
11876  *                  CU, which we have stored in F1UeContextSetupDb,
11877  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
11878  *                  which  needs to send in other layer, as well as this can be the
11879  *                  variable which stores the information in DuCb,
11880  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
11881  *                  information to other layer else it will have ServCellCfgInfo which
11882  *                  we have stored in copyOfmacUeCfg.
11883  * @return ROK/RFAILD
11884  *
11885  * ****************************************************************/
11886 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
11887 ServCellCfgInfo *storedSrvCellCfg)
11888 {
11889    uint8_t ret = ROK;
11890    BWP_DownlinkDedicated_t *dlBwp = NULLP;
11891    BWP_UplinkDedicated_t   *ulBwp = NULLP;
11892
11893    if(cuSrvCellCfg->initialDownlinkBWP)
11894    {
11895       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
11896       if(dlBwp->pdcch_Config)
11897       {
11898          if(dlBwp->pdcch_Config->choice.setup)
11899          {
11900             macSrvCellCfg->initDlBwp.pdcchPresent = true;
11901             if(storedSrvCellCfg)
11902             {
11903                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
11904                {
11905                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11906                }
11907                else
11908                {
11909                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11910                }
11911             }
11912             else
11913             {
11914                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11915             }
11916          }
11917       }
11918       if(dlBwp->pdsch_Config)
11919       {
11920          if(dlBwp->pdsch_Config->choice.setup)
11921          {
11922             macSrvCellCfg->initDlBwp.pdschPresent = true;
11923
11924             if(storedSrvCellCfg)
11925             {
11926                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
11927                {
11928                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
11929                }
11930                else
11931                {
11932                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
11933                         &storedSrvCellCfg->initDlBwp.pdschCfg);
11934                }
11935             }
11936             else
11937             {
11938                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
11939             }
11940          }
11941       }
11942    }
11943    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
11944       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
11945    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
11946       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
11947    if(cuSrvCellCfg->bwp_InactivityTimer)
11948    {
11949       if(macSrvCellCfg->bwpInactivityTmr)
11950       {
11951          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
11952       }
11953       else
11954       {
11955          macSrvCellCfg->bwpInactivityTmr = NULLP;
11956          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
11957          if(macSrvCellCfg->bwpInactivityTmr)
11958          {
11959             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
11960          }
11961          else
11962          {
11963             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
11964             return RFAILED;
11965          }
11966       }
11967    }
11968    if(cuSrvCellCfg->pdsch_ServingCellConfig)
11969    {
11970       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
11971       {
11972          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
11973          if(ret == RFAILED)
11974          {
11975             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
11976             return RFAILED;
11977          }
11978       }
11979    }
11980    if(cuSrvCellCfg->uplinkConfig)
11981    {
11982       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
11983       {
11984          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
11985          if(ulBwp->pusch_Config)
11986          {
11987             macSrvCellCfg->initUlBwp.puschPresent = true;
11988             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
11989          }
11990          if(ulBwp->pucch_Config)
11991          {
11992             macSrvCellCfg->initUlBwp.pucchPresent = true;
11993             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
11994             if(storedSrvCellCfg)
11995             {
11996                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
11997                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
11998                else
11999                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
12000                   &storedSrvCellCfg->initUlBwp.pucchCfg);
12001             }
12002             else
12003             {
12004                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
12005             }
12006          }
12007       }
12008       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
12009          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
12010    }
12011    return ret;
12012 }
12013
12014 #ifdef NR_DRX
12015
12016 /*******************************************************************
12017  *
12018  * @brief fill long cycle offset value of drx in UE structure
12019  *
12020  * @details
12021  *
12022  *    Function : fillLongCycleOffsetValueInUeDb
12023  *
12024  *    Functionality: fill long cycle offset value of drx in UE structure
12025  *
12026  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
12027  * struct DRX_ConfigRrc__drx_LongCycleStartOffset drx_LongCycleStartOffset
12028  *
12029  * @return ROK     - success
12030  *         RFAILED - failure
12031  *
12032  * ****************************************************************/
12033 void fillLongCycleOffsetValueInUeDb(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__drx_LongCycleStartOffset  *drx_LongCycleStartOffset)
12034 {
12035
12036    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = convertLongDrxCycleLengthEnumToValue(drx_LongCycleStartOffset->present);
12037    switch(drx_LongCycleStartOffset->present)
12038    {
12039       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
12040          {
12041             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms10;
12042             break;
12043          }
12044       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
12045          {
12046             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms20;
12047             break;
12048          }
12049       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
12050          {
12051             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms32;
12052             break;
12053          }
12054       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
12055         {
12056             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms40;
12057             break;
12058          }
12059       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
12060          {
12061             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms60;
12062             break;
12063          }
12064       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
12065          {
12066             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms64;
12067             break;
12068          }
12069       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
12070          {
12071             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms70;
12072             break;
12073          }
12074       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
12075          {
12076             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms80;
12077             break;
12078          }
12079       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
12080          {
12081             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms128;
12082             break;
12083          }
12084       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
12085          {
12086             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms160;
12087             break;
12088          }
12089       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
12090          {
12091             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms256;
12092             break;
12093          }
12094       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
12095          {
12096             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms320;
12097             break;
12098          }
12099       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
12100          {
12101             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms512;
12102             break;
12103          }
12104       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
12105          {
12106             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms640;
12107             break;
12108          }
12109       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
12110          {
12111             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms1024;
12112             break;
12113          }
12114       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
12115          {
12116             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms1280;
12117             break;
12118          }
12119       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
12120          {
12121             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms2048;
12122             break;
12123          }
12124       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
12125          {
12126             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms2560;
12127             break;
12128          }
12129        case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
12130          {
12131             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms5120;
12132             break;
12133          }
12134       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
12135          {
12136             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms10240;
12137             break;
12138          }
12139       default :
12140          break;
12141    }
12142 }
12143
12144 /*******************************************************************
12145  *
12146  * @brief Fills drx configuration structure with the help of drx_ConfigRrc
12147  *which recive from CU or storedDrxCfg which is already stored
12148  *
12149  * @details
12150  *
12151  *    Function : extractDrxConfiguration
12152  *
12153  *    Functionality: Fills Reconfig Cell group Info received by CU
12154  *
12155  * @params[in] cuMacCellGrpDrxConfig  = MAC_CellGroupConfig__drx_ConfigRrc information which
12156  *                       is send by CU, which we have stored in F1UeContextSetupDb
12157  *             DrxCfg * drxCfg  = Used to Store the information,
12158  *                      which needs to send in other layer, as well as this can be
12159  *                      the variable which stores the information in DuCb,
12160  *             DrxCfg *storedDrxCfg = Null in case of sending the
12161  *                      information to other layer else it will have the drx information
12162  *                      stored in the copyOfmacUeCfg which we have stored in F1UeContextSetupDb.
12163  *
12164  * @return void
12165  *
12166  * ****************************************************************/
12167 void extractDrxConfiguration(struct MAC_CellGroupConfig__drx_ConfigRrc *cuMacCellGrpDrxConfig, DrxCfg * drxCfg, DrxCfg *storedDrxCfg)
12168 {
12169    struct DRX_ConfigRrc *cuDrxConfig;
12170
12171    if(storedDrxCfg)
12172    {
12173       memcpy(drxCfg, storedDrxCfg, sizeof(DrxCfg));
12174    }
12175    else
12176    {
12177       if(cuMacCellGrpDrxConfig)
12178       {
12179          switch(cuMacCellGrpDrxConfig->present)
12180          {
12181             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
12182                break;
12183
12184             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
12185                {
12186                   cuDrxConfig = cuMacCellGrpDrxConfig->choice.setup;
12187                   if(cuDrxConfig)
12188                   {
12189                      switch(cuDrxConfig->drx_onDurationTimer.present)
12190                      {
12191                         case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
12192                            break;
12193                         case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
12194                            {
12195                               drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
12196                               drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=convertOnDurationTimerMilliSecondsEnumToValue(cuDrxConfig->\
12197                               drx_onDurationTimer.choice.milliSeconds);
12198                               break;
12199                            }
12200                         case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
12201                            {
12202                               drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
12203                               drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = cuDrxConfig->drx_onDurationTimer.choice.subMilliSeconds;
12204                               break;
12205                            }
12206                      }
12207                   }
12208                   fillLongCycleOffsetValueInUeDb(&drxCfg->drxLongCycleStartOffset, &cuDrxConfig->drx_LongCycleStartOffset);
12209                   drxCfg->drxInactivityTimer = convertDrxInactivityTimerEnumToValue(cuDrxConfig->drx_InactivityTimer);
12210                   drxCfg->drxHarqRttTimerDl = cuDrxConfig->drx_HARQ_RTT_TimerDL;
12211                   drxCfg->drxHarqRttTimerUl = cuDrxConfig->drx_HARQ_RTT_TimerUL;
12212                   drxCfg->drxRetransmissionTimerDl = convertDrxRetransmissionTimerDlEnumToValue(cuDrxConfig->drx_RetransmissionTimerDL);
12213                   drxCfg->drxRetransmissionTimerUl = convertDrxRetransmissionTimerUlEnumToValue(cuDrxConfig->drx_RetransmissionTimerUL);
12214                   drxCfg->drxSlotOffset = cuDrxConfig->drx_SlotOffset;
12215                   if(cuDrxConfig->shortDRX)
12216                   {
12217                      drxCfg->shortDrxPres=true;
12218                      drxCfg->shortDrx.drxShortCycle = convertShortDrxCycleLengthEnumToValue(cuDrxConfig->shortDRX->drx_ShortCycle);
12219                      drxCfg->shortDrx.drxShortCycleTimer = cuDrxConfig->shortDRX->drx_ShortCycleTimer;
12220                   }
12221                   else
12222                      drxCfg->shortDrxPres=false;
12223
12224                   break;
12225                }
12226
12227             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
12228                break;
12229          }
12230       }
12231    }
12232 }
12233 #endif
12234
12235 /*******************************************************************
12236  *
12237  * @brief Fills Reconfig Cell group Info received by CU
12238  *
12239  * @details
12240  *
12241  *    Function : extractUeReCfgCellInfo
12242  *
12243  *    Functionality: Fills Reconfig Cell group Info received by CU
12244  *
12245  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
12246  *                       is send by CU, which we have stored in F1UeContextSetupDb
12247  *             MacUeCfg *MacUeCfg = Used to Store the information,
12248  *                      which needs to send in other layer, as well as this can be
12249  *                      the variable which stores the information in DuCb,
12250  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
12251  *                      information to other layer else it will have copyOfmacUeCfg
12252  *                      which we have stored in F1UeContextSetupDb.
12253  *
12254  * @return ROK/RFAILED
12255  *
12256  * ****************************************************************/
12257 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
12258 {
12259    uint8_t ret = ROK;
12260    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
12261    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
12262    SpCellConfig_t            *spcellCfg = NULLP;
12263    ServingCellConfig_t       *servCellCfg = NULLP;
12264
12265    if(cellGrp)
12266    {
12267       /* Fill MacCell Group Reconfig  */
12268       if(cellGrp->mac_CellGroupConfig)
12269       {
12270          macUeCfg->macCellGrpCfgPres = true;
12271          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
12272
12273 #ifdef NR_DRX
12274          if(macCellGroup->drx_ConfigRrc)
12275          {
12276             if(storedMacUeCfg)
12277             {
12278                if(!storedMacUeCfg->macCellGrpCfgPres)
12279                {
12280                   extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg,NULL);
12281                }
12282                else
12283                {
12284                   extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg, &storedMacUeCfg->macCellGrpCfg.drxCfg);
12285                }
12286             }
12287             else
12288             {
12289                extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg,NULL);
12290             }
12291          }
12292 #endif
12293
12294          if(macCellGroup->schedulingRequestConfig)
12295          {
12296             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
12297          }
12298          if(macCellGroup->tag_Config)
12299          {
12300             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
12301          }
12302          if(macCellGroup->bsr_Config)
12303          {
12304             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
12305             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
12306             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
12307             {
12308                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
12309                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
12310             }
12311          }
12312          if(macCellGroup->phr_Config)
12313          {
12314             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
12315             {
12316                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
12317                if(macCellGroup->phr_Config->choice.setup)
12318                {
12319                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
12320                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
12321                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
12322                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
12323                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
12324                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
12325                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
12326                   macCellGroup->phr_Config->choice.setup->multiplePHR;
12327                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
12328                   macCellGroup->phr_Config->choice.setup->dummy;
12329                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
12330                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
12331                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
12332                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
12333                }
12334             }
12335          }
12336       }
12337       /* Fill Physical Cell Group Reconfig */
12338       if(cellGrp->physicalCellGroupConfig)
12339       {
12340          macUeCfg->phyCellGrpCfgPres = true;
12341          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
12342          if(phyCellGrpCfg->p_NR_FR1)
12343          {
12344             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
12345                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
12346          }
12347          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
12348       }
12349       /* Fill SpCell Reconfig */
12350       if(cellGrp->spCellConfig)
12351       {
12352          macUeCfg->spCellCfgPres = true;
12353          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
12354          if(spcellCfg->servCellIndex)
12355          {
12356             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
12357          }
12358          /* Fill Serving cell Reconfig info */
12359          if(cellGrp->spCellConfig->spCellConfigDedicated)
12360          {
12361             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
12362             if(storedMacUeCfg)
12363             {
12364                if(!storedMacUeCfg->spCellCfgPres)
12365                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
12366                else
12367                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
12368                         &storedMacUeCfg->spCellCfg.servCellCfg);
12369             }
12370             else
12371             {
12372                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
12373             }
12374             if(ret == RFAILED)
12375             {
12376                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
12377             }
12378          }
12379       }
12380    }
12381    return ret;
12382 }
12383 /*******************************************************************
12384 *
12385 * @brief free the memory allocated by decoder
12386 *
12387 * @details
12388 *
12389 *    Function : freeAperDecodeNrcgi
12390 *
12391 *    Functionality: Free Nrcgi values
12392 *
12393 * @params[in] NRCGI_t *nrcgi
12394 * @return void
12395 *
12396 * ****************************************************************/
12397
12398
12399 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
12400 {
12401     if(nrcgi->pLMN_Identity.buf != NULLP)
12402     {
12403        free(nrcgi->pLMN_Identity.buf);
12404     }
12405     if(nrcgi->nRCellIdentity.buf != NULLP)
12406     {
12407        free(nrcgi->nRCellIdentity.buf);
12408     }
12409 }
12410 /*******************************************************************
12411 *
12412 * @brief free the memory allocated by decoder
12413 *
12414 * @details
12415 *
12416 *    Function : freeAperDecodeCuToDuInfo
12417 *
12418 *    Functionality:  Free Cu To Du Information
12419 *
12420 * @params[in] CUtoDURRCInformation_t *rrcMsg
12421 * @return void
12422 *
12423 * ****************************************************************/
12424
12425
12426 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
12427 {
12428    uint8_t ieIdx =0;
12429    uint8_t arrIdx =0;
12430
12431    if(rrcMsg->uE_CapabilityRAT_ContainerList)
12432    {
12433       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
12434          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
12435       free(rrcMsg->uE_CapabilityRAT_ContainerList);
12436    }
12437
12438    if(rrcMsg->iE_Extensions)
12439    {
12440       if(rrcMsg->iE_Extensions->list.array)
12441       {
12442          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
12443          {
12444             if(rrcMsg->iE_Extensions->list.array[ieIdx])
12445             {
12446                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
12447                {
12448                   case ProtocolIE_ID_id_CellGroupConfig:
12449                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
12450                      {
12451                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
12452                      }
12453                      break;
12454                   default:
12455                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
12456                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
12457                      break;
12458                }
12459             }
12460          }
12461          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
12462          {
12463             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
12464          }
12465          free(rrcMsg->iE_Extensions->list.array);
12466
12467       }
12468
12469       free(rrcMsg->iE_Extensions);
12470    }
12471 }
12472 /*******************************************************************
12473 *
12474 * @brief free the memory allocated by decoder
12475 *
12476 * @details
12477 *
12478 *    Function : freeAperDecodeSplCellList
12479 *
12480 *    Functionality: Free Spl Cell List
12481                     where memory allocated by aper_decoder
12482 *
12483 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
12484 * @return void
12485 *
12486 * ****************************************************************/
12487
12488
12489 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
12490 {
12491     uint8_t  cellIdx =0;
12492
12493     if(spCellLst->list.array != NULLP)
12494     {
12495        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
12496        {
12497           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
12498           {
12499              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
12500           }
12501           if(spCellLst->list.array[cellIdx]!=NULLP)
12502           {
12503              free(spCellLst->list.array[cellIdx]);
12504           }
12505        }
12506        free(spCellLst->list.array);
12507     }
12508 }
12509 /*******************************************************************
12510 *
12511 * @brief free the memory allocated by decoder
12512 *
12513 * @details
12514 *
12515 *    Function : freeAperDecodeSRBSetup
12516 *
12517 *    Functionality: added free part for the memory allocated by aper_decoder
12518 *
12519 * @params[in] SRBs_ToBeSetup_List_t *srbSet
12520 * @return void
12521 *
12522 ****************************************************************/
12523
12524
12525 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
12526 {
12527     uint8_t srbIdx =0;
12528     if(srbSet->list.array != NULLP)
12529     {
12530        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
12531        {
12532           if(srbSet->list.array[srbIdx]!=NULLP)
12533           {
12534              free(srbSet->list.array[srbIdx]);
12535           }
12536        }
12537        free(srbSet->list.array);
12538     }
12539 }
12540
12541 /*******************************************************************
12542 *
12543 * @brief free the memory allocated by decoder
12544 *
12545 * @details
12546 *
12547 *    Function : freeAperDecodeULTnlInfo
12548 *
12549 *    Functionality: added free part for the memory allocated by aper_decoder
12550 *
12551 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12552 * @return void
12553 *
12554 * ****************************************************************/
12555
12556
12557 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12558 {
12559    uint8_t ulIdx=0;
12560    if(ulInfo->list.array != NULLP)
12561    {
12562       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
12563       {
12564          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
12565          {
12566             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
12567             {
12568                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12569                      transportLayerAddress.buf != NULLP)
12570                {
12571                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
12572                         !=NULLP)
12573                   {
12574                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
12575                   }
12576                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12577                         transportLayerAddress.buf);
12578                }
12579                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
12580             }
12581          }
12582          if(ulInfo->list.array[ulIdx]!=NULLP)
12583          {
12584             free(ulInfo->list.array[ulIdx]);
12585          }
12586       }
12587       free(ulInfo->list.array);
12588    }
12589 }
12590 /*******************************************************************
12591 *
12592 * @brief free the memory allocated by decoder
12593 *
12594 * @details
12595 *
12596 *    Function : freeAperDecodeDRBSetup
12597 *
12598 *    Functionality: free DRBSetup which is allocated by decoder
12599 *
12600 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
12601 * @return void
12602 *
12603 * ****************************************************************/
12604
12605 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
12606 {
12607    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
12608    uint8_t  flowIdx =0;
12609    uint8_t  drbIdx =0;
12610
12611    if(drbSet->list.array != NULLP)
12612    {
12613       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
12614       {
12615          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
12616          {
12617             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
12618             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
12619             {
12620                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12621                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
12622                {
12623                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12624                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12625                   {
12626                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12627                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12628                      {
12629
12630                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
12631                         {
12632
12633                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
12634                            {
12635
12636                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
12637                                     buf!=NULLP)
12638                               {
12639
12640                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
12641                                        flows_Mapped_To_DRB_List.list.array != NULLP)
12642                                  {
12643
12644                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12645                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
12646                                     {
12647
12648                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12649                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
12650                                        {
12651                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12652                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12653                                                 qoSFlowLevelQoSParameters.\
12654                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
12655                                           {
12656                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12657                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12658                                                    qoSFlowLevelQoSParameters.\
12659                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12660                                              {
12661
12662                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12663                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12664                                                       qoSFlowLevelQoSParameters.\
12665                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12666                                                 {
12667
12668
12669                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12670                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12671                                                          qoSFlowLevelQoSParameters.\
12672                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12673                                                 }
12674
12675                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12676                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12677                                                       qoSFlowLevelQoSParameters.\
12678                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12679                                              }
12680
12681                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12682
12683                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12684                                                    qoSFlowLevelQoSParameters.\
12685                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
12686                                           }
12687                                        }
12688                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12689                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
12690                                        {
12691
12692                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12693                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
12694                                        }
12695                                     }
12696
12697                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12698                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
12699                                  }
12700
12701                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12702                                        DRB_Information.sNSSAI.sD->buf);
12703                               }
12704
12705                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
12706                            }
12707
12708                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
12709
12710                         }
12711
12712                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12713
12714                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12715                      }
12716
12717                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12718                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12719                   }
12720
12721                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12722                         qoS_Characteristics.choice.non_Dynamic_5QI);
12723                }
12724                free(drbSetItem->qoSInformation.choice.choice_extension);
12725             }
12726             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
12727             if(drbSetItem->uLConfiguration)
12728             {
12729                free(drbSetItem->uLConfiguration);
12730             }
12731          }
12732          if(drbSet->list.array[drbIdx]!=NULLP)
12733          {
12734             free(drbSet->list.array[drbIdx]);
12735          }
12736       }
12737       free(drbSet->list.array);
12738    }
12739 }
12740
12741
12742 /*******************************************************************
12743  *
12744  * @brief builds Mac Cell Cfg
12745  *
12746  * @details
12747  *
12748  *    Function : procUeReCfgCellInfo
12749  *
12750  *    Functionality: builds Mac Cell Cfg
12751  *
12752  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
12753  *                       needs to send in other layer, as well as this can be
12754  *                       the variable which stores the information in DuCb.
12755  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
12756  *                       information to other layer else it will have copyOfmacUeCfg
12757  *                       which we have stored in F1UeContextSetupDb
12758  *             void *cellInfo = CellGroupConfigRrc_t information which is send
12759  *                        by CU, which we have stored in F1UeContextSetupDb
12760  *
12761  * @return void
12762  *
12763  * ****************************************************************/
12764 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend, MacUeCfg *storedMacUeCfg, void *cellInfo)
12765 {
12766    uint8_t ret = ROK;
12767    CellGroupConfigRrc_t *cellGrp = NULLP;
12768
12769    if(cellInfo)
12770    {
12771       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
12772       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
12773       if(ret == RFAILED)
12774          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
12775    }
12776    if(ret == RFAILED)
12777    {
12778       freeUeReCfgCellGrpInfo(macUeCfgToSend);
12779    }
12780    return ret;
12781 }
12782
12783 /*******************************************************************
12784  *
12785  * @brief Filling modulation info in mac ue cfg
12786  *
12787  * @details
12788  *
12789  *    Function : duFillModulationDetails
12790  *
12791  *    Functionality: Filling modulation info in mac ue cfg
12792  *
12793  * @params[in] MAC UE Config to be updated
12794  *             Current UE configuration
12795  *             UE NR capability from CU
12796  * @return ROK     - success
12797  *         RFAILED - failure
12798  *
12799  * ****************************************************************/
12800 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
12801 {
12802    UE_NR_Capability_t *ueNrCap=NULLP;
12803
12804    if(!ueCap && oldUeCfg)
12805    {
12806       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12807       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12808    }
12809    else
12810    {
12811       ueNrCap = (UE_NR_Capability_t *)ueCap;
12812
12813       /* Filling DL modulation info */
12814       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
12815          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
12816          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
12817       {
12818          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
12819          {
12820             case ModulationOrder_qpsk:
12821                {
12822                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
12823                   break;
12824                }
12825             case ModulationOrder_qam16:
12826                {
12827                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
12828                   break;
12829                }
12830             case ModulationOrder_qam64:
12831                {
12832                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
12833                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
12834                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
12835                   break;
12836                }
12837             case ModulationOrder_qam256:
12838                {
12839                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
12840                   break;
12841                }
12842             default:
12843                {
12844                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
12845                   if(oldUeCfg)
12846                      memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12847                   break;
12848                }
12849          }
12850       }
12851       else
12852       {
12853          if(oldUeCfg)
12854             memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12855       }
12856
12857       /* Filling UL modulation info */
12858       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
12859          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
12860          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
12861       {
12862          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
12863          {
12864             case ModulationOrder_qpsk:
12865                {
12866                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
12867                   break;
12868                }
12869             case ModulationOrder_qam16:
12870                {
12871                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
12872                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
12873                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
12874                   break;
12875                }
12876             case ModulationOrder_qam64:
12877                {
12878                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
12879                   break;
12880                }
12881             case ModulationOrder_qam256:
12882                {
12883                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
12884                   break;
12885                }
12886             default:
12887                {
12888                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
12889                   if(oldUeCfg)
12890                      memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12891                   break;
12892                }
12893          }
12894       }
12895       else
12896       {
12897          if(oldUeCfg)
12898             memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12899       }
12900    }
12901 }
12902
12903 /*******************************************************************
12904  *
12905  * @brief Function to extract info from CU to DU RRC container extension
12906  *
12907  * @details
12908  *
12909  *    Function : extractCuToDuRrcInfoExt
12910  *
12911  *    Functionality: Function to extract info from CU to DU RRC container
12912  *    extension
12913  *
12914  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
12915  *
12916  * @return ROK
12917  *         RFAILED
12918  *
12919  * ****************************************************************/
12920 uint8_t extractCuToDuRrcInfoExt(ProtocolExtensionContainer_4624P16_t *protocolIeExtn, DuUeCfg *ueCfgDb)
12921 {
12922    uint8_t ieIdx =0;
12923    uint16_t recvBufLen =0;
12924    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
12925    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
12926    asn_dec_rval_t rval; /* Decoder return value */
12927    memset(&rval, 0, sizeof(asn_dec_rval_t));
12928
12929    if(protocolIeExtn)
12930    {
12931       for(ieIdx = 0; ieIdx < protocolIeExtn->list.count; ieIdx++)
12932       {
12933          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[ieIdx]));
12934          switch(extIeInfo->id)
12935          {
12936             case ProtocolIE_ID_id_CellGroupConfig:
12937                {
12938                   /* decoding the CellGroup Buf received */
12939                   recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
12940                   DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
12941                   if(cellGrpCfg)
12942                   {
12943                      memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
12944                      rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
12945                            extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
12946                      if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12947                      {
12948                         DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
12949                         return RFAILED;
12950                      }
12951                      xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
12952
12953                      if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
12954                         return NULLP;
12955                      ueCfgDb->cellGrpCfg = cellGrpCfg;
12956                   }
12957                   break;
12958                }
12959
12960             case ProtocolIE_ID_id_HandoverPreparationInformation:
12961                {
12962                   DU_LOG("\nINFO -->  F1AP : Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
12963                   break;
12964                }
12965
12966             default:
12967                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation: %ld at decodeCellGrpCfg()", extIeInfo->id);
12968                break;
12969          }
12970       }
12971    }
12972    return ROK;
12973 }
12974
12975 /*******************************************************************
12976  *
12977  * @brief Fills Srb List received by CU
12978  *
12979  * @details
12980  *
12981  *    Function : procSrbListToSetup
12982  *
12983  *    Functionality: Fills Srb List received  by CU
12984  *
12985  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
12986  *             LcCfg pointer
12987  *             RlcBearerCfg pointer
12988  * @return void
12989  *
12990  * ****************************************************************/
12991 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
12992 {
12993
12994    /* Filling RLC INFO */
12995    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
12996
12997    /* Filling MAC INFO */
12998    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
12999    {
13000       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
13001       return RFAILED;
13002    }
13003
13004    return ROK;
13005 }
13006
13007
13008
13009 /*******************************************************************
13010  *
13011  * @brief extract Srb List received by CU
13012  *
13013  * @details
13014  *
13015  *    Function : extractSrbListToSetup
13016  *
13017  *    Functionality: extract Srb List received by CU
13018  *                   for both MAC and RLC
13019  *
13020  * @params[in] SRBs_ToBeSetup_Item_t pointer
13021  *             DuUeCfg pointer
13022  * @return ROK/RFAIED
13023  *
13024  * ****************************************************************/
13025
13026 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
13027 {
13028    uint8_t ret = ROK, srbIdx = 0, rlcLcIdx = 0;
13029    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
13030    LcCfg *macLcCtxt = NULLP;
13031    RlcBearerCfg *rlcLcCtxt = NULLP;
13032
13033    if(srbCfg)
13034    {
13035       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
13036       {
13037          macLcCtxt = NULL;
13038          rlcLcCtxt = NULL;
13039
13040          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
13041          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
13042          {
13043             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
13044             ret = RFAILED;
13045             break;
13046          }
13047          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
13048          {
13049             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
13050             ret = RFAILED;
13051             break;
13052          }
13053
13054          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numMacLcs; rlcLcIdx++)
13055          {
13056             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == srbItem->sRBID && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_SRB)
13057             {
13058                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13059                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13060                break;
13061             }
13062          }
13063          if(!macLcCtxt)
13064          {
13065             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
13066             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13067             ueCfgDb->numMacLcs++;
13068          }
13069          if(!rlcLcCtxt)
13070          {
13071             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
13072             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13073             ueCfgDb->numRlcLcs++;
13074          }
13075
13076          ret = procSrbListToSetup(srbItem, macLcCtxt, rlcLcCtxt);
13077
13078          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13079                srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13080          if(ret == RFAILED)
13081          {
13082             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
13083             break;
13084          }
13085       }
13086    }
13087    else
13088       ret = RFAILED;
13089
13090    return ret;
13091 }
13092
13093 /*******************************************************************
13094  *
13095  * @brief Fills Drb List received by CU
13096  *
13097  * @details
13098  *
13099  *    Function : procDrbListToSetupMod
13100  *
13101  *    Functionality: Fills Drb List received by CU
13102  *                   for both MAC and RLC
13103  *
13104  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
13105  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
13106  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
13107  * @return void
13108  *
13109  * ****************************************************************/
13110
13111 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
13112 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
13113 {
13114    uint8_t cfgIdx = 0;
13115    RlcMode rlcModeInfo;
13116
13117    if(drbItem != NULLP)
13118    {
13119       /* Filling RLC INFO */
13120       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
13121       qoSInformation);
13122
13123       /* Filling MAC INFO */
13124       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
13125       {
13126          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13127          return RFAILED;
13128       }
13129    }
13130    else if(drbSetupModItem != NULLP)
13131    {
13132       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
13133       &drbSetupModItem->qoSInformation);
13134
13135       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
13136       {
13137          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13138          return RFAILED;
13139       }
13140    }
13141    else if(drbModItem != NULLP)
13142    {
13143       /* Drb to Mod IEs doesnot have rlcMode to be modified
13144        * in ASN. Hence no change in RLC configurations */
13145       if(storedRlcUeCfg != NULLP)
13146       {
13147          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
13148          {
13149             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
13150             {
13151                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
13152                break;
13153             }
13154          }
13155       }
13156
13157       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
13158       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
13159       {
13160          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13161          return RFAILED;
13162       }
13163    }
13164    return ROK;
13165 }
13166
13167 /*******************************************************************
13168  *
13169  * @brief extract Drb List received by CU
13170  *
13171  * @details
13172  *
13173  *    Function : extractDrbListToSetupMod
13174  *
13175  *    Functionality: extract Drb List received by CU
13176  *                   for both MAC and RLC
13177  *
13178  * @params[in] DRBs_ToBeSetup_Item_t pointer
13179  *             DuUeCfg pointer
13180  * @return ROK/RFAIED
13181  *
13182  * ****************************************************************/
13183
13184 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
13185  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
13186 {
13187    uint8_t ret = ROK;
13188    uint8_t drbIdx = 0, rlcLcIdx = 0;
13189    uint8_t drbId = 0, lcId = 0;
13190    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
13191    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
13192    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
13193    LcCfg *macLcCtxt = NULLP;
13194    RlcBearerCfg *rlcLcCtxt = NULLP;
13195
13196    ret = ROK;
13197    if(drbCount > 0)
13198    {
13199       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
13200       {
13201          macLcCtxt = NULL;
13202          rlcLcCtxt = NULL;
13203
13204          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
13205          {
13206             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
13207             ret = RFAILED;
13208             break;
13209          }
13210          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
13211          {
13212             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
13213             ret = RFAILED;
13214             break;
13215          }
13216
13217          if(drbModCfg != NULLP)
13218          {
13219             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
13220             drbId = drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID;
13221          }
13222          else if(drbCfg != NULLP)
13223             drbId = drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item.dRBID;
13224          else if(drbSetupModCfg != NULL)
13225          {
13226             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
13227             drbId = drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item.dRBID;
13228          }
13229
13230          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numRlcLcs; rlcLcIdx++)
13231          {
13232             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == drbId && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_DRB)
13233             {
13234                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13235                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13236                break;
13237             }
13238          }
13239          if(!macLcCtxt)
13240          {
13241             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
13242             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13243             ueCfgDb->numMacLcs++;
13244          }
13245          if(!rlcLcCtxt)
13246          {
13247             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
13248             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13249             ueCfgDb->numRlcLcs++;
13250          }
13251
13252          if(drbModCfg != NULLP)
13253          {
13254             lcId = fetchLcId(drbId);
13255             if(lcId < MIN_DRB_LCID)
13256             {
13257                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
13258                break;
13259             }
13260             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
13261             macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13262             if(ret == RFAILED)
13263             {
13264                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
13265                break;
13266             }
13267          }
13268          else
13269          {
13270             lcId = getDrbLcId(drbBitMap);
13271             if(lcId == RFAILED)
13272             {
13273                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
13274                ret = RFAILED;
13275                break;
13276             }
13277             if(drbCfg != NULL)
13278             {
13279                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
13280                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13281                if(ret == RFAILED)
13282                {
13283                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
13284                   break;
13285                }
13286             }
13287             else if(drbSetupModCfg != NULL)
13288             {
13289                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
13290                      macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13291                if(ret == RFAILED)
13292                {
13293                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
13294                   break;
13295                }
13296                ueCfgDb->numDrbSetupMod++;
13297             }
13298          }
13299          ueCfgDb->numDrb++;
13300
13301          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13302                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13303          if(ret == RFAILED)
13304          {
13305             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
13306             break;
13307          }
13308       }
13309    }
13310    else
13311       ret = RFAILED;
13312
13313    return ret;
13314 }
13315
13316 /*******************************************************************
13317  *
13318  * @brief Function to extract Dl RRC Msg received from CU
13319  *
13320  * @details
13321  *
13322  *    Function : extractDlRrcMsg
13323  *
13324  *    Functionality: Function to extract Dl RRC Msg received from CU
13325  *
13326  * @params[in] F1AP message
13327  * @return ROK     - success
13328  *         RFAILED - failure
13329  *
13330  * ****************************************************************/
13331
13332 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
13333    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
13334 {
13335    uint8_t ret = ROK;
13336    dlRrcMsg->rrcMsgSize = rrcContainer->size;
13337    if(dlRrcMsg->rrcMsgSize > 0)
13338    {
13339       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
13340       if(!dlRrcMsg->rrcMsgPdu)
13341       {
13342          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
13343          ret = RFAILED;
13344       }
13345       else
13346       {
13347          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
13348          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
13349          dlRrcMsg->srbId = SRB1_LCID;
13350          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
13351       }
13352    }
13353    return ret;
13354 }
13355
13356 /*******************************************************************
13357  *
13358  * @brief Extract UE capability info
13359  *
13360  * @details
13361  *
13362  *    Function : extractUeCapability
13363  *
13364  *    Functionality: Extract UE capability info and stores in ue Cb
13365  *
13366  * @params[in] Octet string of UE capability RAT container list
13367  * @return ROK     - success
13368  *         RFAILED - failure
13369  *
13370  * ****************************************************************/
13371 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
13372 {
13373    uint8_t  idx;
13374    uint16_t recvBufLen;
13375    asn_dec_rval_t rval;
13376    UE_NR_Capability_t  *ueNrCap = NULLP;
13377    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
13378
13379    /* Decoding UE Capability RAT Container List */
13380    recvBufLen = ueCapablityListBuf->size;
13381    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13382    if(!ueCapRatContList)
13383    {
13384       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
13385       return NULLP;
13386    }
13387    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13388    memset(&rval, 0, sizeof(asn_dec_rval_t));
13389    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
13390           ueCapablityListBuf->buf, recvBufLen, 0, 0);
13391    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13392    {
13393       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13394       return NULLP;
13395    }
13396    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
13397
13398    /* Free encoded buffer after decoding */
13399
13400    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
13401    {
13402       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
13403       {
13404          /* Decoding UE NR Capability */
13405           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
13406           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
13407           if(!ueNrCap)
13408           {
13409              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
13410              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13411              return NULLP;
13412           }
13413           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
13414           memset(&rval, 0, sizeof(asn_dec_rval_t));
13415           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
13416                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
13417           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13418           {
13419              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13420              return NULLP;
13421           }
13422           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
13423
13424           /* Free encoded buffer after decoding */
13425           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
13426       }
13427       free(ueCapRatContList->list.array[idx]);
13428    }
13429
13430    /* Free Memory*/
13431    free(ueCapRatContList->list.array);
13432    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13433    return ueNrCap;
13434 }
13435
13436 /*******************************************************************
13437 *
13438 * @brief free UE context setup request from CU
13439 *
13440 * @details
13441 *
13442 *    Function : freeAperDecodeF1UeContextSetupReq
13443 *
13444 *    Functionality: freeing part for the memory allocated by aper_decoder
13445 *
13446 * @params[in] F1AP message
13447 * @return ROK     - success
13448 *         RFAILED - failure
13449 *
13450 * ****************************************************************/
13451 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
13452 {
13453    uint8_t ieIdx = 0;
13454
13455    if(ueSetReq->protocolIEs.list.array != NULLP)
13456    {
13457       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
13458       {
13459          if(ueSetReq->protocolIEs.list.array[ieIdx])
13460          {
13461             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13462             {
13463                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13464                   break;
13465                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13466                   break;
13467                case ProtocolIE_ID_id_SpCell_ID:
13468                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
13469                   break;
13470                case ProtocolIE_ID_id_ServCellIndex:
13471                   break;
13472                case ProtocolIE_ID_id_SpCellULConfigured:
13473                   break;
13474                case ProtocolIE_ID_id_CUtoDURRCInformation:
13475
13476                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
13477                   break;
13478                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
13479
13480                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
13481                   break;
13482                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13483
13484                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
13485                   break;
13486                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13487
13488                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
13489                   break;
13490                case ProtocolIE_ID_id_RRCContainer:
13491                   {
13492
13493                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
13494                      {
13495
13496                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13497                      }
13498                      break;
13499                   }
13500                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13501                   break;
13502                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
13503                   {
13504                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
13505                      {
13506                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
13507                      }
13508                      break;
13509                   }
13510                default:
13511                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
13512             }
13513             free(ueSetReq->protocolIEs.list.array[ieIdx]);
13514          }
13515       }
13516       free(ueSetReq->protocolIEs.list.array);
13517    }
13518 }
13519 /*******************************************************************
13520  *
13521  * @brief Process UE context setup request from CU
13522  *
13523  * @details
13524  *
13525  *    Function : procF1UeContextSetupReq
13526  *
13527  *    Functionality: Process UE context setup request from CU
13528  *
13529  * @params[in] F1AP message
13530  * @return ROK     - success
13531  *         RFAILED - failure
13532  *
13533  * ****************************************************************/
13534 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
13535 {
13536    int8_t ueIdx = -1;
13537    uint8_t  ret=0, ieIdx=0, ieExtIdx = 0, servCellIdx = 0;
13538    bool ueCbFound = false, hoInProgress = false;
13539    uint16_t cellIdx=0;
13540    uint64_t nrCellId = 0;
13541    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
13542    DuUeCb   *duUeCb = NULL;
13543    UEContextSetupRequest_t   *ueSetReq = NULL;
13544    DRBs_ToBeSetup_List_t *drbCfg = NULL;
13545    CUtoDURRCInformation_t *rrcInfo = NULL;
13546    DRXCycle_t *drxCycle;
13547
13548    ret = ROK;
13549
13550    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
13551    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13552    {
13553       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13554       {
13555          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13556             {
13557                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13558                break;
13559             }
13560
13561          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13562             {
13563                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13564                break;
13565             }
13566
13567          case ProtocolIE_ID_id_SpCell_ID:
13568             {
13569                bitStringToInt(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
13570
13571                GET_CELL_IDX(nrCellId, cellIdx);
13572                if(!duCb.actvCellLst[cellIdx])
13573                {
13574                   DU_LOG("\nERROR  -->  F1AP : Cell Id [%lu] not found", nrCellId);
13575                   ret = RFAILED;
13576                }
13577                break;
13578             }
13579
13580          case ProtocolIE_ID_id_ServCellIndex:
13581             {
13582                servCellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
13583                break;
13584             }
13585
13586          case ProtocolIE_ID_id_SpCellULConfigured:
13587             {
13588                /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
13589                   UL, SUL or UL+SUL for the indicated cell for the UE */
13590                break;
13591             }
13592
13593          case ProtocolIE_ID_id_CUtoDURRCInformation:
13594             {
13595                rrcInfo = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation;
13596
13597                /* Search if UE context is present */
13598                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
13599                {
13600                   if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId)
13601                   {
13602                      ueCbFound = true;
13603                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13604                      break;
13605                   }
13606                }
13607
13608                /* Check if UE Handover scenario */
13609                if(rrcInfo->iE_Extensions)
13610                {
13611                   for(ieExtIdx = 0; ieExtIdx < rrcInfo->iE_Extensions->list.count; ieExtIdx++)
13612                   {
13613                      if(rrcInfo->iE_Extensions->list.array[ieExtIdx]->id == ProtocolIE_ID_id_HandoverPreparationInformation)
13614                      {
13615                         hoInProgress = true;
13616                         break;
13617                      }
13618                   }
13619                }
13620
13621                /* If UE context is not present, but UE is in handover */
13622                if(!ueCbFound && hoInProgress)
13623                {
13624                   ueIdx = getFreeBitFromUeBitMap(nrCellId);
13625                   if(ueIdx != -1)
13626                      gnbDuUeF1apId = ueIdx +1;
13627                   else
13628                   {
13629                      DU_LOG("\nERROR  -->  F1AP : No free UE IDX found in UE bit map of cell Id [%lu]", nrCellId);
13630                      ret = RFAILED;
13631                      break;
13632                   }
13633                   duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13634                   duUeCb->f1UeDb = NULL;
13635                   duUeCb->gnbCuUeF1apId = gnbCuUeF1apId;
13636                   duUeCb->gnbDuUeF1apId = gnbDuUeF1apId;
13637                   GET_CRNTI(duUeCb->crnti, duUeCb->gnbDuUeF1apId);
13638                   duUeCb->ueState = UE_HANDIN_IN_PROGRESS;
13639                }
13640
13641                if(duUeCb)
13642                {
13643                   DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13644                   if(duUeCb->f1UeDb)
13645                   {
13646                      memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13647                      duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
13648                      duUeCb->f1UeDb->cellIdx = cellIdx;
13649                   }
13650                   else
13651                   {
13652                      DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
13653                      ret = RFAILED;
13654                      break;
13655                   }
13656                }
13657                else
13658                {
13659                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13660                   ret = RFAILED;
13661                   break;
13662                }
13663
13664                /* Extract UE capability info */
13665                if(rrcInfo->uE_CapabilityRAT_ContainerList)
13666                {
13667                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = extractUeCapability(rrcInfo->uE_CapabilityRAT_ContainerList, duUeCb);
13668                }
13669
13670                /* Extract IE extension */
13671                if(rrcInfo->iE_Extensions)
13672                {
13673                   if(extractCuToDuRrcInfoExt(rrcInfo->iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
13674                   {
13675                      DU_LOG("\nERROR  -->  F1AP: Failed to extract CU to DU RRC information extension IE");
13676                      //TODO: Update the failure cause in ue context Setup Response
13677                      ret = RFAILED;
13678                   }
13679                }
13680                break;
13681             }
13682
13683 #ifdef NR_DRX
13684          case ProtocolIE_ID_id_DRXCycle:
13685             {
13686                duUeCb->f1UeDb->duUeCfg.drxCyclePres = true;
13687                drxCycle = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle;
13688                duUeCb->f1UeDb->duUeCfg.drxCycle.drxLongCycleLength =  convertLongDrxCycleLengthEnumToValue(drxCycle->longDRXCycleLength);
13689                if(drxCycle->shortDRXCycleLength)
13690                {
13691                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCyclePres = true;
13692                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycle = \
13693                   convertShortDrxCycleLengthEnumToValue(*(drxCycle->shortDRXCycleLength));
13694                }
13695                if(drxCycle->shortDRXCycleTimer)
13696                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycleTimer = *(drxCycle->shortDRXCycleTimer);
13697
13698                break;
13699             }
13700
13701 #endif
13702          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13703             {
13704                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
13705                         &duUeCb->f1UeDb->duUeCfg))
13706                {
13707                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
13708                   //TODO: Update the failure cause in ue context Setup Response
13709                   ret = RFAILED;
13710                }
13711                break;
13712             }
13713
13714          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13715             {
13716                drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
13717
13718                if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
13719                {
13720                   DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
13721                   //TODO: Update the failure cause in ue context Setup Response
13722                   ret = RFAILED;
13723                }
13724                break;
13725             }
13726          case ProtocolIE_ID_id_RRCContainer:
13727             {
13728                /* Filling Dl RRC Msg Info */
13729                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13730                if(!duUeCb->f1UeDb->dlRrcMsg)
13731                {
13732                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
13733                   ret = RFAILED;
13734                }
13735                else
13736                {
13737                   duUeCb->f1UeDb->dlRrcMsgPres = true;
13738                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13739                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13740                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
13741                }
13742                break;
13743             }
13744
13745          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13746             {
13747                if(duUeCb->f1UeDb->dlRrcMsg)
13748                {
13749                   if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
13750                   {
13751                      duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
13752                   }
13753                   else
13754                   {
13755                      DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
13756                   }
13757                }
13758                break;
13759             }
13760
13761          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
13762             {
13763                /* MaximumBitRate Uplink */
13764                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
13765                if(bitRateSize > 0)
13766                {
13767                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
13768                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
13769                   {
13770                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
13771                      ret = RFAILED;
13772                   }
13773                   else
13774                   {
13775                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
13776                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
13777                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
13778                   }
13779                }
13780                else
13781                   ret = RFAILED;
13782                break;
13783             }
13784
13785          default:
13786             {
13787                break;
13788             }
13789       } /* End of switch */
13790
13791       /* In case of any failure in any IE */
13792       if(ret == RFAILED)
13793       {
13794          // BuildAndSendUeContextSetupRsp(cellId,ueId);
13795          DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
13796          break;
13797       }
13798    } /* End of for loop of IEs */
13799
13800    if(ret == ROK)
13801       ret = duProcUeContextSetupRequest(duUeCb);
13802
13803    freeAperDecodeF1UeContextSetupReq(ueSetReq);
13804    return ret;
13805
13806 }
13807 /*******************************************************************
13808  * @brief Free the memory allocated for Dl Tunnel Info
13809  *
13810  * @details
13811  *
13812  *    Function : freeDlTnlInfo
13813  *
13814  *    Functionality:
13815  *       Free the memory allocated for Dl Tunnel Info
13816  *
13817  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
13818  * @return void
13819  *
13820  * ****************************************************************/
13821
13822 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
13823 {
13824    uint8_t arrIdx = 0;
13825
13826    if(tnlInfo)
13827    {
13828       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
13829       {
13830          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
13831                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
13832          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
13833                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
13834          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
13835          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
13836       }
13837       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
13838    }
13839 }
13840
13841 /*******************************************************************
13842  * @brief Free the memory allocated for DRB setup List
13843  *
13844  * @details
13845  *
13846  *    Function : freeDrbSetupList
13847  *
13848  *    Functionality:
13849  *       Free the memory allocated for DRB setup list
13850  *
13851  * @params[in] DRBs_Setup_List_t *
13852  * @return void
13853  *
13854  * ****************************************************************/
13855 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
13856 {
13857    uint8_t arrIdx = 0;
13858    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
13859
13860    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
13861    {
13862       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
13863       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
13864       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
13865    }
13866    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
13867 }
13868
13869 /*******************************************************************
13870  * @brief Free the memory allocated for UE Setup response
13871  *
13872  * @details
13873  *
13874  *    Function : FreeUeContextSetupRsp
13875  *
13876  *    Functionality:
13877  *       Free the memory allocated for UE Setup response
13878  *
13879  * @params[in] F1AP PDU for UE setup response
13880  * @return ROK     - success
13881  *         RFAILED - failure
13882  *
13883  * ****************************************************************/
13884 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
13885 {
13886    uint8_t idx;
13887    UEContextSetupResponse_t *ueSetRsp = NULLP;
13888
13889    if(f1apMsg)
13890    {
13891       if(f1apMsg->choice.successfulOutcome)
13892       {
13893          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
13894                     UEContextSetupResponse;
13895          if(ueSetRsp->protocolIEs.list.array)
13896          {
13897             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
13898             {
13899                if(ueSetRsp->protocolIEs.list.array[idx])
13900                {
13901                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
13902                   {
13903                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13904                         break;
13905                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13906                         break;
13907                      case ProtocolIE_ID_id_DUtoCURRCInformation:
13908                         {
13909                            CellGroupConfig_t *cellGrpCfg = NULLP;
13910                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
13911                                          DUtoCURRCInformation.cellGroupConfig;
13912                            if(cellGrpCfg->buf != NULLP)
13913                            {
13914                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
13915                               cellGrpCfg = NULLP;
13916                            }
13917                            break;
13918                         }
13919                     case ProtocolIE_ID_id_DRBs_Setup_List:
13920                         {
13921                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
13922                            break;
13923                         }
13924                      default:
13925                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
13926                         ueSetRsp->protocolIEs.list.array[idx]->id);
13927                         break;
13928                   }
13929                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
13930                         sizeof(UEContextSetupResponseIEs_t));
13931                }
13932             }
13933             DU_FREE(ueSetRsp->protocolIEs.list.array, \
13934                   ueSetRsp->protocolIEs.list.size);
13935          }
13936          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13937       }
13938       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13939    }
13940 }
13941
13942 /*******************************************************************
13943  *
13944  * @brief Builds Ue context Setup Rsp DU To CU Info
13945  *
13946  * @details
13947  *
13948  *    Function : EncodeUeCntxtDuToCuInfo
13949  *
13950  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
13951  *
13952  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
13953  *
13954  * @return ROK     - success
13955  *         RFAILED - failure
13956  *
13957  ******************************************************************/
13958
13959 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
13960 {
13961    asn_enc_rval_t        encRetVal;
13962
13963    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
13964    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
13965    encBufSize = 0;
13966    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
13967    /* Encode results */
13968    if(encRetVal.encoded == ENCODE_FAIL)
13969    {
13970       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
13971             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13972       return RFAILED;
13973    }
13974    else
13975    {
13976       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
13977 #ifdef DEBUG_ASN_PRINT
13978       for(int i=0; i< encBufSize; i++)
13979       {
13980          printf("%x",encBuf[i]);
13981       }
13982 #endif
13983    }
13984    duToCuCellGrp->size = encBufSize;
13985    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
13986    if(!duToCuCellGrp->buf)
13987    {
13988       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
13989    }
13990    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
13991    return ROK;
13992 }
13993
13994 /*******************************************************************
13995  *
13996  * @brief Fills Dl Gtp tunnel Info
13997  *
13998  * @details
13999  *
14000  *    Function : fillGtpTunnelforDl
14001  *
14002  *    Functionality: Fills Dl Gtp tunnel Info
14003  *
14004  * @params[in]
14005  *
14006  * @return ROK     - success
14007  *         RFAILED - failure
14008  *
14009  * ****************************************************************/
14010
14011 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
14012 {
14013    uint8_t bufSize = 0;
14014
14015    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
14016    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
14017    if(gtpDl->transportLayerAddress.buf == NULLP)
14018    {
14019       return RFAILED;
14020    }
14021    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
14022
14023    /*GTP TEID*/
14024    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
14025    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
14026    if(gtpDl->gTP_TEID.buf == NULLP)
14027    {
14028       return RFAILED;
14029    }
14030    bufSize = 3; /*forming an Octect String*/
14031    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
14032
14033    return ROK;
14034 }
14035
14036 /*******************************************************************
14037  *
14038  * @brief Fills DL Tunnel Setup List
14039  *
14040  * @details
14041  *
14042  *    Function : fillDlTnlSetupList
14043  *
14044  *    Functionality: Fills the DL Tunnel Setup List
14045  *
14046  * @params[in]
14047  *
14048  * @return ROK     - success
14049  *         RFAILED - failure
14050  *
14051  * ****************************************************************/
14052
14053 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
14054 {
14055    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14056
14057    eleCount = 1;
14058    dlTnlInfo->list.count = eleCount;
14059    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
14060
14061    /* Initialize the DL Tnl Setup List Members */
14062    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
14063    if(dlTnlInfo->list.array == NULLP)
14064    {
14065       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
14066       ret = RFAILED;
14067    }
14068    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14069    {
14070       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
14071       if(dlTnlInfo->list.array[arrIdx] == NULLP)
14072       {
14073          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
14074          return RFAILED;
14075       }
14076       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
14077       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
14078       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
14079       {
14080          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
14081          return RFAILED;
14082       }
14083       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
14084                tnlCfg->tnlCfg1);
14085       if(ret != ROK)
14086          break;
14087    }
14088    return ret;
14089 }
14090
14091 /*******************************************************************
14092  *
14093  * @brief Fills the Drb Setup List for Ue Context Setup Response
14094  *
14095  * @details
14096  *
14097  *    Function : fillDrbSetupList
14098  *
14099  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
14100  *
14101  * @params[in]
14102  *
14103  * @return ROK     - success
14104  *         RFAILED - failure
14105  *
14106  * ****************************************************************/
14107 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
14108 {
14109    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14110    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
14111
14112    eleCount = ueCfg->numDrb;
14113    drbSetupList->list.count = eleCount;
14114    drbSetupList->list.size = \
14115         (eleCount * sizeof(DRBs_Setup_Item_t *));
14116
14117    /* Initialize the Drb Setup List Members */
14118    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
14119    if(drbSetupList->list.array == NULLP)
14120    {
14121       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
14122       ret = RFAILED;
14123    }
14124
14125    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14126    {
14127       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
14128       if(drbSetupList->list.array[arrIdx] == NULLP)
14129       {
14130          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
14131          return RFAILED;
14132       }
14133       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
14134       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
14135       drbItemIe->criticality = Criticality_reject;
14136       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
14137       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
14138       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
14139           &ueCfg->upTnlInfo[arrIdx]);
14140       if(ret != ROK)
14141          break;
14142    }
14143    return ret;
14144 }
14145
14146 /*******************************************************************
14147  *
14148  * @brief Builds and sends the UE Setup Response
14149  *
14150  * @details
14151  *
14152  *    Function : BuildAndSendUeContextSetupRsp
14153  *
14154  *    Functionality: Constructs the UE Setup Response and sends
14155  *                   it to the DU through SCTP.
14156  *
14157  * @params[in] uint8_t cellId,uint8_t ueId
14158  *
14159  * @return ROK     - success
14160  *         RFAILED - failure
14161  *
14162  * ****************************************************************/
14163 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
14164 {
14165    uint8_t   idx, ret, cellIdx, elementCnt;
14166    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
14167    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
14168    asn_enc_rval_t  encRetVal;        /* Encoder return value */
14169    F1AP_PDU_t               *f1apMsg = NULLP;
14170    UEContextSetupResponse_t *ueSetRsp = NULLP;
14171    DuUeCb                   *ueCb = NULLP;
14172
14173    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
14174
14175    while(true)
14176    {
14177       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14178       if(f1apMsg == NULLP)
14179       {
14180          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14181          ret = RFAILED;
14182          break;
14183       }
14184
14185       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
14186       DU_ALLOC(f1apMsg->choice.successfulOutcome,
14187             sizeof(SuccessfulOutcome_t));
14188       if(f1apMsg->choice.successfulOutcome == NULLP)
14189       {
14190          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
14191          ret = RFAILED;
14192          break;
14193       }
14194
14195       f1apMsg->choice.successfulOutcome->procedureCode = \
14196                                                          ProcedureCode_id_UEContextSetup;
14197       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
14198       f1apMsg->choice.successfulOutcome->value.present = \
14199                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
14200
14201       ueSetRsp =
14202          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
14203       elementCnt = 5;
14204       ueSetRsp->protocolIEs.list.count = elementCnt;
14205       ueSetRsp->protocolIEs.list.size = \
14206                                         elementCnt * sizeof(UEContextSetupResponse_t *);
14207
14208       /* Initialize the UESetup members */
14209       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
14210             ueSetRsp->protocolIEs.list.size);
14211       if(ueSetRsp->protocolIEs.list.array == NULLP)
14212       {
14213          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14214          ret = RFAILED;
14215          break;
14216       }
14217
14218       for(idx=0; idx<elementCnt; idx++)
14219       {
14220          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
14221                sizeof(UEContextSetupResponseIEs_t));
14222          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
14223          {
14224             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14225             ret = RFAILED;
14226             break;
14227          }
14228       }
14229       /* Fetching Ue Cb Info*/
14230       GET_CELL_IDX(cellId, cellIdx);
14231       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
14232       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
14233       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
14234
14235       idx = 0;
14236       /*GNB CU UE F1AP ID*/
14237       ueSetRsp->protocolIEs.list.array[idx]->id = \
14238                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14239       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14240       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14241                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
14242       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14243
14244       /*GNB DU UE F1AP ID*/
14245       idx++;
14246       ueSetRsp->protocolIEs.list.array[idx]->id = \
14247                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14248       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14249       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14250                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
14251       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14252
14253
14254       /*DUtoCURRC Information */
14255       idx++;
14256       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14257                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
14258       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14259       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14260                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
14261       BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
14262
14263       /* CRNTI */
14264       idx++;
14265       ueSetRsp->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_C_RNTI;
14266       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14267       ueSetRsp->protocolIEs.list.array[idx]->value.present = UEContextSetupResponseIEs__value_PR_C_RNTI;
14268       ueSetRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI = ueCb->crnti;
14269
14270
14271       /* Drb Setup List */
14272       idx++;
14273       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14274                                                    ProtocolIE_ID_id_DRBs_Setup_List;
14275       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14276       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14277                                                             UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
14278       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
14279             &ueCb->f1UeDb->duUeCfg);
14280       if(ret == RFAILED)
14281       {
14282          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
14283          freeF1UeDb(ueCb->f1UeDb);
14284          ueCb->f1UeDb = NULLP;
14285          break;
14286       }
14287
14288       /* Free UeContext Db created during Ue context Req */
14289       freeF1UeDb(ueCb->f1UeDb);
14290       ueCb->f1UeDb = NULLP;
14291
14292       /* TODO: To send Drb list */
14293       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14294
14295       /* Encode the UE context setup response type as APER */
14296       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
14297       encBufSize = 0;
14298       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14299             encBuf);
14300       /* Encode results */
14301       if(encRetVal.encoded == ENCODE_FAIL)
14302       {
14303          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
14304                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14305          ret = RFAILED;
14306          break;
14307       }
14308       else
14309       {
14310          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
14311 #ifdef DEBUG_ASN_PRINT
14312          for(int i=0; i< encBufSize; i++)
14313          {
14314             printf("%x",encBuf[i]);
14315          }
14316 #endif
14317       }
14318
14319       /* Sending  msg  */
14320       if(sendF1APMsg()  != ROK)
14321       {
14322          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
14323          ret = RFAILED;
14324          break;
14325       }
14326       break;
14327    }
14328    FreeUeContextSetupRsp(f1apMsg);
14329    return ret;
14330 }/* End of BuildAndSendUeContextSetupRsp */
14331 /*******************************************************************
14332 *
14333 * @brief  Build And Send Ue Context Rsp
14334 *
14335 * @details
14336 *
14337 *    Function : BuildAndSendUeCtxtRsp
14338 *
14339 *    Functionality : Build And Send Ue Context Rsp
14340
14341 * @params[in]
14342 * @return sucess = ROK
14343 *         failure = RFAILED
14344 *
14345 * ****************************************************************/
14346 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
14347 {
14348    uint8_t cellIdx = 0, actionType = 0;
14349
14350    GET_CELL_IDX(cellId, cellIdx);
14351    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
14352
14353    switch(actionType)
14354    {
14355       case UE_CTXT_SETUP:
14356          {
14357             if((BuildAndSendUeContextSetupRsp(cellId,ueId)) != ROK)
14358             {
14359                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextSetupRsp()");
14360                return RFAILED;
14361             }
14362             break;
14363          }
14364       case UE_CTXT_MOD:
14365          {
14366             if((BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1])) != ROK)
14367             {
14368                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextModRsp");
14369                return RFAILED;
14370             }
14371             break;
14372          }
14373       default:
14374          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
14375          break;
14376
14377    }
14378    return ROK;
14379 }
14380
14381 /*******************************************************************
14382  *
14383  * @brief deallocating the memory of  F1reset msg
14384  *
14385  * @details
14386  *
14387  *    Function : FreeF1ResetReq
14388  *
14389  *    Functionality :
14390  *         - freeing memory of F1reset request msg
14391  *
14392  * @params[in]
14393  * @return void
14394  *
14395  *
14396  * ****************************************************************/
14397 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
14398 {
14399    uint8_t idx =0 ;
14400    Reset_t *f1ResetMsg;
14401
14402    if(f1apMsg)
14403    {
14404       if(f1apMsg->choice.initiatingMessage)
14405       {
14406          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14407
14408          if(f1ResetMsg->protocolIEs.list.array)
14409          {
14410             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
14411             {
14412                if(f1ResetMsg->protocolIEs.list.array[idx])
14413                {
14414                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14415                }
14416             }
14417             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14418          }
14419          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14420       }
14421       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14422    }
14423 }
14424 /*******************************************************************
14425  *
14426  * @brief Build and Send F1reset request
14427  *
14428  * @details
14429  *
14430  *    Function : BuildAndSendF1ResetReq
14431  *
14432  *    Functionality:
14433  *         - Build and Send F1reset request msg
14434  *
14435  * @params[in]
14436  * @return ROK     - success
14437  *         RFAILED - failure
14438  *
14439  * ****************************************************************/
14440 uint8_t BuildAndSendF1ResetReq()
14441 {
14442    uint8_t          elementCnt=0;
14443    uint8_t          idx=0;
14444    uint8_t          ret= RFAILED;
14445    Reset_t          *f1ResetMsg = NULLP;
14446    F1AP_PDU_t       *f1apMsg = NULLP;
14447    asn_enc_rval_t   encRetVal;
14448    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
14449    do
14450    {
14451       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14452       if(f1apMsg == NULLP)
14453       {
14454          break;
14455       }
14456       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14457       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14458       if(f1apMsg->choice.initiatingMessage == NULLP)
14459       {
14460          break;
14461       }
14462       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
14463       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
14464       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
14465
14466       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14467
14468       elementCnt = 3;
14469       f1ResetMsg->protocolIEs.list.count = elementCnt;
14470       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
14471
14472       /* Initialize the F1Setup members */
14473       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14474       if(f1ResetMsg->protocolIEs.list.array == NULLP)
14475       {
14476          break;
14477       }
14478       for(idx=0; idx<elementCnt; idx++)
14479       {
14480          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14481          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
14482          {
14483             break;
14484          }
14485       }
14486
14487       /*TransactionID*/
14488       idx=0;
14489       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14490       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14491       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
14492       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
14493
14494       /*Cause*/
14495       idx++;
14496       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
14497       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
14498       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
14499       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
14500       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
14501
14502       /*Reset Type*/
14503       idx++;
14504       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
14505       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14506       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
14507       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
14508       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
14509
14510       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14511
14512       /* Encode the F1SetupRequest type as APER */
14513       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14514       encBufSize = 0;
14515       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14516             encBuf);
14517
14518       /* Encode results */
14519       if(encRetVal.encoded == ENCODE_FAIL)
14520       {
14521          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
14522                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14523          break;
14524       }
14525       else
14526       {
14527          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
14528 #ifdef DEBUG_ASN_PRINT
14529          for(idx=0; idx< encBufSize; idx++)
14530          {
14531             printf("%x",encBuf[idx]);
14532          }
14533 #endif
14534       }
14535
14536       if(sendF1APMsg() != ROK)
14537       {
14538          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
14539          break;
14540       }
14541
14542       ret = ROK;
14543       break;
14544    }while(true);
14545
14546    FreeF1ResetReq(f1apMsg);
14547    return ret;
14548 }
14549 /*******************************************************************
14550  *
14551  * @brief Build And Send F1ResetAck
14552  *
14553  * @details
14554  *
14555  *    Function : BuildAndSendF1ResetAck
14556  *
14557  *    Functionality:
14558  *         - Build And Send  F1ResetRSP
14559  *
14560  * @return ROK     - success
14561  *         RFAILED - failure
14562  *
14563  * ****************************************************************/
14564 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
14565 {
14566    uint8_t idx;
14567    ResetAcknowledge_t *f1ResetAck;
14568
14569    if(f1apMsg)
14570    {
14571       if(f1apMsg->choice.successfulOutcome)
14572       {
14573          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14574
14575          if(f1ResetAck->protocolIEs.list.array)
14576          {
14577             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
14578             {
14579                if(f1ResetAck->protocolIEs.list.array[idx])
14580                {
14581                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14582                }
14583             }
14584             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14585          }
14586          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14587       }
14588       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14589    }
14590 }
14591
14592 /*******************************************************************
14593  *
14594  * @brief Build And Send F1ResetAck
14595  *
14596  * @details
14597  *
14598  *    Function : BuildAndSendF1ResetAck
14599  *
14600  *    Functionality:
14601  *         - Build And Send  F1ResetRSP
14602  *
14603  *  @params[in]
14604  * @return ROK     - success
14605  *         RFAILED - failure
14606  *
14607  * ****************************************************************/
14608 uint8_t BuildAndSendF1ResetAck()
14609 {
14610    uint8_t                idx = 0;
14611    uint8_t                elementCnt = 0;
14612    uint8_t                ret = RFAILED;
14613    F1AP_PDU_t             *f1apMsg = NULL;
14614    ResetAcknowledge_t     *f1ResetAck = NULLP;
14615    asn_enc_rval_t         encRetVal;
14616    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
14617
14618    do{
14619       /* Allocate the memory for F1ResetRequest_t */
14620       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14621       if(f1apMsg == NULLP)
14622       {
14623          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14624          break;
14625       }
14626
14627       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
14628
14629       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14630       if(f1apMsg->choice.successfulOutcome == NULLP)
14631       {
14632          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14633          break;
14634       }
14635       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
14636       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
14637       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14638
14639       elementCnt = 1;
14640
14641       f1ResetAck->protocolIEs.list.count = elementCnt;
14642       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
14643
14644       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14645       if(f1ResetAck->protocolIEs.list.array == NULLP)
14646       {
14647          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
14648          break;
14649       }
14650
14651       for(idx=0; idx<elementCnt; idx++)
14652       {
14653          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14654          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
14655          {
14656             break;
14657          }
14658       }
14659       /*TransactionID*/
14660       idx = 0;
14661       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14662       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14663       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
14664       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
14665
14666       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14667
14668       /* Encode the F1SetupRequest type as UPER */
14669       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14670       encBufSize = 0;
14671       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
14672
14673       /* Check encode results */
14674       if(encRetVal.encoded == ENCODE_FAIL)
14675       {
14676          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
14677                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14678          break;
14679       }
14680       else
14681       {
14682          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
14683 #ifdef DEBUG_ASN_PRINT
14684          for(int i=0; i< encBufSize; i++)
14685          {
14686             printf("%x",encBuf[i]);
14687          }
14688 #endif
14689       }
14690       /* Sending msg */
14691       if(sendF1APMsg() != ROK)
14692       {
14693          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
14694          break;
14695       }
14696
14697       ret = ROK;
14698       break;
14699    }while(true);
14700
14701    FreeF1ResetAck(f1apMsg);
14702    return ret;
14703 }
14704 /******************************************************************
14705 *
14706 * @brief free F1 reset msg allocated by aper_decoder
14707 *
14708 * @details
14709 *
14710 *    Function : freeAperDecodeF1ResetMsg
14711 *
14712 *    Functionality: free F1 reset msg allocated by aper_decoder
14713 *
14714 * @params[in] Reset_t *f1ResetMsg
14715 * @return void
14716 *
14717 * ****************************************************************/
14718
14719 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
14720 {
14721    uint8_t ieIdx =0;
14722    if(f1ResetMsg->protocolIEs.list.array)
14723    {
14724       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
14725       {
14726          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
14727          {
14728             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
14729          }
14730       }
14731       free(f1ResetMsg->protocolIEs.list.array);
14732    }
14733 }
14734
14735 /******************************************************************
14736  *
14737  * @brief Processes DL RRC Message Transfer  sent by CU
14738  *
14739  * @details
14740  *
14741  *    Function : procF1ResetReq
14742  *
14743  *    Functionality: Processes DL RRC Message Transfer sent by CU
14744  *
14745  * @params[in] F1AP_PDU_t ASN decoded F1AP message
14746  * @return ROK     - success
14747  *         RFAILED - failure
14748  *
14749  * ****************************************************************/
14750 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
14751 {
14752    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
14753    uint8_t       ieIdx = 0;
14754    uint8_t        ret = ROK;
14755    Reset_t       *f1ResetMsg = NULLP;
14756
14757    DU_LOG("\nINFO   -->  Processing F1 reset request");
14758    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14759
14760    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
14761    {
14762       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
14763       {
14764          case ProtocolIE_ID_id_TransactionID:
14765             break;
14766
14767          case ProtocolIE_ID_id_Cause:
14768             break;
14769
14770          case ProtocolIE_ID_id_ResetType:
14771             {
14772                break;
14773             }
14774
14775          default:
14776             break;
14777       }
14778    }
14779    ret = BuildAndSendF1ResetAck();
14780    DU_LOG("\nINFO   -->  UE release is not supported for now");
14781
14782    freeAperDecodeF1ResetMsg(f1ResetMsg);
14783
14784    return ret;
14785 }
14786
14787 /*******************************************************************
14788  *
14789  * @brief free the RRC delivery report
14790  *
14791  * @details
14792  *
14793  *    Function : freeRrcDeliveryReport
14794  *
14795  *    Functionality: free the RRC delivery report
14796  *
14797  * @params[in]
14798  * @return ROK     - success
14799  *         RFAILED - failure
14800  *
14801  * ****************************************************************/
14802 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
14803 {
14804    uint8_t idx=0;
14805    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14806
14807    if(f1apMsg)
14808    {
14809       if(f1apMsg->choice.initiatingMessage)
14810       {
14811          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14812          if(rrcDeliveryReport->protocolIEs.list.array)
14813          {
14814             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
14815                   idx++)
14816             {
14817                if(rrcDeliveryReport->protocolIEs.list.array[idx])
14818                {
14819                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
14820                         sizeof(RRCDeliveryReportIEs_t));
14821                }
14822             }
14823             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
14824                   rrcDeliveryReport->protocolIEs.list.size);
14825          }
14826          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14827       }
14828       DU_FREE(f1apMsg,
14829             sizeof(F1AP_PDU_t));
14830    }
14831 }
14832
14833 /*******************************************************************
14834 *
14835 * @brief Builds and sends the RRC delivery report
14836 *
14837 * @details
14838 *
14839 *    Function : BuildAndSendRrcDeliveryReport
14840 *
14841 *    Functionality: Builds and sends the RRC delivery report
14842 *
14843 * @params[in]
14844 *
14845 * @return ROK     - success
14846 *         RFAILED - failure
14847 *
14848 * ****************************************************************/
14849 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
14850    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
14851 {
14852    uint8_t             ret = RFAILED;
14853    uint8_t             idx    = 0;
14854    uint8_t             idx1   = 0;
14855    uint8_t             elementCnt = 0;
14856    F1AP_PDU_t          *f1apMsg = NULLP;
14857    asn_enc_rval_t      encRetVal;
14858    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14859
14860    do{
14861
14862       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
14863       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14864       if(f1apMsg == NULLP)
14865       {
14866          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14867          break;
14868       }
14869       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14870       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14871       if(f1apMsg->choice.initiatingMessage == NULLP)
14872       {
14873          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
14874          break;
14875       }
14876       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
14877       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
14878       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
14879
14880       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14881       elementCnt = 4;
14882       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
14883       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
14884
14885       /* Initialize the F1Setup members */
14886       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
14887       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
14888       {
14889          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
14890          break;
14891       }
14892       for(idx =0 ;idx <elementCnt; idx++)
14893       {
14894          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
14895          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
14896          {
14897             break;
14898          }
14899       }
14900
14901       idx1 = 0;
14902
14903       /*GNB CU UE F1AP ID*/
14904       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14905       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
14906       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
14907       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14908
14909       /*GNB DU UE F1AP ID*/
14910       idx1++;
14911       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14912       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
14913       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
14914       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14915
14916       /*RRC delivery status*/
14917       idx1++;
14918       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
14919       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
14920       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
14921       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
14922       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
14923       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
14924       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
14925
14926       /* SRB ID */
14927       idx1++;
14928       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
14929       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
14930       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
14931       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
14932
14933       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14934
14935       /* Encode the RRC DELIVERY REPORT type as APER */
14936       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14937       encBufSize = 0;
14938       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14939             encBuf);
14940
14941       /* Encode results */
14942       if(encRetVal.encoded == ENCODE_FAIL)
14943       {
14944          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
14945                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14946          break;
14947       }
14948       else
14949       {
14950          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
14951 #ifdef DEBUG_ASN_PRINT
14952          for(idx=0; idx< encBufSize; idx++)
14953          {
14954             printf("%x",encBuf[idx]);
14955          }
14956 #endif
14957       }
14958
14959       /* Sending msg */
14960       if(sendF1APMsg() != ROK)
14961       {
14962          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
14963          break;
14964       }
14965       ret = ROK;
14966       break;
14967
14968    }while(true);
14969
14970    freeRrcDeliveryReport(f1apMsg);
14971    return ret;
14972 }
14973
14974 /*******************************************************************
14975  *
14976  * @brief Processes cells to be activated
14977  *
14978  * @details
14979  *
14980  *    Function : extractCellsToBeActivated
14981  *
14982  *    Functionality:
14983  *      - Processes cells to be activated list received in F1SetupRsp
14984  *
14985  * @params[in] void
14986  * @return ROK     - success
14987  *         RFAILED - failure
14988  *
14989  * ****************************************************************/
14990
14991 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
14992 {
14993    uint8_t  ret = ROK;
14994    uint16_t idx, pci = 0;
14995    uint64_t nci;
14996    Cells_to_be_Activated_List_Item_t cell;
14997
14998    for(idx=0; idx<cellsToActivate.list.count; idx++)
14999    {
15000       nci = 0;
15001       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
15002       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
15003
15004       if(cell.nRPCI)
15005       {
15006          pci = *cell.nRPCI;
15007       }
15008       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
15009    }
15010    return ret;
15011 }
15012 /******************************************************************
15013 *
15014 * @brief Processes F1 Setup Response allocated by aper_decoder
15015 *
15016 * @details
15017 *
15018 *    Function : freeF1SetupRsp
15019 *
15020 *    Functionality: free F1 Setup Response allocated by aper_decoder
15021 *
15022 * @params[in] F1SetupResponse_t *f1SetRspMsg
15023 * @return void
15024 *
15025 * ****************************************************************/
15026
15027 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
15028 {
15029    uint8_t ieIdx =0;
15030    uint8_t arrIdx =0;
15031    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
15032    RRC_Version_t      *rrcVer =NULLP;
15033
15034    if(f1SetRspMsg->protocolIEs.list.array)
15035    {
15036       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
15037       {
15038          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
15039          {
15040             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
15041             {
15042                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15043                   {
15044                      cellToActivate =
15045                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
15046                      if(cellToActivate->list.array)
15047                      {
15048                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
15049                         {
15050                            if(cellToActivate->list.array[arrIdx])
15051                            {
15052
15053                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
15054                               pLMN_Identity.buf)
15055                               {
15056                                  if(cellToActivate->list.array[0]->value.choice.\
15057                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
15058                                  {
15059                                     free(cellToActivate->list.array[0]->value.choice.\
15060                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
15061                                  }
15062
15063                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
15064                                        nRCGI.pLMN_Identity.buf);
15065                               }
15066                               free(cellToActivate->list.array[arrIdx]);
15067                            }
15068                         }
15069                         free(cellToActivate->list.array);
15070                      }
15071                      break;
15072                   }
15073                case ProtocolIE_ID_id_TransactionID:
15074                   {
15075                      break;
15076                   }
15077                case ProtocolIE_ID_id_gNB_CU_Name:
15078                   {
15079                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
15080                      break;
15081                   }
15082                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15083                   {
15084                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
15085                      if(rrcVer->latest_RRC_Version.buf)
15086                      {
15087                         if(rrcVer->iE_Extensions)
15088                         {
15089                            if(rrcVer->iE_Extensions->list.array)
15090                            {
15091                               if(rrcVer->iE_Extensions->list.array[0])
15092                               {
15093                                  if(rrcVer->iE_Extensions->list.\
15094                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
15095                                  {
15096                                     free(rrcVer->iE_Extensions->list.\
15097                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
15098                                  }
15099                                  free(rrcVer->iE_Extensions->list.array[0]);
15100                               }
15101                               free(rrcVer->iE_Extensions->list.array);
15102                            }
15103                            free(rrcVer->iE_Extensions);
15104                         }
15105                         free(rrcVer->latest_RRC_Version.buf);
15106                      }
15107                      break;
15108
15109                   }
15110                default:
15111                   {
15112                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15113                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
15114                   }
15115             }
15116             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
15117          }
15118       }
15119       free(f1SetRspMsg->protocolIEs.list.array);
15120    }
15121 }
15122 /******************************************************************
15123  *
15124  * @brief Processes F1 Setup Response sent by CU
15125  *
15126  * @details
15127  *
15128  *    Function : procF1SetupRsp
15129  *
15130  *    Functionality: Processes F1 Setup Response sent by CU
15131  *
15132  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15133  * @return ROK     - success
15134  *         RFAILED - failure
15135  *
15136  * ****************************************************************/
15137 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
15138 {
15139    uint8_t ret = ROK;
15140    uint16_t idx =0;
15141    F1SetupResponse_t *f1SetRspMsg = NULLP;
15142    GNB_CU_Name_t     *cuName = NULLP;
15143    F1SetupRsp  f1SetRspDb;
15144    RRC_Version_t      *rrcVer =NULLP;
15145
15146    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
15147
15148    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
15149    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
15150
15151    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
15152    {
15153       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
15154       {
15155          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15156             {
15157                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
15158                      value.choice.Cells_to_be_Activated_List);
15159                break;
15160             }
15161          case ProtocolIE_ID_id_TransactionID:
15162             {
15163                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
15164                                     value.choice.TransactionID;
15165                break;
15166             }
15167          case ProtocolIE_ID_id_gNB_CU_Name:
15168             {
15169                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
15170                         value.choice.GNB_CU_Name;
15171                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
15172                break;
15173             }
15174          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15175             {
15176                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
15177                strcpy(f1SetRspDb.rrcVersion.rrcVer,
15178                      (const char*)rrcVer->latest_RRC_Version.buf);
15179                break;
15180             }
15181          default:
15182             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15183                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
15184       }
15185       duProcF1SetupRsp();
15186    }
15187
15188    freeAperDecodeF1SetupRsp(f1SetRspMsg);
15189
15190    duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
15191    DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
15192    if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
15193    {
15194       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the buf of F1setup response");
15195       return RFAILED;
15196    }
15197    memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
15198
15199    if(BuildAndSendE2SetupReq() != ROK)
15200    {
15201       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
15202       return RFAILED;
15203    }
15204    return ret;
15205 }
15206 /*******************************************************************
15207 *
15208 * @brief free GNB DU config update ack
15209 *
15210 * @details
15211 *
15212 *    Function : freeAperDecodeGnbDuAck
15213 *
15214 *    Functionality: Processes GNB DU config update ack And
15215 *                     added free part for the memory allocated by aper_decoder
15216 *
15217 * @params[in] F1AP_PDU_t ASN decoded F1AP message
15218 * @return ROK     - success
15219 *         RFAILED - failure
15220 *
15221 * ****************************************************************/
15222
15223 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
15224 {
15225    uint8_t ieIdx = 0;
15226
15227    if(gnbDuAck->protocolIEs.list.array)
15228    {
15229       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15230       {
15231          if(gnbDuAck->protocolIEs.list.array[ieIdx])
15232          {
15233             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
15234          }
15235       }
15236       free(gnbDuAck->protocolIEs.list.array);
15237    }
15238 }
15239
15240 /*******************************************************************
15241 *
15242 * @brief Building  result of gnb-du config update ack output
15243 *
15244 * @details
15245 *
15246 *    Function : duProcGnbDuCfgUpdAckMsg
15247 *
15248 *    Functionality:
15249 *        Building output of gnb-du config update ack
15250 *
15251 * @params[in] transId
15252 * @return void
15253 *
15254 * ****************************************************************/
15255
15256 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
15257 {
15258    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
15259    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
15260    uint16_t cellIdx =0, crnti=0;
15261    uint64_t cellId =0;
15262    CmLList *f1apPduNode = NULLP;
15263    ReservedF1apPduInfo *f1apPduInfo =NULLP;
15264    F1AP_PDU_t *f1apMsgPdu = NULLP;
15265    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
15266    BIT_STRING_t *cellIdentity=NULLP;
15267    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
15268    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
15269    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
15270
15271    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
15272    f1apPduNode = searchFromReservedF1apPduList(transId);
15273    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
15274    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
15275
15276    if(f1apMsgPdu)
15277    {
15278       if(f1apMsgPdu->choice.initiatingMessage)
15279       {
15280          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
15281          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
15282          {
15283             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
15284             {
15285                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
15286                   {
15287                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
15288                                      Served_Cells_To_Delete_List;
15289                      if(cellsToDelete->list.array)
15290                      {
15291                         if(cellsToDelete->list.array[arrIdx])
15292                         {
15293                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
15294                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
15295                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
15296                            {
15297                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
15298                               bitStringToInt(cellIdentity, &cellId);
15299
15300                               GET_CELL_IDX(cellId, cellIdx);
15301                               if(duCb.actvCellLst[cellIdx] != NULLP)
15302                               {
15303                                  duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
15304                               }
15305                            }
15306                         }
15307                      }
15308
15309                      if(duCb.actvCellLst[cellIdx] != NULLP)
15310                      {
15311                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
15312                         {
15313                            ret = duSendCellDeletReq(cellId);
15314                            if(ret == RFAILED)
15315                            {
15316                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
15317                               request for cellId[%lu]", cellId);
15318                            }
15319                         }
15320                         else
15321                         {
15322                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
15323                            while(totalActiveUe)
15324                            {
15325                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
15326                               {
15327                                  ueIdx++;
15328                                  continue;
15329                               }
15330
15331                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
15332                               GET_UE_ID(crnti,ueId);
15333                               /* Sending Ue Context release request only for maximum supporting UEs */
15334                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
15335                               if(ret == RFAILED)
15336                               {
15337                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
15338                                  request for cellId[%lu]", cellId);
15339                               }
15340                               ueIdx++;
15341                               totalActiveUe--;
15342                            }
15343                         }
15344                      }
15345                      else
15346                      {
15347                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%lu] not found", cellId);
15348                         ret = RFAILED;
15349                      }
15350                      break;
15351                   }
15352
15353                default:
15354                   break;
15355             }
15356          }
15357       }
15358    }
15359
15360    FreeDUConfigUpdate(f1apMsgPdu);
15361    deleteFromReservedF1apPduList(f1apPduNode);
15362    return ret;
15363 }
15364
15365 /*******************************************************************
15366 *
15367 * @brief Processes GNB DU config update ack
15368 *
15369 * @details
15370 *
15371 *    Function : procF1GNBDUCfgUpdAck
15372 *
15373 *    Functionality: added free part for the memory allocated by aper_decoder
15374 *
15375 * @params[in] F1AP_PDU_t *f1apMsg
15376 * @return void
15377 *
15378 * ****************************************************************/
15379 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
15380 {
15381    uint8_t ieIdx=0,transId=0;
15382    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
15383
15384    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
15385    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
15386
15387    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15388    {
15389       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
15390       {
15391          case ProtocolIE_ID_id_TransactionID:
15392             {
15393                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
15394                break;
15395             }
15396          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15397             {
15398                break;
15399             }
15400          default :
15401             {
15402                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
15403                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
15404                break;
15405             }
15406       }
15407    }
15408
15409    duProcGnbDuCfgUpdAckMsg(transId);
15410
15411 #if 0
15412    /* presently we are not supporting F1 Reset from DU to CU , we are only
15413     * supporting F1 Reset from CU to DU */
15414
15415    if(BuildAndSendF1ResetReq() != ROK)
15416    {
15417       return RFAILED;
15418    }
15419 #endif
15420
15421    freeAperDecodeGnbDuAck(gnbDuAck);
15422    return ROK;
15423 }
15424 /******************************************************************
15425 *
15426 * @brief free DL RRC Message Transfer allocated by aper_decoder
15427 *
15428 * @details
15429 *
15430 *    Function : freeAperDecodef1DlRrcMsg
15431 *
15432 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
15433 *
15434 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
15435 * @return ROK     - success
15436 *         RFAILED - failure
15437 *
15438 * ****************************************************************/
15439
15440 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
15441 {
15442    uint8_t ieIdx =0;
15443    RRCContainer_t *rrcContainer = NULLP;
15444
15445    if(f1DlRrcMsg->protocolIEs.list.array)
15446    {
15447       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
15448       {
15449          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
15450          {
15451             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
15452             {
15453                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15454                   break;
15455                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15456                   break;
15457                case ProtocolIE_ID_id_SRBID:
15458                   break;
15459                case ProtocolIE_ID_id_RRCContainer:
15460                   {
15461                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
15462                      free(rrcContainer->buf);
15463                   }
15464                case ProtocolIE_ID_id_ExecuteDuplication:
15465                   break;
15466                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15467                   break;
15468                   break;
15469             }
15470             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
15471          }
15472       }
15473       free(f1DlRrcMsg->protocolIEs.list.array);
15474    }
15475 }
15476 /******************************************************************
15477  *
15478  * @brief Processes DL RRC Message Transfer  sent by CU
15479  *
15480  * @details
15481  *
15482  *    Function : procF1DlRrcMsgTrans
15483  *
15484  *    Functionality: Processes DL RRC Message Transfer sent by CU
15485  *
15486  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15487  * @return ROK     - success
15488  *         RFAILED - failure
15489  *
15490  * ****************************************************************/
15491 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
15492 {
15493    uint8_t  idx, ret;
15494    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
15495    F1DlRrcMsg dlMsg;
15496    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
15497
15498    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
15499    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
15500
15501    ret = ROK;
15502
15503    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
15504    {
15505       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
15506       {
15507          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15508             {
15509                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
15510                break;
15511             }
15512          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15513             {
15514                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
15515                break;
15516             }
15517          case ProtocolIE_ID_id_SRBID:
15518             {
15519                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
15520                break;
15521             }
15522          case ProtocolIE_ID_id_ExecuteDuplication:
15523             dlMsg.execDup = true;
15524             break;
15525
15526          case ProtocolIE_ID_id_RRCContainer:
15527             {
15528                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
15529                {
15530                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
15531                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
15532                   if(dlMsg.rrcMsgPdu)
15533                   {
15534                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
15535                         dlMsg.rrcMsgSize);
15536                   }
15537                   else
15538                   {
15539                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
15540                      return RFAILED;
15541                   }
15542                }
15543                else
15544                {
15545                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
15546                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
15547                   return RFAILED;
15548                }
15549                break;
15550             }
15551          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15552             {
15553                dlMsg.deliveryStatRpt = true;
15554                break;
15555             }
15556          default:
15557             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
15558                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
15559       }
15560    }
15561
15562    ret = duProcDlRrcMsg(&dlMsg);
15563
15564    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
15565    return ret;
15566 }
15567 /*******************************************************************
15568  *
15569 * @brief Builds the DRB to be Setup Mod list
15570 *
15571 * @details
15572 *
15573 *    Function :
15574 *
15575 *    Functionality: Constructs the DRB to be Setup Mod list
15576 *
15577 * @params[in] DRBs_SetupMod_List_t *drbSet
15578 *
15579 * @return ROK     - success
15580 *         RFAILED - failure
15581 *
15582 * ****************************************************************/
15583 uint8_t BuildSrbSetupModList(SRBs_SetupMod_List_t *srbList, DuUeCfg *ueCfg)
15584 {
15585    uint8_t srbIdx = 0;
15586    struct SRBs_SetupMod_ItemIEs *srbItemIe;
15587
15588    srbList->list.count = ueCfg->numRlcLcs;
15589    srbList->list.size = srbList->list.count * sizeof(SRBs_SetupMod_ItemIEs_t *);
15590
15591    DU_ALLOC(srbList->list.array, srbList->list.size);
15592    if(srbList->list.array == NULLP)
15593    {
15594       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15595       return RFAILED;
15596    }
15597
15598    for(srbIdx = 0; srbIdx < srbList->list.count; srbIdx++)
15599    {
15600       DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15601       if(srbList->list.array[srbIdx] == NULLP)
15602       {
15603          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15604          return RFAILED;
15605       }
15606    }
15607
15608    for(srbIdx=0; srbIdx < srbList->list.count; srbIdx++)
15609    {
15610       srbItemIe = (struct SRBs_SetupMod_ItemIEs *)srbList->list.array[srbIdx];
15611       srbItemIe->id = ProtocolIE_ID_id_SRBs_SetupMod_Item;
15612       srbItemIe->criticality = Criticality_reject;
15613       srbItemIe->value.present = SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item;
15614       srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID = ueCfg->rlcLcCfg[srbIdx].rbId;
15615       srbItemIe->value.choice.SRBs_SetupMod_Item.lCID = ueCfg->rlcLcCfg[srbIdx].lcId;
15616    }
15617    return ROK;
15618 }
15619
15620 /*******************************************************************
15621  *
15622 * @brief Builds the DRB to be Setup Mod list
15623 *
15624 * @details
15625 *
15626 *    Function :
15627 *
15628 *    Functionality: Constructs the DRB to be Setup Mod list
15629 *
15630 * @params[in] DRBs_SetupMod_List_t *drbSet
15631 *
15632 * @return ROK     - success
15633 *         RFAILED - failure
15634 *
15635 * ****************************************************************/
15636
15637 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
15638 {
15639    uint8_t arrIdx =0;
15640    uint8_t drbCnt =0;
15641    struct DRBs_SetupMod_ItemIEs *drbItemIe;
15642
15643    drbCnt = ueCfg->numDrbSetupMod;
15644
15645    if(!drbCnt)
15646    {
15647       DU_LOG("\nINFO  -->  F1AP : BuildDrbToBeSetupModList(): No DRB information to avaialble to add");
15648       return ROK;
15649    }
15650
15651    drbSet->list.count = drbCnt;
15652    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
15653    DU_ALLOC(drbSet->list.array, drbSet->list.size);
15654    if(drbSet->list.array == NULLP)
15655    {
15656       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15657       return  RFAILED;
15658    }
15659    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
15660    {
15661       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15662       if(drbSet->list.array[arrIdx] == NULLP)
15663       {
15664               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15665               return  RFAILED;
15666       }
15667
15668       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
15669       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
15670       drbItemIe->criticality = Criticality_reject;
15671       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
15672       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
15673       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
15674       &ueCfg->upTnlInfo[arrIdx])!= ROK)
15675       {
15676          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
15677          return RFAILED;
15678       }
15679
15680    }
15681
15682    return ROK;
15683 }
15684 /*******************************************************************
15685 * @brief Free the memory allocated for DRB setup List
15686 *
15687 * @details
15688 *
15689 *    Function : FreeDrbSetupModList
15690 *
15691 *    Functionality:
15692 *       Free the memory allocated for DRB setup list
15693 *
15694 * @params[in] DRBs_Setup_List_t *
15695 * @return void
15696 *
15697 * ****************************************************************/
15698 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
15699 {
15700    uint8_t arrIdx = 0;
15701    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
15702
15703    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
15704    {
15705       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
15706       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
15707       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15708    }
15709    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
15710 }
15711
15712 /*******************************************************************
15713 * @brief Free the memory allocated for SRB setup List
15714 *
15715 * @details
15716 *
15717 *    Function : FreeSrbSetupModList
15718 *
15719 *    Functionality:
15720 *       Free the memory allocated for SRB setup list
15721 *
15722 * @params[in] SRBs_Setup_List_t *
15723 * @return void
15724 *
15725 * ****************************************************************/
15726 void FreeSrbSetupModList(SRBs_SetupMod_List_t *srbSetupList)
15727 {
15728    uint8_t srbIdx = 0;
15729
15730    for(srbIdx = 0; srbIdx < srbSetupList->list.count; srbIdx++)
15731       DU_FREE(srbSetupList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15732    DU_FREE(srbSetupList->list.array, srbSetupList->list.size);
15733 }
15734
15735 /*******************************************************************
15736 * @brief Free the memory allocated for UE Context Mod Response
15737 *
15738 * @details
15739 *
15740 *    Function : FreeUeContextModResp
15741 *
15742 *    Functionality:
15743 *       Free the memory allocated for UE Context Mod Response
15744 *
15745 * @params[in] F1AP_PDU_t *f1apMsg
15746 * @return void
15747 *
15748 * ****************************************************************/
15749
15750 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
15751 {
15752    uint8_t ieIdx;
15753    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15754    if(f1apMsg)
15755    {
15756       if(f1apMsg->choice.successfulOutcome)
15757       {
15758          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15759          if(ueContextModifyRes->protocolIEs.list.array)
15760          {
15761             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
15762             {
15763                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
15764                {
15765                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
15766                   {
15767                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15768                         break;
15769                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15770                         break;
15771                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
15772                         {
15773                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15774                             value.choice.DRBs_SetupMod_List));
15775                             break;
15776                         }
15777                      case ProtocolIE_ID_id_SRBs_SetupMod_List:
15778                         {
15779                            FreeSrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
15780                               SRBs_SetupMod_List));
15781                            break;
15782                         }
15783                   }
15784                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15785                }
15786
15787             }
15788             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15789          }
15790          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15791       }
15792       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
15793    }
15794 }
15795
15796 /*****************************************************************i
15797 *
15798 * @brief Creating the ue context modifcation response and sending
15799 *
15800 * @details
15801 *
15802 *    Function : BuildAndSendUeContextModRsp
15803 *
15804 *    Functionality:
15805 *         - Creating the ue context modifcation response
15806 *
15807 * @params[in] uint8_t cellId,uint8_t ueId
15808 * @return ROK     - success
15809 *         RFAILED - failure
15810 *
15811 * ****************************************************************/
15812 uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb)
15813 {
15814    uint8_t   ieIdx = 0, tnlIdx = 0, rbIdx = 0;
15815    uint8_t   elementCnt = 0;
15816    uint8_t   ret = RFAILED;
15817    F1AP_PDU_t *f1apMsg = NULLP;
15818    asn_enc_rval_t  encRetVal;
15819    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15820
15821    DU_LOG("\nINFO  -->  F1AP : Building UE context modification response\n");
15822
15823    while(true)
15824    {
15825       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
15826       if(f1apMsg == NULLP)
15827       {
15828          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
15829          break;
15830       }
15831
15832       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
15833
15834       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15835       if(f1apMsg->choice.successfulOutcome == NULLP)
15836       {
15837          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
15838          break;
15839       }
15840       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
15841       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
15842       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
15843
15844       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15845
15846       if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
15847       {
15848          if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
15849             elementCnt =3;
15850          else
15851             elementCnt =2;
15852       }
15853       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15854          elementCnt = 5;
15855       if(ueCb->f1UeDb->actionType == UE_CTXT_RRC_RECFG_COMPLETE)
15856          elementCnt = 2;
15857       ueContextModifyRes->protocolIEs.list.count = elementCnt;
15858       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
15859
15860       /* Initialize the UE context modification members */
15861       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15862       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
15863       {
15864          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
15865          break;
15866       }
15867
15868       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
15869       {
15870          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15871          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
15872          {
15873             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
15874             break;
15875          }
15876       }
15877
15878       ieIdx=0;
15879       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
15880       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15881       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
15882       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
15883       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
15884
15885       ieIdx++;
15886       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
15887       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15888       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
15889       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
15890       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
15891
15892       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15893       {
15894          ieIdx++;
15895          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCInformation;
15896          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15897          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
15898          UEContextModificationResponseIEs__value_PR_DUtoCURRCInformation;
15899          BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
15900       }
15901
15902       if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || ((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbSetupMod)))
15903       {
15904          ieIdx++;
15905          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
15906          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15907          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
15908                                                                            UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
15909          if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15910          {
15911             for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
15912             {
15913                if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
15914                {
15915                   memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
15916                }
15917             }
15918          }
15919          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15920                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
15921          if(ret != ROK)
15922          {
15923             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB setupmod List ");
15924             break;
15925          }
15926       }
15927
15928       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15929       {
15930          ieIdx++;
15931          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_SRBs_SetupMod_List;
15932          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15933          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
15934                                                                             UEContextModificationResponseIEs__value_PR_SRBs_SetupMod_List;
15935          for(rbIdx = 0; rbIdx < ueCb->rlcUeCfg.numLcs; rbIdx++)
15936          {
15937             if(ueCb->rlcUeCfg.rlcLcCfg[rbIdx].rbType == RB_TYPE_SRB)
15938             {
15939                memcpy(&ueCb->f1UeDb->duUeCfg.rlcLcCfg[ueCb->f1UeDb->duUeCfg.numRlcLcs++], &ueCb->rlcUeCfg.rlcLcCfg[rbIdx],\
15940                      sizeof(RlcBearerCfg));
15941             }
15942          }
15943          ret = BuildSrbSetupModList(&ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.SRBs_SetupMod_List, \
15944                &ueCb->f1UeDb->duUeCfg);
15945          if(ret != ROK)
15946          {
15947             DU_LOG( "\nERROR  -->  F1AP : Failed to build SRB setupmod List ");
15948             break;
15949          }
15950       }
15951
15952       freeF1UeDb(ueCb->f1UeDb);
15953       ueCb->f1UeDb = NULLP;
15954
15955       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15956
15957       /* Encode the F1SetupRequest type as APER */
15958       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15959       encBufSize = 0;
15960       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
15961
15962       /* Encode results */
15963       if(encRetVal.encoded == ENCODE_FAIL)
15964       {
15965          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
15966                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15967          ret = RFAILED;
15968          break;
15969       }
15970       else
15971       {
15972          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
15973 #ifdef DEBUG_ASN_PRINT
15974          for(int i=0; i< encBufSize; i++)
15975          {
15976             printf("%x",encBuf[i]);
15977          }
15978 #endif
15979       }
15980
15981       /* Sending  msg  */
15982       if(sendF1APMsg() != ROK)
15983       {
15984          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
15985          ret = RFAILED;
15986          break;
15987       }
15988
15989       ret = ROK;
15990       break;
15991    }
15992    FreeUeContextModResp(f1apMsg);
15993    return ret;
15994 }
15995 /*******************************************************************
15996  *
15997  * @brief Deallocating the memory allocated by the aper decoder
15998  *          for QOSInfo
15999  *
16000  * @details
16001  *
16002  *    Function : freeAperDecodeQosInfo
16003  *
16004  *    Functionality:  Deallocating the memory allocated for QOSInfo
16005  *
16006  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
16007  *
16008  * @return void
16009  *
16010  * ****************************************************************/
16011
16012 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
16013 {
16014    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
16015    {
16016       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
16017       {
16018          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
16019          {
16020             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
16021          }
16022          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
16023       }
16024       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
16025    }
16026 }
16027 /*******************************************************************
16028  *
16029  * @brief Deallocating the memory allocated by the aper decoder
16030  *          for UlTnlInfoforDrb
16031  *
16032  * @details
16033  *
16034  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
16035  *
16036  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
16037  *
16038  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
16039  *
16040  * @return void
16041  *
16042  * ****************************************************************/
16043 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
16044 {
16045    uint8_t arrIdx =0;
16046
16047    if(ulInfo->list.array)
16048    {
16049       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
16050       {
16051          if(ulInfo->list.array[arrIdx])
16052          {
16053             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
16054             {
16055                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
16056                {
16057                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
16058                   {
16059                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16060                            gTP_TEID.buf);
16061                   }
16062                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16063                         transportLayerAddress.buf);
16064                }
16065                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
16066             }
16067             free(ulInfo->list.array[arrIdx]);
16068          }
16069       }
16070       free(ulInfo->list.array);
16071    }
16072 }
16073 /*******************************************************************
16074  *
16075  * @brief Deallocating the memory allocated by the aper decoder
16076  *          for DrbSetupModItem
16077  *
16078  * @details
16079  *
16080  *    Function : freeAperDecodeDrbSetupModItem
16081  *
16082  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
16083  *
16084  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
16085  *
16086  * @return void
16087  *
16088  * ****************************************************************/
16089
16090 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
16091 {
16092    uint8_t arrIdx =0;
16093    SNSSAI_t *snssai =NULLP;
16094    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
16095
16096    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
16097    switch(drbItem->qoSInformation.present)
16098    {
16099       case QoSInformation_PR_NOTHING:
16100          break;
16101       case QoSInformation_PR_eUTRANQoS:
16102          {
16103             if(drbItem->qoSInformation.choice.eUTRANQoS)
16104             {
16105                free(drbItem->qoSInformation.choice.eUTRANQoS);
16106             }
16107             break;
16108          }
16109       case QoSInformation_PR_choice_extension:
16110          {
16111             if(drbItem->qoSInformation.choice.choice_extension)
16112             {
16113                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
16114                      DRB_Information.dRB_QoS);
16115                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
16116                if(snssai->sST.buf)
16117                {
16118                   free(snssai->sST.buf);
16119                }
16120                if(snssai->sD)
16121                {
16122                   if(snssai->sD->buf)
16123                   {
16124                      free(snssai->sD->buf);
16125                   }
16126                   free(snssai->sD);
16127                }
16128
16129                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
16130                          DRB_Information.flows_Mapped_To_DRB_List;
16131                if(flowMap->list.array)
16132                {
16133                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
16134                   {
16135                      if(flowMap->list.array[arrIdx] )
16136                      {
16137                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
16138                         free(flowMap->list.array[arrIdx]);
16139                      }
16140                   }
16141                   free(flowMap->list.array);
16142                }
16143
16144                free(drbItem->qoSInformation.choice.choice_extension);
16145             }
16146             break;
16147          }
16148
16149    }
16150    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
16151    if(drbItem->uLConfiguration)
16152    {
16153       free(drbItem->uLConfiguration);
16154    }
16155 }
16156
16157 /*******************************************************************
16158  *
16159  * @brief Deallocating the memory allocated by the aper decoder
16160  *          for DrbToBeSetupModList
16161  *
16162  * @details
16163  *
16164  *    Function : freeAperDecodeDrbToBeSetupModList
16165  *
16166  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
16167  *
16168  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
16169  *
16170  * @return void
16171  *
16172  * ****************************************************************/
16173
16174 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
16175 {
16176    uint8_t arrIdx =0;
16177    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
16178
16179    if(drbSet->list.array)
16180    {
16181       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
16182       {
16183          if(drbSet->list.array[arrIdx] != NULLP)
16184          {
16185             if(arrIdx == 0)
16186             {
16187                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
16188                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
16189             }
16190             free(drbSet->list.array[arrIdx]);
16191          }
16192       }
16193       free(drbSet->list.array);
16194    }
16195
16196 }
16197 /*******************************************************************
16198  *
16199  * @brief Deallocating the memory allocated by the aper decoder
16200  *          for UeContextModificationReqMsg
16201  *
16202  * @details
16203  *
16204  *    Function : freeAperDecodeUeContextModificationReqMsg
16205  *
16206  *    Functionality:  Deallocating memory allocated for
16207  *                  UeContextModificationReqMsg
16208  *
16209  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
16210  *
16211  * @return void
16212  *
16213  * ****************************************************************/
16214 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *ueContextModifyReq )
16215 {
16216    uint8_t arrIdx, ieId;
16217
16218    if(ueContextModifyReq->protocolIEs.list.array)
16219    {
16220       for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
16221       {
16222          if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
16223          {
16224             ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
16225             switch(ieId)
16226             {
16227                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16228                   break;
16229                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16230                   break;
16231                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
16232                   {
16233                      freeAperDecodeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
16234                            value.choice.DRBs_ToBeSetupMod_List);
16235                      break;
16236                   }
16237                case ProtocolIE_ID_id_TransmissionActionIndicator:
16238                   break;
16239                case ProtocolIE_ID_id_RRCContainer:
16240                   {
16241                      free(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf);
16242                   }
16243             }
16244             free(ueContextModifyReq->protocolIEs.list.array[arrIdx]);
16245          }
16246       }
16247       free(ueContextModifyReq->protocolIEs.list.array);
16248    }
16249 }
16250 /*******************************************************************
16251  *
16252  * @brief processing the F1 UeContextModificationReq
16253  *
16254  * @details
16255  *
16256  *    Function : procF1UeContextModificationReq
16257  *
16258  *    Functionality:  processing the F1 UeContextModificationReq
16259  *
16260  * @params[in] F1AP_PDU_t *f1apMsg
16261  *
16262  * @return
16263  * ****************************************************************/
16264 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
16265 {
16266    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
16267    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0;
16268    DuUeCb   *duUeCb = NULLP;
16269    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
16270    DRBs_ToBeModified_List_t *drbModifiedCfg;
16271    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
16272
16273    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
16274    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
16275    {
16276       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
16277       {
16278          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16279             {
16280                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
16281                break;
16282             }
16283          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16284             {
16285                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
16286                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
16287                {
16288                   if(duCb.actvCellLst[cellIdx])
16289                   {
16290                      if((duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == gnbDuUeF1apId)&&\
16291                            (duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbCuUeF1apId == gnbCuUeF1apId))
16292                      {
16293                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1];
16294                         if(duUeCb->f1UeDb == NULLP)
16295                         {
16296                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
16297                            duUeCb->f1UeDb->cellIdx = cellIdx;
16298                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
16299                         }
16300                         break;
16301                      }
16302                   }
16303                }
16304                if(duUeCb == NULLP)
16305                {
16306                   DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
16307                   ret = RFAILED;
16308                }
16309                break;
16310             }
16311
16312          case ProtocolIE_ID_id_RRCContainer:
16313             {
16314                /* Filling Dl RRC Msg Info */
16315                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
16316                if(!duUeCb->f1UeDb->dlRrcMsg)
16317                {
16318                   DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16319                         Memory allocation failed ");
16320                   ret = RFAILED;
16321                }
16322                else
16323                {
16324                   duUeCb->f1UeDb->dlRrcMsgPres = true;
16325                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
16326                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
16327                         &ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
16328                         value.choice.RRCContainer);
16329                }
16330
16331                break;
16332             }
16333
16334          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
16335          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
16336             {
16337                if(duUeCb->f1UeDb)
16338                {
16339                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
16340                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
16341                   {
16342                      drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16343                                       choice.DRBs_ToBeSetupMod_List;
16344
16345                      if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
16346                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
16347                      {
16348                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
16349                         ret = RFAILED;
16350                      }
16351                   }
16352
16353                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
16354                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
16355
16356                   {
16357                      drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16358                                       choice.DRBs_ToBeModified_List;
16359                      if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
16360                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
16361                      {
16362                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
16363                         ret = RFAILED;
16364                      }
16365                   }
16366                }
16367                break;
16368             }
16369
16370          case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
16371             {
16372                DU_LOG("\nINFO  -->  DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
16373                if(duUeCb->f1UeDb)
16374                {
16375                   duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
16376                }
16377                break;
16378             }
16379
16380          case ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator:
16381             {
16382                if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator == \
16383                   RRCReconfigurationCompleteIndicator_true)
16384                {
16385                   duUeCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE;
16386                }
16387                break;
16388             }
16389          case ProtocolIE_ID_id_TransmissionActionIndicator:
16390             {
16391                if(duUeCb->f1UeDb)
16392                {
16393                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator  == TransmissionActionIndicator_stop)
16394                   {
16395                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = STOP_TRANSMISSION;
16396                   }
16397                   else
16398                   {
16399                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = RESTART_TRANSMISSION;
16400                   }
16401                }
16402                break;
16403             }
16404
16405          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
16406             {
16407                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
16408                {
16409                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
16410                }
16411                break;
16412             }
16413
16414       }
16415    }
16416
16417    if(ret != RFAILED)
16418    {
16419       ret = duProcUeContextModReq(duUeCb);
16420    }
16421    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
16422    return ret;
16423 }
16424
16425 /*****************************************************************i
16426 *
16427 * @brief Free memory allocated for UE Context Release Request
16428 *
16429 * @details
16430 *
16431 *    Function : FreeUeContextReleaseReq
16432 *
16433 *    Functionality:
16434 *         - Free memory allocated for UE Context Release Request
16435 *
16436 * @params[in] F1AP_PDU_t *f1apMsg
16437 * @return void
16438 *
16439 * *************************************************************/
16440 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
16441 {
16442    uint8_t ieIdx;
16443    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
16444
16445    if(f1apMsg)
16446    {
16447       if(f1apMsg->choice.initiatingMessage)
16448       {
16449          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
16450          if(ueReleaseReq->protocolIEs.list.array)
16451          {
16452             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
16453             {
16454                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
16455             }
16456             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
16457          }
16458          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
16459       }
16460       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16461    }
16462
16463 }
16464 /*****************************************************************i
16465 *
16466 * @brief Build and Send UE Context Release Request
16467 *
16468 * @details
16469 *
16470 *    Function : BuildAndSendUeContextReleaseReq
16471 *
16472 *    Functionality:
16473 *         - Build and Send UE Context Release Request
16474 *
16475 * @params[in]
16476 * @return ROK     - success
16477 *         RFAILED - failure
16478 *
16479 * *************************************************************/
16480 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
16481 {
16482    bool memAllocFail = false;
16483    uint8_t ieIdx =0;
16484    uint8_t ret = RFAILED;
16485    uint16_t cellIdx =0;
16486    uint16_t crnti = 0;
16487    uint8_t  elementCnt = 0;
16488    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
16489    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
16490    asn_enc_rval_t encRetVal;
16491    F1AP_PDU_t *f1apMsg = NULLP;
16492    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
16493
16494    DU_LOG("\nINFO  --> Building the UE Context Release Request");
16495    do
16496    {
16497       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16498       if(f1apMsg == NULLP)
16499       {
16500          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
16501          break;
16502       }
16503
16504       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
16505       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
16506       if(f1apMsg->choice.initiatingMessage == NULLP)
16507       {
16508          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
16509          initiatingMessage");
16510          break;
16511       }
16512       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
16513       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
16514       f1apMsg->choice.initiatingMessage->value.present = \
16515       InitiatingMessage__value_PR_UEContextReleaseRequest;
16516
16517       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
16518
16519       elementCnt = 2;
16520
16521       ueReleaseReq->protocolIEs.list.count = elementCnt;
16522       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
16523
16524       /* Initialize the F1Setup members */
16525       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
16526       if(ueReleaseReq->protocolIEs.list.array == NULLP)
16527       {
16528          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
16529          break;
16530       }
16531       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
16532       {
16533          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
16534                sizeof(UEContextReleaseRequest_t));
16535          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
16536          {
16537             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
16538             memAllocFail = true;
16539             break;
16540          }
16541       }
16542       if(memAllocFail == true)
16543          break;
16544
16545       /* Fetching Ue Cb Info*/
16546       GET_CELL_IDX(cellId, cellIdx);
16547       if(duCb.actvCellLst[cellIdx] == NULLP)
16548       {
16549          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
16550          break;
16551       }
16552       else
16553       {
16554          GET_CRNTI(crnti, ueId);
16555          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
16556          {
16557             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
16558             break;
16559          }
16560          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
16561          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
16562       }
16563
16564       ieIdx=0;
16565       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16566       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16567       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
16568       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
16569       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16570
16571       ieIdx++;
16572       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16573       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16574       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
16575       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
16576       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16577
16578       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16579
16580       /* Encode the F1SetupRequest type as APER */
16581       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16582       encBufSize = 0;
16583       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
16584       /* Encode results */
16585       if(encRetVal.encoded == ENCODE_FAIL)
16586       {
16587          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
16588                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16589          break;
16590       }
16591       else
16592       {
16593          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
16594 #ifdef DEBUG_ASN_PRINT
16595          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
16596          {
16597             printf("%x",encBuf[ieIdx]);
16598          }
16599 #endif
16600       }
16601
16602       /* Sending msg */
16603       if(sendF1APMsg() != ROK)
16604       {
16605          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
16606          break;
16607       }
16608       ret = ROK;
16609       break;
16610    }while(true);
16611
16612    FreeUeContextReleaseReq(f1apMsg);
16613    return ret;
16614 }
16615 /*****************************************************************i
16616  *
16617  * @brief Free memory allocated for UE Context Release Complete
16618  *
16619  * @details
16620  *
16621  *    Function : FreeUeContextReleaseComplete
16622  *
16623  *    Functionality:
16624  *         - Free memory allocated for UE Context Release Complete
16625  *
16626  * @params[in] F1AP_PDU_t *f1apMsg
16627  * @return void
16628  *
16629  * *************************************************************/
16630 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
16631 {
16632    uint8_t ieIdx;
16633    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
16634
16635    if(f1apMsg)
16636    {
16637       if(f1apMsg->choice.successfulOutcome)
16638       {
16639          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
16640          if(ueReleaseComplete->protocolIEs.list.array)
16641          {
16642             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
16643             {
16644                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
16645             }
16646             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
16647          }
16648          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16649       }
16650       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16651    }
16652
16653 }
16654 /*****************************************************************i
16655  *
16656  * @brief Build and Send UE Context Release Complete
16657  *
16658  * @details
16659  *
16660  *    Function : BuildAndSendUeContextReleaseComplete
16661  *
16662  *    Functionality:
16663  *         - Build and Send UE Context Release Complete
16664  *
16665  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
16666  * @return ROK     - success
16667  *         RFAILED - failure
16668  *
16669  * *************************************************************/
16670 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
16671 {
16672    bool memAllocFail = false;
16673    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
16674    asn_enc_rval_t encRetVal;
16675    F1AP_PDU_t *f1apMsg = NULLP;
16676    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
16677
16678    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
16679    do
16680    {
16681       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16682       if(f1apMsg == NULLP)
16683       {
16684          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
16685          break;
16686       }
16687
16688       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
16689       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16690       if(f1apMsg->choice.successfulOutcome == NULLP)
16691       {
16692          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
16693                successfulOutcome");
16694          break;
16695       }
16696       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
16697       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
16698       f1apMsg->choice.successfulOutcome->value.present = \
16699       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
16700
16701       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
16702
16703       elementCnt = 2;
16704       ueReleaseComplete->protocolIEs.list.count = elementCnt;
16705       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
16706
16707       /* Initialize the UE Release Complete members */
16708       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
16709       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
16710       {
16711          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
16712          break;
16713       }
16714       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
16715       {
16716          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
16717                sizeof(UEContextReleaseComplete_t));
16718          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
16719          {
16720             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
16721             elements");
16722             memAllocFail = true;
16723             break;
16724          }
16725       }
16726       if(memAllocFail == true)
16727          break;
16728
16729
16730       ieIdx=0;
16731       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16732       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16733       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
16734       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
16735       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16736
16737       ieIdx++;
16738       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16739       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16740       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
16741       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
16742       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16743
16744       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16745
16746       /* Encode the F1SetupComplete type as APER */
16747       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16748       encBufSize = 0;
16749       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
16750       /* Encode results */
16751       if(encRetVal.encoded == ENCODE_FAIL)
16752       {
16753          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
16754                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16755          break;
16756       }
16757       else
16758       {
16759          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
16760 #ifdef DEBUG_ASN_PRINT
16761          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
16762          {
16763             printf("%x",encBuf[ieIdx]);
16764          }
16765 #endif
16766       }
16767
16768       /* Sending msg */
16769       if(sendF1APMsg() != ROK)
16770       {
16771          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
16772          break;
16773       }
16774       ret = ROK;
16775       break;
16776    }while(true);
16777
16778    if((ret == ROK) && (duCb.actvCellLst[cellId-1]) && (duCb.actvCellLst[cellId-1]->cellStatus == DELETION_IN_PROGRESS)
16779          && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
16780    {
16781       ret = duSendCellDeletReq(cellId);
16782       if(ret != ROK)
16783       {
16784          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
16785                Delete req for CellId");
16786       }
16787    }
16788    FreeUeContextReleaseComplete(f1apMsg);
16789    return ret;
16790
16791 }
16792
16793 /*******************************************************************
16794 *
16795 * @brief added free part for the memory allocated by aper_decoder
16796 *
16797 * @details
16798 *
16799 *    Function : freeAperDecodeUeContextReleaseCommand
16800 *
16801 *    Functionality: added free part for the memory allocated by aper_decoder
16802 *
16803 * @params[in] F1AP_PDU_t *f1apMsg
16804 * @return void
16805 *
16806 * ****************************************************************/
16807 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
16808 {
16809    uint8_t ieIdx=0;
16810    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
16811
16812    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
16813
16814    if(ueContextReleaseCommand->protocolIEs.list.array)
16815    {
16816       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
16817       {
16818          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
16819          {
16820             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
16821             {
16822                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16823                   break;
16824                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16825                   break;
16826                case ProtocolIE_ID_id_Cause:
16827                   break;
16828                case ProtocolIE_ID_id_RRCContainer:
16829                {
16830                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
16831                   {
16832                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
16833                   }
16834                   break;
16835                }
16836                default :
16837                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
16838                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
16839                   break;
16840             }
16841          }
16842          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
16843       }
16844       free(ueContextReleaseCommand->protocolIEs.list.array);
16845    }
16846 }
16847 /*******************************************************************
16848 *
16849 * @brief processing of UE Context Release Command
16850 *
16851 * @details
16852 *
16853 *    Function : procF1UeContextReleaseCommand
16854 *
16855 *    Functionality: processing of UE Context Release Command
16856 *
16857 * @params[in] F1AP_PDU_t *f1apMsg
16858 * @return void
16859 *
16860 * ****************************************************************/
16861 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
16862 {
16863    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
16864    uint16_t cellIdx =0, cellId = 0;
16865    bool ueIdxFound = false;
16866    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
16867    DuUeCb   *duUeCb = NULLP;
16868    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
16869
16870    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
16871
16872    if(ueContextReleaseCommand->protocolIEs.list.array)
16873    {
16874       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
16875       {
16876          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
16877          {
16878             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
16879             {
16880                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16881                   {
16882                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16883                                     value.choice.GNB_CU_UE_F1AP_ID;
16884                      break;
16885                   }
16886
16887                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16888                   {
16889                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16890                                      value.choice.GNB_DU_UE_F1AP_ID;
16891                      break;
16892                   }
16893
16894                case ProtocolIE_ID_id_Cause:
16895                   {
16896                      for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
16897                      {
16898                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
16899                         {
16900                            if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
16901                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
16902                            {
16903                               cellId = duCb.actvCellLst[cellIdx]->cellId;
16904                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
16905                               ueIdxFound = true;
16906                               break;
16907                            }
16908                         }
16909                         if(ueIdxFound == true)
16910                         {
16911                            break;
16912                         }
16913                      }
16914
16915                      if(!ueIdxFound)
16916                      {
16917                         DU_LOG("\nERROR  -->  F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
16918                         ret = RFAILED;
16919                      }
16920                      break;
16921                   }
16922
16923                case ProtocolIE_ID_id_RRCContainer:
16924                   {
16925                      if(ueIdxFound == true)
16926                      {
16927                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
16928                         if(duUeCb->f1UeDb)
16929                         {
16930                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
16931                            duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
16932                            duUeCb->f1UeDb->cellIdx = cellIdx;
16933                            /* Filling Dl RRC Msg Info */
16934                            DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
16935                            if(!duUeCb->f1UeDb->dlRrcMsg)
16936                            {
16937                               DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16938                                     Memory allocation failed ");
16939                               ret = RFAILED;
16940                            }
16941                            else
16942                            {
16943                               duUeCb->f1UeDb->dlRrcMsgPres = true;
16944                               memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
16945                               ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
16946                                     &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16947                                     value.choice.RRCContainer);
16948                            }
16949
16950                         }
16951                         else
16952                         {
16953                            DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16954                                  Memory allocation failed ");
16955                            ret = RFAILED;
16956
16957                         }
16958                      }
16959                      break;
16960                   }
16961                default :
16962                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
16963                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
16964                   break;
16965             }
16966          }
16967       }
16968    }
16969    if(ret != RFAILED)
16970    {
16971       duProcUeContextReleaseCommand(cellId, duUeCb);
16972    }
16973    freeAperDecodeUeContextReleaseCommand(f1apMsg);
16974    return ret;
16975 }
16976
16977 /**************************************************************
16978  *
16979  * @brief free the memory allocated by aper decoder for paging
16980  *
16981  * @details
16982  *
16983  *    Function : freeAperDecodePagingMsg
16984  *
16985  *    Functionality:
16986  *         - free the memory allocated by aper decoder for
16987  *         the paging f1ap msg
16988  *
16989  * @params[in] Paging_t   *paging
16990  * @return ROK     - success
16991  *         RFAILED - failure
16992  *
16993  ****************************************************************/
16994 void freeAperDecodePagingMsg(Paging_t   *paging)
16995 {
16996    uint8_t ieIdx, cellIdx;
16997    PagingCell_ItemIEs_t *pagingCellItemIes;
16998    PagingCell_Item_t *pagingCellItem;
16999    PagingCell_list_t  *pagingCelllist;
17000
17001    if(paging)
17002    {
17003       if(paging->protocolIEs.list.array)
17004       {
17005          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17006          {
17007             if(paging->protocolIEs.list.array[ieIdx])
17008             {
17009                switch(paging->protocolIEs.list.array[ieIdx]->id)
17010                {
17011                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17012                      {
17013                         free(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf);
17014                         break;
17015                      }
17016                   case ProtocolIE_ID_id_PagingIdentity:
17017                      {
17018                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
17019                         {
17020                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17021                            {
17022                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == \
17023                                     CNUEPagingIdentity_PR_fiveG_S_TMSI)
17024                               {
17025                                  free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf);
17026                               }
17027                               free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity);
17028                            }
17029                         }
17030                         break;
17031                      }
17032                   case ProtocolIE_ID_id_PagingCell_List:
17033                      {
17034                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17035                         if(pagingCelllist->list.array)
17036                         {
17037                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
17038                            {
17039                               if(pagingCelllist->list.array[cellIdx])
17040                               {
17041                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
17042                                  if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
17043                                  {
17044                                     pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17045                                     free(pagingCellItem->nRCGI.pLMN_Identity.buf);
17046                                     free(pagingCellItem->nRCGI.nRCellIdentity.buf);
17047                                  }
17048                                  free(pagingCelllist->list.array[cellIdx]);
17049                               }
17050                            }
17051                            free(pagingCelllist->list.array);
17052                         }
17053                         break;
17054                      }
17055                }
17056                free(paging->protocolIEs.list.array[ieIdx]);
17057             }
17058          }
17059          free(paging->protocolIEs.list.array);
17060
17061       }
17062    }
17063 }
17064
17065 /**************************************************************
17066  *
17067  * @brief processing the paging f1ap msg received from CU
17068  *
17069  * @details
17070  *
17071  *    Function : procPagingMsg
17072  *
17073  *    Functionality:
17074  *         - processing the paging f1ap msg received from CU
17075  *
17076  * @params[in] F1AP_PDU_t *f1apMsg
17077  * @return ROK     - success
17078  *         RFAILED - failure
17079  *
17080  *
17081  ****************************************************************/
17082 uint8_t procPagingMsg(F1AP_PDU_t *f1apMsg)
17083 {
17084    uint8_t ieIdx = 0, cellListIdx = 0;
17085    uint64_t cellId = 0;
17086    Paging_t   *paging = NULLP;
17087    PagingCell_list_t  *pagingCelllist = NULLP;
17088    PagingCell_ItemIEs_t *pagingCellItemIes = NULLP;
17089    PagingCell_Item_t *pagingCellItem = NULLP;
17090    DuPagingMsg *tmpPagingParam = NULLP;
17091
17092    paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
17093    if(paging)
17094    {
17095       if(paging->protocolIEs.list.array)
17096       {
17097          DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg));
17098          if(tmpPagingParam == NULLP)
17099          {
17100             DU_LOG("\nERROR  --> DU APP : Memory Allocation Failure in procPagingMsg");
17101             freeAperDecodePagingMsg(paging);
17102             return RFAILED;
17103          }
17104          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17105          {
17106             if(paging->protocolIEs.list.array[ieIdx])
17107             {
17108                switch(paging->protocolIEs.list.array[ieIdx]->id)
17109                {
17110                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17111                      {
17112                         bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10,\
17113                                          &tmpPagingParam->pagUeId);
17114                         break;
17115                      }
17116
17117                   case ProtocolIE_ID_id_PagingIdentity:
17118                      {
17119                         switch(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present)
17120                         {
17121                            case PagingIdentity_PR_cNUEPagingIdentity:
17122                               {
17123                                  if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17124                                  {
17125                                     bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.\
17126                                           cNUEPagingIdentity->choice.fiveG_S_TMSI, &tmpPagingParam->sTmsi);
17127
17128                                  }
17129                                  break;
17130                               }
17131                             case PagingIdentity_PR_rANUEPagingIdentity:
17132                                {
17133                                   /*TODO: This Identifier is specific to RAN Initiated Paging – Connected Mode Paging*/
17134                                   break;
17135                                }
17136                             default:
17137                                {
17138                                   DU_LOG("ERROR  -->  DU APP: Invalid UE Paging Identity, Skipping this Paging Message:");
17139                                   continue;
17140                                }
17141                         }
17142                      }
17143
17144                   case ProtocolIE_ID_id_PagingDRX:
17145                      {
17146                         tmpPagingParam->pagingDrxPres = TRUE;
17147                         tmpPagingParam->pagingDrx = convertPagingCycleEnumToValue(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX);
17148                         break;
17149                      }
17150
17151                   case ProtocolIE_ID_id_PagingPriority:
17152                      {
17153                         tmpPagingParam->pagPriority = paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority;
17154                         break;
17155                      }
17156
17157                   case ProtocolIE_ID_id_PagingCell_List:
17158                      {
17159                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17160                         if(pagingCelllist->list.array)
17161                         {
17162                            for(cellListIdx = 0; cellListIdx < pagingCelllist->list.count; cellListIdx++)
17163                            {
17164                               if(pagingCelllist->list.array[cellListIdx])
17165                               {
17166                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellListIdx];
17167                                  pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17168                                  bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId);
17169                                  if(processPagingMsg(cellId, tmpPagingParam) != ROK)
17170                                  {
17171                                     DU_LOG("\nERROR  --> DU APP : Paging Processing Failed at CellId:%lu",cellId);
17172                                     continue;
17173                                  }
17174                               }
17175                            }
17176                         }
17177                         break;
17178                      }
17179                    default:
17180                      {
17181                          DU_LOG("\nERROR  --> F1AP : Incorrect Paging IE option");
17182                          break;
17183                      }
17184                }
17185             }
17186          }
17187       }
17188    }
17189    DU_FREE(tmpPagingParam, sizeof(DuPagingMsg));
17190    freeAperDecodePagingMsg(paging);
17191
17192    return ROK;
17193 }
17194
17195 /**************************************************************
17196  *
17197  * @brief Handles received F1AP message and sends back response
17198  *
17199  * @details
17200  *
17201  *    Function : F1APMsgHdlr
17202  *
17203  *    Functionality:
17204  *         - Decodes received F1AP control message
17205  *         - Prepares response message, encodes and sends to SCTP
17206  *
17207  * @params[in]
17208  * @return ROK     - success
17209  *         RFAILED - failure
17210  *
17211  * ****************************************************************/
17212 void F1APMsgHdlr(Buffer *mBuf)
17213 {
17214    int i =0;
17215    char *recvBuf =NULLP;
17216    MsgLen copyCnt =0;
17217    MsgLen recvBufLen =0;
17218    F1AP_PDU_t *f1apMsg =NULLP;
17219    asn_dec_rval_t rval; /* Decoder return value */
17220    F1AP_PDU_t f1apasnmsg ;
17221    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
17222    ODU_PRINT_MSG(mBuf, 0,0);
17223
17224    /* Copy mBuf into char array to decode it */
17225    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
17226    DU_ALLOC(recvBuf, (Size)recvBufLen);
17227
17228    if(recvBuf == NULLP)
17229    {
17230       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
17231       return;
17232    }
17233    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
17234    {
17235       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
17236       return;
17237    }
17238
17239 #ifdef DEBUG_ASN_PRINT
17240    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
17241    for(i=0; i< recvBufLen; i++)
17242    {
17243       printf("%x",recvBuf[i]);
17244    }
17245 #endif
17246
17247    /* Decoding flat buffer into F1AP messsage */
17248    f1apMsg = &f1apasnmsg;
17249    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
17250
17251    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
17252
17253    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
17254    {
17255       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
17256       return;
17257    }
17258    printf("\n");
17259    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
17260
17261    switch(f1apMsg->present)
17262    {
17263       case F1AP_PDU_PR_successfulOutcome:
17264          {
17265             switch(f1apMsg->choice.successfulOutcome->value.present)
17266             {
17267                case SuccessfulOutcome__value_PR_ResetAcknowledge:
17268                   {
17269                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
17270                      break;
17271                   }
17272                case SuccessfulOutcome__value_PR_F1SetupResponse:
17273                   {
17274 #ifndef ODU_TEST_STUB
17275                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
17276 #endif
17277                      break;
17278                   }
17279
17280                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
17281                   {
17282                      procF1GNBDUCfgUpdAck(f1apMsg);
17283                      break;
17284                   }
17285
17286                default:
17287                   {
17288                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
17289                            f1apMsg->choice.successfulOutcome->value.present);
17290                      return;
17291                   }
17292             }/* End of switch(successfulOutcome) */
17293             free(f1apMsg->choice.successfulOutcome);
17294             break;
17295          }
17296       case F1AP_PDU_PR_initiatingMessage:
17297          {
17298             switch(f1apMsg->choice.initiatingMessage->value.present)
17299             {
17300                case InitiatingMessage__value_PR_Reset:
17301                   {
17302                      procF1ResetReq(f1apMsg);
17303                      break;
17304                   }
17305                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
17306                   {
17307                      procF1DlRrcMsgTrans(f1apMsg);
17308                      break;
17309                   }
17310                case InitiatingMessage__value_PR_UEContextSetupRequest:
17311                   {
17312                      procF1UeContextSetupReq(f1apMsg);
17313                      break;
17314                   }
17315                case InitiatingMessage__value_PR_UEContextModificationRequest:
17316                   {
17317                      procF1UeContextModificationReq(f1apMsg);
17318                      break;
17319                   }
17320                case InitiatingMessage__value_PR_UEContextReleaseCommand:
17321                   {
17322                       procF1UeContextReleaseCommand(f1apMsg);
17323                       break;
17324                   }
17325                case InitiatingMessage__value_PR_Paging:
17326                   {
17327                      procPagingMsg(f1apMsg);
17328                      break;
17329                   }
17330                default:
17331                   {
17332                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
17333                            f1apMsg->choice.initiatingMessage->value.present);
17334                      return;
17335                   }
17336             }/* End of switch(initiatingMessage) */
17337             free(f1apMsg->choice.initiatingMessage);
17338             break;
17339          }
17340
17341       default:
17342          {
17343             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
17344             return;
17345          }
17346          free(f1apMsg);
17347
17348    }/* End of switch(f1apMsg->present) */
17349
17350    DU_FREE(recvBuf, (Size)recvBufLen);
17351 } /* End of F1APMsgHdlr */
17352
17353 /**********************************************************************
17354   End of file
17355  **********************************************************************/