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 #ifdef NR_DRX
13511                case ProtocolIE_ID_id_DRXCycle:
13512                   {
13513                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleLength)
13514                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleLength);
13515                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleTimer)
13516                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleTimer);
13517                      break;
13518                   }
13519 #endif
13520                 default:
13521                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
13522             }
13523             free(ueSetReq->protocolIEs.list.array[ieIdx]);
13524          }
13525       }
13526       free(ueSetReq->protocolIEs.list.array);
13527    }
13528 }
13529 /*******************************************************************
13530  *
13531  * @brief Process UE context setup request from CU
13532  *
13533  * @details
13534  *
13535  *    Function : procF1UeContextSetupReq
13536  *
13537  *    Functionality: Process UE context setup request from CU
13538  *
13539  * @params[in] F1AP message
13540  * @return ROK     - success
13541  *         RFAILED - failure
13542  *
13543  * ****************************************************************/
13544 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
13545 {
13546    int8_t ueIdx = -1;
13547    uint8_t  ret=0, ieIdx=0, ieExtIdx = 0, servCellIdx = 0;
13548    bool ueCbFound = false, hoInProgress = false;
13549    uint16_t cellIdx=0;
13550    uint64_t nrCellId = 0;
13551    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
13552    DuUeCb   *duUeCb = NULL;
13553    UEContextSetupRequest_t   *ueSetReq = NULL;
13554    DRBs_ToBeSetup_List_t *drbCfg = NULL;
13555    CUtoDURRCInformation_t *rrcInfo = NULL;
13556    DRXCycle_t *drxCycle;
13557
13558    ret = ROK;
13559
13560    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
13561    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13562    {
13563       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13564       {
13565          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13566             {
13567                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13568                break;
13569             }
13570
13571          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13572             {
13573                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13574                break;
13575             }
13576
13577          case ProtocolIE_ID_id_SpCell_ID:
13578             {
13579                bitStringToInt(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
13580
13581                GET_CELL_IDX(nrCellId, cellIdx);
13582                if(!duCb.actvCellLst[cellIdx])
13583                {
13584                   DU_LOG("\nERROR  -->  F1AP : Cell Id [%lu] not found", nrCellId);
13585                   ret = RFAILED;
13586                }
13587                break;
13588             }
13589
13590          case ProtocolIE_ID_id_ServCellIndex:
13591             {
13592                servCellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
13593                break;
13594             }
13595
13596          case ProtocolIE_ID_id_SpCellULConfigured:
13597             {
13598                /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
13599                   UL, SUL or UL+SUL for the indicated cell for the UE */
13600                break;
13601             }
13602
13603          case ProtocolIE_ID_id_CUtoDURRCInformation:
13604             {
13605                rrcInfo = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation;
13606
13607                /* Search if UE context is present */
13608                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
13609                {
13610                   if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId)
13611                   {
13612                      ueCbFound = true;
13613                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13614                      break;
13615                   }
13616                }
13617
13618                /* Check if UE Handover scenario */
13619                if(rrcInfo->iE_Extensions)
13620                {
13621                   for(ieExtIdx = 0; ieExtIdx < rrcInfo->iE_Extensions->list.count; ieExtIdx++)
13622                   {
13623                      if(rrcInfo->iE_Extensions->list.array[ieExtIdx]->id == ProtocolIE_ID_id_HandoverPreparationInformation)
13624                      {
13625                         hoInProgress = true;
13626                         break;
13627                      }
13628                   }
13629                }
13630
13631                /* If UE context is not present, but UE is in handover */
13632                if(!ueCbFound && hoInProgress)
13633                {
13634                   ueIdx = getFreeBitFromUeBitMap(nrCellId);
13635                   if(ueIdx != -1)
13636                      gnbDuUeF1apId = ueIdx +1;
13637                   else
13638                   {
13639                      DU_LOG("\nERROR  -->  F1AP : No free UE IDX found in UE bit map of cell Id [%lu]", nrCellId);
13640                      ret = RFAILED;
13641                      break;
13642                   }
13643                   duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13644                   duUeCb->f1UeDb = NULL;
13645                   duUeCb->gnbCuUeF1apId = gnbCuUeF1apId;
13646                   duUeCb->gnbDuUeF1apId = gnbDuUeF1apId;
13647                   GET_CRNTI(duUeCb->crnti, duUeCb->gnbDuUeF1apId);
13648                   duUeCb->ueState = UE_HANDIN_IN_PROGRESS;
13649                }
13650
13651                if(duUeCb)
13652                {
13653                   DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13654                   if(duUeCb->f1UeDb)
13655                   {
13656                      memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13657                      duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
13658                      duUeCb->f1UeDb->cellIdx = cellIdx;
13659                   }
13660                   else
13661                   {
13662                      DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
13663                      ret = RFAILED;
13664                      break;
13665                   }
13666                }
13667                else
13668                {
13669                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13670                   ret = RFAILED;
13671                   break;
13672                }
13673
13674                /* Extract UE capability info */
13675                if(rrcInfo->uE_CapabilityRAT_ContainerList)
13676                {
13677                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = extractUeCapability(rrcInfo->uE_CapabilityRAT_ContainerList, duUeCb);
13678                }
13679
13680                /* Extract IE extension */
13681                if(rrcInfo->iE_Extensions)
13682                {
13683                   if(extractCuToDuRrcInfoExt(rrcInfo->iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
13684                   {
13685                      DU_LOG("\nERROR  -->  F1AP: Failed to extract CU to DU RRC information extension IE");
13686                      //TODO: Update the failure cause in ue context Setup Response
13687                      ret = RFAILED;
13688                   }
13689                }
13690                break;
13691             }
13692
13693 #ifdef NR_DRX
13694          case ProtocolIE_ID_id_DRXCycle:
13695             {
13696                duUeCb->f1UeDb->duUeCfg.drxCyclePres = true;
13697                drxCycle = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle;
13698                duUeCb->f1UeDb->duUeCfg.drxCycle.drxLongCycleLength =  convertLongDrxCycleLengthEnumToValue(drxCycle->longDRXCycleLength);
13699                if(drxCycle->shortDRXCycleLength)
13700                {
13701                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCyclePres = true;
13702                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycle = \
13703                   convertShortDrxCycleLengthEnumToValue(*(drxCycle->shortDRXCycleLength));
13704                }
13705                if(drxCycle->shortDRXCycleTimer)
13706                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycleTimer = *(drxCycle->shortDRXCycleTimer);
13707
13708                break;
13709             }
13710
13711 #endif
13712          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13713             {
13714                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
13715                         &duUeCb->f1UeDb->duUeCfg))
13716                {
13717                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
13718                   //TODO: Update the failure cause in ue context Setup Response
13719                   ret = RFAILED;
13720                }
13721                break;
13722             }
13723
13724          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13725             {
13726                drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
13727
13728                if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
13729                {
13730                   DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
13731                   //TODO: Update the failure cause in ue context Setup Response
13732                   ret = RFAILED;
13733                }
13734                break;
13735             }
13736          case ProtocolIE_ID_id_RRCContainer:
13737             {
13738                /* Filling Dl RRC Msg Info */
13739                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13740                if(!duUeCb->f1UeDb->dlRrcMsg)
13741                {
13742                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
13743                   ret = RFAILED;
13744                }
13745                else
13746                {
13747                   duUeCb->f1UeDb->dlRrcMsgPres = true;
13748                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13749                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13750                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
13751                }
13752                break;
13753             }
13754
13755          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13756             {
13757                if(duUeCb->f1UeDb->dlRrcMsg)
13758                {
13759                   if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
13760                   {
13761                      duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
13762                   }
13763                   else
13764                   {
13765                      DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
13766                   }
13767                }
13768                break;
13769             }
13770
13771          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
13772             {
13773                /* MaximumBitRate Uplink */
13774                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
13775                if(bitRateSize > 0)
13776                {
13777                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
13778                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
13779                   {
13780                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
13781                      ret = RFAILED;
13782                   }
13783                   else
13784                   {
13785                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
13786                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
13787                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
13788                   }
13789                }
13790                else
13791                   ret = RFAILED;
13792                break;
13793             }
13794
13795          default:
13796             {
13797                break;
13798             }
13799       } /* End of switch */
13800
13801       /* In case of any failure in any IE */
13802       if(ret == RFAILED)
13803       {
13804          // BuildAndSendUeContextSetupRsp(cellId,ueId);
13805          DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
13806          break;
13807       }
13808    } /* End of for loop of IEs */
13809
13810    if(ret == ROK)
13811       ret = duProcUeContextSetupRequest(duUeCb);
13812
13813    freeAperDecodeF1UeContextSetupReq(ueSetReq);
13814    return ret;
13815
13816 }
13817 /*******************************************************************
13818  * @brief Free the memory allocated for Dl Tunnel Info
13819  *
13820  * @details
13821  *
13822  *    Function : freeDlTnlInfo
13823  *
13824  *    Functionality:
13825  *       Free the memory allocated for Dl Tunnel Info
13826  *
13827  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
13828  * @return void
13829  *
13830  * ****************************************************************/
13831
13832 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
13833 {
13834    uint8_t arrIdx = 0;
13835
13836    if(tnlInfo)
13837    {
13838       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
13839       {
13840          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
13841                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
13842          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
13843                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
13844          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
13845          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
13846       }
13847       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
13848    }
13849 }
13850
13851 /*******************************************************************
13852  * @brief Free the memory allocated for DRB setup List
13853  *
13854  * @details
13855  *
13856  *    Function : freeDrbSetupList
13857  *
13858  *    Functionality:
13859  *       Free the memory allocated for DRB setup list
13860  *
13861  * @params[in] DRBs_Setup_List_t *
13862  * @return void
13863  *
13864  * ****************************************************************/
13865 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
13866 {
13867    uint8_t arrIdx = 0;
13868    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
13869
13870    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
13871    {
13872       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
13873       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
13874       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
13875    }
13876    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
13877 }
13878
13879 /*******************************************************************
13880  * @brief Free the memory allocated for UE Setup response
13881  *
13882  * @details
13883  *
13884  *    Function : FreeUeContextSetupRsp
13885  *
13886  *    Functionality:
13887  *       Free the memory allocated for UE Setup response
13888  *
13889  * @params[in] F1AP PDU for UE setup response
13890  * @return ROK     - success
13891  *         RFAILED - failure
13892  *
13893  * ****************************************************************/
13894 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
13895 {
13896    uint8_t idx;
13897    UEContextSetupResponse_t *ueSetRsp = NULLP;
13898
13899    if(f1apMsg)
13900    {
13901       if(f1apMsg->choice.successfulOutcome)
13902       {
13903          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
13904                     UEContextSetupResponse;
13905          if(ueSetRsp->protocolIEs.list.array)
13906          {
13907             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
13908             {
13909                if(ueSetRsp->protocolIEs.list.array[idx])
13910                {
13911                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
13912                   {
13913                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13914                         break;
13915                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13916                         break;
13917                      case ProtocolIE_ID_id_C_RNTI:
13918                         break;
13919                      case ProtocolIE_ID_id_DUtoCURRCInformation:
13920                         {
13921                            CellGroupConfig_t *cellGrpCfg = NULLP;
13922                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
13923                                          DUtoCURRCInformation.cellGroupConfig;
13924                            if(cellGrpCfg->buf != NULLP)
13925                            {
13926                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
13927                               cellGrpCfg = NULLP;
13928                            }
13929                            break;
13930                         }
13931                      case ProtocolIE_ID_id_DRBs_Setup_List:
13932                         {
13933                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
13934                            break;
13935                         }
13936                      default:
13937                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
13938                               ueSetRsp->protocolIEs.list.array[idx]->id);
13939                         break;
13940                   }
13941                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
13942                         sizeof(UEContextSetupResponseIEs_t));
13943                }
13944             }
13945             DU_FREE(ueSetRsp->protocolIEs.list.array, \
13946                   ueSetRsp->protocolIEs.list.size);
13947          }
13948          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13949       }
13950       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13951    }
13952 }
13953
13954 /*******************************************************************
13955  *
13956  * @brief Builds Ue context Setup Rsp DU To CU Info
13957  *
13958  * @details
13959  *
13960  *    Function : EncodeUeCntxtDuToCuInfo
13961  *
13962  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
13963  *
13964  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
13965  *
13966  * @return ROK     - success
13967  *         RFAILED - failure
13968  *
13969  ******************************************************************/
13970
13971 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
13972 {
13973    asn_enc_rval_t        encRetVal;
13974
13975    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
13976    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
13977    encBufSize = 0;
13978    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
13979    /* Encode results */
13980    if(encRetVal.encoded == ENCODE_FAIL)
13981    {
13982       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
13983             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13984       return RFAILED;
13985    }
13986    else
13987    {
13988       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
13989 #ifdef DEBUG_ASN_PRINT
13990       for(int i=0; i< encBufSize; i++)
13991       {
13992          printf("%x",encBuf[i]);
13993       }
13994 #endif
13995    }
13996    duToCuCellGrp->size = encBufSize;
13997    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
13998    if(!duToCuCellGrp->buf)
13999    {
14000       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
14001    }
14002    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
14003    return ROK;
14004 }
14005
14006 /*******************************************************************
14007  *
14008  * @brief Fills Dl Gtp tunnel Info
14009  *
14010  * @details
14011  *
14012  *    Function : fillGtpTunnelforDl
14013  *
14014  *    Functionality: Fills Dl Gtp tunnel Info
14015  *
14016  * @params[in]
14017  *
14018  * @return ROK     - success
14019  *         RFAILED - failure
14020  *
14021  * ****************************************************************/
14022
14023 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
14024 {
14025    uint8_t bufSize = 0;
14026
14027    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
14028    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
14029    if(gtpDl->transportLayerAddress.buf == NULLP)
14030    {
14031       return RFAILED;
14032    }
14033    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
14034
14035    /*GTP TEID*/
14036    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
14037    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
14038    if(gtpDl->gTP_TEID.buf == NULLP)
14039    {
14040       return RFAILED;
14041    }
14042    bufSize = 3; /*forming an Octect String*/
14043    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
14044
14045    return ROK;
14046 }
14047
14048 /*******************************************************************
14049  *
14050  * @brief Fills DL Tunnel Setup List
14051  *
14052  * @details
14053  *
14054  *    Function : fillDlTnlSetupList
14055  *
14056  *    Functionality: Fills the DL Tunnel Setup List
14057  *
14058  * @params[in]
14059  *
14060  * @return ROK     - success
14061  *         RFAILED - failure
14062  *
14063  * ****************************************************************/
14064
14065 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
14066 {
14067    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14068
14069    eleCount = 1;
14070    dlTnlInfo->list.count = eleCount;
14071    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
14072
14073    /* Initialize the DL Tnl Setup List Members */
14074    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
14075    if(dlTnlInfo->list.array == NULLP)
14076    {
14077       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
14078       ret = RFAILED;
14079    }
14080    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14081    {
14082       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
14083       if(dlTnlInfo->list.array[arrIdx] == NULLP)
14084       {
14085          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
14086          return RFAILED;
14087       }
14088       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
14089       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
14090       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
14091       {
14092          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
14093          return RFAILED;
14094       }
14095       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
14096                tnlCfg->tnlCfg1);
14097       if(ret != ROK)
14098          break;
14099    }
14100    return ret;
14101 }
14102
14103 /*******************************************************************
14104  *
14105  * @brief Fills the Drb Setup List for Ue Context Setup Response
14106  *
14107  * @details
14108  *
14109  *    Function : fillDrbSetupList
14110  *
14111  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
14112  *
14113  * @params[in]
14114  *
14115  * @return ROK     - success
14116  *         RFAILED - failure
14117  *
14118  * ****************************************************************/
14119 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
14120 {
14121    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14122    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
14123
14124    eleCount = ueCfg->numDrb;
14125    drbSetupList->list.count = eleCount;
14126    drbSetupList->list.size = \
14127         (eleCount * sizeof(DRBs_Setup_Item_t *));
14128
14129    /* Initialize the Drb Setup List Members */
14130    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
14131    if(drbSetupList->list.array == NULLP)
14132    {
14133       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
14134       ret = RFAILED;
14135    }
14136
14137    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14138    {
14139       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
14140       if(drbSetupList->list.array[arrIdx] == NULLP)
14141       {
14142          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
14143          return RFAILED;
14144       }
14145       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
14146       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
14147       drbItemIe->criticality = Criticality_reject;
14148       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
14149       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
14150       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
14151           &ueCfg->upTnlInfo[arrIdx]);
14152       if(ret != ROK)
14153          break;
14154    }
14155    return ret;
14156 }
14157
14158 /*******************************************************************
14159  *
14160  * @brief Builds and sends the UE Setup Response
14161  *
14162  * @details
14163  *
14164  *    Function : BuildAndSendUeContextSetupRsp
14165  *
14166  *    Functionality: Constructs the UE Setup Response and sends
14167  *                   it to the DU through SCTP.
14168  *
14169  * @params[in] uint8_t cellId,uint8_t ueId
14170  *
14171  * @return ROK     - success
14172  *         RFAILED - failure
14173  *
14174  * ****************************************************************/
14175 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
14176 {
14177    uint8_t   idx, ret, cellIdx, elementCnt;
14178    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
14179    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
14180    asn_enc_rval_t  encRetVal;        /* Encoder return value */
14181    F1AP_PDU_t               *f1apMsg = NULLP;
14182    UEContextSetupResponse_t *ueSetRsp = NULLP;
14183    DuUeCb                   *ueCb = NULLP;
14184
14185    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
14186
14187    while(true)
14188    {
14189       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14190       if(f1apMsg == NULLP)
14191       {
14192          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14193          ret = RFAILED;
14194          break;
14195       }
14196
14197       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
14198       DU_ALLOC(f1apMsg->choice.successfulOutcome,
14199             sizeof(SuccessfulOutcome_t));
14200       if(f1apMsg->choice.successfulOutcome == NULLP)
14201       {
14202          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
14203          ret = RFAILED;
14204          break;
14205       }
14206
14207       f1apMsg->choice.successfulOutcome->procedureCode = \
14208                                                          ProcedureCode_id_UEContextSetup;
14209       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
14210       f1apMsg->choice.successfulOutcome->value.present = \
14211                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
14212
14213       ueSetRsp =
14214          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
14215       elementCnt = 5;
14216       ueSetRsp->protocolIEs.list.count = elementCnt;
14217       ueSetRsp->protocolIEs.list.size = \
14218                                         elementCnt * sizeof(UEContextSetupResponse_t *);
14219
14220       /* Initialize the UESetup members */
14221       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
14222             ueSetRsp->protocolIEs.list.size);
14223       if(ueSetRsp->protocolIEs.list.array == NULLP)
14224       {
14225          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14226          ret = RFAILED;
14227          break;
14228       }
14229
14230       for(idx=0; idx<elementCnt; idx++)
14231       {
14232          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
14233                sizeof(UEContextSetupResponseIEs_t));
14234          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
14235          {
14236             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14237             ret = RFAILED;
14238             break;
14239          }
14240       }
14241       /* Fetching Ue Cb Info*/
14242       GET_CELL_IDX(cellId, cellIdx);
14243       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
14244       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
14245       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
14246
14247       idx = 0;
14248       /*GNB CU UE F1AP ID*/
14249       ueSetRsp->protocolIEs.list.array[idx]->id = \
14250                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14251       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14252       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14253                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
14254       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14255
14256       /*GNB DU UE F1AP ID*/
14257       idx++;
14258       ueSetRsp->protocolIEs.list.array[idx]->id = \
14259                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14260       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14261       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14262                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
14263       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14264
14265
14266       /*DUtoCURRC Information */
14267       idx++;
14268       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14269                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
14270       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14271       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14272                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
14273       BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
14274
14275       /* CRNTI */
14276       idx++;
14277       ueSetRsp->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_C_RNTI;
14278       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14279       ueSetRsp->protocolIEs.list.array[idx]->value.present = UEContextSetupResponseIEs__value_PR_C_RNTI;
14280       ueSetRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI = ueCb->crnti;
14281
14282
14283       /* Drb Setup List */
14284       idx++;
14285       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14286                                                    ProtocolIE_ID_id_DRBs_Setup_List;
14287       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14288       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14289                                                             UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
14290       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
14291             &ueCb->f1UeDb->duUeCfg);
14292       if(ret == RFAILED)
14293       {
14294          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
14295          freeF1UeDb(ueCb->f1UeDb);
14296          ueCb->f1UeDb = NULLP;
14297          break;
14298       }
14299
14300       /* Free UeContext Db created during Ue context Req */
14301       freeF1UeDb(ueCb->f1UeDb);
14302       ueCb->f1UeDb = NULLP;
14303
14304       /* TODO: To send Drb list */
14305       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14306
14307       /* Encode the UE context setup response type as APER */
14308       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
14309       encBufSize = 0;
14310       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14311             encBuf);
14312       /* Encode results */
14313       if(encRetVal.encoded == ENCODE_FAIL)
14314       {
14315          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
14316                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14317          ret = RFAILED;
14318          break;
14319       }
14320       else
14321       {
14322          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
14323 #ifdef DEBUG_ASN_PRINT
14324          for(int i=0; i< encBufSize; i++)
14325          {
14326             printf("%x",encBuf[i]);
14327          }
14328 #endif
14329       }
14330
14331       /* Sending  msg  */
14332       if(sendF1APMsg()  != ROK)
14333       {
14334          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
14335          ret = RFAILED;
14336          break;
14337       }
14338       break;
14339    }
14340    FreeUeContextSetupRsp(f1apMsg);
14341    return ret;
14342 }/* End of BuildAndSendUeContextSetupRsp */
14343 /*******************************************************************
14344 *
14345 * @brief  Build And Send Ue Context Rsp
14346 *
14347 * @details
14348 *
14349 *    Function : BuildAndSendUeCtxtRsp
14350 *
14351 *    Functionality : Build And Send Ue Context Rsp
14352
14353 * @params[in]
14354 * @return sucess = ROK
14355 *         failure = RFAILED
14356 *
14357 * ****************************************************************/
14358 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
14359 {
14360    uint8_t cellIdx = 0, actionType = 0;
14361
14362    GET_CELL_IDX(cellId, cellIdx);
14363    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
14364
14365    switch(actionType)
14366    {
14367       case UE_CTXT_SETUP:
14368          {
14369             if((BuildAndSendUeContextSetupRsp(cellId,ueId)) != ROK)
14370             {
14371                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextSetupRsp()");
14372                return RFAILED;
14373             }
14374             break;
14375          }
14376       case UE_CTXT_MOD:
14377          {
14378             if((BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1])) != ROK)
14379             {
14380                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextModRsp");
14381                return RFAILED;
14382             }
14383             break;
14384          }
14385       default:
14386          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
14387          break;
14388
14389    }
14390    return ROK;
14391 }
14392
14393 /*******************************************************************
14394  *
14395  * @brief deallocating the memory of  F1reset msg
14396  *
14397  * @details
14398  *
14399  *    Function : FreeF1ResetReq
14400  *
14401  *    Functionality :
14402  *         - freeing memory of F1reset request msg
14403  *
14404  * @params[in]
14405  * @return void
14406  *
14407  *
14408  * ****************************************************************/
14409 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
14410 {
14411    uint8_t idx =0 ;
14412    Reset_t *f1ResetMsg;
14413
14414    if(f1apMsg)
14415    {
14416       if(f1apMsg->choice.initiatingMessage)
14417       {
14418          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14419
14420          if(f1ResetMsg->protocolIEs.list.array)
14421          {
14422             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
14423             {
14424                if(f1ResetMsg->protocolIEs.list.array[idx])
14425                {
14426                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14427                }
14428             }
14429             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14430          }
14431          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14432       }
14433       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14434    }
14435 }
14436 /*******************************************************************
14437  *
14438  * @brief Build and Send F1reset request
14439  *
14440  * @details
14441  *
14442  *    Function : BuildAndSendF1ResetReq
14443  *
14444  *    Functionality:
14445  *         - Build and Send F1reset request msg
14446  *
14447  * @params[in]
14448  * @return ROK     - success
14449  *         RFAILED - failure
14450  *
14451  * ****************************************************************/
14452 uint8_t BuildAndSendF1ResetReq()
14453 {
14454    uint8_t          elementCnt=0;
14455    uint8_t          idx=0;
14456    uint8_t          ret= RFAILED;
14457    Reset_t          *f1ResetMsg = NULLP;
14458    F1AP_PDU_t       *f1apMsg = NULLP;
14459    asn_enc_rval_t   encRetVal;
14460    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
14461    do
14462    {
14463       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14464       if(f1apMsg == NULLP)
14465       {
14466          break;
14467       }
14468       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14469       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14470       if(f1apMsg->choice.initiatingMessage == NULLP)
14471       {
14472          break;
14473       }
14474       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
14475       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
14476       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
14477
14478       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14479
14480       elementCnt = 3;
14481       f1ResetMsg->protocolIEs.list.count = elementCnt;
14482       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
14483
14484       /* Initialize the F1Setup members */
14485       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14486       if(f1ResetMsg->protocolIEs.list.array == NULLP)
14487       {
14488          break;
14489       }
14490       for(idx=0; idx<elementCnt; idx++)
14491       {
14492          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14493          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
14494          {
14495             break;
14496          }
14497       }
14498
14499       /*TransactionID*/
14500       idx=0;
14501       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14502       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14503       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
14504       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
14505
14506       /*Cause*/
14507       idx++;
14508       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
14509       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
14510       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
14511       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
14512       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
14513
14514       /*Reset Type*/
14515       idx++;
14516       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
14517       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14518       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
14519       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
14520       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
14521
14522       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14523
14524       /* Encode the F1SetupRequest type as APER */
14525       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14526       encBufSize = 0;
14527       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14528             encBuf);
14529
14530       /* Encode results */
14531       if(encRetVal.encoded == ENCODE_FAIL)
14532       {
14533          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
14534                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14535          break;
14536       }
14537       else
14538       {
14539          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
14540 #ifdef DEBUG_ASN_PRINT
14541          for(idx=0; idx< encBufSize; idx++)
14542          {
14543             printf("%x",encBuf[idx]);
14544          }
14545 #endif
14546       }
14547
14548       if(sendF1APMsg() != ROK)
14549       {
14550          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
14551          break;
14552       }
14553
14554       ret = ROK;
14555       break;
14556    }while(true);
14557
14558    FreeF1ResetReq(f1apMsg);
14559    return ret;
14560 }
14561 /*******************************************************************
14562  *
14563  * @brief Build And Send F1ResetAck
14564  *
14565  * @details
14566  *
14567  *    Function : BuildAndSendF1ResetAck
14568  *
14569  *    Functionality:
14570  *         - Build And Send  F1ResetRSP
14571  *
14572  * @return ROK     - success
14573  *         RFAILED - failure
14574  *
14575  * ****************************************************************/
14576 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
14577 {
14578    uint8_t idx;
14579    ResetAcknowledge_t *f1ResetAck;
14580
14581    if(f1apMsg)
14582    {
14583       if(f1apMsg->choice.successfulOutcome)
14584       {
14585          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14586
14587          if(f1ResetAck->protocolIEs.list.array)
14588          {
14589             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
14590             {
14591                if(f1ResetAck->protocolIEs.list.array[idx])
14592                {
14593                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14594                }
14595             }
14596             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14597          }
14598          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14599       }
14600       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14601    }
14602 }
14603
14604 /*******************************************************************
14605  *
14606  * @brief Build And Send F1ResetAck
14607  *
14608  * @details
14609  *
14610  *    Function : BuildAndSendF1ResetAck
14611  *
14612  *    Functionality:
14613  *         - Build And Send  F1ResetRSP
14614  *
14615  *  @params[in]
14616  * @return ROK     - success
14617  *         RFAILED - failure
14618  *
14619  * ****************************************************************/
14620 uint8_t BuildAndSendF1ResetAck()
14621 {
14622    uint8_t                idx = 0;
14623    uint8_t                elementCnt = 0;
14624    uint8_t                ret = RFAILED;
14625    F1AP_PDU_t             *f1apMsg = NULL;
14626    ResetAcknowledge_t     *f1ResetAck = NULLP;
14627    asn_enc_rval_t         encRetVal;
14628    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
14629
14630    do{
14631       /* Allocate the memory for F1ResetRequest_t */
14632       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14633       if(f1apMsg == NULLP)
14634       {
14635          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14636          break;
14637       }
14638
14639       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
14640
14641       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14642       if(f1apMsg->choice.successfulOutcome == NULLP)
14643       {
14644          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14645          break;
14646       }
14647       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
14648       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
14649       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14650
14651       elementCnt = 1;
14652
14653       f1ResetAck->protocolIEs.list.count = elementCnt;
14654       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
14655
14656       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14657       if(f1ResetAck->protocolIEs.list.array == NULLP)
14658       {
14659          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
14660          break;
14661       }
14662
14663       for(idx=0; idx<elementCnt; idx++)
14664       {
14665          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14666          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
14667          {
14668             break;
14669          }
14670       }
14671       /*TransactionID*/
14672       idx = 0;
14673       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14674       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14675       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
14676       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
14677
14678       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14679
14680       /* Encode the F1SetupRequest type as UPER */
14681       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14682       encBufSize = 0;
14683       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
14684
14685       /* Check encode results */
14686       if(encRetVal.encoded == ENCODE_FAIL)
14687       {
14688          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
14689                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14690          break;
14691       }
14692       else
14693       {
14694          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
14695 #ifdef DEBUG_ASN_PRINT
14696          for(int i=0; i< encBufSize; i++)
14697          {
14698             printf("%x",encBuf[i]);
14699          }
14700 #endif
14701       }
14702       /* Sending msg */
14703       if(sendF1APMsg() != ROK)
14704       {
14705          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
14706          break;
14707       }
14708
14709       ret = ROK;
14710       break;
14711    }while(true);
14712
14713    FreeF1ResetAck(f1apMsg);
14714    return ret;
14715 }
14716 /******************************************************************
14717 *
14718 * @brief free F1 reset msg allocated by aper_decoder
14719 *
14720 * @details
14721 *
14722 *    Function : freeAperDecodeF1ResetMsg
14723 *
14724 *    Functionality: free F1 reset msg allocated by aper_decoder
14725 *
14726 * @params[in] Reset_t *f1ResetMsg
14727 * @return void
14728 *
14729 * ****************************************************************/
14730
14731 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
14732 {
14733    uint8_t ieIdx =0;
14734    if(f1ResetMsg->protocolIEs.list.array)
14735    {
14736       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
14737       {
14738          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
14739          {
14740             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
14741          }
14742       }
14743       free(f1ResetMsg->protocolIEs.list.array);
14744    }
14745 }
14746
14747 /******************************************************************
14748  *
14749  * @brief Processes DL RRC Message Transfer  sent by CU
14750  *
14751  * @details
14752  *
14753  *    Function : procF1ResetReq
14754  *
14755  *    Functionality: Processes DL RRC Message Transfer sent by CU
14756  *
14757  * @params[in] F1AP_PDU_t ASN decoded F1AP message
14758  * @return ROK     - success
14759  *         RFAILED - failure
14760  *
14761  * ****************************************************************/
14762 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
14763 {
14764    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
14765    uint8_t       ieIdx = 0;
14766    uint8_t        ret = ROK;
14767    Reset_t       *f1ResetMsg = NULLP;
14768
14769    DU_LOG("\nINFO   -->  Processing F1 reset request");
14770    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14771
14772    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
14773    {
14774       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
14775       {
14776          case ProtocolIE_ID_id_TransactionID:
14777             break;
14778
14779          case ProtocolIE_ID_id_Cause:
14780             break;
14781
14782          case ProtocolIE_ID_id_ResetType:
14783             {
14784                break;
14785             }
14786
14787          default:
14788             break;
14789       }
14790    }
14791    ret = BuildAndSendF1ResetAck();
14792    DU_LOG("\nINFO   -->  UE release is not supported for now");
14793
14794    freeAperDecodeF1ResetMsg(f1ResetMsg);
14795
14796    return ret;
14797 }
14798
14799 /*******************************************************************
14800  *
14801  * @brief free the RRC delivery report
14802  *
14803  * @details
14804  *
14805  *    Function : freeRrcDeliveryReport
14806  *
14807  *    Functionality: free the RRC delivery report
14808  *
14809  * @params[in]
14810  * @return ROK     - success
14811  *         RFAILED - failure
14812  *
14813  * ****************************************************************/
14814 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
14815 {
14816    uint8_t idx=0;
14817    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14818
14819    if(f1apMsg)
14820    {
14821       if(f1apMsg->choice.initiatingMessage)
14822       {
14823          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14824          if(rrcDeliveryReport->protocolIEs.list.array)
14825          {
14826             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
14827                   idx++)
14828             {
14829                if(rrcDeliveryReport->protocolIEs.list.array[idx])
14830                {
14831                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
14832                         sizeof(RRCDeliveryReportIEs_t));
14833                }
14834             }
14835             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
14836                   rrcDeliveryReport->protocolIEs.list.size);
14837          }
14838          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14839       }
14840       DU_FREE(f1apMsg,
14841             sizeof(F1AP_PDU_t));
14842    }
14843 }
14844
14845 /*******************************************************************
14846 *
14847 * @brief Builds and sends the RRC delivery report
14848 *
14849 * @details
14850 *
14851 *    Function : BuildAndSendRrcDeliveryReport
14852 *
14853 *    Functionality: Builds and sends the RRC delivery report
14854 *
14855 * @params[in]
14856 *
14857 * @return ROK     - success
14858 *         RFAILED - failure
14859 *
14860 * ****************************************************************/
14861 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
14862    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
14863 {
14864    uint8_t             ret = RFAILED;
14865    uint8_t             idx    = 0;
14866    uint8_t             idx1   = 0;
14867    uint8_t             elementCnt = 0;
14868    F1AP_PDU_t          *f1apMsg = NULLP;
14869    asn_enc_rval_t      encRetVal;
14870    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14871
14872    do{
14873
14874       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
14875       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14876       if(f1apMsg == NULLP)
14877       {
14878          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14879          break;
14880       }
14881       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14882       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14883       if(f1apMsg->choice.initiatingMessage == NULLP)
14884       {
14885          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
14886          break;
14887       }
14888       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
14889       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
14890       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
14891
14892       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14893       elementCnt = 4;
14894       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
14895       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
14896
14897       /* Initialize the F1Setup members */
14898       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
14899       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
14900       {
14901          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
14902          break;
14903       }
14904       for(idx =0 ;idx <elementCnt; idx++)
14905       {
14906          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
14907          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
14908          {
14909             break;
14910          }
14911       }
14912
14913       idx1 = 0;
14914
14915       /*GNB CU UE F1AP ID*/
14916       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14917       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
14918       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
14919       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14920
14921       /*GNB DU UE F1AP ID*/
14922       idx1++;
14923       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14924       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
14925       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
14926       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14927
14928       /*RRC delivery status*/
14929       idx1++;
14930       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
14931       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
14932       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
14933       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
14934       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
14935       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
14936       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
14937
14938       /* SRB ID */
14939       idx1++;
14940       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
14941       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
14942       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
14943       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
14944
14945       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14946
14947       /* Encode the RRC DELIVERY REPORT type as APER */
14948       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14949       encBufSize = 0;
14950       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14951             encBuf);
14952
14953       /* Encode results */
14954       if(encRetVal.encoded == ENCODE_FAIL)
14955       {
14956          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
14957                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14958          break;
14959       }
14960       else
14961       {
14962          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
14963 #ifdef DEBUG_ASN_PRINT
14964          for(idx=0; idx< encBufSize; idx++)
14965          {
14966             printf("%x",encBuf[idx]);
14967          }
14968 #endif
14969       }
14970
14971       /* Sending msg */
14972       if(sendF1APMsg() != ROK)
14973       {
14974          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
14975          break;
14976       }
14977       ret = ROK;
14978       break;
14979
14980    }while(true);
14981
14982    freeRrcDeliveryReport(f1apMsg);
14983    return ret;
14984 }
14985
14986 /*******************************************************************
14987  *
14988  * @brief Processes cells to be activated
14989  *
14990  * @details
14991  *
14992  *    Function : extractCellsToBeActivated
14993  *
14994  *    Functionality:
14995  *      - Processes cells to be activated list received in F1SetupRsp
14996  *
14997  * @params[in] void
14998  * @return ROK     - success
14999  *         RFAILED - failure
15000  *
15001  * ****************************************************************/
15002
15003 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
15004 {
15005    uint8_t  ret = ROK;
15006    uint16_t idx, pci = 0;
15007    uint64_t nci;
15008    Cells_to_be_Activated_List_Item_t cell;
15009
15010    for(idx=0; idx<cellsToActivate.list.count; idx++)
15011    {
15012       nci = 0;
15013       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
15014       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
15015
15016       if(cell.nRPCI)
15017       {
15018          pci = *cell.nRPCI;
15019       }
15020       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
15021    }
15022    return ret;
15023 }
15024 /******************************************************************
15025 *
15026 * @brief Processes F1 Setup Response allocated by aper_decoder
15027 *
15028 * @details
15029 *
15030 *    Function : freeF1SetupRsp
15031 *
15032 *    Functionality: free F1 Setup Response allocated by aper_decoder
15033 *
15034 * @params[in] F1SetupResponse_t *f1SetRspMsg
15035 * @return void
15036 *
15037 * ****************************************************************/
15038
15039 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
15040 {
15041    uint8_t ieIdx =0;
15042    uint8_t arrIdx =0;
15043    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
15044    RRC_Version_t      *rrcVer =NULLP;
15045
15046    if(f1SetRspMsg->protocolIEs.list.array)
15047    {
15048       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
15049       {
15050          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
15051          {
15052             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
15053             {
15054                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15055                   {
15056                      cellToActivate =
15057                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
15058                      if(cellToActivate->list.array)
15059                      {
15060                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
15061                         {
15062                            if(cellToActivate->list.array[arrIdx])
15063                            {
15064
15065                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
15066                               pLMN_Identity.buf)
15067                               {
15068                                  if(cellToActivate->list.array[0]->value.choice.\
15069                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
15070                                  {
15071                                     free(cellToActivate->list.array[0]->value.choice.\
15072                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
15073                                  }
15074
15075                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
15076                                        nRCGI.pLMN_Identity.buf);
15077                               }
15078                               free(cellToActivate->list.array[arrIdx]);
15079                            }
15080                         }
15081                         free(cellToActivate->list.array);
15082                      }
15083                      break;
15084                   }
15085                case ProtocolIE_ID_id_TransactionID:
15086                   {
15087                      break;
15088                   }
15089                case ProtocolIE_ID_id_gNB_CU_Name:
15090                   {
15091                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
15092                      break;
15093                   }
15094                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15095                   {
15096                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
15097                      if(rrcVer->latest_RRC_Version.buf)
15098                      {
15099                         if(rrcVer->iE_Extensions)
15100                         {
15101                            if(rrcVer->iE_Extensions->list.array)
15102                            {
15103                               if(rrcVer->iE_Extensions->list.array[0])
15104                               {
15105                                  if(rrcVer->iE_Extensions->list.\
15106                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
15107                                  {
15108                                     free(rrcVer->iE_Extensions->list.\
15109                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
15110                                  }
15111                                  free(rrcVer->iE_Extensions->list.array[0]);
15112                               }
15113                               free(rrcVer->iE_Extensions->list.array);
15114                            }
15115                            free(rrcVer->iE_Extensions);
15116                         }
15117                         free(rrcVer->latest_RRC_Version.buf);
15118                      }
15119                      break;
15120
15121                   }
15122                default:
15123                   {
15124                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15125                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
15126                   }
15127             }
15128             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
15129          }
15130       }
15131       free(f1SetRspMsg->protocolIEs.list.array);
15132    }
15133 }
15134 /******************************************************************
15135  *
15136  * @brief Processes F1 Setup Response sent by CU
15137  *
15138  * @details
15139  *
15140  *    Function : procF1SetupRsp
15141  *
15142  *    Functionality: Processes F1 Setup Response sent by CU
15143  *
15144  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15145  * @return ROK     - success
15146  *         RFAILED - failure
15147  *
15148  * ****************************************************************/
15149 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
15150 {
15151    uint8_t ret = ROK;
15152    uint16_t idx =0;
15153    F1SetupResponse_t *f1SetRspMsg = NULLP;
15154    GNB_CU_Name_t     *cuName = NULLP;
15155    F1SetupRsp  f1SetRspDb;
15156    RRC_Version_t      *rrcVer =NULLP;
15157
15158    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
15159
15160    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
15161    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
15162
15163    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
15164    {
15165       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
15166       {
15167          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15168             {
15169                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
15170                      value.choice.Cells_to_be_Activated_List);
15171                break;
15172             }
15173          case ProtocolIE_ID_id_TransactionID:
15174             {
15175                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
15176                                     value.choice.TransactionID;
15177                break;
15178             }
15179          case ProtocolIE_ID_id_gNB_CU_Name:
15180             {
15181                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
15182                         value.choice.GNB_CU_Name;
15183                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
15184                break;
15185             }
15186          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15187             {
15188                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
15189                strcpy(f1SetRspDb.rrcVersion.rrcVer,
15190                      (const char*)rrcVer->latest_RRC_Version.buf);
15191                break;
15192             }
15193          default:
15194             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15195                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
15196       }
15197       duProcF1SetupRsp();
15198    }
15199
15200    freeAperDecodeF1SetupRsp(f1SetRspMsg);
15201
15202    duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
15203    DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
15204    if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
15205    {
15206       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the buf of F1setup response");
15207       return RFAILED;
15208    }
15209    memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
15210
15211    if(BuildAndSendE2SetupReq() != ROK)
15212    {
15213       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
15214       return RFAILED;
15215    }
15216    return ret;
15217 }
15218 /*******************************************************************
15219 *
15220 * @brief free GNB DU config update ack
15221 *
15222 * @details
15223 *
15224 *    Function : freeAperDecodeGnbDuAck
15225 *
15226 *    Functionality: Processes GNB DU config update ack And
15227 *                     added free part for the memory allocated by aper_decoder
15228 *
15229 * @params[in] F1AP_PDU_t ASN decoded F1AP message
15230 * @return ROK     - success
15231 *         RFAILED - failure
15232 *
15233 * ****************************************************************/
15234
15235 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
15236 {
15237    uint8_t ieIdx = 0;
15238
15239    if(gnbDuAck->protocolIEs.list.array)
15240    {
15241       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15242       {
15243          if(gnbDuAck->protocolIEs.list.array[ieIdx])
15244          {
15245             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
15246          }
15247       }
15248       free(gnbDuAck->protocolIEs.list.array);
15249    }
15250 }
15251
15252 /*******************************************************************
15253 *
15254 * @brief Building  result of gnb-du config update ack output
15255 *
15256 * @details
15257 *
15258 *    Function : duProcGnbDuCfgUpdAckMsg
15259 *
15260 *    Functionality:
15261 *        Building output of gnb-du config update ack
15262 *
15263 * @params[in] transId
15264 * @return void
15265 *
15266 * ****************************************************************/
15267
15268 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
15269 {
15270    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
15271    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
15272    uint16_t cellIdx =0, crnti=0;
15273    uint64_t cellId =0;
15274    CmLList *f1apPduNode = NULLP;
15275    ReservedF1apPduInfo *f1apPduInfo =NULLP;
15276    F1AP_PDU_t *f1apMsgPdu = NULLP;
15277    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
15278    BIT_STRING_t *cellIdentity=NULLP;
15279    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
15280    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
15281    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
15282
15283    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
15284    f1apPduNode = searchFromReservedF1apPduList(transId);
15285    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
15286    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
15287
15288    if(f1apMsgPdu)
15289    {
15290       if(f1apMsgPdu->choice.initiatingMessage)
15291       {
15292          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
15293          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
15294          {
15295             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
15296             {
15297                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
15298                   {
15299                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
15300                                      Served_Cells_To_Delete_List;
15301                      if(cellsToDelete->list.array)
15302                      {
15303                         if(cellsToDelete->list.array[arrIdx])
15304                         {
15305                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
15306                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
15307                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
15308                            {
15309                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
15310                               bitStringToInt(cellIdentity, &cellId);
15311
15312                               GET_CELL_IDX(cellId, cellIdx);
15313                               if(duCb.actvCellLst[cellIdx] != NULLP)
15314                               {
15315                                  duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
15316                               }
15317                            }
15318                         }
15319                      }
15320
15321                      if(duCb.actvCellLst[cellIdx] != NULLP)
15322                      {
15323                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
15324                         {
15325                            ret = duSendCellDeletReq(cellId);
15326                            if(ret == RFAILED)
15327                            {
15328                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
15329                               request for cellId[%lu]", cellId);
15330                            }
15331                         }
15332                         else
15333                         {
15334                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
15335                            while(totalActiveUe)
15336                            {
15337                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
15338                               {
15339                                  ueIdx++;
15340                                  continue;
15341                               }
15342
15343                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
15344                               GET_UE_ID(crnti,ueId);
15345                               /* Sending Ue Context release request only for maximum supporting UEs */
15346                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
15347                               if(ret == RFAILED)
15348                               {
15349                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
15350                                  request for cellId[%lu]", cellId);
15351                               }
15352                               ueIdx++;
15353                               totalActiveUe--;
15354                            }
15355                         }
15356                      }
15357                      else
15358                      {
15359                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%lu] not found", cellId);
15360                         ret = RFAILED;
15361                      }
15362                      break;
15363                   }
15364
15365                default:
15366                   break;
15367             }
15368          }
15369       }
15370    }
15371
15372    FreeDUConfigUpdate(f1apMsgPdu);
15373    deleteFromReservedF1apPduList(f1apPduNode);
15374    return ret;
15375 }
15376
15377 /*******************************************************************
15378 *
15379 * @brief Processes GNB DU config update ack
15380 *
15381 * @details
15382 *
15383 *    Function : procF1GNBDUCfgUpdAck
15384 *
15385 *    Functionality: added free part for the memory allocated by aper_decoder
15386 *
15387 * @params[in] F1AP_PDU_t *f1apMsg
15388 * @return void
15389 *
15390 * ****************************************************************/
15391 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
15392 {
15393    uint8_t ieIdx=0,transId=0;
15394    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
15395
15396    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
15397    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
15398
15399    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15400    {
15401       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
15402       {
15403          case ProtocolIE_ID_id_TransactionID:
15404             {
15405                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
15406                break;
15407             }
15408          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15409             {
15410                break;
15411             }
15412          default :
15413             {
15414                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
15415                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
15416                break;
15417             }
15418       }
15419    }
15420
15421    duProcGnbDuCfgUpdAckMsg(transId);
15422
15423 #if 0
15424    /* presently we are not supporting F1 Reset from DU to CU , we are only
15425     * supporting F1 Reset from CU to DU */
15426
15427    if(BuildAndSendF1ResetReq() != ROK)
15428    {
15429       return RFAILED;
15430    }
15431 #endif
15432
15433    freeAperDecodeGnbDuAck(gnbDuAck);
15434    return ROK;
15435 }
15436 /******************************************************************
15437 *
15438 * @brief free DL RRC Message Transfer allocated by aper_decoder
15439 *
15440 * @details
15441 *
15442 *    Function : freeAperDecodef1DlRrcMsg
15443 *
15444 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
15445 *
15446 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
15447 * @return ROK     - success
15448 *         RFAILED - failure
15449 *
15450 * ****************************************************************/
15451
15452 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
15453 {
15454    uint8_t ieIdx =0;
15455    RRCContainer_t *rrcContainer = NULLP;
15456
15457    if(f1DlRrcMsg->protocolIEs.list.array)
15458    {
15459       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
15460       {
15461          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
15462          {
15463             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
15464             {
15465                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15466                   break;
15467                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15468                   break;
15469                case ProtocolIE_ID_id_SRBID:
15470                   break;
15471                case ProtocolIE_ID_id_RRCContainer:
15472                   {
15473                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
15474                      free(rrcContainer->buf);
15475                   }
15476                case ProtocolIE_ID_id_ExecuteDuplication:
15477                   break;
15478                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15479                   break;
15480                   break;
15481             }
15482             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
15483          }
15484       }
15485       free(f1DlRrcMsg->protocolIEs.list.array);
15486    }
15487 }
15488 /******************************************************************
15489  *
15490  * @brief Processes DL RRC Message Transfer  sent by CU
15491  *
15492  * @details
15493  *
15494  *    Function : procF1DlRrcMsgTrans
15495  *
15496  *    Functionality: Processes DL RRC Message Transfer sent by CU
15497  *
15498  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15499  * @return ROK     - success
15500  *         RFAILED - failure
15501  *
15502  * ****************************************************************/
15503 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
15504 {
15505    uint8_t  idx, ret;
15506    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
15507    F1DlRrcMsg dlMsg;
15508    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
15509
15510    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
15511    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
15512
15513    ret = ROK;
15514
15515    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
15516    {
15517       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
15518       {
15519          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15520             {
15521                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
15522                break;
15523             }
15524          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15525             {
15526                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
15527                break;
15528             }
15529          case ProtocolIE_ID_id_SRBID:
15530             {
15531                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
15532                break;
15533             }
15534          case ProtocolIE_ID_id_ExecuteDuplication:
15535             dlMsg.execDup = true;
15536             break;
15537
15538          case ProtocolIE_ID_id_RRCContainer:
15539             {
15540                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
15541                {
15542                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
15543                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
15544                   if(dlMsg.rrcMsgPdu)
15545                   {
15546                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
15547                         dlMsg.rrcMsgSize);
15548                   }
15549                   else
15550                   {
15551                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
15552                      return RFAILED;
15553                   }
15554                }
15555                else
15556                {
15557                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
15558                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
15559                   return RFAILED;
15560                }
15561                break;
15562             }
15563          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15564             {
15565                dlMsg.deliveryStatRpt = true;
15566                break;
15567             }
15568          default:
15569             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
15570                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
15571       }
15572    }
15573
15574    ret = duProcDlRrcMsg(&dlMsg);
15575
15576    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
15577    return ret;
15578 }
15579 /*******************************************************************
15580  *
15581 * @brief Builds the DRB to be Setup Mod list
15582 *
15583 * @details
15584 *
15585 *    Function :
15586 *
15587 *    Functionality: Constructs the DRB to be Setup Mod list
15588 *
15589 * @params[in] DRBs_SetupMod_List_t *drbSet
15590 *
15591 * @return ROK     - success
15592 *         RFAILED - failure
15593 *
15594 * ****************************************************************/
15595 uint8_t BuildSrbSetupModList(SRBs_SetupMod_List_t *srbList, DuUeCfg *ueCfg)
15596 {
15597    uint8_t srbIdx = 0;
15598    struct SRBs_SetupMod_ItemIEs *srbItemIe;
15599
15600    srbList->list.count = ueCfg->numRlcLcs;
15601    srbList->list.size = srbList->list.count * sizeof(SRBs_SetupMod_ItemIEs_t *);
15602
15603    DU_ALLOC(srbList->list.array, srbList->list.size);
15604    if(srbList->list.array == NULLP)
15605    {
15606       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15607       return RFAILED;
15608    }
15609
15610    for(srbIdx = 0; srbIdx < srbList->list.count; srbIdx++)
15611    {
15612       DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15613       if(srbList->list.array[srbIdx] == NULLP)
15614       {
15615          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15616          return RFAILED;
15617       }
15618    }
15619
15620    for(srbIdx=0; srbIdx < srbList->list.count; srbIdx++)
15621    {
15622       srbItemIe = (struct SRBs_SetupMod_ItemIEs *)srbList->list.array[srbIdx];
15623       srbItemIe->id = ProtocolIE_ID_id_SRBs_SetupMod_Item;
15624       srbItemIe->criticality = Criticality_reject;
15625       srbItemIe->value.present = SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item;
15626       srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID = ueCfg->rlcLcCfg[srbIdx].rbId;
15627       srbItemIe->value.choice.SRBs_SetupMod_Item.lCID = ueCfg->rlcLcCfg[srbIdx].lcId;
15628    }
15629    return ROK;
15630 }
15631
15632 /*******************************************************************
15633  *
15634 * @brief Builds the DRB to be Setup Mod list
15635 *
15636 * @details
15637 *
15638 *    Function :
15639 *
15640 *    Functionality: Constructs the DRB to be Setup Mod list
15641 *
15642 * @params[in] DRBs_SetupMod_List_t *drbSet
15643 *
15644 * @return ROK     - success
15645 *         RFAILED - failure
15646 *
15647 * ****************************************************************/
15648
15649 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
15650 {
15651    uint8_t arrIdx =0;
15652    uint8_t drbCnt =0;
15653    struct DRBs_SetupMod_ItemIEs *drbItemIe;
15654
15655    drbCnt = ueCfg->numDrbSetupMod;
15656
15657    if(!drbCnt)
15658    {
15659       DU_LOG("\nINFO  -->  F1AP : BuildDrbToBeSetupModList(): No DRB information to avaialble to add");
15660       return ROK;
15661    }
15662
15663    drbSet->list.count = drbCnt;
15664    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
15665    DU_ALLOC(drbSet->list.array, drbSet->list.size);
15666    if(drbSet->list.array == NULLP)
15667    {
15668       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15669       return  RFAILED;
15670    }
15671    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
15672    {
15673       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15674       if(drbSet->list.array[arrIdx] == NULLP)
15675       {
15676               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15677               return  RFAILED;
15678       }
15679
15680       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
15681       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
15682       drbItemIe->criticality = Criticality_reject;
15683       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
15684       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
15685       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
15686       &ueCfg->upTnlInfo[arrIdx])!= ROK)
15687       {
15688          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
15689          return RFAILED;
15690       }
15691
15692    }
15693
15694    return ROK;
15695 }
15696 /*******************************************************************
15697 * @brief Free the memory allocated for DRB setup List
15698 *
15699 * @details
15700 *
15701 *    Function : FreeDrbSetupModList
15702 *
15703 *    Functionality:
15704 *       Free the memory allocated for DRB setup list
15705 *
15706 * @params[in] DRBs_Setup_List_t *
15707 * @return void
15708 *
15709 * ****************************************************************/
15710 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
15711 {
15712    uint8_t arrIdx = 0;
15713    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
15714
15715    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
15716    {
15717       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
15718       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
15719       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15720    }
15721    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
15722 }
15723
15724 /*******************************************************************
15725 * @brief Free the memory allocated for SRB setup List
15726 *
15727 * @details
15728 *
15729 *    Function : FreeSrbSetupModList
15730 *
15731 *    Functionality:
15732 *       Free the memory allocated for SRB setup list
15733 *
15734 * @params[in] SRBs_Setup_List_t *
15735 * @return void
15736 *
15737 * ****************************************************************/
15738 void FreeSrbSetupModList(SRBs_SetupMod_List_t *srbSetupList)
15739 {
15740    uint8_t srbIdx = 0;
15741
15742    for(srbIdx = 0; srbIdx < srbSetupList->list.count; srbIdx++)
15743       DU_FREE(srbSetupList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15744    DU_FREE(srbSetupList->list.array, srbSetupList->list.size);
15745 }
15746
15747 /*******************************************************************
15748 * @brief Free the memory allocated for UE Context Mod Response
15749 *
15750 * @details
15751 *
15752 *    Function : FreeUeContextModResp
15753 *
15754 *    Functionality:
15755 *       Free the memory allocated for UE Context Mod Response
15756 *
15757 * @params[in] F1AP_PDU_t *f1apMsg
15758 * @return void
15759 *
15760 * ****************************************************************/
15761
15762 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
15763 {
15764    uint8_t ieIdx;
15765    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15766    if(f1apMsg)
15767    {
15768       if(f1apMsg->choice.successfulOutcome)
15769       {
15770          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15771          if(ueContextModifyRes->protocolIEs.list.array)
15772          {
15773             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
15774             {
15775                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
15776                {
15777                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
15778                   {
15779                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15780                         break;
15781                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15782                         break;
15783                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
15784                         {
15785                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15786                             value.choice.DRBs_SetupMod_List));
15787                             break;
15788                         }
15789                      case ProtocolIE_ID_id_SRBs_SetupMod_List:
15790                         {
15791                            FreeSrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
15792                               SRBs_SetupMod_List));
15793                            break;
15794                         }
15795                   }
15796                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15797                }
15798
15799             }
15800             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15801          }
15802          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15803       }
15804       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
15805    }
15806 }
15807
15808 /*****************************************************************i
15809 *
15810 * @brief Creating the ue context modifcation response and sending
15811 *
15812 * @details
15813 *
15814 *    Function : BuildAndSendUeContextModRsp
15815 *
15816 *    Functionality:
15817 *         - Creating the ue context modifcation response
15818 *
15819 * @params[in] uint8_t cellId,uint8_t ueId
15820 * @return ROK     - success
15821 *         RFAILED - failure
15822 *
15823 * ****************************************************************/
15824 uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb)
15825 {
15826    uint8_t   ieIdx = 0, tnlIdx = 0, rbIdx = 0;
15827    uint8_t   elementCnt = 0;
15828    uint8_t   ret = RFAILED;
15829    F1AP_PDU_t *f1apMsg = NULLP;
15830    asn_enc_rval_t  encRetVal;
15831    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15832
15833    DU_LOG("\nINFO  -->  F1AP : Building UE context modification response\n");
15834
15835    while(true)
15836    {
15837       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
15838       if(f1apMsg == NULLP)
15839       {
15840          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
15841          break;
15842       }
15843
15844       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
15845
15846       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15847       if(f1apMsg->choice.successfulOutcome == NULLP)
15848       {
15849          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
15850          break;
15851       }
15852       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
15853       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
15854       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
15855
15856       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15857
15858       if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
15859       {
15860          if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
15861             elementCnt =3;
15862          else
15863             elementCnt =2;
15864       }
15865       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15866          elementCnt = 5;
15867       if(ueCb->f1UeDb->actionType == UE_CTXT_RRC_RECFG_COMPLETE)
15868          elementCnt = 2;
15869       ueContextModifyRes->protocolIEs.list.count = elementCnt;
15870       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
15871
15872       /* Initialize the UE context modification members */
15873       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15874       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
15875       {
15876          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
15877          break;
15878       }
15879
15880       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
15881       {
15882          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15883          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
15884          {
15885             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
15886             break;
15887          }
15888       }
15889
15890       ieIdx=0;
15891       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
15892       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15893       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
15894       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
15895       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
15896
15897       ieIdx++;
15898       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
15899       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15900       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
15901       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
15902       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
15903
15904       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15905       {
15906          ieIdx++;
15907          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCInformation;
15908          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15909          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
15910          UEContextModificationResponseIEs__value_PR_DUtoCURRCInformation;
15911          BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
15912       }
15913
15914       if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || ((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbSetupMod)))
15915       {
15916          ieIdx++;
15917          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
15918          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15919          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
15920                                                                            UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
15921          if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15922          {
15923             for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
15924             {
15925                if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
15926                {
15927                   memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
15928                }
15929             }
15930          }
15931          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15932                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
15933          if(ret != ROK)
15934          {
15935             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB setupmod List ");
15936             break;
15937          }
15938       }
15939
15940       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
15941       {
15942          ieIdx++;
15943          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_SRBs_SetupMod_List;
15944          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
15945          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
15946                                                                             UEContextModificationResponseIEs__value_PR_SRBs_SetupMod_List;
15947          for(rbIdx = 0; rbIdx < ueCb->rlcUeCfg.numLcs; rbIdx++)
15948          {
15949             if(ueCb->rlcUeCfg.rlcLcCfg[rbIdx].rbType == RB_TYPE_SRB)
15950             {
15951                memcpy(&ueCb->f1UeDb->duUeCfg.rlcLcCfg[ueCb->f1UeDb->duUeCfg.numRlcLcs++], &ueCb->rlcUeCfg.rlcLcCfg[rbIdx],\
15952                      sizeof(RlcBearerCfg));
15953             }
15954          }
15955          ret = BuildSrbSetupModList(&ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.SRBs_SetupMod_List, \
15956                &ueCb->f1UeDb->duUeCfg);
15957          if(ret != ROK)
15958          {
15959             DU_LOG( "\nERROR  -->  F1AP : Failed to build SRB setupmod List ");
15960             break;
15961          }
15962       }
15963
15964       freeF1UeDb(ueCb->f1UeDb);
15965       ueCb->f1UeDb = NULLP;
15966
15967       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15968
15969       /* Encode the F1SetupRequest type as APER */
15970       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15971       encBufSize = 0;
15972       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
15973
15974       /* Encode results */
15975       if(encRetVal.encoded == ENCODE_FAIL)
15976       {
15977          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
15978                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15979          ret = RFAILED;
15980          break;
15981       }
15982       else
15983       {
15984          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
15985 #ifdef DEBUG_ASN_PRINT
15986          for(int i=0; i< encBufSize; i++)
15987          {
15988             printf("%x",encBuf[i]);
15989          }
15990 #endif
15991       }
15992
15993       /* Sending  msg  */
15994       if(sendF1APMsg() != ROK)
15995       {
15996          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
15997          ret = RFAILED;
15998          break;
15999       }
16000
16001       ret = ROK;
16002       break;
16003    }
16004    FreeUeContextModResp(f1apMsg);
16005    return ret;
16006 }
16007 /*******************************************************************
16008  *
16009  * @brief Deallocating the memory allocated by the aper decoder
16010  *          for QOSInfo
16011  *
16012  * @details
16013  *
16014  *    Function : freeAperDecodeQosInfo
16015  *
16016  *    Functionality:  Deallocating the memory allocated for QOSInfo
16017  *
16018  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
16019  *
16020  * @return void
16021  *
16022  * ****************************************************************/
16023
16024 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
16025 {
16026    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
16027    {
16028       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
16029       {
16030          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
16031          {
16032             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
16033          }
16034          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
16035       }
16036       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
16037    }
16038 }
16039 /*******************************************************************
16040  *
16041  * @brief Deallocating the memory allocated by the aper decoder
16042  *          for UlTnlInfoforDrb
16043  *
16044  * @details
16045  *
16046  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
16047  *
16048  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
16049  *
16050  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
16051  *
16052  * @return void
16053  *
16054  * ****************************************************************/
16055 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
16056 {
16057    uint8_t arrIdx =0;
16058
16059    if(ulInfo->list.array)
16060    {
16061       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
16062       {
16063          if(ulInfo->list.array[arrIdx])
16064          {
16065             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
16066             {
16067                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
16068                {
16069                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
16070                   {
16071                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16072                            gTP_TEID.buf);
16073                   }
16074                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16075                         transportLayerAddress.buf);
16076                }
16077                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
16078             }
16079             free(ulInfo->list.array[arrIdx]);
16080          }
16081       }
16082       free(ulInfo->list.array);
16083    }
16084 }
16085 /*******************************************************************
16086  *
16087  * @brief Deallocating the memory allocated by the aper decoder
16088  *          for DrbSetupModItem
16089  *
16090  * @details
16091  *
16092  *    Function : freeAperDecodeDrbSetupModItem
16093  *
16094  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
16095  *
16096  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
16097  *
16098  * @return void
16099  *
16100  * ****************************************************************/
16101
16102 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
16103 {
16104    uint8_t arrIdx =0;
16105    SNSSAI_t *snssai =NULLP;
16106    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
16107
16108    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
16109    switch(drbItem->qoSInformation.present)
16110    {
16111       case QoSInformation_PR_NOTHING:
16112          break;
16113       case QoSInformation_PR_eUTRANQoS:
16114          {
16115             if(drbItem->qoSInformation.choice.eUTRANQoS)
16116             {
16117                free(drbItem->qoSInformation.choice.eUTRANQoS);
16118             }
16119             break;
16120          }
16121       case QoSInformation_PR_choice_extension:
16122          {
16123             if(drbItem->qoSInformation.choice.choice_extension)
16124             {
16125                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
16126                      DRB_Information.dRB_QoS);
16127                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
16128                if(snssai->sST.buf)
16129                {
16130                   free(snssai->sST.buf);
16131                }
16132                if(snssai->sD)
16133                {
16134                   if(snssai->sD->buf)
16135                   {
16136                      free(snssai->sD->buf);
16137                   }
16138                   free(snssai->sD);
16139                }
16140
16141                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
16142                          DRB_Information.flows_Mapped_To_DRB_List;
16143                if(flowMap->list.array)
16144                {
16145                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
16146                   {
16147                      if(flowMap->list.array[arrIdx] )
16148                      {
16149                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
16150                         free(flowMap->list.array[arrIdx]);
16151                      }
16152                   }
16153                   free(flowMap->list.array);
16154                }
16155
16156                free(drbItem->qoSInformation.choice.choice_extension);
16157             }
16158             break;
16159          }
16160
16161    }
16162    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
16163    if(drbItem->uLConfiguration)
16164    {
16165       free(drbItem->uLConfiguration);
16166    }
16167 }
16168
16169 /*******************************************************************
16170  *
16171  * @brief Deallocating the memory allocated by the aper decoder
16172  *          for DrbToBeSetupModList
16173  *
16174  * @details
16175  *
16176  *    Function : freeAperDecodeDrbToBeSetupModList
16177  *
16178  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
16179  *
16180  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
16181  *
16182  * @return void
16183  *
16184  * ****************************************************************/
16185
16186 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
16187 {
16188    uint8_t arrIdx =0;
16189    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
16190
16191    if(drbSet->list.array)
16192    {
16193       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
16194       {
16195          if(drbSet->list.array[arrIdx] != NULLP)
16196          {
16197             if(arrIdx == 0)
16198             {
16199                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
16200                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
16201             }
16202             free(drbSet->list.array[arrIdx]);
16203          }
16204       }
16205       free(drbSet->list.array);
16206    }
16207
16208 }
16209 /*******************************************************************
16210  *
16211  * @brief Deallocating the memory allocated by the aper decoder
16212  *          for UeContextModificationReqMsg
16213  *
16214  * @details
16215  *
16216  *    Function : freeAperDecodeUeContextModificationReqMsg
16217  *
16218  *    Functionality:  Deallocating memory allocated for
16219  *                  UeContextModificationReqMsg
16220  *
16221  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
16222  *
16223  * @return void
16224  *
16225  * ****************************************************************/
16226 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *ueContextModifyReq )
16227 {
16228    uint8_t arrIdx, ieId;
16229
16230    if(ueContextModifyReq->protocolIEs.list.array)
16231    {
16232       for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
16233       {
16234          if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
16235          {
16236             ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
16237             switch(ieId)
16238             {
16239                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16240                   break;
16241                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16242                   break;
16243                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
16244                   {
16245                      freeAperDecodeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
16246                            value.choice.DRBs_ToBeSetupMod_List);
16247                      break;
16248                   }
16249                case ProtocolIE_ID_id_TransmissionActionIndicator:
16250                   break;
16251                case ProtocolIE_ID_id_RRCContainer:
16252                   {
16253                      free(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf);
16254                   }
16255             }
16256             free(ueContextModifyReq->protocolIEs.list.array[arrIdx]);
16257          }
16258       }
16259       free(ueContextModifyReq->protocolIEs.list.array);
16260    }
16261 }
16262 /*******************************************************************
16263  *
16264  * @brief processing the F1 UeContextModificationReq
16265  *
16266  * @details
16267  *
16268  *    Function : procF1UeContextModificationReq
16269  *
16270  *    Functionality:  processing the F1 UeContextModificationReq
16271  *
16272  * @params[in] F1AP_PDU_t *f1apMsg
16273  *
16274  * @return
16275  * ****************************************************************/
16276 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
16277 {
16278    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
16279    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0;
16280    DuUeCb   *duUeCb = NULLP;
16281    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
16282    DRBs_ToBeModified_List_t *drbModifiedCfg;
16283    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
16284
16285    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
16286    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
16287    {
16288       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
16289       {
16290          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16291             {
16292                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
16293                break;
16294             }
16295          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16296             {
16297                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
16298                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
16299                {
16300                   if(duCb.actvCellLst[cellIdx])
16301                   {
16302                      if((duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == gnbDuUeF1apId)&&\
16303                            (duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbCuUeF1apId == gnbCuUeF1apId))
16304                      {
16305                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1];
16306                         if(duUeCb->f1UeDb == NULLP)
16307                         {
16308                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
16309                            duUeCb->f1UeDb->cellIdx = cellIdx;
16310                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
16311                         }
16312                         break;
16313                      }
16314                   }
16315                }
16316                if(duUeCb == NULLP)
16317                {
16318                   DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
16319                   ret = RFAILED;
16320                }
16321                break;
16322             }
16323
16324          case ProtocolIE_ID_id_RRCContainer:
16325             {
16326                /* Filling Dl RRC Msg Info */
16327                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
16328                if(!duUeCb->f1UeDb->dlRrcMsg)
16329                {
16330                   DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16331                         Memory allocation failed ");
16332                   ret = RFAILED;
16333                }
16334                else
16335                {
16336                   duUeCb->f1UeDb->dlRrcMsgPres = true;
16337                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
16338                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
16339                         &ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
16340                         value.choice.RRCContainer);
16341                }
16342
16343                break;
16344             }
16345
16346          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
16347          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
16348             {
16349                if(duUeCb->f1UeDb)
16350                {
16351                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
16352                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
16353                   {
16354                      drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16355                                       choice.DRBs_ToBeSetupMod_List;
16356
16357                      if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
16358                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
16359                      {
16360                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
16361                         ret = RFAILED;
16362                      }
16363                   }
16364
16365                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
16366                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
16367
16368                   {
16369                      drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16370                                       choice.DRBs_ToBeModified_List;
16371                      if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
16372                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
16373                      {
16374                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
16375                         ret = RFAILED;
16376                      }
16377                   }
16378                }
16379                break;
16380             }
16381
16382          case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
16383             {
16384                DU_LOG("\nINFO  -->  DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
16385                if(duUeCb->f1UeDb)
16386                {
16387                   duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
16388                }
16389                break;
16390             }
16391
16392          case ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator:
16393             {
16394                if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator == \
16395                   RRCReconfigurationCompleteIndicator_true)
16396                {
16397                   duUeCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE;
16398                }
16399                break;
16400             }
16401          case ProtocolIE_ID_id_TransmissionActionIndicator:
16402             {
16403                if(duUeCb->f1UeDb)
16404                {
16405                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator  == TransmissionActionIndicator_stop)
16406                   {
16407                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = STOP_TRANSMISSION;
16408                   }
16409                   else
16410                   {
16411                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = RESTART_TRANSMISSION;
16412                   }
16413                }
16414                break;
16415             }
16416
16417          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
16418             {
16419                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
16420                {
16421                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
16422                }
16423                break;
16424             }
16425 #ifdef NR_DRX
16426          case ProtocolIE_ID_id_DRXConfigurationIndicator:
16427             {
16428                duUeCb->f1UeDb->duUeCfg.drxConfigIndicatorRelease = true;
16429                break;
16430             }
16431 #endif
16432
16433       }
16434    }
16435
16436    if(ret != RFAILED)
16437    {
16438       ret = duProcUeContextModReq(duUeCb);
16439    }
16440    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
16441    return ret;
16442 }
16443
16444 /*****************************************************************i
16445 *
16446 * @brief Free memory allocated for UE Context Release Request
16447 *
16448 * @details
16449 *
16450 *    Function : FreeUeContextReleaseReq
16451 *
16452 *    Functionality:
16453 *         - Free memory allocated for UE Context Release Request
16454 *
16455 * @params[in] F1AP_PDU_t *f1apMsg
16456 * @return void
16457 *
16458 * *************************************************************/
16459 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
16460 {
16461    uint8_t ieIdx;
16462    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
16463
16464    if(f1apMsg)
16465    {
16466       if(f1apMsg->choice.initiatingMessage)
16467       {
16468          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
16469          if(ueReleaseReq->protocolIEs.list.array)
16470          {
16471             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
16472             {
16473                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
16474             }
16475             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
16476          }
16477          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
16478       }
16479       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16480    }
16481
16482 }
16483 /*****************************************************************i
16484 *
16485 * @brief Build and Send UE Context Release Request
16486 *
16487 * @details
16488 *
16489 *    Function : BuildAndSendUeContextReleaseReq
16490 *
16491 *    Functionality:
16492 *         - Build and Send UE Context Release Request
16493 *
16494 * @params[in]
16495 * @return ROK     - success
16496 *         RFAILED - failure
16497 *
16498 * *************************************************************/
16499 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
16500 {
16501    bool memAllocFail = false;
16502    uint8_t ieIdx =0;
16503    uint8_t ret = RFAILED;
16504    uint16_t cellIdx =0;
16505    uint16_t crnti = 0;
16506    uint8_t  elementCnt = 0;
16507    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
16508    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
16509    asn_enc_rval_t encRetVal;
16510    F1AP_PDU_t *f1apMsg = NULLP;
16511    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
16512
16513    DU_LOG("\nINFO  --> Building the UE Context Release Request");
16514    do
16515    {
16516       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16517       if(f1apMsg == NULLP)
16518       {
16519          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
16520          break;
16521       }
16522
16523       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
16524       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
16525       if(f1apMsg->choice.initiatingMessage == NULLP)
16526       {
16527          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
16528          initiatingMessage");
16529          break;
16530       }
16531       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
16532       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
16533       f1apMsg->choice.initiatingMessage->value.present = \
16534       InitiatingMessage__value_PR_UEContextReleaseRequest;
16535
16536       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
16537
16538       elementCnt = 2;
16539
16540       ueReleaseReq->protocolIEs.list.count = elementCnt;
16541       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
16542
16543       /* Initialize the F1Setup members */
16544       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
16545       if(ueReleaseReq->protocolIEs.list.array == NULLP)
16546       {
16547          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
16548          break;
16549       }
16550       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
16551       {
16552          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
16553                sizeof(UEContextReleaseRequest_t));
16554          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
16555          {
16556             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
16557             memAllocFail = true;
16558             break;
16559          }
16560       }
16561       if(memAllocFail == true)
16562          break;
16563
16564       /* Fetching Ue Cb Info*/
16565       GET_CELL_IDX(cellId, cellIdx);
16566       if(duCb.actvCellLst[cellIdx] == NULLP)
16567       {
16568          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
16569          break;
16570       }
16571       else
16572       {
16573          GET_CRNTI(crnti, ueId);
16574          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
16575          {
16576             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
16577             break;
16578          }
16579          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
16580          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
16581       }
16582
16583       ieIdx=0;
16584       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16585       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16586       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
16587       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
16588       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16589
16590       ieIdx++;
16591       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16592       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16593       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
16594       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
16595       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16596
16597       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16598
16599       /* Encode the F1SetupRequest type as APER */
16600       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16601       encBufSize = 0;
16602       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
16603       /* Encode results */
16604       if(encRetVal.encoded == ENCODE_FAIL)
16605       {
16606          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
16607                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16608          break;
16609       }
16610       else
16611       {
16612          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
16613 #ifdef DEBUG_ASN_PRINT
16614          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
16615          {
16616             printf("%x",encBuf[ieIdx]);
16617          }
16618 #endif
16619       }
16620
16621       /* Sending msg */
16622       if(sendF1APMsg() != ROK)
16623       {
16624          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
16625          break;
16626       }
16627       ret = ROK;
16628       break;
16629    }while(true);
16630
16631    FreeUeContextReleaseReq(f1apMsg);
16632    return ret;
16633 }
16634 /*****************************************************************i
16635  *
16636  * @brief Free memory allocated for UE Context Release Complete
16637  *
16638  * @details
16639  *
16640  *    Function : FreeUeContextReleaseComplete
16641  *
16642  *    Functionality:
16643  *         - Free memory allocated for UE Context Release Complete
16644  *
16645  * @params[in] F1AP_PDU_t *f1apMsg
16646  * @return void
16647  *
16648  * *************************************************************/
16649 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
16650 {
16651    uint8_t ieIdx;
16652    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
16653
16654    if(f1apMsg)
16655    {
16656       if(f1apMsg->choice.successfulOutcome)
16657       {
16658          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
16659          if(ueReleaseComplete->protocolIEs.list.array)
16660          {
16661             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
16662             {
16663                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
16664             }
16665             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
16666          }
16667          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16668       }
16669       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16670    }
16671
16672 }
16673 /*****************************************************************i
16674  *
16675  * @brief Build and Send UE Context Release Complete
16676  *
16677  * @details
16678  *
16679  *    Function : BuildAndSendUeContextReleaseComplete
16680  *
16681  *    Functionality:
16682  *         - Build and Send UE Context Release Complete
16683  *
16684  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
16685  * @return ROK     - success
16686  *         RFAILED - failure
16687  *
16688  * *************************************************************/
16689 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
16690 {
16691    bool memAllocFail = false;
16692    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
16693    asn_enc_rval_t encRetVal;
16694    F1AP_PDU_t *f1apMsg = NULLP;
16695    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
16696
16697    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
16698    do
16699    {
16700       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16701       if(f1apMsg == NULLP)
16702       {
16703          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
16704          break;
16705       }
16706
16707       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
16708       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16709       if(f1apMsg->choice.successfulOutcome == NULLP)
16710       {
16711          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
16712                successfulOutcome");
16713          break;
16714       }
16715       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
16716       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
16717       f1apMsg->choice.successfulOutcome->value.present = \
16718       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
16719
16720       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
16721
16722       elementCnt = 2;
16723       ueReleaseComplete->protocolIEs.list.count = elementCnt;
16724       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
16725
16726       /* Initialize the UE Release Complete members */
16727       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
16728       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
16729       {
16730          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
16731          break;
16732       }
16733       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
16734       {
16735          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
16736                sizeof(UEContextReleaseComplete_t));
16737          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
16738          {
16739             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
16740             elements");
16741             memAllocFail = true;
16742             break;
16743          }
16744       }
16745       if(memAllocFail == true)
16746          break;
16747
16748
16749       ieIdx=0;
16750       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16751       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16752       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
16753       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
16754       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16755
16756       ieIdx++;
16757       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16758       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16759       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
16760       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
16761       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16762
16763       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16764
16765       /* Encode the F1SetupComplete type as APER */
16766       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16767       encBufSize = 0;
16768       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
16769       /* Encode results */
16770       if(encRetVal.encoded == ENCODE_FAIL)
16771       {
16772          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
16773                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16774          break;
16775       }
16776       else
16777       {
16778          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
16779 #ifdef DEBUG_ASN_PRINT
16780          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
16781          {
16782             printf("%x",encBuf[ieIdx]);
16783          }
16784 #endif
16785       }
16786
16787       /* Sending msg */
16788       if(sendF1APMsg() != ROK)
16789       {
16790          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
16791          break;
16792       }
16793       ret = ROK;
16794       break;
16795    }while(true);
16796
16797    if((ret == ROK) && (duCb.actvCellLst[cellId-1]) && (duCb.actvCellLst[cellId-1]->cellStatus == DELETION_IN_PROGRESS)
16798          && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
16799    {
16800       ret = duSendCellDeletReq(cellId);
16801       if(ret != ROK)
16802       {
16803          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
16804                Delete req for CellId");
16805       }
16806    }
16807    FreeUeContextReleaseComplete(f1apMsg);
16808    return ret;
16809
16810 }
16811
16812 /*******************************************************************
16813 *
16814 * @brief added free part for the memory allocated by aper_decoder
16815 *
16816 * @details
16817 *
16818 *    Function : freeAperDecodeUeContextReleaseCommand
16819 *
16820 *    Functionality: added free part for the memory allocated by aper_decoder
16821 *
16822 * @params[in] F1AP_PDU_t *f1apMsg
16823 * @return void
16824 *
16825 * ****************************************************************/
16826 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
16827 {
16828    uint8_t ieIdx=0;
16829    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
16830
16831    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
16832
16833    if(ueContextReleaseCommand->protocolIEs.list.array)
16834    {
16835       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
16836       {
16837          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
16838          {
16839             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
16840             {
16841                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16842                   break;
16843                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16844                   break;
16845                case ProtocolIE_ID_id_Cause:
16846                   break;
16847                case ProtocolIE_ID_id_RRCContainer:
16848                {
16849                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
16850                   {
16851                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
16852                   }
16853                   break;
16854                }
16855                default :
16856                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
16857                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
16858                   break;
16859             }
16860          }
16861          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
16862       }
16863       free(ueContextReleaseCommand->protocolIEs.list.array);
16864    }
16865 }
16866 /*******************************************************************
16867 *
16868 * @brief processing of UE Context Release Command
16869 *
16870 * @details
16871 *
16872 *    Function : procF1UeContextReleaseCommand
16873 *
16874 *    Functionality: processing of UE Context Release Command
16875 *
16876 * @params[in] F1AP_PDU_t *f1apMsg
16877 * @return void
16878 *
16879 * ****************************************************************/
16880 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
16881 {
16882    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
16883    uint16_t cellIdx =0, cellId = 0;
16884    bool ueIdxFound = false;
16885    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
16886    DuUeCb   *duUeCb = NULLP;
16887    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
16888
16889    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
16890
16891    if(ueContextReleaseCommand->protocolIEs.list.array)
16892    {
16893       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
16894       {
16895          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
16896          {
16897             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
16898             {
16899                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16900                   {
16901                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16902                                     value.choice.GNB_CU_UE_F1AP_ID;
16903                      break;
16904                   }
16905
16906                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16907                   {
16908                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16909                                      value.choice.GNB_DU_UE_F1AP_ID;
16910                      break;
16911                   }
16912
16913                case ProtocolIE_ID_id_Cause:
16914                   {
16915                      for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
16916                      {
16917                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
16918                         {
16919                            if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
16920                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
16921                            {
16922                               cellId = duCb.actvCellLst[cellIdx]->cellId;
16923                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
16924                               ueIdxFound = true;
16925                               break;
16926                            }
16927                         }
16928                         if(ueIdxFound == true)
16929                         {
16930                            break;
16931                         }
16932                      }
16933
16934                      if(!ueIdxFound)
16935                      {
16936                         DU_LOG("\nERROR  -->  F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
16937                         ret = RFAILED;
16938                      }
16939                      break;
16940                   }
16941
16942                case ProtocolIE_ID_id_RRCContainer:
16943                   {
16944                      if(ueIdxFound == true)
16945                      {
16946                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
16947                         if(duUeCb->f1UeDb)
16948                         {
16949                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
16950                            duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
16951                            duUeCb->f1UeDb->cellIdx = cellIdx;
16952                            /* Filling Dl RRC Msg Info */
16953                            DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
16954                            if(!duUeCb->f1UeDb->dlRrcMsg)
16955                            {
16956                               DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16957                                     Memory allocation failed ");
16958                               ret = RFAILED;
16959                            }
16960                            else
16961                            {
16962                               duUeCb->f1UeDb->dlRrcMsgPres = true;
16963                               memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
16964                               ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
16965                                     &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
16966                                     value.choice.RRCContainer);
16967                            }
16968
16969                         }
16970                         else
16971                         {
16972                            DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16973                                  Memory allocation failed ");
16974                            ret = RFAILED;
16975
16976                         }
16977                      }
16978                      break;
16979                   }
16980                default :
16981                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
16982                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
16983                   break;
16984             }
16985          }
16986       }
16987    }
16988    if(ret != RFAILED)
16989    {
16990       duProcUeContextReleaseCommand(cellId, duUeCb);
16991    }
16992    freeAperDecodeUeContextReleaseCommand(f1apMsg);
16993    return ret;
16994 }
16995
16996 /**************************************************************
16997  *
16998  * @brief free the memory allocated by aper decoder for paging
16999  *
17000  * @details
17001  *
17002  *    Function : freeAperDecodePagingMsg
17003  *
17004  *    Functionality:
17005  *         - free the memory allocated by aper decoder for
17006  *         the paging f1ap msg
17007  *
17008  * @params[in] Paging_t   *paging
17009  * @return ROK     - success
17010  *         RFAILED - failure
17011  *
17012  ****************************************************************/
17013 void freeAperDecodePagingMsg(Paging_t   *paging)
17014 {
17015    uint8_t ieIdx, cellIdx;
17016    PagingCell_ItemIEs_t *pagingCellItemIes;
17017    PagingCell_Item_t *pagingCellItem;
17018    PagingCell_list_t  *pagingCelllist;
17019
17020    if(paging)
17021    {
17022       if(paging->protocolIEs.list.array)
17023       {
17024          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17025          {
17026             if(paging->protocolIEs.list.array[ieIdx])
17027             {
17028                switch(paging->protocolIEs.list.array[ieIdx]->id)
17029                {
17030                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17031                      {
17032                         free(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf);
17033                         break;
17034                      }
17035                   case ProtocolIE_ID_id_PagingIdentity:
17036                      {
17037                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
17038                         {
17039                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17040                            {
17041                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == \
17042                                     CNUEPagingIdentity_PR_fiveG_S_TMSI)
17043                               {
17044                                  free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf);
17045                               }
17046                               free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity);
17047                            }
17048                         }
17049                         break;
17050                      }
17051                   case ProtocolIE_ID_id_PagingCell_List:
17052                      {
17053                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17054                         if(pagingCelllist->list.array)
17055                         {
17056                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
17057                            {
17058                               if(pagingCelllist->list.array[cellIdx])
17059                               {
17060                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
17061                                  if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
17062                                  {
17063                                     pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17064                                     free(pagingCellItem->nRCGI.pLMN_Identity.buf);
17065                                     free(pagingCellItem->nRCGI.nRCellIdentity.buf);
17066                                  }
17067                                  free(pagingCelllist->list.array[cellIdx]);
17068                               }
17069                            }
17070                            free(pagingCelllist->list.array);
17071                         }
17072                         break;
17073                      }
17074                }
17075                free(paging->protocolIEs.list.array[ieIdx]);
17076             }
17077          }
17078          free(paging->protocolIEs.list.array);
17079
17080       }
17081    }
17082 }
17083
17084 /**************************************************************
17085  *
17086  * @brief processing the paging f1ap msg received from CU
17087  *
17088  * @details
17089  *
17090  *    Function : procPagingMsg
17091  *
17092  *    Functionality:
17093  *         - processing the paging f1ap msg received from CU
17094  *
17095  * @params[in] F1AP_PDU_t *f1apMsg
17096  * @return ROK     - success
17097  *         RFAILED - failure
17098  *
17099  *
17100  ****************************************************************/
17101 uint8_t procPagingMsg(F1AP_PDU_t *f1apMsg)
17102 {
17103    uint8_t ieIdx = 0, cellListIdx = 0;
17104    uint64_t cellId = 0;
17105    Paging_t   *paging = NULLP;
17106    PagingCell_list_t  *pagingCelllist = NULLP;
17107    PagingCell_ItemIEs_t *pagingCellItemIes = NULLP;
17108    PagingCell_Item_t *pagingCellItem = NULLP;
17109    DuPagingMsg *tmpPagingParam = NULLP;
17110
17111    paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
17112    if(paging)
17113    {
17114       if(paging->protocolIEs.list.array)
17115       {
17116          DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg));
17117          if(tmpPagingParam == NULLP)
17118          {
17119             DU_LOG("\nERROR  --> DU APP : Memory Allocation Failure in procPagingMsg");
17120             freeAperDecodePagingMsg(paging);
17121             return RFAILED;
17122          }
17123          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17124          {
17125             if(paging->protocolIEs.list.array[ieIdx])
17126             {
17127                switch(paging->protocolIEs.list.array[ieIdx]->id)
17128                {
17129                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17130                      {
17131                         bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10,\
17132                                          &tmpPagingParam->pagUeId);
17133                         break;
17134                      }
17135
17136                   case ProtocolIE_ID_id_PagingIdentity:
17137                      {
17138                         switch(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present)
17139                         {
17140                            case PagingIdentity_PR_cNUEPagingIdentity:
17141                               {
17142                                  if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17143                                  {
17144                                     bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.\
17145                                           cNUEPagingIdentity->choice.fiveG_S_TMSI, &tmpPagingParam->sTmsi);
17146
17147                                  }
17148                                  break;
17149                               }
17150                             case PagingIdentity_PR_rANUEPagingIdentity:
17151                                {
17152                                   /*TODO: This Identifier is specific to RAN Initiated Paging – Connected Mode Paging*/
17153                                   break;
17154                                }
17155                             default:
17156                                {
17157                                   DU_LOG("ERROR  -->  DU APP: Invalid UE Paging Identity, Skipping this Paging Message:");
17158                                   continue;
17159                                }
17160                         }
17161                      }
17162
17163                   case ProtocolIE_ID_id_PagingDRX:
17164                      {
17165                         tmpPagingParam->pagingDrxPres = TRUE;
17166                         tmpPagingParam->pagingDrx = convertPagingCycleEnumToValue(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX);
17167                         break;
17168                      }
17169
17170                   case ProtocolIE_ID_id_PagingPriority:
17171                      {
17172                         tmpPagingParam->pagPriority = paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority;
17173                         break;
17174                      }
17175
17176                   case ProtocolIE_ID_id_PagingCell_List:
17177                      {
17178                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17179                         if(pagingCelllist->list.array)
17180                         {
17181                            for(cellListIdx = 0; cellListIdx < pagingCelllist->list.count; cellListIdx++)
17182                            {
17183                               if(pagingCelllist->list.array[cellListIdx])
17184                               {
17185                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellListIdx];
17186                                  pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17187                                  bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId);
17188                                  if(processPagingMsg(cellId, tmpPagingParam) != ROK)
17189                                  {
17190                                     DU_LOG("\nERROR  --> DU APP : Paging Processing Failed at CellId:%lu",cellId);
17191                                     continue;
17192                                  }
17193                               }
17194                            }
17195                         }
17196                         break;
17197                      }
17198                    default:
17199                      {
17200                          DU_LOG("\nERROR  --> F1AP : Incorrect Paging IE option");
17201                          break;
17202                      }
17203                }
17204             }
17205          }
17206       }
17207    }
17208    DU_FREE(tmpPagingParam, sizeof(DuPagingMsg));
17209    freeAperDecodePagingMsg(paging);
17210
17211    return ROK;
17212 }
17213
17214 /**************************************************************
17215  *
17216  * @brief Handles received F1AP message and sends back response
17217  *
17218  * @details
17219  *
17220  *    Function : F1APMsgHdlr
17221  *
17222  *    Functionality:
17223  *         - Decodes received F1AP control message
17224  *         - Prepares response message, encodes and sends to SCTP
17225  *
17226  * @params[in]
17227  * @return ROK     - success
17228  *         RFAILED - failure
17229  *
17230  * ****************************************************************/
17231 void F1APMsgHdlr(Buffer *mBuf)
17232 {
17233    int i =0;
17234    char *recvBuf =NULLP;
17235    MsgLen copyCnt =0;
17236    MsgLen recvBufLen =0;
17237    F1AP_PDU_t *f1apMsg =NULLP;
17238    asn_dec_rval_t rval; /* Decoder return value */
17239    F1AP_PDU_t f1apasnmsg ;
17240    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
17241    ODU_PRINT_MSG(mBuf, 0,0);
17242
17243    /* Copy mBuf into char array to decode it */
17244    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
17245    DU_ALLOC(recvBuf, (Size)recvBufLen);
17246
17247    if(recvBuf == NULLP)
17248    {
17249       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
17250       return;
17251    }
17252    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
17253    {
17254       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
17255       return;
17256    }
17257
17258 #ifdef DEBUG_ASN_PRINT
17259    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
17260    for(i=0; i< recvBufLen; i++)
17261    {
17262       printf("%x",recvBuf[i]);
17263    }
17264 #endif
17265
17266    /* Decoding flat buffer into F1AP messsage */
17267    f1apMsg = &f1apasnmsg;
17268    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
17269
17270    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
17271
17272    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
17273    {
17274       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
17275       return;
17276    }
17277    printf("\n");
17278    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
17279
17280    switch(f1apMsg->present)
17281    {
17282       case F1AP_PDU_PR_successfulOutcome:
17283          {
17284             switch(f1apMsg->choice.successfulOutcome->value.present)
17285             {
17286                case SuccessfulOutcome__value_PR_ResetAcknowledge:
17287                   {
17288                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
17289                      break;
17290                   }
17291                case SuccessfulOutcome__value_PR_F1SetupResponse:
17292                   {
17293 #ifndef ODU_TEST_STUB
17294                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
17295 #endif
17296                      break;
17297                   }
17298
17299                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
17300                   {
17301                      procF1GNBDUCfgUpdAck(f1apMsg);
17302                      break;
17303                   }
17304
17305                default:
17306                   {
17307                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
17308                            f1apMsg->choice.successfulOutcome->value.present);
17309                      return;
17310                   }
17311             }/* End of switch(successfulOutcome) */
17312             free(f1apMsg->choice.successfulOutcome);
17313             break;
17314          }
17315       case F1AP_PDU_PR_initiatingMessage:
17316          {
17317             switch(f1apMsg->choice.initiatingMessage->value.present)
17318             {
17319                case InitiatingMessage__value_PR_Reset:
17320                   {
17321                      procF1ResetReq(f1apMsg);
17322                      break;
17323                   }
17324                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
17325                   {
17326                      procF1DlRrcMsgTrans(f1apMsg);
17327                      break;
17328                   }
17329                case InitiatingMessage__value_PR_UEContextSetupRequest:
17330                   {
17331                      procF1UeContextSetupReq(f1apMsg);
17332                      break;
17333                   }
17334                case InitiatingMessage__value_PR_UEContextModificationRequest:
17335                   {
17336                      procF1UeContextModificationReq(f1apMsg);
17337                      break;
17338                   }
17339                case InitiatingMessage__value_PR_UEContextReleaseCommand:
17340                   {
17341                       procF1UeContextReleaseCommand(f1apMsg);
17342                       break;
17343                   }
17344                case InitiatingMessage__value_PR_Paging:
17345                   {
17346                      procPagingMsg(f1apMsg);
17347                      break;
17348                   }
17349                default:
17350                   {
17351                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
17352                            f1apMsg->choice.initiatingMessage->value.present);
17353                      return;
17354                   }
17355             }/* End of switch(initiatingMessage) */
17356             free(f1apMsg->choice.initiatingMessage);
17357             break;
17358          }
17359
17360       default:
17361          {
17362             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
17363             return;
17364          }
17365          free(f1apMsg);
17366
17367    }/* End of switch(f1apMsg->present) */
17368
17369    DU_FREE(recvBuf, (Size)recvBufLen);
17370 } /* End of F1APMsgHdlr */
17371
17372 /**********************************************************************
17373   End of file
17374  **********************************************************************/