src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "ckw.h"
  22 #include "ckw.x"
  23 #include "kwu.h"
  24 #include "kwu.x"
  25 #include "lkw.h"
  26 #include "lrg.h"
  27 #include "legtp.h"
  28 #include "lkw.x"
  29 #include "lrg.x"
  30 #include "F1AP-PDU.h"
  31 #include "InitiatingMessage.h"
  32 #include "SuccessfulOutcome.h"
  33 #include "du_app_mac_inf.h"
  34 #include "du_cfg.h"
  35 #include "du_app_rlc_inf.h"
  36 #include "du_mgr_main.h"
  37 #include "du_mgr.h"
  38 #include "du_utils.h"
  39 #include "du_ue_mgr.h"
  40 #include "RAT-Type.h"
  41 #include "NRFreqInfo.h"
  42 #include "NRCGI.h"
  43 #include "TDD-Info.h"
  44 #include "NR-Mode-Info.h"
  45 #include "ServedPLMNs-List.h"
  46 #include "GNB-DU-Served-Cells-List.h"
  47 #include "Served-Cell-Information.h"
  48 #include "ProtocolExtensionContainer.h"
  49 #include "RRC-Version.h"
  50 #include "FDD-Info.h"
  51 #include "FreqBandNrItem.h"
  52 #include "ServedPLMNs-Item.h"
  53 #include "GNB-DU-Served-Cells-Item.h"
  54 #include "SliceSupportItem.h"
  55 #include "FeatureSetUplinkPerCC.h"
  56 #include "SliceSupportItem.h"
  57 #include "Served-Cells-To-Modify-Item.h"
  58 #include "Served-Cells-To-Delete-List.h"
  59 #include "Served-Cells-To-Delete-Item.h"
  60 #include "QoSInformation.h"
  61 #include "ULUPTNLInformation-ToBeSetup-List.h"
  62 #include "DRB-Information.h"
  63 #include "DRBs-ToBeSetup-Item.h"
  64 #include "DRBs-ToBeSetupMod-Item.h"
  65 #include "DRBs-ToBeModified-Item.h"
  66 #include "CUtoDURRCInformation.h"
  67 #include "SCell-ToBeSetup-List.h"
  68 #include "SRBs-ToBeSetup-List.h"
  69 #include "DRBs-ToBeSetup-List.h"
  70 #include "SRBs-ToBeSetup-Item.h"
  71 #include "DRBs-ToBeModified-List.h"
  72 #include "RRCContainer.h"
  73 #include "UE-CapabilityRAT-ContainerList.h"
  74 #include "DRBs-Setup-List.h"
  75 #include "CellGroupConfig.h"
  76 #include "ResetAll.h"
  77 #include "ResetType.h"
  78 #include "Cells-to-be-Activated-List.h"
  79 #include "GNB-CU-Name.h"
  80 #include "SRBs-SetupMod-List.h"
  81 #include "DRBs-SetupMod-List.h"
  82 #include "DRBs-ToBeSetupMod-List.h"
  83 #include "PagingCell-Item.h"
  84 #include "PagingCell-list.h"
  85 #include "QoS-Characteristics.h"
  86 #include "ULUPTNLInformation-ToBeSetup-Item.h"
  87 #include "Flows-Mapped-To-DRB-Item.h"
  88 #include "NonDynamic5QIDescriptor.h"
  89 #include "Dynamic5QIDescriptor.h"
  90 #include "FeatureSetDownlinkPerCC.h"
  91 #include "FeatureSets.h"
  92 #include "UE-NR-Capability.h"
  93 #include "UE-CapabilityRAT-Container.h"
  94 #include "UE-CapabilityRAT-ContainerListRRC.h"
  95 #include "GNB-DU-System-Information.h"
  96 #include "CellGroupConfigRrc.h"
  97 #include "MAC-CellGroupConfig.h"
  98 #include "SchedulingRequestConfig.h"
  99 #include "SchedulingRequestToAddMod.h"
 100 #include "BSR-Config.h"
 101 #include "TAG-Config.h"
 102 #include "TAG.h"
 103 #include "PHR-Config.h"
 104 #include "RLC-Config.h"
 105 #include "UL-AM-RLC.h"
 106 #include "DL-AM-RLC.h"
 107 #include "LogicalChannelConfig.h"
 108 #include "RLC-BearerConfig.h"
 109 #include "PhysicalCellGroupConfig.h"
 110 #include "SpCellConfig.h"
 111 #include "TDD-UL-DL-ConfigDedicated.h"
 112 #include "ServingCellConfig.h"
 113 #include "ControlResourceSet.h"
 114 #include "SearchSpace.h"
 115 #include "PDCCH-Config.h"
 116 #include "PDSCH-TimeDomainResourceAllocation.h"
 117 #include "PDSCH-TimeDomainResourceAllocationList.h"
 118 #include "PDSCH-CodeBlockGroupTransmission.h"
 119 #include "PDSCH-ServingCellConfig.h"
 120 #include "DMRS-DownlinkConfig.h"
 121 #include "PDSCH-Config.h"
 122 #include "BWP-DownlinkDedicated.h"
 123 #include "BWP-Downlink.h"
 124 #include "PUSCH-TimeDomainResourceAllocation.h"
 125 #include "PUSCH-TimeDomainResourceAllocationList.h"
 126 #include "DMRS-UplinkConfig.h"
 127 #include "PUSCH-Config.h"
 128 #include "SRS-ResourceId.h"
 129 #include "SRS-Resource.h"
 130 #include "SRS-ResourceSet.h"
 131 #include "SRS-Config.h"
 132 #include "BWP-UplinkDedicated.h"
 133 #include "PUSCH-ServingCellConfig.h"
 134 #include "UplinkConfig.h"
 135 #include "DUtoCURRCContainer.h"
 136 #include "GBR-QoSFlowInformation.h"
 137 #include "QoSFlowLevelQoSParameters.h"
 138 #include "PUCCH-Config.h"
 139 #include "PUCCH-ResourceSet.h"
 140 #include "PUCCH-Resource.h"
 141 #include "PUCCH-PowerControl.h"
 142 #include "P0-PUCCH.h"
 143 #include "PUCCH-PathlossReferenceRS.h"
 144 #include "PUCCH-format0.h"
 145 #include "PUCCH-format1.h"
 146 #include "PUCCH-format2.h"
 147 #include "PUCCH-format3.h"
 148 #include "PUCCH-format4.h"
 149 #include "PUCCH-FormatConfig.h"
 150 #include "SchedulingRequestResourceConfig.h"
 151 #include<ProtocolIE-Field.h>
 152 #include "ProtocolExtensionField.h"
 153 #include "odu_common_codec.h"
 154 #include "du_mgr.h"
 155 #include "du_cell_mgr.h"
 156 #include "du_f1ap_msg_hdl.h"
 157 #include "DRBs-Setup-Item.h"
 158 #include "DLUPTNLInformation-ToBeSetup-List.h"
 159 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 160 #include "UPTransportLayerInformation.h"
 161 #include "GTPTunnel.h"
 162 #include "SupportedSULFreqBandItem.h"
 163 #include "du_e2ap_msg_hdl.h"
 164 #include "du_f1ap_conversions.h"
 165 #include "CNUEPagingIdentity.h"
 166 #include "PCCH-Config.h"
 167 #include "SCS-SpecificCarrier.h"
 168 #include "FrequencyInfoDL.h"
 169 #include "DownlinkConfigCommon.h"
 170 #include "FrequencyInfoUL.h"
 171 #include "UplinkConfigCommon.h"
 172 #include "TDD-UL-DL-ConfigCommon.h"
 173 #include "RACH-ConfigDedicated.h"
 174 #include "CFRA-SSB-Resource.h"
 175 #include "BWP-UplinkCommon.h"
 176 #include "ReconfigurationWithSync.h"
 177 #include "du_sys_info_hdl.h"
 178 #include "DRX-ConfigRrc.h"
 179
 180 #ifdef O1_ENABLE
 181 #include "CmInterface.h"
 182 extern StartupConfig g_cfg;
 183 #endif
 184
 185 DuCfgParams duCfgParam;
 186
 187 /******************************************************************
 188  *
 189  * @brief Function to fetch lcId based on DRB Id
 190  *
 191  * @details
 192  *
 193  *    Function : fetchLcId
 194  *
 195  *    @params[in] drbId
 196  *
 197  *    Functionality: Function to fetch lcId based on DRB Id
 198  *
 199  * Returns: lcId - SUCCESS
 200  *          RFAILED - FAILURE
 201  *****************************************************************/
 202
 203 uint8_t fetchLcId(uint8_t drbId)
 204 {
 205    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 206
 207    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 208    {
 209       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 210       {
 211          if(duCb.actvCellLst[cellIdx] != NULLP)
 212          {
 213             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.numLcs;
 214             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 215             {
 216                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbId == drbId && \
 217                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbType == RB_TYPE_DRB)
 218                {
 219                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].lcId;
 220                   return lcId;
 221                }
 222             }
 223          }
 224       }
 225    }
 226    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 227    return RFAILED;
 228 }
 229
 230 /*******************************************************************
 231 *
 232 * @brief Adding F1AP pdu to reserved pdu list
 233 *
 234 * @details
 235 *
 236 *    Function : addToReservedF1apPduList
 237 *
 238 *    Functionality: Adding F1AP pdu to reserved pdu list.
 239 *     These pdu are awaiting aknowledgment from CU
 240 *
 241 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 242 *
 243 * @return ROK - success
 244 *         RFAILED - failure
 245 *
 246 * ****************************************************************/
 247 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 248 {
 249    CmLList         *node = NULLP;
 250    ReservedF1apPduInfo *pduInfo = NULLP;
 251    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 252    if(pduInfo)
 253    {
 254       DU_ALLOC(node, sizeof(CmLList));
 255       if(node)
 256       {
 257          pduInfo->transId = transId;
 258          pduInfo->f1apMsg = (void*) f1apPdu;
 259
 260          node->node = (PTR)pduInfo;
 261          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 262       }
 263    }
 264 }
 265
 266 /*******************************************************************
 267 *
 268 * @brief searching for F1AP pdu from ReservedF1apPduList
 269 *
 270 * @details
 271 *
 272 *    Function : searchFromReservedF1apPduList
 273 *
 274 *    Functionality: searching for F1AP pdu information
 275 *
 276 * @params[in] uint8_t transId
 277 *
 278 * @return pointer to F1AP_PDU_t
 279 *
 280 * ****************************************************************/
 281
 282 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 283 {
 284    CmLList         *node;
 285    ReservedF1apPduInfo *f1apPdu;
 286    if(duCb.reservedF1apPduList.count)
 287    {
 288       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 289       while(node)
 290       {
 291          f1apPdu = (ReservedF1apPduInfo*)node->node;
 292          if(f1apPdu->transId == transId)
 293          {
 294             return node;
 295          }
 296          node = node->next;
 297       }
 298    }
 299    return NULL;
 300 }
 301
 302 /*******************************************************************
 303 *
 304 * @brief deleting F1AP pdu information from ReservedF1apPduList
 305 *
 306 * @details
 307 *
 308 *    Function : deleteFromReservedF1apPduList
 309 *
 310 *    Functionality: deleting pdu information from ReservedF1apPduList
 311 *
 312 * @params[in] CmLList *node
 313 *
 314 * @return void
 315 *
 316 * ****************************************************************/
 317
 318 void deleteFromReservedF1apPduList(CmLList *node)
 319 {
 320    ReservedF1apPduInfo *f1apPdu;
 321
 322    if(node != NULL)
 323    {
 324       f1apPdu = (ReservedF1apPduInfo *)node->node;
 325       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 326       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 327       DU_FREE(node, sizeof(CmLList));
 328       node = NULL;
 329    }
 330 }
 331
 332 /*******************************************************************
 333  *
 334  * @brief Builds Uplink Info for NR
 335  *
 336  * @details
 337  *
 338  *    Function : BuildULNRInfo
 339  *
 340  *    Functionality: Building NR Uplink Info
 341  *
 342  * @params[in] NRFreqInfo_t *ulnrfreq
 343  * @return ROK     - success
 344  *         RFAILED - failure
 345  *
 346  * ****************************************************************/
 347 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 348 {
 349    uint8_t idx=0;
 350    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 351                        fdd.ulNrFreqInfo.nrArfcn;
 352    ulnrfreq->freqBandListNr.list.count = 1;
 353    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 354    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 355    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 356    {
 357       return RFAILED;
 358    }
 359    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 360    {
 361       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 362       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 363       {
 364          return RFAILED;
 365       }
 366    }
 367    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 368                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 369                                                                  freqBand[0].nrFreqBand;
 370    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 371    return ROK;
 372 }
 373 /*******************************************************************
 374  *
 375  * @brief Builds Downlink NR Info
 376  *
 377  * @details
 378  *
 379  *    Function : BuildDLNRInfo
 380  *
 381  *    Functionality: Building Downlink NR Info
 382  *
 383  * @params[in] NRFreqInfo_t *dlnrfreq
 384  * @return ROK     - success
 385  *         RFAILED - failure
 386  *
 387  * ****************************************************************/
 388 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 389 {
 390    uint8_t idx=0;
 391    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 392                        fdd.dlNrFreqInfo.nrArfcn;
 393    dlnrfreq->freqBandListNr.list.count = 1;
 394    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 395    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 396    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 397    {
 398       return RFAILED;
 399    }
 400    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 401    {
 402       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 403       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 404       {
 405          return RFAILED;
 406       }
 407    }
 408    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 409                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 410                                                                  freqBand[0].nrFreqBand;
 411    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 412
 413    return ROK;
 414 }
 415
 416 /*******************************************************************
 417  *
 418  * @brief Builds Nrcgi
 419  *
 420  * @details
 421  *
 422  *    Function : BuildNrcgi
 423  *
 424  *    Functionality: Building the PLMN ID and NR Cell id
 425  *
 426  * @params[in] NRCGI_t *nrcgi
 427  * @return ROK     - success
 428  *         RFAILED - failure
 429  *
 430  * ****************************************************************/
 431 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 432 {
 433    uint8_t ret;
 434    uint8_t byteSize = 5;
 435    /* Allocate Buffer Memory */
 436    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 437    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 438    if(nrcgi->pLMN_Identity.buf == NULLP)
 439    {
 440       return RFAILED;
 441    }
 442    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 443          nrcgi->pLMN_Identity.buf); // Building PLMN function
 444    if(ret != ROK)
 445    {
 446       return RFAILED;
 447    }
 448    /*nrCellIdentity*/
 449    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 450    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 451    if(nrcgi->nRCellIdentity.buf == NULLP)
 452    {
 453       return RFAILED;
 454    }
 455    fillBitString(&nrcgi->nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
 456
 457    return ROK;
 458 }
 459 /*******************************************************************
 460  *
 461  * @brief Builds FiveGStac
 462  *
 463  * @details
 464  *
 465  *    Function : BuildFiveGSTac
 466  *
 467  *    Functionality: Building the FiveGSTac
 468  *
 469  * @params[in] OCTET_STRING_t *fivegsTac
 470  * @return ROK     - success
 471  *         RFAILED - failure
 472  *
 473  * ****************************************************************/
 474 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 475 {
 476    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 477    if(servcell->fiveGS_TAC == NULLP)
 478    {
 479       return RFAILED;
 480    }
 481    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 482    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 483          sizeof(servcell->fiveGS_TAC->size));
 484    if(servcell->fiveGS_TAC->buf == NULLP)
 485    {
 486       return RFAILED;
 487    }
 488    servcell->fiveGS_TAC->buf[0] = 0;
 489    servcell->fiveGS_TAC->buf[1] = 0;
 490    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 491    return ROK;
 492 }
 493
 494 /*******************************************************************
 495  *
 496  * @brief fill nr frequency information
 497  *
 498  * @details
 499  *
 500  *    Function : fillNrTddInfo
 501  *
 502  *    Functionality: fill nr frequency information
 503  *
 504  * @params[in] NRFreqInfo_t freqInfo
 505  * @return ROK     - success
 506  *         RFAILED - failure
 507  *
 508  * ****************************************************************/
 509 uint8_t fillNrTddInfo(TDD_Info_t *tddInfo)
 510 {
 511    uint8_t elementCnt = 1, freqBandListIdx = 0, supportedBandIdx = 0;
 512    NRFreqInfo_t *freqInfo = NULLP;
 513
 514    if(tddInfo == NULLP)
 515    {
 516       DU_LOG("\nERROR  --> DU APP : Null pointer received at fillNrTddInfo");
 517       return RFAILED;
 518    }
 519
 520    freqInfo = &tddInfo->nRFreqInfo;
 521    freqInfo->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn;
 522
 523    freqInfo->freqBandListNr.list.count = elementCnt;
 524    freqInfo->freqBandListNr.list.size = freqInfo->freqBandListNr.list.count  * sizeof(FreqBandNrItem_t *);
 525    DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
 526    if(!freqInfo->freqBandListNr.list.array)
 527    {
 528       DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 529       return RFAILED;
 530    }
 531
 532    for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
 533    {
 534       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
 535       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
 536       {
 537          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 538          return RFAILED;
 539       }
 540
 541       freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
 542       f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
 543       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
 544       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
 545       supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
 546
 547       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
 548             freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
 549       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
 550       {
 551          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 552          return RFAILED;
 553       }
 554
 555       for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
 556       {
 557          DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
 558                sizeof(SupportedSULFreqBandItem_t));
 559          if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
 560          {
 561             DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 562             return RFAILED;
 563          }
 564
 565          freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx]->freqBandIndicatorNr =\
 566          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.freqBand[0].sulBand[0];
 567       }
 568    }
 569
 570    tddInfo->transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs;
 571    tddInfo->transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb;
 572
 573    return ROK;
 574 }
 575
 576 /*******************************************************************
 577  *
 578  * @brief Builds NR Mode
 579  *
 580  * @details
 581  *
 582  *    Function : BuildNrMode
 583  *
 584  *    Functionality: Building the NR Mode
 585  *
 586  * @params[in] NR_Mode_Info_t *fdd
 587  * @return ROK     - success
 588  *         RFAILED - failure
 589  *
 590  * ****************************************************************/
 591 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 592 {
 593    uint8_t BuildDLNRInforet=0;
 594    uint8_t BuildULNRInforet=0;
 595
 596 #ifdef NR_TDD
 597    mode->present = NR_Mode_Info_PR_tDD;
 598 #else
 599    mode->present = NR_Mode_Info_PR_fDD;
 600 #endif
 601
 602    if(mode->present == NR_Mode_Info_PR_fDD)
 603    {
 604       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 605       if(mode->choice.fDD == NULLP)
 606       {
 607          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 608          return RFAILED;
 609       }
 610       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 611       if(BuildULNRInforet != ROK)
 612       {
 613          DU_LOG("\nERROR  --> Failed to build UlNrFreqInfo");
 614          return RFAILED;
 615       }
 616       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 617       if(BuildDLNRInforet != ROK)
 618       {
 619          DU_LOG("\nERROR  --> Failed to build DlNrFreqInfo");
 620          return RFAILED;
 621       }
 622       mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 623                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 624                                                           f1Mode.mode.fdd.ulTxBw.nrScs;
 625       mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 626                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 627                                                           f1Mode.mode.fdd.ulTxBw.nrb;
 628       mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 629                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 630                                                           f1Mode.mode.fdd.dlTxBw.nrScs;
 631       mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 632                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
 633                                                           f1Mode.mode.fdd.dlTxBw.nrb;
 634    }
 635    else if(mode->present == NR_Mode_Info_PR_tDD)
 636    {
 637       DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
 638       if(mode->choice.tDD == NULLP)
 639       {
 640          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
 641          return RFAILED;
 642       }
 643
 644       if(fillNrTddInfo(mode->choice.tDD) != ROK)
 645       {
 646          DU_LOG("\nERROR  --> Failed to fill Nr TDD information");
 647          return RFAILED;
 648       }
 649
 650    }
 651
 652    return ROK;
 653 }
 654 /*******************************************************************
 655  *
 656  * @brief Builds IE Extensions for Served PLMNs
 657  *
 658  * @details
 659  *
 660  *    Function : BuildExtensions
 661  *
 662  *    Functionality: Building the IE Extensions
 663  *
 664  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 665  * @return ROK     - success
 666  *         RFAILED - failure
 667  *
 668  * ****************************************************************/
 669 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 670 {
 671    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 672    uint8_t elementCnt=0, extensionCnt=0;
 673
 674    extensionCnt=IE_EXTENSION_LIST_COUNT;
 675    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 676    if((*ieExtend) == NULLP)
 677    {
 678       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 679       return RFAILED;
 680    }
 681    (*ieExtend)->list.count = extensionCnt;
 682    (*ieExtend)->list.size = \
 683                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 684    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 685    if((*ieExtend)->list.array == NULLP)
 686    {
 687       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 688       return RFAILED;
 689    }
 690    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 691    {
 692       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 693             sizeof(ServedPLMNs_ItemExtIEs_t));
 694       if((*ieExtend)->list.array[plmnidx] == NULLP)
 695       {
 696          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 697          return RFAILED;
 698       }
 699    }
 700
 701    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 702    idx = 0;
 703    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 704    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 705    (*ieExtend)->list.array[idx]->extensionValue.present = \
 706    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 707    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 708       list.count = elementCnt;
 709    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 710       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 711       list.count * sizeof(SliceSupportItem_t *);
 712
 713    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 714          list.array, elementCnt * sizeof(SliceSupportItem_t *));
 715    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 716          list.array == NULLP)
 717    {
 718       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 719       return RFAILED;
 720    }
 721
 722    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
 723    {
 724       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 725             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
 726       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 727             list.array[sliceLstIdx] == NULLP)
 728       {
 729          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 730          return RFAILED;
 731       }
 732       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 733          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
 734       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 735             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
 736             extensionValue.choice.SliceSupportList.\
 737             list.array[sliceLstIdx]->sNSSAI.sST.size);
 738       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
 739             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
 740       {
 741          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 742          return RFAILED;
 743       }
 744       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 745          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
 746          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
 747
 748       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 749             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
 750       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 751             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
 752       {
 753          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 754          return RFAILED;
 755       }
 756       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 757          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
 758       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 759             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
 760             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 761       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 762             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
 763       {
 764          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 765          return RFAILED;
 766       }
 767       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 768       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
 769       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
 770       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
 771    }
 772    return ROK;
 773 }
 774 /*******************************************************************
 775  *
 776  * @brief Builds Served PLMN
 777  *
 778  * @details
 779  *
 780  *    Function : BuildServedPlmn
 781  *
 782  *    Functionality: Building the Served PLMN
 783  *
 784  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
 785  * @return ROK     - success
 786  *         RFAILED - failure
 787  *
 788  * ****************************************************************/
 789 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
 790 {
 791    uint8_t  plmnidx;
 792    uint8_t  servPlmnCnt=1;
 793    uint8_t buildPlmnIdret=0;
 794    uint8_t BuildExtensionsret=0;
 795    srvplmn->list.count = servPlmnCnt;
 796    srvplmn->list.size = \
 797                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
 798    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
 799    if(srvplmn->list.array == NULLP)
 800    {
 801       return RFAILED;
 802    }
 803    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
 804    {
 805       DU_ALLOC(srvplmn->list.array[plmnidx],\
 806             sizeof(ServedPLMNs_Item_t));
 807       if(srvplmn->list.array[plmnidx] == NULLP)
 808       {
 809          return RFAILED;
 810       }
 811    }
 812    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 813    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
 814    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 815          srvplmn->list.array[0]->pLMN_Identity.buf);
 816    if(buildPlmnIdret!= ROK)
 817    {
 818       return RFAILED;
 819    }
 820    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
 821    if(BuildExtensionsret!= ROK)
 822    {
 823       return RFAILED;
 824    }
 825    return ROK;
 826 }
 827 /*******************************************************************
 828  *
 829  * @brief Builds Served Cell List
 830  *
 831  * @details
 832  *
 833  *    Function : BuildServedCellList
 834  *
 835  *    Functionality: Building Served Cell List
 836  *
 837  * @params[in] PLMNID plmn
 838  * @return ROK     - success
 839  *         RFAILED - failure
 840  *
 841  * ****************************************************************/
 842
 843 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
 844 {
 845    uint8_t  BuildNrcgiret=0;
 846    uint8_t  BuildFiveGSTacret=0;
 847    uint8_t  BuildServedPlmnret=0;
 848    uint8_t  BuildNrModeret=0;
 849    uint8_t  idx;
 850    uint8_t  plmnidx;
 851    uint8_t  plmnCnt=1;
 852    GNB_DU_Served_Cells_Item_t *srvCellItem;
 853    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
 854    duServedCell->list.count = plmnCnt;
 855
 856    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
 857    if(duServedCell->list.array == NULLP)
 858    {
 859       return RFAILED;
 860    }
 861    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
 862    {
 863       DU_ALLOC(duServedCell->list.array[plmnidx],\
 864             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
 865       if(duServedCell->list.array[plmnidx] == NULLP)
 866       {
 867          return RFAILED;
 868       }
 869    }
 870    idx = 0;
 871    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
 872    duServedCell->list.array[idx]->criticality = Criticality_reject;
 873    duServedCell->list.array[idx]->value.present = \
 874                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
 875    srvCellItem = \
 876                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
 877    /*nRCGI*/
 878    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
 879    if(BuildNrcgiret != ROK)
 880    {
 881       return RFAILED;
 882    }
 883    /*nRPCI*/
 884    srvCellItem->served_Cell_Information.nRPCI = \
 885                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
 886
 887    /*fiveGS_TAC*/
 888    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
 889    if(BuildFiveGSTacret != ROK)
 890    {
 891       return RFAILED;
 892    }
 893    /*Served PLMNs*/
 894    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
 895    if(BuildServedPlmnret !=ROK)
 896    {
 897       return RFAILED;
 898    }
 899    /*nR Mode Info with FDD*/
 900    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
 901    if(BuildNrModeret != ROK)
 902    {
 903       return RFAILED;
 904    }
 905    /*Measurement timing Config*/
 906    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
 907       size = sizeof(uint8_t);
 908    DU_ALLOC(srvCellItem->served_Cell_Information.\
 909          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
 910    if(srvCellItem->served_Cell_Information.\
 911          measurementTimingConfiguration.buf == NULLP)
 912    {
 913       return RFAILED;
 914    }
 915    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
 916                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
 917
 918    /* GNB DU System Information */
 919    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
 920          sizeof(GNB_DU_System_Information_t));
 921    if(!srvCellItem->gNB_DU_System_Information)
 922    {
 923       return RFAILED;
 924    }
 925    /* MIB */
 926    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
 927    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
 928          srvCellItem->gNB_DU_System_Information->mIB_message.size);
 929    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
 930    {
 931       return RFAILED;
 932    }
 933    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
 934                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
 935
 936    /* SIB1 */
 937    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
 938                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
 939
 940    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
 941          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
 942    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
 943    {
 944       return RFAILED;
 945    }
 946    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
 947    {
 948       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
 949                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
 950    }
 951    return ROK;
 952 }
 953 /*******************************************************************
 954  *
 955  * @brief Builds RRC Version
 956  *
 957  * @details
 958  *
 959  *    Function : BuildRrcVer
 960  *
 961  *    Functionality: Building RRC Version
 962  *
 963  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
 964  * @return ROK     - success
 965  *         RFAILED - failure
 966  *
 967  * ****************************************************************/
 968 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
 969 {
 970    uint8_t rrcExt;
 971    uint8_t rrcLatest;
 972    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
 973    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
 974    if(rrcVer->latest_RRC_Version.buf == NULLP)
 975    {
 976       return RFAILED;
 977    }
 978    rrcVer->latest_RRC_Version.buf[0] = 0;
 979    rrcVer->latest_RRC_Version.bits_unused = 5;
 980    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
 981    if(rrcVer->iE_Extensions == NULLP)
 982    {
 983       return RFAILED;
 984    }
 985    rrcVer->iE_Extensions->list.count = 1;
 986    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
 987    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
 988    if(rrcVer->iE_Extensions->list.array == NULLP)
 989    {
 990       return RFAILED;
 991    }
 992    rrcExt = 0;
 993    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
 994          sizeof(RRC_Version_ExtIEs_t));
 995    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
 996    {
 997       return RFAILED;
 998    }
 999    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1000                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1001    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1002    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1003                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1004    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1005       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1006    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1007          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1008          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1009    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1010          .Latest_RRC_Version_Enhanced.buf == NULLP)
1011    {
1012       return RFAILED;
1013    }
1014    rrcLatest = 0;
1015    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1016       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1017    rrcLatest++;
1018    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1019       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1020    rrcLatest++;
1021    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1022       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1023    return ROK;
1024 }
1025 /*******************************************************************
1026  *
1027  * @brief Sends F1 msg over SCTP
1028  *
1029  * @details
1030  *
1031  *    Function : sendF1APMsg
1032  *
1033  *    Functionality: Sends F1 msg over SCTP
1034  *
1035  * @params[in] Region region
1036  *             Pool pool
1037  * @return ROK     - success
1038  *         RFAILED - failure
1039  *
1040  * ****************************************************************/
1041 uint8_t sendF1APMsg()
1042 {
1043    Buffer *mBuf = NULLP;
1044
1045    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1046    {
1047       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1048       {
1049             ODU_PRINT_MSG(mBuf, 0,0);
1050
1051             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1052             {
1053                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1054                ODU_PUT_MSG_BUF(mBuf);
1055                return RFAILED;
1056             }
1057       }
1058       else
1059       {
1060          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1061          ODU_PUT_MSG_BUF(mBuf);
1062          return RFAILED;
1063       }
1064       ODU_PUT_MSG_BUF(mBuf);
1065    }
1066    else
1067    {
1068       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1069       return RFAILED;
1070    }
1071    return ROK;
1072 } /* sendF1APMsg */
1073
1074 /*******************************************************************
1075  *
1076  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1077  *
1078  * @details
1079  *
1080  *    Function :  FreeRrcVer
1081  *
1082  *    Functionality: deallocating the memory of function BuildRrcVer
1083  *
1084  * @params[in] RRC_Version_t *rrcVer
1085  *
1086  * @return void
1087  *
1088  *****************************************************************/
1089 void FreeRrcVer(RRC_Version_t *rrcVer)
1090 {
1091    if(rrcVer->latest_RRC_Version.buf != NULLP)
1092    {
1093       if(rrcVer->iE_Extensions != NULLP)
1094       {
1095          if(rrcVer->iE_Extensions->list.array != NULLP)
1096          {
1097             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1098             {
1099                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1100                      != NULLP)
1101                {
1102                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1103                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1104                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1105                }
1106                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1107             }
1108             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1109          }
1110          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1111       }
1112       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1113    }
1114 }
1115
1116 /*******************************************************************
1117  *
1118  * @brief Deallocating memory of TDD NrFreqInfo
1119  *
1120  * @details
1121  *
1122  *    Function : freeTddNrFreqInfo
1123  *
1124  *    Functionality: freeTddNrFreqInfo
1125  *
1126  * @params[in]  F1AP_PDU_t *f1apDuCfg
1127  *
1128  * @return ROK     - void
1129  *
1130  * ****************************************************************/
1131 void freeTddNrFreqInfo(NRFreqInfo_t *freqInfo)
1132 {
1133    uint8_t freqBandListIdx = 0, supportedBandIdx = 0;
1134
1135    if(freqInfo->freqBandListNr.list.array)
1136    {
1137       for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
1138       {
1139          if(freqInfo->freqBandListNr.list.array[freqBandListIdx])
1140          {
1141             if(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
1142             {
1143                for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
1144                {
1145                   DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1146                         sizeof(SupportedSULFreqBandItem_t));
1147                }
1148                DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
1149                      freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
1150
1151             }
1152             DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
1153          }
1154       }
1155       DU_FREE(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
1156    }
1157 }
1158
1159 /*******************************************************************
1160  *
1161  * @brief Deallocating memory allocated for Nr fdd frequencey mode
1162  *
1163  * @details
1164  *
1165  *    Function : freeFddNrFreqInfo
1166  *
1167  *    Functionality:Free memory allocated for Nr fdd frequencey mode
1168  *
1169  * @params[in]
1170  *
1171  * @return ROK     - void
1172  *
1173  * ****************************************************************/
1174 void freeFddNrFreqInfo(FDD_Info_t *fDD)
1175 {
1176    uint8_t arrIdx =0;
1177
1178    if(fDD != NULLP)
1179    {
1180       if(fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1181       {
1182          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1183                array[arrIdx], sizeof(FreqBandNrItem_t));
1184          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1185                fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1186       }
1187
1188       if(fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1189       {
1190          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.\
1191                array[arrIdx], sizeof(FreqBandNrItem_t));
1192          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1193                fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1194       }
1195       DU_FREE(fDD,sizeof(FDD_Info_t));
1196    }
1197 }
1198
1199 /*******************************************************************
1200  *
1201  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1202  *
1203  * @details
1204  *
1205  *    Function :  FreeServedCellList
1206  *
1207  *    Functionality:  deallocating the memory of function BuildServedCellList
1208
1209  *
1210  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1211  *
1212  * @return void
1213  *
1214  * ****************************************************************/
1215 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1216 {
1217    uint8_t   plmnCnt=MAX_PLMN;
1218    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1219    uint8_t  plmnIdx=0, sliceIdx=0;
1220    GNB_DU_Served_Cells_Item_t *srvCellItem;
1221    ServedPLMNs_Item_t  *servedPlmnItem;
1222    SliceSupportItem_t  *sliceSupportItem;
1223
1224    if(duServedCell->list.array!=NULLP)
1225    {
1226       if(duServedCell->list.array[0]!=NULLP)
1227       {
1228          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1229
1230          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1231                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1232          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1233                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1234
1235          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1236          {
1237             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1238                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1239             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1240          }
1241
1242          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1243          {
1244             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1245             {
1246                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1247                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1248
1249                if(servedPlmnItem->iE_Extensions != NULLP)
1250                {
1251                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1252                   {
1253                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1254                      {
1255                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1256                               SliceSupportList.list.array != NULLP)
1257                         {
1258                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1259                                  extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1260                            {
1261                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1262                                     SliceSupportList.list.array[sliceIdx] != NULLP)
1263                               {
1264                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1265                                                     extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1266
1267                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1268
1269                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1270                                  {
1271                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1272                                           sliceSupportItem->sNSSAI.sD->size);
1273                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1274                                  }
1275
1276                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1277                                        choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1278                               }
1279                            }
1280                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1281                                  SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1282                                  extensionValue.choice.SliceSupportList.list.size);
1283                         }
1284                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1285                               sizeof(ServedPLMNs_ItemExtIEs_t));
1286                      }
1287                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1288                            extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1289                   }
1290                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1291                }
1292                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1293                      sizeof(ServedPLMNs_Item_t));
1294             }
1295             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1296                   sizeof(ServedPLMNs_Item_t *));
1297          }
1298
1299          if(srvCellItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1300          {
1301             freeFddNrFreqInfo(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1302          }
1303          else
1304          {
1305             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD != NULLP)
1306             {
1307                freeTddNrFreqInfo(&srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1308                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1309             }
1310          }
1311
1312          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1313                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1314
1315          if(srvCellItem->gNB_DU_System_Information != NULLP)
1316          {
1317             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1318             {
1319                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1320                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1321             }
1322
1323             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1324             {
1325                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1326                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1327             }
1328
1329             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1330          }
1331
1332          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1333       }
1334       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1335    }
1336 }
1337
1338 /*******************************************************************
1339  *
1340  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1341  *
1342  * @details
1343  *
1344  *    Function :  FreeF1SetupReq
1345  *
1346  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1347  *
1348  * @params[in] F1AP_PDU_t *f1apMsg
1349  *
1350  * @return void
1351  *
1352  * ****************************************************************/
1353 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1354 {
1355    uint8_t ieIdx, ieIdx2;
1356    F1SetupRequest_t *f1SetupReq=NULLP;
1357
1358    if(f1apMsg != NULLP)
1359    {
1360       if(f1apMsg->choice.initiatingMessage != NULLP)
1361       {
1362          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1363          if(f1SetupReq->protocolIEs.list.array != NULLP)
1364          {
1365             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1366             {
1367                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1368                {
1369                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1370                   {
1371                      case ProtocolIE_ID_id_TransactionID:
1372                         break;
1373                      case ProtocolIE_ID_id_gNB_DU_ID:
1374                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1375                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1376                         break;
1377                      case ProtocolIE_ID_id_gNB_DU_Name:
1378                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1379                               strlen((char *)duCfgParam.duName));
1380                         break;
1381                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1382                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1383                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1384                         break;
1385                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1386                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1387                         break;
1388                      default:
1389                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1390                         break;
1391                   }
1392                }
1393             }
1394             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1395             {
1396                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1397             }
1398             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1399                   f1SetupReq->protocolIEs.list.size);
1400          }
1401          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1402       }
1403       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1404    }
1405 }
1406 /*******************************************************************
1407  *
1408  * @brief Builds and Send the F1SetupRequest
1409  *
1410  * @details
1411  *
1412  *    Function : BuildAndSendF1SetupReq
1413  *
1414  * Functionality:Fills the F1SetupRequest
1415  *
1416  * @return ROK     - success
1417  *         RFAILED - failure
1418  *
1419  ******************************************************************/
1420 uint8_t BuildAndSendF1SetupReq()
1421 {
1422    uint8_t   ret, ieIdx, elementCnt;
1423    F1AP_PDU_t                 *f1apMsg = NULLP;
1424    F1SetupRequest_t           *f1SetupReq=NULLP;
1425    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1426    RRC_Version_t              *rrcVer=NULLP;
1427    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1428    ret= RFAILED;
1429
1430    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1431    do
1432    {
1433       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1434       if(f1apMsg == NULLP)
1435       {
1436          break;
1437       }
1438       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1439       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1440       if(f1apMsg->choice.initiatingMessage == NULLP)
1441       {
1442          break;
1443       }
1444       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1445       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1446       f1apMsg->choice.initiatingMessage->value.present = \
1447                                                          InitiatingMessage__value_PR_F1SetupRequest;
1448
1449       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1450
1451       elementCnt = 4;
1452
1453       f1SetupReq->protocolIEs.list.count = elementCnt;
1454       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1455
1456       /* Initialize the F1Setup members */
1457       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1458       if(f1SetupReq->protocolIEs.list.array == NULLP)
1459       {
1460          break;
1461       }
1462       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1463       {
1464          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1465                sizeof(F1SetupRequestIEs_t));
1466          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1467          {
1468             break;
1469          }
1470       }
1471
1472       ieIdx = 0;
1473       /*TransactionID*/
1474       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1475       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1476       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1477                                                                 F1SetupRequestIEs__value_PR_TransactionID;
1478       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1479                                                                               TRANS_ID;
1480
1481       /*DU ID*/
1482       ieIdx++;
1483       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1484       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1485       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1486                                                                  F1SetupRequestIEs__value_PR_GNB_DU_ID;
1487       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1488                                                                               sizeof(uint8_t);
1489
1490       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1491             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1492       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1493             NULLP)
1494       {
1495          break;
1496       }
1497
1498       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1499                                                                                 duCfgParam.duId;
1500 #if 0
1501       /* DU name IE is of type printableString_t which wireshark is unable to decode.
1502        * However this string is decoded successfully on online decoders.
1503        * Since this is an optional IE and the value received in it are not
1504        * used as of now, eliminating this IE for now to avoid wireshark error.
1505        */
1506       /*DU Name*/
1507       if(duCfgParam.duName != NULL)
1508       {
1509          ieIdx++;
1510          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1511          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1512          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1513          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size = strlen((char *)duCfgParam.duName);
1514          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf, \
1515                f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size);
1516          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf == NULLP)
1517          {
1518             break;
1519          }
1520          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,
1521                (char*)&duCfgParam.duName);
1522       }
1523 #endif
1524
1525       /*Served Cell list */
1526       ieIdx++;
1527       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1528                                                       ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1529       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1530       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1531                                                                  F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1532       duServedCell = &f1SetupReq->protocolIEs.list.\
1533                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1534       if(BuildServedCellList(duServedCell))
1535       {
1536          break;
1537       }
1538
1539
1540       /*RRC Version*/
1541       ieIdx++;
1542       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1543                                                       ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1544       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1545       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1546                                                                  F1SetupRequestIEs__value_PR_RRC_Version;
1547       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1548       if(BuildRrcVer(rrcVer))
1549       {
1550          break;
1551       }
1552
1553       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1554
1555       /* Encode the F1SetupRequest type as APER */
1556       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1557       encBufSize = 0;
1558       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1559             encBuf);
1560
1561       /* Encode results */
1562       if(encRetVal.encoded == ENCODE_FAIL)
1563       {
1564          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1565                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1566          break;
1567       }
1568       else
1569       {
1570          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1571 #ifdef DEBUG_ASN_PRINT
1572          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1573          {
1574             printf("%x",encBuf[ieIdx]);
1575          }
1576 #endif
1577
1578          duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize;
1579          DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize);
1580          if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
1581          {
1582             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the encoding of f1setup req");
1583             return RFAILED;
1584          }
1585          memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
1586       }
1587
1588       /* Sending msg */
1589       if(sendF1APMsg() != ROK)
1590       {
1591          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1592          break;
1593       }
1594
1595       ret=ROK;
1596       break;
1597    }while(true);
1598
1599    FreeF1SetupReq(f1apMsg);
1600
1601    return ret;
1602 }/* End of BuildAndSendF1SetupReq */
1603
1604 /*******************************************************************
1605  *
1606  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1607  *
1608  * @details
1609  *
1610  *    Function : freeCellsToModifyItem
1611  *
1612  *    Functionality: Deallocating memory of variables allocated in
1613  *                    BuildAndSendDUConfigUpdate function
1614  *
1615  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1616  *
1617  * @return ROK     - void
1618  *
1619  * ****************************************************************/
1620
1621 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1622 {
1623    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1624    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1625    SliceSupportItem_t *sliceSupportItem = NULLP;
1626
1627    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1628    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1629
1630    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1631            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1632    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1633          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1634
1635    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1636    {
1637       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1638       {
1639          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1640
1641          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1642
1643          if(servedPlmnItem->iE_Extensions != NULLP)
1644          {
1645             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1646             {
1647                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1648                {
1649                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1650                         list.array != NULLP)
1651                   {
1652                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1653                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1654                      {
1655                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1656                               list.array[sliceLstIdx] != NULLP)
1657                         {
1658
1659                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1660                                               SliceSupportList.list.array[sliceLstIdx];
1661
1662                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1663                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1664                            {
1665                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1666                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1667                            }
1668                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1669                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1670                         }
1671                      }
1672                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1673                            choice.SliceSupportList.list.array,\
1674                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1675                            extensionValue.choice.SliceSupportList.list.size);
1676                   }
1677                }
1678                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1679                {
1680                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1681                }
1682                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1683             }
1684             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1685          }
1686       }
1687       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1688       {
1689          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1690       }
1691       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1692          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1693    }
1694
1695    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1696    {
1697       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1698    }
1699    else
1700    {
1701       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
1702       {
1703          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1704          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1705       }
1706    }
1707    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1708       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1709 }
1710
1711 /*******************************************************************
1712  *
1713  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1714  *
1715  * @details
1716  *
1717  *    Function : FreeDUConfigUpdate
1718  *
1719  *    Functionality: Deallocating memory of variables allocated in
1720  *                    BuildAndSendDUConfigUpdate function
1721  *
1722  * @params[in]  F1AP_PDU_t *f1apDuCfg
1723  *
1724  * @return ROK     - void
1725  *
1726  * ****************************************************************/
1727 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1728 {
1729    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1730    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1731    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1732    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1733    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1734    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1735
1736    if(f1apDuCfg != NULLP)
1737    {
1738       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1739       {
1740          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1741                        value.choice.GNBDUConfigurationUpdate;
1742          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1743          {
1744             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1745             {
1746                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1747                {
1748                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1749                   {
1750                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1751                         {
1752                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1753                                            value.choice.Served_Cells_To_Modify_List;
1754                            if(cellsToModify->list.array != NULLP)
1755                            {
1756                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1757                               {
1758                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1759                                  {
1760                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1761                                           Served_Cells_To_Modify_Item);
1762                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1763                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1764                                  }
1765                               }
1766                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1767                            }
1768                            break;
1769                         }
1770                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1771                         {
1772                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1773                                            value.choice.Served_Cells_To_Delete_List;
1774                            if(cellsToDelete->list.array != NULLP)
1775                            {
1776                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1777                               {
1778                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1779                                  {
1780                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1781                                           cellsToDelete->list.array[cellDeleteIdx]);
1782                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1783                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1784                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1785                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1786                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1787                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1788                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1789                                  }
1790                               }
1791                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1792                            }
1793
1794                            break;
1795                         }
1796                      case ProtocolIE_ID_id_gNB_DU_ID:
1797                         {
1798                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1799                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1800                            break;
1801                         }
1802                   }
1803                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1804                         sizeof(GNBDUConfigurationUpdateIEs_t));
1805                }
1806             }
1807             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1808          }
1809          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1810       }
1811       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1812    }
1813 }
1814
1815 /*******************************************************************
1816  *
1817  * @brief Fills Served Plmns required in ServCellInfo IE
1818  *
1819  * @details
1820  *
1821  *    Function : fillServedPlmns
1822  *
1823  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1824  *
1825  * @params[in] Pointer to ServedPLMNs_List_t *
1826  *
1827  * @return ROK     - success
1828  *         RFAILED - failure
1829  *
1830  *****************************************************************/
1831
1832 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
1833 {
1834    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
1835
1836    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
1837    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
1838          array[arrayIdx]->pLMN_Identity.size);
1839    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
1840    {
1841       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1842       return RFAILED;
1843    }
1844    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
1845          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
1846    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1847    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
1848    {
1849       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1850       return RFAILED;
1851    }
1852
1853    ieListCnt=1;
1854    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
1855    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
1856    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
1857          iE_Extensions->list.size);
1858    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
1859    {
1860       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1861       return RFAILED;
1862    }
1863    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
1864    {
1865       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
1866             sizeof(ServedPLMNs_ItemExtIEs_t));
1867       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
1868       {
1869          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1870          return RFAILED;
1871       }
1872    }
1873
1874    ieIdx = 0;
1875    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1876    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
1877    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
1878    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
1879    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1880    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1881       list.count = elementCnt;
1882    servedPlmn->list.array[arrayIdx]->\
1883       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1884       list.size = elementCnt * sizeof(SliceSupportItem_t *);
1885    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1886          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1887          list.array,servedPlmn->list.array[arrayIdx]->\
1888          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
1889    if(servedPlmn->list.array[arrayIdx]->\
1890          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1891          list.array == NULLP)
1892    {
1893       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1894       return RFAILED;
1895    }
1896
1897    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
1898    {
1899       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1900       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1901       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
1902       if(servedPlmn->list.array[arrayIdx]->\
1903       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1904       list.array[sliceLstIdx] == NULLP)
1905       {
1906          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1907          return RFAILED;
1908       }
1909
1910       servedPlmn->list.array[arrayIdx]->\
1911       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1912       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1913       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1914       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1915       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
1916       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
1917       sNSSAI.sST.size);
1918
1919       if(servedPlmn->list.array[arrayIdx]->\
1920       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1921       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1922       {
1923          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1924          return RFAILED;
1925       }
1926       servedPlmn->list.array[arrayIdx]->\
1927       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1928       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1929       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1930
1931       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1932       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1933       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1934       if(servedPlmn->list.array[arrayIdx]->\
1935       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1936       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1937       {
1938          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1939          return RFAILED;
1940       }
1941       servedPlmn->list.array[arrayIdx]->\
1942       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1943       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1944       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
1945       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1946       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
1947       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1948       list.array[sliceLstIdx]->sNSSAI.sD->size);
1949       if(servedPlmn->list.array[arrayIdx]->\
1950       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1951       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1952       {
1953          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
1954          return RFAILED;
1955       }
1956       memcpy(servedPlmn->list.array[arrayIdx]->\
1957       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1958       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
1959       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
1960       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
1961       list.array[sliceLstIdx]->sNSSAI.sD->size);
1962    }
1963    return ROK;
1964 }
1965
1966 /*******************************************************************
1967  *
1968  * @brief Fills Nr Fdd Info required in ServCellInfo IE
1969  *
1970  * @details
1971  *
1972  *    Function : fillNrFddInfo
1973  *
1974  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
1975  *
1976  * @params[in] FDD_Info_t *fDD
1977  *
1978  * @return ROK     - success
1979  *         RFAILED - failure
1980  *
1981  *****************************************************************/
1982
1983 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
1984 {
1985    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
1986       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
1987    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
1988    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
1989    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1990          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1991    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
1992    {
1993       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
1994       return RFAILED;
1995    }
1996
1997    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
1998       sizeof(FreqBandNrItem_t));
1999    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2000    {
2001       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2002       return RFAILED;
2003    }
2004
2005    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2006       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2007       freqBand[0].nrFreqBand;
2008    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2009    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2010       dlNrFreqInfo.nrArfcn;
2011    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2012    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2013    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2014    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2015    {
2016       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2017       return RFAILED;
2018    }
2019
2020    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
2021    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2022    {
2023       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2024       return RFAILED;
2025    }
2026
2027    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2028       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2029       freqBand[0].nrFreqBand;
2030    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2031
2032    /*Transmission Bandwidth*/
2033    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2034       f1Mode.mode.fdd.ulTxBw.nrScs;
2035    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2036       f1Mode.mode.fdd.ulTxBw.nrb;
2037    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2038       f1Mode.mode.fdd.dlTxBw.nrScs;
2039    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2040       f1Mode.mode.fdd.dlTxBw.nrb;
2041
2042    return ROK;
2043 }
2044
2045 /*******************************************************************
2046  *
2047  * @brief Fills ServCellInfo IE
2048  *
2049  * @details
2050  *
2051  *    Function : fillServedCellInfo
2052  *
2053  *    Functionality: Fills ServCellInfo
2054  *
2055  * @params[in] Pointer to Served_Cell_Information_t *
2056  *
2057  * @return ROK     - success
2058  *         RFAILED - failure
2059  *
2060  *****************************************************************/
2061
2062 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2063 {
2064    uint8_t ieIdx, ieListCnt;
2065
2066    /*nRCGI*/
2067    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2068    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2069          srvCellInfo->nRCGI.pLMN_Identity.size);
2070    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2071    {
2072       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2073       return RFAILED;
2074    }
2075    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2076          srvCellInfo->nRCGI.pLMN_Identity.buf);
2077    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2078    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2079          srvCellInfo->nRCGI.nRCellIdentity.size);
2080    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2081    {
2082       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2083       return RFAILED;
2084    }
2085
2086    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2087    /*nRPCI*/
2088    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2089
2090    /*servedPLMNs*/
2091    ieListCnt = 1;
2092    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2093    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2094    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2095    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2096    {
2097       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2098       return RFAILED;
2099    }
2100    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2101    {
2102       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2103       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2104       {
2105          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2106          return RFAILED;
2107       }
2108    }
2109    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2110    {
2111       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2112       return RFAILED;
2113    }
2114
2115 #ifndef NR_TDD
2116    /*nR Mode Info with FDD*/
2117    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2118    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2119    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2120    {
2121       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2122       return RFAILED;
2123    }
2124    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2125    {
2126        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2127       return RFAILED;
2128    }
2129 #else
2130    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2131    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2132    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2133    {
2134       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2135       return RFAILED;
2136    }
2137    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2138    {
2139       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2140       return RFAILED;
2141    }
2142 #endif
2143
2144    /*Measurement timing Config*/
2145    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2146    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2147          buf,srvCellInfo->measurementTimingConfiguration.size);
2148    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2149    {
2150       return RFAILED;
2151    }
2152    srvCellInfo->measurementTimingConfiguration.\
2153          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2154
2155    return ROK;
2156 }
2157
2158 /*******************************************************************
2159  *
2160  * @brief Fills ServCellToModItem IE
2161  *
2162  * @details
2163  *
2164  *    Function : fillServCellToModItem
2165  *
2166  *    Functionality: Fills ServCellToModItem IE
2167  *
2168  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2169  *
2170  * @return ROK     - success
2171  *         RFAILED - failure
2172  *
2173  *****************************************************************/
2174
2175 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2176 {
2177    /*pLMN_Identity*/
2178    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2179    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2180    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2181    {
2182       return RFAILED;
2183    }
2184    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2185          modifyItem->oldNRCGI.pLMN_Identity.buf);
2186
2187    /*nRCellIdentity*/
2188    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2189    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2190          modifyItem->oldNRCGI.nRCellIdentity.size);
2191    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2192    {
2193       return RFAILED;
2194    }
2195    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2196
2197    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2198       return RFAILED;
2199    else
2200       return ROK;
2201 }
2202
2203 /*******************************************************************
2204  *
2205  * @brief Builds ServCellToModList
2206  *
2207  * @details
2208  *
2209  *    Function : buildServCellToModList
2210  *
2211  *    Functionality: Builds the serv cell to Mod List
2212  *
2213  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2214  *
2215  * @return ROK     - success
2216  *         RFAILED - failure
2217  *
2218  *****************************************************************/
2219
2220 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2221 {
2222    uint8_t ieListCnt, ieIdx;
2223    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2224
2225    ieListCnt = 1;
2226    cellsToModify->list.count = ieListCnt;
2227    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2228    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2229    if(cellsToModify->list.array == NULLP)
2230    {
2231       return RFAILED;
2232    }
2233    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2234    {
2235       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2236       if(cellsToModify->list.array[ieIdx] == NULLP)
2237       {
2238          return RFAILED;
2239       }
2240    }
2241    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2242    cellsToModify->list.array[0]->criticality = Criticality_reject;
2243    cellsToModify->list.array[0]->value.present =\
2244       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2245    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2246
2247    if(fillServCellToModItem(modifyItem))
2248       return RFAILED;
2249    else
2250       return ROK;
2251 }
2252 /*******************************************************************
2253  *
2254  * @brief filling the DeleteItemList
2255  *
2256  * @details
2257  *
2258  *    Function : fillCellToDeleteItem
2259  *
2260  *    Functionality: Filling the DeleteItemIe
2261  *
2262  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2263  *
2264  * @return ROK     - success
2265  *         RFAILED - failure
2266  *
2267  *****************************************************************/
2268 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2269 {
2270    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2271
2272    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2273    deleteItemIe->criticality = Criticality_reject;
2274    deleteItemIe->value.present =\
2275    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2276    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2277
2278    /*pLMN_Identity*/
2279    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2280    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2281    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2282    {
2283       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2284       return RFAILED;
2285    }
2286    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2287          deleteItem->oldNRCGI.pLMN_Identity.buf);
2288
2289    /*nRCellIdentity*/
2290    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2291    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2292          deleteItem->oldNRCGI.nRCellIdentity.size);
2293    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2294    {
2295       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2296       return RFAILED;
2297    }
2298    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2299    return ROK;
2300 }
2301 /*******************************************************************
2302  *
2303  * @brief Builds ServCellToDeleteList
2304  *
2305  * @details
2306  *
2307  *    Function : buildServCellToDeleteList
2308  *
2309  *    Functionality: Builds the serv cell to delete List
2310  *
2311  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2312  *
2313  * @return ROK     - success
2314  *         RFAILED - failure
2315  *
2316  *****************************************************************/
2317
2318 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2319 {
2320    uint8_t ieListCnt, arrIdx;
2321
2322    ieListCnt = 1;
2323    cellsToDelete->list.count = ieListCnt;
2324    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2325
2326    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2327    if(cellsToDelete->list.array == NULLP)
2328    {
2329       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2330       return RFAILED;
2331    }
2332
2333    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2334    {
2335       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2336       if(cellsToDelete->list.array[arrIdx] == NULLP)
2337       {
2338          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2339          return RFAILED;
2340       }
2341    }
2342
2343    arrIdx=0;
2344    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2345    {
2346       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2347       return RFAILED;
2348    }
2349    return ROK;
2350 }
2351
2352 /*******************************************************************
2353  *
2354  * @brief Builds and sends the DUConfigUpdate
2355  *
2356  * @details
2357  *
2358  *    Function : BuildAndSendDUConfigUpdate
2359  *
2360  *    Functionality: Constructs the DU Update message and sends
2361  *                   it to the CU through SCTP.
2362  *
2363  * @params[in] void **buf,Buffer to which encoded pattern is written into
2364  * @params[in] int *size,size of buffer
2365  *
2366  * @return ROK     - success
2367  *         RFAILED - failure
2368  *
2369  * ****************************************************************/
2370 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2371 {
2372    uint8_t ret =0, ieIdx=0, elementCnt=0;
2373    bool memAlloctionFailure = false;
2374    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2375    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2376    asn_enc_rval_t encRetVal;     /* Encoder return value */
2377
2378    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2379    ret= RFAILED;
2380
2381    while(true)
2382    {
2383       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2384       /* Allocate the memory for F1DuCfg */
2385       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2386       if(f1apDuCfg == NULLP)
2387       {
2388          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2389          break;
2390       }
2391
2392       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2393       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2394       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2395       {
2396          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2397          break;
2398       }
2399
2400       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2401                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2402       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2403       f1apDuCfg->choice.initiatingMessage->value.present = \
2404                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2405       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2406                     choice.GNBDUConfigurationUpdate;
2407       elementCnt = 3;
2408       duCfgUpdate->protocolIEs.list.count = elementCnt;
2409       duCfgUpdate->protocolIEs.list.size = \
2410                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2411
2412       /* Initialize the F1Setup members */
2413       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2414       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2415       {
2416          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2417          break;
2418       }
2419       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2420       {
2421          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2422          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2423          {
2424             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2425             memAlloctionFailure = true;
2426             break;
2427          }
2428       }
2429
2430       if(memAlloctionFailure == true)
2431       {
2432          break;
2433       }
2434       /*TransactionID*/
2435       ieIdx = 0;
2436       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2437       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2438       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2439       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2440       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2441
2442       ieIdx++;
2443       if(servCellAction == SERV_CELL_TO_MODIFY)
2444       {
2445          /*Served Cell to Modify */
2446          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2447          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2448          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2449          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2450          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2451          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2452                   Served_Cells_To_Modify_List))
2453          {
2454             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2455             break;
2456          }
2457       }
2458       else
2459       {
2460          /*Served Cell to Delete */
2461          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2462          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2463          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2464          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2465          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2466          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2467          Served_Cells_To_Delete_List)!=ROK)
2468          {
2469             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2470             break;
2471          }
2472
2473       }
2474       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2475       /*GNB DU ID */
2476       ieIdx++;
2477       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2478       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2479       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2480       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2481       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2482       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2483             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2484       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2485       {
2486          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2487          break;
2488       }
2489       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2490
2491       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2492
2493       /* Encode the DU Config Update type as APER */
2494       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2495       encBufSize = 0;
2496       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2497
2498       /* Checking encode results */
2499       if(encRetVal.encoded == ENCODE_FAIL)
2500       {
2501          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2502                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2503          break;
2504       }
2505       else
2506       {
2507          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2508 #ifdef DEBUG_ASN_PRINT
2509          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2510          {
2511             printf("%x",encBuf[ieIdx]);
2512          }
2513 #endif
2514       }
2515       /* Sending msg */
2516       if(sendF1APMsg() != ROK)
2517       {
2518          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2519          break;
2520       }
2521
2522       ret = ROK;
2523       break;
2524    }
2525
2526    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2527    return ret;
2528 }
2529
2530
2531 /*******************************************************************
2532  *
2533  * @brief free the ULRRCMessageTransfer
2534  *
2535  * @details
2536  *
2537  *    Function : FreeULRRCMessageTransfer
2538  *
2539  *    Functionality: Deallocating the memory of variable allocated in
2540  *                      FreeULRRCMessageTransfer
2541  *
2542  * @params[in]
2543  *
2544  * @return ROK     - void
2545  *
2546  ******************************************************************/
2547 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2548 {
2549    uint8_t idx1;
2550    ULRRCMessageTransfer_t  *ulRRCMsg;
2551
2552    if(f1apMsg != NULLP)
2553    {
2554       if(f1apMsg->choice.initiatingMessage != NULLP)
2555       {
2556          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2557          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2558          {
2559             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2560             {
2561                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2562                {
2563                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2564                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2565                   {
2566                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2567                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2568                   }
2569                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2570                }
2571             }
2572             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2573          }
2574          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2575       }
2576       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2577    }
2578 }
2579 /*******************************************************************
2580  *
2581  * @brief Builds and sends the ULRRCMessageTransfer
2582  *
2583  * @details
2584  *
2585  *    Function : BuildAndSendULRRCMessageTransfer
2586  *
2587  *    Functionality: Constructs the UL RRC Message Transfer and sends
2588  *                   it to the CU through SCTP.
2589  *
2590  * @params[in]
2591  *
2592  * @return ROK     - success
2593  *         RFAILED - failure
2594  *
2595  * ****************************************************************/
2596 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  *ueCb, uint8_t lcId, \
2597       uint16_t msgLen, uint8_t *rrcMsg)
2598 {
2599    uint8_t                 elementCnt=0, idx1=0, idx=0;
2600    uint8_t                 ret = RFAILED;
2601    F1AP_PDU_t              *f1apMsg = NULLP;
2602    ULRRCMessageTransfer_t  *ulRRCMsg = NULLP;
2603    asn_enc_rval_t          encRetVal;        /* Encoder return value */
2604
2605    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2606
2607    while(true)
2608    {
2609       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2610
2611       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2612       if(f1apMsg == NULLP)
2613       {
2614          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2615          break;
2616       }
2617       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2618       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2619       if(f1apMsg->choice.initiatingMessage == NULLP)
2620       {
2621          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2622          break;
2623       }
2624       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2625       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2626       f1apMsg->choice.initiatingMessage->value.present = \
2627                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2628       ulRRCMsg =
2629          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2630       elementCnt = 4;
2631       ulRRCMsg->protocolIEs.list.count = elementCnt;
2632       ulRRCMsg->protocolIEs.list.size = \
2633                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2634
2635       /* Initialize the F1Setup members */
2636       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2637       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2638       {
2639          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2640          break;
2641       }
2642       for(idx=0; idx<elementCnt; idx++)
2643       {
2644          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2645          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2646          {
2647             break;
2648          }
2649       }
2650
2651       idx1 = 0;
2652
2653       /*GNB CU UE F1AP ID*/
2654       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2655       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2656       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2657                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2658       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
2659
2660       /*GNB DU UE F1AP ID*/
2661       idx1++;
2662       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2663       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2664       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2665                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2666       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
2667
2668       /*SRBID*/
2669       idx1++;
2670       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2671       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2672       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2673                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2674       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2675
2676       /*RRCContainer*/
2677       idx1++;
2678       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2679       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2680       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2681                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2682       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2683       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2684             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2685       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2686       {
2687          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2688          break;
2689       }
2690       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2691       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2692             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2693
2694       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2695
2696       /* Encode the F1SetupRequest type as APER */
2697       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2698       encBufSize = 0;
2699       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2700             encBuf);
2701       /* Encode results */
2702       if(encRetVal.encoded == ENCODE_FAIL)
2703       {
2704          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2705                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2706          break;
2707       }
2708       else
2709       {
2710          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2711 #ifdef DEBUG_ASN_PRINT
2712          for(int i=0; i< encBufSize; i++)
2713          {
2714             printf("%x",encBuf[i]);
2715          }
2716 #endif
2717       }
2718
2719       /* Sending  msg  */
2720       if(sendF1APMsg()  !=      ROK)
2721       {
2722          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2723          break;
2724       }
2725       ret = ROK;
2726       break;
2727    }
2728    FreeULRRCMessageTransfer(f1apMsg);
2729
2730    return ret;
2731 }/* End of BuildAndSendULRRCMessageTransfer*/
2732
2733 /*******************************************************************
2734  *
2735  * @brief Builds tag config
2736  *
2737  * @details
2738  *
2739  *    Function : BuildTagConfig
2740  *
2741  *    Functionality: Builds tag config in MacCellGroupConfig
2742  *
2743  * @params[in] TAG_Config *tag_Config
2744  *
2745  * @return ROK     - success
2746  *         RFAILED - failure
2747  *
2748  * ****************************************************************/
2749 uint8_t BuildTagConfig(DuUeCb *ueCb, struct TAG_Config *tagConfig)
2750 {
2751    struct TAG_Config__tag_ToAddModList *tagList;
2752    uint8_t                     idx, elementCnt;
2753
2754    tagConfig->tag_ToReleaseList = NULLP;
2755    tagConfig->tag_ToAddModList = NULLP;
2756    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2757    if(!tagConfig->tag_ToAddModList)
2758    {
2759       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2760       return RFAILED;
2761    }
2762
2763    if(ueCb == NULLP)
2764       elementCnt = ODU_VALUE_ONE;
2765    else
2766       elementCnt = ueCb->duMacUeCfg.macCellGrpCfg.tagCfg.addModListCount;
2767
2768    tagList = tagConfig->tag_ToAddModList;
2769    tagList->list.count = elementCnt;
2770    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2771
2772    tagList->list.array = NULLP;
2773    DU_ALLOC(tagList->list.array, tagList->list.size);
2774    if(!tagList->list.array)
2775    {
2776       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2777       return RFAILED;
2778    }
2779
2780    for(idx=0; idx<tagList->list.count; idx++)
2781    {
2782       tagList->list.array[idx] = NULLP;
2783       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2784       if(!tagList->list.array[idx])
2785       {
2786          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2787          return RFAILED;
2788       }
2789    }
2790
2791    if(ueCb == NULLP)
2792    {
2793       idx = 0;
2794       tagList->list.array[idx]->tag_Id = TAG_ID;
2795       tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2796    }
2797    else
2798    {
2799       for(idx=0; idx<tagList->list.count; idx++)
2800       {
2801          tagList->list.array[idx]->tag_Id = ueCb->duMacUeCfg.macCellGrpCfg.tagCfg.addModList[idx].tagId;
2802          tagList->list.array[idx]->timeAlignmentTimer = ueCb->duMacUeCfg.macCellGrpCfg.tagCfg.addModList[idx].timeAlignTimer;
2803       }
2804    }
2805
2806    return ROK;
2807 }
2808
2809 /*******************************************************************
2810  *
2811  * @brief Builds PHR Config
2812  *
2813  * @details
2814  *
2815  *    Function : BuildPhrConfig
2816  *
2817  *    Functionality: Builds phrConfig in MacCellGroupConfig
2818  *
2819  * @params[in] PHR Config *
2820  *
2821  * @return ROK     - success
2822  *         RFAILED - failure
2823  *
2824  * ****************************************************************/
2825 uint8_t BuildPhrConfig(DuUeCb *ueCb, struct MAC_CellGroupConfig__phr_Config *phrConfig)
2826 {
2827
2828    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2829    phrConfig->choice.setup = NULLP;
2830    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2831    if(!phrConfig->choice.setup)
2832    {
2833       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2834       return RFAILED;
2835    }
2836
2837    if(ueCb == NULLP)
2838    {
2839       phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2840       phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2841       phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2842       phrConfig->choice.setup->multiplePHR              = false;
2843       phrConfig->choice.setup->dummy                    = false;
2844       phrConfig->choice.setup->phr_Type2OtherCell       = false;
2845       phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2846    }
2847    else
2848    {
2849       phrConfig->choice.setup->phr_PeriodicTimer        = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.periodicTimer;
2850       phrConfig->choice.setup->phr_ProhibitTimer        = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.prohibitTimer;
2851       phrConfig->choice.setup->phr_Tx_PowerFactorChange = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.txPowerFactor;
2852       phrConfig->choice.setup->multiplePHR              = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.multiplePHR;
2853       phrConfig->choice.setup->dummy                    = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.dummy;
2854       phrConfig->choice.setup->phr_Type2OtherCell       = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.phrType2OtherCell;
2855       phrConfig->choice.setup->phr_ModeOtherCG          = ueCb->duMacUeCfg.macCellGrpCfg.phrCfg.phrOtherCG;
2856    }
2857
2858    return ROK;
2859 }
2860
2861 /*******************************************************************
2862  *
2863  * @brief Builds BSR Config
2864  *
2865  * @details
2866  *
2867  *    Function : BuildBsrConfig
2868  *
2869  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2870  *
2871  * @params[in] BSR_Config *bsrConfig
2872  *
2873  * @return ROK     - success
2874  *         RFAILED - failure
2875  *
2876  * ****************************************************************/
2877 uint8_t BuildBsrConfig(DuUeCb *ueCb, struct BSR_Config *bsrConfig)
2878 {
2879    if(ueCb == NULLP)
2880    {
2881       bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
2882       bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
2883       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2884    }
2885    else
2886    {
2887       bsrConfig->periodicBSR_Timer = convertBsrPeriodicTmrValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.bsrTmrCfg.periodicTimer);
2888       bsrConfig->retxBSR_Timer     = convertBsrRetxTmrValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.bsrTmrCfg.retxTimer);
2889
2890       bsrConfig->logicalChannelSR_DelayTimer = NULLP;
2891       DU_ALLOC(bsrConfig->logicalChannelSR_DelayTimer, sizeof(long));
2892       if(bsrConfig->logicalChannelSR_DelayTimer == NULLP)
2893       {
2894          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildBsrConfig");
2895          return RFAILED;
2896       }
2897       *(bsrConfig->logicalChannelSR_DelayTimer) = convertLcSrDelayTmrValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.bsrTmrCfg.srDelayTimer);
2898    }
2899
2900    return ROK;
2901 }
2902
2903 /*******************************************************************
2904  *
2905  * @brief Builds scheduling request config
2906  *
2907  * @details
2908  *
2909  *    Function : BuildSchedulingReqConfig
2910  *
2911  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
2912  *
2913  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
2914  *
2915  * @return ROK     - success
2916  *         RFAILED - failure
2917  *
2918  * ****************************************************************/
2919 uint8_t BuildSchedulingReqConfig(DuUeCb *ueCb, struct SchedulingRequestConfig *schedulingRequestConfig)
2920 {
2921    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
2922    uint8_t                     idx, elementCnt;
2923
2924    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
2925    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
2926          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
2927    if(!schedulingRequestConfig->schedulingRequestToAddModList)
2928    {
2929       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2930       return RFAILED;
2931    }
2932
2933    if(ueCb == NULLP)
2934       elementCnt = ODU_VALUE_ONE;
2935    else
2936       elementCnt = ueCb->duMacUeCfg.macCellGrpCfg.schReqCfg.addModListCount;
2937
2938    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
2939    schReqList->list.count = elementCnt;
2940    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
2941
2942    schReqList->list.array = NULLP;
2943    DU_ALLOC(schReqList->list.array, schReqList->list.size);
2944    if(!schReqList->list.array)
2945    {
2946       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2947       return RFAILED;
2948    }
2949
2950    for(idx=0; idx<schReqList->list.count; idx++)
2951    {
2952       schReqList->list.array[idx] = NULLP;
2953       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
2954       if(!schReqList->list.array[idx])
2955       {
2956          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2957          return RFAILED;
2958       }
2959    }
2960
2961    if(ueCb == NULLP)
2962    {
2963       idx = 0;
2964       schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
2965
2966       schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2967       DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2968       if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2969       {
2970          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2971          return RFAILED;
2972       }
2973       *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
2974       schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
2975    }
2976    else
2977    {
2978       for(idx=0; idx<schReqList->list.count; idx++)
2979       {
2980          schReqList->list.array[idx]->schedulingRequestId = ueCb->duMacUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].schedReqId;
2981
2982          schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
2983          DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
2984          if(!schReqList->list.array[idx]->sr_ProhibitTimer)
2985          {
2986             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
2987             return RFAILED;
2988          }
2989          *(schReqList->list.array[idx]->sr_ProhibitTimer) = ueCb->duMacUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srProhibitTmr;
2990          schReqList->list.array[idx]->sr_TransMax = ueCb->duMacUeCfg.macCellGrpCfg.schReqCfg.addModList[idx].srTransMax;
2991       }
2992    }
2993
2994    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
2995
2996    return ROK;
2997 }
2998
2999 /*******************************************************************
3000  *
3001  * @brief Builds RLC Configuration for AM mode
3002  *
3003  * @details
3004  *
3005  *    Function : BuildRlcConfigAm
3006  *
3007  *    Functionality:
3008  *       Builds AM mode RLC Config in BuildRlcBearerToAddModList
3009  *
3010  * @params[in] AmBearerCfg *amCfg
3011  *             RLC_Config_t  *rlcConfig
3012  *
3013  * @return ROK     - success
3014  *         RFAILED - failure
3015  *
3016  * ****************************************************************/
3017 uint8_t BuildRlcConfigAm(AmBearerCfg *amCfg, struct RLC_Config *rlcConfig)
3018 {
3019    rlcConfig->choice.am = NULLP;
3020    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3021    if(!rlcConfig->choice.am)
3022    {
3023       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3024       return RFAILED;
3025    }
3026
3027    /* Fill AM UL configuration */
3028    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3029    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3030    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3031    {
3032       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3033       return RFAILED;
3034    }
3035
3036    /* Fill default AM UL configuration if input pointer to DU database is NULL */
3037    if(amCfg == NULLP)
3038    {
3039       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3040       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3041       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3042       rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3043       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3044    }
3045    else
3046    {
3047       *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->dlAmCfg.snLenDl);
3048       rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = covertPollRetxTmrValueToEnum(amCfg->dlAmCfg.pollRetxTmr);
3049       rlcConfig->choice.am->ul_AM_RLC.pollPDU           = covertPollPduValueToEnum(amCfg->dlAmCfg.pollPdu);
3050       rlcConfig->choice.am->ul_AM_RLC.pollByte          = covertPollByteValueToEnum(amCfg->dlAmCfg.pollByte);
3051       rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = covertMaxRetxValueToEnum(amCfg->dlAmCfg.maxRetxTh);
3052    }
3053
3054    /* Fill AM DL configuraion */
3055    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3056    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3057    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3058    {
3059       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigAm");
3060       return RFAILED;
3061    }
3062
3063    /* Fill default AM DL configuration if input pointer to DU database is NULL */
3064    if(amCfg == NULLP)
3065    {
3066       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3067       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3068       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3069    }
3070    else /* Fill AM configuration from DU database */
3071    {
3072       *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = covertAmSnLenFromIntEnumToRrcEnum(amCfg->ulAmCfg.snLenUl);
3073       rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = convertReasmblTmrValueToEnum(amCfg->ulAmCfg.reAssemTmr);
3074       rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = convertProhibitTmrValueToEnum(amCfg->ulAmCfg.statProhTmr);
3075    }
3076    return ROK;
3077 }
3078
3079 /*******************************************************************
3080  *
3081  * @brief Builds RLC Config for UM Bidirection
3082  *
3083  * @details
3084  *
3085  *    Function : BuildRlcConfig UmBiDir
3086  *
3087  *    Functionality:
3088  *       Builds RLC Config for UM Bidirection in BuildRlcBearerToAddModList
3089  *
3090  * @params[in] UmBiDirBearerCfg *umBiDirCfg
3091  *             RLC_Config_t *rlcConfig
3092  *
3093  * @return ROK     - success
3094  *         RFAILED - failure
3095  *
3096  * ****************************************************************/
3097 uint8_t BuildRlcConfigUmBiDir(UmBiDirBearerCfg *umBiDirCfg, struct RLC_Config *rlcConfig)
3098 {
3099    rlcConfig->choice.um_Bi_Directional = NULLP;
3100    DU_ALLOC(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
3101    if(rlcConfig->choice.um_Bi_Directional == NULLP)
3102    {
3103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3104       return RFAILED;
3105    }
3106
3107    /* Fill UM Bidirectional UL configuration */
3108    rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength = NULLP;
3109    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3110    if(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength == NULLP)
3111    {
3112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3113       return RFAILED;
3114    }
3115
3116    if(umBiDirCfg != NULLP)
3117    {
3118       *(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->dlUmCfg.snLenDlUm);
3119    }
3120
3121    /* Fill UM Bidirectional DL configuration */
3122    rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength = NULLP;
3123    DU_ALLOC(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3124    if(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength == NULLP)
3125    {
3126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmBiDir");
3127       return RFAILED;
3128    }
3129
3130    if(umBiDirCfg != NULLP)
3131    {
3132       *(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umBiDirCfg->ulUmCfg.snLenUlUm);
3133       rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umBiDirCfg->ulUmCfg.reAssemTmr);
3134    }
3135
3136    return ROK;
3137 }
3138
3139 /*******************************************************************
3140  *
3141  * @brief Builds RLC Config for UM Uni directional UL
3142  *
3143  * @details
3144  *
3145  *    Function : BuildRlcConfigUmUniDirUl
3146  *
3147  *    Functionality:
3148  *       Builds RLC Config for UM Unidirection UL in BuildRlcBearerToAddModList
3149  *
3150  * @params[in] UmUniDirDlBearerCfg *umUniDirDlCfg
3151  *             RLC_Config_t *rlcConfig
3152  *
3153  * @return ROK     - success
3154  *         RFAILED - failure
3155  *
3156  * ****************************************************************/
3157 uint8_t BuildRlcConfigUmUniDirUl(UmUniDirDlBearerCfg *umUniDirDlCfg, RLC_Config_t *rlcConfig)
3158 {
3159    rlcConfig->choice.um_Uni_Directional_UL = NULLP;
3160    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
3161    if(rlcConfig->choice.um_Uni_Directional_UL == NULLP)
3162    {
3163       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3164       return RFAILED;
3165    }
3166
3167    rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength = NULLP;
3168    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3169    if(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength == NULLP)
3170    {
3171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirUl");
3172       return RFAILED;
3173    }
3174
3175    if(umUniDirDlCfg != NULLP)
3176    {
3177       *(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirDlCfg->dlUmCfg.snLenDlUm);
3178    }
3179
3180    return ROK;
3181 }
3182
3183 /*******************************************************************
3184  *
3185  * @brief Builds RLC Config for UM Uni directional DL
3186  *
3187  * @details
3188  *
3189  *    Function : BuildRlcConfigUmUniDirDl
3190  *
3191  *    Functionality:
3192  *       Builds RLC Config for UM Unidirection DL in BuildRlcBearerToAddModList
3193  *
3194  * @params[in] UmUniDirUlBearerCfg *umUniDirUlCfg
3195  *             RLC_Config_t *rlcConfig
3196  *
3197  * @return ROK     - success
3198  *         RFAILED - failure
3199  *
3200  * ****************************************************************/
3201 uint8_t BuildRlcConfigUmUniDirDl(UmUniDirUlBearerCfg *umUniDirUlCfg, RLC_Config_t *rlcConfig)
3202 {
3203    rlcConfig->choice.um_Uni_Directional_DL = NULLP;
3204    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
3205    if(rlcConfig->choice.um_Uni_Directional_DL == NULLP)
3206    {
3207       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3208       return RFAILED;
3209    }
3210
3211    rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength = NULLP;
3212    DU_ALLOC(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
3213    if(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength == NULLP)
3214    {
3215       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfigUmUniDirDl");
3216       return RFAILED;
3217    }
3218
3219    if(umUniDirUlCfg != NULLP)
3220    {
3221       *(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength) = covertUmSnLenFromIntEnumToRrcEnum(umUniDirUlCfg->ulUmCfg.snLenUlUm);
3222       rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.t_Reassembly = convertReasmblTmrValueToEnum(umUniDirUlCfg->ulUmCfg.reAssemTmr);
3223    }
3224
3225    return ROK;
3226 }
3227
3228 /*******************************************************************
3229  *
3230  * @brief Builds RLC Config
3231  *
3232  * @details
3233  *
3234  *    Function : BuildRlcConfig
3235  *
3236  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3237  *
3238  * @params[in] RLC_Config_t *rlcConfig
3239  *
3240  * @return ROK     - success
3241  *         RFAILED - failure
3242  *
3243  * ****************************************************************/
3244 uint8_t BuildRlcConfig(RlcBearerCfg *rbCfg, struct RLC_Config *rlcConfig)
3245 {
3246
3247    /* Fill default values if rbCfg is NULL */
3248    if(rbCfg == NULLP)
3249    {
3250       rlcConfig->present = RLC_Config_PR_am;
3251       BuildRlcConfigAm(NULLP, rlcConfig);
3252    }
3253    /* If RbCfg is present, fill RLC configurations from DU Database */
3254    else
3255    {
3256       rlcConfig->present = covertRlcModeFromIntEnumToRrcEnum(rbCfg->rlcMode);
3257       switch(rlcConfig->present)
3258       {
3259          case RLC_Config_PR_am:
3260             BuildRlcConfigAm(rbCfg->u.amCfg, rlcConfig);
3261             break;
3262          case RLC_Config_PR_um_Bi_Directional:
3263             BuildRlcConfigUmBiDir(rbCfg->u.umBiDirCfg, rlcConfig);
3264             break;
3265          case RLC_Config_PR_um_Uni_Directional_UL:
3266             BuildRlcConfigUmUniDirUl(rbCfg->u.umUniDirDlCfg, rlcConfig);
3267             break;
3268          case RLC_Config_PR_um_Uni_Directional_DL:
3269             BuildRlcConfigUmUniDirDl(rbCfg->u.umUniDirUlCfg, rlcConfig);
3270             break;
3271          case RLC_Config_PR_NOTHING:
3272          default:
3273             break;
3274       }
3275    }
3276
3277    return ROK;
3278 }
3279
3280 /*******************************************************************
3281  *
3282  * @brief Builds MAC LC Config
3283  *
3284  * @details
3285  *
3286  *    Function : BuildMacLCConfig
3287  *
3288  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3289  *
3290  * @params[in] struct LogicalChannelConfig macLcConfig
3291  *
3292  * @return ROK     - success
3293  *         RFAILED - failure
3294  *
3295  * ****************************************************************/
3296 uint8_t BuildMacLCConfig(LcCfg *lcCfgDb, struct LogicalChannelConfig *macLcConfig)
3297 {
3298    macLcConfig->ul_SpecificParameters = NULLP;
3299    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3300    if(!macLcConfig->ul_SpecificParameters)
3301    {
3302       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3303       return RFAILED;
3304    }
3305
3306    if(lcCfgDb == NULLP)
3307    {
3308       macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3309       macLcConfig->ul_SpecificParameters->prioritisedBitRate =  PRIORTISIED_BIT_RATE;
3310       macLcConfig->ul_SpecificParameters->bucketSizeDuration =  BUCKET_SIZE_DURATION;
3311    }
3312    else
3313    {
3314       macLcConfig->ul_SpecificParameters->priority = lcCfgDb->ulLcCfg.priority;
3315       macLcConfig->ul_SpecificParameters->prioritisedBitRate = lcCfgDb->ulLcCfg.pbr;
3316       macLcConfig->ul_SpecificParameters->bucketSizeDuration = lcCfgDb->ulLcCfg.bsd;
3317    }
3318
3319    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3320    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3321    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3322    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3323
3324    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3325    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3326    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3327    {
3328       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3329       return RFAILED;
3330    }
3331
3332    if(lcCfgDb == NULLP)
3333       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3334    else
3335       *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = lcCfgDb->ulLcCfg.lcGroup;
3336
3337    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3338    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3339    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3340    {
3341       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3342       return RFAILED;
3343    }
3344
3345    if(lcCfgDb == NULLP)
3346       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3347    else
3348       *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = lcCfgDb->ulLcCfg.schReqId;
3349
3350    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3351    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3352    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3353
3354    return ROK;
3355 }
3356
3357 /*******************************************************************
3358  *
3359  * @brief Builds RLC Bearer to Add/Mod list
3360  *
3361  * @details
3362  *
3363  *    Function :BuildRlcBearerToAddModList
3364  *
3365  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3366  *
3367  * @params[in] rlc_BearerToAddModList
3368  *
3369  * @return ROK     - success
3370  *         RFAILED - failure
3371  *
3372  * ****************************************************************/
3373 uint8_t BuildRlcBearerToAddModList(DuUeCb *ueCb, struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3374 {
3375    uint8_t  idx = 0, lcIdx=0, macLcIdx = 0, elementCnt = 0;
3376
3377    if(ueCb == NULLP)
3378       elementCnt = 1;
3379    else if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
3380       elementCnt = ueCb->rlcUeCfg.numLcs;
3381    else
3382    {
3383       for(lcIdx = 0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3384       {
3385          if(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == false)
3386             elementCnt++;
3387       }
3388    }
3389    rlcBearerList->list.count = elementCnt;
3390    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3391
3392    rlcBearerList->list.array = NULLP;
3393    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3394    if(!rlcBearerList->list.array)
3395    {
3396       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3397       return RFAILED;
3398    }
3399
3400    for(idx=0; idx<rlcBearerList->list.count; idx++)
3401    {
3402       rlcBearerList->list.array[idx] = NULLP;
3403       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3404       if(!rlcBearerList->list.array[idx])
3405       {
3406          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3407          return RFAILED;
3408       }
3409    }
3410
3411    if(ueCb == NULLP)
3412    {
3413       idx=0;
3414       rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3415       DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3416       if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3417       {
3418          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3419          return RFAILED;
3420       }
3421       rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3422       rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB1_LCID;
3423       rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3424
3425       /* Fill RLC related Configurations for this Radio Bearer */
3426       rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3427       DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3428       if(!rlcBearerList->list.array[idx]->rlc_Config)
3429       {
3430          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3431          return RFAILED;
3432       }
3433       if(BuildRlcConfig(NULLP, rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3434       {
3435          DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3436          return RFAILED;
3437       }
3438
3439       /* Fill MAC related configurations for this Radio Bearer */
3440       rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3441       DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3442       if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3443       {
3444          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3445          return RFAILED;
3446       }
3447       if(BuildMacLCConfig(NULLP, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3448       {
3449          DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3450          return RFAILED;
3451       }
3452    }
3453    else
3454    {
3455       idx=0;
3456       for(lcIdx=0; lcIdx<ueCb->rlcUeCfg.numLcs; lcIdx++)
3457       {
3458          if((ueCb->f1UeDb->actionType != UE_CTXT_CFG_QUERY) && (ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent == true))
3459             continue;
3460
3461          /* Fill Logical channel identity */
3462          rlcBearerList->list.array[idx]->logicalChannelIdentity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId;
3463
3464          /* Fill Radio Bearer Id and type (DRB/SRB) for this logical channel */
3465          DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
3466          if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3467          {
3468             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3469             return RFAILED;
3470          }
3471          rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3472                                                                       covertRbTypeFromIntEnumToRrcEnum(ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbType);
3473          switch(rlcBearerList->list.array[idx]->servedRadioBearer->present)
3474          {
3475             case RLC_BearerConfig__servedRadioBearer_PR_srb_Identity:
3476                rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3477                break;
3478             case RLC_BearerConfig__servedRadioBearer_PR_drb_Identity:
3479                rlcBearerList->list.array[idx]->servedRadioBearer->choice.drb_Identity = ueCb->rlcUeCfg.rlcLcCfg[lcIdx].rbId;
3480                break;
3481             case RLC_BearerConfig__servedRadioBearer_PR_NOTHING:
3482             default:
3483                break;
3484          }
3485          ueCb->rlcUeCfg.rlcLcCfg[lcIdx].isLcAddModRspSent = true;
3486
3487          rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3488
3489          /* Fill RLC related Configurations for this Radio Bearer */
3490          rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3491          DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3492          if(!rlcBearerList->list.array[idx]->rlc_Config)
3493          {
3494             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3495             return RFAILED;
3496          }
3497          if(BuildRlcConfig(&ueCb->rlcUeCfg.rlcLcCfg[lcIdx], rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3498          {
3499             DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3500             return RFAILED;
3501          }
3502
3503          /* Fill MAC related configurations for this Radio Bearer */
3504          rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3505          DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
3506          if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3507          {
3508             DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3509             return RFAILED;
3510          }
3511          for(macLcIdx = 0; macLcIdx < ueCb->duMacUeCfg.numLcs; macLcIdx++)
3512          {
3513             if(ueCb->duMacUeCfg.lcCfgList[macLcIdx].lcConfig.lcId == ueCb->rlcUeCfg.rlcLcCfg[lcIdx].lcId)
3514             {
3515                if(BuildMacLCConfig(&ueCb->duMacUeCfg.lcCfgList[macLcIdx].lcConfig, rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3516                {
3517                   DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3518                   return RFAILED;
3519                }
3520                break;
3521             }
3522          }
3523
3524          idx++;
3525       }
3526    }
3527    return ROK;
3528 }
3529
3530 /*******************************************************************
3531  *
3532  * @brief Build Control resource set to add/modify list
3533  *
3534  * @details
3535  *
3536  *    Function : BuildControlRSetToAddModList
3537  *
3538  *    Functionality: Build Control resource set to add/modify list
3539  *
3540  * @params[in]
3541  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3542  *
3543  * @return ROK     - success
3544  *         RFAILED - failure
3545  *
3546  * ****************************************************************/
3547 uint8_t BuildControlRSetToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList)
3548 {
3549    uint8_t idx;
3550    uint8_t elementCnt;
3551    uint8_t numBytes, bitsUnused;
3552    struct ControlResourceSet *controlRSet;
3553    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3554    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3555
3556    if(pdcchCfg == NULLP)
3557       elementCnt = 1;
3558    else
3559       elementCnt = pdcchCfg->numCRsetToAddMod;
3560
3561    controlRSetList->list.count = elementCnt;
3562    controlRSetList->list.size = elementCnt * sizeof(struct ControlResourceSet *);
3563
3564    controlRSetList->list.array = NULLP;
3565    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3566    if(!controlRSetList->list.array)
3567    {
3568       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3569       return RFAILED;
3570    }
3571
3572    for(idx = 0; idx < elementCnt; idx++)
3573    {
3574       controlRSetList->list.array[idx] = NULLP;
3575       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3576       if(!controlRSetList->list.array[idx])
3577       {
3578          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3579          return RFAILED;
3580       }
3581    }
3582
3583    for(idx = 0; idx < elementCnt; idx++)
3584    {
3585       controlRSet = controlRSetList->list.array[idx];
3586
3587       if(pdcchCfg == NULLP)
3588          controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3589       else
3590          controlRSet->controlResourceSetId = pdcchCfg->cRSetToAddModList[idx].cRSetId;
3591
3592       /* size 6 bytes
3593        * 3 LSBs unsued
3594        * Bit string stored ff0000000000
3595        */
3596       numBytes = 6;
3597       bitsUnused = 3;
3598       controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3599
3600       controlRSet->frequencyDomainResources.buf = NULLP;
3601       DU_ALLOC(controlRSet->frequencyDomainResources.buf, controlRSet->frequencyDomainResources.size);
3602       if(!controlRSet->frequencyDomainResources.buf)
3603       {
3604          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3605          return RFAILED;
3606       }
3607
3608       memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3609
3610       if(pdcchCfg == NULLP)
3611       {
3612          coreset0EndPrb = CORESET0_END_PRB;
3613          coreset1StartPrb = coreset0EndPrb + 6;
3614          coreset1NumPrb = CORESET1_NUM_PRB;
3615          /* calculate the PRBs */
3616          fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3617          memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3618          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3619
3620          controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3621          controlRSet->cce_REG_MappingType.present = ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3622          controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3623       }
3624       else
3625       {
3626          memcpy(controlRSet->frequencyDomainResources.buf, pdcchCfg->cRSetToAddModList[idx].freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
3627          controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3628          controlRSet->duration = pdcchCfg->cRSetToAddModList[idx].duration;
3629          controlRSet->cce_REG_MappingType.present = pdcchCfg->cRSetToAddModList[idx].cceRegMappingType;
3630          controlRSet->precoderGranularity = pdcchCfg->cRSetToAddModList[idx].precoderGranularity;
3631       }
3632       controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3633       controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3634       controlRSet->tci_PresentInDCI = NULLP;
3635
3636 #if 0
3637       uint8_t tciStateIdx;
3638
3639       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3640             sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3641       if(!controlRset->tci_StatesPDCCH_ToAddList)
3642       {
3643          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3644          return RFAILED;
3645       }
3646
3647       elementCnt = 1;
3648       controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3649       controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3650       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3651             controlRset->tci_StatesPDCCH_ToAddList->list.size)
3652          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3653          {
3654             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3655             return RFAILED;
3656          }
3657
3658       for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3659       {
3660          DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3661          if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3662          {
3663             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3664             return RFAILED;
3665          }
3666       }
3667
3668       tciStateIdx = 0;
3669       /* TODO */
3670       *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3671
3672       DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3673       if(!controlRset->tci_PresentInDCI)
3674       {
3675          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3676          return RFAILED;
3677       }
3678       /* TODO */
3679       *(controlRset->tci_PresentInDCI);
3680 #endif
3681
3682       controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3683       DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3684       if(!controlRSet->pdcch_DMRS_ScramblingID)
3685       {
3686          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3687          return RFAILED;
3688       }
3689       if(pdcchCfg == NULLP)
3690          *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3691       else
3692          *(controlRSet->pdcch_DMRS_ScramblingID) = pdcchCfg->cRSetToAddModList[idx].dmrsScramblingId;
3693    }
3694    return ROK;
3695 } /* End BuildControlRSetToAddModList */
3696
3697 /*******************************************************************
3698  *
3699  * @brief Build search space to add/modify list
3700  *
3701  * @details
3702  *
3703  *    Function : BuildSearchSpcToAddModList
3704  *
3705  *    Functionality: Build search space to add/modify list
3706  *
3707  * @params[in]
3708  * @return ROK     - success
3709  *         RFAILED - failure
3710  *
3711  * ****************************************************************/
3712 uint8_t BuildSearchSpcToAddModList(PdcchConfig *pdcchCfg, struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
3713 {
3714    uint8_t idx;
3715    uint8_t numBytes;
3716    uint8_t byteIdx;
3717    uint8_t bitsUnused;
3718    uint8_t elementCnt;
3719    struct SearchSpace *searchSpc;
3720
3721    if(pdcchCfg == NULLP)
3722       elementCnt = 1;
3723    else
3724       elementCnt = pdcchCfg->numSearchSpcToAddMod;
3725
3726    searchSpcList->list.count = elementCnt;
3727    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3728
3729    searchSpcList->list.array = NULLP;
3730    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3731    if(!searchSpcList->list.array)
3732    {
3733       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3734       return RFAILED;
3735    }
3736
3737    for(idx = 0; idx < elementCnt; idx++)
3738    {
3739       searchSpcList->list.array[idx] = NULLP;
3740       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3741       if(!searchSpcList->list.array[idx])
3742       {
3743          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3744          return RFAILED;
3745       }
3746    }
3747
3748    for(idx = 0; idx < elementCnt; idx++)
3749    {
3750       searchSpc = searchSpcList->list.array[idx];
3751
3752       if(pdcchCfg == NULLP)
3753          searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3754       else
3755          searchSpc->searchSpaceId = pdcchCfg->searchSpcToAddModList[idx].searchSpaceId;
3756
3757       searchSpc->controlResourceSetId = NULLP;
3758       DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3759       if(!searchSpc->controlResourceSetId)
3760       {
3761          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3762          return RFAILED;
3763       }
3764       if(pdcchCfg == NULLP)
3765          *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3766       else
3767          *(searchSpc->controlResourceSetId) = pdcchCfg->searchSpcToAddModList[idx].cRSetId;
3768
3769       searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3770       DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3771       if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3772       {
3773          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3774          return RFAILED;
3775       }
3776       if(pdcchCfg == NULLP)
3777          searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3778       else
3779          searchSpc->monitoringSlotPeriodicityAndOffset->present = pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset;
3780
3781       searchSpc->duration = NULLP;
3782       searchSpc->monitoringSymbolsWithinSlot = NULLP;
3783       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3784       if(!searchSpc->monitoringSymbolsWithinSlot)
3785       {
3786          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3787          return RFAILED;
3788       }
3789
3790       /* Values taken from reference logs :
3791        * size 2 bytes
3792        * 2 LSBs unsued
3793        * Bit string stores 8000
3794        */
3795       numBytes = 2;
3796       bitsUnused = 2;
3797       searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3798       searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3799       DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, searchSpc->monitoringSymbolsWithinSlot->size);
3800       if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3801       {
3802          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3803          return RFAILED;
3804       }
3805       if(pdcchCfg == NULLP)
3806       {
3807          byteIdx = 0;
3808          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3809          searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3810       }
3811       else
3812          memcpy(searchSpc->monitoringSymbolsWithinSlot->buf, pdcchCfg->searchSpcToAddModList[idx].mSymbolsWithinSlot, numBytes);
3813       searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3814
3815       searchSpc->nrofCandidates = NULLP;
3816       DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3817       if(!searchSpc->nrofCandidates)
3818       {
3819          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3820          return RFAILED;
3821       }
3822
3823       if(pdcchCfg == NULLP)
3824       {
3825          searchSpc->nrofCandidates->aggregationLevel1 = PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3826          searchSpc->nrofCandidates->aggregationLevel2 = PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3827          searchSpc->nrofCandidates->aggregationLevel4 = PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3828          searchSpc->nrofCandidates->aggregationLevel8 = PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3829          searchSpc->nrofCandidates->aggregationLevel16 = PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3830       }
3831       else
3832       {
3833          searchSpc->nrofCandidates->aggregationLevel1 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel1;
3834          searchSpc->nrofCandidates->aggregationLevel2 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel2;
3835          searchSpc->nrofCandidates->aggregationLevel4 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel4;
3836          searchSpc->nrofCandidates->aggregationLevel8 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel8;
3837          searchSpc->nrofCandidates->aggregationLevel16 = pdcchCfg->searchSpcToAddModList[idx].numCandidatesAggLevel16;
3838       }
3839
3840       searchSpc->searchSpaceType = NULLP;
3841       DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3842       if(!searchSpc->searchSpaceType)
3843       {
3844          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3845          return RFAILED;
3846       }
3847       if(pdcchCfg == NULLP)
3848          searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3849       else
3850          searchSpc->searchSpaceType->present = pdcchCfg->searchSpcToAddModList[idx].searchSpaceType;
3851
3852       searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3853       DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3854       if(!searchSpc->searchSpaceType->choice.ue_Specific)
3855       {
3856          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3857          return RFAILED;
3858       }
3859       if(pdcchCfg == NULLP)
3860          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3861       else
3862          searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = pdcchCfg->searchSpcToAddModList[idx].ueSpecificDciFormat;
3863    }
3864    return ROK;
3865 }/* End BuildSearchSpcToAddModList */
3866
3867 /*******************************************************************
3868  *
3869  * @brief Builds BWP DL dedicated PDCCH config
3870  *
3871  * @details
3872  *
3873  *    Function : BuildBWPDlDedPdcchCfg
3874  *
3875  *    Functionality: Builds BWP DL dedicated PDCCH config
3876  *
3877  * @params[in] struct PDCCH_Config *pdcchCfg
3878  *
3879  * @return ROK     - success
3880  *         RFAILED - failure
3881  *
3882  * ****************************************************************/
3883 uint8_t BuildBWPDlDedPdcchCfg(PdcchConfig *pdcchCfgDb, struct PDCCH_Config *pdcchCfg)
3884 {
3885    pdcchCfg->controlResourceSetToAddModList = NULLP;
3886    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3887    if(!pdcchCfg->controlResourceSetToAddModList)
3888    {
3889       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3890       return RFAILED;
3891    }
3892
3893    if(BuildControlRSetToAddModList(pdcchCfgDb, pdcchCfg->controlResourceSetToAddModList) != ROK)
3894    {
3895       DU_LOG("\nERROR  --> F1AP : Failed in BuildControlRSetToAddModList()");
3896       return RFAILED;
3897    }
3898
3899    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3900
3901    pdcchCfg->searchSpacesToAddModList = NULLP;
3902    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3903    if(!pdcchCfg->searchSpacesToAddModList)
3904    {
3905       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3906       return RFAILED;
3907    }
3908
3909    if(BuildSearchSpcToAddModList(pdcchCfgDb, pdcchCfg->searchSpacesToAddModList) != ROK)
3910    {
3911       DU_LOG("\nERROR  --> F1AP : Failed in BuildSearchSpcToAddModList()");
3912       return RFAILED;
3913    }
3914
3915    pdcchCfg->searchSpacesToReleaseList = NULLP;
3916    pdcchCfg->downlinkPreemption = NULLP;
3917    pdcchCfg->tpc_PUSCH = NULLP;
3918    pdcchCfg->tpc_PUCCH = NULLP;
3919    pdcchCfg->tpc_SRS = NULLP;
3920
3921    return ROK;
3922 }
3923
3924 /*******************************************************************
3925  *
3926  * @brief Builds DMRS DL PDSCH Mapping type A
3927  *
3928  * @details
3929  *
3930  *    Function : BuildDMRSDLPdschMapTypeA
3931  *
3932  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3933  *
3934  * @params[in]
3935  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3936  * @return ROK     - success
3937  *         RFAILED - failure
3938  *
3939  * ****************************************************************/
3940 uint8_t BuildDMRSDLPdschMapTypeA(PdschConfig *pdschCfg, struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg)
3941 {
3942    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3943    dmrsDlCfg->choice.setup = NULLP;
3944    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3945    if(!dmrsDlCfg->choice.setup)
3946    {
3947       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3948       return RFAILED;
3949    }
3950
3951    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3952    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3953    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3954    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3955    {
3956       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3957       return RFAILED;
3958    }
3959    if(pdschCfg == NULLP)
3960       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3961    else
3962       *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = pdschCfg->dmrsDlCfgForPdschMapTypeA.addPos;
3963
3964    dmrsDlCfg->choice.setup->maxLength = NULLP;
3965    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3966    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3967    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3968
3969    return ROK;
3970 }
3971
3972 /*******************************************************************
3973  *
3974  * @brief Builds TCI states to add/modify list
3975  *
3976  * @details
3977  *
3978  *    Function : BuildTCIStatesToAddModList
3979  *
3980  *    Functionality:Builds TCI states to add/modify list
3981  *
3982  * @params[in]
3983  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3984  *
3985  * @return ROK     - success
3986  *         RFAILED - failure
3987  *
3988  * ****************************************************************/
3989 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3990 {
3991    return ROK;
3992 }
3993
3994 /*******************************************************************
3995  *
3996  * @brief Builds PDSCH time domain allocation list
3997  *
3998  * @details
3999  *
4000  *    Function : BuildPdschTimeDomAllocList
4001  *
4002  *    Functionality: Builds PDSCH time domain allocation list
4003  *
4004  * @params[in]
4005  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4006  *
4007  * @return ROK     - success
4008  *         RFAILED - failure
4009  *
4010  * ****************************************************************/
4011 uint8_t BuildPdschTimeDomAllocList(PdschConfig *pdschCfg, struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
4012 {
4013    uint8_t idx;
4014    uint8_t elementCnt;
4015    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
4016
4017    timeDomAllocList->present = PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
4018
4019    timeDomAllocList->choice.setup = NULLP;
4020    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4021    if(!timeDomAllocList->choice.setup)
4022    {
4023       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4024       return RFAILED;
4025    }
4026
4027 if(pdschCfg == NULLP)
4028    elementCnt = 2;
4029 else
4030 elementCnt = pdschCfg->numTimeDomRsrcAlloc;
4031    timeDomAllocList->choice.setup->list.count = elementCnt;
4032    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
4033
4034    timeDomAllocList->choice.setup->list.array = NULLP;
4035    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4036    if(!timeDomAllocList->choice.setup->list.array)
4037    {
4038       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4039       return RFAILED;
4040    }
4041
4042    for(idx = 0; idx < elementCnt; idx++)
4043    {
4044       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4045       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
4046             sizeof(struct PDSCH_TimeDomainResourceAllocation));
4047       if(!timeDomAllocList->choice.setup->list.array[idx])
4048       {
4049          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4050          return RFAILED;
4051       }
4052    }
4053
4054    if(pdschCfg == NULLP)
4055    {
4056       idx = 0;
4057       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4058       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4059       if(!timeDomAlloc->k0)
4060       {
4061          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4062          return RFAILED;
4063       }
4064       *(timeDomAlloc->k0) = 0;
4065       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4066       timeDomAlloc->startSymbolAndLength = \
4067                                            calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4068
4069       idx++;
4070       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4071       DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4072       if(!timeDomAlloc->k0)
4073       {
4074          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4075          return RFAILED;
4076       }
4077       *(timeDomAlloc->k0) = 1;
4078       timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4079       timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4080    }
4081    else
4082    {
4083       for(idx = 0; idx < elementCnt; idx++)
4084       {
4085          timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4086          DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4087          if(!timeDomAlloc->k0)
4088          {
4089             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4090             return RFAILED;
4091          }
4092          if(pdschCfg->timeDomRsrcAllociList[idx].k0)
4093             *(timeDomAlloc->k0) = *(pdschCfg->timeDomRsrcAllociList[idx].k0);
4094          timeDomAlloc->mappingType = pdschCfg->timeDomRsrcAllociList[idx].mappingType;
4095          timeDomAlloc->startSymbolAndLength = pdschCfg->timeDomRsrcAllociList[idx].startSymbolAndLength;
4096       }
4097    }
4098
4099    return ROK;
4100 }
4101
4102 /*******************************************************************
4103  *
4104  * @brief Builds PDSCH PRB Bundling type
4105  *
4106  * @details
4107  *
4108  *    Function : BuildPdschPrbBundlingType
4109  *
4110  *    Functionality: Builds PDSCH PRB Bundling type
4111  *
4112  * @params[in]
4113  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4114  *
4115  * @return ROK     - success
4116  *         RFAILED - failure
4117  *
4118  * ****************************************************************/
4119 uint8_t BuildPdschPrbBundlingType(PdschConfig *pdschCfg, struct PDSCH_Config__prb_BundlingType *prbBndlType)
4120 {
4121    if(pdschCfg == NULLP)
4122       prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4123    else
4124       prbBndlType->present = pdschCfg->bundlingType;
4125
4126    prbBndlType->choice.staticBundling = NULLP;
4127    DU_ALLOC(prbBndlType->choice.staticBundling, \
4128          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4129    if(!prbBndlType->choice.staticBundling)
4130    {
4131       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4132       return RFAILED;
4133    }
4134    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4135
4136    return ROK;
4137 }
4138
4139 /*******************************************************************
4140  *
4141  * @brief Builds BWP DL dedicated PDSCH config
4142  *
4143  * @details
4144  *
4145  *    Function : BuildBWPDlDedPdschCfg
4146  *
4147  *    Functionality: Builds BWP DL dedicated PDSCH config
4148  *
4149  * @params[in] struct PDSCH_Config *pdschCfg
4150  *
4151  * @return ROK     - success
4152  *         RFAILED - failure
4153  *
4154  * ****************************************************************/
4155 uint8_t BuildBWPDlDedPdschCfg(PdschConfig *pdschCfgDb, struct PDSCH_Config *pdschCfg)
4156 {
4157    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4158
4159    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4160    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4161    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4162    {
4163       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4164       return RFAILED;
4165    }
4166
4167    if(BuildDMRSDLPdschMapTypeA(pdschCfgDb, pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4168    {
4169       return RFAILED;
4170    }
4171
4172    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4173    pdschCfg->tci_StatesToAddModList = NULLP;
4174    pdschCfg->tci_StatesToReleaseList = NULLP;
4175    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4176 #if 0
4177    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4178    if(!pdschCfg->tci_StatesToAddModList)
4179    {
4180       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4181       return RFAILED;
4182    }
4183    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4184    {
4185       return RFAILED;
4186    }
4187 #endif
4188
4189 if(pdschCfgDb == NULLP)
4190    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4191 else
4192 pdschCfg->resourceAllocation = pdschCfgDb->resourceAllocType;
4193
4194    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4195    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4196    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4197    {
4198       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4199       return RFAILED;
4200    }
4201    if(BuildPdschTimeDomAllocList(pdschCfgDb, pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4202    {
4203       return RFAILED;
4204    }
4205
4206    pdschCfg->pdsch_AggregationFactor = NULLP;
4207    pdschCfg->rateMatchPatternToAddModList = NULLP;
4208    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4209    pdschCfg->rateMatchPatternGroup1 = NULLP;
4210    pdschCfg->rateMatchPatternGroup2 = NULLP;
4211    if(pdschCfgDb == NULLP)
4212       pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4213    else
4214       pdschCfg->rbg_Size = pdschCfgDb->rbgSize;
4215    pdschCfg->mcs_Table = NULLP;
4216
4217    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4218    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4219    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4220    {
4221       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4222       return RFAILED;
4223    }
4224    if(pdschCfgDb == NULLP)
4225       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4226    else
4227       *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = pdschCfgDb->numCodeWordsSchByDci;
4228
4229    if(BuildPdschPrbBundlingType(pdschCfgDb, &pdschCfg->prb_BundlingType) != ROK)
4230    {
4231       return RFAILED;
4232    }
4233
4234    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4235    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4236    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4237    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4238    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4239    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4240    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4241
4242    return ROK;
4243 }
4244
4245 /*******************************************************************
4246  *
4247  * @brief Builds intitial DL BWP
4248  * @details
4249  *
4250  *    Function : BuildInitialDlBWP
4251  *
4252  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4253  *
4254  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4255  *
4256  * @return ROK     - success
4257  *         RFAILED - failure
4258  *
4259  * ****************************************************************/
4260 uint8_t BuildInitialDlBWP(InitialDlBwp *initiDlBwp, BWP_DownlinkDedicated_t *dlBwp)
4261 {
4262    PdcchConfig *pdcchCfg = NULLP;
4263    PdschConfig *pdschCfg = NULLP;
4264
4265    if(initiDlBwp)
4266    {
4267       if(initiDlBwp->pdcchPresent)
4268          pdcchCfg = &initiDlBwp->pdcchCfg;
4269       if(initiDlBwp->pdschPresent)
4270          pdschCfg = &initiDlBwp->pdschCfg;
4271    }
4272
4273    dlBwp->pdcch_Config = NULLP;
4274    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4275    if(!dlBwp->pdcch_Config)
4276    {
4277       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4278       return RFAILED;
4279    }
4280    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4281
4282    dlBwp->pdcch_Config->choice.setup = NULLP;
4283    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4284    if(!dlBwp->pdcch_Config->choice.setup)
4285    {
4286       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4287       return RFAILED;
4288    }
4289    if(BuildBWPDlDedPdcchCfg(pdcchCfg, dlBwp->pdcch_Config->choice.setup) != ROK)
4290    {
4291       return RFAILED;
4292    }
4293
4294    dlBwp->pdsch_Config = NULLP;
4295    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4296    if(!dlBwp->pdsch_Config)
4297    {
4298       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4299       return RFAILED;
4300    }
4301    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4302
4303    dlBwp->pdsch_Config->choice.setup = NULLP;
4304    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4305    if(!dlBwp->pdsch_Config->choice.setup)
4306    {
4307       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4308       return RFAILED;
4309    }
4310
4311    if(BuildBWPDlDedPdschCfg(pdschCfg, dlBwp->pdsch_Config->choice.setup) != ROK)
4312    {
4313       return RFAILED;
4314    }
4315
4316    dlBwp->sps_Config = NULLP;
4317    dlBwp->radioLinkMonitoringConfig = NULLP;
4318    return ROK;
4319 }
4320
4321 /*******************************************************************
4322  *
4323  * @brief Builds DMRS UL Pusch Mapping type A
4324  *
4325  * @details
4326  *
4327  *    Function : BuildDMRSULPuschMapTypeA
4328  *
4329  *    Functionality: Builds DMRS UL Pusch Mapping type A
4330  *
4331  * @params[in]
4332  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4333  * @return ROK     - success
4334  *         RFAILED - failure
4335  *
4336  * ****************************************************************/
4337 uint8_t BuildDMRSULPuschMapTypeA(DmrsUlCfg *ulDmrsCfgDb, struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg)
4338 {
4339    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4340    dmrsUlCfg->choice.setup= NULLP;
4341    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4342    if(!dmrsUlCfg->choice.setup)
4343    {
4344       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4345       return RFAILED;
4346    }
4347
4348    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4349    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4350    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4351    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4352    {
4353       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4354       return RFAILED;
4355    }
4356    if(ulDmrsCfgDb == NULLP)
4357       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4358    else
4359       *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = ulDmrsCfgDb->addPos;
4360
4361    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4362    dmrsUlCfg->choice.setup->maxLength = NULLP;
4363    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4364    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4365    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4366    {
4367       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4368       return RFAILED;
4369    }
4370
4371    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4372    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4373          sizeof(long));
4374    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4375    {
4376       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4377       return RFAILED;
4378    }
4379    if(ulDmrsCfgDb == NULLP)
4380       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4381    else
4382       *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = ulDmrsCfgDb->transPrecodDisabled.scramblingId0;
4383
4384    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4385    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4386    return ROK;
4387 }
4388
4389 /*******************************************************************
4390  *
4391  * @brief Build PUSCH time domain allocation list
4392  *
4393  * @details
4394  *
4395  *    Function : BuildPuschTimeDomAllocList
4396  *
4397  *    Functionality: Build PUSCH time domain allocation list
4398  *
4399  * @params[in]
4400  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4401  *
4402  * @return ROK     - success
4403  *         RFAILED - failure
4404  *
4405  * ****************************************************************/
4406 uint8_t BuildPuschTimeDomAllocList(PuschCfg *puschCfgDb, struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList)
4407 {
4408    uint8_t idx;
4409    uint8_t elementCnt;
4410    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4411
4412    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4413    timeDomAllocList->choice.setup = NULLP;
4414    DU_ALLOC(timeDomAllocList->choice.setup, sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4415    if(!timeDomAllocList->choice.setup)
4416    {
4417       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4418       return RFAILED;
4419    }
4420
4421    if(puschCfgDb == NULLP)
4422       elementCnt = 2;
4423    else
4424       elementCnt = puschCfgDb->numTimeDomRsrcAlloc;
4425
4426    timeDomAllocList->choice.setup->list.count = elementCnt;
4427    timeDomAllocList->choice.setup->list.size = elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4428    timeDomAllocList->choice.setup->list.array = NULLP;
4429    DU_ALLOC(timeDomAllocList->choice.setup->list.array, timeDomAllocList->choice.setup->list.size);
4430    if(!timeDomAllocList->choice.setup->list.array)
4431    {
4432       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4433       return RFAILED;
4434    }
4435
4436    for(idx = 0; idx < elementCnt; idx++)
4437    {
4438       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4439       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], sizeof(PUSCH_TimeDomainResourceAllocation_t));
4440       if(!timeDomAllocList->choice.setup->list.array[idx])
4441       {
4442          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4443          return RFAILED;
4444       }
4445    }
4446
4447    for(idx = 0; idx < elementCnt; idx++)
4448    {
4449       timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4450       DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4451       if(!timeDomAlloc->k2)
4452       {
4453          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4454          return RFAILED;
4455       }
4456       if(puschCfgDb == NULLP)
4457       {
4458          if(idx == 0)
4459             *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4460          else if(idx == 1)
4461             *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4462
4463          timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4464          timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4465       }
4466       else
4467       {
4468          *(timeDomAlloc->k2) = puschCfgDb->timeDomRsrcAllocList[idx].k2;
4469          timeDomAlloc->mappingType = puschCfgDb->timeDomRsrcAllocList[idx].mappingType;
4470          timeDomAlloc->startSymbolAndLength = puschCfgDb->timeDomRsrcAllocList[idx].startSymbolAndLength;
4471       }
4472    }
4473
4474    return ROK;
4475 }
4476
4477 /*******************************************************************
4478  *
4479  * @brief Builds BWP UL dedicated PUSCH Config
4480  *
4481  * @details
4482  *
4483  *    Function : BuildBWPUlDedPuschCfg
4484  *
4485  *    Functionality:
4486  *      Builds BWP UL dedicated PUSCH Config
4487  *
4488  * @params[in] : PUSCH_Config_t *puschCfg
4489  *
4490  * @return ROK     - success
4491  *         RFAILED - failure
4492  *
4493  * ****************************************************************/
4494 uint8_t BuildBWPUlDedPuschCfg(PuschCfg *puschCfgDb, PUSCH_Config_t *puschCfg)
4495 {
4496    DmrsUlCfg *ulDmrsCfg = NULLP;
4497
4498    if(puschCfgDb)
4499       ulDmrsCfg = &puschCfgDb->dmrsUlCfgForPuschMapTypeA;
4500
4501    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4502    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4503    if(!puschCfg->dataScramblingIdentityPUSCH)
4504    {
4505       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4506       return RFAILED;
4507    }
4508    if(puschCfgDb == NULLP)
4509       *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4510    else
4511       *(puschCfg->dataScramblingIdentityPUSCH) = puschCfgDb->dataScramblingId;
4512
4513    puschCfg->txConfig = NULLP;
4514    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4515    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4516    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4517    {
4518       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4519       return RFAILED;
4520    }
4521
4522    if(BuildDMRSULPuschMapTypeA(ulDmrsCfg, puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4523    {
4524       return RFAILED;
4525    }
4526
4527    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4528    puschCfg->pusch_PowerControl = NULLP;
4529    puschCfg->frequencyHopping = NULLP;
4530    puschCfg->frequencyHoppingOffsetLists = NULLP;
4531
4532    if(puschCfgDb == NULLP)
4533       puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4534    else
4535       puschCfg->resourceAllocation = puschCfgDb->resourceAllocType;
4536
4537    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4538    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4539    if(!puschCfg->pusch_TimeDomainAllocationList)
4540    {
4541       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4542       return RFAILED;
4543    }
4544
4545    if(BuildPuschTimeDomAllocList(puschCfgDb, puschCfg->pusch_TimeDomainAllocationList) != ROK)
4546    {
4547       return RFAILED;
4548    }
4549
4550    puschCfg->pusch_AggregationFactor = NULLP;
4551    puschCfg->mcs_Table = NULLP;
4552    puschCfg->mcs_TableTransformPrecoder = NULLP;
4553    puschCfg->transformPrecoder = NULLP;
4554    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4555    if(!puschCfg->transformPrecoder)
4556    {
4557       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4558       return RFAILED;
4559    }
4560    if(puschCfgDb == NULLP)
4561       *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4562    else
4563       *(puschCfg->transformPrecoder) = puschCfgDb->transformPrecoder;
4564
4565    puschCfg->codebookSubset = NULLP;
4566    puschCfg->maxRank = NULLP;
4567    puschCfg->rbg_Size = NULLP;
4568    puschCfg->uci_OnPUSCH = NULLP;
4569    puschCfg->tp_pi2BPSK = NULLP;
4570
4571    return ROK;
4572 }
4573
4574 /*******************************************************************
4575  *
4576  * @brief Builds PUCCH resource set add/modify list
4577  *
4578  * @details
4579  *
4580  *    Function : BuildPucchRsrcSetAddModList
4581  *
4582  *    Functionality:
4583  *      Builds PUCCH resource set add/modify list
4584  *
4585  * @params[in] : PucchResrcSetCfg *rsrcSetCfgDb
4586  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4587  *
4588  * @return ROK     - success
4589  *         RFAILED - failure
4590  *
4591  * ****************************************************************/
4592 uint8_t BuildPucchRsrcSetAddModList(PucchResrcSetCfg *rsrcSetCfgDb, \
4593    struct PUCCH_Config__resourceSetToAddModList *resourceSetToAddModList)
4594 {
4595    uint8_t elementCnt = 0, rsrcSetIdx = 0, rsrcIdx = 0;
4596    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4597
4598    if(rsrcSetCfgDb == NULLP)
4599       elementCnt = 1;
4600    else
4601       elementCnt = rsrcSetCfgDb->resrcSetToAddModListCount;
4602
4603    resourceSetToAddModList->list.count = elementCnt;
4604    resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4605    DU_ALLOC(resourceSetToAddModList->list.array, resourceSetToAddModList->list.size);
4606    if(resourceSetToAddModList->list.array == NULLP)
4607    {
4608       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4609       return RFAILED;
4610    }
4611    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4612    {
4613       DU_ALLOC(resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4614       if(resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4615       {
4616          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4617          return RFAILED;
4618       }
4619    }
4620
4621    for(rsrcSetIdx=0; rsrcSetIdx < resourceSetToAddModList->list.count; rsrcSetIdx++)
4622    {
4623       rsrcSet = resourceSetToAddModList->list.array[rsrcSetIdx];
4624
4625       /* Resource set Id */
4626       if(rsrcSetCfgDb == NULLP)
4627          rsrcSet->pucch_ResourceSetId = 1;
4628       else
4629          rsrcSet->pucch_ResourceSetId = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcSetId;
4630
4631       /* Resource list of a resource set */
4632       if(rsrcSetCfgDb == NULLP)
4633          elementCnt = 1;
4634       else
4635          elementCnt = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcListCount;
4636       rsrcSet->resourceList.list.count = elementCnt;
4637       rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4638       DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4639       if(rsrcSet->resourceList.list.array == NULLP)
4640       {
4641          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4642          return RFAILED;
4643       }
4644
4645       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4646       {
4647          DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4648          if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4649          {
4650             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4651             return RFAILED;
4652          }
4653       }
4654       for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4655       {
4656          if(rsrcSetCfgDb == NULLP)
4657             *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4658          else
4659             *(rsrcSet->resourceList.list.array[rsrcIdx]) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].resrcList[rsrcIdx];
4660       }
4661
4662       /* Max payload size (minus 1) in a Resource set */
4663       rsrcSet->maxPayloadMinus1 = NULLP;
4664       if(rsrcSetCfgDb && rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize)
4665       {
4666          DU_ALLOC(rsrcSet->maxPayloadMinus1, sizeof(long));
4667          if(rsrcSet->maxPayloadMinus1 == NULLP)
4668          {
4669             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcSetAddModList");
4670             return RFAILED;
4671          }
4672          *(rsrcSet->maxPayloadMinus1) = rsrcSetCfgDb->resrcSetToAddModList[rsrcSetIdx].maxPayLoadSize;
4673       }
4674    }
4675    return ROK;
4676 }
4677
4678 /*******************************************************************
4679  *
4680  * @brief Builds PUCCH resource add/modify list
4681  *
4682  * @details
4683  *
4684  *    Function : BuildPucchRsrcAdddModList
4685  *
4686  *    Functionality:
4687  *      Builds PUCCH resource add/modify list
4688  *
4689  * @params[in] : PucchResrcCfg *rsrcSetCfgDb
4690  *               struct PUCCH_Config__resourceSetToAddModList *rsrcSetAddModList
4691  *
4692  * @return ROK     - success
4693  *         RFAILED - failure
4694  *
4695  * ****************************************************************/
4696 uint8_t BuildPucchRsrcAddModList(PucchResrcCfg *rsrcCfgDb, struct PUCCH_Config__resourceToAddModList  *resourceToAddModList)
4697 {
4698    uint8_t elementCnt = 0, rsrcIdx = 0;
4699    PUCCH_Resource_t *rsrc = NULLP;
4700
4701    if(rsrcCfgDb == NULLP)
4702       elementCnt = 1;
4703    else
4704       elementCnt = rsrcCfgDb->resrcToAddModListCount;
4705    resourceToAddModList->list.count = elementCnt;
4706    resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4707    DU_ALLOC(resourceToAddModList->list.array, resourceToAddModList->list.size);
4708    if(resourceToAddModList->list.array == NULLP)
4709    {
4710       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4711       return RFAILED;
4712    }
4713    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4714    {
4715       DU_ALLOC(resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4716       if(resourceToAddModList->list.array[rsrcIdx] == NULLP)
4717       {
4718          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4719          return RFAILED;
4720       }
4721    }
4722
4723    for(rsrcIdx=0; rsrcIdx < resourceToAddModList->list.count; rsrcIdx++)
4724    {
4725       rsrc = resourceToAddModList->list.array[rsrcIdx];
4726
4727       if(rsrcCfgDb == NULLP)
4728       {
4729          rsrc->pucch_ResourceId = 1;
4730          rsrc->startingPRB = 0;
4731          rsrc->format.present = PUCCH_Resource__format_PR_format1;
4732          DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4733          if(rsrc->format.choice.format1 == NULLP)
4734          {
4735             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4736             return RFAILED;
4737          }
4738          rsrc->format.choice.format1->initialCyclicShift = 0;
4739          rsrc->format.choice.format1->nrofSymbols = 4;
4740          rsrc->format.choice.format1->startingSymbolIndex = 0;
4741          rsrc->format.choice.format1->timeDomainOCC = 0;
4742       }
4743       else
4744       {
4745          rsrc->pucch_ResourceId = rsrcCfgDb->resrcToAddModList[rsrcIdx].resrcId;
4746          rsrc->startingPRB = rsrcCfgDb->resrcToAddModList[rsrcIdx].startPrb;
4747          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop)
4748          {
4749             DU_ALLOC(rsrc->intraSlotFrequencyHopping, sizeof(long));
4750             if(rsrc->intraSlotFrequencyHopping == NULLP)
4751             {
4752                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4753                return RFAILED;
4754             }
4755             *(rsrc->intraSlotFrequencyHopping) = rsrcCfgDb->resrcToAddModList[rsrcIdx].intraFreqHop;
4756          }
4757          else
4758             rsrc->intraSlotFrequencyHopping = NULLP;
4759
4760          if(rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop)
4761          {
4762             DU_ALLOC(rsrc->secondHopPRB, sizeof(PRB_Id_t));
4763             if(rsrc->secondHopPRB == NULLP)
4764             {
4765                DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4766                return RFAILED;
4767             }
4768             *(rsrc->secondHopPRB) = rsrcCfgDb->resrcToAddModList[rsrcIdx].secondPrbHop;
4769          }
4770          else
4771             rsrc->secondHopPRB = NULLP;
4772          rsrc->format.present = covertPucchFormatIntEnumToRrcEnum(rsrcCfgDb->resrcToAddModList[rsrcIdx].pucchFormat);
4773
4774          switch(rsrc->format.present)
4775          {
4776             case PUCCH_Resource__format_PR_NOTHING:
4777                break;
4778             case PUCCH_Resource__format_PR_format0:
4779                {
4780                   DU_ALLOC(rsrc->format.choice.format0, sizeof(PUCCH_format0_t));
4781                   if(rsrc->format.choice.format0 == NULLP)
4782                   {
4783                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4784                      return RFAILED;
4785                   }
4786                   rsrc->format.choice.format0->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->initialCyclicShift;
4787                   rsrc->format.choice.format0->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->numSymbols;
4788                   rsrc->format.choice.format0->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format0->startSymbolIdx;
4789                   break;
4790                }
4791
4792             case PUCCH_Resource__format_PR_format1:
4793                {
4794                   DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4795                   if(rsrc->format.choice.format1 == NULLP)
4796                   {
4797                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4798                      return RFAILED;
4799                   }
4800                   rsrc->format.choice.format1->initialCyclicShift = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->initialCyclicShift;
4801                   rsrc->format.choice.format1->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->numSymbols;
4802                   rsrc->format.choice.format1->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->startSymbolIdx;
4803                   rsrc->format.choice.format1->timeDomainOCC = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format1->timeDomOCC;
4804                   break;
4805                }
4806
4807             case PUCCH_Resource__format_PR_format2:
4808                {
4809                   DU_ALLOC(rsrc->format.choice.format2, sizeof(PUCCH_format2_t));
4810                   if(rsrc->format.choice.format2 == NULLP)
4811                   {
4812                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4813                      return RFAILED;
4814                   }
4815                   rsrc->format.choice.format2->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numPrbs;
4816                   rsrc->format.choice.format2->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->numSymbols;
4817                   rsrc->format.choice.format2->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format2->startSymbolIdx;
4818                   break;
4819                }
4820
4821             case PUCCH_Resource__format_PR_format3:
4822                {
4823                   DU_ALLOC(rsrc->format.choice.format3, sizeof(PUCCH_format3_t));
4824                   if(rsrc->format.choice.format3 == NULLP)
4825                   {
4826                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4827                      return RFAILED;
4828                   }
4829                   rsrc->format.choice.format3->nrofPRBs = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numPrbs;
4830                   rsrc->format.choice.format3->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->numSymbols;
4831                   rsrc->format.choice.format3->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format3->startSymbolIdx;
4832                   break;
4833                }
4834
4835             case PUCCH_Resource__format_PR_format4:
4836                {
4837                   DU_ALLOC(rsrc->format.choice.format4, sizeof(PUCCH_format4_t));
4838                   if(rsrc->format.choice.format4 == NULLP)
4839                   {
4840                      DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchRsrcAddModList");
4841                      return RFAILED;
4842                   }
4843                   rsrc->format.choice.format4->nrofSymbols = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->numSymbols;
4844                   rsrc->format.choice.format4->occ_Length = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occLen;
4845                   rsrc->format.choice.format4->occ_Index = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->occIdx;
4846                   rsrc->format.choice.format4->startingSymbolIndex = rsrcCfgDb->resrcToAddModList[rsrcIdx].PucchFormat.format4->startSymbolIdx;
4847                   break;
4848                }
4849          }
4850       }
4851    }
4852    return ROK;
4853 }
4854
4855 /*******************************************************************
4856  *
4857  * @brief Builds PUCCH format  config
4858  *
4859  * @details
4860  *
4861  *    Function : BuildPucchFormat
4862  *
4863  *    Functionality: Builds PUCCH format  config
4864  *
4865  * @params[in] : PucchFormatCfg *formatDb
4866  *               PUCCH_FormatConfig_t *format
4867  *
4868  * @return ROK     - success
4869  *         RFAILED - failure
4870  *
4871  * ****************************************************************/
4872 uint8_t BuildPucchFormat(PucchFormatCfg *formatDb, PUCCH_FormatConfig_t *format)
4873 {
4874    /* Inter Slot Fequency hopping */
4875    format->interslotFrequencyHopping = NULLP;
4876    if((formatDb != NULLP) && (formatDb->interSlotFreqHop == true))
4877    {
4878       DU_ALLOC(format->interslotFrequencyHopping, sizeof(long));
4879       if(format->interslotFrequencyHopping)
4880       {
4881          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4882          return RFAILED;
4883       }
4884       *(format->interslotFrequencyHopping) = PUCCH_FormatConfig__interslotFrequencyHopping_enabled;
4885    }
4886
4887    /* Additional DMRS */
4888    format->additionalDMRS = NULLP;
4889    if((formatDb != NULLP) && (formatDb->addDmrs == true))
4890    {
4891       DU_ALLOC(format->additionalDMRS, sizeof(long));
4892       if(format->additionalDMRS)
4893       {
4894          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4895          return RFAILED;
4896       }
4897       *(format->additionalDMRS) = PUCCH_FormatConfig__additionalDMRS_true;
4898    }
4899
4900     /* Maximum code rate */
4901    format->maxCodeRate = NULLP;
4902    if((formatDb != NULLP) && (formatDb->maxCodeRate != 0))
4903    {
4904       DU_ALLOC(format->maxCodeRate, sizeof(long));
4905       if(format->maxCodeRate)
4906       {
4907          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4908          return RFAILED;
4909       }
4910       *(format->maxCodeRate) = formatDb->maxCodeRate;
4911    }
4912
4913    /* Number of slots */
4914    format->nrofSlots = NULLP;
4915    if((formatDb == NULLP) || ((formatDb != NULLP) && (formatDb->numSlots != 0)))
4916    {
4917       DU_ALLOC(format->nrofSlots, sizeof(long));
4918       if(format->nrofSlots == NULLP)
4919       {
4920          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4921          return RFAILED;
4922       }
4923       if(formatDb == NULLP)
4924          *(format->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4925       else
4926          *(format->nrofSlots) = formatDb->numSlots;
4927    }
4928
4929    /* Pi2BPSK*/
4930    format->pi2BPSK = NULLP;
4931    if((formatDb != NULLP) && (formatDb->pi2BPSK == true))
4932    {
4933       DU_ALLOC(format->pi2BPSK, sizeof(long));
4934       if(format->pi2BPSK)
4935       {
4936          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4937          return RFAILED;
4938       }
4939       *(format->pi2BPSK) = PUCCH_FormatConfig__pi2BPSK_enabled;
4940    }
4941
4942    /* Simultaneous HARQ ACK and CSI */
4943    format->simultaneousHARQ_ACK_CSI = NULLP;
4944    if((formatDb != NULLP) && (formatDb->harqAckCSI == true))
4945    {
4946       DU_ALLOC(format->simultaneousHARQ_ACK_CSI, sizeof(long));
4947       if(format->simultaneousHARQ_ACK_CSI)
4948       {
4949          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPucchFormat");
4950          return RFAILED;
4951       }
4952       *(format->simultaneousHARQ_ACK_CSI) = PUCCH_FormatConfig__simultaneousHARQ_ACK_CSI_true;
4953    }
4954
4955    return ROK;
4956 }
4957
4958
4959 /*******************************************************************
4960  *
4961  * @brief Builds PUCCH scheduling request list
4962  *
4963  * @details
4964  *
4965  *    Function : BuildPucchSchReqAddModList
4966  *
4967  *    Functionality:
4968  *      Builds PUCCH scheduling request list
4969  *
4970  * @params[in] : PucchSchedReqCfg *schReqDb
4971  *               struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList
4972  *
4973  * @return ROK     - success
4974  *         RFAILED - failure
4975  *
4976  * ****************************************************************/
4977 uint8_t BuildPucchSchReqAddModList(PucchSchedReqCfg *schReqDb, \
4978    struct PUCCH_Config__schedulingRequestResourceToAddModList *schReqRsrcToAddModList)
4979 {
4980    uint8_t elementCnt = 0, schReqIdx = 0;
4981    SchedulingRequestResourceConfig_t *schReqRsrc;
4982
4983    elementCnt = schReqDb->schedAddModListCount;
4984    schReqRsrcToAddModList->list.count = elementCnt;
4985    schReqRsrcToAddModList->list.size = elementCnt *sizeof(struct SchedulingRequestResourceConfig *);
4986
4987    schReqRsrcToAddModList->list.array = NULLP;
4988    DU_ALLOC(schReqRsrcToAddModList->list.array, schReqRsrcToAddModList->list.size);
4989    if(schReqRsrcToAddModList->list.array == NULLP)
4990    {
4991       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
4992       return RFAILED;
4993    }
4994
4995    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
4996    {
4997       DU_ALLOC(schReqRsrcToAddModList->list.array[schReqIdx], schReqRsrcToAddModList->list.size);
4998       if(schReqRsrcToAddModList->list.array[schReqIdx] == NULLP)
4999       {
5000          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5001          return RFAILED;
5002       }
5003    }
5004
5005    for(schReqIdx = 0; schReqIdx < schReqRsrcToAddModList->list.count; schReqIdx++)
5006    {
5007       schReqRsrc = schReqRsrcToAddModList->list.array[schReqIdx];
5008       schReqRsrc->schedulingRequestResourceId = schReqDb->schedAddModList[schReqIdx].resrcId;
5009       schReqRsrc->schedulingRequestID = schReqDb->schedAddModList[schReqIdx].requestId;
5010
5011       if(schReqDb->schedAddModList[schReqIdx].periodicity)
5012       {
5013          schReqRsrc->periodicityAndOffset = NULLP;
5014          DU_ALLOC(schReqRsrc->periodicityAndOffset, sizeof(struct SchedulingRequestResourceConfig__periodicityAndOffset));
5015          if(schReqRsrc->periodicityAndOffset == NULLP)
5016          {
5017             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5018             return RFAILED;
5019          }
5020
5021          schReqRsrc->periodicityAndOffset->present = schReqDb->schedAddModList[schReqIdx].periodicity;
5022          switch(schReqRsrc->periodicityAndOffset->present)
5023          {
5024             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_NOTHING:
5025                break;
5026             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
5027                schReqRsrc->periodicityAndOffset->choice.sym2 = schReqDb->schedAddModList[schReqIdx].offset;
5028                break;
5029             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
5030                schReqRsrc->periodicityAndOffset->choice.sym6or7 = schReqDb->schedAddModList[schReqIdx].offset;
5031                break;
5032             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
5033                schReqRsrc->periodicityAndOffset->choice.sl1 = schReqDb->schedAddModList[schReqIdx].offset;
5034                break;
5035             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
5036                schReqRsrc->periodicityAndOffset->choice.sl2 = schReqDb->schedAddModList[schReqIdx].offset;
5037                break;
5038             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
5039                schReqRsrc->periodicityAndOffset->choice.sl4 = schReqDb->schedAddModList[schReqIdx].offset;
5040                break;
5041             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
5042                schReqRsrc->periodicityAndOffset->choice.sl5 = schReqDb->schedAddModList[schReqIdx].offset;
5043                break;
5044             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
5045                schReqRsrc->periodicityAndOffset->choice.sl8 = schReqDb->schedAddModList[schReqIdx].offset;
5046                break;
5047             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
5048                schReqRsrc->periodicityAndOffset->choice.sl10 = schReqDb->schedAddModList[schReqIdx].offset;
5049                break;
5050             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
5051                schReqRsrc->periodicityAndOffset->choice.sl16 = schReqDb->schedAddModList[schReqIdx].offset;
5052                break;
5053             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
5054                schReqRsrc->periodicityAndOffset->choice.sl20 = schReqDb->schedAddModList[schReqIdx].offset;
5055                break;
5056             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
5057                schReqRsrc->periodicityAndOffset->choice.sl40 = schReqDb->schedAddModList[schReqIdx].offset;
5058                break;
5059             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
5060                schReqRsrc->periodicityAndOffset->choice.sl80 = schReqDb->schedAddModList[schReqIdx].offset;
5061                break;
5062             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
5063                schReqRsrc->periodicityAndOffset->choice.sl160 = schReqDb->schedAddModList[schReqIdx].offset;
5064                break;
5065             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
5066                schReqRsrc->periodicityAndOffset->choice.sl320 = schReqDb->schedAddModList[schReqIdx].offset;
5067                break;
5068             case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
5069                schReqRsrc->periodicityAndOffset->choice.sl640 = schReqDb->schedAddModList[schReqIdx].offset;
5070                break;
5071          }
5072       }
5073
5074       if(schReqDb->schedAddModList[schReqIdx].resrc)
5075       {
5076          schReqRsrc->resource = NULLP;
5077          DU_ALLOC(schReqRsrc->resource, sizeof(PUCCH_ResourceId_t));
5078          if(schReqRsrc->resource == NULLP)
5079          {
5080             DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchSchReqAddModList");
5081             return RFAILED;
5082          }
5083          *(schReqRsrc->resource) = schReqDb->schedAddModList[schReqIdx].resrc;
5084
5085       }
5086    }
5087    return ROK;
5088 }
5089
5090 /*******************************************************************
5091  *
5092  * @brief Builds PUCCH multi csi resource list
5093  *
5094  * @details
5095  *
5096  *    Function : BuildPucchMultiCsiRsrcList
5097  *
5098  *    Functionality:
5099  *      Builds PUCCH multi csi resource list
5100  *
5101  * @params[in] : PucchMultiCsiCfg *multiCsiDb
5102  *               struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList
5103  *
5104  * @return ROK     - success
5105  *         RFAILED - failure
5106  *
5107  * ****************************************************************/
5108 uint8_t BuildPucchMultiCsiRsrcList(PucchMultiCsiCfg *multiCsiDb, struct PUCCH_Config__multi_CSI_PUCCH_ResourceList  *multiCsiRsrcList)
5109 {
5110    uint8_t elementCnt = 0, rsrcIdx = 0;
5111
5112    elementCnt = multiCsiDb->multiCsiResrcListCount;
5113    multiCsiRsrcList->list.count = elementCnt;
5114    multiCsiRsrcList->list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
5115    multiCsiRsrcList->list.array = NULLP;
5116    DU_ALLOC(multiCsiRsrcList->list.array, multiCsiRsrcList->list.size);
5117    if(multiCsiRsrcList->list.array == NULLP)
5118    {
5119       DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5120       return RFAILED;
5121    }
5122
5123    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5124    {
5125       DU_ALLOC(multiCsiRsrcList->list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5126       if(multiCsiRsrcList->list.array[rsrcIdx] == NULLP)
5127       {
5128          DU_LOG("\nERROR  --> DU APP: Memory allocation failed in BuildPucchMultiCsiRsrcList");
5129          return RFAILED;
5130       }
5131    }
5132
5133    for(rsrcIdx = 0; rsrcIdx<multiCsiRsrcList->list.count; rsrcIdx++)
5134    {
5135       *(multiCsiRsrcList->list.array[rsrcIdx]) = multiCsiDb->multiCsiResrcList[rsrcIdx];
5136    }
5137    return ROK;
5138 }
5139
5140 /*******************************************************************
5141  *
5142  * @brief Builds DL data -to- Ul Ack list
5143  *
5144  * @details
5145  *
5146  *    Function : BuildDlDataToUlAckList
5147  *
5148  *    Functionality: Builds DL data -to- Ul Ack list
5149  *
5150  * @params[in] : PucchDlDataToUlAck *dlDataToUlAckDb
5151  *               struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList
5152  *
5153  * @return ROK     - success
5154  *         RFAILED - failure
5155  *
5156  * ****************************************************************/
5157 uint8_t BuildDlDataToUlAckList(PucchDlDataToUlAck *dlDataToUlAckDb, struct PUCCH_Config__dl_DataToUL_ACK * dlDataToUlACKList)
5158 {
5159    uint8_t elementCnt = 0, arrIdx = 0;
5160
5161    if(dlDataToUlAckDb == NULLP)
5162       elementCnt = 2;
5163    else
5164       elementCnt = dlDataToUlAckDb->dlDataToUlAckListCount;
5165
5166    dlDataToUlACKList->list.count = elementCnt;
5167    dlDataToUlACKList->list.size = elementCnt * sizeof(long *);
5168    DU_ALLOC(dlDataToUlACKList->list.array, dlDataToUlACKList->list.size);
5169    if(dlDataToUlACKList->list.array == NULLP)
5170    {
5171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5172       return RFAILED;
5173    }
5174
5175    for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5176    {
5177       DU_ALLOC(dlDataToUlACKList->list.array[arrIdx], sizeof(long));
5178       if(dlDataToUlACKList->list.array[arrIdx] == NULLP)
5179       {
5180          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDlDataToUlAckList");
5181          return RFAILED;
5182       }
5183    }
5184
5185    if(dlDataToUlAckDb == NULLP)
5186    {
5187       arrIdx = 0;
5188       *(dlDataToUlACKList->list.array[arrIdx++]) = 1;
5189       *(dlDataToUlACKList->list.array[arrIdx]) = 2;
5190    }
5191    else
5192    {
5193       for(arrIdx = 0; arrIdx <  dlDataToUlACKList->list.count; arrIdx++)
5194       {
5195          *(dlDataToUlACKList->list.array[arrIdx]) = dlDataToUlAckDb->dlDataToUlAckList[arrIdx];
5196       }
5197    }
5198    return ROK;
5199 }
5200
5201 /*******************************************************************
5202  *
5203  * @brief Builds BWP UL dedicated PUCCH Config
5204  *
5205  * @details
5206  *
5207  *    Function : BuildBWPUlDedPucchCfg
5208  *
5209  *    Functionality:
5210  *      Builds BWP UL dedicated PUCCH Config
5211  *
5212  * @params[in] : PUCCH_Config_t *pucchCfg
5213  *
5214  * @return ROK     - success
5215  *         RFAILED - failure
5216  *
5217  * ****************************************************************/
5218 uint8_t BuildBWPUlDedPucchCfg(PucchCfg *pucchCfgDb, PUCCH_Config_t *pucchCfg)
5219 {
5220    PucchResrcSetCfg *rsrcSetCfgDb = NULLP;
5221    PucchResrcCfg *rsrcCfgDb = NULLP;
5222    PucchFormatCfg *format1Db = NULLP;
5223    PucchFormatCfg *format2Db = NULLP;
5224    PucchFormatCfg *format3Db = NULLP;
5225    PucchFormatCfg *format4Db = NULLP;
5226    PucchSchedReqCfg *schReqDb = NULLP;
5227    PucchMultiCsiCfg  *multiCsiDb = NULLP;
5228    PucchDlDataToUlAck *dlDataToUlAckDb = NULLP;
5229
5230    if(pucchCfgDb)
5231    {
5232       rsrcSetCfgDb = pucchCfgDb->resrcSet;
5233       rsrcCfgDb = pucchCfgDb->resrc;
5234       format1Db = pucchCfgDb->format1;
5235       format2Db = pucchCfgDb->format2;
5236       format3Db = pucchCfgDb->format3;
5237       format4Db = pucchCfgDb->format4;
5238       schReqDb = pucchCfgDb->schedReq;
5239       multiCsiDb = pucchCfgDb->multiCsiCfg;
5240       dlDataToUlAckDb = pucchCfgDb->dlDataToUlAck;
5241    }
5242
5243    /* RESOURCE SET */
5244    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5245    if(pucchCfg->resourceSetToAddModList == NULL)
5246    {
5247       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5248       return RFAILED;
5249    }
5250
5251    if(BuildPucchRsrcSetAddModList(rsrcSetCfgDb, pucchCfg->resourceSetToAddModList) != ROK)
5252    {
5253       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5254       return RFAILED;
5255    }
5256
5257    /* PUCCH RESOURCE */
5258    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5259    if(pucchCfg->resourceToAddModList == NULLP)
5260    {
5261       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5262       return RFAILED;
5263    }
5264
5265    if(BuildPucchRsrcAddModList(rsrcCfgDb, pucchCfg->resourceToAddModList) != ROK)
5266    {
5267       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5268       return RFAILED;
5269    }
5270
5271    /* PUCCH Format 1 */
5272    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5273    if(pucchCfg->format1 == NULLP)
5274    {
5275       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5276       return RFAILED;
5277    }
5278
5279    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
5280    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5281    if(pucchCfg->format1->choice.setup == NULLP)
5282    {
5283       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5284       return RFAILED;
5285    }
5286
5287    if(BuildPucchFormat(format1Db, pucchCfg->format1->choice.setup) != ROK)
5288    {
5289       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5290       return RFAILED;
5291    }
5292
5293    /* PUCCH Format 2 */
5294    if(format2Db)
5295    {
5296       DU_ALLOC(pucchCfg->format2, sizeof(struct PUCCH_Config__format2));
5297       if(pucchCfg->format2 == NULLP)
5298       {
5299          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5300          return RFAILED;
5301       }
5302
5303       pucchCfg->format2->present = PUCCH_Config__format2_PR_setup;
5304       DU_ALLOC(pucchCfg->format2->choice.setup, sizeof(PUCCH_FormatConfig_t));
5305       if(pucchCfg->format2->choice.setup == NULLP)
5306       {
5307          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5308          return RFAILED;
5309       }
5310
5311       if(BuildPucchFormat(format2Db, pucchCfg->format2->choice.setup) != ROK)
5312       {
5313          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5314          return RFAILED;
5315       }
5316    }
5317
5318    /* PUCCH Format 3 */
5319    if(format3Db)
5320    {
5321       DU_ALLOC(pucchCfg->format3, sizeof(struct PUCCH_Config__format3));
5322       if(pucchCfg->format3 == NULLP)
5323       {
5324          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5325          return RFAILED;
5326       }
5327
5328       pucchCfg->format3->present = PUCCH_Config__format3_PR_setup;
5329       DU_ALLOC(pucchCfg->format3->choice.setup, sizeof(PUCCH_FormatConfig_t));
5330       if(pucchCfg->format3->choice.setup == NULLP)
5331       {
5332          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5333          return RFAILED;
5334       }
5335
5336       if(BuildPucchFormat(format3Db, pucchCfg->format3->choice.setup) != ROK)
5337       {
5338          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5339          return RFAILED;
5340       }
5341    }
5342
5343    /* PUCCH Format 4 */
5344    if(format4Db)
5345    {
5346       DU_ALLOC(pucchCfg->format4, sizeof(struct PUCCH_Config__format4));
5347       if(pucchCfg->format4 == NULLP)
5348       {
5349          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5350          return RFAILED;
5351       }
5352
5353       pucchCfg->format4->present = PUCCH_Config__format4_PR_setup;
5354       DU_ALLOC(pucchCfg->format4->choice.setup, sizeof(PUCCH_FormatConfig_t));
5355       if(pucchCfg->format4->choice.setup == NULLP)
5356       {
5357          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5358          return RFAILED;
5359       }
5360
5361       if(BuildPucchFormat(format4Db, pucchCfg->format4->choice.setup) != ROK)
5362       {
5363          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5364          return RFAILED;
5365       }
5366    }
5367
5368    /* Scheduling Request */
5369    if(schReqDb && (schReqDb->schedAddModListCount != 0))
5370    {
5371       pucchCfg->schedulingRequestResourceToAddModList = NULLP;
5372       DU_ALLOC(pucchCfg->schedulingRequestResourceToAddModList, sizeof(struct PUCCH_Config__schedulingRequestResourceToAddModList));
5373       if(pucchCfg->schedulingRequestResourceToAddModList == NULLP)
5374       {
5375          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5376          return RFAILED;
5377       }
5378
5379       if(BuildPucchSchReqAddModList(schReqDb, pucchCfg->schedulingRequestResourceToAddModList) != ROK)
5380       {
5381          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5382          return RFAILED;
5383       }
5384    }
5385
5386    /* Multi CSI */
5387    if(multiCsiDb && (multiCsiDb->multiCsiResrcListCount != 0))
5388    {
5389       pucchCfg->multi_CSI_PUCCH_ResourceList = NULLP;
5390       DU_ALLOC(pucchCfg->multi_CSI_PUCCH_ResourceList, sizeof(struct PUCCH_Config__multi_CSI_PUCCH_ResourceList));
5391       if(pucchCfg->multi_CSI_PUCCH_ResourceList == NULLP)
5392       {
5393          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5394          return RFAILED;
5395       }
5396
5397       if(BuildPucchMultiCsiRsrcList(multiCsiDb, pucchCfg->multi_CSI_PUCCH_ResourceList) != ROK)
5398       {
5399          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5400          return RFAILED;
5401       }
5402    }
5403
5404    /* DL DATA TO UL ACK */
5405    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5406    if(pucchCfg->dl_DataToUL_ACK == NULLP)
5407    {
5408       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5409       return RFAILED;
5410    }
5411
5412    if(BuildDlDataToUlAckList(dlDataToUlAckDb, pucchCfg->dl_DataToUL_ACK) != ROK)
5413    {
5414       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
5415       return RFAILED;
5416    }
5417
5418    /* TODO : spatial relation info add/mod list and power control*/
5419
5420    return ROK;
5421 }
5422
5423 /*******************************************************************
5424  *
5425  * @brief Fills SRS resource to add/modify list
5426  *
5427  * @details
5428  *
5429  *    Function : BuildSrsRsrcAddModList
5430  *
5431  *    Functionality: Fills SRS resource to add/modify list
5432  *
5433  * @params[in]
5434  * @return ROK     - success
5435  *         RFAILED - failure
5436  *
5437  * ****************************************************************/
5438 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
5439 {
5440    uint8_t   elementCnt;
5441    uint8_t   rsrcIdx;
5442
5443    elementCnt = 1;
5444    resourceList->list.count = elementCnt;
5445    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
5446    resourceList->list.array = NULLP;
5447    DU_ALLOC(resourceList->list.array, resourceList->list.size);
5448    if(!resourceList->list.array)
5449    {
5450       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5451       return RFAILED;
5452    }
5453
5454    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5455    {
5456       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5457       if(!resourceList->list.array[rsrcIdx])
5458       {
5459          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5460          return RFAILED;
5461       }
5462    }
5463
5464    rsrcIdx = 0;
5465    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
5466    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
5467    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
5468
5469    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
5470    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
5471          sizeof(struct SRS_Resource__transmissionComb__n2));
5472    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
5473    {
5474       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5475       return RFAILED;
5476    }
5477    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
5478       = SRS_COMB_OFFSET_N2;
5479    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
5480       = SRS_CYCLIC_SHIFT_N2;
5481
5482    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
5483                                                                       PUSCH_START_SYMBOL;
5484    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
5485                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
5486    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
5487                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
5488
5489    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
5490    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
5491    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
5492    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
5493    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
5494    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
5495                                                                SRS_Resource__groupOrSequenceHopping_neither;
5496
5497    /* Setting resource type to aperiodic for intergration purposes */
5498    resourceList->list.array[rsrcIdx]->resourceType.present = \
5499                                                              SRS_Resource__resourceType_PR_aperiodic;
5500    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
5501    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
5502          sizeof(struct SRS_Resource__resourceType__aperiodic));
5503    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
5504    {
5505       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
5506       return RFAILED;
5507    }
5508
5509    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
5510
5511    return ROK;
5512 }
5513
5514 /*******************************************************************
5515  *
5516  * @brief Build SRS resource set Add/mod list
5517  *
5518  * @details
5519  *
5520  *    Function : BuildSrsRsrcSetAddModList
5521  *
5522  *    Functionality: Build SRS resource set Add/mod list
5523  *
5524  * @params[in]
5525  * @return ROK     - success
5526  *         RFAILED - failure
5527  *
5528  * ****************************************************************/
5529    uint8_t BuildSrsRsrcSetAddModList
5530 (
5531  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
5532  )
5533 {
5534    uint8_t  elementCnt;
5535    uint8_t  rSetIdx;
5536    uint8_t  rsrcIdx;
5537    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
5538
5539    elementCnt = 1;
5540    rsrcSetList->list.count = elementCnt;
5541    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
5542    rsrcSetList->list.array = NULLP;
5543    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
5544    if(!rsrcSetList->list.array)
5545    {
5546       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5547       return RFAILED;
5548    }
5549
5550    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5551    {
5552       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5553       if(!rsrcSetList->list.array[rSetIdx])
5554       {
5555          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5556          return RFAILED;
5557       }
5558    }
5559
5560    rSetIdx = 0;
5561    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
5562
5563    /* Fill Resource Id list in resource set */
5564    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
5565    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5566          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5567    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5568    {
5569       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5570       return RFAILED;
5571    }
5572
5573    elementCnt = 1;
5574    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5575    rsrcIdList->list.count = elementCnt;
5576    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
5577    rsrcIdList->list.array = NULLP;
5578    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
5579    if(!rsrcIdList->list.array)
5580    {
5581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5582       return RFAILED;
5583    }
5584
5585    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5586    {
5587       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5588       if(!rsrcIdList->list.array[rsrcIdx])
5589       {
5590          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5591          return RFAILED;
5592       }
5593    }
5594
5595    rsrcIdx = 0;
5596    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
5597
5598    /* Fill resource type */
5599    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
5600                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
5601
5602    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
5603    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5604          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5605    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
5606    {
5607       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
5608       return RFAILED;
5609    }
5610    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
5611       = APERIODIC_SRS_RESRC_TRIGGER;
5612
5613    /* TODO : Fill values for below IEs as expected by Viavi */
5614    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
5615    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
5616
5617
5618    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
5619    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
5620    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
5621    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
5622    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
5623
5624    return ROK;
5625 }
5626
5627 /*******************************************************************
5628  *
5629  * @brief Builds BWP UL dedicated SRS Config
5630  *
5631  * @details
5632  *
5633  *    Function : BuildBWPUlDedSrsCfg
5634  *
5635  *    Functionality: Builds BWP UL dedicated SRS Config
5636  *
5637  * @params[in] SRS Config
5638  * @return ROK     - success
5639  *         RFAILED - failure
5640  *
5641  * ****************************************************************/
5642 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
5643 {
5644    srsCfg->srs_ResourceSetToReleaseList = NULLP;
5645    srsCfg->srs_ResourceSetToAddModList = NULLP;
5646    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
5647          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5648    if(!srsCfg->srs_ResourceSetToAddModList)
5649    {
5650       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5651       return RFAILED;
5652    }
5653    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
5654    {
5655       return RFAILED;
5656    }
5657
5658    srsCfg->srs_ResourceToReleaseList = NULLP;
5659
5660    /* Resource to Add/Modify list */
5661    srsCfg->srs_ResourceToAddModList = NULLP;
5662    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
5663          sizeof(struct SRS_Config__srs_ResourceToAddModList));
5664    if(!srsCfg->srs_ResourceToAddModList)
5665    {
5666       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
5667       return RFAILED;
5668    }
5669
5670    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
5671    {
5672       return RFAILED;
5673    }
5674    srsCfg->tpc_Accumulation = NULLP;
5675
5676    return ROK;
5677 }
5678
5679
5680
5681 /*******************************************************************
5682  *
5683  * @brief Builds Pusch Serving cell Config
5684  *
5685  * @details
5686  *
5687  *    Function : BuildPuschSrvCellCfg
5688  *
5689  *    Functionality: Builds Pusch Serving cell Config
5690  *
5691  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
5692  *
5693  * @return ROK     - success
5694  *         RFAILED - failure
5695  *
5696  * ****************************************************************/
5697 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
5698 {
5699    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
5700    puschCfg->choice.setup = NULLP;
5701    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5702    if(!puschCfg->choice.setup)
5703    {
5704       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5705       return RFAILED;
5706    }
5707
5708    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5709    puschCfg->choice.setup->rateMatching = NULLP;
5710    puschCfg->choice.setup->xOverhead = NULLP;
5711    puschCfg->choice.setup->ext1 = NULLP;
5712
5713    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
5714    if(!puschCfg->choice.setup->ext1)
5715    {
5716       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5717       return RFAILED;
5718    }
5719
5720    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
5721    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5722    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
5723    {
5724       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5725       return RFAILED;
5726    }
5727    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5728
5729    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5730    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5731    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5732    {
5733       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5734       return RFAILED;
5735    }
5736    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5737
5738    return ROK;
5739 }
5740
5741 /*******************************************************************
5742  *
5743  * @brief Builds inital UL BWP
5744  *
5745  * @details
5746  *
5747  *    Function : BuildInitialUlBWP
5748  *
5749  *    Functionality: Builds initial UL BWP
5750  *
5751  * @params[in] BWP_UplinkDedicated_t *ulBwp
5752  * @return ROK     - success
5753  *         RFAILED - failure
5754  *
5755  * ****************************************************************/
5756 uint8_t BuildInitialUlBWP(InitialUlBwp *initUlBwp, BWP_UplinkDedicated_t *ulBwp)
5757 {
5758    PucchCfg *pucchCfg = NULLP;
5759    PuschCfg *puschCfg = NULLP;
5760
5761    if(initUlBwp)
5762    {
5763       if(initUlBwp->pucchPresent)
5764          pucchCfg = &initUlBwp->pucchCfg;
5765       if(initUlBwp->puschPresent)
5766          puschCfg = &initUlBwp->puschCfg;
5767    }
5768
5769    ulBwp->pucch_Config = NULLP;
5770    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5771    if(!ulBwp->pucch_Config)
5772    {
5773       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5774       return RFAILED;
5775    }
5776
5777    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
5778    ulBwp->pucch_Config->choice.setup = NULLP;
5779    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5780    if(!ulBwp->pucch_Config->choice.setup)
5781    {
5782       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5783       return RFAILED;
5784    }
5785
5786    if(BuildBWPUlDedPucchCfg(pucchCfg, ulBwp->pucch_Config->choice.setup) != ROK)
5787    {
5788       return RFAILED;
5789    }
5790
5791    /* Fill BWP UL dedicated PUSCH config */
5792    ulBwp->pusch_Config = NULLP;
5793    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5794    if(!ulBwp->pusch_Config)
5795    {
5796       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5797       return RFAILED;
5798    }
5799
5800    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
5801    ulBwp->pusch_Config->choice.setup = NULLP;
5802    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5803    if(!ulBwp->pusch_Config->choice.setup)
5804    {
5805       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5806       return RFAILED;
5807    }
5808
5809    if(BuildBWPUlDedPuschCfg(puschCfg, ulBwp->pusch_Config->choice.setup) != ROK)
5810    {
5811       return RFAILED;
5812    }
5813
5814    ulBwp->configuredGrantConfig = NULLP;
5815
5816    /* Fill BPW UL dedicated SRS config */
5817    ulBwp->srs_Config = NULLP;
5818    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5819    if(!ulBwp->srs_Config)
5820    {
5821       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5822       return RFAILED;
5823    }
5824
5825    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
5826    ulBwp->srs_Config->choice.setup = NULLP;
5827    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5828    if(!ulBwp->srs_Config->choice.setup)
5829    {
5830       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5831       return RFAILED;
5832    }
5833
5834    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
5835    {
5836       return RFAILED;
5837    }
5838
5839    ulBwp->beamFailureRecoveryConfig = NULLP;
5840
5841    return ROK;
5842 }
5843
5844 /*******************************************************************
5845  *
5846  * @brief Builds UL config
5847  * @details
5848  *
5849  *    Function : BuildUlCfg
5850  *
5851  *    Functionality: Builds UL config in spCellCfgDed
5852  *
5853  * @params[in] UplinkConfig_t *ulCfg
5854  *
5855  * @return ROK     - success
5856  *         RFAILED - failure
5857  *
5858  * ****************************************************************/
5859 uint8_t BuildUlCfg(ServCellRecfgInfo *servCellRecfg, UplinkConfig_t *ulCfg)
5860 {
5861    InitialUlBwp *initUlBwp = NULLP;
5862
5863    if(servCellRecfg)
5864    {
5865       initUlBwp = &servCellRecfg->initUlBwp;
5866    }
5867
5868    ulCfg->initialUplinkBWP = NULLP;
5869    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5870    if(!ulCfg->initialUplinkBWP)
5871    {
5872       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5873       return RFAILED;
5874    }
5875
5876    if(BuildInitialUlBWP(initUlBwp, ulCfg->initialUplinkBWP) != ROK)
5877    {
5878       return RFAILED;
5879    }
5880
5881    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5882    ulCfg->uplinkBWP_ToAddModList = NULLP;
5883    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5884    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5885    if(!ulCfg->firstActiveUplinkBWP_Id)
5886    {
5887       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5888       return RFAILED;
5889    }
5890    if(servCellRecfg == NULLP)
5891       *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5892    else
5893       *(ulCfg->firstActiveUplinkBWP_Id) = servCellRecfg->firstActvUlBwpId;
5894
5895    ulCfg->pusch_ServingCellConfig = NULLP;
5896    DU_ALLOC(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5897    if(!ulCfg->pusch_ServingCellConfig)
5898    {
5899       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5900       return RFAILED;
5901    }
5902
5903    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5904    {
5905       return RFAILED;
5906    }
5907
5908    ulCfg->carrierSwitching = NULLP;
5909    ulCfg->ext1 = NULLP;
5910    return ROK;
5911 }
5912
5913 /*******************************************************************
5914  *
5915  * @brief Builds PDSCH serving cell config
5916  * @details
5917  *
5918  *    Function : BuildPdschSrvCellCfg
5919  *
5920  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5921  *
5922  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5923  *
5924  * @return ROK     - success
5925  *         RFAILED - failure
5926  *
5927  * ****************************************************************/
5928 uint8_t BuildPdschSrvCellCfg(PdschServCellCfg *pdschServCellDb, struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5929 {
5930    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5931    pdschCfg->choice.setup = NULLP;
5932    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5933    if(!pdschCfg->choice.setup)
5934    {
5935       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5936       return RFAILED;
5937    }
5938
5939    /* Code Block Group Transmission */
5940    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5941    if(pdschServCellDb && (pdschServCellDb->maxCodeBlkGrpPerTb || pdschServCellDb->codeBlkGrpFlushInd))
5942    {
5943       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission, sizeof(struct PDSCH_ServingCellConfig__codeBlockGroupTransmission));
5944       if(pdschCfg->choice.setup->codeBlockGroupTransmission == NULLP)
5945       {
5946          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5947          return RFAILED;
5948       }
5949
5950       pdschCfg->choice.setup->codeBlockGroupTransmission->present = PDSCH_ServingCellConfig__codeBlockGroupTransmission_PR_setup;
5951       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup = NULLP;
5952       DU_ALLOC(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup, sizeof(struct PDSCH_CodeBlockGroupTransmission ));
5953       if(pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup == NULLP)
5954       {
5955          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5956          return RFAILED;
5957       }
5958
5959       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock = \
5960          *(pdschServCellDb->maxCodeBlkGrpPerTb);
5961       pdschCfg->choice.setup->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator = \
5962          *(pdschServCellDb->codeBlkGrpFlushInd);
5963    }
5964
5965    /* xOverhead */
5966    pdschCfg->choice.setup->xOverhead = NULLP;
5967    if(pdschServCellDb && pdschServCellDb->xOverhead)
5968    {
5969       DU_ALLOC(pdschCfg->choice.setup->xOverhead, sizeof(long));
5970       if(pdschCfg->choice.setup->xOverhead == NULLP)
5971       {
5972          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5973          return RFAILED;
5974       }
5975       *(pdschCfg->choice.setup->xOverhead) = *(pdschServCellDb->xOverhead);
5976    }
5977
5978    /* Number of HARQ processes */
5979    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5980    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5981    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5982    {
5983       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5984       return RFAILED;
5985    }
5986
5987    if(pdschServCellDb == NULLP)
5988    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = PDSCH_NUM_HARQ_PROC;
5989    else
5990    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH) = pdschServCellDb->numHarqProcForPdsch;
5991
5992    pdschCfg->choice.setup->pucch_Cell = NULLP;
5993
5994    /* Extension */
5995    pdschCfg->choice.setup->ext1 = NULLP;
5996    if(pdschServCellDb && pdschServCellDb->maxMimoLayers)
5997    {
5998       DU_ALLOC(pdschCfg->choice.setup->ext1, sizeof(struct PDSCH_ServingCellConfig__ext1));
5999       if(pdschCfg->choice.setup->ext1 == NULLP)
6000       {
6001          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6002          return RFAILED;
6003       }
6004
6005       DU_ALLOC(pdschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
6006       if(pdschCfg->choice.setup->ext1->maxMIMO_Layers == NULLP)
6007       {
6008          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
6009          return RFAILED;
6010       }
6011       *(pdschCfg->choice.setup->ext1->maxMIMO_Layers) = *(pdschServCellDb->maxMimoLayers);
6012    }
6013
6014    return ROK;
6015 }
6016
6017 /*******************************************************************
6018  *
6019  * @brief Builds CSI Meas config
6020  * @details
6021  *
6022  *    Function : BuildCsiMeasCfg
6023  *
6024  *    Functionality: Builds CSI Meas config in spCellCfgDed
6025  *
6026  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
6027  *
6028  * @return ROK     - success
6029  *         RFAILED - failure
6030  *
6031  * ****************************************************************/
6032 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
6033 {
6034
6035    return ROK;
6036 }
6037
6038 /*******************************************************************
6039  *
6040  * @brief Builds DL BWP to add/modify list
6041  * @details
6042  *
6043  *    Function : BuildDlBwpToAddModList
6044  *
6045  *    Functionality: Builds DL BWP to add/modify list
6046  *
6047  * @params[in] ServCellRecfgInfo *servCellRecfg,
6048  *             struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList
6049  *
6050  * @return ROK     - success
6051  *         RFAILED - failure
6052  *
6053  * ****************************************************************/
6054 uint8_t BuildDlBwpToAddModList(ServCellRecfgInfo *servCellRecfg, struct ServingCellConfig__downlinkBWP_ToAddModList *dlBwpAddModList)
6055 {
6056    uint8_t elementCnt, idx;
6057
6058    elementCnt = servCellRecfg->numDlBwpToAddOrMod;
6059    dlBwpAddModList->list.count = elementCnt;
6060    dlBwpAddModList->list.size = elementCnt * sizeof(struct BWP_Downlink *);
6061    dlBwpAddModList->list.array = NULLP;
6062    DU_ALLOC(dlBwpAddModList->list.array, dlBwpAddModList->list.size);
6063    if(dlBwpAddModList->list.array == NULLP)
6064    {
6065       DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6066       return RFAILED;
6067    }
6068
6069    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6070    {
6071       DU_ALLOC(dlBwpAddModList->list.array[idx], sizeof(BWP_Downlink_t));
6072       if(dlBwpAddModList->list.array[idx] == NULLP)
6073       {
6074          DU_LOG("\nERROR  --> DU APP: Memory allocation failure in BuildDlBwpToAddModList");
6075          return RFAILED;
6076       }
6077    }
6078
6079    for(idx=0; idx<dlBwpAddModList->list.count; idx++)
6080    {
6081       dlBwpAddModList->list.array[idx]->bwp_Id = servCellRecfg->dlBwpToAddOrModList[idx].bwpId;
6082       dlBwpAddModList->list.array[idx]->bwp_Common = NULLP;
6083       dlBwpAddModList->list.array[idx]->bwp_Dedicated = NULLP;
6084    }
6085    return ROK;
6086 }
6087
6088 /*******************************************************************
6089  *
6090  * @brief Builds Spcell config dedicated
6091  * @details
6092  *
6093  *    Function : BuildSpCellCfgDed
6094  *
6095  *    Functionality: Builds sp cell config dedicated in spCellCfg
6096  *
6097  * @params[in] ServingCellConfig_t srvCellCfg
6098  *
6099  * @return ROK     - success
6100  *         RFAILED - failure
6101  *
6102  * ****************************************************************/
6103 uint8_t BuildSpCellCfgDed(DuUeCb *ueCb, ServingCellConfig_t *srvCellCfg)
6104 {
6105    ServCellRecfgInfo *servCellRecfg = NULLP;
6106    InitialDlBwp *initDlBwp = NULLP;
6107    PdschServCellCfg *pdschServCellDb = NULLP;
6108
6109    if(ueCb)
6110    {
6111       servCellRecfg = &ueCb->duMacUeCfg.spCellCfg.servCellCfg;
6112       initDlBwp = &servCellRecfg->initDlBwp;
6113       pdschServCellDb = &servCellRecfg->pdschServCellCfg;
6114    }
6115
6116    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
6117
6118    srvCellCfg->initialDownlinkBWP = NULLP;
6119    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6120    if(!srvCellCfg->initialDownlinkBWP)
6121    {
6122       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6123       return RFAILED;
6124    }
6125
6126    if(BuildInitialDlBWP(initDlBwp, srvCellCfg->initialDownlinkBWP) != ROK)
6127    {
6128       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6129       return RFAILED;
6130    }
6131
6132    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
6133
6134    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
6135    if(ueCb && ueCb->duMacUeCfg.spCellCfg.servCellCfg.numDlBwpToAddOrMod)
6136    {
6137       DU_ALLOC(srvCellCfg->downlinkBWP_ToAddModList, sizeof(struct ServingCellConfig__downlinkBWP_ToAddModList));
6138       if(srvCellCfg->downlinkBWP_ToAddModList == NULLP)
6139       {
6140          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6141          return RFAILED;
6142       }
6143
6144       if(BuildDlBwpToAddModList(&ueCb->duMacUeCfg.spCellCfg.servCellCfg, srvCellCfg->downlinkBWP_ToAddModList) != ROK)
6145       {
6146          DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
6147          return RFAILED;
6148       }
6149    }
6150
6151    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
6152    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6153    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
6154    {
6155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6156       return RFAILED;
6157    }
6158    if(ueCb == NULLP)
6159       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6160    else
6161       *(srvCellCfg->firstActiveDownlinkBWP_Id) = ueCb->duMacUeCfg.spCellCfg.servCellCfg.firstActvDlBwpId;
6162
6163    srvCellCfg->bwp_InactivityTimer = NULLP;
6164
6165    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
6166    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6167    if(!srvCellCfg->defaultDownlinkBWP_Id)
6168    {
6169       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6170       return RFAILED;
6171    }
6172    if(ueCb == NULLP)
6173       *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
6174    else
6175       *(srvCellCfg->defaultDownlinkBWP_Id) = ueCb->duMacUeCfg.spCellCfg.servCellCfg.defaultDlBwpId;
6176
6177    srvCellCfg->uplinkConfig = NULLP;
6178    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6179    if(!srvCellCfg->uplinkConfig)
6180    {
6181       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6182       return RFAILED;
6183    }
6184
6185    if(BuildUlCfg(servCellRecfg, srvCellCfg->uplinkConfig) != ROK)
6186    {
6187       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
6188       return RFAILED;
6189    }
6190    srvCellCfg->supplementaryUplink = NULLP;
6191    srvCellCfg->pdcch_ServingCellConfig = NULLP;
6192
6193    srvCellCfg->pdsch_ServingCellConfig = NULLP;
6194    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
6195    if(!srvCellCfg->pdsch_ServingCellConfig)
6196    {
6197       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6198       return RFAILED;
6199    }
6200
6201    if(BuildPdschSrvCellCfg(pdschServCellDb, srvCellCfg->pdsch_ServingCellConfig) != ROK)
6202    {
6203       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
6204       return RFAILED;
6205    }
6206
6207    srvCellCfg->csi_MeasConfig = NULLP;
6208 #if 0
6209    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
6210       if(!srvCellCfg->csi_MeasConfig)
6211       {
6212          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
6213          return RFAILED;
6214       }
6215
6216    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
6217    {
6218       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
6219       return RFAILED;
6220    }
6221 #endif
6222    srvCellCfg->sCellDeactivationTimer = NULLP;
6223    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
6224    srvCellCfg->tag_Id = TAG_ID;
6225    srvCellCfg->dummy = NULLP;
6226    srvCellCfg->pathlossReferenceLinking = NULLP;
6227    srvCellCfg->servingCellMO = NULLP;
6228    srvCellCfg->ext1 = NULLP;
6229
6230    return ROK;
6231 }
6232
6233 /*******************************************************************
6234  *
6235  * @brief Fills SCS specific carrier list in DL frequency info
6236  *
6237  * @details
6238  *
6239  *    Function : BuildScsSpecificCarrierListDl
6240  *
6241  *    Functionality: Fills SCS specific carrier list in DL frequency info
6242  *
6243  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
6244  *
6245  * @return ROK     - success
6246  *         RFAILED - failure
6247  *
6248  * ****************************************************************/
6249 uint8_t BuildScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
6250 {
6251    uint8_t elementCnt = 0, listIdx = 0;
6252    ScsSpecCarrier duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.dlScsCarrier;
6253
6254    elementCnt = ODU_VALUE_ONE;
6255    scsCarrierList->list.count = elementCnt;
6256    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6257
6258    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6259    if(!scsCarrierList->list.array)
6260    {
6261       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for scs carrier list array \
6262          in BuildScsSpecificCarrierListDl()");
6263       return RFAILED;
6264    }
6265
6266    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6267    {
6268       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6269       if(!scsCarrierList->list.array[listIdx])
6270       {
6271          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SCS Specific Carrier list array \
6272             element in BuildScsSpecificCarrierListDl()");
6273          return RFAILED;
6274       }
6275    }
6276
6277    listIdx = 0;
6278    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6279    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6280    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6281
6282    return ROK;
6283 }
6284
6285 /*******************************************************************
6286  *
6287  * @brief Fills DL frequency info in DL config common
6288  *
6289  * @details
6290  *
6291  *    Function : BuildFreqInfoDl
6292  *
6293  *    Functionality: Fills DL frequency info in DL config common
6294  *
6295  * @params[in] Pointer to DownlinkConfigCommon_t
6296  *
6297  * @return ROK     - success
6298  *         RFAILED - failure
6299  *
6300  * ****************************************************************/
6301 uint8_t BuildFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
6302 {
6303    uint8_t freqBandIdx = 0, elementCnt = 0;
6304    DlCfgCommon  dlCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg;
6305
6306    /* TODO : Fill SSB Absolute Frequency */
6307    /*
6308       DU_ALLOC(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
6309       if(!frequencyInfoDL->absoluteFrequencySSB)
6310       {
6311       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB Absolute Frequency in BuildFreqInfoDl()");
6312       return RFAILED;
6313       }
6314       frequencyInfoDL->absoluteFrequencySSB = ?;
6315       */
6316
6317    /* NR Multi Frequency Band List */
6318    elementCnt = ODU_VALUE_ONE;
6319    frequencyInfoDL->frequencyBandList.list.count = elementCnt;
6320    frequencyInfoDL->frequencyBandList.list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6321
6322    DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
6323    if(!frequencyInfoDL->frequencyBandList.list.array)
6324    {
6325       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for Frequency Band List array in BuildFreqInfoDl()");
6326       return RFAILED;
6327    }
6328
6329    for(freqBandIdx = 0; freqBandIdx < elementCnt; freqBandIdx++)
6330    {
6331       DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
6332       if(!frequencyInfoDL->frequencyBandList.list.array[freqBandIdx])
6333       {
6334          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoDl()");
6335          return RFAILED;
6336       }
6337    }
6338
6339    freqBandIdx = 0;
6340    *(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx]) = dlCfg.freqBandInd;
6341
6342    /* TODO : Absolute Frequency to Point A */
6343    //frequencyInfoDL->absoluteFrequencyPointA
6344
6345    /* Subcarrier Spacing specifc carrier List */
6346    if((BuildScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList)) != ROK)
6347    {
6348       DU_LOG("\nERROR  -->  DU APP : Failed to fill SCS specific carrier list DL in BuildFreqInfoDl()");
6349       return RFAILED;
6350    }
6351
6352    return ROK;
6353
6354 }
6355
6356 /*******************************************************************
6357  *
6358  * @brief Fills DL config common in Serving cell config common
6359  *
6360  * @details
6361  *
6362  *    Function : BuildDlConfigCommon
6363  *
6364  *    Functionality: Fills DL config common in Serving cell config common
6365  *
6366  * @params[in] Pointer to DownlinkConfigCommon_t
6367  *
6368  * @return ROK     - success
6369  *         RFAILED - failure
6370  *
6371  * ****************************************************************/
6372 uint8_t BuildDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
6373 {
6374    /* DL Frequency Info */
6375    DU_ALLOC(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
6376    if(!dlCfgCommon->frequencyInfoDL)
6377    {
6378       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL frequency info in BuildDlConfigCommon()");
6379       return RFAILED;
6380    }
6381    if((BuildFreqInfoDl(dlCfgCommon->frequencyInfoDL))!= ROK)
6382    {
6383       DU_LOG("\nERROR  --> DU APP : Failed to fill DL frequency info in BuildDlConfigCommon()");
6384       return RFAILED;
6385    }
6386
6387    /* DL BWP config common */
6388    DU_ALLOC(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
6389    if(!dlCfgCommon->initialDownlinkBWP)
6390    {
6391       DU_LOG("\nERROR  --> DU APP : Memory allocation failed for DL BWP config common in BuildDlConfigCommon()");
6392       return RFAILED;
6393    }
6394    if((BuildBwpDlCommon(dlCfgCommon->initialDownlinkBWP)) != ROK)
6395    {
6396       DU_LOG("\nERROR  --> DU APP : Failed to fill DL DWP config common in BuildDlConfigCommon()");
6397       return RFAILED;
6398    }
6399
6400    return ROK;
6401 }
6402
6403 /*******************************************************************
6404  *
6405  * @brief Fills SCS specific carrier list in UL frequency Info
6406  *
6407  * @details
6408  *
6409  *    Function : BuildScsSpecificCarrierListUl
6410  *
6411  *    Functionality: Fills SCS specific carrier list in UL frequency Info
6412  *
6413  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
6414  *
6415  * @return ROK     - success
6416  *         RFAILED - failure
6417  *
6418  * ****************************************************************/
6419 uint8_t BuildScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
6420 {
6421    uint8_t elementCnt = 0, listIdx = 0;
6422    ScsSpecCarrier   duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.ulScsCarrier;
6423
6424    elementCnt = ODU_VALUE_ONE;
6425    scsCarrierList->list.count = elementCnt;
6426    scsCarrierList->list.size = elementCnt * sizeof(SCS_SpecificCarrier_t *);
6427
6428    DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
6429    if(!scsCarrierList->list.array)
6430    {
6431       DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6432       return RFAILED;
6433    }
6434
6435    for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
6436    {
6437       DU_ALLOC(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
6438       if(!scsCarrierList->list.array[listIdx])
6439       {
6440          DU_LOG("\nERROR  -->  DU APP : SCS Specific Carrier list memory allocation failed");
6441          return RFAILED;
6442       }
6443    }
6444    listIdx = 0;
6445    scsCarrierList->list.array[listIdx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
6446    scsCarrierList->list.array[listIdx]->subcarrierSpacing = duScsSpecCarrier.scs;
6447    scsCarrierList->list.array[listIdx]->carrierBandwidth = duScsSpecCarrier.scsBw;
6448
6449    return ROK;
6450 }
6451
6452 /*******************************************************************
6453  *
6454  * @brief Fills frequency info in UL config common
6455  *
6456  * @details
6457  *
6458  *    Function : BuildFreqInfoUl
6459  *
6460  *    Functionality: Fills frequency info in UL config common
6461  *
6462  * @params[in] Pointer to FrequencyInfoUL_t
6463  *
6464  * @return ROK     - success
6465  *         RFAILED - failure
6466  *
6467  * ****************************************************************/
6468 uint8_t BuildFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
6469 {
6470    uint8_t elementCnt = 0, listIdx= 0;
6471    UlCfgCommon  ulCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg;
6472
6473    /* NR Multi Frequency Band List */
6474    DU_ALLOC(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
6475    if(!frequencyInfoUL->frequencyBandList)
6476    {
6477       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band list in BuildFreqInfoUl()");
6478       return RFAILED;
6479    }
6480
6481    elementCnt = ODU_VALUE_ONE;
6482    frequencyInfoUL->frequencyBandList->list.count = elementCnt;
6483    frequencyInfoUL->frequencyBandList->list.size = elementCnt * sizeof(FreqBandIndicatorNR_t *);
6484
6485    DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
6486    if(!frequencyInfoUL->frequencyBandList->list.array)
6487    {
6488       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array in BuildFreqInfoUl()");
6489       return RFAILED;
6490    }
6491
6492    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6493    {
6494       DU_ALLOC(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
6495       if(!frequencyInfoUL->frequencyBandList->list.array[listIdx])
6496       {
6497          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for frequency band array element in BuildFreqInfoUl()");
6498          return RFAILED;
6499       }
6500    }
6501
6502    listIdx = 0;
6503    *(frequencyInfoUL->frequencyBandList->list.array[listIdx]) = ulCfg.freqBandInd;
6504
6505    /* TODO : Fill Absolute frequency point A */
6506    /*
6507       DU_ALLOC(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
6508       if(!frequencyInfoUL->absoluteFrequencyPointA)
6509       {
6510       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for absolute frequency point A in BuildFreqInfoUl()");
6511       return RFAILED;
6512       }
6513     *(frequencyInfoUL->absoluteFrequencyPointA) = ?;
6514     */
6515
6516    /* Subcarrier Spacing specifc carrier */
6517    if((BuildScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList)) != ROK)
6518    {
6519       DU_LOG("\nERROR  --> DU APP : Failed to fill SCS Specific Carrier list UL in BuildFreqInfoUl()");
6520       return RFAILED;
6521    }
6522
6523    /* P-MAX */
6524    DU_ALLOC(frequencyInfoUL->p_Max, sizeof(P_Max_t));
6525    if(!frequencyInfoUL->p_Max)
6526    {
6527       DU_LOG("\nERROR  -->  DU APP : UL Frequency Infoo  memory allocation failure");
6528       return RFAILED;
6529    }
6530    *frequencyInfoUL->p_Max = ulCfg.pMax;
6531
6532    return ROK;
6533 }
6534
6535 /*******************************************************************
6536  *
6537  * @brief Fills UL config common in Serving cell config common
6538  *
6539  * @details
6540  *
6541  *    Function : BuildUlConfigCommon
6542  *
6543  *    Functionality: Fills UL config common in Serving cell config common
6544  *
6545  * @params[in] Pointer to UplinkConfigCommon_t
6546  *
6547  * @return ROK     - success
6548  *         RFAILED - failure
6549  *
6550  * ****************************************************************/
6551 uint8_t BuildUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
6552 {
6553    /* UL Frequency Info */
6554    DU_ALLOC(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
6555    if(!ulCfgCommon->frequencyInfoUL)
6556    {
6557       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for UL frequency info in BuildUlConfigCommon()");
6558       return RFAILED;
6559    }
6560
6561    if((BuildFreqInfoUl(ulCfgCommon->frequencyInfoUL)) != ROK)
6562    {
6563       DU_LOG("\nERROR  -->  DU APP : Failed to fill frequency info UL in BuildUlConfigCommon()");
6564       return RFAILED;
6565    }
6566
6567    /* UL BWP common */
6568    DU_ALLOC(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
6569    if(!ulCfgCommon->initialUplinkBWP)
6570    {
6571       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for initial UL BWP in BuildUlConfigCommon()");
6572       return RFAILED;
6573    }
6574
6575    if((BuildBwpUlCommon(ulCfgCommon->initialUplinkBWP)) != ROK)
6576    {
6577       DU_LOG("\nERROR  -->  DU APP : Failed to fill BWP UL common in BuildUlConfigCommon()");
6578       return RFAILED;
6579    }
6580
6581    /* Time Alignment timer */
6582    ulCfgCommon->dummy = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.timeAlignTimerComm;
6583
6584    return ROK;
6585 }
6586
6587 /*******************************************************************
6588  *
6589  * @brief Fills SSB position in burst in SP cell config common
6590  *
6591  * @details
6592  *
6593  *    Function : BuildSsbPosInBurst
6594  *
6595  *    Functionality:
6596  *       Fills SSB position in burst in SP cell config common
6597  *
6598  * @params[in] Pointer to struct ServingCellConfigCommon__ssb_PositionsInBurst
6599  *
6600  * @return ROK     - success
6601  *         RFAILED - failure
6602  *
6603  * ****************************************************************/
6604 uint8_t BuildSsbPosInBurst(struct ServingCellConfigCommon__ssb_PositionsInBurst *ssbPosInBurst)
6605 {
6606    uint8_t bitStringSizeInBytes = 0;
6607
6608    ssbPosInBurst->present = ServingCellConfigCommon__ssb_PositionsInBurst_PR_mediumBitmap;
6609
6610    /* As per spec 38.331,in the definition of ServingCellConfigCommon */
6611    bitStringSizeInBytes = 1;
6612    ssbPosInBurst->choice.mediumBitmap.size = bitStringSizeInBytes * sizeof(uint8_t);
6613
6614    DU_ALLOC(ssbPosInBurst->choice.mediumBitmap.buf, ssbPosInBurst->choice.mediumBitmap.size);
6615    if(!ssbPosInBurst->choice.mediumBitmap.buf)
6616    {
6617       DU_LOG("\nERROR  -->  DU APP : Memory Allocation failed for medium bit map buffer in BuildSsbPosInBurst()");
6618       return RFAILED;
6619    }
6620
6621    if((fillBitString(&ssbPosInBurst->choice.mediumBitmap, 0, bitStringSizeInBytes, \
6622                duCfgParam.sib1Params.srvCellCfgCommSib.ssbPosInBurst)) != ROK)
6623    {
6624       DU_LOG("\nERROR  -->  DU APP : Failed to fill medium bit map in BuildSsbPosInBurst()");
6625       return RFAILED;
6626    }
6627
6628    return ROK;
6629 }
6630
6631 /*******************************************************************
6632  *
6633  * @brief Fills SP cell config common in Reconfig with Sync
6634  *
6635  * @details
6636  *
6637  *    Function : BuildSpCellConfigCommon
6638  *
6639  *    Functionality: Fills SP cell config common in Reconfig with Sync
6640  *
6641  * @params[in] Pointer to ServingCellConfigCommon_t
6642  *
6643  * @return ROK     - success
6644  *         RFAILED - failure
6645  *
6646  * ****************************************************************/
6647 uint8_t BuildSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
6648 {
6649    /* Physical Cell Identity */
6650    DU_ALLOC(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
6651    if(!spCellConfigCommon->physCellId)
6652    {
6653       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for physical cell id in BuildSpCellConfigCommon()");
6654       return RFAILED;
6655    }
6656    *(spCellConfigCommon->physCellId) = NR_PCI;
6657
6658    /* Downlink Config Common */
6659    DU_ALLOC(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
6660    if(!spCellConfigCommon->downlinkConfigCommon)
6661    {
6662       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for DL Config Common in BuildSpCellConfigCommon()");
6663       return RFAILED;
6664    }
6665    if((BuildDlConfigCommon(spCellConfigCommon->downlinkConfigCommon)) != ROK)
6666    {
6667       DU_LOG("\nERROR  -->  DU APP : Failed to fill DL config commin in BuildSpCellConfigCommon()");
6668       return RFAILED;
6669    }
6670
6671    /* Uplinlink Config Common */
6672    DU_ALLOC(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
6673    if(!spCellConfigCommon->uplinkConfigCommon)
6674    {
6675       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for UL Config Common in BuildSpCellConfigCommon()");
6676       return RFAILED;
6677    }
6678    if((BuildUlConfigCommon(spCellConfigCommon->uplinkConfigCommon)) != ROK)
6679    {
6680       DU_LOG("\nERROR  -->  DU APP : Failed to fill UL config commin in BuildSpCellConfigCommon()");
6681       return RFAILED;
6682    }
6683
6684    /* Timing Advance offset */
6685    DU_ALLOC(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
6686    if(!spCellConfigCommon->n_TimingAdvanceOffset)
6687    {
6688       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for Timing Advance Offset in BuildSpCellConfigCommon()");
6689       return RFAILED;
6690    }
6691    *(spCellConfigCommon->n_TimingAdvanceOffset) = ServingCellConfigCommon__n_TimingAdvanceOffset_n0;
6692
6693    /* SSB Position In Burst */
6694    DU_ALLOC(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
6695    if(!spCellConfigCommon->ssb_PositionsInBurst)
6696    {
6697       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Position In Burst in BuildSpCellConfigCommon()");
6698       return RFAILED;
6699    }
6700    if((BuildSsbPosInBurst(spCellConfigCommon->ssb_PositionsInBurst)) != ROK)
6701    {
6702       DU_LOG("\nERROR  -->  DU APP : Failed to fill SSB Position In Burst in BuildSpCellConfigCommon()");
6703       return RFAILED;
6704    }
6705
6706    /* SSB Periodicity in Serving cell */
6707    DU_ALLOC(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
6708    if(!spCellConfigCommon->ssb_periodicityServingCell)
6709    {
6710       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for SSB Periodicity serving cell in \
6711          BuildSpCellConfigCommon()");
6712       return RFAILED;
6713    }
6714    *(spCellConfigCommon->ssb_periodicityServingCell) = \
6715       convertSsbPeriodicityValueToEnum(duCfgParam.sib1Params.srvCellCfgCommSib.ssbPrdServingCell);
6716
6717    /* DMRS Type A position */
6718    spCellConfigCommon->dmrs_TypeA_Position = convertDmrsTypeAPosValueToEnum(duCfgParam.macCellCfg.dmrsTypeAPos);
6719
6720    /* SSB subcarrier spacing */
6721    DU_ALLOC(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
6722    if(!spCellConfigCommon->ssbSubcarrierSpacing)
6723    {
6724       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for sub-carrier spacing in BuildSpCellConfigCommon()");
6725       return RFAILED;
6726    }
6727    *(spCellConfigCommon->ssbSubcarrierSpacing) = duCfgParam.sib1Params.srvCellCfgCommSib.scs;
6728
6729    /* TDD UL-DL configuration common */
6730    DU_ALLOC(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
6731    if(!spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)
6732    {
6733       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for TDD UL-DL config common in BuildSpCellConfigCommon()");
6734       return RFAILED;
6735    }
6736    if((BuildTddUlDlCfgComm(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon)) != ROK)
6737    {
6738       DU_LOG("\nERROR  -->  DU APP : Failed to fill TDD UL-DL config common in BuildSpCellConfigCommon()");
6739       return RFAILED;
6740    }
6741
6742    /* SS PBCH Block Power */
6743    spCellConfigCommon->ss_PBCH_BlockPower = duCfgParam.sib1Params.srvCellCfgCommSib.ssPbchBlockPwr;
6744
6745    return ROK;
6746 }
6747
6748 /*******************************************************************
6749  *
6750  * @brief Fills dedicated RACH configuration in Reconfiguration with sync
6751  *
6752  * @details
6753  *
6754  *    Function : BuildRecfgWithSync
6755  *
6756  *    Functionality:
6757  *       Fills dedicated RACH configuration in Reconfiguration with sync
6758  *
6759  * @params[in] DU UE CB
6760  *             Pointer to Rach config dedicated struct
6761  *
6762  * @return ROK     - success
6763  *         RFAILED - failure
6764  *
6765  * ****************************************************************/
6766 uint8_t BuildRachConfigDedicated(DuUeCb *ueCb, struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
6767 {
6768    uint8_t elementCnt = 0, listIdx = 0;
6769    CFRA_t *cfra = NULLP;
6770    struct CFRA__resources__ssb *ssbResource = NULLP;
6771    RachCfgCommon duRachCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.rachCfg;
6772
6773    rachCfgDed->present = ReconfigurationWithSync__rach_ConfigDedicated_PR_uplink;
6774
6775    /* Uplink */
6776    DU_ALLOC(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
6777    if(!rachCfgDed->choice.uplink)
6778    {
6779       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for RACH uplink configuration in BuildRachConfigDedicated()");
6780       return RFAILED;
6781    }
6782
6783    /* CFRA : Contention free Random Access */
6784    DU_ALLOC(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
6785    if(!rachCfgDed->choice.uplink->cfra)
6786    {
6787       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA in BuildRachConfigDedicated()");
6788       return RFAILED;
6789    }
6790    cfra = rachCfgDed->choice.uplink->cfra;
6791
6792    /* CFRA occassions */
6793    DU_ALLOC(cfra->occasions, sizeof(struct CFRA__occasions));
6794    if(!cfra->occasions)
6795    {
6796       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA occassion in BuildRachConfigDedicated()");
6797       return RFAILED;
6798    }
6799
6800    /* CFRA occassions : RACH generic configuration */
6801    cfra->occasions->rach_ConfigGeneric.prach_ConfigurationIndex = duRachCfg.prachCfgIdx;
6802    cfra->occasions->rach_ConfigGeneric.msg1_FDM = duRachCfg.msg1Fdm;
6803    cfra->occasions->rach_ConfigGeneric.msg1_FrequencyStart = duRachCfg.msg1FreqStart;
6804    cfra->occasions->rach_ConfigGeneric.zeroCorrelationZoneConfig = duRachCfg.zeroCorrZoneCfg;
6805    cfra->occasions->rach_ConfigGeneric.preambleReceivedTargetPower = duRachCfg.preambleRcvdTgtPwr;
6806    cfra->occasions->rach_ConfigGeneric.preambleTransMax = duRachCfg.preambleTransMax;
6807    cfra->occasions->rach_ConfigGeneric.powerRampingStep = duRachCfg.pwrRampingStep;
6808    cfra->occasions->rach_ConfigGeneric.ra_ResponseWindow = duRachCfg.raRspWindow;
6809
6810    /* CFRA occassions : SSB per RACH occasion */
6811    DU_ALLOC(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
6812    if(!cfra->occasions->ssb_perRACH_Occasion)
6813    {
6814       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB per RACH occassion in BuildRachConfigDedicated()");
6815       return RFAILED;
6816    }
6817    *(cfra->occasions->ssb_perRACH_Occasion) = convertCFRASsbPerRachOccasionValueToEnum(duCfgParam.macCellCfg.prachCfg.ssbPerRach);
6818
6819    /* CFRA resource */
6820    cfra->resources.present = CFRA__resources_PR_ssb;
6821
6822    /* CFRA resource : SSB */
6823    DU_ALLOC(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
6824    if(!cfra->resources.choice.ssb)
6825    {
6826       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for CFRA resource - SSB in BuildRachConfigDedicated()");
6827       return RFAILED;
6828    }
6829    ssbResource = cfra->resources.choice.ssb;
6830
6831    /* CFRA SSB resource list */
6832    elementCnt = ueCb->cfraResource.numSsb;
6833    ssbResource->ssb_ResourceList.list.count = elementCnt;
6834    ssbResource->ssb_ResourceList.list.size = elementCnt * sizeof(CFRA_SSB_Resource_t *);
6835
6836    DU_ALLOC(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
6837    if(!ssbResource->ssb_ResourceList.list.array)
6838    {
6839       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list in BuildRachConfigDedicated()");
6840       return RFAILED;
6841    }
6842
6843    for(listIdx = 0; listIdx < elementCnt; listIdx++)
6844    {
6845       DU_ALLOC(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
6846       if(!ssbResource->ssb_ResourceList.list.array[listIdx])
6847       {
6848          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for SSB resource list element in BuildRachConfigDedicated()");
6849          return RFAILED;
6850       }
6851       ssbResource->ssb_ResourceList.list.array[listIdx]->ssb = ueCb->cfraResource.ssbResource[listIdx].ssbIdx;
6852       ssbResource->ssb_ResourceList.list.array[listIdx]->ra_PreambleIndex = ueCb->cfraResource.ssbResource[listIdx].raPreambleIdx;
6853    }
6854
6855    return ROK;
6856 }
6857
6858 /*******************************************************************
6859  *
6860  * @brief Fills reconfiguration with sync in SP cell config
6861  *
6862  * @details
6863  *
6864  *    Function : BuildRecfgWithSync
6865  *
6866  *    Functionality: Fills reconfiguration with sync in SP cell config
6867  *
6868  * @params[in] DU UE CB
6869  *             Pointer to ReconfigurationWithSync_t
6870  *
6871  * @return ROK     - success
6872  *         RFAILED - failure
6873  *
6874  * ****************************************************************/
6875 uint8_t BuildRecfgWithSync(DuUeCb *ueCb, ReconfigurationWithSync_t *recfgWithSync)
6876 {
6877    /* SP Cell Config Common */
6878    DU_ALLOC(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
6879    if(!recfgWithSync->spCellConfigCommon)
6880    {
6881       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for spCellConfigCommon in BuildRecfgWithSync()");
6882       return RFAILED;
6883    }
6884
6885    if((BuildSpCellConfigCommon(recfgWithSync->spCellConfigCommon)) != ROK)
6886    {
6887       DU_LOG("\nERROR  -->  DU APP : Failed to build SpCellConfigCommon in BuildRecfgWithSync()");
6888       return RFAILED;
6889    }
6890
6891    /* New UE Identity */
6892    recfgWithSync->newUE_Identity = ueCb->crnti;
6893
6894    /* T304 timer */
6895    recfgWithSync->t304 = ReconfigurationWithSync__t304_ms1000;
6896
6897    /* RACH configuration dedicated */
6898    DU_ALLOC(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
6899    if(!recfgWithSync->rach_ConfigDedicated)
6900    {
6901       DU_LOG("\nERROR  -->  DU APP : Failed to allocate memory for RACH config dedicated in BuildRecfgWithSync()");
6902       return RFAILED;
6903    }
6904
6905    if((BuildRachConfigDedicated(ueCb, recfgWithSync->rach_ConfigDedicated)) != ROK)
6906    {
6907       DU_LOG("\nERROR  -->  DU APP : Failed to build RACH config dedicated in BuildRecfgWithSync()");
6908       return RFAILED;
6909    }
6910
6911    return ROK;
6912 }
6913
6914 /*******************************************************************
6915  *
6916  * @brief Builds Spcell config
6917  *
6918  * @details
6919  *
6920  *    Function : BuildSpCellCfg
6921  *
6922  *    Functionality: Builds sp cell config in DuToCuRrcContainer
6923  *
6924  * @params[in] SpCellConfig_t spCellCfg
6925  *
6926  * @return ROK     - success
6927  *         RFAILED - failure
6928  *
6929  * ****************************************************************/
6930 uint8_t BuildSpCellCfg(DuUeCb *ueCb, SpCellConfig_t *spCellCfg)
6931 {
6932    spCellCfg->servCellIndex = NULLP;
6933    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
6934    if(!spCellCfg->servCellIndex)
6935    {
6936       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6937       return RFAILED;
6938    }
6939
6940    if(ueCb == NULLP)
6941       *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
6942    else
6943       *(spCellCfg->servCellIndex) = ueCb->duMacUeCfg.spCellCfg.servCellIdx;
6944
6945    spCellCfg->reconfigurationWithSync = NULLP;
6946    if(ueCb && (ueCb->ueState == UE_HANDIN_IN_PROGRESS))
6947    {
6948       DU_ALLOC(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
6949       if(!spCellCfg->reconfigurationWithSync)
6950       {
6951          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6952          return RFAILED;
6953       }
6954
6955       if((BuildRecfgWithSync(ueCb, spCellCfg->reconfigurationWithSync)) != ROK)
6956       {
6957          DU_LOG("\nERROR  -->  F1AP : Building of reconfiguration with sync failed at BuildSpCellCfg");
6958          return RFAILED;
6959       }
6960    }
6961
6962    spCellCfg->rlf_TimersAndConstants = NULLP;
6963    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
6964
6965    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6966    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
6967    {
6968       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6969       return RFAILED;
6970    }
6971    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
6972
6973    spCellCfg->spCellConfigDedicated = NULLP;
6974    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6975    if(!spCellCfg->spCellConfigDedicated)
6976    {
6977       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
6978       return RFAILED;
6979    }
6980    if(BuildSpCellCfgDed(ueCb, spCellCfg->spCellConfigDedicated) != ROK)
6981    {
6982       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
6983       return RFAILED;
6984    }
6985
6986    return ROK;
6987 }
6988
6989 /*******************************************************************
6990  *
6991  * @brief Builds Phy cell group config
6992  *
6993  * @details
6994  *
6995  *    Function : BuildPhyCellGrpCfg
6996  *
6997  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
6998  *
6999  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
7000  *
7001  * @return ROK     - success
7002  *         RFAILED - failure
7003  *
7004  * ****************************************************************/
7005 uint8_t BuildPhyCellGrpCfg(DuUeCb *ueCb, PhysicalCellGroupConfig_t *phyCellGrpCfg)
7006 {
7007    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
7008    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
7009
7010    phyCellGrpCfg->p_NR_FR1 = NULLP;
7011    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
7012    if(!phyCellGrpCfg->p_NR_FR1)
7013    {
7014       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
7015       return RFAILED;
7016    }
7017
7018    if(ueCb == NULLP)
7019    {
7020       *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
7021       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
7022    }
7023    else
7024    {
7025       *(phyCellGrpCfg->p_NR_FR1) = ueCb->duMacUeCfg.phyCellGrpCfg.pNrFr1;
7026       phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = ueCb->duMacUeCfg.phyCellGrpCfg.pdschHarqAckCodebook;
7027    }
7028
7029    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
7030    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
7031    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
7032    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
7033    phyCellGrpCfg->cs_RNTI = NULLP;
7034    phyCellGrpCfg->ext1 = NULLP;
7035    phyCellGrpCfg->ext2 = NULLP;
7036
7037    return ROK;
7038 }
7039 #ifdef NR_DRX
7040 /*******************************************************************
7041  *
7042  * @brief fill long cycle offset value of drx
7043  *
7044  * @details
7045  *
7046  *    Function : fillLongCycleOffsetValFromDuCb
7047  *
7048  *    Functionality: fill long cycle offset value of drx
7049  *
7050  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
7051  * struct DRX_ConfigRrc__drx_LongCycleStartOffset drx_LongCycleStartOffset
7052  *
7053  * @return ROK     - success
7054  *         RFAILED - failure
7055  *
7056  * ****************************************************************/
7057 void fillLongCycleOffsetValFromDuCb(DrxLongCycleStartOffset  drxLongCycleStartOffset,\
7058 struct DRX_ConfigRrc__drx_LongCycleStartOffset *drx_LongCycleStartOffset)
7059 {
7060
7061    drx_LongCycleStartOffset->present = convertLongDrxCycleLengthValueToEnum(drxLongCycleStartOffset.drxLongCycleStartOffsetChoice);
7062    switch(drx_LongCycleStartOffset->present)
7063    {
7064       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
7065          {
7066             drx_LongCycleStartOffset->choice.ms10 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7067             break;
7068          }
7069       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
7070          {
7071             drx_LongCycleStartOffset->choice.ms20 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7072             break;
7073          }
7074       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
7075          {
7076             drx_LongCycleStartOffset->choice.ms32 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7077             break;
7078          }
7079       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
7080          {
7081             drx_LongCycleStartOffset->choice.ms40 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7082             break;
7083          }
7084       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
7085          {
7086             drx_LongCycleStartOffset->choice.ms60 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7087             break;
7088          }
7089       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
7090          {
7091             drx_LongCycleStartOffset->choice.ms64 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7092             break;
7093          }
7094       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
7095          {
7096             drx_LongCycleStartOffset->choice.ms70 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7097             break;
7098          }
7099       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
7100          {
7101             drx_LongCycleStartOffset->choice.ms80 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7102             break;
7103          }
7104       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
7105          {
7106             drx_LongCycleStartOffset->choice.ms128 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7107             break;
7108          }
7109       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
7110          {
7111             drx_LongCycleStartOffset->choice.ms160 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7112             break;
7113          }
7114       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
7115          {
7116             drx_LongCycleStartOffset->choice.ms256 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7117             break;
7118          }
7119       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
7120          {
7121             drx_LongCycleStartOffset->choice.ms320 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7122             break;
7123          }
7124       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
7125          {
7126             drx_LongCycleStartOffset->choice.ms512 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7127             break;
7128          }
7129       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
7130          {
7131             drx_LongCycleStartOffset->choice.ms640 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7132             break;
7133          }
7134       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
7135          {
7136             drx_LongCycleStartOffset->choice.ms1024 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7137             break;
7138          }
7139       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
7140          {
7141             drx_LongCycleStartOffset->choice.ms1280 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7142             break;
7143          }
7144       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
7145          {
7146             drx_LongCycleStartOffset->choice.ms2048 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7147             break;
7148          }
7149       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
7150          {
7151             drx_LongCycleStartOffset->choice.ms2560 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7152             break;
7153          }
7154       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
7155          {
7156             drx_LongCycleStartOffset->choice.ms5120 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7157             break;
7158          }
7159       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
7160          {
7161             drx_LongCycleStartOffset->choice.ms10240 = drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
7162             break;
7163          }
7164       default :
7165          break;
7166    }
7167 }
7168 /*******************************************************************
7169  *
7170  * @brief Builds drx config IE
7171  *
7172  * @details
7173  *
7174  *    Function : BuildDrxConfigRrc
7175  *
7176  *    Functionality: Build drx config in MacCellGrpCfg
7177  *
7178  * @params[in] struct MAC_CellGroupConfig__drx_ConfigRrc
7179  *
7180  * @return ROK     - success
7181  *         RFAILED - failure
7182  *
7183  * ****************************************************************/
7184 uint8_t BuildDrxConfigRrc(DuUeCb *ueCb, struct MAC_CellGroupConfig__drx_ConfigRrc *drxCfg)
7185 {
7186    drxCfg->present = MAC_CellGroupConfig__drx_ConfigRrc_PR_setup;
7187    DU_ALLOC(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
7188    if(!drxCfg->choice.setup)
7189    {
7190       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDrxConfigRrc");
7191       return RFAILED;
7192    }
7193    if(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationTimerValInMs)
7194    {
7195       drxCfg->choice.setup->drx_onDurationTimer.present = DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds;
7196       drxCfg->choice.setup->drx_onDurationTimer.choice.milliSeconds = convertOnDurationTimerMilliSecondsValueToEnum(ueCb->duMacUeCfg.\
7197       macCellGrpCfg.drxCfg.drxOnDurationTimer.onDurationtimerValue.milliSeconds);
7198    }
7199    else
7200    {
7201       drxCfg->choice.setup->drx_onDurationTimer.present = DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds;
7202       drxCfg->choice.setup->drx_onDurationTimer.choice.subMilliSeconds = ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.\
7203       drxOnDurationTimer.onDurationtimerValue.subMilliSeconds;
7204    }
7205    drxCfg->choice.setup->drx_InactivityTimer = convertDrxInactivityTimerValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxInactivityTimer);
7206    drxCfg->choice.setup->drx_HARQ_RTT_TimerDL = ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxHarqRttTimerDl;
7207    drxCfg->choice.setup->drx_HARQ_RTT_TimerUL = ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxHarqRttTimerUl;
7208    drxCfg->choice.setup->drx_RetransmissionTimerDL = convertDrxRetransmissionTimerDlValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.\
7209    drxRetransmissionTimerDl);
7210    drxCfg->choice.setup->drx_RetransmissionTimerUL = convertDrxRetransmissionTimerUlValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.\
7211    drxRetransmissionTimerUl);
7212    drxCfg->choice.setup->drx_SlotOffset = ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxSlotOffset;
7213    fillLongCycleOffsetValFromDuCb(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.drxLongCycleStartOffset, &drxCfg->choice.setup->drx_LongCycleStartOffset);
7214
7215    if(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.shortDrxPres)
7216    {
7217       DU_ALLOC(drxCfg->choice.setup->shortDRX, sizeof(struct DRX_ConfigRrc__shortDRX));
7218       if(drxCfg->choice.setup->shortDRX)
7219       {
7220          drxCfg->choice.setup->shortDRX->drx_ShortCycle = convertShortDrxCycleLengthValueToEnum(ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.\
7221          shortDrx.drxShortCycle);
7222          drxCfg->choice.setup->shortDRX->drx_ShortCycleTimer = ueCb->duMacUeCfg.macCellGrpCfg.drxCfg.shortDrx.drxShortCycleTimer;
7223       }
7224       else
7225       {
7226          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDrxConfigRrc");
7227          return RFAILED;
7228       }
7229    }
7230    return ROK;
7231 }
7232 #endif
7233 /*******************************************************************
7234  *
7235  * @brief Builds Mac cell group config
7236  *
7237  * @details
7238  *
7239  *    Function : BuildMacCellGrpCfg
7240  *
7241  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
7242  *
7243  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
7244  *
7245  * @return ROK     - success
7246  *         RFAILED - failure
7247  *
7248  * ****************************************************************/
7249 uint8_t BuildMacCellGrpCfg(DuUeCb *ueCb, MAC_CellGroupConfig_t *macCellGrpCfg)
7250 {
7251    macCellGrpCfg->drx_ConfigRrc = NULLP;
7252 #ifdef NR_DRX
7253    if(ueCb)
7254    {
7255       DU_ALLOC(macCellGrpCfg->drx_ConfigRrc, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
7256       if(!macCellGrpCfg->drx_ConfigRrc)
7257       {
7258          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7259          return RFAILED;
7260       }
7261       if(BuildDrxConfigRrc(ueCb, macCellGrpCfg->drx_ConfigRrc) != ROK)
7262       {
7263          DU_LOG("\nERROR  -->  F1AP : failed to build drx config");
7264          return RFAILED;
7265       }
7266    }
7267 #endif
7268    macCellGrpCfg->schedulingRequestConfig = NULLP;
7269    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
7270    if(!macCellGrpCfg->schedulingRequestConfig)
7271    {
7272       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7273       return RFAILED;
7274    }
7275
7276    if(BuildSchedulingReqConfig(ueCb, macCellGrpCfg->schedulingRequestConfig) != ROK)
7277    {
7278       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
7279       return RFAILED;
7280    }
7281
7282    macCellGrpCfg->bsr_Config = NULLP;
7283    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
7284    if(!macCellGrpCfg->bsr_Config)
7285    {
7286       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7287       return RFAILED;
7288    }
7289
7290    if(BuildBsrConfig(ueCb, macCellGrpCfg->bsr_Config) != ROK)
7291    {
7292       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
7293       return RFAILED;
7294    }
7295
7296    macCellGrpCfg->tag_Config = NULLP;
7297    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
7298    if(!macCellGrpCfg->tag_Config)
7299    {
7300       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7301       return RFAILED;
7302    }
7303
7304    if(BuildTagConfig(ueCb, macCellGrpCfg->tag_Config) != ROK)
7305    {
7306       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
7307       return RFAILED;
7308    }
7309
7310    macCellGrpCfg->phr_Config = NULLP;
7311    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
7312    if(!macCellGrpCfg->phr_Config)
7313    {
7314       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
7315       return RFAILED;
7316    }
7317
7318    if(BuildPhrConfig(ueCb, macCellGrpCfg->phr_Config) != ROK)
7319    {
7320       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
7321       return RFAILED;
7322    }
7323
7324    macCellGrpCfg->skipUplinkTxDynamic = false;
7325    macCellGrpCfg->ext1 = NULLP;
7326
7327    return ROK;
7328 }
7329 /*******************************************************************
7330  *
7331  * @brief Frees memeory allocated for SearchSpcToAddModList
7332  *
7333  * @details
7334  *
7335  *    Function : FreeSearchSpcToAddModList
7336  *
7337  *    Functionality: Deallocating memory of SearchSpcToAddModList
7338  *
7339  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
7340  *
7341  * @return void
7342  *
7343  4221 * ****************************************************************/
7344 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
7345 {
7346    uint8_t idx1=0;
7347    uint8_t idx2=0;
7348    struct  SearchSpace *searchSpc=NULLP;
7349
7350    if(searchSpcList->list.array)
7351    {
7352       if(searchSpcList->list.array[idx2])
7353       {
7354          searchSpc = searchSpcList->list.array[idx2];
7355          if(searchSpc->controlResourceSetId)
7356          {
7357             if(searchSpc->monitoringSlotPeriodicityAndOffset)
7358             {
7359                if(searchSpc->monitoringSymbolsWithinSlot)
7360                {
7361                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
7362                   {
7363                      if(searchSpc->nrofCandidates)
7364                      {
7365                         if(searchSpc->searchSpaceType)
7366                         {
7367                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
7368                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
7369                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
7370                                     SearchSpace__searchSpaceType));
7371                         }
7372                         DU_FREE(searchSpc->nrofCandidates,
7373                               sizeof(struct SearchSpace__nrofCandidates));
7374                      }
7375                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
7376                            searchSpc->monitoringSymbolsWithinSlot->size);
7377                   }
7378                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
7379                         sizeof(BIT_STRING_t));
7380                }
7381                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
7382                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
7383             }
7384             DU_FREE(searchSpc->controlResourceSetId,
7385                   sizeof(ControlResourceSetId_t));
7386          }
7387       }
7388       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
7389       {
7390          DU_FREE(searchSpcList->list.array[idx1],
7391                sizeof(struct SearchSpace));
7392       }
7393       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
7394    }
7395 }
7396 /*******************************************************************
7397  *
7398  * @brief Frees memory allocated for PdschTimeDomAllocList
7399  *
7400  * @details
7401  *
7402  *    Function : FreePdschTimeDomAllocList
7403  *
7404  *    Functionality: Deallocating memory of PdschTimeDomAllocList
7405  *
7406  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
7407  *
7408  * @return void
7409  *
7410  * ****************************************************************/
7411 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
7412 {
7413    uint8_t idx1=0;
7414
7415    if(timeDomAllocList->choice.setup)
7416    {
7417       if(timeDomAllocList->choice.setup->list.array)
7418       {
7419          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
7420          {
7421             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
7422             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
7423                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
7424          }
7425          DU_FREE(timeDomAllocList->choice.setup->list.array, \
7426                timeDomAllocList->choice.setup->list.size);
7427       }
7428       DU_FREE(timeDomAllocList->choice.setup,\
7429             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
7430    }
7431 }
7432 /*******************************************************************
7433  *
7434  * @brief Frees memory allocated for PuschTimeDomAllocList
7435  *
7436  *@details
7437  *
7438  *    Function : FreePuschTimeDomAllocList
7439  *
7440  *    Functionality: Deallocating memory of PuschTimeDomAllocList
7441  *
7442  * @params[in] PUSCH_Config_t *puschCfg
7443  *
7444  * @return void
7445  *
7446  * ****************************************************************/
7447 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
7448 {
7449    uint8_t rsrcListIdx=0;
7450    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7451
7452    if(puschCfg->pusch_TimeDomainAllocationList)
7453    {
7454       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7455       if(timeDomAllocList_t->choice.setup)
7456       {
7457          if(timeDomAllocList_t->choice.setup->list.array)
7458          {
7459             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
7460             {
7461                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
7462                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
7463                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
7464             }
7465             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
7466                   timeDomAllocList_t->choice.setup->list.size);
7467          }
7468          DU_FREE(timeDomAllocList_t->choice.setup, \
7469                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
7470       }
7471       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
7472       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
7473             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
7474    }
7475
7476 }
7477
7478 /*******************************************************************
7479  *
7480  * @brief Frees memory allocated for Dedicated PUCCH config
7481  *
7482  * @details
7483  *
7484  *    Function : FreeBWPUlDedPucchCfg
7485  *
7486  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
7487  *
7488  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
7489  *
7490  * @return void
7491  *
7492  * ****************************************************************/
7493 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
7494 {
7495    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
7496    PUCCH_Config_t *pucchCfg = NULLP;
7497    PUCCH_ResourceSet_t *rsrcSet = NULLP;
7498    PUCCH_Resource_t *rsrc = NULLP;
7499
7500    if(ulBwpPucchCfg)
7501    {
7502       if(ulBwpPucchCfg->choice.setup)
7503       {
7504          pucchCfg = ulBwpPucchCfg->choice.setup;
7505
7506          //Free resource set list
7507          if(pucchCfg->resourceSetToAddModList)
7508          {
7509             if(pucchCfg->resourceSetToAddModList->list.array)
7510             {
7511                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
7512                {
7513                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
7514                   if(rsrcSet->resourceList.list.array)
7515                   {
7516                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
7517                      {
7518                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
7519                      }
7520                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
7521                   }
7522                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
7523                }
7524                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
7525             }
7526             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
7527          }
7528
7529          //Free resource list
7530          if(pucchCfg->resourceToAddModList)
7531          {
7532             if(pucchCfg->resourceToAddModList->list.array)
7533             {
7534                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
7535                {
7536                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
7537                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
7538                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
7539                }
7540                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
7541             }
7542             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
7543          }
7544
7545          //PUCCH Format 1
7546          if(pucchCfg->format1)
7547          {
7548             if(pucchCfg->format1->choice.setup)
7549             {
7550                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
7551                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
7552             }
7553             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
7554          }
7555
7556          //DL DATA TO UL ACK
7557          if(pucchCfg->dl_DataToUL_ACK)
7558          {
7559             if(pucchCfg->dl_DataToUL_ACK->list.array)
7560             {
7561                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
7562                {
7563                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
7564                }
7565                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
7566             }
7567             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
7568          }
7569
7570          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
7571       }
7572       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
7573    }
7574 }
7575
7576 /*******************************************************************
7577  *
7578  * @brief Frees memory allocated for InitialUlBWP
7579  *
7580  * @details
7581  *
7582  *    Function : FreeInitialUlBWP
7583  *
7584  *    Functionality: Deallocating memory of InitialUlBWP
7585  *
7586  * @params[in] BWP_UplinkDedicated_t *ulBwp
7587  *
7588  * @return void
7589  *
7590  * ****************************************************************/
7591 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
7592 {
7593    uint8_t  rSetIdx, rsrcIdx;
7594    SRS_Config_t   *srsCfg = NULLP;
7595    PUSCH_Config_t *puschCfg = NULLP;
7596    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
7597    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
7598    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
7599    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
7600
7601    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
7602
7603    if(ulBwp->pusch_Config)
7604    {
7605       if(ulBwp->pusch_Config->choice.setup)
7606       {
7607          puschCfg=ulBwp->pusch_Config->choice.setup;
7608          if(puschCfg->dataScramblingIdentityPUSCH)
7609          {
7610             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
7611             {
7612                FreePuschTimeDomAllocList(puschCfg);
7613                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
7614                if(dmrsUlCfg->choice.setup)
7615                {
7616                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
7617                   {
7618                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
7619                      {
7620                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
7621                               sizeof(long));
7622                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
7623                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
7624                      }
7625                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
7626                            sizeof(long));
7627                   }
7628                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
7629                }
7630                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
7631                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
7632             }
7633             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
7634          }
7635          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
7636       }
7637       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
7638
7639       /* Free SRS-Config */
7640       if(ulBwp->srs_Config)
7641       {
7642          if(ulBwp->srs_Config->choice.setup)
7643          {
7644             srsCfg = ulBwp->srs_Config->choice.setup;
7645
7646             /* Free Resource Set to add/mod list */
7647             if(srsCfg->srs_ResourceSetToAddModList)
7648             {
7649                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
7650                if(rsrcSetList->list.array)
7651                {
7652                   rSetIdx = 0;
7653
7654                   /* Free SRS resource Id list in this SRS resource set */
7655                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
7656                   {
7657                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
7658
7659                      if(rsrcIdList->list.array)
7660                      {
7661                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
7662                         {
7663                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
7664                         }
7665                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
7666                      }
7667                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
7668                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
7669                   }
7670
7671                   /* Free resource type info for this SRS resource set */
7672                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
7673                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
7674
7675                   /* Free memory for each resource set */
7676                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
7677                   {
7678                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
7679                   }
7680                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
7681                }
7682                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
7683                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
7684             }
7685
7686             /* Free resource to add/modd list */
7687             if(srsCfg->srs_ResourceToAddModList)
7688             {
7689                resourceList = srsCfg->srs_ResourceToAddModList;
7690                if(resourceList->list.array)
7691                {
7692                   rsrcIdx = 0;
7693                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
7694                         sizeof(struct SRS_Resource__transmissionComb__n2));
7695                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
7696                         sizeof(struct SRS_Resource__resourceType__aperiodic));
7697
7698                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
7699                   {
7700                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
7701                   }
7702                   DU_FREE(resourceList->list.array, resourceList->list.size);
7703                }
7704                DU_FREE(srsCfg->srs_ResourceToAddModList, \
7705                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
7706             }
7707
7708             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
7709          }
7710          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
7711       }
7712    }
7713 }
7714 /*******************************************************************
7715  *
7716  * @brief Frees memory allocated for initialUplinkBWP
7717  *
7718  * @details
7719  *
7720  *    Function : FreeinitialUplinkBWP
7721  *
7722  *    Functionality: Deallocating memory of initialUplinkBWP
7723  *
7724  * @params[in] UplinkConfig_t *ulCfg
7725  *
7726  * @return void
7727  *
7728  *
7729  * ****************************************************************/
7730 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
7731 {
7732    BWP_UplinkDedicated_t *ulBwp=NULLP;
7733    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
7734
7735    if(ulCfg->initialUplinkBWP)
7736    {
7737       ulBwp=ulCfg->initialUplinkBWP;
7738       if(ulCfg->firstActiveUplinkBWP_Id)
7739       {
7740          if(ulCfg->pusch_ServingCellConfig)
7741          {
7742             puschCfg=ulCfg->pusch_ServingCellConfig;
7743             if(puschCfg->choice.setup)
7744             {
7745                if(puschCfg->choice.setup->ext1)
7746                {
7747                   DU_FREE(puschCfg->choice.setup->ext1->\
7748                         processingType2Enabled,sizeof(BOOLEAN_t));
7749                   DU_FREE(puschCfg->choice.setup->ext1->\
7750                         maxMIMO_Layers,sizeof(long));
7751                   DU_FREE(puschCfg->choice.setup->ext1, \
7752                         sizeof(struct PUSCH_ServingCellConfig__ext1));
7753                }
7754                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
7755             }
7756             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
7757          }
7758          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
7759       }
7760       FreeInitialUlBWP(ulBwp);
7761       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
7762    }
7763 }
7764 /*******************************************************************
7765  *
7766  * @brief Frees emmory allocated for BWPDlDedPdschCfg
7767  *
7768  * @details
7769  *
7770  *    Function : FreeBWPDlDedPdschCfg
7771  *
7772  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
7773  *
7774  * @params[in] BWP_DownlinkDedicated_t *dlBwp
7775  *
7776  * @return void
7777  *
7778  *
7779  * ****************************************************************/
7780 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
7781 {
7782    struct PDSCH_Config *pdschCfg=NULLP;
7783    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
7784    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
7785    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
7786
7787    if(dlBwp->pdsch_Config->choice.setup)
7788    {
7789       pdschCfg=dlBwp->pdsch_Config->choice.setup;
7790       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7791       {
7792          if(pdschCfg->pdsch_TimeDomainAllocationList)
7793          {
7794             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
7795             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
7796             {
7797                prbBndlType=&pdschCfg->prb_BundlingType;
7798                DU_FREE(prbBndlType->choice.staticBundling,\
7799                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
7800                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
7801             }
7802             FreePdschTimeDomAllocList(timeDomAllocList);
7803             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
7804                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
7805          }
7806          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
7807          if(dmrsDlCfg->choice.setup)
7808          {
7809             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
7810                   sizeof(long));
7811             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
7812          }
7813          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
7814                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
7815       }
7816       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
7817    }
7818 }
7819 /*******************************************************************
7820  *
7821  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
7822  *
7823  * @details
7824  *
7825  *    Function : FreeBWPDlDedPdcchCfg
7826  *
7827  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
7828  *
7829  * @params[in] BWP_DownlinkDedicated_t *dlBwp
7830  *
7831  * @return void
7832  *
7833  *
7834  * ****************************************************************/
7835 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
7836 {
7837    uint8_t idx1=0;
7838    uint8_t idx2=0;
7839    struct PDCCH_Config *pdcchCfg=NULLP;
7840    struct ControlResourceSet *controlRSet=NULLP;
7841    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
7842
7843    if(dlBwp->pdcch_Config->choice.setup)
7844    {
7845       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
7846       if(pdcchCfg->controlResourceSetToAddModList)
7847       {
7848          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
7849          if(controlRSetList->list.array)
7850          {
7851             controlRSet = controlRSetList->list.array[idx2];
7852             if(controlRSet)
7853             {
7854                if(controlRSet->frequencyDomainResources.buf)
7855                {
7856                   if(controlRSet->pdcch_DMRS_ScramblingID)
7857                   {
7858                      if(pdcchCfg->searchSpacesToAddModList)
7859                      {
7860                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
7861                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
7862                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
7863                      }
7864                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
7865                   }
7866                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
7867                         controlRSet->frequencyDomainResources.size);
7868                }
7869             }
7870             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
7871             {
7872                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
7873             }
7874             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
7875          }
7876          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
7877                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
7878       }
7879       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
7880    }
7881 }
7882
7883 /*******************************************************************
7884  *
7885  * @brief Free SCS specific carrier list in DL frequency info
7886  *
7887  * @details
7888  *
7889  *    Function : FreeScsSpecificCarrierListDl
7890  *
7891  *    Functionality: Free SCS specific carrier list in DL frequency info
7892  *
7893  * @params[in] Pointer to struct FrequencyInfoDL__scs_SpecificCarrierList
7894  *
7895  * @return void
7896  *
7897  * ****************************************************************/
7898 void FreeScsSpecificCarrierListDl(struct FrequencyInfoDL__scs_SpecificCarrierList *scsCarrierList)
7899 {
7900    uint8_t listIdx = 0;
7901
7902    if(!scsCarrierList->list.array)
7903    {
7904       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
7905       {
7906          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
7907       }
7908       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
7909    }
7910 }
7911
7912 /*******************************************************************
7913  *
7914  * @brief Free DL frequency info in DL config common
7915  *
7916  * @details
7917  *
7918  *    Function : FreeFreqInfoDl
7919  *
7920  *    Functionality: Free DL frequency info in DL config common
7921  *
7922  * @params[in] Pointer to DownlinkConfigCommon_t
7923  *
7924  * @return void
7925  *
7926  * ****************************************************************/
7927 void FreeFreqInfoDl(FrequencyInfoDL_t *frequencyInfoDL)
7928 {
7929    uint8_t freqBandIdx = 0;
7930
7931    /* SSB Absolute Frequency */
7932    DU_FREE(frequencyInfoDL->absoluteFrequencySSB, sizeof(ARFCN_ValueNR_t));
7933
7934    /* NR Multi Frequency Band List */
7935    if(frequencyInfoDL->frequencyBandList.list.array)
7936    {
7937       for(freqBandIdx = 0; freqBandIdx < frequencyInfoDL->frequencyBandList.list.count; freqBandIdx++)
7938       {
7939          DU_FREE(frequencyInfoDL->frequencyBandList.list.array[freqBandIdx], sizeof(FreqBandIndicatorNR_t));
7940       }
7941       DU_FREE(frequencyInfoDL->frequencyBandList.list.array, frequencyInfoDL->frequencyBandList.list.size);
7942    }
7943
7944    /* Subcarrier Spacing specifc carrier List */
7945    FreeScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList);
7946 }
7947
7948 /*******************************************************************
7949  *
7950  * @brief Free DL config common in Serving cell config common
7951  *
7952  * @details
7953  *
7954  *    Function : FreeDlConfigCommon
7955  *
7956  *    Functionality: Free DL config common in Serving cell config common
7957  *
7958  * @params[in] Pointer to DownlinkConfigCommon_t
7959  *
7960  * @return void
7961  *
7962  * ****************************************************************/
7963 void FreeDlConfigCommon(DownlinkConfigCommon_t *dlCfgCommon)
7964 {
7965    /* DL Frequency Info */
7966    if(dlCfgCommon->frequencyInfoDL)
7967    {
7968       FreeFreqInfoDl(dlCfgCommon->frequencyInfoDL);
7969       DU_FREE(dlCfgCommon->frequencyInfoDL, sizeof(FrequencyInfoDL_t));
7970    }
7971
7972    /* DL BWP config common */
7973    if(dlCfgCommon->initialDownlinkBWP)
7974    {
7975       FreeBwpDlCommon(dlCfgCommon->initialDownlinkBWP);
7976       DU_FREE(dlCfgCommon->initialDownlinkBWP, sizeof(BWP_DownlinkCommon_t));
7977    }
7978 }
7979
7980 /*******************************************************************
7981  *
7982  * @brief Free SCS specific carrier list in UL frequency Info
7983  *
7984  * @details
7985  *
7986  *    Function : FreeScsSpecificCarrierListUl
7987  *
7988  *    Functionality: Free SCS specific carrier list in UL frequency Info
7989  *
7990  * @params[in] Pointer to struct FrequencyInfoUL__scs_SpecificCarrierList
7991  *
7992  * @return void
7993  *
7994  * ****************************************************************/
7995 void FreeScsSpecificCarrierListUl(struct FrequencyInfoUL__scs_SpecificCarrierList *scsCarrierList)
7996 {
7997    uint8_t listIdx = 0;
7998
7999    if(scsCarrierList->list.array)
8000    {
8001       for(listIdx = 0; listIdx < scsCarrierList->list.count; listIdx++)
8002       {
8003          DU_FREE(scsCarrierList->list.array[listIdx], sizeof(SCS_SpecificCarrier_t));
8004       }
8005       DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
8006    }
8007 }
8008
8009 /*******************************************************************
8010  *
8011  * @brief Free frequency info in UL config common
8012  *
8013  * @details
8014  *
8015  *    Function : FreeFreqInfoUl
8016  *
8017  *    Functionality: Free frequency info in UL config common
8018  *
8019  * @params[in] Pointer to FrequencyInfoUL_t
8020  *
8021  * @return void
8022  *
8023  * ****************************************************************/
8024 void FreeFreqInfoUl(FrequencyInfoUL_t *frequencyInfoUL)
8025 {
8026    uint8_t listIdx= 0;
8027
8028    /* NR Multi Frequency Band List */
8029    if(!frequencyInfoUL->frequencyBandList)
8030    {
8031       if(frequencyInfoUL->frequencyBandList->list.array)
8032       {
8033          for(listIdx = 0; listIdx < frequencyInfoUL->frequencyBandList->list.count; listIdx++)
8034          {
8035             DU_FREE(frequencyInfoUL->frequencyBandList->list.array[listIdx], sizeof(FreqBandIndicatorNR_t));
8036          }
8037          DU_FREE(frequencyInfoUL->frequencyBandList->list.array, frequencyInfoUL->frequencyBandList->list.size);
8038       }
8039       DU_FREE(frequencyInfoUL->frequencyBandList, sizeof(MultiFrequencyBandListNR_t));
8040    }
8041
8042    /* Absolute frequency point A */
8043    DU_FREE(frequencyInfoUL->absoluteFrequencyPointA, sizeof(ARFCN_ValueNR_t));
8044
8045    /* Subcarrier Spacing specifc carrier */
8046    FreeScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList);
8047
8048    /* P-MAX */
8049    DU_FREE(frequencyInfoUL->p_Max, sizeof(P_Max_t));
8050 }
8051
8052 /*******************************************************************
8053  *
8054  * @brief Free UL config common in Serving cell config common
8055  *
8056  * @details
8057  *
8058  *    Function : FreeUlConfigCommon
8059  *
8060  *    Functionality: Free UL config common in Serving cell config common
8061  *
8062  * @params[in] Pointer to UplinkConfigCommon_t
8063  *
8064  * @return void
8065  *
8066  * ****************************************************************/
8067 void FreeUlConfigCommon(UplinkConfigCommon_t *ulCfgCommon)
8068 {
8069    /* UL Frequency Info */
8070    if(ulCfgCommon->frequencyInfoUL)
8071    {
8072       FreeFreqInfoUl(ulCfgCommon->frequencyInfoUL);
8073       DU_FREE(ulCfgCommon->frequencyInfoUL, sizeof(FrequencyInfoUL_t));
8074    }
8075
8076    /* UL BWP common */
8077    if(ulCfgCommon->initialUplinkBWP)
8078    {
8079       FreeBwpUlCommon(ulCfgCommon->initialUplinkBWP);
8080       DU_FREE(ulCfgCommon->initialUplinkBWP, sizeof(BWP_UplinkCommon_t));
8081    }
8082 }
8083
8084 /*******************************************************************
8085  *
8086  * @brief Free SP cell config common in Reconfig with Sync
8087  *
8088  * @details
8089  *
8090  *    Function : FreeSpCellConfigCommon
8091  *
8092  *    Functionality: Free SP cell config common in Reconfig with Sync
8093  *
8094  * @params[in] Pointer to ServingCellConfigCommon_t
8095  *
8096  * @return void
8097  *
8098  * ****************************************************************/
8099 void FreeSpCellConfigCommon(ServingCellConfigCommon_t *spCellConfigCommon)
8100 {
8101    /* Free Physical cell identity */
8102    DU_FREE(spCellConfigCommon->physCellId, sizeof(PhysCellId_t));
8103
8104    /* Free Downlink Config common */
8105    if(spCellConfigCommon->downlinkConfigCommon)
8106    {
8107       FreeDlConfigCommon(spCellConfigCommon->downlinkConfigCommon);
8108       DU_FREE(spCellConfigCommon->downlinkConfigCommon, sizeof(DownlinkConfigCommon_t));
8109    }
8110
8111    /* Free Uplink Config common */
8112    if(spCellConfigCommon->uplinkConfigCommon)
8113    {
8114       FreeUlConfigCommon(spCellConfigCommon->uplinkConfigCommon);
8115       DU_FREE(spCellConfigCommon->uplinkConfigCommon, sizeof(UplinkConfigCommon_t));
8116    }
8117
8118    /* Free Timing Advance offset */
8119    DU_FREE(spCellConfigCommon->n_TimingAdvanceOffset, sizeof(long));
8120
8121    /* Free SSB Position in Burst */
8122    if(spCellConfigCommon->ssb_PositionsInBurst)
8123    {
8124       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.buf, \
8125          spCellConfigCommon->ssb_PositionsInBurst->choice.mediumBitmap.size);
8126       DU_FREE(spCellConfigCommon->ssb_PositionsInBurst, sizeof(struct ServingCellConfigCommon__ssb_PositionsInBurst));
8127    }
8128
8129    /* Free SSB Periodicity in Serving cell */
8130    DU_FREE(spCellConfigCommon->ssb_periodicityServingCell, sizeof(long));
8131
8132    /* Free SSB subcarrier spacing */
8133    DU_FREE(spCellConfigCommon->ssbSubcarrierSpacing, sizeof(SubcarrierSpacing_t));
8134
8135    /* TDD UL-DL configuration common */
8136    DU_FREE(spCellConfigCommon->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
8137 }
8138
8139 /*******************************************************************
8140  *
8141  * @brief Free dedicated RACH configuration in Reconfiguration with sync
8142  *
8143  * @details
8144  *
8145  *    Function : FreeRecfgWithSync
8146  *
8147  *    Functionality:
8148  *       Free dedicated RACH configuration in Reconfiguration with sync
8149  *
8150  * @params[in] Pinter to Rach config dedicated struct
8151  *
8152  * @return void
8153  *
8154  * ****************************************************************/
8155 void FreeRachConfigDedicated(struct ReconfigurationWithSync__rach_ConfigDedicated *rachCfgDed)
8156 {
8157    uint8_t listIdx = 0;
8158    CFRA_t *cfra = NULLP;
8159    struct CFRA__resources__ssb *ssbResource = NULLP;
8160
8161    /* Uplink */
8162    if(rachCfgDed->choice.uplink)
8163    {
8164       /* CFRA : Contention free Random Access */
8165       if(rachCfgDed->choice.uplink->cfra)
8166       {
8167          cfra = rachCfgDed->choice.uplink->cfra;
8168
8169          /* CFRA occassions */
8170          if(cfra->occasions)
8171          {
8172             /* CFRA occassions : SSB per RACH occasion */
8173             DU_FREE(cfra->occasions->ssb_perRACH_Occasion, sizeof(long));
8174             DU_FREE(cfra->occasions, sizeof(struct CFRA__occasions));
8175          }
8176
8177          /* CFRA resource */
8178          cfra->resources.present = CFRA__resources_PR_ssb;
8179
8180          /* CFRA resource : SSB */
8181          if(cfra->resources.choice.ssb)
8182          {
8183             ssbResource = cfra->resources.choice.ssb;
8184
8185             /* CFRA SSB resource list */
8186             if(ssbResource->ssb_ResourceList.list.array)
8187             {
8188                for(listIdx = 0; listIdx < ssbResource->ssb_ResourceList.list.count; listIdx++)
8189                {
8190                   DU_FREE(ssbResource->ssb_ResourceList.list.array[listIdx], sizeof(CFRA_SSB_Resource_t));
8191                }
8192                DU_FREE(ssbResource->ssb_ResourceList.list.array, ssbResource->ssb_ResourceList.list.size);
8193             }
8194             DU_FREE(cfra->resources.choice.ssb, sizeof(struct CFRA__resources__ssb));
8195          }
8196          DU_FREE(rachCfgDed->choice.uplink->cfra, sizeof(CFRA_t));
8197       }
8198       DU_FREE(rachCfgDed->choice.uplink, sizeof(RACH_ConfigDedicated_t));
8199    }
8200 }
8201
8202 /*******************************************************************
8203  *
8204  * @brief Frees reconfiguration with sync in SP cell config
8205  *
8206  * @details
8207  *
8208  *    Function : FreeRecfgWithSync
8209  *
8210  *    Functionality: Fress reconfiguration with sync in SP cell config
8211  *
8212  * @params[in] Pointer to ReconfigurationWithSync_t
8213  *
8214  * @return void
8215  *
8216  * ****************************************************************/
8217 void FreeRecfgWithSync(ReconfigurationWithSync_t *recfgWithSync)
8218 {
8219    /* Free SP Cell config common */
8220    if(recfgWithSync->spCellConfigCommon)
8221    {
8222       FreeSpCellConfigCommon(recfgWithSync->spCellConfigCommon);
8223       DU_FREE(recfgWithSync->spCellConfigCommon, sizeof(ServingCellConfigCommon_t));
8224    }
8225
8226    /* Free Dedicated RACH configuration */
8227    if(recfgWithSync->rach_ConfigDedicated)
8228    {
8229       FreeRachConfigDedicated(recfgWithSync->rach_ConfigDedicated);
8230       DU_FREE(recfgWithSync->rach_ConfigDedicated, sizeof(struct ReconfigurationWithSync__rach_ConfigDedicated));
8231    }
8232 }
8233
8234 /*******************************************************************
8235  *
8236  * @brief Frees emmory allocated for DUToCURRCContainer
8237  *
8238  * @details
8239  *
8240  *    Function : FreeMemDuToCuRrcCont
8241  *
8242  *    Functionality: Deallocating memory of DuToCuRrcContainer
8243  *
8244  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
8245  *
8246  * @return ROK     - success
8247  *         RFAILED - failure
8248  *
8249  * ****************************************************************/
8250 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
8251 {
8252    uint8_t idx=0;
8253    SpCellConfig_t *spCellCfg=NULLP;
8254    ServingCellConfig_t *srvCellCfg=NULLP;
8255    BWP_DownlinkDedicated_t *dlBwp=NULLP;
8256    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
8257    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
8258    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
8259    struct RLC_Config *rlcConfig=NULLP;
8260    struct LogicalChannelConfig *macLcConfig=NULLP;
8261    struct MAC_CellGroupConfig__drx_ConfigRrc *drxCfg=NULLP;
8262    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
8263    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
8264    struct TAG_Config *tagConfig=NULLP;
8265    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
8266    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
8267    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
8268
8269    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
8270    if(rlcBearerList)
8271    {
8272       if(rlcBearerList->list.array)
8273       {
8274          for(idx=0; idx<rlcBearerList->list.count; idx++)
8275          {
8276             if(rlcBearerList->list.array[idx])
8277             {
8278                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
8279                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
8280                if(rlcConfig)
8281                {
8282                   switch(rlcConfig->present)
8283                   {
8284                      case RLC_Config_PR_NOTHING:
8285                         break;
8286
8287                      case RLC_Config_PR_am:
8288                         {
8289                            if(rlcConfig->choice.am)
8290                            {
8291                               DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8292                               DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
8293                               DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
8294                            }
8295                            break;
8296                         }
8297                      case RLC_Config_PR_um_Bi_Directional:
8298                         {
8299                            if(rlcConfig->choice.um_Bi_Directional)
8300                            {
8301                               DU_FREE(rlcConfig->choice.um_Bi_Directional->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8302                               DU_FREE(rlcConfig->choice.um_Bi_Directional->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8303                               DU_FREE(rlcConfig->choice.um_Bi_Directional, sizeof(struct RLC_Config__um_Bi_Directional));
8304                            }
8305                            break;
8306                         }
8307                      case RLC_Config_PR_um_Uni_Directional_UL:
8308                         {
8309                            if(rlcConfig->choice.um_Uni_Directional_UL)
8310                            {
8311                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL->ul_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8312                               DU_FREE(rlcConfig->choice.um_Uni_Directional_UL , sizeof(struct RLC_Config__um_Uni_Directional_UL));
8313                            }
8314                            break;
8315                         }
8316                      case RLC_Config_PR_um_Uni_Directional_DL:
8317                         {
8318                            if(rlcConfig->choice.um_Uni_Directional_DL )
8319                            {
8320                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL->dl_UM_RLC.sn_FieldLength, sizeof(SN_FieldLengthUM_t));
8321                               DU_FREE(rlcConfig->choice.um_Uni_Directional_DL , sizeof(struct RLC_Config__um_Uni_Directional_DL));
8322                            }
8323                            break;
8324                         }
8325                   }
8326                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
8327                }
8328                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
8329                if(macLcConfig)
8330                {
8331                   if(macLcConfig->ul_SpecificParameters)
8332                   {
8333                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
8334                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
8335                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
8336                   }
8337                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
8338                }
8339                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
8340             }
8341          }
8342          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
8343       }
8344       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8345    }
8346
8347    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
8348    if(macCellGrpCfg)
8349    {
8350       drxCfg = macCellGrpCfg->drx_ConfigRrc;
8351
8352       if(drxCfg)
8353       {
8354           switch(drxCfg->present)
8355           {
8356             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
8357                break;
8358             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
8359             {
8360                if(drxCfg->choice.setup)
8361                {
8362                   DU_FREE(drxCfg->choice.setup->shortDRX, sizeof(struct DRX_ConfigRrc__shortDRX));
8363                   DU_FREE(drxCfg->choice.setup, sizeof(struct DRX_ConfigRrc));
8364                }
8365             }
8366             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
8367                break;
8368           }
8369           DU_FREE(drxCfg, sizeof(struct MAC_CellGroupConfig__drx_ConfigRrc));
8370       }
8371       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
8372       if(schedulingRequestConfig)
8373       {
8374          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
8375          if(schReqList)
8376          {
8377             if(schReqList->list.array)
8378             {
8379                for(idx=0;idx<schReqList->list.count; idx++)
8380                {
8381                   if(schReqList->list.array[idx])
8382                   {
8383                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
8384                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
8385                   }
8386                }
8387                DU_FREE(schReqList->list.array, schReqList->list.size);
8388             }
8389             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
8390                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
8391             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
8392       }
8393       if(macCellGrpCfg->bsr_Config)
8394       {
8395          DU_FREE(macCellGrpCfg->bsr_Config->logicalChannelSR_DelayTimer, sizeof(long));
8396          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
8397       }
8398       tagConfig = macCellGrpCfg->tag_Config;
8399       if(tagConfig)
8400       {
8401          tagList = tagConfig->tag_ToAddModList;
8402          if(tagList)
8403          {
8404             if(tagList->list.array)
8405             {
8406                for(idx=0; idx<tagList->list.count; idx++)
8407                {
8408                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
8409                }
8410                DU_FREE(tagList->list.array, tagList->list.size);
8411             }
8412             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
8413          }
8414          DU_FREE(tagConfig, sizeof(struct TAG_Config));
8415       }
8416
8417       phrConfig = macCellGrpCfg->phr_Config;
8418       if(phrConfig)
8419       {
8420          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
8421          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
8422       }
8423
8424       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
8425    }
8426
8427    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
8428    if(phyCellGrpCfg)
8429    {
8430       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
8431       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
8432    }
8433
8434    spCellCfg = cellGrpCfg->spCellConfig;
8435    if(spCellCfg)
8436    {
8437       /* Free serving cell index */
8438       DU_FREE(spCellCfg->servCellIndex, sizeof(long));
8439
8440       /* Free Reconfiguration with sync */
8441       if(spCellCfg->reconfigurationWithSync)
8442       {
8443          FreeRecfgWithSync(spCellCfg->reconfigurationWithSync);
8444          DU_FREE(spCellCfg->reconfigurationWithSync, sizeof(ReconfigurationWithSync_t));
8445       }
8446
8447       /* Free rlmInSyncOutOfSyncThreshold */
8448       DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
8449
8450       /* Free SP Cell config dedicated */
8451       if(spCellCfg->spCellConfigDedicated)
8452       {
8453          srvCellCfg = spCellCfg->spCellConfigDedicated;
8454
8455          /* Free TDD UL-DL config dedicated */
8456          DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
8457
8458          /* Free Initial Downlink BWP */
8459          if(srvCellCfg->initialDownlinkBWP)
8460          {
8461             dlBwp = srvCellCfg->initialDownlinkBWP;
8462
8463             /* Free DL BWP PDCCH Config */
8464             if(dlBwp->pdcch_Config)
8465             {
8466                FreeBWPDlDedPdcchCfg(dlBwp);
8467                DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
8468             }
8469
8470             /* Free DL BWP PDSCH config */
8471             if(dlBwp->pdsch_Config)
8472             {
8473                FreeBWPDlDedPdschCfg(dlBwp);
8474                DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
8475             }
8476             DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
8477          }
8478
8479          /* Free First Active Downlink BWP */
8480          DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
8481
8482          /* Free Default downlink BWP */
8483          DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
8484
8485          /* Free Uplink config */
8486          if(srvCellCfg->uplinkConfig)
8487          {
8488             FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
8489             DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
8490          }
8491
8492          /* Free PDSCH serving cell config */
8493          if(srvCellCfg->pdsch_ServingCellConfig)
8494          {
8495             pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
8496             if(pdschCfg->choice.setup)
8497             {
8498                DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
8499                DU_FREE(pdschCfg->choice.setup, sizeof(struct PDSCH_ServingCellConfig));
8500             }
8501             DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct ServingCellConfig__pdsch_ServingCellConfig));
8502          }
8503
8504          DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
8505       }
8506       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
8507    }
8508    return ROK;
8509 }
8510
8511 /*******************************************************************
8512  *
8513  * @brief Builds CellGroupConfigRrc for DU To CU RRC Container
8514  *
8515  * @details
8516  *
8517  *    Function : BuildCellGroupConfigRrc
8518  *
8519  *    Functionality: Builds and copied Cell group config buffer into
8520  *       DuToCuRrcContainer
8521  *
8522  * @params[in] idx, index in F1AP msg
8523  *             DuToCuRRCContainer, DuToCuRRCContainer
8524  *
8525  * @return ROK     - success
8526  *         RFAILED - failure
8527  *
8528  * ****************************************************************/
8529 uint8_t BuildCellGroupConfigRrc(DuUeCb *ueCb, OCTET_STRING_t *duToCuRrcContainer)
8530 {
8531    uint8_t  ret = ROK;
8532    CellGroupConfigRrc_t  cellGrpCfg;
8533    asn_enc_rval_t        encRetVal;
8534    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
8535    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8536
8537    while(true)
8538    {
8539       cellGrpCfg.cellGroupId = CELL_GRP_ID;
8540
8541       cellGrpCfg.rlc_BearerToAddModList = NULLP;
8542       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
8543       if(!cellGrpCfg.rlc_BearerToAddModList)
8544       {
8545          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8546          ret = RFAILED;
8547          break;
8548       }
8549       if(BuildRlcBearerToAddModList(ueCb, cellGrpCfg.rlc_BearerToAddModList) != ROK)
8550       {
8551          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
8552          ret = RFAILED;
8553          break;
8554       }
8555
8556       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
8557       cellGrpCfg.mac_CellGroupConfig = NULLP;
8558       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
8559       if(!cellGrpCfg.mac_CellGroupConfig)
8560       {
8561          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8562          ret = RFAILED;
8563          break;
8564       }
8565       if(BuildMacCellGrpCfg(ueCb, cellGrpCfg.mac_CellGroupConfig) != ROK)
8566       {
8567          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
8568          ret = RFAILED;
8569          break;
8570       }
8571
8572       cellGrpCfg.physicalCellGroupConfig = NULLP;
8573       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
8574       if(!cellGrpCfg.physicalCellGroupConfig)
8575       {
8576          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8577          ret = RFAILED;
8578          break;
8579       }
8580       if(BuildPhyCellGrpCfg(ueCb, cellGrpCfg.physicalCellGroupConfig) != ROK)
8581       {
8582          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
8583          ret = RFAILED;
8584          break;
8585       }
8586
8587       cellGrpCfg.spCellConfig = NULLP;
8588       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
8589       if(!cellGrpCfg.spCellConfig)
8590       {
8591          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
8592          ret = RFAILED;
8593          break;
8594       }
8595       if(BuildSpCellCfg(ueCb, cellGrpCfg.spCellConfig) != ROK)
8596       {
8597          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
8598          ret = RFAILED;
8599          break;
8600       }
8601
8602       cellGrpCfg.sCellToAddModList = NULLP;
8603       cellGrpCfg.sCellToReleaseList = NULLP;
8604       cellGrpCfg.ext1 = NULLP;
8605
8606       /* encode cellGrpCfg into duToCuRrcContainer */
8607       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
8608       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8609       encBufSize = 0;
8610       encRetVal = uper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
8611       /* Encode results */
8612       if(encRetVal.encoded == ENCODE_FAIL)
8613       {
8614          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
8615                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
8616          ret = RFAILED;
8617          break;
8618       }
8619       else
8620       {
8621          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
8622 #ifdef DEBUG_ASN_PRINT
8623          for(int i=0; i< encBufSize; i++)
8624          {
8625             printf("%x",encBuf[i]);
8626          }
8627 #endif
8628       }
8629
8630       duToCuRrcContainer->size = encBufSize;
8631       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
8632       if(!duToCuRrcContainer->buf)
8633       {
8634          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
8635          ret = RFAILED;
8636          break;
8637       }
8638       if(ret == ROK)
8639       {
8640          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
8641       }
8642       break;
8643    }
8644    FreeMemDuToCuRrcCont(&cellGrpCfg);
8645    return ret;
8646 }
8647
8648 /*******************************************************************
8649  *
8650  * @brief Free memory allocated in InitialULRRCMessage
8651  *
8652  * @details
8653  *
8654  *    Function : freeInitUlRrcMsgTransfer
8655  *
8656  *    Functionality: Free memory allocated in InitialULRRCMessage
8657  *
8658  * @params[in]F1AP_PDU_t  *f1apMsg)
8659  *
8660  * @return ROK     - success
8661  *         RFAILED - failure
8662  *
8663  * ****************************************************************/
8664
8665 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
8666 {
8667    uint8_t ieIdx, arrIdx;
8668    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
8669
8670    if(f1apMsg)
8671    {
8672       if(f1apMsg->choice.initiatingMessage)
8673       {
8674          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
8675             choice.InitialULRRCMessageTransfer;
8676          if(initULRRCMsg->protocolIEs.list.array)
8677          {
8678             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
8679             {
8680                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
8681                {
8682                   case ProtocolIE_ID_id_NRCGI:
8683                   {
8684                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
8685                      {
8686                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
8687                         {
8688                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
8689                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
8690                         }
8691                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
8692                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
8693                      }
8694                      break;
8695                   }
8696                   case ProtocolIE_ID_id_RRCContainer:
8697                   {
8698                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8699                      {
8700                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
8701                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8702                      }
8703                      break;
8704                   }
8705                   case ProtocolIE_ID_id_DUtoCURRCContainer:
8706                   {
8707                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
8708                      {
8709                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
8710                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
8711                      }
8712                      break;
8713                   }
8714                   default:
8715                      break;
8716                }
8717              }
8718              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
8719              {
8720                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
8721                 {
8722                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
8723                       sizeof(InitialULRRCMessageTransferIEs_t));
8724                 }
8725              }
8726              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
8727           }
8728          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8729       }
8730       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
8731    }
8732    else
8733    {
8734       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
8735       return RFAILED;
8736    }
8737    return ROK;
8738 }
8739
8740 /*******************************************************************
8741  *
8742  * @brief Builds and sends the InitialULRRCMessage
8743  *
8744  * @details
8745  *
8746  *    Function : BuildAndSendInitialRrcMsgTransfer
8747  *
8748  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
8749  *                   it to the CU through SCTP.
8750  *
8751  * @params[in]
8752  *
8753  * @return ROK     - success
8754  *         RFAILED - failure
8755  *
8756  * ****************************************************************/
8757 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
8758       uint16_t rrcContSize, uint8_t *rrcContainer)
8759 {
8760    uint8_t   ret;
8761    uint8_t   elementCnt;
8762    uint8_t   ieIdx, cellIdx, ueIdx;
8763    DuUeCb    *duUeCb = NULLP;
8764    asn_enc_rval_t  encRetVal;
8765    F1AP_PDU_t  *f1apMsg = NULLP;
8766    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
8767    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
8768
8769    while(true)
8770    {
8771       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
8772       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
8773       if(f1apMsg == NULLP)
8774       {
8775          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
8776          break;
8777       }
8778       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
8779       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
8780       if(f1apMsg->choice.initiatingMessage == NULLP)
8781       {
8782          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
8783          break;
8784       }
8785       f1apMsg->choice.initiatingMessage->procedureCode =\
8786                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
8787       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
8788       f1apMsg->choice.initiatingMessage->value.present = \
8789                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
8790       initULRRCMsg =\
8791                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
8792       elementCnt = 5;
8793       initULRRCMsg->protocolIEs.list.count = elementCnt;
8794       initULRRCMsg->protocolIEs.list.size = \
8795                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
8796       /* Initialize the F1Setup members */
8797       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
8798       if(initULRRCMsg->protocolIEs.list.array == NULLP)
8799       {
8800          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
8801                RRCSetupRequestMessageTransferIEs failed");
8802          break;
8803       }
8804       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
8805       {
8806          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
8807                sizeof(InitialULRRCMessageTransferIEs_t));
8808          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
8809          {
8810             break;
8811          }
8812       }
8813       ieIdx = 0;
8814       /*GNB DU UE F1AP ID*/
8815       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8816                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
8817       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
8818       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
8819                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
8820       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
8821
8822
8823       /*NRCGI*/
8824       ieIdx++;
8825       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8826                                                         ProtocolIE_ID_id_NRCGI;
8827       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
8828       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
8829                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
8830
8831       ret =\
8832            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
8833       if(ret!=ROK)
8834       {
8835          break;
8836       }
8837
8838       /*CRNTI*/
8839       ieIdx++;
8840       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8841                                                         ProtocolIE_ID_id_C_RNTI;
8842       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8843       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8844                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
8845       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
8846
8847       /*RRCContainer*/
8848       ieIdx++;
8849       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
8850                                                         ProtocolIE_ID_id_RRCContainer;
8851       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8852       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8853                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
8854
8855       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
8856       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
8857             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
8858       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
8859       {
8860          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
8861          break;
8862
8863       }
8864       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
8865             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
8866
8867
8868       /*DUtoCURRCContainer*/
8869       ieIdx++;
8870       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
8871       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
8872       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
8873                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
8874
8875       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
8876       {
8877          for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
8878          {
8879             if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
8880                   (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti == crnti))
8881             {
8882                duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
8883             }
8884          }
8885       }
8886
8887       ret = BuildCellGroupConfigRrc(duUeCb, &initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
8888       if(ret != ROK)
8889       {
8890          break;
8891       }
8892
8893       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
8894
8895       /* Encode the Intial UL RRC Message transfer as APER */
8896       memset(encBuf, 0, ENC_BUF_MAX_LEN);
8897       encBufSize = 0;
8898       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
8899       /* Encode results */
8900       if(encRetVal.encoded == ENCODE_FAIL)
8901       {
8902          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
8903                structure (at %s)\n",encRetVal.failed_type ? \
8904                encRetVal.failed_type->name : "unknown");
8905          ret = RFAILED;
8906          break;
8907       }
8908       else
8909       {
8910
8911          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
8912                Message transfer\n");
8913 #ifdef DEBUG_ASN_PRINT
8914          for(int i=0; i< encBufSize; i++)
8915          {
8916             printf("%x",encBuf[i]);
8917          }
8918 #endif
8919       }
8920       /* Sending  msg  */
8921       if(sendF1APMsg() != ROK)
8922       {
8923          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
8924          ret = RFAILED;
8925          break;
8926       }
8927       break;
8928    }
8929    freeInitUlRrcMsgTransfer(f1apMsg);
8930    return ret;
8931 }/* End of BuildAndSendInitialRrcMsgTransfer*/
8932
8933 /*****  UE SETUP REQUEST *****/
8934
8935 /******************************************************************
8936 *
8937 * @brief Function to delete the RLC Lc cfg from UE APP DB
8938 *
8939 * @details
8940 *
8941 *  Function : freeRlcLcCfg
8942 *
8943 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
8944 *
8945 *
8946  *****************************************************************/
8947
8948 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
8949 {
8950    switch(lcCfg->rlcMode)
8951    {
8952       case RLC_AM :
8953          {
8954             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
8955             break;
8956          }
8957       case RLC_UM_BI_DIRECTIONAL :
8958          {
8959             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
8960             break;
8961          }
8962       case RLC_UM_UNI_DIRECTIONAL_UL :
8963          {
8964             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
8965             break;
8966          }
8967       case RLC_UM_UNI_DIRECTIONAL_DL :
8968          {
8969             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
8970             break;
8971          }
8972       default:
8973          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
8974          break;
8975    }
8976    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
8977 }
8978
8979 /*******************************************************************
8980  *
8981  * @brief Function to free MacLcCfg
8982  *
8983  * @details
8984  *
8985  *    Function : freeMacLcCfg
8986  *
8987  *    Functionality: Function to free MacLcCfg
8988  *
8989  * @params[in] LcCfg *lcCfg,
8990  * @return void
8991  *
8992  * ****************************************************************/
8993
8994 void freeMacLcCfg(LcCfg *lcCfg)
8995 {
8996     /* Deleting DRBQOS */
8997    if(lcCfg->drbQos)
8998    {
8999       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
9000    }
9001    /* Deleting SNSSAI */
9002    if(lcCfg->snssai)
9003    {
9004       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
9005    }
9006 }
9007 /*******************************************************************
9008  *
9009  * @brief Free UE NR Capability received in UE Context setup request
9010  *
9011  * @details
9012  *
9013  *    Function : freeAperDecodeUeNrCapability
9014  *
9015  *    Functionality:
9016  *       Free UE NR Capability received in UE Context setup request
9017  *
9018  * @params[in]
9019  * @return ROK     - success
9020  *         RFAILED - failure
9021  *
9022  * ****************************************************************/
9023 void freeAperDecodeUeNrCapability(void *ueNrCapability)
9024 {
9025    uint8_t arrIdx =0;
9026    FeatureSets_t *featureSets =NULLP;
9027    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
9028
9029    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
9030    {
9031       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
9032       {
9033          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
9034             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
9035       }
9036       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
9037    }
9038
9039    if(ueNrCap->featureSets)
9040    {
9041       featureSets = ueNrCap->featureSets;
9042       if(featureSets->featureSetsDownlinkPerCC)
9043       {
9044          if(featureSets->featureSetsDownlinkPerCC->list.array)
9045          {
9046             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
9047             {
9048                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
9049                {
9050                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
9051                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
9052                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
9053                }
9054             }
9055             free(featureSets->featureSetsDownlinkPerCC->list.array);
9056          }
9057          free(featureSets->featureSetsDownlinkPerCC);
9058       }
9059       if(featureSets->featureSetsUplinkPerCC)
9060       {
9061          if(featureSets->featureSetsUplinkPerCC->list.array)
9062          {
9063             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
9064             {
9065                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
9066                {
9067                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
9068                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
9069                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
9070                }
9071             }
9072             free(featureSets->featureSetsUplinkPerCC->list.array);
9073          }
9074          free(featureSets->featureSetsUplinkPerCC);
9075       }
9076       free(ueNrCap->featureSets);
9077    }
9078 }
9079
9080 /*******************************************************************
9081 *
9082 * @brief Function to free PdcchSearchSpcToAddModList
9083          where memory allocated by aper_decoder
9084 *
9085 * @details
9086 *
9087 *    Function : freeAperDecodePdcchSearchSpcToAddModList
9088 *
9089 *    Functionality: Function to free PdcchSearchSpcToAddModList
9090 *
9091 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
9092 * @return void
9093 *
9094 * ****************************************************************/
9095
9096 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
9097 {
9098    uint8_t searchSpcArrIdx=0;
9099    uint8_t searchSpcArrIdx1=0;
9100    struct  SearchSpace *searchSpc=NULLP;
9101
9102
9103    if(searchSpcList->list.array)
9104    {
9105       if(searchSpcList->list.array[searchSpcArrIdx1])
9106       {
9107          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
9108          if(searchSpc->controlResourceSetId)
9109          {
9110             if(searchSpc->monitoringSlotPeriodicityAndOffset)
9111             {
9112                if(searchSpc->monitoringSymbolsWithinSlot)
9113                {
9114                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
9115                   {
9116                      if(searchSpc->nrofCandidates)
9117                      {
9118                         if(searchSpc->searchSpaceType)
9119                         {
9120                            free(searchSpc->searchSpaceType->choice.ue_Specific);
9121                            free(searchSpc->searchSpaceType);
9122                         }
9123                         free(searchSpc->nrofCandidates);
9124                      }
9125                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
9126                   }
9127                   free(searchSpc->monitoringSymbolsWithinSlot);
9128                }
9129                free(searchSpc->monitoringSlotPeriodicityAndOffset);
9130             }
9131             free(searchSpc->controlResourceSetId);
9132          }
9133       }
9134       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
9135       {
9136          free(searchSpcList->list.array[searchSpcArrIdx]);
9137       }
9138       free(searchSpcList->list.array);
9139    }
9140 }
9141 /*******************************************************************
9142 *
9143 * @brief Function for free part for the memory allocated by aper_decoder
9144 *
9145 * @details
9146 *
9147 *    Function : freeAperDecodeBWPDlDedPdcchConfig
9148 *
9149 *    Functionality: Function to free BWPDlDedPdcchConfig
9150 *
9151 * @params[in]
9152 * @return void
9153 *
9154 * ****************************************************************/
9155
9156
9157 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
9158 {
9159    uint8_t arrIdx1=0;
9160    uint8_t arrIdx2=0;
9161    struct PDCCH_Config *pdcchCfg=NULLP;
9162    struct ControlResourceSet *controlRSet=NULLP;
9163    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
9164
9165    if(dlBwp->pdcch_Config->choice.setup)
9166    {
9167       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
9168       if(pdcchCfg->controlResourceSetToAddModList)
9169       {
9170          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
9171          if(controlRSetList->list.array)
9172          {
9173             controlRSet = controlRSetList->list.array[arrIdx2];
9174             if(controlRSet)
9175             {
9176                if(controlRSet->frequencyDomainResources.buf)
9177                {
9178                   if(controlRSet->pdcch_DMRS_ScramblingID)
9179                   {
9180                      if(pdcchCfg->searchSpacesToAddModList)
9181                      {
9182                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
9183                         free(pdcchCfg->searchSpacesToAddModList);
9184                      }
9185                      free(controlRSet->pdcch_DMRS_ScramblingID);
9186                   }
9187                   free(controlRSet->frequencyDomainResources.buf);
9188                }
9189             }
9190             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
9191             {
9192                free(controlRSetList->list.array[arrIdx1]);
9193             }
9194             free(controlRSetList->list.array);
9195          }
9196          free(pdcchCfg->controlResourceSetToAddModList);
9197       }
9198       free(dlBwp->pdcch_Config->choice.setup);
9199    }
9200 }
9201 /*******************************************************************
9202 *
9203 * @brief Function to free PdschTimeDomAllocationList
9204 *     where the memory allocated by aper_decoder
9205 *
9206 * @details
9207 *
9208 *    Function : freeAperDecodePdschTimeDomAllocationList
9209 *
9210 *    Functionality: Function to free PdschTimeDomAllocationList
9211 *
9212 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
9213 * @return void
9214 *
9215 * ****************************************************************/
9216
9217
9218 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
9219 {
9220    uint8_t arrIdx=0;
9221
9222    if(timeDomAllocList->choice.setup)
9223    {
9224       if(timeDomAllocList->choice.setup->list.array)
9225       {
9226          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
9227          {
9228             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
9229          }
9230          free(timeDomAllocList->choice.setup->list.array);
9231       }
9232       free(timeDomAllocList->choice.setup);
9233    }
9234 }
9235
9236 /*******************************************************************
9237 *
9238 * @brief Function to free BWPDlDedPdschConfig
9239 *        where the memory allocated by aper_decoder
9240 *
9241 * @details
9242 *
9243 *    Function : freeAperDecodeBWPDlDedPdschConfig
9244 *
9245 *    Functionality: Function to free BWPDlDedPdschConfig
9246 *
9247 * @params[in] BWP_DownlinkDedicated_t *dlBwp
9248 * @return void
9249 *
9250 * ****************************************************************/
9251
9252
9253 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
9254 {
9255    struct PDSCH_Config *pdschCfg=NULLP;
9256    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
9257    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
9258    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
9259
9260    if(dlBwp->pdsch_Config->choice.setup)
9261    {
9262       pdschCfg=dlBwp->pdsch_Config->choice.setup;
9263       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
9264       {
9265          if(pdschCfg->pdsch_TimeDomainAllocationList)
9266          {
9267             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
9268             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
9269             {
9270                prbBndlType=&pdschCfg->prb_BundlingType;
9271                free(prbBndlType->choice.staticBundling);
9272                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
9273             }
9274             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
9275             free(pdschCfg->pdsch_TimeDomainAllocationList);
9276          }
9277          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
9278          if(dmrsDlCfg->choice.setup)
9279          {
9280             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
9281             free(dmrsDlCfg->choice.setup);
9282          }
9283          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
9284       }
9285       free(dlBwp->pdsch_Config->choice.setup);
9286    }
9287 }
9288 /*******************************************************************
9289 *
9290 * @brief Function to free PuschTimeDomAllocListCfg
9291                  where the memory allocated by aper_decoder
9292 *
9293 * @details
9294 *
9295 *    Function : freeAperDecodePuschTimeDomAllocListCfg
9296 *
9297 *    Functionality: Function to free PuschTimeDomAllocListCfg
9298 *
9299 * @params[in] PUSCH_Config_t *puschCfg
9300 * @return void
9301 *
9302 * ****************************************************************/
9303
9304
9305 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
9306 {
9307    uint8_t arrIdx=0;
9308    uint8_t arrIdx1=0;
9309    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
9310
9311    if(puschCfg->pusch_TimeDomainAllocationList)
9312    {
9313       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
9314       if(timeDomAllocList_t->choice.setup)
9315       {
9316          if(timeDomAllocList_t->choice.setup->list.array)
9317          {
9318             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
9319             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
9320             {
9321                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
9322             }
9323             free(timeDomAllocList_t->choice.setup->list.array);
9324          }
9325          free(timeDomAllocList_t->choice.setup);
9326       }
9327       free(puschCfg->transformPrecoder);
9328       free(puschCfg->pusch_TimeDomainAllocationList);
9329    }
9330 }
9331 /*******************************************************************
9332 *
9333 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
9334 *
9335 * @details
9336 *
9337 *    Function : freeAperDecodeInitialUlBWPConfig
9338 *
9339 *    Functionality: Function to free InitialUlBWPConfig
9340 *
9341 * @params[in]  BWP_UplinkDedicated_t *ulBwp
9342 * @return void
9343 *
9344 * ****************************************************************/
9345
9346
9347 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
9348 {
9349    uint8_t  rSetIdx =0;
9350    uint8_t  rsrcIdx =0;
9351    SRS_Config_t   *srsCfg = NULLP;
9352    PUSCH_Config_t *puschCfg = NULLP;
9353    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
9354    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
9355    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
9356    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
9357
9358    if(ulBwp->pusch_Config)
9359    {
9360       if(ulBwp->pusch_Config->choice.setup)
9361       {
9362          puschCfg=ulBwp->pusch_Config->choice.setup;
9363          if(puschCfg->dataScramblingIdentityPUSCH)
9364          {
9365             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
9366             {
9367                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
9368                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
9369                if(dmrsUlCfg->choice.setup)
9370                {
9371                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
9372                   {
9373                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
9374                      {
9375                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
9376                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
9377                      }
9378                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
9379                   }
9380                   free(dmrsUlCfg->choice.setup);
9381                }
9382                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
9383             }
9384             free(puschCfg->dataScramblingIdentityPUSCH);
9385          }
9386          free(ulBwp->pusch_Config->choice.setup);
9387       }
9388       free(ulBwp->pusch_Config);
9389
9390       /* Free SRS-Config */
9391       if(ulBwp->srs_Config)
9392       {
9393          if(ulBwp->srs_Config->choice.setup)
9394          {
9395             srsCfg = ulBwp->srs_Config->choice.setup;
9396
9397             /* Free Resource Set to add/mod list */
9398             if(srsCfg->srs_ResourceSetToAddModList)
9399             {
9400                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
9401                if(rsrcSetList->list.array)
9402                {
9403                   rSetIdx = 0;
9404
9405                   /* Free SRS resource Id list in this SRS resource set */
9406                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
9407                   {
9408                      rsrcIdList =
9409                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
9410
9411                      if(rsrcIdList->list.array)
9412                      {
9413                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
9414                               rsrcIdx++)
9415                         {
9416                            free(rsrcIdList->list.array[rsrcIdx]);
9417                         }
9418                         free(rsrcIdList->list.array);
9419                      }
9420                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
9421                   }
9422
9423                   /* Free resource type info for this SRS resource set */
9424
9425                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
9426
9427                   /* Free memory for each resource set */
9428                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
9429                   {
9430                      free(rsrcSetList->list.array[rSetIdx]);
9431                   }
9432                   free(rsrcSetList->list.array);
9433                }
9434                free(srsCfg->srs_ResourceSetToAddModList);
9435             }
9436
9437             /* Free resource to add/modd list */
9438             if(srsCfg->srs_ResourceToAddModList)
9439             {
9440                resourceList = srsCfg->srs_ResourceToAddModList;
9441                if(resourceList->list.array)
9442                {
9443                   rsrcIdx = 0;
9444
9445                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
9446                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
9447
9448                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
9449                   {
9450                      free(resourceList->list.array[rsrcIdx]);
9451                   }
9452                   free(resourceList->list.array);
9453                }
9454                free(srsCfg->srs_ResourceToAddModList);
9455             }
9456
9457             free(ulBwp->srs_Config->choice.setup);
9458          }
9459          free(ulBwp->srs_Config);
9460       }
9461    }
9462 }
9463 /*******************************************************************
9464 *
9465 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
9466 *
9467 * @details
9468 *
9469 *    Function : freeAperDecodeinitialUplinkBWPConfig
9470 *
9471 *    Functionality: Function to free initialUplinkBWPConfig
9472 *
9473 * @params[in] UplinkConfig_t *ulCfg
9474 * @return void
9475 *
9476 * ****************************************************************/
9477
9478
9479 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
9480 {
9481    BWP_UplinkDedicated_t *ulBwp=NULLP;
9482    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
9483
9484    if(ulCfg->initialUplinkBWP)
9485    {
9486       ulBwp=ulCfg->initialUplinkBWP;
9487       if(ulCfg->firstActiveUplinkBWP_Id)
9488       {
9489          if(ulCfg->pusch_ServingCellConfig)
9490          {
9491             puschCfg=ulCfg->pusch_ServingCellConfig;
9492             if(puschCfg->choice.setup)
9493             {
9494                if(puschCfg->choice.setup->ext1)
9495                {
9496                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
9497                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
9498                   free(puschCfg->choice.setup->ext1);
9499                }
9500                free(puschCfg->choice.setup);
9501             }
9502             free(ulCfg->pusch_ServingCellConfig);
9503          }
9504          free(ulCfg->firstActiveUplinkBWP_Id);
9505       }
9506       freeAperDecodeInitialUlBWPConfig(ulBwp);
9507       free(ulCfg->initialUplinkBWP);
9508    }
9509 }
9510
9511 /*******************************************************************
9512  *
9513  * @brief Function to free DuUeCfg
9514  *
9515  * @details
9516  *
9517  *    Function : freeDuUeCfg
9518  *
9519  *    Functionality: Function to free DuUeCfg
9520  *
9521  * @params[in] DuUeCfg *ueCfg
9522  * @return void
9523  *
9524  * ****************************************************************/
9525 void freeDuUeCfg(UeCtxtActionType actionType, DuUeCfg *ueCfg)
9526 {
9527    uint8_t lcIdx = 0;
9528    uint8_t arrIdx = 0;
9529    SpCellConfig_t *spCellCfg = NULLP;
9530    ServingCellConfig_t *srvCellCfg = NULLP;
9531    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9532    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
9533    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9534    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
9535    struct RLC_Config *rlcConfig = NULLP;
9536    struct LogicalChannelConfig *macLcConfig = NULLP;
9537    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
9538    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
9539    struct TAG_Config *tagConfig = NULLP;
9540    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
9541    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
9542    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
9543    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
9544
9545    if(ueCfg->ueNrCapability)
9546    {
9547       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
9548       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
9549       ueCfg->ueNrCapability = NULLP;
9550    }
9551
9552    if(ueCfg->cellGrpCfg)
9553    {
9554       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
9555       if(rlcBearerList)
9556       {
9557          if(rlcBearerList->list.array)
9558          {
9559             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
9560             {
9561                if(rlcBearerList->list.array[arrIdx])
9562                {
9563                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
9564                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
9565
9566                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
9567                   {
9568                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
9569                   }
9570                   if(rlcConfig)
9571                   {
9572                      if(rlcConfig->choice.am)
9573                      {
9574                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
9575                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
9576                         free(rlcConfig->choice.am);
9577                      }
9578                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
9579                   }
9580                   if(macLcConfig)
9581                   {
9582                      if(macLcConfig->ul_SpecificParameters)
9583                      {
9584                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
9585                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
9586                         free(macLcConfig->ul_SpecificParameters);
9587                      }
9588                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
9589                   }
9590                   free(rlcBearerList->list.array[arrIdx]);
9591                }
9592             }
9593             free(rlcBearerList->list.array);
9594          }
9595          free(cellGrpCfg->rlc_BearerToAddModList);
9596       }
9597
9598       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
9599       if(macCellGrpCfg)
9600       {
9601          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
9602          if(schedulingRequestConfig)
9603          {
9604             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
9605             if(schReqList)
9606             {
9607                if(schReqList->list.array)
9608                {
9609                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
9610                   {
9611                      if(schReqList->list.array[arrIdx])
9612                      {
9613                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
9614                         free(schReqList->list.array[arrIdx]);
9615                      }
9616                   }
9617                   free(schReqList->list.array);
9618                }
9619                free(schedulingRequestConfig->schedulingRequestToAddModList);
9620             }
9621             free(macCellGrpCfg->schedulingRequestConfig);
9622          }
9623          if(macCellGrpCfg->bsr_Config)
9624          {
9625             free(macCellGrpCfg->bsr_Config);
9626          }
9627          tagConfig = macCellGrpCfg->tag_Config;
9628          if(tagConfig)
9629          {
9630             tagList = tagConfig->tag_ToAddModList;
9631             if(tagList)
9632             {
9633                if(tagList->list.array)
9634                {
9635                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
9636                   {
9637                      free(tagList->list.array[arrIdx]);
9638                   }
9639                   free(tagList->list.array);
9640                }
9641                free(tagConfig->tag_ToAddModList);
9642             }
9643             free(tagConfig);
9644          }
9645
9646          phrConfig = macCellGrpCfg->phr_Config;
9647          if(phrConfig)
9648          {
9649             free(phrConfig->choice.setup);
9650             free(phrConfig);
9651          }
9652
9653          free(macCellGrpCfg);
9654       }
9655
9656       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
9657       if(phyCellGrpCfg)
9658       {
9659          free(phyCellGrpCfg->p_NR_FR1);
9660          free(phyCellGrpCfg);
9661       }
9662
9663       spCellCfg = cellGrpCfg->spCellConfig;
9664       if(spCellCfg)
9665       {
9666          if(spCellCfg->servCellIndex)
9667          {
9668             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
9669             {
9670                if(spCellCfg->spCellConfigDedicated)
9671                {
9672                   srvCellCfg = spCellCfg->spCellConfigDedicated;
9673                   if(srvCellCfg->initialDownlinkBWP)
9674                   {
9675                      dlBwp = srvCellCfg->initialDownlinkBWP;
9676                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
9677                      {
9678                         if(srvCellCfg->defaultDownlinkBWP_Id)
9679                         {
9680                            if(srvCellCfg->uplinkConfig)
9681                            {
9682
9683                               if(srvCellCfg->pdsch_ServingCellConfig)
9684                               {
9685                                  pdschCfg=
9686                                     srvCellCfg->pdsch_ServingCellConfig;
9687                                  if(pdschCfg->choice.setup)
9688                                  {
9689
9690                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
9691                                     free(pdschCfg->choice.setup);
9692                                  }
9693
9694                                  free(srvCellCfg->pdsch_ServingCellConfig);
9695                               }
9696
9697                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
9698                               free(srvCellCfg->uplinkConfig);
9699                            }
9700                            free(srvCellCfg->defaultDownlinkBWP_Id);
9701                         }
9702
9703                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
9704                      }
9705                      if(dlBwp->pdcch_Config)
9706                      {
9707                         if(dlBwp->pdsch_Config)
9708                         {
9709                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
9710                            free(dlBwp->pdsch_Config);
9711                         }
9712                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
9713                         free(dlBwp->pdcch_Config);
9714                      }
9715                      free(srvCellCfg->initialDownlinkBWP);
9716                   }
9717
9718                   free(spCellCfg->spCellConfigDedicated);
9719                }
9720                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
9721             }
9722             free(spCellCfg->servCellIndex);
9723          }
9724          free(spCellCfg);
9725       }
9726       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9727       ueCfg->cellGrpCfg = NULLP;
9728    }
9729
9730    if(ueCfg->ambrCfg)
9731    {
9732       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
9733    }
9734
9735    if(actionType != UE_CTXT_CFG_QUERY)
9736    {
9737       for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
9738       {
9739          freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
9740       }
9741    }
9742
9743    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
9744    {
9745       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx].lcConfig);
9746    }
9747
9748    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
9749    {
9750       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
9751    }
9752 }
9753
9754 /*******************************************************************
9755  *
9756  * @brief Function to free UecontextSetupDb
9757  *
9758  * @details
9759  *
9760  *    Function : freeF1UeDb
9761  *
9762  *    Functionality: Function to free UecontextSetupDb
9763  *
9764  * @params[in] UecontextSetupDb *
9765  * @return void
9766  *
9767  * ****************************************************************/
9768
9769 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
9770 {
9771
9772    if(f1UeDb->dlRrcMsg)
9773    {
9774       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
9775       {
9776         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
9777                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
9778       }
9779       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
9780    }
9781    freeDuUeCfg(f1UeDb->actionType, &f1UeDb->duUeCfg);
9782    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
9783    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
9784 }
9785
9786 /*******************************************************************
9787  *
9788  * @brief Function to build Am cfg Info
9789  *
9790  * @details
9791  *
9792  *    Function : extractRlcAmCfg
9793  *
9794  *    Functionality: Function to build Am cfg Info
9795  *
9796  * @params[in] AmBearerCfg *
9797  *             void *
9798  *
9799  * @return ROK/RFAILED
9800  *
9801  * ****************************************************************/
9802
9803 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
9804 {
9805    if(rlcAmCfg)
9806    {
9807       /* UL AM */
9808       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
9809       {
9810          amCfgToSet->ulAmCfg.snLenUl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->dl_AM_RLC.sn_FieldLength));
9811          /*TODO: Check the timer value when sent by real CU */
9812          amCfgToSet->ulAmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_Reassembly);
9813          amCfgToSet->ulAmCfg.statProhTmr = convertProhibitTmrEnumToValue(rlcAmCfg->dl_AM_RLC.t_StatusProhibit);
9814       }
9815
9816       /* DL AM */
9817       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
9818       {
9819          amCfgToSet->dlAmCfg.snLenDl = covertAmSnLenFromRrcEnumToIntEnum(*(rlcAmCfg->ul_AM_RLC.sn_FieldLength));
9820          amCfgToSet->dlAmCfg.pollRetxTmr = covertPollRetxTmrEnumToValue(rlcAmCfg->ul_AM_RLC.t_PollRetransmit);
9821          amCfgToSet->dlAmCfg.pollPdu   = covertPollPduEnumToValue(rlcAmCfg->ul_AM_RLC.pollPDU);
9822          amCfgToSet->dlAmCfg.pollByte  = covertPollByteEnumToValue(rlcAmCfg->ul_AM_RLC.pollByte);
9823          amCfgToSet->dlAmCfg.maxRetxTh = covertMaxRetxEnumToValue(rlcAmCfg->ul_AM_RLC.maxRetxThreshold);
9824       }
9825    }
9826 }
9827
9828 /*******************************************************************
9829  *
9830  * @brief Function to build Um Bi Info
9831  *
9832  * @details
9833  *
9834  *    Function : extractRlcUmBiCfg
9835  *
9836  *    Functionality: Function to build Um Bi Info
9837  *
9838  * @params[in] UmBiDirBearerCfg *
9839  *             void *
9840  *
9841  * @return ROK/RFAILED
9842  *
9843  * ****************************************************************/
9844
9845 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
9846 {
9847    if(rlcBiCfg)
9848    {
9849       /* UL UM BI DIR Cfg */
9850       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
9851       {
9852          umBiCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->dl_UM_RLC.sn_FieldLength));
9853          umBiCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(rlcBiCfg->dl_UM_RLC.t_Reassembly);
9854       }
9855
9856       /* DL UM BI DIR Cfg */
9857       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
9858          umBiCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(rlcBiCfg->ul_UM_RLC.sn_FieldLength));
9859    }
9860 }
9861
9862 /*******************************************************************
9863  *
9864  * @brief Function to build Um Ul Info
9865  *
9866  * @details
9867  *
9868  *    Function : extractRlcUmUlCfg
9869  *
9870  *    Functionality: Function to build Um Ul Info
9871  *
9872  * @params[in] UmUniDirUlBearerCfg *
9873  *             void *
9874  *
9875  * @return ROK/RFAILED
9876  *
9877  * ****************************************************************/
9878
9879 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
9880 {
9881    if(umUlCfg)
9882    {
9883       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
9884       {
9885          umUlCfgToSet->ulUmCfg.snLenUlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umUlCfg->dl_UM_RLC.sn_FieldLength));
9886          umUlCfgToSet->ulUmCfg.reAssemTmr = convertReasmblTmrEnumToValue(umUlCfg->dl_UM_RLC.t_Reassembly);
9887       }
9888    }
9889 }
9890
9891 /*******************************************************************
9892  *
9893  * @brief Function to build Um Uni Dl Info
9894  *
9895  * @details
9896  *
9897  *    Function : extractRlcUmDlCfg
9898  *
9899  *    Functionality: Function to build Um Uni Dl Info
9900  *
9901  * @params[in] UmUniDirDlBearerCfg *
9902  *             void *
9903  *
9904  * @return ROK/RFAILED
9905  *
9906  * ****************************************************************/
9907 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
9908 {
9909    if(umDlCfg)
9910    {
9911       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
9912          umDlCfgToSet->dlUmCfg.snLenDlUm  = covertUmSnLenFromRrcEnumToIntEnum(*(umDlCfg->ul_UM_RLC.sn_FieldLength));
9913    }
9914 }
9915
9916 /*******************************************************************
9917  *
9918  * @brief Function to extractRlcModeCfg
9919  *
9920  * @details
9921  *
9922  *    Function : extractRlcModeCfg
9923  *
9924  *    Functionality: Function to extractRlcModeCfg
9925  *
9926  * @params[in] RLC_Config_t *
9927  *             RlcBearerCfg *
9928  *             void  *
9929  * @return ROK/RFAILED
9930  *
9931  * ****************************************************************/
9932 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
9933 {
9934    if(lcCfg)
9935    {
9936       switch(rlcMode)
9937       {
9938          case RLC_AM :
9939             {
9940                if(lcCfg->choice.am)
9941                {
9942                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
9943                   if(rlcDbCfg->u.amCfg)
9944                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
9945                }
9946                break;
9947             }
9948          case RLC_UM_BI_DIRECTIONAL :
9949             {
9950                if(lcCfg->choice.um_Bi_Directional)
9951                {
9952                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
9953                   if(rlcDbCfg->u.umBiDirCfg)
9954                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
9955                }
9956                break;
9957             }
9958          case RLC_UM_UNI_DIRECTIONAL_UL :
9959             {
9960                if(lcCfg->choice.um_Uni_Directional_DL)
9961                {
9962                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
9963                   if(rlcDbCfg->u.umUniDirUlCfg)
9964                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
9965                }
9966                break;
9967             }
9968          case RLC_UM_UNI_DIRECTIONAL_DL :
9969             {
9970                if(lcCfg->choice.um_Uni_Directional_UL)
9971                {
9972                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
9973                   if(rlcDbCfg->u.umUniDirDlCfg)
9974                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
9975                }
9976                break;
9977             }
9978          default:
9979             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
9980             break;
9981       }
9982    }
9983 }
9984
9985 /*******************************************************************
9986  *
9987  * @brief Function to extract extractUlLcCfg
9988  *
9989  * @details
9990  *
9991  *    Function : extractUlLcCfg
9992  *
9993  *    Functionality: Function to extract extractUlLcCfg
9994  *
9995  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
9996  * @return void
9997  *
9998  * ****************************************************************/
9999
10000 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
10001 {
10002    if(ulLcCfg)
10003    {
10004       if(ulLcCfg->ul_SpecificParameters)
10005       {
10006          f1UlLcCfg->priority = \
10007             ulLcCfg->ul_SpecificParameters->priority;
10008       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
10009       {
10010          f1UlLcCfg->lcGroup = \
10011            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
10012       }
10013       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
10014       {
10015          f1UlLcCfg->schReqId = \
10016            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
10017       }
10018       f1UlLcCfg->pbr = \
10019          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
10020       f1UlLcCfg->bsd = \
10021          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
10022       }
10023    }
10024 }
10025
10026 /*******************************************************************
10027 *
10028 * @brief Function to extract Snssai Cfg Info from CU
10029 *
10030 * @details
10031 *
10032 *    Function : extractDrbSnssaiCfg
10033 *
10034 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
10035 *
10036 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
10037 * @return ROK/RFAILED
10038 *
10039 * ****************************************************************/
10040
10041 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
10042 {
10043    if(!(*snssaiToBeShared))
10044    {
10045       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
10046       if(snssaiToBeShared == NULLP)
10047       {
10048          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
10049          return RFAILED;
10050       }
10051    }
10052    if(RecvSnssai)
10053    {
10054       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
10055       if(RecvSnssai->sD)
10056       {
10057          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
10058       }
10059       else
10060       {
10061          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
10062          return RFAILED;
10063       }
10064    }
10065    return ROK;
10066 }
10067
10068 /*******************************************************************
10069  *
10070  * @brief Function to procRlcLcCfg
10071  *
10072  * @details
10073  *
10074  *    Function : procRlcLcCfg
10075  *
10076  *    Functionality: Function to procRlcLcCfg
10077  *
10078  * @params[in] rbId, lcId, rbType, rlcMod
10079  *             RLC_Config_t *, RlcBearerCfg * ,
10080  * @return void
10081  *
10082  * ****************************************************************/
10083
10084 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
10085    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
10086 {
10087    DRB_Information_t *drbInfo;
10088
10089    lcCfg->rbId   = rbId;
10090    lcCfg->configType = configType;
10091
10092    if(rbType == RB_TYPE_SRB)
10093    {
10094       lcCfg->rbType = RB_TYPE_SRB;
10095       lcCfg->lcId   = rbId;
10096       lcCfg->lcType = LCH_DCCH;
10097       lcCfg->rlcMode = RLC_AM;
10098    }
10099    else if(rbType == RB_TYPE_DRB)
10100    {
10101       lcCfg->rbType = RB_TYPE_DRB;
10102       lcCfg->lcId   = lcId;
10103       lcCfg->lcType = LCH_DTCH;
10104       lcCfg->rlcMode = rlcMode;
10105    }
10106    if(f1RlcCfg) /* rlc mode config recived */
10107    {
10108       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
10109    }
10110    if(qoSInformation != NULLP)
10111    {
10112       if(qoSInformation->present == QoSInformation_PR_choice_extension)
10113       {
10114          if(qoSInformation->choice.choice_extension->value.present ==\
10115                QoSInformation_ExtIEs__value_PR_DRB_Information)
10116          {
10117             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10118             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
10119             {
10120                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
10121                return;
10122             }
10123          }
10124       }
10125    }
10126 }
10127
10128 /*******************************************************************
10129  *
10130  * @brief Fills DrbQos Info received by CU
10131  *
10132  * @details
10133  *
10134  *    Function : extractQosInfo
10135  *
10136  *    Functionality: Fills DrbQos Info received  by CU
10137  *
10138  * @params[in] DrbQosInfo *qosToAdd,
10139  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
10140  * @return void
10141  *
10142  * ****************************************************************/
10143
10144 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
10145 {
10146    uint8_t qosCntIdx = 0;
10147    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
10148
10149    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
10150    qosToAdd->u.nonDyn5Qi.fiveQi     =\
10151                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
10152    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
10153    {
10154       qosToAdd->u.nonDyn5Qi.avgWindow = \
10155                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
10156    }
10157
10158    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume)
10159    {
10160       qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
10161                                               *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
10162    }
10163
10164    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
10165    {
10166       qosToAdd->u.nonDyn5Qi.priorLevel = \
10167                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
10168    }
10169    qosToAdd->ngRanRetPri.priorityLevel = \
10170                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
10171    qosToAdd->ngRanRetPri.preEmptionCap = \
10172                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
10173    qosToAdd->ngRanRetPri.preEmptionVul = \
10174                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
10175    if(qosFlowCfg->gBR_QoS_Flow_Information)
10176    {
10177       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
10178             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
10179             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
10180       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
10181             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
10182             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
10183       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
10184             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
10185             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
10186       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
10187             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
10188             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
10189    }
10190    /*Extracting PDU_SESSION_ID*/
10191    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
10192    if(qosIeExt)
10193    {
10194       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
10195       {
10196          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
10197                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
10198          {
10199             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
10200             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
10201          }
10202       }
10203    }
10204    qosToAdd->ulPduSessAggMaxBitRate = 0;
10205 }
10206
10207 /*******************************************************************
10208  *
10209  * @brief Function to extract GTP Tunnel Info from CU
10210  *
10211  * @details
10212  *
10213  *    Function : extractUpTnlInfo
10214  *
10215  *    Functionality: Function to extract GTP Tunnel Info from CU
10216  *
10217  * @params[in] F1AP message
10218  * @return ROK/RFAILED
10219  *
10220  * ****************************************************************/
10221
10222 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
10223    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
10224 {
10225    uint8_t tnlIdx;
10226    uint32_t ipv4_du = 0;
10227    GTPTunnel_t *gtpTunnel = NULLP;
10228
10229    upTnlInfo->drbId = drbId;
10230    upTnlInfo->configType = configType;
10231 #ifdef O1_ENABLE
10232    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
10233 #else
10234    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
10235 #endif
10236
10237    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
10238    {
10239       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
10240       {
10241          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
10242          {
10243             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
10244             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
10245             if(upTnlInfo->tnlCfg1 == NULLP)
10246             {
10247                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
10248                return RFAILED;
10249             }
10250             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
10251             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
10252             if(gtpTunnel->gTP_TEID.size > 0)
10253             {
10254                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
10255             }
10256          }
10257          break;
10258       }
10259    }
10260    return ROK;
10261 }
10262
10263 /*******************************************************************
10264 *
10265 * @brief Function to extract Drb Qos Cfg Info from CU
10266 *
10267 * @details
10268 *
10269 *    Function : extractDrbQosCfg
10270 *
10271 *    Functionality: Function to extract Drb Qos Cfg Info from CU
10272 *
10273 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
10274 * @return ROK/RFAILED
10275 *
10276 * ****************************************************************/
10277
10278 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
10279 {
10280    if(!macLcToAdd->drbQos)
10281    {
10282       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
10283       if(macLcToAdd->drbQos == NULLP)
10284       {
10285          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
10286          return RFAILED;
10287       }
10288
10289    }
10290    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
10291    {
10292       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
10293       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
10294    }
10295    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
10296    {
10297       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
10298       return RFAILED;
10299    }
10300    return ROK;
10301 }
10302 /*******************************************************************
10303  *
10304  * @brief Function to extract DRB info received from CU
10305  *
10306  * @details
10307  *
10308  *    Function : extractDrbCfg
10309  *
10310  *    Functionality: Function to extract DRB info received from CU
10311  *
10312  * @params[in] F1AP message
10313  * @return void
10314  *
10315  * ****************************************************************/
10316 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
10317 DRBs_ToBeModified_Item_t *drbModItem,  DuLcCfg *lcCfgToAdd, UpTnlCfg *upTnlInfo)
10318 {
10319    DRB_Information_t *drbInfo = NULLP;
10320
10321    if(drbItem != NULLP)
10322    {
10323       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
10324       {
10325          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10326          return RFAILED;
10327       }
10328       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10329       {
10330          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
10331          {
10332             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10333             if(extractDrbQosCfg(drbInfo , &lcCfgToAdd->lcConfig) != ROK)
10334             {
10335                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10336                return RFAILED;
10337             }
10338          }
10339       }
10340    }
10341    else if(drbSetupModItem != NULLP)
10342    {
10343       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
10344       upTnlInfo) != ROK)
10345       {
10346          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10347          return RFAILED;
10348       }
10349       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
10350       {
10351          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
10352          QoSInformation_ExtIEs__value_PR_DRB_Information)
10353          {
10354             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
10355             if(extractDrbQosCfg(drbInfo , &lcCfgToAdd->lcConfig) != ROK)
10356             {
10357                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10358                return RFAILED;
10359             }
10360
10361          }
10362       }
10363    }
10364    else if(drbModItem != NULLP)
10365    {
10366       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
10367       upTnlInfo) != ROK)
10368       {
10369          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
10370          return RFAILED;
10371       }
10372       if(drbModItem->qoSInformation != NULLP)
10373       {
10374          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
10375          {
10376             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
10377                   QoSInformation_ExtIEs__value_PR_DRB_Information)
10378             {
10379                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
10380                if(extractDrbQosCfg(drbInfo , &lcCfgToAdd->lcConfig) != ROK)
10381                {
10382                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
10383                   return RFAILED;
10384                }
10385
10386             }
10387          }
10388       }
10389    }
10390    return ROK;
10391 }
10392
10393 /*******************************************************************
10394  *
10395  * @brief Function to extract RB info received from CU
10396  *
10397  * @details
10398  *
10399  *    Function : extractMacRbCfg
10400  *
10401  *    Functionality: Function to extract RB info received from CU
10402  *
10403  * @params[in] F1AP message
10404  * @return ROK/RFAILED
10405  *
10406  * ****************************************************************/
10407
10408 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
10409 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, DuLcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10410 {
10411    if(drbCfg != NULLP)
10412    {
10413       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
10414       {
10415          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10416          return RFAILED;
10417       }
10418    }
10419    else if(drbSetupModCfg != NULLP)
10420    {
10421       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
10422       {
10423          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10424          return RFAILED;
10425       }
10426    }
10427    else if(drbModCfg != NULLP)
10428    {
10429       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
10430       {
10431          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
10432          return RFAILED;
10433       }
10434    }
10435    else
10436    {
10437       lcCfg->lcConfig.drbQos = NULLP;
10438       lcCfg->lcConfig.snssai = NULLP;
10439       if(lcCfg->lcConfig.lcId == SRB2_LCID)
10440          lcCfg->lcConfig.dlLcCfg.lcp = LC_PRIORITY_3;
10441       else
10442          lcCfg->lcConfig.dlLcCfg.lcp = LC_PRIORITY_1;
10443
10444    }
10445    if(ulLcCfg)
10446    {
10447       lcCfg->lcConfig.ulLcCfgPres = true;
10448       extractUlLcCfg(&lcCfg->lcConfig.ulLcCfg, ulLcCfg);
10449    }
10450    else
10451       lcCfg->lcConfig.ulLcCfgPres = false;
10452    return ROK;
10453 }
10454
10455 /*******************************************************************
10456  *
10457  * @brief Function processing LC config info received from CU
10458  *
10459  * @details
10460  *
10461  *    Function : procMacLcCfg
10462  *
10463  *    Functionality: Function processing LC config info received from CU
10464  *
10465  * @params[in] F1AP message
10466  * @return ROK/RFAILED
10467  *
10468  * ****************************************************************/
10469
10470 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
10471 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
10472 DuLcCfg *lcCfg, UpTnlCfg *upTnlInfo)
10473 {
10474    uint8_t ret = ROK;
10475
10476    lcCfg->lcConfig.lcId = lcId;
10477    lcCfg->configType = configType;
10478    if(rbType == RB_TYPE_SRB)
10479    {
10480       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
10481    }
10482    else if(rbType == RB_TYPE_DRB && upTnlInfo != NULLP)
10483    {
10484       if(drbItem != NULL)
10485         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
10486       else if(drbSetupModItem != NULL)
10487         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
10488       else if(drbModItem != NULL)
10489         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
10490    }
10491    return ret;
10492 }
10493
10494 /*******************************************************************
10495  *
10496  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
10497  *
10498  * @details
10499  *
10500  *    Function : extractRlcCfgToAddMod
10501  *
10502  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
10503  *
10504  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
10505  *             DuUeCfg Pointer
10506  * @return ROK/RFAILED
10507  *
10508  * ****************************************************************/
10509
10510 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
10511 {
10512   uint8_t idx, rbId, lcId, rlcMode, rbType;
10513   RLC_Config_t *f1RlcCfg = NULLP;
10514   LogicalChannelConfig_t *macUlLcCfg = NULLP;
10515
10516   for(idx = 0; idx < lcCfg->list.count; idx++)
10517   {
10518      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
10519      if(lcCfg->list.array[idx]->servedRadioBearer)
10520      {
10521         /* RadioBearer for SRB/DRB */
10522         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10523         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
10524         {
10525            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
10526            rbType = RB_TYPE_SRB;
10527         }
10528         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
10529         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
10530         {
10531            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
10532            rbType = RB_TYPE_DRB;
10533         }
10534         else
10535         {
10536            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
10537            return RFAILED;
10538         }
10539         /* MAC UL LC Config */
10540         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
10541         {
10542            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
10543         }
10544      }
10545      else
10546      {
10547         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
10548         return RFAILED;
10549      }
10550      /* RLC Mode Config */
10551      if(lcCfg->list.array[idx]->rlc_Config)
10552      {
10553         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
10554         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
10555      }
10556
10557      /* Filling RLC/MAC Config*/
10558      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(DuLcCfg));
10559      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
10560      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
10561      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
10562      {
10563         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
10564         return RFAILED;
10565      }
10566      (ueCfgDb->numRlcLcs)++;
10567      (ueCfgDb->numMacLcs)++;
10568      DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10569         rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10570   }
10571   //TODO: To send the failure cause in UeContextSetupRsp
10572   return ROK;
10573 }
10574
10575 /*******************************************************************
10576  *
10577  * @brief DeAlloc pdsch serv cell config info
10578  *
10579  * @details
10580  *
10581  *    Function : freeMacPdschServCellInfo
10582  *
10583  *    Functionality: DeAlloc pdsch serv cell config info
10584  *
10585  * @params[in] PdschServCellCfg pointer
10586  * @return void
10587  *
10588  * ****************************************************************/
10589
10590 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
10591 {
10592    if(pdsch->xOverhead)
10593    {
10594       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
10595    }
10596    if(pdsch->codeBlkGrpFlushInd)
10597    {
10598       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
10599    }
10600    if(pdsch->maxCodeBlkGrpPerTb)
10601    {
10602       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
10603    }
10604    if(pdsch->maxMimoLayers)
10605    {
10606       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
10607    }
10608 }
10609
10610 /*******************************************************************
10611  *
10612  * @brief Free Serving cell Info
10613  *
10614  * @details
10615  *
10616  *    Function : freeMacServingCellInfo
10617  *
10618  *    Functionality: Free Serving cell Info
10619  *
10620  * @params[in] ServCellCfgInfo *srvCellCfg
10621  * @return void
10622  *
10623  * ****************************************************************/
10624 void freeMacServingCellInfo(ServCellRecfgInfo *srvCellCfg)
10625 {
10626    uint8_t timeDomRsrcIdx;
10627
10628    if(srvCellCfg->initDlBwp.pdschPresent)
10629    {
10630       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
10631       {
10632          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
10633             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
10634       }
10635    }
10636
10637    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
10638    if(srvCellCfg->bwpInactivityTmr)
10639    {
10640       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
10641    }
10642
10643    if(srvCellCfg->initUlBwp.pucchPresent)
10644    {
10645       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
10646    }
10647 }
10648
10649 /*******************************************************************
10650  *
10651  * @brief Free cell Grp Cfg Info
10652  *
10653  * @details
10654  *
10655  *    Function : freeUeRecfgCellGrpInfo
10656  *
10657  *    Functionality: Free cell Grp Cfg Info
10658  *
10659  * @params[in] DuMacUeCfg*  duUeCfg
10660  * @return void
10661  *
10662  * ****************************************************************/
10663
10664 void freeUeRecfgCellGrpInfo(DuMacUeCfg *macUeCfg)
10665 {
10666    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
10667 }
10668
10669 /*******************************************************************
10670  *
10671  * @brief Fills Reconfig SchReqReConfig
10672  *
10673  * @details
10674  *
10675  *    Function : extractSchReqReConfig
10676  *
10677  *    Functionality: Fills Reconfig SchReqReConfig
10678  *
10679  * @params[in] SchedulingRequestConfig_t *cuSchedReq
10680  *             SchedReqCfg*  macSchedReq
10681  * @return void
10682  *
10683  * ****************************************************************/
10684 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
10685 {
10686    uint8_t schReqIdx = 0;
10687    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
10688    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
10689
10690    if(cuSchedReq->schedulingRequestToAddModList)
10691    {
10692       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
10693       if(schReqListToAdd->list.count)
10694       {
10695          macSchedReq->addModListCount = schReqListToAdd->list.count;
10696          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
10697          {
10698             macSchedReq->addModList[schReqIdx].schedReqId = \
10699                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
10700             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
10701                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
10702             macSchedReq->addModList[schReqIdx].srTransMax    =\
10703                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
10704          }
10705       }
10706    }
10707    /* Scheduling Req To release */
10708    if(cuSchedReq->schedulingRequestToReleaseList)
10709    {
10710       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
10711       if(schReqListToRel->list.count)
10712       {
10713          macSchedReq->relListCount = schReqListToRel->list.count;
10714          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
10715          {
10716             macSchedReq->relList[schReqIdx] = \
10717                *schReqListToRel->list.array[schReqIdx];
10718          }
10719       }
10720    }
10721 }
10722
10723 /*******************************************************************
10724  *
10725  * @brief Fills TagReconfig
10726  *
10727  * @details
10728  *
10729  *    Function : extractTagReconfig
10730  *
10731  *    Functionality: Fills extractTagReconfig
10732  *
10733  * @params[in] TAG_Config_t *cuTagCfg
10734  *             TagCfg *macTagCfg
10735  * @return void
10736  *
10737  * ****************************************************************/
10738
10739 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
10740 {
10741   uint8_t tagIdx = 0;
10742   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
10743   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
10744
10745   /* Tag config to AddMod */
10746   if(cuTagCfg->tag_ToAddModList)
10747   {
10748      tagListToAddMod = cuTagCfg->tag_ToAddModList;
10749      if(tagListToAddMod->list.count)
10750      {
10751         macTagCfg->addModListCount = tagListToAddMod->list.count;
10752         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
10753         {
10754            macTagCfg->addModList[tagIdx].tagId =\
10755               tagListToAddMod->list.array[tagIdx]->tag_Id;
10756            macTagCfg->addModList[tagIdx].timeAlignTimer = \
10757
10758               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
10759         }
10760      }
10761   }
10762   /* Tag config to release */
10763   if(cuTagCfg->tag_ToReleaseList)
10764   {
10765      tagListToRel = cuTagCfg->tag_ToReleaseList;
10766      if(tagListToRel->list.count)
10767      {
10768         macTagCfg->relListCount = tagListToRel->list.count;
10769         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
10770         {
10771            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
10772         }
10773      }
10774   }
10775 }
10776
10777 /*******************************************************************
10778  *
10779  * @brief Fills PdcchCfg received by CU
10780  *
10781  * @details
10782  *
10783  *    Function : extractPdcchCfg
10784  *
10785  *    Functionality: Fills PdcchCfg received  by CU
10786  *
10787  * @params[in] PDCCH_Config_t *cuPdcchCfg,
10788  *             PdcchConfig *duPdcchCfg
10789  * @return void
10790  *
10791  * ****************************************************************/
10792
10793 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
10794 {
10795    uint8_t cRsetIdx = 0;
10796    uint8_t srchSpcIdx = 0;
10797
10798    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
10799    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
10800    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
10801    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
10802
10803
10804    /* Control Resource Set To Add/Mod List */
10805    if(cuPdcchCfg->controlResourceSetToAddModList)
10806    {
10807       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
10808       if(cRsetToAddModList->list.count)
10809       {
10810          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
10811          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
10812          {
10813             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
10814                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
10815             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
10816                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
10817             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
10818                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
10819                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
10820
10821             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
10822                 cRsetToAddModList->list.array[cRsetIdx]->duration;
10823
10824             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
10825                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
10826             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
10827             {
10828                //TODO: handle the case for Interleaved
10829             }
10830             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
10831                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
10832             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
10833             {
10834                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
10835                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
10836             }
10837          }
10838       }
10839    }
10840    /* Control Resource Set To Release List */
10841    if(cuPdcchCfg->controlResourceSetToReleaseList)
10842    {
10843       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
10844       if(cRsetToRelList->list.count)
10845       {
10846          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
10847          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
10848          {
10849             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
10850          }
10851       }
10852    }
10853
10854    /* Search space To Add/Mod List */
10855    if(cuPdcchCfg->searchSpacesToAddModList)
10856    {
10857       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
10858       if(srchSpcToAddModList->list.count)
10859       {
10860          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
10861          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
10862          {
10863             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
10864                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
10865             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
10866                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
10867             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
10868             {
10869                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
10870                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
10871             }
10872             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
10873             {
10874                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
10875                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
10876             }
10877             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
10878             {
10879                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
10880                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
10881                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
10882                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
10883                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
10884                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
10885
10886                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
10887                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
10888
10889                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
10890                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
10891             }
10892             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
10893             {
10894                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
10895                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
10896                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
10897                {
10898                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
10899                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
10900                }
10901
10902             }
10903          }
10904       }
10905    }
10906    /* Search space To Rel List */
10907    if(cuPdcchCfg->searchSpacesToReleaseList)
10908    {
10909       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
10910       if(srchSpcToRelList->list.count)
10911       {
10912          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
10913          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
10914          {
10915             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
10916                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
10917          }
10918       }
10919    }
10920 }
10921
10922 /*******************************************************************
10923  *
10924  * @brief Fills PdschCfg received by CU
10925  *
10926  * @details
10927  *
10928  *    Function : extractPdschCfg
10929  *
10930  *    Functionality: Fills PdschCfg received  by CU
10931  *
10932  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
10933  *                   which we have stored in F1UeContextSetupDb,
10934  *             PdschConfig *macPdschCfg = Used to Store the information which
10935  *                   needs to send in other layer, as well as this can be the variable
10936  *                   which stores the information in DuCb,
10937  *             PdschConfig *storedPdschCfg =  Null in case of sending the
10938  *                   information to other layer else it will have stored pdsch
10939  *                   configuration in copyOfmacUeCfg.
10940  * @return void
10941  *
10942  * ****************************************************************/
10943
10944 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
10945 {
10946    uint8_t timeDomIdx;
10947    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
10948
10949    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
10950    {
10951       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
10952             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
10953       {
10954          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
10955          {
10956             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
10957                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
10958          }
10959       }
10960    }
10961    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
10962    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
10963    {
10964       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
10965       if(timeDomAlloc->present ==\
10966             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
10967       {
10968          if(timeDomAlloc->choice.setup)
10969          {
10970             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
10971             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
10972             {
10973                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
10974                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
10975                {
10976                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
10977                   {
10978                      if(storedPdschCfg)
10979                      {
10980                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
10981                         {
10982                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
10983                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
10984                         }
10985                         else
10986                         {
10987                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
10988                         }
10989                      }
10990                      else
10991                      {
10992                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
10993                      }
10994                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
10995                      {
10996                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
10997                         return;
10998                      }
10999                   }
11000                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
11001                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
11002                }
11003                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
11004                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
11005                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
11006                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
11007             }
11008          }
11009       }
11010    }
11011    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
11012    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
11013       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
11014    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
11015    {
11016       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
11017       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
11018       {
11019          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
11020          {
11021             macPdschCfg->bundlingInfo.StaticBundling.size = \
11022                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
11023          }
11024       }
11025    }
11026    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
11027    {
11028       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
11029    }
11030
11031 }
11032
11033 /*******************************************************************
11034  *
11035  * @brief Fills PdschServingCellCfg received by CU
11036  *
11037  * @details
11038  *
11039  *    Function : extractPdschServingCellCfg
11040  *
11041  *    Functionality: Fills PdschCfg received  by CU
11042  *
11043  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
11044  *             PdschServCellCfg *macUePdschSrvCellCfg
11045  * @return ROK/RFAILED
11046  *
11047  * ****************************************************************/
11048
11049 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
11050 {
11051    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
11052    {
11053       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
11054       {
11055          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
11056          {
11057             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
11058                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
11059          }
11060          else
11061          {
11062             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
11063             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
11064             {
11065                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
11066                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
11067             }
11068             else
11069             {
11070                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
11071                return RFAILED;
11072             }
11073          }
11074          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
11075          {
11076             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
11077                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
11078          }
11079          else
11080          {
11081             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
11082             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
11083             {
11084                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
11085                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
11086             }
11087             else
11088             {
11089                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
11090                return RFAILED;
11091             }
11092          }
11093       }
11094    }
11095    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
11096    {
11097       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
11098    }
11099    if(cuPdschSrvCellCfg->ext1)
11100    {
11101       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
11102       {
11103         if(macUePdschSrvCellCfg->maxMimoLayers)
11104         {
11105            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
11106         }
11107         else
11108         {
11109            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
11110            if(macUePdschSrvCellCfg->maxMimoLayers)
11111            {
11112               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
11113            }
11114            else
11115            {
11116               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
11117               return RFAILED;
11118            }
11119         }
11120       }
11121    }
11122    if(cuPdschSrvCellCfg->xOverhead)
11123    {
11124       if(macUePdschSrvCellCfg->xOverhead)
11125       {
11126          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
11127       }
11128       else
11129       {
11130          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
11131          if(macUePdschSrvCellCfg->xOverhead)
11132          {
11133             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
11134          }
11135          else
11136          {
11137             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
11138             return RFAILED;
11139          }
11140       }
11141    }
11142    return ROK;
11143 }
11144
11145 /*******************************************************************
11146  *
11147  * @brief Fills PuschCfg received by CU
11148  *
11149  * @details
11150  *
11151  *    Function : extractPuschCfg
11152  *
11153  *    Functionality: Fills PuschCfg received  by CU
11154  *
11155  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
11156  *             PuschCfg *macPuschCfg
11157  * @return void
11158  *
11159  * ****************************************************************/
11160
11161 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
11162 {
11163    uint8_t timeDomIdx = 0;
11164    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
11165    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
11166
11167    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
11168    {
11169       if(cuPuschCfg->choice.setup)
11170       {
11171          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
11172          {
11173              macPuschCfg->dataScramblingId = \
11174                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
11175          }
11176          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
11177          {
11178             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
11179             {
11180                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
11181                {
11182                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
11183                   if(dmrsUlCfg->dmrs_AdditionalPosition)
11184                   {
11185                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
11186                         *(dmrsUlCfg->dmrs_AdditionalPosition);
11187                   }
11188                   if(dmrsUlCfg->transformPrecodingDisabled)
11189                   {
11190                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
11191                      {
11192                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
11193                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
11194                      }
11195                   }
11196                }
11197             }
11198          }
11199          /*Res Alloc Type for UL */
11200          if(cuPuschCfg->choice.setup->resourceAllocation)
11201          {
11202             macPuschCfg->resourceAllocType = \
11203                cuPuschCfg->choice.setup->resourceAllocation;
11204          }
11205          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
11206          {
11207             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
11208             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
11209             {
11210                if(timeDomAllocList->choice.setup)
11211                {
11212                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
11213                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
11214                   {
11215                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
11216                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
11217                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
11218                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
11219                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
11220                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
11221                   }
11222                }
11223             }
11224          }
11225          if(cuPuschCfg->choice.setup->transformPrecoder)
11226             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
11227       }
11228    }
11229 }
11230
11231 /*******************************************************************
11232  *
11233  * @brief Function to fill pucch Power Control
11234  *
11235  * @details
11236  *
11237  *    Function : extractPucchPowerControl
11238  *
11239  *    Functionality: Function to fill pucch Power Control
11240  *
11241  * @params[in] PucchPowerControl *pwrCtrl,
11242  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
11243  * @return void
11244  *
11245  * ****************************************************************/
11246
11247 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
11248 {
11249    uint8_t arrIdx;
11250
11251    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
11252       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
11253    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
11254       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
11255    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
11256       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
11257    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
11258       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
11259    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
11260       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
11261    if(cuPwrCtrlCfg->p0_Set)
11262    {
11263       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
11264       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
11265       {
11266          pwrCtrl->p0Set[arrIdx].p0PucchId =\
11267             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
11268          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
11269             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
11270       }
11271    }
11272    if(cuPwrCtrlCfg->pathlossReferenceRSs)
11273    {
11274       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
11275       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
11276       {
11277          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
11278             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
11279       }
11280    }
11281 }
11282
11283  /*******************************************************************
11284  *
11285  * @brief Function to extractResrcSetToAddModList sent by CU
11286  *
11287  * @details
11288  *
11289  *    Function : extractResrcSetToAddModList
11290  *
11291  *    Functionality: Fucntion to extractResrcSetToAddModList
11292  *
11293  * @params[in] PucchResrcSetCfg pointer,
11294  *             struct PUCCH_Config__resourceSetToAddModList pointer
11295  * @return void
11296  *
11297  * ****************************************************************/
11298
11299 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
11300 {
11301    uint8_t arrIdx, rsrcListIdx;
11302
11303    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
11304    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
11305    {
11306       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
11307          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
11308       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
11309          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
11310       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
11311       {
11312          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
11313             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
11314       }
11315
11316       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
11317       {
11318          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
11319             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
11320       }
11321       else
11322       {
11323          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
11324       }
11325    }
11326 }/* End of extractResrcSetToAddModList */
11327
11328 /*******************************************************************
11329  *
11330  * @brief Fills extractResrcToAddModList sent by CU
11331  *
11332  * @details
11333  *
11334  *    Function : extractResrcToAddModList
11335  *
11336  *    Functionality: Fills extractResrcToAddModList
11337  *
11338  * @params[in] PucchResrcCfg pointer,
11339  *             struct PUCCH_Config__resourceToAddModList pointer
11340  * @return ROk/RFAILED
11341  *
11342  * ****************************************************************/
11343
11344 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
11345 {
11346    uint8_t arrIdx;
11347
11348    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
11349    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
11350    {
11351       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
11352         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
11353       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
11354         cuResrcList->list.array[arrIdx]->startingPRB;
11355       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
11356       {
11357          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
11358            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
11359       }
11360       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
11361       {
11362          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
11363            *cuResrcList->list.array[arrIdx]->secondHopPRB;
11364       }
11365       /* PUCCH RSRC FORMAT */
11366       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
11367       {
11368          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
11369          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
11370          {
11371             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
11372             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
11373             {
11374                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
11375                return RFAILED;
11376             }
11377             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
11378                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
11379             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
11380                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
11381             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
11382                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
11383          }
11384       }
11385       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
11386       {
11387          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
11388          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
11389          {
11390             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
11391             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
11392             {
11393                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
11394                return RFAILED;
11395             }
11396             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
11397                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
11398             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
11399                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
11400             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
11401                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
11402             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
11403                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
11404          }
11405       }
11406       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
11407       {
11408          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
11409          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
11410          {
11411             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
11412             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
11413             {
11414                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
11415                return RFAILED;
11416             }
11417             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
11418                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
11419             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
11420                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
11421             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
11422                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
11423          }
11424       }
11425       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
11426       {
11427          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
11428          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
11429          {
11430             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
11431             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
11432             {
11433                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
11434                return RFAILED;
11435             }
11436             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
11437                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
11438             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
11439                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
11440             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
11441                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
11442          }
11443       }
11444       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
11445       {
11446          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
11447          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
11448          {
11449             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
11450             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
11451             {
11452                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
11453                return RFAILED;
11454             }
11455             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
11456                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
11457             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
11458                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
11459             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
11460                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
11461             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
11462                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
11463          }
11464       }
11465    }
11466    return ROK;
11467
11468 }/* End of extractResrcToAddModList */
11469
11470 /*******************************************************************
11471  *
11472  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
11473  *
11474  * @details
11475  *
11476  *    Function : fillPucchSchedReqPeriodAndOffset
11477  *
11478  *    Functionality: To fillPucchSchedReqPeriodAndOffset
11479  *
11480  * @params[in] macPeriodicty,
11481  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
11482  * @return void
11483  *
11484  * ****************************************************************/
11485
11486 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
11487    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
11488 {
11489    macPeriodicty = cuPeriodicty->present;
11490    switch(macPeriodicty)
11491    {
11492       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
11493          {
11494             macOffset     = cuPeriodicty->choice.sym2;
11495             break;
11496          }
11497       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
11498          {
11499             macOffset     = cuPeriodicty->choice.sym6or7;
11500             break;
11501          }
11502       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
11503          {
11504             macOffset     = cuPeriodicty->choice.sl1;
11505             break;
11506          }
11507       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
11508          {
11509             macOffset = cuPeriodicty->choice.sl2;
11510             break;
11511          }
11512       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
11513          {
11514             macOffset = cuPeriodicty->choice.sl4;
11515             break;
11516          }
11517       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
11518          {
11519             macOffset = cuPeriodicty->choice.sl5;
11520             break;
11521          }
11522       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
11523          {
11524             macOffset = cuPeriodicty->choice.sl8;
11525             break;
11526          }
11527       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
11528          {
11529             macOffset = cuPeriodicty->choice.sl10;
11530             break;
11531          }
11532       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
11533          {
11534             macOffset = cuPeriodicty->choice.sl16;
11535             break;
11536          }
11537       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
11538          {
11539             macOffset = cuPeriodicty->choice.sl20;
11540             break;
11541          }
11542       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
11543          {
11544             macOffset = cuPeriodicty->choice.sl40;
11545             break;
11546          }
11547       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
11548          {
11549             macOffset = cuPeriodicty->choice.sl80;
11550             break;
11551          }
11552       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
11553          {
11554             macOffset = cuPeriodicty->choice.sl160;
11555             break;
11556          }
11557       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
11558          {
11559             macOffset = cuPeriodicty->choice.sl320;
11560             break;
11561          }
11562       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
11563          {
11564             macOffset = cuPeriodicty->choice.sl640;
11565             break;
11566          }
11567       default :
11568          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
11569    }
11570 }
11571
11572 /*******************************************************************
11573  *
11574  * @brief Function to extractPucchFormatCfg sent by CU
11575  *
11576  * @details
11577  *
11578  *    Function : extractPucchFormatCfg
11579  *
11580  *    Functionality: Function to extractPucchFormatCfg
11581  *
11582  * @params[in] PucchFormatCfg pointer,
11583  *             PUCCH_FormatConfig_t pointer
11584  * @return void
11585  *
11586  * ****************************************************************/
11587
11588 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
11589  {
11590     if(cuFormatCfg->interslotFrequencyHopping)
11591        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
11592     if(cuFormatCfg->additionalDMRS)
11593        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
11594     if(cuFormatCfg->maxCodeRate)
11595        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
11596     if(cuFormatCfg->nrofSlots)
11597        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
11598     if(cuFormatCfg->pi2BPSK)
11599        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
11600     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
11601        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
11602  }/* End of extractPucchFormatCfg */
11603
11604 /*******************************************************************
11605  *
11606  * @brief Function to extractSchedReqCfgToAddMod sent by CU
11607  *
11608  * @details
11609  *
11610  *    Function : extractSchedReqCfgToAddMod
11611  *
11612  *    Functionality: Function to extractSchedReqCfgToAddMod
11613  *
11614  * @params[in] PucchSchedReqCfg pointer,
11615  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
11616  * @return void
11617  *
11618  * ****************************************************************/
11619
11620 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
11621 {
11622    uint8_t arrIdx;
11623
11624    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
11625    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
11626    {
11627       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
11628          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
11629       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
11630          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
11631       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
11632       {
11633          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
11634             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
11635       }
11636       if(cuSchedReqList->list.array[arrIdx]->resource)
11637       {
11638          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
11639             *cuSchedReqList->list.array[arrIdx]->resource;
11640       }
11641    }
11642
11643 }/* End of extractSchedReqCfgToAddMod */
11644
11645  /*******************************************************************
11646  *
11647  * @brief Fills PucchCfg received by CU
11648  *
11649  * @details
11650  *
11651  *    Function : extractPucchCfg
11652  *
11653  *    Functionality: Fills PucchCfg received  by CU
11654  *
11655  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
11656  *                is send by CU, which we have stored in F1UeContextSetupDb,
11657  *             PucchCfg *macPucchCfg = Used to Store the information which
11658  *                needs to send in other layer, as well as this can be the variable
11659  *                which stores the information in DuCb,
11660  *             PucchCfg *storedPucchCfg = Null in case of sending the
11661  *                information to other layer else it will have Pucch Cfg which
11662  *                we have stored in copyOfmacUeCfg.
11663  * @return ROK/RFAILED
11664  *
11665  * ****************************************************************/
11666
11667 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
11668 PucchCfg *storedPucchCfg)
11669 {
11670    uint8_t arrIdx;
11671
11672    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
11673    {
11674       if(cuPucchCfg->choice.setup)
11675       {
11676          /* Resource Set Cfg */
11677          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
11678          {
11679             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
11680             if(macPucchCfg->resrcSet == NULLP)
11681             {
11682                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
11683                return RFAILED;
11684             }
11685             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
11686             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
11687          }
11688
11689          /* Resource Cfg */
11690          if(cuPucchCfg->choice.setup->resourceToAddModList)
11691          {
11692             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
11693             if(macPucchCfg->resrc == NULLP)
11694             {
11695                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
11696                return RFAILED;
11697             }
11698             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
11699             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
11700          }
11701
11702          /* Format 1 Cfg */
11703          if(cuPucchCfg->choice.setup->format1)
11704          {
11705             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
11706             if(macPucchCfg->format1 == NULLP)
11707             {
11708                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
11709                return RFAILED;
11710             }
11711             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
11712             extractPucchFormatCfg(macPucchCfg->format1,\
11713                cuPucchCfg->choice.setup->format1->choice.setup);
11714          }
11715
11716          /* Format 2 Cfg */
11717          if(cuPucchCfg->choice.setup->format2)
11718          {
11719             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
11720             if(macPucchCfg->format2 == NULLP)
11721             {
11722                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
11723                return RFAILED;
11724             }
11725             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
11726             extractPucchFormatCfg(macPucchCfg->format2,\
11727                cuPucchCfg->choice.setup->format2->choice.setup);
11728          }
11729
11730          /* Format 3 Cfg */
11731          if(cuPucchCfg->choice.setup->format3)
11732          {
11733             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
11734             if(macPucchCfg->format3 == NULLP)
11735             {
11736                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
11737                return RFAILED;
11738             }
11739             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
11740             extractPucchFormatCfg(macPucchCfg->format3,\
11741                cuPucchCfg->choice.setup->format3->choice.setup);
11742          }
11743
11744          /* Format 4 Cfg */
11745          if(cuPucchCfg->choice.setup->format4)
11746          {
11747             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
11748             if(macPucchCfg->format4 == NULLP)
11749             {
11750                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
11751                return RFAILED;
11752             }
11753             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
11754             extractPucchFormatCfg(macPucchCfg->format4,\
11755                cuPucchCfg->choice.setup->format4->choice.setup);
11756          }
11757
11758          /* Sched Req List */
11759          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
11760          {
11761             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
11762             if(macPucchCfg->schedReq == NULLP)
11763             {
11764                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
11765                return RFAILED;
11766             }
11767             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
11768             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
11769             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
11770          }
11771
11772          /*TODO: Add support for  Spatial Info */
11773
11774          /* MultiCsiCfg */
11775          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
11776          {
11777             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
11778             if(macPucchCfg->multiCsiCfg == NULLP)
11779             {
11780                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
11781                return RFAILED;
11782             }
11783             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
11784             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
11785             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
11786             {
11787                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
11788                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
11789             }
11790          }
11791
11792          /* Dl_DataToUL_ACK */
11793          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
11794     {
11795        if(storedPucchCfg)
11796        {
11797           if(storedPucchCfg->dlDataToUlAck)
11798           {
11799              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
11800           }
11801           else
11802           {
11803             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
11804           }
11805        }
11806        else
11807        {
11808           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
11809        }
11810        if(macPucchCfg->dlDataToUlAck == NULLP)
11811        {
11812           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
11813           return RFAILED;
11814        }
11815        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
11816        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
11817        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
11818        {
11819           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
11820           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
11821        }
11822          }
11823
11824          /* Power Control */
11825          if(cuPucchCfg->choice.setup->pucch_PowerControl)
11826          {
11827             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
11828             if(macPucchCfg->powerControl == NULLP)
11829             {
11830                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
11831                return RFAILED;
11832             }
11833             extractPucchPowerControl(macPucchCfg->powerControl,\
11834                cuPucchCfg->choice.setup->pucch_PowerControl);
11835          }
11836       }
11837    }
11838    return ROK;
11839 }
11840
11841 /*******************************************************************
11842  *
11843  * @brief Fills ServingCellReconfig received by CU
11844  *
11845  * @details
11846  *
11847  *    Function : extractSpCellDedicatedCfg
11848  *
11849  *    Functionality: Fills ServingCellReconfig received  by CU
11850  *
11851  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
11852  *                  CU, which we have stored in F1UeContextSetupDb,
11853  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
11854  *                  which  needs to send in other layer, as well as this can be the
11855  *                  variable which stores the information in DuCb,
11856  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
11857  *                  information to other layer else it will have ServCellCfgInfo which
11858  *                  we have stored in copyOfmacUeCfg.
11859  * @return ROK/RFAILD
11860  *
11861  * ****************************************************************/
11862 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellRecfgInfo *macSrvCellCfg,\
11863 ServCellRecfgInfo *storedSrvCellCfg)
11864 {
11865    uint8_t ret = ROK;
11866    BWP_DownlinkDedicated_t *dlBwp = NULLP;
11867    BWP_UplinkDedicated_t   *ulBwp = NULLP;
11868
11869    if(cuSrvCellCfg->initialDownlinkBWP)
11870    {
11871       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
11872       if(dlBwp->pdcch_Config)
11873       {
11874          if(dlBwp->pdcch_Config->choice.setup)
11875          {
11876             macSrvCellCfg->initDlBwp.pdcchPresent = true;
11877             if(storedSrvCellCfg)
11878             {
11879                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
11880                {
11881                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11882                }
11883                else
11884                {
11885                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11886                }
11887             }
11888             else
11889             {
11890                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
11891             }
11892          }
11893       }
11894       if(dlBwp->pdsch_Config)
11895       {
11896          if(dlBwp->pdsch_Config->choice.setup)
11897          {
11898             macSrvCellCfg->initDlBwp.pdschPresent = true;
11899
11900             if(storedSrvCellCfg)
11901             {
11902                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
11903                {
11904                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
11905                }
11906                else
11907                {
11908                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
11909                         &storedSrvCellCfg->initDlBwp.pdschCfg);
11910                }
11911             }
11912             else
11913             {
11914                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
11915             }
11916          }
11917       }
11918    }
11919    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
11920       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
11921    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
11922       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
11923    if(cuSrvCellCfg->bwp_InactivityTimer)
11924    {
11925       if(macSrvCellCfg->bwpInactivityTmr)
11926       {
11927          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
11928       }
11929       else
11930       {
11931          macSrvCellCfg->bwpInactivityTmr = NULLP;
11932          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
11933          if(macSrvCellCfg->bwpInactivityTmr)
11934          {
11935             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
11936          }
11937          else
11938          {
11939             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
11940             return RFAILED;
11941          }
11942       }
11943    }
11944    if(cuSrvCellCfg->pdsch_ServingCellConfig)
11945    {
11946       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
11947       {
11948          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
11949          if(ret == RFAILED)
11950          {
11951             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
11952             return RFAILED;
11953          }
11954       }
11955    }
11956    if(cuSrvCellCfg->uplinkConfig)
11957    {
11958       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
11959       {
11960          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
11961          if(ulBwp->pusch_Config)
11962          {
11963             macSrvCellCfg->initUlBwp.puschPresent = true;
11964             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
11965          }
11966          if(ulBwp->pucch_Config)
11967          {
11968             macSrvCellCfg->initUlBwp.pucchPresent = true;
11969             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
11970             if(storedSrvCellCfg)
11971             {
11972                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
11973                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
11974                else
11975                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
11976                   &storedSrvCellCfg->initUlBwp.pucchCfg);
11977             }
11978             else
11979             {
11980                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
11981             }
11982          }
11983       }
11984       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
11985          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
11986    }
11987    return ret;
11988 }
11989
11990 #ifdef NR_DRX
11991
11992 /*******************************************************************
11993  *
11994  * @brief fill long cycle offset value of drx in UE structure
11995  *
11996  * @details
11997  *
11998  *    Function : fillLongCycleOffsetValueInUeDb
11999  *
12000  *    Functionality: fill long cycle offset value of drx in UE structure
12001  *
12002  * @params[in] DrxLongCycleStartOffset  drxLongCycleStartOffset,
12003  * struct DRX_ConfigRrc__drx_LongCycleStartOffset drx_LongCycleStartOffset
12004  *
12005  * @return ROK     - success
12006  *         RFAILED - failure
12007  *
12008  * ****************************************************************/
12009 void fillLongCycleOffsetValueInUeDb(DrxLongCycleStartOffset *drxLongCycleStartOffset, struct DRX_ConfigRrc__drx_LongCycleStartOffset  *drx_LongCycleStartOffset)
12010 {
12011
12012    drxLongCycleStartOffset->drxLongCycleStartOffsetChoice = convertLongDrxCycleLengthEnumToValue(drx_LongCycleStartOffset->present);
12013    switch(drx_LongCycleStartOffset->present)
12014    {
12015       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10:
12016          {
12017             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms10;
12018             break;
12019          }
12020       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms20:
12021          {
12022             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms20;
12023             break;
12024          }
12025       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms32:
12026          {
12027             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms32;
12028             break;
12029          }
12030       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms40:
12031         {
12032             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms40;
12033             break;
12034          }
12035       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms60:
12036          {
12037             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms60;
12038             break;
12039          }
12040       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms64:
12041          {
12042             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms64;
12043             break;
12044          }
12045       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms70:
12046          {
12047             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms70;
12048             break;
12049          }
12050       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms80:
12051          {
12052             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms80;
12053             break;
12054          }
12055       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms128:
12056          {
12057             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms128;
12058             break;
12059          }
12060       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms160:
12061          {
12062             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms160;
12063             break;
12064          }
12065       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms256:
12066          {
12067             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms256;
12068             break;
12069          }
12070       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms320:
12071          {
12072             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms320;
12073             break;
12074          }
12075       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms512:
12076          {
12077             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms512;
12078             break;
12079          }
12080       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms640:
12081          {
12082             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms640;
12083             break;
12084          }
12085       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1024:
12086          {
12087             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms1024;
12088             break;
12089          }
12090       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms1280:
12091          {
12092             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms1280;
12093             break;
12094          }
12095       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2048:
12096          {
12097             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms2048;
12098             break;
12099          }
12100       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms2560:
12101          {
12102             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms2560;
12103             break;
12104          }
12105        case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms5120:
12106          {
12107             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms5120;
12108             break;
12109          }
12110       case DRX_ConfigRrc__drx_LongCycleStartOffset_PR_ms10240:
12111          {
12112             drxLongCycleStartOffset->drxLongCycleStartOffsetVal = drx_LongCycleStartOffset->choice.ms10240;
12113             break;
12114          }
12115       default :
12116          break;
12117    }
12118 }
12119
12120 /*******************************************************************
12121  *
12122  * @brief Fills drx configuration structure with the help of drx_ConfigRrc
12123  *which recive from CU or storedDrxCfg which is already stored
12124  *
12125  * @details
12126  *
12127  *    Function : extractDrxConfiguration
12128  *
12129  *    Functionality: Fills Reconfig Cell group Info received by CU
12130  *
12131  * @params[in] cuMacCellGrpDrxConfig  = MAC_CellGroupConfig__drx_ConfigRrc information which
12132  *                       is send by CU, which we have stored in F1UeContextSetupDb
12133  *             DrxCfg * drxCfg  = Used to Store the information,
12134  *                      which needs to send in other layer, as well as this can be
12135  *                      the variable which stores the information in DuCb,
12136  *             DrxCfg *storedDrxCfg = Null in case of sending the
12137  *                      information to other layer else it will have the drx information
12138  *                      stored in the copyOfmacUeCfg which we have stored in F1UeContextSetupDb.
12139  *
12140  * @return void
12141  *
12142  * ****************************************************************/
12143 void extractDrxConfiguration(struct MAC_CellGroupConfig__drx_ConfigRrc *cuMacCellGrpDrxConfig, DrxCfg * drxCfg, DrxCfg *storedDrxCfg)
12144 {
12145    struct DRX_ConfigRrc *cuDrxConfig;
12146
12147    if(storedDrxCfg)
12148    {
12149       memcpy(drxCfg, storedDrxCfg, sizeof(DrxCfg));
12150    }
12151    else
12152    {
12153       if(cuMacCellGrpDrxConfig)
12154       {
12155          switch(cuMacCellGrpDrxConfig->present)
12156          {
12157             case MAC_CellGroupConfig__drx_ConfigRrc_PR_NOTHING:
12158                break;
12159
12160             case MAC_CellGroupConfig__drx_ConfigRrc_PR_setup:
12161                {
12162                   cuDrxConfig = cuMacCellGrpDrxConfig->choice.setup;
12163                   if(cuDrxConfig)
12164                   {
12165                      switch(cuDrxConfig->drx_onDurationTimer.present)
12166                      {
12167                         case DRX_ConfigRrc__drx_onDurationTimer_PR_NOTHING:
12168                            break;
12169                         case DRX_ConfigRrc__drx_onDurationTimer_PR_milliSeconds:
12170                            {
12171                               drxCfg->drxOnDurationTimer.onDurationTimerValInMs = true;
12172                               drxCfg->drxOnDurationTimer.onDurationtimerValue.milliSeconds=convertOnDurationTimerMilliSecondsEnumToValue(cuDrxConfig->\
12173                               drx_onDurationTimer.choice.milliSeconds);
12174                               break;
12175                            }
12176                         case DRX_ConfigRrc__drx_onDurationTimer_PR_subMilliSeconds:
12177                            {
12178                               drxCfg->drxOnDurationTimer.onDurationTimerValInMs = false;
12179                               drxCfg->drxOnDurationTimer.onDurationtimerValue.subMilliSeconds = cuDrxConfig->drx_onDurationTimer.choice.subMilliSeconds;
12180                               break;
12181                            }
12182                      }
12183                   }
12184                   fillLongCycleOffsetValueInUeDb(&drxCfg->drxLongCycleStartOffset, &cuDrxConfig->drx_LongCycleStartOffset);
12185                   drxCfg->drxInactivityTimer = convertDrxInactivityTimerEnumToValue(cuDrxConfig->drx_InactivityTimer);
12186                   drxCfg->drxHarqRttTimerDl = cuDrxConfig->drx_HARQ_RTT_TimerDL;
12187                   drxCfg->drxHarqRttTimerUl = cuDrxConfig->drx_HARQ_RTT_TimerUL;
12188                   drxCfg->drxRetransmissionTimerDl = convertDrxRetransmissionTimerDlEnumToValue(cuDrxConfig->drx_RetransmissionTimerDL);
12189                   drxCfg->drxRetransmissionTimerUl = convertDrxRetransmissionTimerUlEnumToValue(cuDrxConfig->drx_RetransmissionTimerUL);
12190                   drxCfg->drxSlotOffset = cuDrxConfig->drx_SlotOffset;
12191                   if(cuDrxConfig->shortDRX)
12192                   {
12193                      drxCfg->shortDrxPres=true;
12194                      drxCfg->shortDrx.drxShortCycle = convertShortDrxCycleLengthEnumToValue(cuDrxConfig->shortDRX->drx_ShortCycle);
12195                      drxCfg->shortDrx.drxShortCycleTimer = cuDrxConfig->shortDRX->drx_ShortCycleTimer;
12196                   }
12197                   else
12198                      drxCfg->shortDrxPres=false;
12199
12200                   break;
12201                }
12202
12203             case MAC_CellGroupConfig__drx_ConfigRrc_PR_release:
12204                break;
12205          }
12206       }
12207    }
12208 }
12209 #endif
12210
12211 /*******************************************************************
12212  *
12213  * @brief Fills Reconfig Cell group Info received by CU
12214  *
12215  * @details
12216  *
12217  *    Function : extractUeRecfgCellInfo
12218  *
12219  *    Functionality: Fills Reconfig Cell group Info received by CU
12220  *
12221  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
12222  *                       is send by CU, which we have stored in F1UeContextSetupDb
12223  *             DuMacUeCfg *MacUeCfg = Used to Store the information,
12224  *                      which needs to send in other layer, as well as this can be
12225  *                      the variable which stores the information in DuCb,
12226  *             DuMacUeCfg *storedMacUeCfg = Null in case of sending the
12227  *                      information to other layer else it will have copyOfmacUeCfg
12228  *                      which we have stored in F1UeContextSetupDb.
12229  *
12230  * @return ROK/RFAILED
12231  *
12232  * ****************************************************************/
12233 uint8_t extractUeRecfgCellInfo(CellGroupConfigRrc_t *cellGrp, DuMacUeCfg *macUeCfg, DuMacUeCfg *storedMacUeCfg)
12234 {
12235    uint8_t ret = ROK;
12236    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
12237    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
12238    SpCellConfig_t            *spcellCfg = NULLP;
12239    ServingCellConfig_t       *servCellCfg = NULLP;
12240
12241    if(cellGrp)
12242    {
12243       /* Fill MacCell Group Reconfig  */
12244       if(cellGrp->mac_CellGroupConfig)
12245       {
12246          macUeCfg->macCellGrpCfgPres = true;
12247          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
12248
12249 #ifdef NR_DRX
12250          if(macCellGroup->drx_ConfigRrc)
12251          {
12252             if(storedMacUeCfg)
12253             {
12254                if(!storedMacUeCfg->macCellGrpCfgPres)
12255                {
12256                   extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg,NULL);
12257                }
12258                else
12259                {
12260                   extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg, &storedMacUeCfg->macCellGrpCfg.drxCfg);
12261                }
12262             }
12263             else
12264             {
12265                extractDrxConfiguration(macCellGroup->drx_ConfigRrc, &macUeCfg->macCellGrpCfg.drxCfg,NULL);
12266             }
12267          }
12268 #endif
12269
12270          if(macCellGroup->schedulingRequestConfig)
12271          {
12272             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
12273          }
12274          if(macCellGroup->tag_Config)
12275          {
12276             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
12277          }
12278          if(macCellGroup->bsr_Config)
12279          {
12280             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
12281             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
12282             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
12283             {
12284                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
12285                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
12286             }
12287          }
12288          if(macCellGroup->phr_Config)
12289          {
12290             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
12291             {
12292                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
12293                if(macCellGroup->phr_Config->choice.setup)
12294                {
12295                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
12296                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
12297                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
12298                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
12299                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
12300                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
12301                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
12302                   macCellGroup->phr_Config->choice.setup->multiplePHR;
12303                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
12304                   macCellGroup->phr_Config->choice.setup->dummy;
12305                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
12306                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
12307                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
12308                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
12309                }
12310             }
12311          }
12312       }
12313       /* Fill Physical Cell Group Reconfig */
12314       if(cellGrp->physicalCellGroupConfig)
12315       {
12316          macUeCfg->phyCellGrpCfgPres = true;
12317          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
12318          if(phyCellGrpCfg->p_NR_FR1)
12319          {
12320             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
12321                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
12322          }
12323          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
12324       }
12325       /* Fill SpCell Reconfig */
12326       if(cellGrp->spCellConfig)
12327       {
12328          macUeCfg->spCellCfgPres = true;
12329          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
12330          if(spcellCfg->servCellIndex)
12331          {
12332             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
12333          }
12334          /* Fill Serving cell Reconfig info */
12335          if(cellGrp->spCellConfig->spCellConfigDedicated)
12336          {
12337             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
12338             if(storedMacUeCfg)
12339             {
12340                if(!storedMacUeCfg->spCellCfgPres)
12341                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
12342                else
12343                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
12344                         &storedMacUeCfg->spCellCfg.servCellCfg);
12345             }
12346             else
12347             {
12348                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
12349             }
12350             if(ret == RFAILED)
12351             {
12352                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
12353             }
12354          }
12355       }
12356    }
12357    return ret;
12358 }
12359 /*******************************************************************
12360 *
12361 * @brief free the memory allocated by decoder
12362 *
12363 * @details
12364 *
12365 *    Function : freeAperDecodeNrcgi
12366 *
12367 *    Functionality: Free Nrcgi values
12368 *
12369 * @params[in] NRCGI_t *nrcgi
12370 * @return void
12371 *
12372 * ****************************************************************/
12373
12374
12375 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
12376 {
12377     if(nrcgi->pLMN_Identity.buf != NULLP)
12378     {
12379        free(nrcgi->pLMN_Identity.buf);
12380     }
12381     if(nrcgi->nRCellIdentity.buf != NULLP)
12382     {
12383        free(nrcgi->nRCellIdentity.buf);
12384     }
12385 }
12386 /*******************************************************************
12387 *
12388 * @brief free the memory allocated by decoder
12389 *
12390 * @details
12391 *
12392 *    Function : freeAperDecodeCuToDuInfo
12393 *
12394 *    Functionality:  Free Cu To Du Information
12395 *
12396 * @params[in] CUtoDURRCInformation_t *rrcMsg
12397 * @return void
12398 *
12399 * ****************************************************************/
12400
12401
12402 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
12403 {
12404    uint8_t ieIdx =0;
12405    uint8_t arrIdx =0;
12406
12407    if(rrcMsg->uE_CapabilityRAT_ContainerList)
12408    {
12409       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
12410          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
12411       free(rrcMsg->uE_CapabilityRAT_ContainerList);
12412    }
12413
12414    if(rrcMsg->iE_Extensions)
12415    {
12416       if(rrcMsg->iE_Extensions->list.array)
12417       {
12418          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
12419          {
12420             if(rrcMsg->iE_Extensions->list.array[ieIdx])
12421             {
12422                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
12423                {
12424                   case ProtocolIE_ID_id_CellGroupConfig:
12425                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
12426                      {
12427                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
12428                      }
12429                      break;
12430                   default:
12431                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
12432                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
12433                      break;
12434                }
12435             }
12436          }
12437          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
12438          {
12439             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
12440          }
12441          free(rrcMsg->iE_Extensions->list.array);
12442
12443       }
12444
12445       free(rrcMsg->iE_Extensions);
12446    }
12447 }
12448 /*******************************************************************
12449 *
12450 * @brief free the memory allocated by decoder
12451 *
12452 * @details
12453 *
12454 *    Function : freeAperDecodeSplCellList
12455 *
12456 *    Functionality: Free Spl Cell List
12457                     where memory allocated by aper_decoder
12458 *
12459 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
12460 * @return void
12461 *
12462 * ****************************************************************/
12463
12464
12465 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
12466 {
12467     uint8_t  cellIdx =0;
12468
12469     if(spCellLst->list.array != NULLP)
12470     {
12471        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
12472        {
12473           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
12474           {
12475              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
12476           }
12477           if(spCellLst->list.array[cellIdx]!=NULLP)
12478           {
12479              free(spCellLst->list.array[cellIdx]);
12480           }
12481        }
12482        free(spCellLst->list.array);
12483     }
12484 }
12485 /*******************************************************************
12486 *
12487 * @brief free the memory allocated by decoder
12488 *
12489 * @details
12490 *
12491 *    Function : freeAperDecodeSRBSetup
12492 *
12493 *    Functionality: added free part for the memory allocated by aper_decoder
12494 *
12495 * @params[in] SRBs_ToBeSetup_List_t *srbSet
12496 * @return void
12497 *
12498 ****************************************************************/
12499
12500
12501 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
12502 {
12503     uint8_t srbIdx =0;
12504     if(srbSet->list.array != NULLP)
12505     {
12506        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
12507        {
12508           if(srbSet->list.array[srbIdx]!=NULLP)
12509           {
12510              free(srbSet->list.array[srbIdx]);
12511           }
12512        }
12513        free(srbSet->list.array);
12514     }
12515 }
12516
12517 /*******************************************************************
12518 *
12519 * @brief free the memory allocated by decoder
12520 *
12521 * @details
12522 *
12523 *    Function : freeAperDecodeULTnlInfo
12524 *
12525 *    Functionality: added free part for the memory allocated by aper_decoder
12526 *
12527 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12528 * @return void
12529 *
12530 * ****************************************************************/
12531
12532
12533 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12534 {
12535    uint8_t ulIdx=0;
12536    if(ulInfo->list.array != NULLP)
12537    {
12538       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
12539       {
12540          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
12541          {
12542             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
12543             {
12544                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12545                      transportLayerAddress.buf != NULLP)
12546                {
12547                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
12548                         !=NULLP)
12549                   {
12550                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
12551                   }
12552                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12553                         transportLayerAddress.buf);
12554                }
12555                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
12556             }
12557          }
12558          if(ulInfo->list.array[ulIdx]!=NULLP)
12559          {
12560             free(ulInfo->list.array[ulIdx]);
12561          }
12562       }
12563       free(ulInfo->list.array);
12564    }
12565 }
12566 /*******************************************************************
12567 *
12568 * @brief free the memory allocated by decoder
12569 *
12570 * @details
12571 *
12572 *    Function : freeAperDecodeDRBSetup
12573 *
12574 *    Functionality: free DRBSetup which is allocated by decoder
12575 *
12576 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
12577 * @return void
12578 *
12579 * ****************************************************************/
12580
12581 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
12582 {
12583    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
12584    uint8_t  flowIdx =0;
12585    uint8_t  drbIdx =0;
12586
12587    if(drbSet->list.array != NULLP)
12588    {
12589       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
12590       {
12591          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
12592          {
12593             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
12594             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
12595             {
12596                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12597                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
12598                {
12599                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12600                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12601                   {
12602                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12603                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12604                      {
12605
12606                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
12607                         {
12608
12609                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
12610                            {
12611
12612                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
12613                                     buf!=NULLP)
12614                               {
12615
12616                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
12617                                        flows_Mapped_To_DRB_List.list.array != NULLP)
12618                                  {
12619
12620                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12621                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
12622                                     {
12623
12624                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12625                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
12626                                        {
12627                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12628                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12629                                                 qoSFlowLevelQoSParameters.\
12630                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
12631                                           {
12632                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12633                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12634                                                    qoSFlowLevelQoSParameters.\
12635                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12636                                              {
12637
12638                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12639                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12640                                                       qoSFlowLevelQoSParameters.\
12641                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12642                                                 {
12643
12644
12645                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12646                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12647                                                          qoSFlowLevelQoSParameters.\
12648                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12649                                                 }
12650
12651                                                 free(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->averagingWindow);
12655                                              }
12656
12657                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12658
12659                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
12660                                                    qoSFlowLevelQoSParameters.\
12661                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
12662                                           }
12663                                        }
12664                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12665                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
12666                                        {
12667
12668                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12669                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
12670                                        }
12671                                     }
12672
12673                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12674                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
12675                                  }
12676
12677                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
12678                                        DRB_Information.sNSSAI.sD->buf);
12679                               }
12680
12681                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
12682                            }
12683
12684                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
12685
12686                         }
12687
12688                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12689
12690                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12691                      }
12692
12693                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12694                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12695                   }
12696
12697                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
12698                         qoS_Characteristics.choice.non_Dynamic_5QI);
12699                }
12700                free(drbSetItem->qoSInformation.choice.choice_extension);
12701             }
12702             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
12703             if(drbSetItem->uLConfiguration)
12704             {
12705                free(drbSetItem->uLConfiguration);
12706             }
12707          }
12708          if(drbSet->list.array[drbIdx]!=NULLP)
12709          {
12710             free(drbSet->list.array[drbIdx]);
12711          }
12712       }
12713       free(drbSet->list.array);
12714    }
12715 }
12716
12717
12718 /*******************************************************************
12719  *
12720  * @brief builds Mac Cell Cfg
12721  *
12722  * @details
12723  *
12724  *    Function : procUeRecfgCellInfo
12725  *
12726  *    Functionality: builds Mac Cell Cfg
12727  *
12728  * @params[in] DuMacUeCfg *macUeCfgToSend = Used to Store the information which
12729  *                       needs to send in other layer, as well as this can be
12730  *                       the variable which stores the information in DuCb.
12731  *             DuMacUeCfg *storedMacUeCfg = Null in case of sending the
12732  *                       information to other layer else it will have copyOfmacUeCfg
12733  *                       which we have stored in F1UeContextSetupDb
12734  *             void *cellInfo = CellGroupConfigRrc_t information which is send
12735  *                        by CU, which we have stored in F1UeContextSetupDb
12736  *
12737  * @return void
12738  *
12739  * ****************************************************************/
12740 uint8_t procUeRecfgCellInfo(DuMacUeCfg *macUeCfgToSend, DuMacUeCfg *storedMacUeCfg, void *cellInfo)
12741 {
12742    uint8_t ret = ROK;
12743    CellGroupConfigRrc_t *cellGrp = NULLP;
12744
12745    if(cellInfo)
12746    {
12747       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
12748       ret = extractUeRecfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
12749       if(ret == RFAILED)
12750          DU_LOG("\nERROR  -->  F1AP : Failed at procUeRecfgCellInfo()");
12751    }
12752    if(ret == RFAILED)
12753    {
12754       freeUeRecfgCellGrpInfo(macUeCfgToSend);
12755    }
12756    return ret;
12757 }
12758
12759 /*******************************************************************
12760  *
12761  * @brief Filling modulation info in mac ue cfg
12762  *
12763  * @details
12764  *
12765  *    Function : duFillModulationDetails
12766  *
12767  *    Functionality: Filling modulation info in mac ue cfg
12768  *
12769  * @params[in] MAC UE Config to be updated
12770  *             Current UE configuration
12771  *             UE NR capability from CU
12772  * @return ROK     - success
12773  *         RFAILED - failure
12774  *
12775  * ****************************************************************/
12776 void duFillModulationDetails(DuMacUeCfg *ueCfg, DuMacUeCfg *oldUeCfg, void *ueCap)
12777 {
12778    UE_NR_Capability_t *ueNrCap=NULLP;
12779
12780    if(!ueCap && oldUeCfg)
12781    {
12782       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12783       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12784    }
12785    else
12786    {
12787       ueNrCap = (UE_NR_Capability_t *)ueCap;
12788
12789       /* Filling DL modulation info */
12790       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
12791          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
12792          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
12793       {
12794          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
12795          {
12796             case ModulationOrder_qpsk:
12797                {
12798                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
12799                   break;
12800                }
12801             case ModulationOrder_qam16:
12802                {
12803                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
12804                   break;
12805                }
12806             case ModulationOrder_qam64:
12807                {
12808                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
12809                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
12810                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
12811                   break;
12812                }
12813             case ModulationOrder_qam256:
12814                {
12815                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
12816                   break;
12817                }
12818             default:
12819                {
12820                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
12821                   if(oldUeCfg)
12822                      memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12823                   break;
12824                }
12825          }
12826       }
12827       else
12828       {
12829          if(oldUeCfg)
12830             memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
12831       }
12832
12833       /* Filling UL modulation info */
12834       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
12835          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
12836          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
12837       {
12838          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
12839          {
12840             case ModulationOrder_qpsk:
12841                {
12842                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
12843                   break;
12844                }
12845             case ModulationOrder_qam16:
12846                {
12847                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
12848                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
12849                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
12850                   break;
12851                }
12852             case ModulationOrder_qam64:
12853                {
12854                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
12855                   break;
12856                }
12857             case ModulationOrder_qam256:
12858                {
12859                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
12860                   break;
12861                }
12862             default:
12863                {
12864                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
12865                   if(oldUeCfg)
12866                      memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12867                   break;
12868                }
12869          }
12870       }
12871       else
12872       {
12873          if(oldUeCfg)
12874             memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
12875       }
12876    }
12877 }
12878
12879 /*******************************************************************
12880  *
12881  * @brief Function to extract info from CU to DU RRC container extension
12882  *
12883  * @details
12884  *
12885  *    Function : extractCuToDuRrcInfoExt
12886  *
12887  *    Functionality: Function to extract info from CU to DU RRC container
12888  *    extension
12889  *
12890  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
12891  *
12892  * @return ROK
12893  *         RFAILED
12894  *
12895  * ****************************************************************/
12896 uint8_t extractCuToDuRrcInfoExt(ProtocolExtensionContainer_4624P16_t *protocolIeExtn, DuUeCfg *ueCfgDb)
12897 {
12898    uint8_t ieIdx =0;
12899    uint16_t recvBufLen =0;
12900    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
12901    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
12902    asn_dec_rval_t rval; /* Decoder return value */
12903    memset(&rval, 0, sizeof(asn_dec_rval_t));
12904
12905    if(protocolIeExtn)
12906    {
12907       for(ieIdx = 0; ieIdx < protocolIeExtn->list.count; ieIdx++)
12908       {
12909          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[ieIdx]));
12910          switch(extIeInfo->id)
12911          {
12912             case ProtocolIE_ID_id_CellGroupConfig:
12913                {
12914                   /* decoding the CellGroup Buf received */
12915                   recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
12916                   DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
12917                   if(cellGrpCfg)
12918                   {
12919                      memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
12920                      rval = uper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
12921                            extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
12922                      if(rval.code == RC_FAIL || rval.code == RC_WMORE)
12923                      {
12924                         DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
12925                         return RFAILED;
12926                      }
12927                      xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
12928
12929                      if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
12930                         return NULLP;
12931                      ueCfgDb->cellGrpCfg = cellGrpCfg;
12932                   }
12933                   break;
12934                }
12935
12936             case ProtocolIE_ID_id_HandoverPreparationInformation:
12937                {
12938                   DU_LOG("\nINFO -->  F1AP : Received HANDOVER PREPARATION INFO in UE CONTEXT SETUP REQUEST");
12939                   break;
12940                }
12941
12942             default:
12943                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation: %ld at decodeCellGrpCfg()", extIeInfo->id);
12944                break;
12945          }
12946       }
12947    }
12948    return ROK;
12949 }
12950
12951 /*******************************************************************
12952  *
12953  * @brief Fills Srb List received by CU
12954  *
12955  * @details
12956  *
12957  *    Function : procSrbListToSetup
12958  *
12959  *    Functionality: Fills Srb List received  by CU
12960  *
12961  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
12962  *             DuLcCfg pointer
12963  *             RlcBearerCfg pointer
12964  * @return void
12965  *
12966  * ****************************************************************/
12967 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, DuLcCfg *duMacLcToAdd, RlcBearerCfg *rlcLcToAdd)
12968 {
12969
12970    /* Filling RLC INFO */
12971    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
12972
12973    /* Filling MAC INFO */
12974    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, duMacLcToAdd, NULL)  != ROK)
12975    {
12976       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
12977       return RFAILED;
12978    }
12979
12980    return ROK;
12981 }
12982
12983
12984
12985 /*******************************************************************
12986  *
12987  * @brief extract Srb List received by CU
12988  *
12989  * @details
12990  *
12991  *    Function : extractSrbListToSetup
12992  *
12993  *    Functionality: extract Srb List received by CU
12994  *                   for both MAC and RLC
12995  *
12996  * @params[in] SRBs_ToBeSetup_Item_t pointer
12997  *             DuUeCfg pointer
12998  * @return ROK/RFAIED
12999  *
13000  * ****************************************************************/
13001
13002 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
13003 {
13004    uint8_t ret = ROK, srbIdx = 0, rlcLcIdx = 0;
13005    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
13006    DuLcCfg *macLcCtxt = NULLP;
13007    RlcBearerCfg *rlcLcCtxt = NULLP;
13008
13009    if(srbCfg)
13010    {
13011       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
13012       {
13013          macLcCtxt = NULL;
13014          rlcLcCtxt = NULL;
13015
13016          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
13017          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
13018          {
13019             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
13020             ret = RFAILED;
13021             break;
13022          }
13023          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
13024          {
13025             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
13026             ret = RFAILED;
13027             break;
13028          }
13029
13030          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numMacLcs; rlcLcIdx++)
13031          {
13032             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == srbItem->sRBID && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_SRB)
13033             {
13034                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13035                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13036                break;
13037             }
13038          }
13039          if(!macLcCtxt)
13040          {
13041             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(DuLcCfg));
13042             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13043             ueCfgDb->numMacLcs++;
13044          }
13045          if(!rlcLcCtxt)
13046          {
13047             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
13048             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13049             ueCfgDb->numRlcLcs++;
13050          }
13051
13052          ret = procSrbListToSetup(srbItem, macLcCtxt, rlcLcCtxt);
13053
13054          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %ld [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13055                srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13056          if(ret == RFAILED)
13057          {
13058             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
13059             break;
13060          }
13061       }
13062    }
13063    else
13064       ret = RFAILED;
13065
13066    return ret;
13067 }
13068
13069 /*******************************************************************
13070  *
13071  * @brief Fills Drb List received by CU
13072  *
13073  * @details
13074  *
13075  *    Function : procDrbListToSetupMod
13076  *
13077  *    Functionality: Fills Drb List received by CU
13078  *                   for both MAC and RLC
13079  *
13080  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
13081  *             DRBs_ToBeModified_Item_t , lcId, DuLcCfg pointer,
13082  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
13083  * @return void
13084  *
13085  * ****************************************************************/
13086
13087 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
13088 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, DuLcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
13089 {
13090    uint8_t cfgIdx = 0;
13091    RlcMode rlcModeInfo;
13092
13093    if(drbItem != NULLP)
13094    {
13095       /* Filling RLC INFO */
13096       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
13097       qoSInformation);
13098
13099       /* Filling MAC INFO */
13100       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
13101       {
13102          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13103          return RFAILED;
13104       }
13105    }
13106    else if(drbSetupModItem != NULLP)
13107    {
13108       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
13109       &drbSetupModItem->qoSInformation);
13110
13111       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
13112       {
13113          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13114          return RFAILED;
13115       }
13116    }
13117    else if(drbModItem != NULLP)
13118    {
13119       /* Drb to Mod IEs doesnot have rlcMode to be modified
13120        * in ASN. Hence no change in RLC configurations */
13121       if(storedRlcUeCfg != NULLP)
13122       {
13123          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
13124          {
13125             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
13126             {
13127                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
13128                break;
13129             }
13130          }
13131       }
13132
13133       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
13134       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
13135       {
13136          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
13137          return RFAILED;
13138       }
13139    }
13140    return ROK;
13141 }
13142
13143 /*******************************************************************
13144  *
13145  * @brief extract Drb List received by CU
13146  *
13147  * @details
13148  *
13149  *    Function : extractDrbListToSetupMod
13150  *
13151  *    Functionality: extract Drb List received by CU
13152  *                   for both MAC and RLC
13153  *
13154  * @params[in] DRBs_ToBeSetup_Item_t pointer
13155  *             DuUeCfg pointer
13156  * @return ROK/RFAIED
13157  *
13158  * ****************************************************************/
13159
13160 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
13161  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
13162 {
13163    uint8_t ret = ROK;
13164    uint8_t drbIdx = 0, rlcLcIdx = 0;
13165    uint8_t drbId = 0, lcId = 0;
13166    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
13167    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
13168    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
13169    DuLcCfg *macLcCtxt = NULLP;
13170    RlcBearerCfg *rlcLcCtxt = NULLP;
13171
13172    ret = ROK;
13173    if(drbCount > 0)
13174    {
13175       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
13176       {
13177          macLcCtxt = NULL;
13178          rlcLcCtxt = NULL;
13179
13180          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
13181          {
13182             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
13183             ret = RFAILED;
13184             break;
13185          }
13186          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
13187          {
13188             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
13189             ret = RFAILED;
13190             break;
13191          }
13192
13193          if(drbModCfg != NULLP)
13194          {
13195             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
13196             drbId = drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID;
13197          }
13198          else if(drbCfg != NULLP)
13199             drbId = drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item.dRBID;
13200          else if(drbSetupModCfg != NULL)
13201          {
13202             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
13203             drbId = drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item.dRBID;
13204          }
13205
13206          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numRlcLcs; rlcLcIdx++)
13207          {
13208             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == drbId && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_DRB)
13209             {
13210                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13211                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13212                break;
13213             }
13214          }
13215          if(!macLcCtxt)
13216          {
13217             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(DuLcCfg));
13218             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13219             ueCfgDb->numMacLcs++;
13220          }
13221          if(!rlcLcCtxt)
13222          {
13223             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
13224             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13225             ueCfgDb->numRlcLcs++;
13226          }
13227
13228          if(drbModCfg != NULLP)
13229          {
13230             lcId = fetchLcId(drbId);
13231             if(lcId < MIN_DRB_LCID)
13232             {
13233                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
13234                break;
13235             }
13236             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
13237             macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13238             if(ret == RFAILED)
13239             {
13240                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
13241                break;
13242             }
13243             ueCfgDb->numDrbModified++;
13244          }
13245          else
13246          {
13247             lcId = getDrbLcId(drbBitMap);
13248             if(lcId == RFAILED)
13249             {
13250                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
13251                ret = RFAILED;
13252                break;
13253             }
13254             if(drbCfg != NULL)
13255             {
13256                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
13257                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13258                if(ret == RFAILED)
13259                {
13260                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
13261                   break;
13262                }
13263             }
13264             else if(drbSetupModCfg != NULL)
13265             {
13266                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
13267                      macLcCtxt, rlcLcCtxt, &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
13268                if(ret == RFAILED)
13269                {
13270                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
13271                   break;
13272                }
13273                ueCfgDb->numDrbSetupMod++;
13274             }
13275          }
13276          ueCfgDb->numDrb++;
13277
13278          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13279                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13280          if(ret == RFAILED)
13281          {
13282             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
13283             break;
13284          }
13285       }
13286    }
13287    else
13288       ret = RFAILED;
13289
13290    return ret;
13291 }
13292
13293 /*******************************************************************
13294  *
13295  * @brief extract Drb List received from CU
13296  *
13297  * @details
13298  *
13299  *    Function : extractDrbListToRelease
13300  *
13301  *    Functionality: extract Drb List received from CU
13302  *                   for both MAC and RLC
13303  *
13304  * @params[in] DRBs_ToBeReleased_Item_t pointer
13305  *             DuUeCfg pointer
13306  * @return ROK/RFAIED
13307  *
13308  * ****************************************************************/
13309
13310 uint8_t extractDrbListToRelease(uint8_t ueId, DRBs_ToBeReleased_List_t *drbToRel, uint8_t drbCount, DuUeCfg *ueCfgDb, RlcUeCfg *rlcUeCfg)
13311 {
13312    uint8_t ret = ROK, teIdx = 0;
13313    uint8_t drbIdx = 0, rlcLcIdx = 0;
13314    uint8_t drbId = 0, lcId = 0;
13315    DRBs_ToBeReleased_ItemIEs_t *drbRelItem = NULLP;
13316    DuLcCfg *macLcCtxt = NULLP;
13317    RlcBearerCfg *rlcLcCtxt = NULLP;
13318
13319    ret = ROK;
13320    if(drbCount > 0)
13321    {
13322       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
13323       {
13324          macLcCtxt = NULL;
13325          rlcLcCtxt = NULL;
13326
13327          if(drbToRel != NULLP)
13328          {
13329             drbRelItem = (DRBs_ToBeReleased_ItemIEs_t *) drbToRel->list.array[drbIdx];
13330             drbId = drbRelItem->value.choice.DRBs_ToBeReleased_Item.dRBID;
13331          }
13332          else
13333          {
13334             DU_LOG("ERROR  --> DU APP : DrbToRelease pointer is NULL in extractDrbListToRelease");
13335             return RFAILED;
13336          }
13337
13338          for(rlcLcIdx = 0; rlcLcIdx < ueCfgDb->numRlcLcs; rlcLcIdx++)
13339          {
13340             if(ueCfgDb->rlcLcCfg[rlcLcIdx].rbId == drbId && ueCfgDb->rlcLcCfg[rlcLcIdx].rbType == RB_TYPE_DRB)
13341             {
13342                macLcCtxt = &ueCfgDb->macLcCfg[rlcLcIdx];
13343                rlcLcCtxt = &ueCfgDb->rlcLcCfg[rlcLcIdx];
13344                break;
13345             }
13346          }
13347
13348          if(!macLcCtxt)
13349          {
13350             memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(DuLcCfg));
13351             macLcCtxt = &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs];
13352             ueCfgDb->numMacLcs++;
13353          }
13354          if(!rlcLcCtxt)
13355          {
13356             memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
13357             rlcLcCtxt = &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs];
13358             ueCfgDb->numRlcLcs++;
13359          }
13360          lcId = fetchLcId(drbId);
13361          if(lcId < MIN_DRB_LCID)
13362          {
13363             DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToRelease() for Modified List", lcId);
13364             break;
13365          }
13366
13367          /* Filling RLC INFO */
13368          procRlcLcCfg(drbId, lcId, RB_TYPE_DRB, rlcLcCtxt->rlcMode, CONFIG_DEL, NULL, rlcLcCtxt, NULLP);
13369          /* Filling MAC INFO */
13370          if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_DEL, NULL, NULL, NULL, NULL, macLcCtxt, NULLP) != ROK)
13371          {
13372             DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in extractDrbListToRelease()");
13373             return RFAILED;
13374          }
13375          ueCfgDb->upTnlInfo[ueCfgDb->numDrb].configType = CONFIG_DEL;
13376          ueCfgDb->upTnlInfo[ueCfgDb->numDrb].drbId = drbId;
13377          ueCfgDb->upTnlInfo[ueCfgDb->numDrb].ueId = ueId;
13378
13379          for(teIdx = 0; teIdx < duCb.numTeId; teIdx++)
13380          {
13381             if((duCb.upTnlCfg[teIdx]->ueId == ueCfgDb->upTnlInfo[ueCfgDb->numDrb].ueId) && \
13382                   (duCb.upTnlCfg[teIdx]->drbId == ueCfgDb->upTnlInfo[ueCfgDb->numDrb].drbId))
13383             {
13384                DU_ALLOC(ueCfgDb->upTnlInfo[ueCfgDb->numDrb].tnlCfg1, sizeof(GtpTnlCfg));
13385                memcpy(ueCfgDb->upTnlInfo[ueCfgDb->numDrb].tnlCfg1, duCb.upTnlCfg[teIdx]->tnlCfg1, sizeof(GtpTnlCfg));
13386                break;
13387             }
13388          }
13389
13390          ueCfgDb->numDrb++;
13391          if(ret == RFAILED)
13392          {
13393             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToRelease() for Modified List");
13394             break;
13395          }
13396
13397          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToRelease():lcId:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
13398                lcId,ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
13399       }
13400    }
13401    else
13402       ret = RFAILED;
13403
13404    return ret;
13405 }
13406
13407 /*******************************************************************
13408  *
13409  * @brief Function to extract Dl RRC Msg received from CU
13410  *
13411  * @details
13412  *
13413  *    Function : extractDlRrcMsg
13414  *
13415  *    Functionality: Function to extract Dl RRC Msg received from CU
13416  *
13417  * @params[in] F1AP message
13418  * @return ROK     - success
13419  *         RFAILED - failure
13420  *
13421  * ****************************************************************/
13422
13423 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
13424    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
13425 {
13426    uint8_t ret = ROK;
13427    dlRrcMsg->rrcMsgSize = rrcContainer->size;
13428    if(dlRrcMsg->rrcMsgSize > 0)
13429    {
13430       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
13431       if(!dlRrcMsg->rrcMsgPdu)
13432       {
13433          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
13434          ret = RFAILED;
13435       }
13436       else
13437       {
13438          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
13439          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
13440          dlRrcMsg->srbId = SRB1_LCID;
13441          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
13442       }
13443    }
13444    return ret;
13445 }
13446
13447 /*******************************************************************
13448  *
13449  * @brief Extract UE capability info
13450  *
13451  * @details
13452  *
13453  *    Function : extractUeCapability
13454  *
13455  *    Functionality: Extract UE capability info and stores in ue Cb
13456  *
13457  * @params[in] Octet string of UE capability RAT container list
13458  * @return ROK     - success
13459  *         RFAILED - failure
13460  *
13461  * ****************************************************************/
13462 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
13463 {
13464    uint8_t  idx;
13465    uint16_t recvBufLen;
13466    asn_dec_rval_t rval;
13467    UE_NR_Capability_t  *ueNrCap = NULLP;
13468    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
13469
13470    /* Decoding UE Capability RAT Container List */
13471    recvBufLen = ueCapablityListBuf->size;
13472    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13473    if(!ueCapRatContList)
13474    {
13475       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
13476       return NULLP;
13477    }
13478    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13479    memset(&rval, 0, sizeof(asn_dec_rval_t));
13480    rval = uper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
13481           ueCapablityListBuf->buf, recvBufLen, 0, 0);
13482    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13483    {
13484       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13485       return NULLP;
13486    }
13487    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
13488
13489    /* Free encoded buffer after decoding */
13490
13491    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
13492    {
13493       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
13494       {
13495          /* Decoding UE NR Capability */
13496           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
13497           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
13498           if(!ueNrCap)
13499           {
13500              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
13501              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13502              return NULLP;
13503           }
13504           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
13505           memset(&rval, 0, sizeof(asn_dec_rval_t));
13506           rval = uper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
13507                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
13508           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13509           {
13510              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
13511              return NULLP;
13512           }
13513           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
13514
13515           /* Free encoded buffer after decoding */
13516           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
13517       }
13518       free(ueCapRatContList->list.array[idx]);
13519    }
13520
13521    /* Free Memory*/
13522    free(ueCapRatContList->list.array);
13523    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
13524    return ueNrCap;
13525 }
13526
13527 /*******************************************************************
13528 *
13529 * @brief free UE context setup request from CU
13530 *
13531 * @details
13532 *
13533 *    Function : freeAperDecodeF1UeContextSetupReq
13534 *
13535 *    Functionality: freeing part for the memory allocated by aper_decoder
13536 *
13537 * @params[in] F1AP message
13538 * @return ROK     - success
13539 *         RFAILED - failure
13540 *
13541 * ****************************************************************/
13542 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
13543 {
13544    uint8_t ieIdx = 0;
13545
13546    if(ueSetReq->protocolIEs.list.array != NULLP)
13547    {
13548       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
13549       {
13550          if(ueSetReq->protocolIEs.list.array[ieIdx])
13551          {
13552             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13553             {
13554                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13555                   break;
13556                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13557                   break;
13558                case ProtocolIE_ID_id_SpCell_ID:
13559                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
13560                   break;
13561                case ProtocolIE_ID_id_ServCellIndex:
13562                   break;
13563                case ProtocolIE_ID_id_SpCellULConfigured:
13564                   break;
13565                case ProtocolIE_ID_id_CUtoDURRCInformation:
13566
13567                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
13568                   break;
13569                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
13570
13571                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
13572                   break;
13573                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13574
13575                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
13576                   break;
13577                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13578
13579                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
13580                   break;
13581                case ProtocolIE_ID_id_RRCContainer:
13582                   {
13583
13584                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
13585                      {
13586
13587                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13588                      }
13589                      break;
13590                   }
13591                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13592                   break;
13593                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
13594                   {
13595                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
13596                      {
13597                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
13598                      }
13599                      break;
13600                   }
13601 #ifdef NR_DRX
13602                case ProtocolIE_ID_id_DRXCycle:
13603                   {
13604                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleLength)
13605                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleLength);
13606                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleTimer)
13607                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle.shortDRXCycleTimer);
13608                      break;
13609                   }
13610 #endif
13611                 default:
13612                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
13613             }
13614             free(ueSetReq->protocolIEs.list.array[ieIdx]);
13615          }
13616       }
13617       free(ueSetReq->protocolIEs.list.array);
13618    }
13619 }
13620 /*******************************************************************
13621  *
13622  * @brief Process UE context setup request from CU
13623  *
13624  * @details
13625  *
13626  *    Function : procF1UeContextSetupReq
13627  *
13628  *    Functionality: Process UE context setup request from CU
13629  *
13630  * @params[in] F1AP message
13631  * @return ROK     - success
13632  *         RFAILED - failure
13633  *
13634  * ****************************************************************/
13635 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
13636 {
13637    int8_t ueIdx = -1;
13638    uint8_t  ret=0, ieIdx=0, ieExtIdx = 0;
13639    //uint8_t servCellIdx = 0;
13640    bool ueCbFound = false, hoInProgress = false;
13641    uint16_t cellIdx=0;
13642    uint64_t nrCellId = 0;
13643    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
13644    DuUeCb   *duUeCb = NULL;
13645    UEContextSetupRequest_t   *ueSetReq = NULL;
13646    DRBs_ToBeSetup_List_t *drbCfg = NULL;
13647    CUtoDURRCInformation_t *rrcInfo = NULL;
13648 #ifdef NR_DRX
13649    DRXCycle_t *drxCycle;
13650 #endif
13651    ret = ROK;
13652
13653    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
13654    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13655    {
13656       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
13657       {
13658          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13659             {
13660                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13661                break;
13662             }
13663
13664          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13665             {
13666                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13667                break;
13668             }
13669
13670          case ProtocolIE_ID_id_SpCell_ID:
13671             {
13672                bitStringToInt(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity, &nrCellId);
13673
13674                GET_CELL_IDX(nrCellId, cellIdx);
13675                if(!duCb.actvCellLst[cellIdx])
13676                {
13677                   DU_LOG("\nERROR  -->  F1AP : Cell Id [%lu] not found", nrCellId);
13678                   ret = RFAILED;
13679                }
13680                break;
13681             }
13682
13683          case ProtocolIE_ID_id_ServCellIndex:
13684             {
13685                //servCellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
13686                break;
13687             }
13688
13689          case ProtocolIE_ID_id_SpCellULConfigured:
13690             {
13691                /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
13692                   UL, SUL or UL+SUL for the indicated cell for the UE */
13693                break;
13694             }
13695
13696          case ProtocolIE_ID_id_CUtoDURRCInformation:
13697             {
13698                rrcInfo = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation;
13699
13700                /* Search if UE context is present */
13701                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
13702                {
13703                   if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId)
13704                   {
13705                      ueCbFound = true;
13706                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13707                      break;
13708                   }
13709                }
13710
13711                /* Check if UE Handover scenario */
13712                if(rrcInfo->iE_Extensions)
13713                {
13714                   for(ieExtIdx = 0; ieExtIdx < rrcInfo->iE_Extensions->list.count; ieExtIdx++)
13715                   {
13716                      if(rrcInfo->iE_Extensions->list.array[ieExtIdx]->id == ProtocolIE_ID_id_HandoverPreparationInformation)
13717                      {
13718                         hoInProgress = true;
13719                         break;
13720                      }
13721                   }
13722                }
13723
13724                /* If UE context is not present, but UE is in handover */
13725                if(!ueCbFound && hoInProgress)
13726                {
13727                   ueIdx = getFreeBitFromUeBitMap(nrCellId);
13728                   if(ueIdx != -1)
13729                      gnbDuUeF1apId = ueIdx +1;
13730                   else
13731                   {
13732                      DU_LOG("\nERROR  -->  F1AP : No free UE IDX found in UE bit map of cell Id [%lu]", nrCellId);
13733                      ret = RFAILED;
13734                      break;
13735                   }
13736                   duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13737                   duUeCb->f1UeDb = NULL;
13738                   duUeCb->gnbCuUeF1apId = gnbCuUeF1apId;
13739                   duUeCb->gnbDuUeF1apId = gnbDuUeF1apId;
13740                   GET_CRNTI(duUeCb->crnti, duUeCb->gnbDuUeF1apId);
13741                   duUeCb->ueState = UE_HANDIN_IN_PROGRESS;
13742                }
13743
13744                if(duUeCb)
13745                {
13746                   DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13747                   if(duUeCb->f1UeDb)
13748                   {
13749                      memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13750                      duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
13751                      duUeCb->f1UeDb->cellIdx = cellIdx;
13752                   }
13753                   else
13754                   {
13755                      DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
13756                      ret = RFAILED;
13757                      break;
13758                   }
13759                }
13760                else
13761                {
13762                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13763                   ret = RFAILED;
13764                   break;
13765                }
13766
13767                /* Extract UE capability info */
13768                if(rrcInfo->uE_CapabilityRAT_ContainerList)
13769                {
13770                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = extractUeCapability(rrcInfo->uE_CapabilityRAT_ContainerList, duUeCb);
13771                }
13772
13773                /* Extract IE extension */
13774                if(rrcInfo->iE_Extensions)
13775                {
13776                   if(extractCuToDuRrcInfoExt(rrcInfo->iE_Extensions, &duUeCb->f1UeDb->duUeCfg) != ROK)
13777                   {
13778                      DU_LOG("\nERROR  -->  F1AP: Failed to extract CU to DU RRC information extension IE");
13779                      //TODO: Update the failure cause in ue context Setup Response
13780                      ret = RFAILED;
13781                   }
13782                }
13783                break;
13784             }
13785
13786 #ifdef NR_DRX
13787          case ProtocolIE_ID_id_DRXCycle:
13788             {
13789                duUeCb->f1UeDb->duUeCfg.drxCyclePres = true;
13790                drxCycle = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRXCycle;
13791                duUeCb->f1UeDb->duUeCfg.drxCycle.drxLongCycleLength =  convertLongDrxCycleLengthEnumToValue(drxCycle->longDRXCycleLength);
13792                if(drxCycle->shortDRXCycleLength)
13793                {
13794                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCyclePres = true;
13795                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycle = \
13796                   convertShortDrxCycleLengthEnumToValue(*(drxCycle->shortDRXCycleLength));
13797                }
13798                if(drxCycle->shortDRXCycleTimer)
13799                   duUeCb->f1UeDb->duUeCfg.drxCycle.shortDrxCycle.drxShortCycleTimer = *(drxCycle->shortDRXCycleTimer);
13800
13801                break;
13802             }
13803
13804 #endif
13805          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
13806             {
13807                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
13808                         &duUeCb->f1UeDb->duUeCfg))
13809                {
13810                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
13811                   //TODO: Update the failure cause in ue context Setup Response
13812                   ret = RFAILED;
13813                }
13814                break;
13815             }
13816
13817          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
13818             {
13819                drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
13820
13821                if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
13822                {
13823                   DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
13824                   //TODO: Update the failure cause in ue context Setup Response
13825                   ret = RFAILED;
13826                }
13827                break;
13828             }
13829          case ProtocolIE_ID_id_RRCContainer:
13830             {
13831                /* Filling Dl RRC Msg Info */
13832                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13833                if(!duUeCb->f1UeDb->dlRrcMsg)
13834                {
13835                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
13836                   ret = RFAILED;
13837                }
13838                else
13839                {
13840                   duUeCb->f1UeDb->dlRrcMsgPres = true;
13841                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13842                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13843                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
13844                }
13845                break;
13846             }
13847
13848          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
13849             {
13850                if(duUeCb->f1UeDb->dlRrcMsg)
13851                {
13852                   if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
13853                   {
13854                      duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
13855                   }
13856                   else
13857                   {
13858                      DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
13859                   }
13860                }
13861                break;
13862             }
13863
13864          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
13865             {
13866                /* MaximumBitRate Uplink */
13867                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
13868                if(bitRateSize > 0)
13869                {
13870                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
13871                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
13872                   {
13873                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
13874                      ret = RFAILED;
13875                   }
13876                   else
13877                   {
13878                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
13879                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
13880                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
13881                   }
13882                }
13883                else
13884                   ret = RFAILED;
13885                break;
13886             }
13887
13888          default:
13889             {
13890                break;
13891             }
13892       } /* End of switch */
13893
13894       /* In case of any failure in any IE */
13895       if(ret == RFAILED)
13896       {
13897          // BuildAndSendUeContextSetupRsp(cellId,ueId);
13898          DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
13899          break;
13900       }
13901    } /* End of for loop of IEs */
13902
13903    if(ret == ROK)
13904       ret = duProcUeContextSetupRequest(duUeCb);
13905
13906    freeAperDecodeF1UeContextSetupReq(ueSetReq);
13907    return ret;
13908
13909 }
13910 /*******************************************************************
13911  * @brief Free the memory allocated for Dl Tunnel Info
13912  *
13913  * @details
13914  *
13915  *    Function : freeDlTnlInfo
13916  *
13917  *    Functionality:
13918  *       Free the memory allocated for Dl Tunnel Info
13919  *
13920  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
13921  * @return void
13922  *
13923  * ****************************************************************/
13924
13925 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
13926 {
13927    uint8_t arrIdx = 0;
13928
13929    if(tnlInfo)
13930    {
13931       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
13932       {
13933          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
13934                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
13935          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
13936                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
13937          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
13938          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
13939       }
13940       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
13941    }
13942 }
13943
13944 /*******************************************************************
13945  * @brief Free the memory allocated for DRB setup List
13946  *
13947  * @details
13948  *
13949  *    Function : freeDrbSetupList
13950  *
13951  *    Functionality:
13952  *       Free the memory allocated for DRB setup list
13953  *
13954  * @params[in] DRBs_Setup_List_t *
13955  * @return void
13956  *
13957  * ****************************************************************/
13958 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
13959 {
13960    uint8_t arrIdx = 0;
13961    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
13962
13963    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
13964    {
13965       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
13966       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
13967       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
13968    }
13969    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
13970 }
13971
13972 /*******************************************************************
13973  * @brief Free the memory allocated for UE Setup response
13974  *
13975  * @details
13976  *
13977  *    Function : FreeUeContextSetupRsp
13978  *
13979  *    Functionality:
13980  *       Free the memory allocated for UE Setup response
13981  *
13982  * @params[in] F1AP PDU for UE setup response
13983  * @return ROK     - success
13984  *         RFAILED - failure
13985  *
13986  * ****************************************************************/
13987 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
13988 {
13989    uint8_t idx;
13990    UEContextSetupResponse_t *ueSetRsp = NULLP;
13991
13992    if(f1apMsg)
13993    {
13994       if(f1apMsg->choice.successfulOutcome)
13995       {
13996          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
13997                     UEContextSetupResponse;
13998          if(ueSetRsp->protocolIEs.list.array)
13999          {
14000             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
14001             {
14002                if(ueSetRsp->protocolIEs.list.array[idx])
14003                {
14004                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
14005                   {
14006                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14007                         break;
14008                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14009                         break;
14010                      case ProtocolIE_ID_id_C_RNTI:
14011                         break;
14012                      case ProtocolIE_ID_id_DUtoCURRCInformation:
14013                         {
14014                            CellGroupConfig_t *cellGrpCfg = NULLP;
14015                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
14016                                          DUtoCURRCInformation.cellGroupConfig;
14017                            if(cellGrpCfg->buf != NULLP)
14018                            {
14019                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
14020                               cellGrpCfg = NULLP;
14021                            }
14022                            break;
14023                         }
14024                      case ProtocolIE_ID_id_DRBs_Setup_List:
14025                         {
14026                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
14027                            break;
14028                         }
14029                      default:
14030                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
14031                               ueSetRsp->protocolIEs.list.array[idx]->id);
14032                         break;
14033                   }
14034                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
14035                         sizeof(UEContextSetupResponseIEs_t));
14036                }
14037             }
14038             DU_FREE(ueSetRsp->protocolIEs.list.array, \
14039                   ueSetRsp->protocolIEs.list.size);
14040          }
14041          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14042       }
14043       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14044    }
14045 }
14046
14047 /*******************************************************************
14048  *
14049  * @brief Builds Ue context Setup Rsp DU To CU Info
14050  *
14051  * @details
14052  *
14053  *    Function : EncodeUeCntxtDuToCuInfo
14054  *
14055  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
14056  *
14057  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
14058  *
14059  * @return ROK     - success
14060  *         RFAILED - failure
14061  *
14062  ******************************************************************/
14063
14064 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
14065 {
14066    asn_enc_rval_t        encRetVal;
14067
14068    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
14069    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
14070    encBufSize = 0;
14071    encRetVal = uper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
14072    /* Encode results */
14073    if(encRetVal.encoded == ENCODE_FAIL)
14074    {
14075       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
14076             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14077       return RFAILED;
14078    }
14079    else
14080    {
14081       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
14082 #ifdef DEBUG_ASN_PRINT
14083       for(int i=0; i< encBufSize; i++)
14084       {
14085          printf("%x",encBuf[i]);
14086       }
14087 #endif
14088    }
14089    duToCuCellGrp->size = encBufSize;
14090    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
14091    if(!duToCuCellGrp->buf)
14092    {
14093       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
14094    }
14095    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
14096    return ROK;
14097 }
14098
14099 /*******************************************************************
14100  *
14101  * @brief Fills Dl Gtp tunnel Info
14102  *
14103  * @details
14104  *
14105  *    Function : fillGtpTunnelforDl
14106  *
14107  *    Functionality: Fills Dl Gtp tunnel Info
14108  *
14109  * @params[in]
14110  *
14111  * @return ROK     - success
14112  *         RFAILED - failure
14113  *
14114  * ****************************************************************/
14115
14116 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
14117 {
14118    uint8_t bufSize = 0;
14119
14120    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
14121    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
14122    if(gtpDl->transportLayerAddress.buf == NULLP)
14123    {
14124       return RFAILED;
14125    }
14126    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
14127
14128    /*GTP TEID*/
14129    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
14130    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
14131    if(gtpDl->gTP_TEID.buf == NULLP)
14132    {
14133       return RFAILED;
14134    }
14135    bufSize = 3; /*forming an Octect String*/
14136    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
14137
14138    return ROK;
14139 }
14140
14141 /*******************************************************************
14142  *
14143  * @brief Fills DL Tunnel Setup List
14144  *
14145  * @details
14146  *
14147  *    Function : fillDlTnlSetupList
14148  *
14149  *    Functionality: Fills the DL Tunnel Setup List
14150  *
14151  * @params[in]
14152  *
14153  * @return ROK     - success
14154  *         RFAILED - failure
14155  *
14156  * ****************************************************************/
14157
14158 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
14159 {
14160    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14161
14162    eleCount = 1;
14163    dlTnlInfo->list.count = eleCount;
14164    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
14165
14166    /* Initialize the DL Tnl Setup List Members */
14167    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
14168    if(dlTnlInfo->list.array == NULLP)
14169    {
14170       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
14171       ret = RFAILED;
14172    }
14173    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14174    {
14175       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
14176       if(dlTnlInfo->list.array[arrIdx] == NULLP)
14177       {
14178          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
14179          return RFAILED;
14180       }
14181       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
14182       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
14183       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
14184       {
14185          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
14186          return RFAILED;
14187       }
14188       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
14189                tnlCfg->tnlCfg1);
14190       if(ret != ROK)
14191          break;
14192    }
14193    return ret;
14194 }
14195
14196 /*******************************************************************
14197  *
14198  * @brief Fills the Drb Setup List for Ue Context Setup Response
14199  *
14200  * @details
14201  *
14202  *    Function : fillDrbSetupList
14203  *
14204  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
14205  *
14206  * @params[in]
14207  *
14208  * @return ROK     - success
14209  *         RFAILED - failure
14210  *
14211  * ****************************************************************/
14212 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
14213 {
14214    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
14215    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
14216
14217    eleCount = ueCfg->numDrb;
14218    drbSetupList->list.count = eleCount;
14219    drbSetupList->list.size = \
14220         (eleCount * sizeof(DRBs_Setup_Item_t *));
14221
14222    /* Initialize the Drb Setup List Members */
14223    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
14224    if(drbSetupList->list.array == NULLP)
14225    {
14226       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
14227       ret = RFAILED;
14228    }
14229
14230    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
14231    {
14232       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
14233       if(drbSetupList->list.array[arrIdx] == NULLP)
14234       {
14235          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
14236          return RFAILED;
14237       }
14238       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
14239       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
14240       drbItemIe->criticality = Criticality_reject;
14241       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
14242       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
14243       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
14244           &ueCfg->upTnlInfo[arrIdx]);
14245       if(ret != ROK)
14246          break;
14247    }
14248    return ret;
14249 }
14250
14251 /*******************************************************************
14252  *
14253  * @brief Builds and sends the UE Setup Response
14254  *
14255  * @details
14256  *
14257  *    Function : BuildAndSendUeContextSetupRsp
14258  *
14259  *    Functionality: Constructs the UE Setup Response and sends
14260  *                   it to the DU through SCTP.
14261  *
14262  * @params[in] uint8_t cellId,uint8_t ueId
14263  *
14264  * @return ROK     - success
14265  *         RFAILED - failure
14266  *
14267  * ****************************************************************/
14268 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
14269 {
14270    uint8_t   idx, ret, cellIdx, elementCnt;
14271    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
14272    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
14273    asn_enc_rval_t  encRetVal;        /* Encoder return value */
14274    F1AP_PDU_t               *f1apMsg = NULLP;
14275    UEContextSetupResponse_t *ueSetRsp = NULLP;
14276    DuUeCb                   *ueCb = NULLP;
14277
14278    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
14279
14280    while(true)
14281    {
14282       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14283       if(f1apMsg == NULLP)
14284       {
14285          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14286          ret = RFAILED;
14287          break;
14288       }
14289
14290       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
14291       DU_ALLOC(f1apMsg->choice.successfulOutcome,
14292             sizeof(SuccessfulOutcome_t));
14293       if(f1apMsg->choice.successfulOutcome == NULLP)
14294       {
14295          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
14296          ret = RFAILED;
14297          break;
14298       }
14299
14300       f1apMsg->choice.successfulOutcome->procedureCode = \
14301                                                          ProcedureCode_id_UEContextSetup;
14302       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
14303       f1apMsg->choice.successfulOutcome->value.present = \
14304                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
14305
14306       ueSetRsp =
14307          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
14308       elementCnt = 5;
14309       ueSetRsp->protocolIEs.list.count = elementCnt;
14310       ueSetRsp->protocolIEs.list.size = \
14311                                         elementCnt * sizeof(UEContextSetupResponse_t *);
14312
14313       /* Initialize the UESetup members */
14314       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
14315             ueSetRsp->protocolIEs.list.size);
14316       if(ueSetRsp->protocolIEs.list.array == NULLP)
14317       {
14318          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14319          ret = RFAILED;
14320          break;
14321       }
14322
14323       for(idx=0; idx<elementCnt; idx++)
14324       {
14325          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
14326                sizeof(UEContextSetupResponseIEs_t));
14327          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
14328          {
14329             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
14330             ret = RFAILED;
14331             break;
14332          }
14333       }
14334       /* Fetching Ue Cb Info*/
14335       GET_CELL_IDX(cellId, cellIdx);
14336       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
14337       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
14338       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
14339
14340       idx = 0;
14341       /*GNB CU UE F1AP ID*/
14342       ueSetRsp->protocolIEs.list.array[idx]->id = \
14343                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
14344       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14345       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14346                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
14347       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
14348
14349       /*GNB DU UE F1AP ID*/
14350       idx++;
14351       ueSetRsp->protocolIEs.list.array[idx]->id = \
14352                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
14353       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14354       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
14355                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
14356       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
14357
14358
14359       /*DUtoCURRC Information */
14360       idx++;
14361       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14362                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
14363       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14364       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14365                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
14366       BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
14367
14368       /* CRNTI */
14369       idx++;
14370       ueSetRsp->protocolIEs.list.array[idx]->id  = ProtocolIE_ID_id_C_RNTI;
14371       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14372       ueSetRsp->protocolIEs.list.array[idx]->value.present = UEContextSetupResponseIEs__value_PR_C_RNTI;
14373       ueSetRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI = ueCb->crnti;
14374
14375
14376       /* Drb Setup List */
14377       idx++;
14378       ueSetRsp->protocolIEs.list.array[idx]->id  = \
14379                                                    ProtocolIE_ID_id_DRBs_Setup_List;
14380       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14381       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
14382                                                             UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
14383       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
14384             &ueCb->f1UeDb->duUeCfg);
14385       if(ret == RFAILED)
14386       {
14387          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
14388          freeF1UeDb(ueCb->f1UeDb);
14389          ueCb->f1UeDb = NULLP;
14390          break;
14391       }
14392
14393       /* Free UeContext Db created during Ue context Req */
14394       freeF1UeDb(ueCb->f1UeDb);
14395       ueCb->f1UeDb = NULLP;
14396
14397       /* TODO: To send Drb list */
14398       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14399
14400       /* Encode the UE context setup response type as APER */
14401       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
14402       encBufSize = 0;
14403       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14404             encBuf);
14405       /* Encode results */
14406       if(encRetVal.encoded == ENCODE_FAIL)
14407       {
14408          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
14409                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14410          ret = RFAILED;
14411          break;
14412       }
14413       else
14414       {
14415          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
14416 #ifdef DEBUG_ASN_PRINT
14417          for(int i=0; i< encBufSize; i++)
14418          {
14419             printf("%x",encBuf[i]);
14420          }
14421 #endif
14422       }
14423
14424       /* Sending  msg  */
14425       if(sendF1APMsg()  != ROK)
14426       {
14427          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
14428          ret = RFAILED;
14429          break;
14430       }
14431       break;
14432    }
14433    FreeUeContextSetupRsp(f1apMsg);
14434    return ret;
14435 }/* End of BuildAndSendUeContextSetupRsp */
14436
14437 /*******************************************************************
14438 *
14439 * @brief  Build And Send Ue Context Rsp
14440 *
14441 * @details
14442 *
14443 *    Function : BuildAndSendUeCtxtRsp
14444 *
14445 *    Functionality : Build And Send Ue Context Rsp
14446
14447 * @params[in]
14448 * @return sucess = ROK
14449 *         failure = RFAILED
14450 *
14451 * ****************************************************************/
14452 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
14453 {
14454    uint8_t cellIdx = 0, actionType = 0;
14455
14456    GET_CELL_IDX(cellId, cellIdx);
14457    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
14458
14459    switch(actionType)
14460    {
14461       case UE_CTXT_SETUP:
14462          {
14463             if((BuildAndSendUeContextSetupRsp(cellId,ueId)) != ROK)
14464             {
14465                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextSetupRsp()");
14466                return RFAILED;
14467             }
14468             break;
14469          }
14470       case UE_CTXT_MOD:
14471          {
14472             if((BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1])) != ROK)
14473             {
14474                DU_LOG("\nERROR  -->  F1AP : Failed at BuildAndSendUeContextModRsp");
14475                return RFAILED;
14476             }
14477             break;
14478          }
14479       default:
14480          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
14481          break;
14482
14483    }
14484    return ROK;
14485 }
14486
14487 /*******************************************************************
14488  *
14489  * @brief deallocating the memory of  F1reset msg
14490  *
14491  * @details
14492  *
14493  *    Function : FreeF1ResetReq
14494  *
14495  *    Functionality :
14496  *         - freeing memory of F1reset request msg
14497  *
14498  * @params[in]
14499  * @return void
14500  *
14501  *
14502  * ****************************************************************/
14503 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
14504 {
14505    uint8_t idx =0 ;
14506    Reset_t *f1ResetMsg;
14507
14508    if(f1apMsg)
14509    {
14510       if(f1apMsg->choice.initiatingMessage)
14511       {
14512          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14513
14514          if(f1ResetMsg->protocolIEs.list.array)
14515          {
14516             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
14517             {
14518                if(f1ResetMsg->protocolIEs.list.array[idx])
14519                {
14520                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14521                }
14522             }
14523             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14524          }
14525          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14526       }
14527       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14528    }
14529 }
14530 /*******************************************************************
14531  *
14532  * @brief Build and Send F1reset request
14533  *
14534  * @details
14535  *
14536  *    Function : BuildAndSendF1ResetReq
14537  *
14538  *    Functionality:
14539  *         - Build and Send F1reset request msg
14540  *
14541  * @params[in]
14542  * @return ROK     - success
14543  *         RFAILED - failure
14544  *
14545  * ****************************************************************/
14546 uint8_t BuildAndSendF1ResetReq()
14547 {
14548    uint8_t          elementCnt=0;
14549    uint8_t          idx=0;
14550    uint8_t          ret= RFAILED;
14551    Reset_t          *f1ResetMsg = NULLP;
14552    F1AP_PDU_t       *f1apMsg = NULLP;
14553    asn_enc_rval_t   encRetVal;
14554    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
14555    do
14556    {
14557       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14558       if(f1apMsg == NULLP)
14559       {
14560          break;
14561       }
14562       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14563       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
14564       if(f1apMsg->choice.initiatingMessage == NULLP)
14565       {
14566          break;
14567       }
14568       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
14569       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
14570       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
14571
14572       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14573
14574       elementCnt = 3;
14575       f1ResetMsg->protocolIEs.list.count = elementCnt;
14576       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
14577
14578       /* Initialize the F1Setup members */
14579       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
14580       if(f1ResetMsg->protocolIEs.list.array == NULLP)
14581       {
14582          break;
14583       }
14584       for(idx=0; idx<elementCnt; idx++)
14585       {
14586          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
14587          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
14588          {
14589             break;
14590          }
14591       }
14592
14593       /*TransactionID*/
14594       idx=0;
14595       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14596       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14597       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
14598       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
14599
14600       /*Cause*/
14601       idx++;
14602       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
14603       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
14604       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
14605       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
14606       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
14607
14608       /*Reset Type*/
14609       idx++;
14610       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
14611       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14612       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
14613       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
14614       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
14615
14616       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14617
14618       /* Encode the F1SetupRequest type as APER */
14619       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14620       encBufSize = 0;
14621       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
14622             encBuf);
14623
14624       /* Encode results */
14625       if(encRetVal.encoded == ENCODE_FAIL)
14626       {
14627          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
14628                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14629          break;
14630       }
14631       else
14632       {
14633          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
14634 #ifdef DEBUG_ASN_PRINT
14635          for(idx=0; idx< encBufSize; idx++)
14636          {
14637             printf("%x",encBuf[idx]);
14638          }
14639 #endif
14640       }
14641
14642       if(sendF1APMsg() != ROK)
14643       {
14644          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
14645          break;
14646       }
14647
14648       ret = ROK;
14649       break;
14650    }while(true);
14651
14652    FreeF1ResetReq(f1apMsg);
14653    return ret;
14654 }
14655 /*******************************************************************
14656  *
14657  * @brief Build And Send F1ResetAck
14658  *
14659  * @details
14660  *
14661  *    Function : BuildAndSendF1ResetAck
14662  *
14663  *    Functionality:
14664  *         - Build And Send  F1ResetRSP
14665  *
14666  * @return ROK     - success
14667  *         RFAILED - failure
14668  *
14669  * ****************************************************************/
14670 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
14671 {
14672    uint8_t idx;
14673    ResetAcknowledge_t *f1ResetAck;
14674
14675    if(f1apMsg)
14676    {
14677       if(f1apMsg->choice.successfulOutcome)
14678       {
14679          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14680
14681          if(f1ResetAck->protocolIEs.list.array)
14682          {
14683             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
14684             {
14685                if(f1ResetAck->protocolIEs.list.array[idx])
14686                {
14687                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14688                }
14689             }
14690             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14691          }
14692          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14693       }
14694       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
14695    }
14696 }
14697
14698 /*******************************************************************
14699  *
14700  * @brief Build And Send F1ResetAck
14701  *
14702  * @details
14703  *
14704  *    Function : BuildAndSendF1ResetAck
14705  *
14706  *    Functionality:
14707  *         - Build And Send  F1ResetRSP
14708  *
14709  *  @params[in]
14710  * @return ROK     - success
14711  *         RFAILED - failure
14712  *
14713  * ****************************************************************/
14714 uint8_t BuildAndSendF1ResetAck()
14715 {
14716    uint8_t                idx = 0;
14717    uint8_t                elementCnt = 0;
14718    uint8_t                ret = RFAILED;
14719    F1AP_PDU_t             *f1apMsg = NULL;
14720    ResetAcknowledge_t     *f1ResetAck = NULLP;
14721    asn_enc_rval_t         encRetVal;
14722    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
14723
14724    do{
14725       /* Allocate the memory for F1ResetRequest_t */
14726       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14727       if(f1apMsg == NULLP)
14728       {
14729          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14730          break;
14731       }
14732
14733       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
14734
14735       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
14736       if(f1apMsg->choice.successfulOutcome == NULLP)
14737       {
14738          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14739          break;
14740       }
14741       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
14742       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
14743       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
14744
14745       elementCnt = 1;
14746
14747       f1ResetAck->protocolIEs.list.count = elementCnt;
14748       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
14749
14750       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
14751       if(f1ResetAck->protocolIEs.list.array == NULLP)
14752       {
14753          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
14754          break;
14755       }
14756
14757       for(idx=0; idx<elementCnt; idx++)
14758       {
14759          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
14760          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
14761          {
14762             break;
14763          }
14764       }
14765       /*TransactionID*/
14766       idx = 0;
14767       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
14768       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
14769       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
14770       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
14771
14772       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14773
14774       /* Encode the F1SetupRequest type as UPER */
14775       memset(encBuf, 0, ENC_BUF_MAX_LEN);
14776       encBufSize = 0;
14777       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
14778
14779       /* Check encode results */
14780       if(encRetVal.encoded == ENCODE_FAIL)
14781       {
14782          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
14783                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
14784          break;
14785       }
14786       else
14787       {
14788          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
14789 #ifdef DEBUG_ASN_PRINT
14790          for(int i=0; i< encBufSize; i++)
14791          {
14792             printf("%x",encBuf[i]);
14793          }
14794 #endif
14795       }
14796       /* Sending msg */
14797       if(sendF1APMsg() != ROK)
14798       {
14799          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
14800          break;
14801       }
14802
14803       ret = ROK;
14804       break;
14805    }while(true);
14806
14807    FreeF1ResetAck(f1apMsg);
14808    return ret;
14809 }
14810 /******************************************************************
14811 *
14812 * @brief free F1 reset msg allocated by aper_decoder
14813 *
14814 * @details
14815 *
14816 *    Function : freeAperDecodeF1ResetMsg
14817 *
14818 *    Functionality: free F1 reset msg allocated by aper_decoder
14819 *
14820 * @params[in] Reset_t *f1ResetMsg
14821 * @return void
14822 *
14823 * ****************************************************************/
14824
14825 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
14826 {
14827    uint8_t ieIdx =0;
14828    if(f1ResetMsg->protocolIEs.list.array)
14829    {
14830       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
14831       {
14832          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
14833          {
14834             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
14835          }
14836       }
14837       free(f1ResetMsg->protocolIEs.list.array);
14838    }
14839 }
14840
14841 /******************************************************************
14842  *
14843  * @brief Processes DL RRC Message Transfer  sent by CU
14844  *
14845  * @details
14846  *
14847  *    Function : procF1ResetReq
14848  *
14849  *    Functionality: Processes DL RRC Message Transfer sent by CU
14850  *
14851  * @params[in] F1AP_PDU_t ASN decoded F1AP message
14852  * @return ROK     - success
14853  *         RFAILED - failure
14854  *
14855  * ****************************************************************/
14856 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
14857 {
14858    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
14859    uint8_t       ieIdx = 0;
14860    uint8_t        ret = ROK;
14861    Reset_t       *f1ResetMsg = NULLP;
14862
14863    DU_LOG("\nINFO   -->  Processing F1 reset request");
14864    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
14865
14866    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
14867    {
14868       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
14869       {
14870          case ProtocolIE_ID_id_TransactionID:
14871             break;
14872
14873          case ProtocolIE_ID_id_Cause:
14874             break;
14875
14876          case ProtocolIE_ID_id_ResetType:
14877             {
14878                break;
14879             }
14880
14881          default:
14882             break;
14883       }
14884    }
14885    ret = BuildAndSendF1ResetAck();
14886    DU_LOG("\nINFO   -->  UE release is not supported for now");
14887
14888    freeAperDecodeF1ResetMsg(f1ResetMsg);
14889
14890    return ret;
14891 }
14892
14893 /*******************************************************************
14894  *
14895  * @brief free the RRC delivery report
14896  *
14897  * @details
14898  *
14899  *    Function : freeRrcDeliveryReport
14900  *
14901  *    Functionality: free the RRC delivery report
14902  *
14903  * @params[in]
14904  * @return ROK     - success
14905  *         RFAILED - failure
14906  *
14907  * ****************************************************************/
14908 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
14909 {
14910    uint8_t idx=0;
14911    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14912
14913    if(f1apMsg)
14914    {
14915       if(f1apMsg->choice.initiatingMessage)
14916       {
14917          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14918          if(rrcDeliveryReport->protocolIEs.list.array)
14919          {
14920             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
14921                   idx++)
14922             {
14923                if(rrcDeliveryReport->protocolIEs.list.array[idx])
14924                {
14925                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
14926                         sizeof(RRCDeliveryReportIEs_t));
14927                }
14928             }
14929             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
14930                   rrcDeliveryReport->protocolIEs.list.size);
14931          }
14932          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14933       }
14934       DU_FREE(f1apMsg,
14935             sizeof(F1AP_PDU_t));
14936    }
14937 }
14938
14939 /*******************************************************************
14940 *
14941 * @brief Builds and sends the RRC delivery report
14942 *
14943 * @details
14944 *
14945 *    Function : BuildAndSendRrcDeliveryReport
14946 *
14947 *    Functionality: Builds and sends the RRC delivery report
14948 *
14949 * @params[in]
14950 *
14951 * @return ROK     - success
14952 *         RFAILED - failure
14953 *
14954 * ****************************************************************/
14955 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
14956    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
14957 {
14958    uint8_t             ret = RFAILED;
14959    uint8_t             idx    = 0;
14960    uint8_t             idx1   = 0;
14961    uint8_t             elementCnt = 0;
14962    F1AP_PDU_t          *f1apMsg = NULLP;
14963    asn_enc_rval_t      encRetVal;
14964    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
14965
14966    do{
14967
14968       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
14969       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
14970       if(f1apMsg == NULLP)
14971       {
14972          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
14973          break;
14974       }
14975       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
14976       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
14977       if(f1apMsg->choice.initiatingMessage == NULLP)
14978       {
14979          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
14980          break;
14981       }
14982       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
14983       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
14984       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
14985
14986       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
14987       elementCnt = 4;
14988       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
14989       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
14990
14991       /* Initialize the F1Setup members */
14992       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
14993       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
14994       {
14995          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
14996          break;
14997       }
14998       for(idx =0 ;idx <elementCnt; idx++)
14999       {
15000          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
15001          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
15002          {
15003             break;
15004          }
15005       }
15006
15007       idx1 = 0;
15008
15009       /*GNB CU UE F1AP ID*/
15010       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
15011       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
15012       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
15013       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
15014
15015       /*GNB DU UE F1AP ID*/
15016       idx1++;
15017       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
15018       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
15019       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
15020       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
15021
15022       /*RRC delivery status*/
15023       idx1++;
15024       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
15025       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
15026       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
15027       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
15028       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
15029       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
15030       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
15031
15032       /* SRB ID */
15033       idx1++;
15034       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
15035       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
15036       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
15037       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
15038
15039       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
15040
15041       /* Encode the RRC DELIVERY REPORT type as APER */
15042       memset(encBuf, 0, ENC_BUF_MAX_LEN);
15043       encBufSize = 0;
15044       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
15045             encBuf);
15046
15047       /* Encode results */
15048       if(encRetVal.encoded == ENCODE_FAIL)
15049       {
15050          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
15051                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
15052          break;
15053       }
15054       else
15055       {
15056          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
15057 #ifdef DEBUG_ASN_PRINT
15058          for(idx=0; idx< encBufSize; idx++)
15059          {
15060             printf("%x",encBuf[idx]);
15061          }
15062 #endif
15063       }
15064
15065       /* Sending msg */
15066       if(sendF1APMsg() != ROK)
15067       {
15068          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
15069          break;
15070       }
15071       ret = ROK;
15072       break;
15073
15074    }while(true);
15075
15076    freeRrcDeliveryReport(f1apMsg);
15077    return ret;
15078 }
15079
15080 /*******************************************************************
15081  *
15082  * @brief Processes cells to be activated
15083  *
15084  * @details
15085  *
15086  *    Function : extractCellsToBeActivated
15087  *
15088  *    Functionality:
15089  *      - Processes cells to be activated list received in F1SetupRsp
15090  *
15091  * @params[in] void
15092  * @return ROK     - success
15093  *         RFAILED - failure
15094  *
15095  * ****************************************************************/
15096
15097 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
15098 {
15099    uint8_t  ret = ROK;
15100    uint16_t idx, pci = 0;
15101    uint64_t nci;
15102    Cells_to_be_Activated_List_Item_t cell;
15103
15104    for(idx=0; idx<cellsToActivate.list.count; idx++)
15105    {
15106       nci = 0;
15107       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
15108       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
15109
15110       if(cell.nRPCI)
15111       {
15112          pci = *cell.nRPCI;
15113       }
15114       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
15115    }
15116    return ret;
15117 }
15118 /******************************************************************
15119 *
15120 * @brief Processes F1 Setup Response allocated by aper_decoder
15121 *
15122 * @details
15123 *
15124 *    Function : freeF1SetupRsp
15125 *
15126 *    Functionality: free F1 Setup Response allocated by aper_decoder
15127 *
15128 * @params[in] F1SetupResponse_t *f1SetRspMsg
15129 * @return void
15130 *
15131 * ****************************************************************/
15132
15133 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
15134 {
15135    uint8_t ieIdx =0;
15136    uint8_t arrIdx =0;
15137    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
15138    RRC_Version_t      *rrcVer =NULLP;
15139
15140    if(f1SetRspMsg->protocolIEs.list.array)
15141    {
15142       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
15143       {
15144          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
15145          {
15146             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
15147             {
15148                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15149                   {
15150                      cellToActivate =
15151                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
15152                      if(cellToActivate->list.array)
15153                      {
15154                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
15155                         {
15156                            if(cellToActivate->list.array[arrIdx])
15157                            {
15158
15159                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
15160                               pLMN_Identity.buf)
15161                               {
15162                                  if(cellToActivate->list.array[0]->value.choice.\
15163                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
15164                                  {
15165                                     free(cellToActivate->list.array[0]->value.choice.\
15166                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
15167                                  }
15168
15169                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
15170                                        nRCGI.pLMN_Identity.buf);
15171                               }
15172                               free(cellToActivate->list.array[arrIdx]);
15173                            }
15174                         }
15175                         free(cellToActivate->list.array);
15176                      }
15177                      break;
15178                   }
15179                case ProtocolIE_ID_id_TransactionID:
15180                   {
15181                      break;
15182                   }
15183                case ProtocolIE_ID_id_gNB_CU_Name:
15184                   {
15185                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
15186                      break;
15187                   }
15188                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15189                   {
15190                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
15191                      if(rrcVer->latest_RRC_Version.buf)
15192                      {
15193                         if(rrcVer->iE_Extensions)
15194                         {
15195                            if(rrcVer->iE_Extensions->list.array)
15196                            {
15197                               if(rrcVer->iE_Extensions->list.array[0])
15198                               {
15199                                  if(rrcVer->iE_Extensions->list.\
15200                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
15201                                  {
15202                                     free(rrcVer->iE_Extensions->list.\
15203                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
15204                                  }
15205                                  free(rrcVer->iE_Extensions->list.array[0]);
15206                               }
15207                               free(rrcVer->iE_Extensions->list.array);
15208                            }
15209                            free(rrcVer->iE_Extensions);
15210                         }
15211                         free(rrcVer->latest_RRC_Version.buf);
15212                      }
15213                      break;
15214
15215                   }
15216                default:
15217                   {
15218                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15219                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
15220                   }
15221             }
15222             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
15223          }
15224       }
15225       free(f1SetRspMsg->protocolIEs.list.array);
15226    }
15227 }
15228 /******************************************************************
15229  *
15230  * @brief Processes F1 Setup Response sent by CU
15231  *
15232  * @details
15233  *
15234  *    Function : procF1SetupRsp
15235  *
15236  *    Functionality: Processes F1 Setup Response sent by CU
15237  *
15238  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15239  * @return ROK     - success
15240  *         RFAILED - failure
15241  *
15242  * ****************************************************************/
15243 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
15244 {
15245    uint8_t ret = ROK;
15246    uint16_t idx =0;
15247    F1SetupResponse_t *f1SetRspMsg = NULLP;
15248    GNB_CU_Name_t     *cuName = NULLP;
15249    F1SetupRsp  f1SetRspDb;
15250    RRC_Version_t      *rrcVer =NULLP;
15251
15252    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
15253
15254    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
15255    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
15256
15257    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
15258    {
15259       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
15260       {
15261          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15262             {
15263                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
15264                      value.choice.Cells_to_be_Activated_List);
15265                break;
15266             }
15267          case ProtocolIE_ID_id_TransactionID:
15268             {
15269                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
15270                                     value.choice.TransactionID;
15271                break;
15272             }
15273          case ProtocolIE_ID_id_gNB_CU_Name:
15274             {
15275                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
15276                         value.choice.GNB_CU_Name;
15277                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
15278                break;
15279             }
15280          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
15281             {
15282                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
15283                strcpy(f1SetRspDb.rrcVersion.rrcVer,
15284                      (const char*)rrcVer->latest_RRC_Version.buf);
15285                break;
15286             }
15287          default:
15288             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
15289                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
15290       }
15291       duProcF1SetupRsp();
15292    }
15293
15294    freeAperDecodeF1SetupRsp(f1SetRspMsg);
15295
15296    duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
15297    DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
15298    if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
15299    {
15300       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the buf of F1setup response");
15301       return RFAILED;
15302    }
15303    memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
15304
15305    if(BuildAndSendE2SetupReq() != ROK)
15306    {
15307       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
15308       return RFAILED;
15309    }
15310    return ret;
15311 }
15312 /*******************************************************************
15313 *
15314 * @brief free GNB DU config update ack
15315 *
15316 * @details
15317 *
15318 *    Function : freeAperDecodeGnbDuAck
15319 *
15320 *    Functionality: Processes GNB DU config update ack And
15321 *                     added free part for the memory allocated by aper_decoder
15322 *
15323 * @params[in] F1AP_PDU_t ASN decoded F1AP message
15324 * @return ROK     - success
15325 *         RFAILED - failure
15326 *
15327 * ****************************************************************/
15328
15329 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
15330 {
15331    uint8_t ieIdx = 0;
15332
15333    if(gnbDuAck->protocolIEs.list.array)
15334    {
15335       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15336       {
15337          if(gnbDuAck->protocolIEs.list.array[ieIdx])
15338          {
15339             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
15340          }
15341       }
15342       free(gnbDuAck->protocolIEs.list.array);
15343    }
15344 }
15345
15346 /*******************************************************************
15347 *
15348 * @brief Building  result of gnb-du config update ack output
15349 *
15350 * @details
15351 *
15352 *    Function : duProcGnbDuCfgUpdAckMsg
15353 *
15354 *    Functionality:
15355 *        Building output of gnb-du config update ack
15356 *
15357 * @params[in] transId
15358 * @return void
15359 *
15360 * ****************************************************************/
15361
15362 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
15363 {
15364    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
15365    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
15366    uint16_t cellIdx =0, crnti=0;
15367    uint64_t cellId =0;
15368    CmLList *f1apPduNode = NULLP;
15369    ReservedF1apPduInfo *f1apPduInfo =NULLP;
15370    F1AP_PDU_t *f1apMsgPdu = NULLP;
15371    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
15372    BIT_STRING_t *cellIdentity=NULLP;
15373    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
15374    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
15375    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
15376
15377    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
15378    f1apPduNode = searchFromReservedF1apPduList(transId);
15379    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
15380    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
15381
15382    if(f1apMsgPdu)
15383    {
15384       if(f1apMsgPdu->choice.initiatingMessage)
15385       {
15386          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
15387          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
15388          {
15389             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
15390             {
15391                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
15392                   {
15393                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
15394                                      Served_Cells_To_Delete_List;
15395                      if(cellsToDelete->list.array)
15396                      {
15397                         if(cellsToDelete->list.array[arrIdx])
15398                         {
15399                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
15400                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
15401                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
15402                            {
15403                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
15404                               bitStringToInt(cellIdentity, &cellId);
15405
15406                               GET_CELL_IDX(cellId, cellIdx);
15407                               if(duCb.actvCellLst[cellIdx] != NULLP)
15408                               {
15409                                  duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
15410                               }
15411                            }
15412                         }
15413                      }
15414
15415                      if(duCb.actvCellLst[cellIdx] != NULLP)
15416                      {
15417                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
15418                         {
15419                            ret = duSendCellDeletReq(cellId);
15420                            if(ret == RFAILED)
15421                            {
15422                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
15423                               request for cellId[%lu]", cellId);
15424                            }
15425                         }
15426                         else
15427                         {
15428                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
15429                            while(totalActiveUe)
15430                            {
15431                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
15432                               {
15433                                  ueIdx++;
15434                                  continue;
15435                               }
15436
15437                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
15438                               GET_UE_ID(crnti,ueId);
15439                               /* Sending Ue Context release request only for maximum supporting UEs */
15440                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
15441                               if(ret == RFAILED)
15442                               {
15443                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
15444                                  request for cellId[%lu]", cellId);
15445                               }
15446                               ueIdx++;
15447                               totalActiveUe--;
15448                            }
15449                         }
15450                      }
15451                      else
15452                      {
15453                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%lu] not found", cellId);
15454                         ret = RFAILED;
15455                      }
15456                      break;
15457                   }
15458
15459                default:
15460                   break;
15461             }
15462          }
15463       }
15464    }
15465
15466    FreeDUConfigUpdate(f1apMsgPdu);
15467    deleteFromReservedF1apPduList(f1apPduNode);
15468    return ret;
15469 }
15470
15471 /*******************************************************************
15472 *
15473 * @brief Processes GNB DU config update ack
15474 *
15475 * @details
15476 *
15477 *    Function : procF1GNBDUCfgUpdAck
15478 *
15479 *    Functionality: added free part for the memory allocated by aper_decoder
15480 *
15481 * @params[in] F1AP_PDU_t *f1apMsg
15482 * @return void
15483 *
15484 * ****************************************************************/
15485 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
15486 {
15487    uint8_t ieIdx=0,transId=0;
15488    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
15489
15490    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
15491    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
15492
15493    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
15494    {
15495       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
15496       {
15497          case ProtocolIE_ID_id_TransactionID:
15498             {
15499                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
15500                break;
15501             }
15502          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
15503             {
15504                break;
15505             }
15506          default :
15507             {
15508                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
15509                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
15510                break;
15511             }
15512       }
15513    }
15514
15515    duProcGnbDuCfgUpdAckMsg(transId);
15516
15517 #if 0
15518    /* presently we are not supporting F1 Reset from DU to CU , we are only
15519     * supporting F1 Reset from CU to DU */
15520
15521    if(BuildAndSendF1ResetReq() != ROK)
15522    {
15523       return RFAILED;
15524    }
15525 #endif
15526
15527    freeAperDecodeGnbDuAck(gnbDuAck);
15528    return ROK;
15529 }
15530 /******************************************************************
15531 *
15532 * @brief free DL RRC Message Transfer allocated by aper_decoder
15533 *
15534 * @details
15535 *
15536 *    Function : freeAperDecodef1DlRrcMsg
15537 *
15538 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
15539 *
15540 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
15541 * @return ROK     - success
15542 *         RFAILED - failure
15543 *
15544 * ****************************************************************/
15545
15546 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
15547 {
15548    uint8_t ieIdx =0;
15549    RRCContainer_t *rrcContainer = NULLP;
15550
15551    if(f1DlRrcMsg->protocolIEs.list.array)
15552    {
15553       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
15554       {
15555          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
15556          {
15557             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
15558             {
15559                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15560                   break;
15561                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15562                   break;
15563                case ProtocolIE_ID_id_SRBID:
15564                   break;
15565                case ProtocolIE_ID_id_RRCContainer:
15566                   {
15567                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
15568                      free(rrcContainer->buf);
15569                   }
15570                case ProtocolIE_ID_id_ExecuteDuplication:
15571                   break;
15572                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15573                   break;
15574                   break;
15575             }
15576             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
15577          }
15578       }
15579       free(f1DlRrcMsg->protocolIEs.list.array);
15580    }
15581 }
15582 /******************************************************************
15583  *
15584  * @brief Processes DL RRC Message Transfer  sent by CU
15585  *
15586  * @details
15587  *
15588  *    Function : procF1DlRrcMsgTrans
15589  *
15590  *    Functionality: Processes DL RRC Message Transfer sent by CU
15591  *
15592  * @params[in] F1AP_PDU_t ASN decoded F1AP message
15593  * @return ROK     - success
15594  *         RFAILED - failure
15595  *
15596  * ****************************************************************/
15597 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
15598 {
15599    uint8_t  idx, ret;
15600    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
15601    F1DlRrcMsg dlMsg;
15602    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
15603
15604    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
15605    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
15606
15607    ret = ROK;
15608
15609    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
15610    {
15611       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
15612       {
15613          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15614             {
15615                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
15616                break;
15617             }
15618          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15619             {
15620                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
15621                break;
15622             }
15623          case ProtocolIE_ID_id_SRBID:
15624             {
15625                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
15626                break;
15627             }
15628          case ProtocolIE_ID_id_ExecuteDuplication:
15629             dlMsg.execDup = true;
15630             break;
15631
15632          case ProtocolIE_ID_id_RRCContainer:
15633             {
15634                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
15635                {
15636                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
15637                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
15638                   if(dlMsg.rrcMsgPdu)
15639                   {
15640                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
15641                         dlMsg.rrcMsgSize);
15642                   }
15643                   else
15644                   {
15645                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
15646                      return RFAILED;
15647                   }
15648                }
15649                else
15650                {
15651                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
15652                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
15653                   return RFAILED;
15654                }
15655                break;
15656             }
15657          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
15658             {
15659                dlMsg.deliveryStatRpt = true;
15660                break;
15661             }
15662          default:
15663             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
15664                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
15665       }
15666    }
15667
15668    ret = duProcDlRrcMsg(&dlMsg);
15669
15670    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
15671    return ret;
15672 }
15673 /*******************************************************************
15674  *
15675 * @brief Builds the DRB to be Setup Mod list
15676 *
15677 * @details
15678 *
15679 *    Function :
15680 *
15681 *    Functionality: Constructs the DRB to be Setup Mod list
15682 *
15683 * @params[in] DRBs_SetupMod_List_t *drbSet
15684 *
15685 * @return ROK     - success
15686 *         RFAILED - failure
15687 *
15688 * ****************************************************************/
15689 uint8_t BuildSrbSetupModList(SRBs_SetupMod_List_t *srbList, DuUeCfg *ueCfg)
15690 {
15691    uint8_t srbIdx = 0;
15692    struct SRBs_SetupMod_ItemIEs *srbItemIe;
15693
15694    srbList->list.count = ueCfg->numRlcLcs;
15695    srbList->list.size = srbList->list.count * sizeof(SRBs_SetupMod_ItemIEs_t *);
15696
15697    DU_ALLOC(srbList->list.array, srbList->list.size);
15698    if(srbList->list.array == NULLP)
15699    {
15700       DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15701       return RFAILED;
15702    }
15703
15704    for(srbIdx = 0; srbIdx < srbList->list.count; srbIdx++)
15705    {
15706       DU_ALLOC(srbList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15707       if(srbList->list.array[srbIdx] == NULLP)
15708       {
15709          DU_LOG("\nERROR  -->  DU APP : Memory allocation failed in BuildSrbSetupModList");
15710          return RFAILED;
15711       }
15712    }
15713
15714    for(srbIdx=0; srbIdx < srbList->list.count; srbIdx++)
15715    {
15716       srbItemIe = (struct SRBs_SetupMod_ItemIEs *)srbList->list.array[srbIdx];
15717       srbItemIe->id = ProtocolIE_ID_id_SRBs_SetupMod_Item;
15718       srbItemIe->criticality = Criticality_reject;
15719       srbItemIe->value.present = SRBs_SetupMod_ItemIEs__value_PR_SRBs_SetupMod_Item;
15720       srbItemIe->value.choice.SRBs_SetupMod_Item.sRBID = ueCfg->rlcLcCfg[srbIdx].rbId;
15721       srbItemIe->value.choice.SRBs_SetupMod_Item.lCID = ueCfg->rlcLcCfg[srbIdx].lcId;
15722    }
15723    return ROK;
15724 }
15725
15726 /*******************************************************************
15727  *
15728 * @brief Builds the DRB to be Setup Mod list
15729 *
15730 * @details
15731 *
15732 *    Function :
15733 *
15734 *    Functionality: Constructs the DRB to be Setup Mod list
15735 *
15736 * @params[in] DRBs_SetupMod_List_t *drbSet
15737 *
15738 * @return ROK     - success
15739 *         RFAILED - failure
15740 *
15741 * ****************************************************************/
15742
15743 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
15744 {
15745    uint8_t arrIdx =0;
15746    uint8_t drbCnt =0;
15747    struct DRBs_SetupMod_ItemIEs *drbItemIe;
15748
15749    drbCnt = ueCfg->numDrbSetupMod;
15750
15751    drbSet->list.count = drbCnt;
15752    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
15753    DU_ALLOC(drbSet->list.array, drbSet->list.size);
15754    if(drbSet->list.array == NULLP)
15755    {
15756       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15757       return  RFAILED;
15758    }
15759    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
15760    {
15761       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15762       if(drbSet->list.array[arrIdx] == NULLP)
15763       {
15764               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
15765               return  RFAILED;
15766       }
15767
15768       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
15769       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
15770       drbItemIe->criticality = Criticality_reject;
15771       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
15772       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
15773       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
15774       &ueCfg->upTnlInfo[arrIdx])!= ROK)
15775       {
15776          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
15777          return RFAILED;
15778       }
15779
15780    }
15781
15782    return ROK;
15783 }
15784 /*******************************************************************
15785 * @brief Free the memory allocated for DRB setup List
15786 *
15787 * @details
15788 *
15789 *    Function : FreeDrbSetupModList
15790 *
15791 *    Functionality:
15792 *       Free the memory allocated for DRB setup list
15793 *
15794 * @params[in] DRBs_Setup_List_t *
15795 * @return void
15796 *
15797 * ****************************************************************/
15798 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
15799 {
15800    uint8_t arrIdx = 0;
15801    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
15802
15803    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
15804    {
15805       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
15806       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
15807       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
15808    }
15809    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
15810 }
15811
15812 /*******************************************************************
15813 *
15814 * @brief Builds the DRB to be Mod list
15815 *
15816 * @details
15817 *
15818 *    Function :
15819 *
15820 *    Functionality: Constructs the DRB to be Mod list
15821 *
15822 * @params[in] DRBs_Modified_List_t *drbModList
15823 *
15824 * @return ROK     - success
15825 *         RFAILED - failure
15826 *
15827 * ****************************************************************/
15828
15829 uint8_t BuildDrbModList(DRBs_Modified_List_t *drbModList, DuUeCfg *ueCfg)
15830 {
15831    uint8_t arrIdx =0, drbIdx = 0;
15832    uint8_t drbCnt =0;
15833    struct DRBs_Modified_ItemIEs *drbItemIe;
15834
15835    drbCnt = ueCfg->numDrbModified;
15836
15837    drbModList->list.count = drbCnt;
15838    drbModList->list.size = drbCnt * sizeof(DRBs_Modified_ItemIEs_t *);
15839    DU_ALLOC(drbModList->list.array, drbModList->list.size);
15840    if(drbModList->list.array == NULLP)
15841    {
15842       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbModList()");
15843       return  RFAILED;
15844    }
15845
15846    drbIdx = 0;
15847    for(arrIdx = 0; arrIdx < ueCfg->numMacLcs; arrIdx++)
15848    {
15849       if(ueCfg->macLcCfg[arrIdx].configType == CONFIG_MOD)
15850       {
15851          DU_ALLOC(drbModList->list.array[drbIdx], sizeof(DRBs_Modified_ItemIEs_t));
15852          if(drbModList->list.array[drbIdx] == NULLP)
15853          {
15854             DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbModList");
15855             return  RFAILED;
15856          }
15857
15858          drbItemIe = (struct DRBs_Modified_ItemIEs *)drbModList->list.array[drbIdx];
15859          drbItemIe->id = ProtocolIE_ID_id_DRBs_Modified_Item;
15860          drbItemIe->criticality = Criticality_reject;
15861          drbItemIe->value.present = DRBs_Modified_ItemIEs__value_PR_DRBs_Modified_Item;
15862          drbItemIe->value.choice.DRBs_Modified_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
15863          if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Modified_Item.dLUPTNLInformation_ToBeSetup_List,\
15864                   &ueCfg->upTnlInfo[arrIdx])!= ROK)
15865          {
15866             DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbModList");
15867             return RFAILED;
15868          }
15869          drbIdx++;
15870       }
15871    }
15872
15873    return ROK;
15874 }
15875
15876 /*******************************************************************
15877 * @brief Free the memory allocated for DRB Mod List
15878 *
15879 * @details
15880 *
15881 *    Function : FreeDrbModList
15882 *
15883 *    Functionality:
15884 *       Free the memory allocated for DRB modified list
15885 *
15886 * @params[in] DRBs_Modified_List_t *
15887 * @return void
15888 *
15889 * ****************************************************************/
15890 void FreeDrbModList(DRBs_Modified_List_t *drbModList)
15891 {
15892    uint8_t arrIdx = 0;
15893    DRBs_Modified_ItemIEs_t *drbItemIe = NULLP;
15894
15895    for(arrIdx = 0; arrIdx < drbModList->list.count; arrIdx++)
15896    {
15897       drbItemIe = ((DRBs_Modified_ItemIEs_t *)drbModList->list.array[arrIdx]);
15898       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Modified_Item.dLUPTNLInformation_ToBeSetup_List);
15899       DU_FREE(drbModList->list.array[arrIdx], sizeof(DRBs_Modified_ItemIEs_t));
15900    }
15901    DU_FREE(drbModList->list.array, drbModList->list.size);
15902 }
15903
15904 /*******************************************************************
15905 * @brief Free the memory allocated for SRB setup List
15906 *
15907 * @details
15908 *
15909 *    Function : FreeSrbSetupModList
15910 *
15911 *    Functionality:
15912 *       Free the memory allocated for SRB setup list
15913 *
15914 * @params[in] SRBs_Setup_List_t *
15915 * @return void
15916 *
15917 * ****************************************************************/
15918 void FreeSrbSetupModList(SRBs_SetupMod_List_t *srbSetupList)
15919 {
15920    uint8_t srbIdx = 0;
15921
15922    for(srbIdx = 0; srbIdx < srbSetupList->list.count; srbIdx++)
15923       DU_FREE(srbSetupList->list.array[srbIdx], sizeof(SRBs_SetupMod_ItemIEs_t));
15924    DU_FREE(srbSetupList->list.array, srbSetupList->list.size);
15925 }
15926
15927 /*******************************************************************
15928 * @brief Free the memory allocated for UE Context Mod Response
15929 *
15930 * @details
15931 *
15932 *    Function : FreeUeContextModResp
15933 *
15934 *    Functionality:
15935 *       Free the memory allocated for UE Context Mod Response
15936 *
15937 * @params[in] F1AP_PDU_t *f1apMsg
15938 * @return void
15939 *
15940 * ****************************************************************/
15941
15942 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
15943 {
15944    uint8_t ieIdx;
15945    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
15946    if(f1apMsg)
15947    {
15948       if(f1apMsg->choice.successfulOutcome)
15949       {
15950          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
15951          if(ueContextModifyRes->protocolIEs.list.array)
15952          {
15953             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
15954             {
15955                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
15956                {
15957                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
15958                   {
15959                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
15960                         break;
15961                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
15962                         break;
15963                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
15964                         {
15965                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15966                             value.choice.DRBs_SetupMod_List));
15967                             break;
15968                         }
15969                      case ProtocolIE_ID_id_DRBs_Modified_List:
15970                         {
15971                             FreeDrbModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
15972                             value.choice.DRBs_Modified_List));
15973                             break;
15974                         }
15975                      case ProtocolIE_ID_id_SRBs_SetupMod_List:
15976                         {
15977                            FreeSrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
15978                               SRBs_SetupMod_List));
15979                            break;
15980                         }
15981                   }
15982                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
15983                }
15984
15985             }
15986             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
15987          }
15988          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
15989       }
15990       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
15991    }
15992 }
15993
15994 /*****************************************************************i
15995 *
15996 * @brief Creating the ue context modifcation response and sending
15997 *
15998 * @details
15999 *
16000 *    Function : BuildAndSendUeContextModRsp
16001 *
16002 *    Functionality:
16003 *         - Creating the ue context modifcation response
16004 *
16005 * @params[in] uint8_t cellId,uint8_t ueId
16006 * @return ROK     - success
16007 *         RFAILED - failure
16008 *
16009 * ****************************************************************/
16010 uint8_t BuildAndSendUeContextModRsp(DuUeCb *ueCb)
16011 {
16012    uint8_t   ieIdx = 0, tnlIdx = 0, rbIdx = 0;
16013    uint8_t   elementCnt = 0;
16014    uint8_t   ret = RFAILED;
16015    F1AP_PDU_t *f1apMsg = NULLP;
16016    asn_enc_rval_t  encRetVal;
16017    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
16018
16019    DU_LOG("\nINFO  -->  F1AP : Building UE context modification response\n");
16020
16021    while(true)
16022    {
16023       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16024       if(f1apMsg == NULLP)
16025       {
16026          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
16027          break;
16028       }
16029
16030       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
16031
16032       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
16033       if(f1apMsg->choice.successfulOutcome == NULLP)
16034       {
16035          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
16036          break;
16037       }
16038       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
16039       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
16040       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
16041
16042       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
16043
16044       if(ueCb->f1UeDb->actionType == UE_CTXT_MOD)
16045       {
16046          elementCnt = 2;
16047          if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
16048             elementCnt++;
16049          if(ueCb->f1UeDb->duUeCfg.numDrbModified)
16050             elementCnt++;
16051       }
16052       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
16053       {
16054          elementCnt = 5;
16055       }
16056       if(ueCb->f1UeDb->actionType == UE_CTXT_RRC_RECFG_COMPLETE)
16057          elementCnt = 2;
16058       ueContextModifyRes->protocolIEs.list.count = elementCnt;
16059       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
16060
16061       /* Initialize the UE context modification members */
16062       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
16063       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
16064       {
16065          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
16066          break;
16067       }
16068
16069       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
16070       {
16071          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
16072          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
16073          {
16074             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
16075             break;
16076          }
16077       }
16078
16079       ieIdx=0;
16080       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16081       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16082       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
16083       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
16084       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = ueCb->gnbCuUeF1apId;
16085
16086       ieIdx++;
16087       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16088       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16089       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
16090       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
16091       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = ueCb->gnbDuUeF1apId;
16092
16093       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
16094       {
16095          ieIdx++;
16096          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCInformation;
16097          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16098          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
16099          UEContextModificationResponseIEs__value_PR_DUtoCURRCInformation;
16100          BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
16101       }
16102
16103       if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || \
16104            ((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbSetupMod)))
16105       {
16106          ieIdx++;
16107          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
16108          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16109          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
16110                                                                            UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
16111          if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
16112          {
16113             for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
16114             {
16115                if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
16116                {
16117                   memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
16118                }
16119             }
16120          }
16121          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
16122                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
16123          if(ret != ROK)
16124          {
16125             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB setupmod List ");
16126             break;
16127          }
16128       }
16129
16130       if((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbModified))
16131       {
16132          ieIdx++;
16133          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_Modified_List;
16134          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16135          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
16136                                                                     UEContextModificationResponseIEs__value_PR_DRBs_Modified_List;
16137          ret = BuildDrbModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
16138                                  value.choice.DRBs_Modified_List) , &ueCb->f1UeDb->duUeCfg);
16139          if(ret != ROK)
16140          {
16141             DU_LOG( "\nERROR  -->  F1AP : Failed to build DRB Modified List ");
16142             break;
16143          }
16144       }
16145
16146       if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
16147       {
16148          ieIdx++;
16149          ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_SRBs_SetupMod_List;
16150          ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
16151          ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present = \
16152                                                                             UEContextModificationResponseIEs__value_PR_SRBs_SetupMod_List;
16153          for(rbIdx = 0; rbIdx < ueCb->rlcUeCfg.numLcs; rbIdx++)
16154          {
16155             if(ueCb->rlcUeCfg.rlcLcCfg[rbIdx].rbType == RB_TYPE_SRB)
16156             {
16157                memcpy(&ueCb->f1UeDb->duUeCfg.rlcLcCfg[ueCb->f1UeDb->duUeCfg.numRlcLcs++], &ueCb->rlcUeCfg.rlcLcCfg[rbIdx],\
16158                      sizeof(RlcBearerCfg));
16159             }
16160          }
16161          ret = BuildSrbSetupModList(&ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.SRBs_SetupMod_List, \
16162                &ueCb->f1UeDb->duUeCfg);
16163          if(ret != ROK)
16164          {
16165             DU_LOG( "\nERROR  -->  F1AP : Failed to build SRB setupmod List ");
16166             break;
16167          }
16168       }
16169
16170       freeF1UeDb(ueCb->f1UeDb);
16171       ueCb->f1UeDb = NULLP;
16172
16173       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16174
16175       /* Encode the F1SetupRequest type as APER */
16176       memset(encBuf, 0, ENC_BUF_MAX_LEN);
16177       encBufSize = 0;
16178       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
16179
16180       /* Encode results */
16181       if(encRetVal.encoded == ENCODE_FAIL)
16182       {
16183          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Modification Response structure (at %s)\n",\
16184                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
16185          ret = RFAILED;
16186          break;
16187       }
16188       else
16189       {
16190          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
16191 #ifdef DEBUG_ASN_PRINT
16192          for(int i=0; i< encBufSize; i++)
16193          {
16194             printf("%x",encBuf[i]);
16195          }
16196 #endif
16197       }
16198
16199       /* Sending  msg  */
16200       if(sendF1APMsg() != ROK && (ret == ROK))
16201       {
16202          DU_LOG("\nERROR  -->  F1AP : Sending UE Modification Res Failed");
16203          ret = RFAILED;
16204          break;
16205       }
16206
16207       ret = ROK;
16208       break;
16209    }
16210    FreeUeContextModResp(f1apMsg);
16211    return ret;
16212 }
16213
16214 /*******************************************************************
16215  *
16216  * @brief Deallocating the memory allocated by the aper decoder
16217  *          for QOSInfo
16218  *
16219  * @details
16220  *
16221  *    Function : freeAperDecodeQosInfo
16222  *
16223  *    Functionality:  Deallocating the memory allocated for QOSInfo
16224  *
16225  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
16226  *
16227  * @return void
16228  *
16229  * ****************************************************************/
16230
16231 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
16232 {
16233    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
16234    {
16235       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
16236       {
16237          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
16238          {
16239             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
16240          }
16241          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
16242       }
16243       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
16244    }
16245 }
16246 /*******************************************************************
16247  *
16248  * @brief Deallocating the memory allocated by the aper decoder
16249  *          for UlTnlInfoforDrb
16250  *
16251  * @details
16252  *
16253  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
16254  *
16255  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
16256  *
16257  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
16258  *
16259  * @return void
16260  *
16261  * ****************************************************************/
16262 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
16263 {
16264    uint8_t arrIdx =0;
16265
16266    if(ulInfo->list.array)
16267    {
16268       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
16269       {
16270          if(ulInfo->list.array[arrIdx])
16271          {
16272             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
16273             {
16274                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
16275                {
16276                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
16277                   {
16278                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16279                            gTP_TEID.buf);
16280                   }
16281                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
16282                         transportLayerAddress.buf);
16283                }
16284                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
16285             }
16286             free(ulInfo->list.array[arrIdx]);
16287          }
16288       }
16289       free(ulInfo->list.array);
16290    }
16291 }
16292
16293 /*******************************************************************
16294  *
16295  * @brief Deallocating the memory allocated by the aper decoder
16296  *          for DrbSetupModItem
16297  *
16298  * @details
16299  *
16300  *    Function : freeAperDecodeDrbSetupModItem
16301  *
16302  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
16303  *
16304  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
16305  *
16306  * @return void
16307  *
16308  * ****************************************************************/
16309
16310 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
16311 {
16312    uint8_t arrIdx =0;
16313    SNSSAI_t *snssai =NULLP;
16314    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
16315
16316    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
16317    switch(drbItem->qoSInformation.present)
16318    {
16319       case QoSInformation_PR_NOTHING:
16320          break;
16321       case QoSInformation_PR_eUTRANQoS:
16322          {
16323             if(drbItem->qoSInformation.choice.eUTRANQoS)
16324             {
16325                free(drbItem->qoSInformation.choice.eUTRANQoS);
16326             }
16327             break;
16328          }
16329       case QoSInformation_PR_choice_extension:
16330          {
16331             if(drbItem->qoSInformation.choice.choice_extension)
16332             {
16333                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
16334                      DRB_Information.dRB_QoS);
16335                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
16336                if(snssai->sST.buf)
16337                {
16338                   free(snssai->sST.buf);
16339                }
16340                if(snssai->sD)
16341                {
16342                   if(snssai->sD->buf)
16343                   {
16344                      free(snssai->sD->buf);
16345                   }
16346                   free(snssai->sD);
16347                }
16348
16349                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
16350                          DRB_Information.flows_Mapped_To_DRB_List;
16351                if(flowMap->list.array)
16352                {
16353                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
16354                   {
16355                      if(flowMap->list.array[arrIdx] )
16356                      {
16357                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
16358                         free(flowMap->list.array[arrIdx]);
16359                      }
16360                   }
16361                   free(flowMap->list.array);
16362                }
16363
16364                free(drbItem->qoSInformation.choice.choice_extension);
16365             }
16366             break;
16367          }
16368
16369    }
16370    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
16371    if(drbItem->uLConfiguration)
16372    {
16373       free(drbItem->uLConfiguration);
16374    }
16375 }
16376
16377 /*******************************************************************
16378  *
16379  * @brief Deallocating the memory allocated by the aper decoder
16380  *          for DrbToBeSetupModList
16381  *
16382  * @details
16383  *
16384  *    Function : freeAperDecodeDrbToBeSetupModList
16385  *
16386  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
16387  *
16388  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
16389  *
16390  * @return void
16391  *
16392  * ****************************************************************/
16393
16394 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
16395 {
16396    uint8_t arrIdx =0;
16397    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
16398
16399    if(drbSet->list.array)
16400    {
16401       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
16402       {
16403          if(drbSet->list.array[arrIdx] != NULLP)
16404          {
16405             if(arrIdx == 0)
16406             {
16407                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
16408                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
16409             }
16410             free(drbSet->list.array[arrIdx]);
16411          }
16412       }
16413       free(drbSet->list.array);
16414    }
16415
16416 }
16417
16418 /*******************************************************************
16419  *
16420  * @brief Deallocating the memory allocated by the aper decoder
16421  *          for DrbSetupModItem
16422  *
16423  * @details
16424  *
16425  *    Function : freeAperDecodeDrbModifiedItem
16426  *
16427  *    Functionality:  Deallocating memory allocated for DrbModifedItem
16428  *
16429  * @params[in] DRBs_ToBeModified_Item_t *drbItem
16430  *
16431  * @return void
16432  *
16433  * ****************************************************************/
16434
16435 void freeAperDecodeDrbModifiedItem(DRBs_ToBeModified_Item_t *drbItem)
16436 {
16437    uint8_t arrIdx =0;
16438    SNSSAI_t *snssai =NULLP;
16439    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
16440
16441    if(drbItem->qoSInformation != NULLP)
16442    {
16443       drbItem->qoSInformation->present = QoSInformation_PR_choice_extension;
16444       switch(drbItem->qoSInformation->present)
16445       {
16446          case QoSInformation_PR_NOTHING:
16447             break;
16448          case QoSInformation_PR_eUTRANQoS:
16449             {
16450                if(drbItem->qoSInformation->choice.eUTRANQoS)
16451                {
16452                   free(drbItem->qoSInformation->choice.eUTRANQoS);
16453                }
16454                break;
16455             }
16456          case QoSInformation_PR_choice_extension:
16457             {
16458                if(drbItem->qoSInformation->choice.choice_extension)
16459                {
16460                   freeAperDecodeQosInfo(&drbItem->qoSInformation->choice.choice_extension->value.choice.\
16461                         DRB_Information.dRB_QoS);
16462                   snssai = &drbItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information.sNSSAI;
16463                   if(snssai->sST.buf)
16464                   {
16465                      free(snssai->sST.buf);
16466                   }
16467                   if(snssai->sD)
16468                   {
16469                      if(snssai->sD->buf)
16470                      {
16471                         free(snssai->sD->buf);
16472                      }
16473                      free(snssai->sD);
16474                   }
16475
16476                   flowMap = &drbItem->qoSInformation->choice.choice_extension->value.choice.\
16477                             DRB_Information.flows_Mapped_To_DRB_List;
16478                   if(flowMap->list.array)
16479                   {
16480                      for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
16481                      {
16482                         if(flowMap->list.array[arrIdx] )
16483                         {
16484                            freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
16485                            free(flowMap->list.array[arrIdx]);
16486                         }
16487                      }
16488                      free(flowMap->list.array);
16489                   }
16490
16491                   free(drbItem->qoSInformation->choice.choice_extension);
16492                }
16493                break;
16494             }
16495       }
16496       free(drbItem->qoSInformation);
16497    }
16498    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
16499    if(drbItem->uLConfiguration)
16500    {
16501       free(drbItem->uLConfiguration);
16502    }
16503 }
16504
16505 /*******************************************************************
16506  *
16507  * @brief Deallocating the memory allocated by the aper decoder
16508  *          for DrbToBeSetupModList
16509  *
16510  * @details
16511  *
16512  *    Function : freeAperDecodeDrbToBeModifiedList
16513  *
16514  *    Functionality:  Deallocating memory allocated for DrbToBeModifiedList
16515  *
16516  * @params[in] DRBs_ToBeModified_List_t *drbSet
16517  *
16518  * @return void
16519  *
16520  * ****************************************************************/
16521
16522 void freeAperDecodeDrbToBeModifiedList(DRBs_ToBeModified_List_t *drbSet)
16523 {
16524    uint8_t arrIdx =0;
16525    struct DRBs_ToBeModified_ItemIEs *drbItemIe;
16526
16527    if(drbSet->list.array)
16528    {
16529       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
16530       {
16531          if(drbSet->list.array[arrIdx] != NULLP)
16532          {
16533             if(arrIdx == 0)
16534             {
16535                drbItemIe = (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx];
16536                freeAperDecodeDrbModifiedItem(&(drbItemIe->value.choice.DRBs_ToBeModified_Item));
16537             }
16538             free(drbSet->list.array[arrIdx]);
16539          }
16540       }
16541       free(drbSet->list.array);
16542    }
16543
16544 }
16545
16546 /*******************************************************************
16547  *
16548  * @brief Deallocating the memory allocated by the aper decoder
16549  *          for DrbToBeSetupModList
16550  *
16551  * @details
16552  *
16553  *    Function : freeAperDecodeDrbToBeReleasedList
16554  *
16555  *    Functionality:  Deallocating memory allocated for DrbToBeReleasedList
16556  *
16557  * @params[in] DRBs_ToBeReleased_List_t *drbSet
16558  *
16559  * @return void
16560  *
16561  * ****************************************************************/
16562
16563 void freeAperDecodeDrbToBeReleasedList(DRBs_ToBeReleased_List_t *drbSet)
16564 {
16565    uint8_t arrIdx =0;
16566
16567    if(drbSet->list.array)
16568    {
16569       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
16570       {
16571          if(drbSet->list.array[arrIdx] != NULLP)
16572          {
16573             free(drbSet->list.array[arrIdx]);
16574          }
16575       }
16576       free(drbSet->list.array);
16577    }
16578
16579 }
16580 /*******************************************************************
16581  *
16582  * @brief Deallocating the memory allocated by the aper decoder
16583  *          for UeContextModificationReqMsg
16584  *
16585  * @details
16586  *
16587  *    Function : freeAperDecodeUeContextModificationReqMsg
16588  *
16589  *    Functionality:  Deallocating memory allocated for
16590  *                  UeContextModificationReqMsg
16591  *
16592  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
16593  *
16594  * @return void
16595  *
16596  * ****************************************************************/
16597 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *ueContextModifyReq )
16598 {
16599    uint8_t arrIdx, ieId;
16600
16601    if(ueContextModifyReq->protocolIEs.list.array)
16602    {
16603       for( arrIdx = 0 ; arrIdx<ueContextModifyReq->protocolIEs.list.count ; arrIdx++)
16604       {
16605          if(ueContextModifyReq->protocolIEs.list.array[arrIdx])
16606          {
16607             ieId = ueContextModifyReq->protocolIEs.list.array[arrIdx]->id;
16608             switch(ieId)
16609             {
16610                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16611                   break;
16612                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16613                   break;
16614                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
16615                   {
16616                      freeAperDecodeDrbToBeSetupModList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
16617                            value.choice.DRBs_ToBeSetupMod_List);
16618                      break;
16619                   }
16620                case ProtocolIE_ID_id_DRBs_ToBeModified_List:
16621                   {
16622                      freeAperDecodeDrbToBeModifiedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
16623                            value.choice.DRBs_ToBeModified_List);
16624                      break;
16625                   }
16626                case ProtocolIE_ID_id_DRBs_ToBeReleased_List:
16627                   {
16628                      freeAperDecodeDrbToBeReleasedList(&ueContextModifyReq->protocolIEs.list.array[arrIdx]->\
16629                            value.choice.DRBs_ToBeReleased_List);
16630                      break;
16631                   }
16632                case ProtocolIE_ID_id_TransmissionActionIndicator:
16633                   break;
16634                case ProtocolIE_ID_id_RRCContainer:
16635                   {
16636                      free(ueContextModifyReq->protocolIEs.list.array[arrIdx]->value.choice.RRCContainer.buf);
16637                   }
16638             }
16639             free(ueContextModifyReq->protocolIEs.list.array[arrIdx]);
16640          }
16641       }
16642       free(ueContextModifyReq->protocolIEs.list.array);
16643    }
16644 }
16645 /*******************************************************************
16646  *
16647  * @brief processing the F1 UeContextModificationReq
16648  *
16649  * @details
16650  *
16651  *    Function : procF1UeContextModificationReq
16652  *
16653  *    Functionality:  processing the F1 UeContextModificationReq
16654  *
16655  * @params[in] F1AP_PDU_t *f1apMsg
16656  *
16657  * @return
16658  * ****************************************************************/
16659 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
16660 {
16661    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
16662    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0;
16663    DuUeCb   *duUeCb = NULLP;
16664    DRBs_ToBeSetupMod_List_t *drbSetupModCfg = NULLP;
16665    DRBs_ToBeModified_List_t *drbModifiedCfg = NULLP;
16666    DRBs_ToBeReleased_List_t *drbToRelease = NULLP;
16667    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
16668
16669    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
16670    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
16671    {
16672       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
16673       {
16674          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
16675             {
16676                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
16677                break;
16678             }
16679          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
16680             {
16681                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
16682                for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
16683                {
16684                   if(duCb.actvCellLst[cellIdx])
16685                   {
16686                      if((duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbDuUeF1apId == gnbDuUeF1apId)&&\
16687                            (duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1].gnbCuUeF1apId == gnbCuUeF1apId))
16688                      {
16689                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[gnbDuUeF1apId-1];
16690                         if(duUeCb->f1UeDb == NULLP)
16691                         {
16692                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
16693                            duUeCb->f1UeDb->cellIdx = cellIdx;
16694                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
16695                         }
16696                         break;
16697                      }
16698                   }
16699                }
16700                if(duUeCb == NULLP)
16701                {
16702                   DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
16703                   ret = RFAILED;
16704                }
16705                break;
16706             }
16707
16708          case ProtocolIE_ID_id_RRCContainer:
16709             {
16710                /* Filling Dl RRC Msg Info */
16711                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
16712                if(!duUeCb->f1UeDb->dlRrcMsg)
16713                {
16714                   DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
16715                         Memory allocation failed ");
16716                   ret = RFAILED;
16717                }
16718                else
16719                {
16720                   duUeCb->f1UeDb->dlRrcMsgPres = true;
16721                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
16722                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
16723                         &ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
16724                         value.choice.RRCContainer);
16725                }
16726
16727                break;
16728             }
16729
16730          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
16731          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
16732          case ProtocolIE_ID_id_DRBs_ToBeReleased_List:
16733             {
16734                if(duUeCb->f1UeDb)
16735                {
16736                   /*DRBs to be Added*/
16737                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
16738                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
16739                   {
16740                      drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16741                                       choice.DRBs_ToBeSetupMod_List;
16742
16743                      if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
16744                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
16745                      {
16746                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
16747                         ret = RFAILED;
16748                      }
16749                   }
16750
16751                   /*DRBs to be Modified*/
16752                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
16753                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
16754
16755                   {
16756                      drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16757                                       choice.DRBs_ToBeModified_List;
16758                      if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
16759                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
16760                      {
16761                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
16762                         ret = RFAILED;
16763                      }
16764                   }
16765                   /*DRBs to be Released*/
16766                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
16767                         UEContextModificationRequestIEs__value_PR_DRBs_ToBeReleased_List)
16768
16769                   {
16770                      drbToRelease = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
16771                                       choice.DRBs_ToBeReleased_List;
16772                      if(extractDrbListToRelease(gnbDuUeF1apId, drbToRelease, drbToRelease->list.count,\
16773                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->rlcUeCfg))
16774                      {
16775                         DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
16776                         ret = RFAILED;
16777                      }
16778                   }
16779                }
16780                break;
16781             }
16782
16783          case ProtocolIE_ID_id_GNB_DUConfigurationQuery:
16784             {
16785                DU_LOG("\nINFO  -->  DU APP : Received GNB DU Configuration Query in UE Context Modification Request from CU");
16786                if(duUeCb->f1UeDb)
16787                {
16788                   duUeCb->f1UeDb->actionType = UE_CTXT_CFG_QUERY;
16789                }
16790                break;
16791             }
16792
16793          case ProtocolIE_ID_id_RRCReconfigurationCompleteIndicator:
16794             {
16795                if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.RRCReconfigurationCompleteIndicator == \
16796                   RRCReconfigurationCompleteIndicator_true)
16797                {
16798                   duUeCb->f1UeDb->actionType = UE_CTXT_RRC_RECFG_COMPLETE;
16799                }
16800                break;
16801             }
16802          case ProtocolIE_ID_id_TransmissionActionIndicator:
16803             {
16804                if(duUeCb->f1UeDb)
16805                {
16806                   if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.TransmissionActionIndicator  == TransmissionActionIndicator_stop)
16807                   {
16808                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = STOP_TRANSMISSION;
16809                   }
16810                   else
16811                   {
16812                      duUeCb->f1UeDb->duUeCfg.dataTransmissionAction = RESTART_TRANSMISSION;
16813                   }
16814                }
16815                break;
16816             }
16817
16818          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
16819             {
16820                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
16821                {
16822                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
16823                }
16824                break;
16825             }
16826 #ifdef NR_DRX
16827          case ProtocolIE_ID_id_DRXConfigurationIndicator:
16828             {
16829                duUeCb->f1UeDb->duUeCfg.drxConfigIndicatorRelease = true;
16830                break;
16831             }
16832 #endif
16833
16834       }
16835    }
16836
16837    if(ret != RFAILED)
16838    {
16839       ret = duProcUeContextModReq(duUeCb);
16840    }
16841    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
16842    return ret;
16843 }
16844
16845 /*****************************************************************i
16846 *
16847 * @brief Free memory allocated for UE Context Release Request
16848 *
16849 * @details
16850 *
16851 *    Function : FreeUeContextReleaseReq
16852 *
16853 *    Functionality:
16854 *         - Free memory allocated for UE Context Release Request
16855 *
16856 * @params[in] F1AP_PDU_t *f1apMsg
16857 * @return void
16858 *
16859 * *************************************************************/
16860 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
16861 {
16862    uint8_t ieIdx;
16863    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
16864
16865    if(f1apMsg)
16866    {
16867       if(f1apMsg->choice.initiatingMessage)
16868       {
16869          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
16870          if(ueReleaseReq->protocolIEs.list.array)
16871          {
16872             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
16873             {
16874                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
16875             }
16876             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
16877          }
16878          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
16879       }
16880       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
16881    }
16882
16883 }
16884 /*****************************************************************i
16885 *
16886 * @brief Build and Send UE Context Release Request
16887 *
16888 * @details
16889 *
16890 *    Function : BuildAndSendUeContextReleaseReq
16891 *
16892 *    Functionality:
16893 *         - Build and Send UE Context Release Request
16894 *
16895 * @params[in]
16896 * @return ROK     - success
16897 *         RFAILED - failure
16898 *
16899 * *************************************************************/
16900 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
16901 {
16902    bool memAllocFail = false;
16903    uint8_t ieIdx =0;
16904    uint8_t ret = RFAILED;
16905    uint16_t cellIdx =0;
16906    uint16_t crnti = 0;
16907    uint8_t  elementCnt = 0;
16908    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
16909    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
16910    asn_enc_rval_t encRetVal;
16911    F1AP_PDU_t *f1apMsg = NULLP;
16912    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
16913
16914    DU_LOG("\nINFO  --> Building the UE Context Release Request");
16915    do
16916    {
16917       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
16918       if(f1apMsg == NULLP)
16919       {
16920          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
16921          break;
16922       }
16923
16924       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
16925       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
16926       if(f1apMsg->choice.initiatingMessage == NULLP)
16927       {
16928          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
16929          initiatingMessage");
16930          break;
16931       }
16932       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
16933       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
16934       f1apMsg->choice.initiatingMessage->value.present = \
16935       InitiatingMessage__value_PR_UEContextReleaseRequest;
16936
16937       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
16938
16939       elementCnt = 2;
16940
16941       ueReleaseReq->protocolIEs.list.count = elementCnt;
16942       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
16943
16944       /* Initialize the F1Setup members */
16945       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
16946       if(ueReleaseReq->protocolIEs.list.array == NULLP)
16947       {
16948          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
16949          break;
16950       }
16951       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
16952       {
16953          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
16954                sizeof(UEContextReleaseRequest_t));
16955          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
16956          {
16957             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
16958             memAllocFail = true;
16959             break;
16960          }
16961       }
16962       if(memAllocFail == true)
16963          break;
16964
16965       /* Fetching Ue Cb Info*/
16966       GET_CELL_IDX(cellId, cellIdx);
16967       if(duCb.actvCellLst[cellIdx] == NULLP)
16968       {
16969          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
16970          break;
16971       }
16972       else
16973       {
16974          GET_CRNTI(crnti, ueId);
16975          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
16976          {
16977             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
16978             break;
16979          }
16980          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
16981          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
16982       }
16983
16984       ieIdx=0;
16985       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
16986       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16987       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
16988       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
16989       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
16990
16991       ieIdx++;
16992       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
16993       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
16994       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
16995       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
16996       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
16997
16998       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
16999
17000       /* Encode the F1SetupRequest type as APER */
17001       memset(encBuf, 0, ENC_BUF_MAX_LEN);
17002       encBufSize = 0;
17003       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
17004       /* Encode results */
17005       if(encRetVal.encoded == ENCODE_FAIL)
17006       {
17007          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
17008                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
17009          break;
17010       }
17011       else
17012       {
17013          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
17014 #ifdef DEBUG_ASN_PRINT
17015          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
17016          {
17017             printf("%x",encBuf[ieIdx]);
17018          }
17019 #endif
17020       }
17021
17022       /* Sending msg */
17023       if(sendF1APMsg() != ROK)
17024       {
17025          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
17026          break;
17027       }
17028       ret = ROK;
17029       break;
17030    }while(true);
17031
17032    FreeUeContextReleaseReq(f1apMsg);
17033    return ret;
17034 }
17035 /*****************************************************************i
17036  *
17037  * @brief Free memory allocated for UE Context Release Complete
17038  *
17039  * @details
17040  *
17041  *    Function : FreeUeContextReleaseComplete
17042  *
17043  *    Functionality:
17044  *         - Free memory allocated for UE Context Release Complete
17045  *
17046  * @params[in] F1AP_PDU_t *f1apMsg
17047  * @return void
17048  *
17049  * *************************************************************/
17050 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
17051 {
17052    uint8_t ieIdx;
17053    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
17054
17055    if(f1apMsg)
17056    {
17057       if(f1apMsg->choice.successfulOutcome)
17058       {
17059          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
17060          if(ueReleaseComplete->protocolIEs.list.array)
17061          {
17062             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
17063             {
17064                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
17065             }
17066             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
17067          }
17068          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
17069       }
17070       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
17071    }
17072
17073 }
17074 /*****************************************************************i
17075  *
17076  * @brief Build and Send UE Context Release Complete
17077  *
17078  * @details
17079  *
17080  *    Function : BuildAndSendUeContextReleaseComplete
17081  *
17082  *    Functionality:
17083  *         - Build and Send UE Context Release Complete
17084  *
17085  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
17086  * @return ROK     - success
17087  *         RFAILED - failure
17088  *
17089  * *************************************************************/
17090 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
17091 {
17092    bool memAllocFail = false;
17093    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
17094    asn_enc_rval_t encRetVal;
17095    F1AP_PDU_t *f1apMsg = NULLP;
17096    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
17097
17098    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
17099    do
17100    {
17101       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
17102       if(f1apMsg == NULLP)
17103       {
17104          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
17105          break;
17106       }
17107
17108       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
17109       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
17110       if(f1apMsg->choice.successfulOutcome == NULLP)
17111       {
17112          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
17113                successfulOutcome");
17114          break;
17115       }
17116       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
17117       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
17118       f1apMsg->choice.successfulOutcome->value.present = \
17119       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
17120
17121       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
17122
17123       elementCnt = 2;
17124       ueReleaseComplete->protocolIEs.list.count = elementCnt;
17125       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
17126
17127       /* Initialize the UE Release Complete members */
17128       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
17129       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
17130       {
17131          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
17132          break;
17133       }
17134       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
17135       {
17136          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
17137                sizeof(UEContextReleaseComplete_t));
17138          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
17139          {
17140             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
17141             elements");
17142             memAllocFail = true;
17143             break;
17144          }
17145       }
17146       if(memAllocFail == true)
17147          break;
17148
17149
17150       ieIdx=0;
17151       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
17152       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
17153       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
17154       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
17155       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
17156
17157       ieIdx++;
17158       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
17159       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
17160       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
17161       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
17162       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
17163
17164       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
17165
17166       /* Encode the F1SetupComplete type as APER */
17167       memset(encBuf, 0, ENC_BUF_MAX_LEN);
17168       encBufSize = 0;
17169       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
17170       /* Encode results */
17171       if(encRetVal.encoded == ENCODE_FAIL)
17172       {
17173          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
17174                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
17175          break;
17176       }
17177       else
17178       {
17179          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
17180 #ifdef DEBUG_ASN_PRINT
17181          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
17182          {
17183             printf("%x",encBuf[ieIdx]);
17184          }
17185 #endif
17186       }
17187
17188       /* Sending msg */
17189       if(sendF1APMsg() != ROK)
17190       {
17191          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
17192          break;
17193       }
17194       ret = ROK;
17195       break;
17196    }while(true);
17197
17198    if((ret == ROK) && (duCb.actvCellLst[cellId-1]) && (duCb.actvCellLst[cellId-1]->cellStatus == DELETION_IN_PROGRESS)
17199          && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
17200    {
17201       ret = duSendCellDeletReq(cellId);
17202       if(ret != ROK)
17203       {
17204          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
17205                Delete req for CellId");
17206       }
17207    }
17208    FreeUeContextReleaseComplete(f1apMsg);
17209    return ret;
17210
17211 }
17212
17213 /*******************************************************************
17214 *
17215 * @brief added free part for the memory allocated by aper_decoder
17216 *
17217 * @details
17218 *
17219 *    Function : freeAperDecodeUeContextReleaseCommand
17220 *
17221 *    Functionality: added free part for the memory allocated by aper_decoder
17222 *
17223 * @params[in] F1AP_PDU_t *f1apMsg
17224 * @return void
17225 *
17226 * ****************************************************************/
17227 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
17228 {
17229    uint8_t ieIdx=0;
17230    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
17231
17232    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
17233
17234    if(ueContextReleaseCommand->protocolIEs.list.array)
17235    {
17236       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
17237       {
17238          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
17239          {
17240             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
17241             {
17242                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
17243                   break;
17244                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
17245                   break;
17246                case ProtocolIE_ID_id_Cause:
17247                   break;
17248                case ProtocolIE_ID_id_RRCContainer:
17249                {
17250                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
17251                   {
17252                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
17253                   }
17254                   break;
17255                }
17256                default :
17257                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
17258                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
17259                   break;
17260             }
17261          }
17262          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
17263       }
17264       free(ueContextReleaseCommand->protocolIEs.list.array);
17265    }
17266 }
17267 /*******************************************************************
17268 *
17269 * @brief processing of UE Context Release Command
17270 *
17271 * @details
17272 *
17273 *    Function : procF1UeContextReleaseCommand
17274 *
17275 *    Functionality: processing of UE Context Release Command
17276 *
17277 * @params[in] F1AP_PDU_t *f1apMsg
17278 * @return void
17279 *
17280 * ****************************************************************/
17281 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
17282 {
17283    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
17284    uint16_t cellIdx =0, cellId = 0;
17285    bool ueIdxFound = false;
17286    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
17287    DuUeCb   *duUeCb = NULLP;
17288    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
17289
17290    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
17291
17292    if(ueContextReleaseCommand->protocolIEs.list.array)
17293    {
17294       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
17295       {
17296          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
17297          {
17298             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
17299             {
17300                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
17301                   {
17302                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
17303                                     value.choice.GNB_CU_UE_F1AP_ID;
17304                      break;
17305                   }
17306
17307                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
17308                   {
17309                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
17310                                      value.choice.GNB_DU_UE_F1AP_ID;
17311                      break;
17312                   }
17313
17314                case ProtocolIE_ID_id_Cause:
17315                   {
17316                      for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
17317                      {
17318                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
17319                         {
17320                            if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
17321                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
17322                            {
17323                               cellId = duCb.actvCellLst[cellIdx]->cellId;
17324                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
17325                               ueIdxFound = true;
17326                               break;
17327                            }
17328                         }
17329                         if(ueIdxFound == true)
17330                         {
17331                            break;
17332                         }
17333                      }
17334
17335                      if(!ueIdxFound)
17336                      {
17337                         DU_LOG("\nERROR  -->  F1AP: procF1UeContextReleaseCommand(): Ue Information is not available");
17338                         ret = RFAILED;
17339                      }
17340                      break;
17341                   }
17342
17343                case ProtocolIE_ID_id_RRCContainer:
17344                   {
17345                      if(ueIdxFound == true)
17346                      {
17347                         DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
17348                         if(duUeCb->f1UeDb)
17349                         {
17350                            memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
17351                            duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
17352                            duUeCb->f1UeDb->cellIdx = cellIdx;
17353                            /* Filling Dl RRC Msg Info */
17354                            DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
17355                            if(!duUeCb->f1UeDb->dlRrcMsg)
17356                            {
17357                               DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
17358                                     Memory allocation failed ");
17359                               ret = RFAILED;
17360                            }
17361                            else
17362                            {
17363                               duUeCb->f1UeDb->dlRrcMsgPres = true;
17364                               memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
17365                               ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
17366                                     &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
17367                                     value.choice.RRCContainer);
17368                            }
17369
17370                         }
17371                         else
17372                         {
17373                            DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
17374                                  Memory allocation failed ");
17375                            ret = RFAILED;
17376
17377                         }
17378                      }
17379                      break;
17380                   }
17381                default :
17382                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
17383                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
17384                   break;
17385             }
17386          }
17387       }
17388    }
17389    if(ret != RFAILED)
17390    {
17391       duProcUeContextReleaseCommand(cellId, duUeCb);
17392    }
17393    freeAperDecodeUeContextReleaseCommand(f1apMsg);
17394    return ret;
17395 }
17396
17397 /**************************************************************
17398  *
17399  * @brief free the memory allocated by aper decoder for paging
17400  *
17401  * @details
17402  *
17403  *    Function : freeAperDecodePagingMsg
17404  *
17405  *    Functionality:
17406  *         - free the memory allocated by aper decoder for
17407  *         the paging f1ap msg
17408  *
17409  * @params[in] Paging_t   *paging
17410  * @return ROK     - success
17411  *         RFAILED - failure
17412  *
17413  ****************************************************************/
17414 void freeAperDecodePagingMsg(Paging_t   *paging)
17415 {
17416    uint8_t ieIdx, cellIdx;
17417    PagingCell_ItemIEs_t *pagingCellItemIes;
17418    PagingCell_Item_t *pagingCellItem;
17419    PagingCell_list_t  *pagingCelllist;
17420
17421    if(paging)
17422    {
17423       if(paging->protocolIEs.list.array)
17424       {
17425          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17426          {
17427             if(paging->protocolIEs.list.array[ieIdx])
17428             {
17429                switch(paging->protocolIEs.list.array[ieIdx]->id)
17430                {
17431                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17432                      {
17433                         free(paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10.buf);
17434                         break;
17435                      }
17436                   case ProtocolIE_ID_id_PagingIdentity:
17437                      {
17438                         if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present == PagingIdentity_PR_cNUEPagingIdentity)
17439                         {
17440                            if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17441                            {
17442                               if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->present == \
17443                                     CNUEPagingIdentity_PR_fiveG_S_TMSI)
17444                               {
17445                                  free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity->choice.fiveG_S_TMSI.buf);
17446                               }
17447                               free(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity);
17448                            }
17449                         }
17450                         break;
17451                      }
17452                   case ProtocolIE_ID_id_PagingCell_List:
17453                      {
17454                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17455                         if(pagingCelllist->list.array)
17456                         {
17457                            for(cellIdx = 0; cellIdx < pagingCelllist->list.count; cellIdx++)
17458                            {
17459                               if(pagingCelllist->list.array[cellIdx])
17460                               {
17461                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellIdx];
17462                                  if(pagingCellItemIes->id == ProtocolIE_ID_id_PagingCell_Item)
17463                                  {
17464                                     pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17465                                     free(pagingCellItem->nRCGI.pLMN_Identity.buf);
17466                                     free(pagingCellItem->nRCGI.nRCellIdentity.buf);
17467                                  }
17468                                  free(pagingCelllist->list.array[cellIdx]);
17469                               }
17470                            }
17471                            free(pagingCelllist->list.array);
17472                         }
17473                         break;
17474                      }
17475                }
17476                free(paging->protocolIEs.list.array[ieIdx]);
17477             }
17478          }
17479          free(paging->protocolIEs.list.array);
17480
17481       }
17482    }
17483 }
17484
17485 /**************************************************************
17486  *
17487  * @brief processing the paging f1ap msg received from CU
17488  *
17489  * @details
17490  *
17491  *    Function : procPagingMsg
17492  *
17493  *    Functionality:
17494  *         - processing the paging f1ap msg received from CU
17495  *
17496  * @params[in] F1AP_PDU_t *f1apMsg
17497  * @return ROK     - success
17498  *         RFAILED - failure
17499  *
17500  *
17501  ****************************************************************/
17502 uint8_t procPagingMsg(F1AP_PDU_t *f1apMsg)
17503 {
17504    uint8_t ieIdx = 0, cellListIdx = 0;
17505    uint64_t cellId = 0;
17506    Paging_t   *paging = NULLP;
17507    PagingCell_list_t  *pagingCelllist = NULLP;
17508    PagingCell_ItemIEs_t *pagingCellItemIes = NULLP;
17509    PagingCell_Item_t *pagingCellItem = NULLP;
17510    DuPagingMsg *tmpPagingParam = NULLP;
17511
17512    paging = &f1apMsg->choice.initiatingMessage->value.choice.Paging;
17513    if(paging)
17514    {
17515       if(paging->protocolIEs.list.array)
17516       {
17517          DU_ALLOC(tmpPagingParam, sizeof(DuPagingMsg));
17518          if(tmpPagingParam == NULLP)
17519          {
17520             DU_LOG("\nERROR  --> DU APP : Memory Allocation Failure in procPagingMsg");
17521             freeAperDecodePagingMsg(paging);
17522             return RFAILED;
17523          }
17524          for(ieIdx=0 ; ieIdx<paging->protocolIEs.list.count; ieIdx++)
17525          {
17526             if(paging->protocolIEs.list.array[ieIdx])
17527             {
17528                switch(paging->protocolIEs.list.array[ieIdx]->id)
17529                {
17530                   case ProtocolIE_ID_id_UEIdentityIndexValue:
17531                      {
17532                         bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.UEIdentityIndexValue.choice.indexLength10,\
17533                                          &tmpPagingParam->pagUeId);
17534                         break;
17535                      }
17536
17537                   case ProtocolIE_ID_id_PagingIdentity:
17538                      {
17539                         switch(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.present)
17540                         {
17541                            case PagingIdentity_PR_cNUEPagingIdentity:
17542                               {
17543                                  if(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.cNUEPagingIdentity)
17544                                  {
17545                                     bitStringToInt(&paging->protocolIEs.list.array[ieIdx]->value.choice.PagingIdentity.choice.\
17546                                           cNUEPagingIdentity->choice.fiveG_S_TMSI, &tmpPagingParam->sTmsi);
17547
17548                                  }
17549                                  break;
17550                               }
17551                             case PagingIdentity_PR_rANUEPagingIdentity:
17552                                {
17553                                   /*TODO: This Identifier is specific to RAN Initiated Paging – Connected Mode Paging*/
17554                                   break;
17555                                }
17556                             default:
17557                                {
17558                                   DU_LOG("ERROR  -->  DU APP: Invalid UE Paging Identity, Skipping this Paging Message:");
17559                                   continue;
17560                                }
17561                         }
17562                      }
17563
17564                   case ProtocolIE_ID_id_PagingDRX:
17565                      {
17566                         tmpPagingParam->pagingDrxPres = TRUE;
17567                         tmpPagingParam->pagingDrx = convertPagingCycleEnumToValue(paging->protocolIEs.list.array[ieIdx]->value.choice.PagingDRX);
17568                         break;
17569                      }
17570
17571                   case ProtocolIE_ID_id_PagingPriority:
17572                      {
17573                         tmpPagingParam->pagPriority = paging->protocolIEs.list.array[ieIdx]->value.choice.PagingPriority;
17574                         break;
17575                      }
17576
17577                   case ProtocolIE_ID_id_PagingCell_List:
17578                      {
17579                         pagingCelllist = &paging->protocolIEs.list.array[ieIdx]->value.choice.PagingCell_list;
17580                         if(pagingCelllist->list.array)
17581                         {
17582                            for(cellListIdx = 0; cellListIdx < pagingCelllist->list.count; cellListIdx++)
17583                            {
17584                               if(pagingCelllist->list.array[cellListIdx])
17585                               {
17586                                  pagingCellItemIes = (PagingCell_ItemIEs_t *)pagingCelllist->list.array[cellListIdx];
17587                                  pagingCellItem = &pagingCellItemIes->value.choice.PagingCell_Item;
17588                                  bitStringToInt(&pagingCellItem->nRCGI.nRCellIdentity, &cellId);
17589                                  if(processPagingMsg(cellId, tmpPagingParam) != ROK)
17590                                  {
17591                                     DU_LOG("\nERROR  --> DU APP : Paging Processing Failed at CellId:%lu",cellId);
17592                                     continue;
17593                                  }
17594                               }
17595                            }
17596                         }
17597                         break;
17598                      }
17599                    default:
17600                      {
17601                          DU_LOG("\nERROR  --> F1AP : Incorrect Paging IE option");
17602                          break;
17603                      }
17604                }
17605             }
17606          }
17607       }
17608    }
17609    DU_FREE(tmpPagingParam, sizeof(DuPagingMsg));
17610    freeAperDecodePagingMsg(paging);
17611
17612    return ROK;
17613 }
17614
17615 /**************************************************************
17616  *
17617  * @brief Handles received F1AP message and sends back response
17618  *
17619  * @details
17620  *
17621  *    Function : F1APMsgHdlr
17622  *
17623  *    Functionality:
17624  *         - Decodes received F1AP control message
17625  *         - Prepares response message, encodes and sends to SCTP
17626  *
17627  * @params[in]
17628  * @return ROK     - success
17629  *         RFAILED - failure
17630  *
17631  * ****************************************************************/
17632 void F1APMsgHdlr(Buffer *mBuf)
17633 {
17634    int i =0;
17635    char *recvBuf =NULLP;
17636    MsgLen copyCnt =0;
17637    MsgLen recvBufLen =0;
17638    F1AP_PDU_t *f1apMsg =NULLP;
17639    asn_dec_rval_t rval; /* Decoder return value */
17640    F1AP_PDU_t f1apasnmsg ;
17641    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
17642    ODU_PRINT_MSG(mBuf, 0,0);
17643
17644    /* Copy mBuf into char array to decode it */
17645    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
17646    DU_ALLOC(recvBuf, (Size)recvBufLen);
17647
17648    if(recvBuf == NULLP)
17649    {
17650       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
17651       return;
17652    }
17653    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
17654    {
17655       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
17656       return;
17657    }
17658
17659 #ifdef DEBUG_ASN_PRINT
17660    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
17661    for(i=0; i< recvBufLen; i++)
17662    {
17663       printf("%x",recvBuf[i]);
17664    }
17665 #endif
17666
17667    /* Decoding flat buffer into F1AP messsage */
17668    f1apMsg = &f1apasnmsg;
17669    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
17670
17671    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
17672
17673    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
17674    {
17675       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
17676       return;
17677    }
17678    printf("\n");
17679    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
17680
17681    switch(f1apMsg->present)
17682    {
17683       case F1AP_PDU_PR_successfulOutcome:
17684          {
17685             switch(f1apMsg->choice.successfulOutcome->value.present)
17686             {
17687                case SuccessfulOutcome__value_PR_ResetAcknowledge:
17688                   {
17689                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
17690                      break;
17691                   }
17692                case SuccessfulOutcome__value_PR_F1SetupResponse:
17693                   {
17694 #ifndef ODU_TEST_STUB
17695                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
17696 #endif
17697                      break;
17698                   }
17699
17700                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
17701                   {
17702                      procF1GNBDUCfgUpdAck(f1apMsg);
17703                      break;
17704                   }
17705
17706                default:
17707                   {
17708                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
17709                            f1apMsg->choice.successfulOutcome->value.present);
17710                      return;
17711                   }
17712             }/* End of switch(successfulOutcome) */
17713             free(f1apMsg->choice.successfulOutcome);
17714             break;
17715          }
17716       case F1AP_PDU_PR_initiatingMessage:
17717          {
17718             switch(f1apMsg->choice.initiatingMessage->value.present)
17719             {
17720                case InitiatingMessage__value_PR_Reset:
17721                   {
17722                      procF1ResetReq(f1apMsg);
17723                      break;
17724                   }
17725                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
17726                   {
17727                      procF1DlRrcMsgTrans(f1apMsg);
17728                      break;
17729                   }
17730                case InitiatingMessage__value_PR_UEContextSetupRequest:
17731                   {
17732                      procF1UeContextSetupReq(f1apMsg);
17733                      break;
17734                   }
17735                case InitiatingMessage__value_PR_UEContextModificationRequest:
17736                   {
17737                      procF1UeContextModificationReq(f1apMsg);
17738                      break;
17739                   }
17740                case InitiatingMessage__value_PR_UEContextReleaseCommand:
17741                   {
17742                       procF1UeContextReleaseCommand(f1apMsg);
17743                       break;
17744                   }
17745                case InitiatingMessage__value_PR_Paging:
17746                   {
17747                      procPagingMsg(f1apMsg);
17748                      break;
17749                   }
17750                default:
17751                   {
17752                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
17753                            f1apMsg->choice.initiatingMessage->value.present);
17754                      return;
17755                   }
17756             }/* End of switch(initiatingMessage) */
17757             free(f1apMsg->choice.initiatingMessage);
17758             break;
17759          }
17760
17761       default:
17762          {
17763             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
17764             return;
17765          }
17766          free(f1apMsg);
17767
17768    }/* End of switch(f1apMsg->present) */
17769
17770    DU_FREE(recvBuf, (Size)recvBufLen);
17771 } /* End of F1APMsgHdlr */
17772
17773 /**********************************************************************
17774   End of file
17775  **********************************************************************/